Best way to move sprites around in the scene?

Question

What is the best way to move sprites around on the scene?
So far I came up with this code to move all the sprites from the right to the left
var anim = Timeline {
repeatCount: Timeline.INDEFINITE
keyFrames: KeyFrame {
time: 0.1s;
action : function(){
for(n in container.content){
def item = n as Sprite;
item.posX -= 2;
it moves the sprites for 2px every 0.1s, but it's not so smoth.
Is there a better way for doing it?

Answer 1

netsuvi wrote:
But this approach limits me in someway that i am unable to change yet. It means that I have to know
the end position on the sprite at the beginning? But how about user interaction? I would like to adjust the speed, during running.
Or how about collision detections?To use this technique, you have to know the end position, at least provisionally, at the start.
If something changes during the timeline (such as the user clicking) you can always stop the timeline
and recompute a new trajectory and start another timeline.
Collision detection is harder, especially among objects that are all moving.
I saw some people are just generation tics. Like 10 per seconds, Then then calculate the whole stuff in a function.
probably it would be enough to have 2 calculation tics per second and let the javaFX engine calculate the necessary frames in between.This is a reasonable approach, and it's fairly straightforward. However, even in some cases like BrickBreaker, you can compute
the endpoint or do collision detection (mostly) up front without having to compute frame-by-frame. For example, when the ball
is heading up, you can tell from its position and velocity whether it's going to hit a brick or a wall and when it will hit. When the
ball is heading down, you don't know whether the ball will hit the paddle, because the user can move it. However, the paddle
moves only horizontally along a certain Y-position, so you can compute the time and location at which the ball will reach that
Y-position. If the paddle is there, it bounces, otherwise the ball drops off the bottom and the turn ends.
If you want to compute collision detection among two or more moving objects, well, that's a lot harder. It probably requires doing
a bunch of math, and it might be possible to do in closed form. If not, successive approximation might be the easiest way to do
it.
So in pseudo code it would something like this:
Animation Start 0Seconds: Sprites have this position
Animation Start 0.5Seconds: Move sprite to this position // JavaFX makes the in between steps
do function() {
calculate speed,
calculate collision detection or whatever
then restart the Animation steps.I think the key is to decouple the position and collision computations from the actual graphics animation.
For example, suppose you have an object heading towards a wall that's 500 pixels away, and it's moving at 250
pixels/sec. (Assume constant velocity.) Then you know that the object will be at the wall in 2 seconds, so
you just set up a KeyFrame with that information, put it into a Timeline, and run it. You'll need to put an action
function in the KeyFrame as well. But note that this doesn't necessarily compute the next 0.5 seconds or the
next 2 seconds. Instead, it should look at the new state and compute the time at which the next event occurs
and then set up KeyFrames to run all the objects until that time.
I tried something with the timeline.playFromStart() but it didn't work. It just repeated the same animation instead of doing a new one.
You have any clue how to do that?The playFromStart() function will simply replay the same animation, as you noted. What you want to do is
recompute KeyFrames starting from the current state that show animation to some future state. Then,
load these KeyFrames into the Timeline (or create a new Timeline) and run it.