Your xstep and ystep values together constitute what is called a vector. The word vector has quite a few different but related meanings, but in this context you can think of it as Direction + Magnitude. If you imagine the vector as an arrow, the direction of course is the direction the arrow is pointing, and the magnitude is the arrow's length. If xstep=1 and ystep=1, the resulting vector is (1,1). It can be conceptualized as an arrow that is pointing up and to the right (assuming the origin, (0,0), to be in the lower left corner of the screen) at a 45 degree angle. The magnitude of the vector is approximately 1.414. (The magnitude, or length, of course is calculated by the Pythagorean theorem.) So if you add xstep and ystep to the ball's current position, the result is to move it up and right a distance of 1.414 units.

To get the ball to move in other directions, you merely change the values of xstep and ystep to point the arrow in different directions. xstep=-1, ystep=1 will move it up and to the left. xstep=0, ystep=1 will move it straight up. xstep=1, ystep=0 will move it straight right. And so forth.

Of course, you also need the ball to move at a consistent speed (denoted by the magnitude of the vector) regardless of what direction it is pointing. A vector of (1,1) is not the same length as the vector (0,1), so a ball moving along the vector (1,1) will move faster than along the vector (0,1). To fix this, you need to normalize the vector; ie, convert the vector to what is called a unit vector, or a vector whose magnitude is 1. This is simple enough to do, you simply divide xstep and ystep by the magnitude of the vector.

Once your vector is normalized to unit length, then you can scale it by the ball's speed (by multiplying xstep and ystep by speed) before using it to move the ball. One way of doing this is to encapsulate xstep, ystep and speed into some sort of ball structure, which is far preferable than having xstep and ystep live globally in your program. Then you can just call a method on the ball structure/class to move the ball. Something like this:


class Ball
{
public:
Ball(float x, float y, float vx, float vy, float speed) : x_(x), y_(y), speed_(speed)
{
setDirection(vx,vy);
}
~Ball(){}

void setPosition(float x, float y)
{
x_=x;
y_=y;
}

void setDirection(float vx, float vy)
{
vx_=vx;
vy_=vy;
float len=sqrt(vx*vx+vy*vy);
vx/=len;
vy/=len;
}

void move()
{
x_+=vx_*speed_;
y_+=vy_*speed_;

// Check to see if it hit the sides, and reflect the vector if so
if(x_<0 || x_>ScreenWidth) vx_*=-1.0f;
if(y_<0 || y_>ScreenHeight) vy_*=-1.0f
}

private:
float x_, y_, speed_, vx_, vy_;
};


This is just a quickie, of course, but it shows how the Ball class encapsulates everything it needs to move. Then in your timer function, instead of explicitly performing the movement and checks there, you can simply call Ball.move() to have the ball update itself.



void timer(int value)
{
ball.move();
glutPostRedisplay();
glutTimerFunc(20, timer, 1);
}



There is no reason any of the ball's internal logic should be in timer() itself; that should be safely encapsulated inside Ball, so that the timer function doesn't have to worry about it. The timer function should just be calling logic update methods, and letting the object logic handle itself. It's much cleaner and far more flexible this way.

x_, y_, vx_ and vy_ are class members. They're the actual ball position and velocity. That should be apparent by the fact that setPosition() sets x_ and y_, and setDirection() sets vx_ and vy_. (Appending a _ for class members is a convention of mine I picked up who knows where to allow me to quickly identify members while reading code.)