CODEWITHSUNDEEP
javaandroidanimationlibgdx
user2795329
user2795329

Reputation: 53

Animating translation between two fixed points (Libgdx)

I'm making a 2d game in libgdx and I would like to know what the standard way of moving (translating between two known points) on the screen is.

On a button press, I am trying to animate a diagonal movement of a sprite between two points. I know the x and y coordinates of start and finish point. However I can't figure out the maths that determines where the texture should be in between on each call to render. At the moment my algorithm is sort of like:

textureProperty = new TextureProperty();
firstPtX = textureProperty.currentLocationX
firstPtY = textureProperty.currentLocationY
nextPtX = textureProperty.getNextLocationX()
nextPtX = textureProperty.getNextLocationX()
diffX = nextPtX - firstPtX
diffY = nextPtY - firstPtY
deltaX = diffX/speedFactor // Arbitrary, controlls speed of the translation
deltaX = diffX/speedFactor
renderLocX = textureProperty.renderLocX()
renderLocY = textureProperty.renderLocY()
if(textureProperty.getFirstPoint() != textureProperty.getNextPoint()){
    animating = true
}
if (animating) {
    newLocationX = renderLocX + deltaX
    newLocationY = renderLocY + deltaY
    textureProperty.setRenderPoint(renderLocX, renderLocY)
}
if (textureProperty.getRenderPoint() == textureProperty.getNextPoint()){
   animating = false
   textureProperty.setFirstPoint(textureProperty.getNextPoint())
}
batch.draw(texture, textureProperty.renderLocX(), textureProperty.renderLocY())

However, I can foresee a few issues with this code. 1) Since pixels are integers, if I divide that number by something that doesn't go evenly, it will round. 2) as a result of number 1, it will miss the target.

Also when I do test the animation, the objects moving from point1, miss by a long shot, which suggests something may be wrong with my maths.

Here is what I mean graphically:

Desired outcome: Desired Outcome

Actual outcome:

Actual Outcome

Surely this is a standard problem. I welcome any suggestions.

Upvotes: 1

Views: 479

Answers (3)

DiLDoST
DiLDoST

Reputation: 372

I didn't saw any big errors, tho' i saw some like you are comparing two objects using == and !=, But i suggest u to use a.equals(b) and !a.equals(b) like that. And secondly i found that your renderLock coords are always being set same in textureProperty.setRenderPoint(renderLocX, renderLocY) you are assigning the same back. Maybe you were supposed to use newLocation coords.

BTW Thanks for your code, i was searching Something that i got by you <3

Upvotes: 0

MilanG
MilanG

Reputation: 7114

Let's say you have start coordinates X1,Y1 and end coordinates X2,Y2. And let's say you have some variable p which holds percantage of passed path. So if p == 0 that means you are at X1,Y1 and if p == 100 that means you are at X2, Y2 and if 0<p<100 you are somewhere in between. In that case you can calculate current coordinates depending on p like:

X = X1 + ((X2 - X1)*p)/100;
Y = Y1 + ((Y2 - Y1)*p)/100;

So, you are not basing current coords on previous one, but you always calculate depending on start and end point and percentage of passed path.

Upvotes: 1

Robert P
Robert P

Reputation: 9783

First of all you need a Vector2 direction, giving the direction between the 2 points.
This Vector should be normalized, so that it's length is 1:

Vector2 dir = new Vector2(x2-x1,y2-y1).nor();

Then in the render method you need to move the object, which means you need to change it's position. You have the speed (given in distance/seconds), a normalized Vector, giving the direction, and the time since the last update.
So the new position can be calculated like this:

position.x += speed * delta * dir.x;
position.y += speed * delta * dir.y;

Now you only need to limit the position to the target position, so that you don't go to far:

boolean stop = false;
if (position.x >= target.x) {
    position.x = target.x;
    stop = true;
}
if (position.y >= target.y) {
    position.y = target.y;
    stop = true;
}

Now to the pixel-problem:
Do not use pixels! Using pixels will make your game resolution dependent.
Use Libgdx Viewport and Camera instead. This alows you do calculate everything in you own world unit (for example meters) and Libgdx will convert it for you.

Upvotes: 0

Related Questions