Game Development Stack Exchange is a question and answer site for professional and independent game developers. It only takes a minute to sign up.
Sign up to join this community
In a 2D game, I simply want to draw the trajectory of an arrow in flight. With the code below, the trajectory (the parabola) looks right, but the angle (or rotation) or the arrow isn't.
float g = -9.8f;
float x = (launchVelocity * time);
float y = (launchVelocity * time) + (0.5f * g * (float)Math.Pow(time, 2));
float angle = (float)Math.Tanh(y / x);
What am I missing? Thanks.
Arctanh gives you the tangent for the hyperbolic curve! As far as I know your parabola isn't a hyperbola.
But we have good news: finding the tangent for your parabola is easier. The equation is
Where s is your launchVelocity. Now the slope of your arrow is:
You can safety use Arctan now if you like.
Some additional info about physics:
The approximate trajectory you are simulating applies to the center of mass of your arrow. When you say "position" (x,y) you are talking about the center of mass' position. The center of mass for an arrow is slightly forward from the midpoint and you should take that into account if you are going to draw the arrow.
Keep in mind that you are not considering the inertial momentum of the arrow (which can vary a lot if you are firing a giant ballista) and you are not considering the arrow's fluid dynamics: bow arrow flight won't follow a parabolic path!
You want the angle of the arrow at any point in time. You remembered that in order to compute an angle, there's a tangent. But here's where your thinking started to go wrong:
Ok, so if you neglect air friction, then the x-velocity of the arrow is a constant.
First, decompose velocity into x and y components. You could be shooting at an angle of 45 degrees or 60 degrees. So you need launchVelocity and an angle, it's not a scalar.
Second, compute everything as double, not float. You're not numerically sophisticated enough to know when roundoff error won't kill you, so don't try. It's not a great time saver in any case.
Third, don't use Math.pow, it's slow and not as accurate as multiplying for integer powers. Also you can save a lot of time by using Horner's form (see below)
final double DEG2RAD = Math.PI/180;
double ang = launchAngle * DEG2RAD;
double v0x = launchVelocity * cos(ang); // initial velocity in x
double v0y = launchVelocity * sin(ang); // initial velocity in y
double x = (v0x * time);
// double y = (v0y * time) + (0.5 * g * (float)Math.Pow(time, 2));
double y = (0.5 * g * time + v0y) * time
If you are desperate for performance, you can even precompute 0.5*g, but the above code will take you 90% of the way there without doing anything too crazy. Benchmark doing this 10 million times if you like, it's admittedly not a huge amount of time but percentage-wise it's pretty big -- libraries are very slow in Java
So, if you wanted the angle at which the arrow should go, what you want is
atan(dy/dx)
And in this case, that would work because dx is a constant. But in general, dx can be zero, so you usually want to use:
atan2(dy, dx)
which is a function specifically designed for this job.
But as I said, library functions in Java are hideously slow, and in this case there's a better way of doing it without as alluded to by @FxIII above.
If the horizontal velocity is always v0x, and the vertical velocity is:
double vy = v0y - 0.5 * g * time;
then your delta is: vx,vy
You don't need the angle. If you wanted to draw an arrow, use something nominally like:
plot( x, y, x+vx, y+vy);
I don't know what you're drawing, so if you do need the angle to rotate it (like you're using JOGL) then sure, use the angle.
Don't forget if you are using opengl to turn the angle back into degrees, because ATAN2 returns radians:
final double RAD2DEG = 180 / Math.PI;
double ang = Math.atan2(vy,vx); // don't forget, vy first!!!
double deg = ang * RAD2DEG;
Tanh() (hyperbolic tangent) takes an angle as a parameter, but you've fed it the ratio of the sides.
What you really want is to use the hyperbolic arctangent, which takes the ratio of the sides as a parameter, and returns the angle. (Naming on this may be "atanh", "atanh2", "arctanh", or something else similar; seems to vary a lot between different maths libraries)
