从A平稳移动到B

Question

I have a android game where I have to from time to time move camera (visible screen part) from point A to point B.

Obviously I could do it like that:

camera.setCenter(B.getX(), B.getY();

But it does not looks good, it simply jump immediately, and what I want to achieve is smooth movement from A to B. I can access onUpdate method which is loop updating certain game objects (so I can execute certain things in certain milliseconds)

I really can not figure out how to create such algorithm, to allow smooth movement between two points (Classifying I have no clue how to calculate what values should I add to the

camera.setCenter(camera.getX() + xValue, camera.getY() + yValue)

Because those values have to be calculated depends on what is distance between those two points.

Answer 1

If your game updates at 60 frames per second, and you want a transition to take two seconds, then it should take 120 frames to get there.

Thus, the amount it should move in any given update is total/120 .

You can abstract this into a method that queues a movement, calculates the FPS and the amount to move each update, and calls .setCenter on its current position plus the update amount. This is typically called interpolation . To determine how far you need to move, its no more than the absolute value of current - destination (it doesn't matter which is in front of the other, so we just take the absolute value to ignore the sign. To be technical, distance is a scalar whereas position is a vector ).

So, to sum up in semi-code (I don't know the actual contracts for these functions):

//given these variables already have value
double fps, currentX, destinationX, currentY, destinationY, animationLength; //animation length in seconds
...
double xValue = Math.abs(currentX - destinationX);
double yValue = Math.abs(currentY - destinationY);
...
//on each update:
double amountToMoveX = xValue / (animationLength * fps);
double amountToMoveY = yValue / (animationLength * fps);
camera.setCenter(camera.getX() + amountToMoveX, camera.getY() + amountToMoveY)

Then you simply need to keep track of when to stop, and you should be good to go.

Whether or not you're using an engine that already has a means of doing this, I don't know. But in terms of a pure algorithm, this seems the way to go.

Answer 2

See the discussion from this question

From the answer:

length=square_root((bx - ax)^2+(by - ay)^2)

velocityX = (bx - ax) / length * speed

velocityY = (by - ay) / length * speed

Where xValue is velocityX and similarly for Y