Mathematical Vectors and Rotations (Topdown java game dev - physics problem)

Question

I've been working on a top down car game for quite a while now, and it seems it always comes back to being able to do one thing properly. In my instance it's getting my car physics properly done.

I'm having a problem with my current rotation not being handled properly. I know the problem lies in the fact that my magnitude is 0 while multiplying it by Math.cos/sin direction, but I simply have no idea how to fix it.

This is the current underlying code.

private void move(int deltaTime) {

double secondsElapsed = (deltaTime / 1000.0);// seconds since last update
double speed = velocity.magnitude();
double magnitude = 0;

if (up)
    magnitude = 100.0;
if (down)
    magnitude = -100.0;
if (right)
    direction += rotationSpeed * (speed/topspeed);// * secondsElapsed;
if (left)
    direction -= rotationSpeed * (speed/topspeed);// * secondsElapsed;

double dir = Math.toRadians(direction - 90);
acceleration = new Vector2D(magnitude * Math.cos(dir), magnitude * Math.sin(dir));

Vector2D deltaA = acceleration.scale(secondsElapsed); 
velocity = velocity.add(deltaA); 

if (speed < 1.5 && speed != 0)
    velocity.setLength(0);

Vector2D deltaP = velocity.scale(secondsElapsed); 
position = position.add(deltaP);

...
}

My vector class emulates vector basics - including addition subtraction, multiplying by scalars... etc.

To re-iterate the underlying problem - that is magnitude * Math.cos(dir) = 0 when magnitude is 0, thus when a player only presses right or left arrow keys with no 'acceleration' direction doesn't change.

If anyone needs more information you can find it at

http://www.java-gaming.org/index.php/topic,23930.0.html

Answer 1

Yes, those physics calculations are all mixed up. The fundamental problem is that, as you've realized, multiplying the acceleration by the direction is wrong. This is because your "direction" is not just the direction the car is accelerating; it's the direction the car is moving.

The easiest way to straighten this out is to start by considering acceleration and steering separately. First, acceleration: For this, you've just got a speed, and you've got "up" and "down" keys. For that, the code looks like this (including your threshold code to reduce near-zero speeds to zero):

if (up)
    acceleration = 100.0;
if (down)
    acceleration = -100.0;

speed += acceleration * secondsElapsed;

if (abs(speed) < 1.5) speed = 0;

Separately, you have steering, which changes the direction of the car's motion -- that is, it changes the unit vector you multiply the speed by to get the velocity. I've also taken the liberty of modifying your variable names a little bit to look more like the acceleration part of the code, and clarify what they mean.

if (right)
    rotationRate = maxRotationSpeed * (speed/topspeed);
if (left)
    rotationRate = maxRotationSpeed * (speed/topspeed);

direction += rotationRate * secondsElapsed;

double dir = Math.toRadians(direction - 90);
velocity = new Vector2D(speed * Math.cos(dir), speed * Math.sin(dir));

You can simply combine these two pieces, using the speed from the first part in the velocity computation from the second part, to get a complete simple acceleration-and-steering simulation.

Answer 2

Since you asked about acceleration as a vector, here is an alternate solution which would compute things that way.

First, given the velocity (a Vector2D value), let's suppose you can compute a direction from it. I don't know your syntax, so here's a sketch of what that might be:

double forwardDirection = Math.toDegrees(velocity.direction()) + 90;

This is the direction the car is pointing. (Cars are always pointing in the direction of their velocity.)

Then, we get the components of the acceleration. First, the front-and-back part of the acceleration, which is pretty simple:

double forwardAcceleration = 0;
if (up)
    forwardAcceleration = 100;
if (down)
    forwardAcceleration = -100;

The acceleration due to steering is a little more complicated. If you're going around in a circle, the magnitude of the acceleration towards the center of that circle is equal to the speed squared divided by the circle's radius. And, if you're steering left, the acceleration is to the left; if you're steering right, it's to the right. So:

double speed = velocity.magnitude();
double leftAcceleration = 0;
if (right)
    leftAcceleration = ((speed * speed) / turningRadius);
if (left)
    leftAcceleration = -((speed * speed) / turningRadius);

Now, you have a forwardAcceleration value that contains the acceleration in the forward direction (negative for backward), and a leftAcceleration value that contains the acceleration in the leftward direction (negative for rightward). Let's convert that into an acceleration vector.

First, some additional direction variables, which we use to make unit vectors (primarily to make the code easy to explain):

double leftDirection = forwardDirection + 90;

double fDir = Math.toRadians(forwardDirection - 90);
double ldir = Math.toRadians(leftDirection - 90);

Vector2D forwardUnitVector = new Vector2D(Math.cos(fDir), Math.sin(fDir));
Vector2D leftUnitVector = new Vector2D(Math.cos(lDir), Math.sin(lDir));

Then, you can create the acceleration vector by assembling the forward and leftward pieces, like so:

Vector2D acceleration = forwardUnitVector.scale(forwardAcceleration);
acceleration = acceleration.add(leftUnitVector.scale(leftAcceleration));

Okay, so that's your acceleration. You convert that to a change in velocity like so (note that the correct term for this is deltaV, not deltaA):

Vector2D deltaV = acceleration.scale(secondsElapsed);
velocity = velocity.add(deltaV).

Finally, you probably want to know what direction the car is headed (for purposes of drawing it on screen), so you compute that from the new velocity:

double forwardDirection = Math.toDegrees(velocity.direction()) + 90;

And there you have it -- the physics computation done with acceleration as a vector, rather than using a one-dimensional speed that rotates with the car.

(This version is closer to what you were initially trying to do, so let me analyze a bit of where you went wrong. The part of the acceleration that comes from up/down is always in a direction that is pointed the way the car is pointed; it does not turn with the steering until the car turns. Meanwhile, the part of the acceleration that comes from steering is always purely to the left or right, and its magnitude has nothing to do with the front/back acceleration -- and, in particular, its magnitude can be nonzero even when the front/back acceleration is zero. To get the total acceleration vector, you need to compute these two parts separately and add them together as vectors.)

Neither of these computations are completely precise. In this one, you compute the "forward" and "left" directions from where the car started, but the car is rotating and so those directions change over the timestep. Thus, the deltaV = acceleration * time equation is only an estimate and will produce a slightly wrong answer. The other solution has similar inaccuracies -- but one of the reasons that the other solution is better is that, in this one, the small errors mean that the speed will increase if you steer the car left and right, even if you don't touch the "up" key -- whereas, in the other one, that sort of cross-error doesn't happen because we keep the speed and steering separate.