First, you want to multiply your sin and cos by the distance in units you want the ship to move.

As for gravity, I'll use and Earth-like object for an example which has a gravitational pull of 9.8m/s. This means that all nearby objects will move towards the Earth-like object with an acceleration of 9.8 meters per sec. If your game is updating at 24 frames per second, your ship should accelerate 9.8 / 24 (approx .4083) meters each frame. When updating the movement of the ship, you'd have to move based on the ships trajectory AND the gravitational pull.

To find the angle from your ship to the Earth-like object you'll first need the tangent of the angle. This is the distance between the Y components divided by the distance between the X components ((planet_y - ship_y) / (planet_x - ship_x)). You can then use an arc tangent (atan() function) to find the angle from the tangent. Remember that the angle returned is in radians, not degrees. In case you need to, you can convert radians to degrees by multiplying the radians by (180 / PI).

Hope this helps.

Quote:Original post by Aressera
but my real question is, why do you need any help with this if your program uses newtonian physics?

It's an arcade game; it doesn't have to be perfect, or even realistic.

So here's what we have: a ship whose position is always 0,0, some number of asteroids of possibly varying sizes, and an orientation of the ship that's expressed solely as an angle. The speed is expressed as an X and Y pair (good for you).

Now, I'm assuming you update your world on a per-frame basis, and that's fine for this situation.

coderx75 is right about one thing; since your speed will be changing, just using sine and cosine is insufficient. You'll need to multiply both of those by some variable v representing the speed. Right now, your speed is always 1. With other forces affecting your ship, that's no longer going to be true.

As Aressera noted, the gravitational force is:
F = G * m1 * m2 / (r*r)
where G is the gravitational constant 6.67e-11, m1 is the mass of the ship, m2 is the mass of the asteroid, and r is the distance between them.

Got that? Now forget it.

See, what we do is use the force to get the change in velocity, using F=m*a (force equals mass times acceleration). Ergo a = F/m. Since the F is the aforementioned gravity, and m is the mass of the object being moved (the ship, so m = m1), we can write:

a = G * m2 / (r*r)

So first, this is your game, not Newton's. We're going to do a couple things here:

First, we don't have to use G. Use whatever makes the game look nice. Instead of "G" we're going to use g, some arbitrary constant of your own design. It can be equal to G, pi, 6½ or whatever works. If gravity is too strong, make it smaller. If it's too weak, make it bigger.

Next, I'm assuming that you want bigger asteroids to have a bigger pull. Instead of using m2 for each one, we're going to store the relative effect of each asteroid - so that a normal sized asteroid has a value of 1, and a smaller one might have a value of 2 and so forth. We'll call this c. So m2 for any asteroid can be expressed as:
m2 = b * c
where b is another arbitrary constant. Now we have:
a = g * b * c / (r*r)
But since g and b are both arbitrary, let's lump them together into one final constant k.
a = k * c / (r*r)

So now that we have all of this, what do we do with it?

Starting out, we have this:

// v starts off as 1.0x_speed += v * cos(direction);y_speed += v * sin(direction);

Now what we have to do is go through and work out the gravitational effect of each asteroid:

for (int i=0; i<MAX_ASTEROIDS; i++) {  // Find out how far away it is  // (This is easy since the ship's position is always 0,0  float r2 = asteroid_x*asteroid_x + asteroid_y*asteroid_y;  // Ok, so this is the square of the distance; no sense in wasting it.  // Let's get the acceleration:  float a = k * asteroid_c / r2;  // Now let's get the real distance:  float r = sqrtf(r2);  // Now let's apply the acceleration  x_speed += -a * asteroid_x / r;  y_speed += -a * asteroid_y / r;  // We're done!}

HTH

Quote:Original post by smitty1276
In my opinion, calculating realistic gravity for a video game like this is overkill. The actual force due to gravity would probably be negligible within the context of a space shooter or something asteroids-like... unless you intend to have incredibly dense asteroids that are much more massive than actual asteroids of their size. Nothing that fits on the screen is going to exert enough force to alter your ship's behavior--again, under normal circumstances.

Nor is it realistic to have a very dense asteroid field where the asteroids fling in random directions and only take one laser shot to destroy. It's fun though, and that's the point. :D

(Astronauts on the Apollo reported that objects moving away from the left side of the ship suddenly reappeared on the right side on the ship, forcing them to rethink the way they do evasive maneuvers. This has become less of a problem since the RAM in the onboard computers has increased. :P)