Implementing vector based movement in a 2d environment

Question

Good evening.

I apologize if the title is a bit vague, I really could not come up with anything better. I am currently reading a book called the nature of code and as a side project, I am working on a small 2d game in javascript.

One of the core concepts of this book states that a game object should incorporate three vectors, acceleration, velocity and location, where only acceleration is directly modified by the player. This translates to the following code;

    acceleration.add(0, 0.001);
    velocity.add(acceleration);
    location.add(velocity);

This works perfectly fine and so does the the .sub() method, when I want to move backwards. However, this requires two functions. Also, all vectors have to be positive. This is quite a pain because I now have to decide whether the applied vector is a positive or a negative one, thus requiring methods like applyForceNeg(vec) and applyForcePos(vec). I'd much rather have one method where I could pass any vector.

I have pasted some of the code here.

How would I implement this without turning the code into a complete mess?

Any help would be much appreciated.

EDIT:

I figured out what actually caused all this;

As you can see here, I initially wrote the if statement so that upon every run, acceleration gets incremented by 0.001. Then acceleration gets added to velocity, which in turn gets added to location. The problem was that I did not set acceleration back to zero. So in the first run, acceleration is set to 0.001, so is velocity and location. However, in the second run, acceleration increases by 0.001, yielding a total value of 0.002 which in turn gets added to velocity and location. Therefore we now have acceleration = 0.002, velocity = 0.003 and location = 0.003. After the third run, velocity and location are at 0.006 while acceleration is at 0.003.

Now, when I set acceleration to zero, it reduces the problem. Only if I also reset velocity, the problem is gone. However, I doubt this is the right way to do it...

Answer 1

First, you shouldn't be hard-coding numbers like your acceleration. Numbers like these, which need to be fine tuned, should be variables that can be easily tweaked, either in one-place or dynamically using a slider or somesuch during testing.

Second, from what I understand (of your comment to MagiSun), your problem with the acceleration giving you odd behavior is that your acceleration value is far too small.

Even at 60 updates per second, you're accelerating at 0.06/s, and unless your velocities and positions are also in similarly small measurements (which I assume they aren't by your description of the resultant behavior), this will result in a very slow deceleration.

If you're keeping the "Down" key pressed the entire time, by the time you reverse course (and travel in negative velocity), your negative acceleration will be very noticeable, giving you the "uncontrollable speeds".

Try raising your acceleration value, but take note that you might also want to increment acceleration at a slower rate than your updates-per-second/fps. Another concern is that you might want a maximum acceleration, even if it might be unrealistic, simply for the sake of a good "feel".

Answer 2

In regards to this comment by OP:

The problem is the resulting behavior, where the object continues to move up for example, even if the down key is pressed. It eventually changes direction but by then it's at nearly uncontrollable speeds.

That is how velocity and acceleration work. You are simply providing the user with acceleration increments that are too large. Try reducing your acceleration increments to 1/4 of their present value, and report the results.

Because distance travelled varies as the square of applied acceleration, rather subtle changes in acceleration can affect the agent more than might be intuitively expected. Also check my answer to this post on simple equations of motion with constant acceleration.

Update:
Your turns should look like this, where the player can only set a = .001, or 0.000 or -0.001:

    a    v    l
 0.001 .001 .001
 0.001 .002 .003
 0.001 .003 .006
 0.001 .004 .010
 0.001 .005 .015 now motor turned off, so a = 0.000
 0.000 .005 .020
 0.000 .005 .025 now retro-rockets fired (ie braking applied)
-0.001 .004 .029
-0.001 .003 .032
-0.001 .002 .034
-0.001 .001 .035
-0.001 .000 .036 now motor turned off again 
 0.000 .000 .036 etc.

When you increase the acceleration by .001 each time, you are in fact using constant jerk, as I suspected earlier.

Answer 3

So, the .add method doesn't take negative numbers?

If it does, it's just a matter of adding a negative acceleration to velocity. Otherwise, you really have no choice but to check.

EDIT: I think I understand your problem now. Vectors can't be negative correct? If so, you'd probably be better off having acceleration be two scalars. This way, I assume they can be negative and you can just add each component.

Answer 4

Have you thought about adding negative velocity and using a ternary statement to decide what to add?

if(keys.up != keys.down) {
  acceleration.add(0, keys.up ? 0.001 : -0.001);
  velocity.add(acceleration);
  location.add(velocity);
}

EDIT: What platform are you using? I've never seen a vector class that couldn't go negative.

Answer 5

I see several things wrong with your code. However, before trying to list them here, let me just show how I would rewrite your main loop:

// reset acceleration to default value
acceleration.set(0, 0);  // or, equivalently, acceleration.mult(0);

// adjust acceleration based on keys pressed
if (keys.up) {
    acceleration.add(0, 0.001);
}
if (keys.down) {
    acceleration.sub(0, 0.001);
}

// move ship according to Newton's laws
velocity.add(acceleration);
location.add(velocity);

ship.move(location.getX(), location.getY());

The main differences between this and your code are that:

1. The acceleration is not retained between update steps, but is reset to its default value (which I've assumed to be zero, but you could e.g. include gravity in that value) on every iteration. This default value is then modified based on the player's controls.

2. The velocity and location of the ship are updated on every iteration, not just when the player presses a key: in the absence of player interaction, the ship should continue on its inertial trajectory. Of course, since the default acceleration is zero, the velocity only changes if the player presses some keys (and thus the inertial trajectory is a straight line), but that would change if you included gravity.

Note that I've assumed that you want the ship to accelerate upwards when the up key is pressed and downwards if the down key is pressed, regardless of its orientation. Depending on what kind of game you're making, you may instead want to add or subtract the ship's heading vector (normalized and scaled by a constant) instead of the fixed vector (0, 0.001) to the acceleration.

---

Also, there are a couple of improvements you could make to you physics simulation (i.e. the lines velocity.add(acceleration); and location.add(velocity);). One is to account for the fact that the velocity has changed during the timestep in your location update, by taking the average of the old and new velocity:

// move ship according to Newton's laws...
velocity.add(acceleration);
location.add(velocity);
// ...including the correction for the gradual change in velocity
acceleration.mult(0.5);
location.sub(acceleration);

This makes the trajectories physically exact (under constant acceleration), and, in particular, ensures that, with appropriate scaling, they won't be affected by changes in the simulation time step. However, to really make use of this feature, you need to actually involve the timestep in the calculations. This would be easiest to do if your vector class included a multiply-and-add method:

// move ship according to Newton's laws...
velocity.muladd(acceleration, timestep);  // velocity += acceleration * timestep
location.muladd(velocity, timestep);      // location += velocity * timestep
// ...including the correction for the gradual change in velocity
location.muladd(acceleration, -timestep*timestep/2);

If not, you'll just have to do it by hand, e.g. like this:

// velocity += acceleration * timestep
acceleration.mult(timestep);
velocity.add(acceleration);

// location += (velocity - 0.5 * acceleration * timestep) * timestep
var displacement = velocity.clone();
acceleration.mult(0.5);
displacement.sub(acceleration);
displacement.mult(timestep);
location.add(displacement);

Note that this will mess up the acceleration vector (by multiplying it with 0.5 * timestep²), so you shouldn't use it for anything after this.