How do I calculate how an object will move from one point to another?

Question

Here's the problem: A player starts the game in the 0 coordinate (x=0,y=0). When the user clicks on the screen, it returns the coordinates of the destination. Now the player has to move from its current position A(0.0) to B(x,y). Take into account that B is in the first Quadrant so x>0 and y>0.

How will the player move? I know that I will have to use this: atan2(positionY-destinationY, positionX-destinationX) to get the angle.

Now what? How will the player move with a fixed velocity (which by the way will be a variable, so a player may move faster while using some "items")?

Whose answer is better? What is more accurate? Trigonometry or Linear Algebra?

Answer 1

Basic trigonometry example

cosine for x axis

sine for y axis

speed is whatever you would like the movement each time to increment by... Obviously the higher the number the more pixels it will move at any given time so the quicker it will be.

dx = (double) (Math.cos(angle) * speed);
dy = (double) (Math.sin(angle) * speed);            

A.x += dx;
A.y += dy;

Linear algebra example

Check Sidar's answer :).. Explains it way better than I could.

This is in java... You can easily convert it to C++ though.

Answer 2

To add to Savlons answer:

There are two ways of doing this

Vector2D objects(Assuming your positions are vectors):

Vector2D diffVec(B.posVec-A.posVec);
diffVec.normlize(); //Assuming it's applied on the vector itself
// and does not return a new one.   
//This vector is now a unit vector which represents the heading/Direction   
//without the "speed" (Well its speed is 1, more precisely its MAGNITUDE is 1).

diffVec.multiply(speed);

camera.velocity = diffVec;

The normalize function would probably look something like this:

void Vector2D::normalize(){
     float len = length();
     this.x /= len;
     this.y /= len;    
};

 float Vector2D::length(){
    return sqrt(x*x+y*y);
 };

Now if you're not using vectors this could be translated to:

float dx = destinationX-positionX;
float dy = destinationY-positionY;

Let's pretend dx and dy are the components of an imaginary vector. ( And by components I mean the x and y properties ).

We can perform the same calculations as we have in our Vector2D class: First we need to "normalize" our imaginary vector by dividing it by its length. Pythagoras theorem, remember that one?

float length = sqrtf(dx*dx+dy*dy);

Now we use this to normalize our imaginary vector:

dx/=length;
dy/=length;

Now if we were to apply the Pythagoras theorem on our new dx and dy value you will notice that the length is 1. Meaning that we have a direction, and a magnitude of 1. To change it to our speed simply multiply each component by it.

dx *= speed;
dy *= speed;

cam.velocityX = dx;
cam.velocityY = dy;

Imagine a vector to be an arrow with a specific length. When you normalize it you bring the length to one.

So if you multiply it ( by a scalar ), the speed in this case, the x and y components adjust accordingly that the length of the vector is the speed it's multiplied with.

Answer 3

Forget atan2. You don't need angles. Think in terms of linear algebra approaches.

You have a source and a destination. Subtract source from destination to get a vector representing the change. Normalize this. You now have a unit vector pointing from source to destination. Multiply by speed. You now have the offset to apply each update. It's that easy.