Blog

Bonjour!

Another week has passed, and brings us ever closer to the Kickstarter. We can’t reveal the exact date, but rest assured that it will be soon, and that if you read this blog, you will know a week in advance. This said, this week has been very productive. Many important features and assets have been started and/or finished. Here’s a list:

Speaking of which, ballistics are the subject of our blog this week. To do this I will now give my keyboard to Benoît, the newest member of our team.

Ballistics, or how to hit things by throwing stuff.

Hi everybody,

Today’s lesson is about projectile ballistics. That’s right, we’re going to talk about archers and catapults!

For those of you who haven’t done their high school physics classes, I’ll try to be as simple as possible in my explanations and to assume very little background knowledge. However, the goal of this blog is also to give guidelines to other casual game programmers (or professional I suppose), so in that respect, I’ll be as thorough as possible with the underlying math.

You’ve been warned.

Basic, basic physics

I’m sure all of you are familiar with this formula:

Suppose you want to travel from city A to city B which are 320 km (200 miles) away from one another. Suppose you’re going at an average speed of 80 km per hour (50 mph). Then your trip will have lasted 4 hours. So, that’s pretty simple, right?

Well, believe it or not, this simple formula accounts for the whole package of projectile ballistics (ignoring air resistance).

Here we’re using x and y as the horizontal and vertical components of the projectile travelling through the 3-D world. We can treat the world as being 2-D once the target and the projectile are aligned together.

I have to say that I’ve played a little trick on you, though. My little formula uses v̅ ( read: v-bar ), which is the average speed. That means if you’ve stopped for some gas or for a meal on your way, your average speed decreases accordingly, so really, v̅ contains an awful lot of information.

Fortunately, in the world of projectiles, v̅ is pretty simple to predict. Your final speed is your initial speed plus all the downwards acceleration that you’ve accumulated through gravity (denoted by the symbol g). Now your average speed is your initial speed plus half that same downwards acceleration.

Now that we have v̅ in terms that are easy to measure, we can replace it in the original formulas for x and y, giving :

Arrows

In Castle Story, archers can fire arrows at various targets to inflict them damage or neutralize them. They can shoot at any angle they desire that would improve their chance of hitting their target. However, they’re limited by the robustness of their bows and by their own physical strength. We decided that the main mechanism behind bows and arrows would mainly have to do with choosing an appropriate angle for shooting rather than varying the tension in the string. That also allows us to make a simpler animation for said string if we know in advance how pulled it will be.

OK, back to formulas.

Suppose you’ve just fired an arrow and you’re looking at it flying. You can look at the x and y components of its velocity and describe its “orientation”. At the beginning, the arrow is pointing generally upwards, but as the gravity pulls its y speed down, the arrows starts pointing more and more towards the ground, all the while keeping its original x speed (read: horizontal speed).

The elevation angle at which an arrow is fired have a huge impact on the range it covers. Here are a few trajectories that an arrow could have:

Imagine you’re firing an arrow at an elevation angle of 30°. Let’s call that angle θ (read: theta). What does that mean in terms of x and y arrow velocity? Well, your arrow will have the same total speed regardless of where you fire it, so let’s say it has a starting speed of v. However, if you fire it at 30°, it will have the better part of its speed invested in its horizontal velocity and it will take very little time before the arrow starts pointing downwards. On the other hand, if you fire it at, say, 60°, the opposite will happen: the arrow will still start with speed v, but it fly for a longer time before hitting the ground, yet it will also have travelled at a much lower horizontal velocity. Now that sounds very vague and general. Using trigonometric formulas, our original equations become the following:

So, what is the best angle to hit a given target? As a general rule, 45° is the angle that reaches the farthest, although that’s not exactly true for terrain that’s not entirely flat. But how can we hit a precise target if it’s closer to us than that farthest point? Is there a way to predict where to aim specifically?

By looking at the last two formulas, we see that we have only two unknowns remaining, namely θ and t. Since we also have two independent equations, algebra allows us to isolate t in both equations and, with appropriate manipulations and some sweating, obtain θ. The resulting formula is big and ugly, but don’t panic, it can just be used in a plug-and-play manner in any little physics engine with amazing results (see applet below). Without further ado:

If any of you should be interested in the algebra needed to derive the formula, Wikipedia has a page dedicated to projectile trajectories that explains it in a detailed fashion here.

Let’s go back to the big formula one last time very quickly and break it apart for those programmers among you who’d like to use it. θ is the elevation angle that we’re trying to calculate. arctan is the inverse of the tangent trigonometric function, which in turn is the ratio of the sine and cosine functions applied to a given angle. Generally, all math programming libraries have an arctan or atan function ready for use. Then we have our good old v (read: velocity), which stands for the initial speed of the arrow. In our case, that would depend on the strength of the Bricktron firing the arrow, or the tension in the catapult at the moment of releasing a projectile. Finally, we have x and y, which in this case mean the horizontal range at which the target stands, and the altitude of the target relative to the shooter, respectively.

So, that’s what’s happening in the Bricktron archer’s head. Looking at the target. Estimating its range and altitude. Plugging his firing power in the equation, and computing the right firing angle. Since the arrow travels reasonably rapidly, the target will not generally have the time to move too far away from the aimed spot, but we’ve also included a small estimation of the target’s future position according to its speed at the moment of aiming. We won’t cover that last detail in today’s blog, though.

Catapults

While archers can change their firing angle very quickly and easily, catapults can’t. Their mechanism is designed to brake at a very specific angle, something like 45°, and to throw any given projectile along a relatively similar trajectory. Where the catapult changes is in regards to it’s firing power. Not only can it project objects of different masses at different speeds, in can also be handled by a Bricktron to release more or less firing power at a time. Increasing the fire power makes the projectile go farther, and decreasing it makes it go closer, which makes it relatively easy to gauge where the catapult is shooting.

The following not-so-simple formula computes the initial speed that a projectile needs to have in order to reach a particular point in space (at horizontal reach x and altitude y, aiming at angle θ).

Try it yourself!

We’ve made a small applet that allows you to play a little bit with angle and firing power if you want to. Click inside the rectangle to change the target’s position. Knock yourself out!

[iframe src="http://www.freewebs.com/batiazul3627/castlestory/ballistics.html" width="555px" height="340px"]
Anyway, that’s it for this week’s blog, now to the soundtrack of the week!

See you next week everybody!
Peace.

The Sauropod team