LAB FOUR SOLUTION

In this lab you will be performing a simulation of a physical system, shooting a projectile from a cannon and working out where it will land. Although this is not a very complicated physical system, it does introduce the fundamental principles of computer simulation, which is a very important field. As the last step, you will turn the simulation into a little interactive game about blowing things up.




1. The Calculation.




If a projectile is fired or thrown upwards at a known velocity, its entire trajectory can be accurately computed. You probably remember the physics formula




h = v t ‐ ½ g t 2




(h is the projectile’s height at any given time, v is the initial upwards velocity, t is the time elapsed since it was fired or thrown, and g is the “acceleration due to gravity”, an approximate constant anywhere on the surface of the earth). If you measure h in feet, t in seconds, and v in feet per second, g is about 32.174.




Obviously this is going to be a very important formula for this program. One of the most important aspects of good programming is to make separate functions for all the important things.




So make a good start: write a clear and simple function that takes values for v and t as parameters, and calculates and returns the corresponding value of h. Think about what types the parameters and other constants should have for an accurate calculation.




Test your function thoroughly. It may be difficult to think of good values for testing. If you remember calculus you can work things out exactly, but velocities between 100 and 200 feet per second should keep the cannon ball in the air for a few seconds.




The exact formula for how long the ball stays in the air, when there is no atmosphere to slow it down is (2 v / g) seconds.







2. Tabulation.




It would be a lot easier to do the testing (and the results would be a lot more useful) if your program could automatically print the height at a number of different times. For instance, if you have a total flight time of 12 seconds, you might want to see what the height is at each of 0, 1, 2, 3, ..., 11, and 12 seconds.




after 0 seconds, height is 0 feet after 1 seconds, height is 184 feet after 2 seconds, height is 336 feet after 3 seconds, height is 456 feet




etc.

Think of the various examples you have seen of programs controlling repetition, and you will probably find this part easy.




Don’t modify the function you wrote for part 1 (unless there is something wrong with it). You have tested it and ensured that it is perfect. If you change it, all that testing was for nothing. Instead, write another function that makes use of the first one.







3. Interaction.




There are functions in the library called read_int(), read_double(), read_float(), read_string(), etc. When called, they wait until the user has typed something of the appropriate type, then return that value as their result. A program could rudely ask someone their age like this:




print("How old are you? ");




const int age = read_int();




print("That is old. in ten years you will be "); print(age+10);




(The system only notices input typed when the black “dos shell” window is active.)




Make your program ask the user to enter the initial velocity for the cannon ball. It should then calculate the total flight time and, using your solution to part 2, print the height above ground at a reasonable number of times throughout the flight.










4. Visual Representation.




Now make your program plot those altitudes as vertical dots in a reasonably sized window, perhaps one dot for each second of flight. If you make the colour of the dots gradually change as time progresses, the results are much easier to interpret.




If you use reasonable velocities, you will be able to have a scale of one pixel per foot, which is quite convenient.




To control the colours in this way, you could make use of a handy library function: set_pen_color(R, G, B). The three parameters, R, G, and B are numeric values anywhere between 0.0 and 1.0. They specify the redness, greenness, and blueness of a colour.




set_pen_color(1.0, 0.0, 0.0) is pure red




set_pen_color(0.0, 0.0, 1.0) is pure blue

set_pen_color(0.7, 0.0, 0.3) is a blueish red

set_pen_color(0.3, 0.0, 0.7) is a reddish blue

set_pen_color(0.0, 0.0, 0.0) is black

set_pen_color(1.0, 1.0, 1.0) is white, and so on.

5. First Flight.




Even with the dots gradually changing colour as time increases, that vertical picture doesn’t give a very good representation of a trajectory. Using height as the vertical axis at one pixel per foot works out quite nicely. Letting time provide the horizontal axis also makes a lot of sense. You’ll need to scale the time axis somehow, as one pixel per second is useless. Even if the cannonball is fired upwards at the speed of sound, it only spends about 63 seconds in flight.




Make it happen.























































None of these steps should require big changes to your program, nor should they be making your program big or hard to follow.




