the trajectory cannonball shot from the ground in c - c

Question

I started to learn to code last year.Not very good though.
I tried to plot the trajectory of cannonball shot from the ground using c language. (I didn't code this alone anyway).
(# sorry I have to delete the original code for a while. If you would like to see my original code, please let me know. but I'm sure it'd be totally enough if you just see　the selected answer below.　)
and if I excute it, the result is like this.
the speed is?
6
the angle is
32
the spring is
0.4
X=0.000000, Y=0.000000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
X=0.000000, Y=-0.049000
I tried to figure out what I did wrong, but I have no idea at all.
Please help me!

Answer 1

The problem with this approach is that the Y-coordinate can become negative. And once it does, if the initial speed is not high enough, the ball can become stuck underneath the surface, as demonstrated by #RetiredNinja's results (the coordinate becomes stuck at -0.049 at some point which is not the correct behavior).
Erroneous results (not to scale) from original code, with modified parameters:
The ball seems to "tunnel" through the ground (some values dip below zero).
How to resolve this? We need to resolve the collision properly, making sure that the ball bounces instead of crossing the surface boundary. To do so, let's examine the behavior of the ball during a timestep in which a bounce occurs.
A collision occurs when both the vertical velocity and vertical position are negative. To find the collision time and velocity, use the equations of motion:
Once we have the collision velocity, we can simply update the new vertical speed to -spring * vc (spring should have a better name, e.g. coef_rest); an additional advantage is that we no longer need calls to pow.
This may occur several times during a timestep, so we need to perform this in a loop. One more thing to watch out for is that as the vertical velocity decays, the bounces become infinitely more frequent - so we need a "cut-off" velocity at which to stop the ball from bouncing.
Code:
#include <stdio.h>
#include <math.h>
#ifndef M_PI
#define M_PI 3.141592654
#endif
int main()
{
const double g = 9.81; // gravity
const double dt = 0.025; // time step
const double maxtime = 5.0; // max time
const double spring = 0.95; // coefficient of restitution
const double cutoff = 1e-4; // cut-off velocity
double speed = 6;
double angle = 32;
angle = angle * M_PI / 180.0;
double init_vx = speed * cos(angle);
double init_vy = speed * sin(angle);
int springnumber = 0;
printf("0.0,0.0\n");
for (double ts = 0.0, vs = init_vy, time = dt; time <= maxtime;)
{
// positions *after* this time step
double px = time * init_vx;
double elapse = time - ts;
double py = 0.0, vy = 0.0;
if (vs >= cutoff)
{
py = (vs - 0.5 * g * elapse) * elapse;
vy = vs - g * elapse;
}
// check for bounce
if (vy < 0.0 && py < 0.0)
{
// collision time
double tc = 2.0 * vs / g;
// update speed after bounce and time of collision
springnumber++;
vs *= spring;
ts += tc;
continue;
}
// print
printf("%f,%f\n", px, py);
// timestep
time += dt;
}
return 0;
}
Test results, with the same parameters as before:
The ball no longer "tunnels", which is the correct behavior.