Movement algorithm for game

Question

I'm currently developing a script for a map in COD4. I think that the language is so simple that I'm tagging this as language-agnostic since the problem is in the algorithm for this situation.

There is a room which is 960 units wide. And inside it there's an object in the middle, which we'll count as the axis. The ball is supposed to move to a random position each time it is hit, but should not traverse further than the walls. Here's a diagram:

The API of the game only allows the moving of objects relative to its position, as far as I know, so here's code that I came up with. The problem is that after the second call to head_move() it begins to produce unexpected results and this is crashing my head. Could somebody help me out?

movementThink():

while (1)
{
    self waittill ("trigger", player); //Wait till player hits the object       
    head_origin thread head_move();

}



head_move()
{
    /* level.prevx is a global variable which I use to store
    the distance traveled in the previous shot. Defaults to 0 */

    /*This works in the first and second hit, but then it begins to show
    incorrect max and min values*/

    x_min = (0-480) + level.prevx;
    x_max = x_min + 960;

    x_units =  RandomIntRange( x_min, x_max ); //Create a random integrer

    log2screen("MIN: " + x_min + " and MAX: " + x_max + " and MOVED " + x_units);
    log2screen("Moved " + x_units);

    //Movement function, first parameter is the distance to be traveled, and the second one is the speed
    self movex (x_units , level.movespeed); 

    level.prevx = x_units;

}

EDIT: Just to clarify. When the user shoots the ball, its position changes to a certain value. Now, if he hits it again, the min and max values of the random int generator should change to prevent the ball from moving outside the walls. Example:

1. Level starts. The ball is in the middle of the room. The min and max ranges are -480 and 480 respectively
2. The user hits the ball and its moved -200 units (200 units to the left).
3. Now, the min and max range should be -280 and 680.

I hope this is clear enough.

EDIT 2: Edited the sign as FlipScript suggested. Here's the output from the log2screen functions, what is actually happening:

1. MIN: -480 and MAX 480. MOVED 67
2. MIN: -413 and MAX 547. MOVED 236
3. MIN: -244 and MAX 716. MOVED 461

Just a sample case. Something is backwards I believe, these aren't the right calculations to do.

Answer 1

Your code works only when self.prevx contains your displacement from the starting position, i.e. your absolute position. However, what you are storing is your displacement from your current position. It works the first two times because that displacement happens to be the same as your absolute position, but once you move again, you lose all track of where you are.

What you should do instead is get rid of min and max, and start by calculating a random absolute position within the bounds. Then use your previously stored absolute position to calculate the relative movement needed to get you there, and store the new absolute position.

head_move()
{    
    new_x = RandomIntRange( -480, 480 ); //create a random location

    delta_x = new_x - level.prev;  //determine relative movement needed to get there

    self movex (delta_x , level.movespeed); //move to new position

    level.prevx = new_x;  //store new position
}