If your program is getting out of hand, take a step back and think carefully about what every part of it is doing. If you have a lot of parts that seem very similar do what you can to clean things up. A little effort at clarity and structure in the beginning really pays off in the end.




6. A Nice Arc.




It seems absolutely trivial to convert the program to draw lines between the points. It is almost trivial, but there is one little problem that you’ll have to deal with. The problem will become obvious when you try it. Try it now.




Once you have got the points joined by lines, you notice that one point per second isn’t enough. See what you can do to produce a nice smooth accurate trajectory.




7. Take the Battle to the Enemy.




Sensible artillerymen do not fire their cannons straight up. The always set a cannon at an angle so that the cannonball will travel horizontally as well as vertically. If the cannon is set at angle (0 = vertical, 90 = horizontal), the position equations are slightly altered:




= v t cos( ) ‐ ½ g t 2 d = v t sin( )



Now, d represents the horizontal distance travelled. Remember that computers use radians instead of degrees; there are radians to 180 .




Modify your program so that it now takes two inputs from the user before plotting the path. The first is still the initial velocity, the second should be the angle that the cannon is set at. Be kind to your user: accept the input angle in degrees, and have the program make the conversion.




In part 6, the vertical axis really did represent vertical height, maybe even at a very reasonable scale of 1 pixel = 1 foot. But the horizontal axis indicated time, which gives an unrealistic view. After this step, the horizontal axis really will indicate the horizontal position of the cannonball, perhaps again at a scale of 1 pixel = 1 foot. Just like a window onto nature.




When the cannon-ball finally hits the ground, your program should print its final horizontal (x) position, and its total time in flight.




8. The Game.




Draw a simple representation of a cannon set at the right angle at one edge of the window, and a simple representation of the Enemy HQ at the other. If the cannonball hits the ground inside Enemy HQ, the user wins. Perhaps you could draw a little congratulatory explosion. Don’t get obsessed by graphical perfection. It is only a game.




Use your cannon drawing function from lab 3. Making flexible, re-usable software is very important in the professional world, so you might as well get used to it.




Put the cannon on a built-up platform so we’ve got the advantage of height, and Draw the enemy HQ as an ugly squat bunker with a flat roof and two slits for windows.



They are the enemy after all, their æsthetic sense is very poor. 







9. Make it Interesting.




Give the user a few chances to pick the right velocity and angle, three to five tries seems reasonable. Make the HQ appear at a random position each time a new game is started, so the user can’t just learn the right numbers. Perhaps even make it work in real time, so that a flight of five seconds really takes five seconds.







10. OPTIONAL, For Extra Credit.




This was a popular game on Macintosh computers in the mid-1980s. Sell your version of it to Nintendo and become a millionaire. My cut is only 15%.

That’s the END of the lab. The rest is just if you need a bit of help with the shape:




This is the cannon sitting on a wheel. The wheel’s radius is r.






























































































a is the aiming angle.




L1 is the distance from the back of the cannon to the wheel’s axle, L2 is the rest of the length.

Like all cannons it is wider at the back (w1) than the front (w2).












































































G is the point on the ground where the wheel rests. Its coordinates are (xg, yg).




C is the exact position of the axle, its coordinates are (xc, yc).

P is the easiest point to start drawing the body of the cannon from, coordinates (xp, yp).

E is the point where the ball pops out when it is fired, coordinates (xe, ye).













































This is a simplified picture of the body of the cannon shown with its “bounding box”. The point is to illustrate the difference between the real length of the cannon (len) and the sum L1+L2.




The angle shown as b is also helpful when drawing the shape. When the cannon is aimed at angle a, the heading for the bottom line is (a-b). Don’t forget that all angles are computed in radians.




xc = xg




yc = yg - r




b = asin((w1-w2)/2/(L1+L2))




xp = xc - L1 * sin(a-b)




yp = yc + L1 * cos(a-b)




len = (L1+L2) * cos(b)




Finally, to find the point E, we need two extra values:




d is the distance between points P and E

g is the angle from point P to point E if the cannon lies flat as in the third diagram.




d = sqrt(len*len + w1*w1/4)




g = asin(w1/2/d)




xe = xp + d * sin(a-g)




ye = yp - d * cos(a-g)