Projectile calculations in 3D space, using your own movement code

It’s been a while ūüôā I have been busy and did not have the energy to finish this 4 part series of projectile calculations. Now I am finally putting out the last bit. Calculating the projectile movement in 3D space using your own movement code.

For starters, lets refresh what I wanted to write in the first place. I was working with a project where I needed to calculate the a projectile path in 3D space using my own movement code rather than relying on the rigid body and physic engine. In my case I absolutely wanted the projectile to hit the target always so I couldn’t go with the calculate path with any given velocity and any given angle.

For a refreshment’s sake, let’s revisit this picture. Red diamond is the source and green cube is the target. Source position is x1, y1, z1 and target position is x2, y2, z2. The angle between x -axis and projectile is theta which is 66 degrees in the example. Y axis is up and Z is forward.

projectile_3d_001

So last time we used rigid body and it’s AddForce method to do all the work. Now we need to calculate the position by ourselves. So lets start with the same formula based on Wikipedia. You can solve the velocity from distance formula when both start and end y coordinates are 0. v = 1 / cos(a) * sqrt((0.5 * g * d * d) / (d * tan(a))); where v = velocity, d = distance, g = gravity and a = angle.

Since we are interested in horizontal velocity having 2 components (X and Z) and vertical component Y we need also calculate direction because we want to manipulate the X and Z correctly. Direction we can get by subtracting the start and end positions and taking the normalized of resulting vector. So: Vector3 direction = (end – start).normalized;

You are also going to need the duration the projectile will stay in the air. Well, you could also not care about this but probably you want to do some cleanup code so your scene will not get filled with projectiles that are already landed and immobile. You can use the horizontal distance as base for duration or you can use the Y component thus velocity and gravity. Since we used the horizontal distance last time let’s now use the Y component. So the duration can be calculated by: (Sin(Angle) * velocity * 2) / gravity.

So in our example: d = 21.2132, a = 66.0, g = 9.81, replacing the variables in the velocity equation give us v = 16.74. Duration is: 3.11

If you remember from the 2D example we used the Unity’s update() function to move the projectile. This is perfect fit again since we have just one more component it’s basically the same.

So we are going to utilize the Time.deltaTime so we know how long as time passed since last update and multiply that with horizontal velocity. This is going to be our fraction of the journey up to the destination in horizontal space. Then we need to multiply the (horizontal) speed with the fraction multiplied by direction. So code is:


var horizontal = Mathf.Cos(Angle * Mathf.Deg2Rad) * velocity;
float frac = (Time.deltaTime * horizontal / distance);
var direction = (target.transform.position - start).normalized;
float x = frac * distance * direction.x;
float z = frac * distance * direction.z;

I am actually doing unnecessarily the direction inside the Update() since start and end do not change during the projectile flight. Anyways. This is the increment / decrement you need to apply to X and Z components.

What about the Y component? This is exactly the same as previously. From the wikipedia article, height at arbitrary distance X: By feeding our parameters in the formula: height y = start.y + x * tan(angle) – (gravity * pow(x) / 2 * pow((velocity * cos(angle)))). Note: x here is the distance from the start. Well, wikipedia article is 2D so X is the distance from the start but we need to use both X and Z components. Well we actually have all we need, we did the fraction right?


Vector2 position = new Vector2(transform.position.x + x, transform.position.z + z);

This is the current projectile position and since I am using the code in the projectile, transform refers to this GameObject’s transform. If we take the position.magnitude we have the distance.

Ultimately we want to do this:


this.transform.position = new Vector3(position.x, y, position.y);

Note: We projected the X,Z movement to Vector2 so it do not have Z we need to use Y. You can do this also without the Vector2 by calculating the distance by:
sqrt(pow(start.x – end.x) + pow(start.z – end.z)).

So here it is, now you can do the projectile calculation in 3D by using your own code. The complete solutions is not here, but all the relevant bits are here so you should be able to complete the Update() function very easily.

What do you think of all this? Do you have any suggestions or feedback. Please leave a comment and happy coding!

Projectile calculations in 3D space, using rigid bodies

If you have been following what I wanted to write regarding projectile calculations you know now how to do the calculations in 2D with using both rigid bodies and by calculating the movement code yourself. Now we add one dimension and see how it effects things.

Let’s take a look at this picture. This is pretty similar than the previous one but with one more axis involved. This is your game where you have source (red diamond) and target (green cube). Source position is x1, y1, z1 and target position is x2, y2, z2. The angle between x -axis and projectile is theta which is 66 degrees in the example. Notice how now Y axis is up and Z is forward.

projectile_3d_001

We are still going to need the velocity vector like previously which then can be applied to rigid body. You have now three components X, Y and Z that you need to solve because you want the projectile to move to all directions.

With the same formula based on Wikipedia you can solve the velocity from distance formula when both start and end y coordinates are 0. v = 1 / cos(a) * sqrt((0.5 * g * d * d) / (d * tan(a))); where v = velocity, d = distance, g = gravity and a = angle.

Since we are now interested in horizontal velocity having 2 components (X and Z) and vertical component Y we need also calculate direction because that is going to dictate how much force we need per component. Direction we can get by subtracting the start and end positions and taking the normalized of resulting vector. So: Vector3 direction = (end – start).normalized;

Distance you get by d = sqrt(pow((x2 – x1)) + pow(y2 – y1)), or Vector3.Distance(start, end) or (start,end).magnitude (where start and end are Vector3 objects)

So in our example: d = 21.2132, a = 66.0, g = 9.81, replacing the variables in the equation give us v = 15.0929.

Remember how we used the rigid body’s AddForce -method to apply the velocity vector? We can use the same function but now we are going to need the Z -component too. Last time we did this:


var distance = Vector3.Distance(target.transform.position, position);
var velocity = (float)(1 / Mathf.Cos(angle * Mathf.Deg2Rad)) * Mathf.Sqrt((float)(0.5f * 9.81 * distance * distance) / (distance * Mathf.Tan(angle * Mathf.Deg2Rad)));
float horizontal = Mathf.Cos(angle * Mathf.Deg2Rad) * velocity;
var direction = (target.transform.position - position).normalized;
var rbVelocity = new Vector2(direction.x * horizontal, Mathf.Sin(angle * Mathf.Deg2Rad) * velocity);
rigidBody.AddForce(rbVelocity, ForceMode.Impulse);

Now we just use Vector3 like this:


var rbVelocity = new Vector3(direction.x * horizontal, Mathf.Sin(angle * Mathf.Deg2Rad) * velocity, direction.z * horizontal);

That is basically all we need. Adding the third dimension was very easy since the direction already contains both X and Z components that we need. Now you can fire a projectile that will always land on it target so matter what is used angle (with the exception of 90 and 0 of course). What do you think, any ideas or suggestions? Please, leave a comment.

Simple projectile calculations in 2D with your own movement code

So last time we did a simple projectile calculation by using Unity’s rigid bodies by calculating velocity vector and applying a force to the projectile rigid body. Now we do the same without rigid body but doing a calculation based on updating the position manually.

Remember this was the sketch of what we have:

projectile_2d_001

For updating the position we need to know the angle, distance, amount of gravity and time of flight. We also need to calculate the velocity which we need to do other calculations. The distance as you remember from the last time we get by: d = sqrt(pow((x2 ‚Äď x1)) + pow(y2 ‚Äď y1)), or Vector3.Distance(start, end) or (start,end).magnitude (where start and end are Vector3 objects).

So in our example: d = 15.0, a = 66.0, g = 9.81, replacing the variables in the equation give us v = 14.0716. Now we are interested how long the projectile will stay in the air. This is because we need to interpolate the position between the start and end positions. We could use some a fixed value for time but this will create unrealistic result since the actual time spent in the air depends on the angle and distance (and gravity).

So how we get the time? You can calculate the time the projectile is airborn in two ways. Either you can use the Y component (eventually gravity pulls the projectile back to ground) or X component. If you want to use Y, the formula is time t = (velocityY * 2) / gravity. So y velocity times 2 over gravity. If you remember from the last time we used the velocity and direction to get the horizontal velocity and sin(angle) * velocity to get Y vertical velocity? We use the same method like this:


var direction = (target.transform.position - start).normalized;
var horizontal = Mathf.Cos(angle * Mathf.Deg2Rad) * velocity;
var vertical = Mathf.Sin(angle * Mathf.Deg2Rad) * velocity;

Finally we can calculate time: t = (vertical * 2) / g. So in our example it is: 2.62s This means that the projectile will stay in the air 2.62 seconds without hitting the target. So bigger the angle more velocity we need to hit the target thus longer the projectile will stay in the air. You could also use t = distance / horizontal, which by the way also gives the same 2.62. (which is a good thing!)

Ok, we have now all the components needed for our calculation. We are using Update() function which Unity will call every frame. This makes the function frame rate dependent, e.g. with 30 fps Update will get called on average by every 33.33 ms. So we know that we should get from start to the end in 2.62s. I said we need to interpolate the position based on the time. This can be done in several ways.

Unity has a Vector3.Lerp -function what is very handy what we can use e.q. Vector3 currentPos = Vector3.Lerp(start, end, time / duration); If the use this helper inside Update() -function we need to increment time variable by the difference of the previous call and Time.deltaTime is exactly for this. This way you make sure your stuff is not frame rate dependent. So a small example:

private float time = 0.0f;

private void Update()
{
time+=Time.deltaTime;
var currenPos = Vector3.Lerp(start, end, time/duration);
}

Duration you need to be calculate somewhere outside Update and start and end are positions as Vector3 type.

If you update your projectile currentPos, it will fly from start to end in given duration, but since it’s a linear interpolation between the values it do not have the projectile trajectory yet. We actually use only the x component to update the x position but we also use it to calculate y position. So how it’s calculated? We go back to the original Wikipedia page and see that height at arbitrary distance x has a formula:

height y = start.y + x * tan(angle) – (gravity * pow(x) / 2 * pow((velocity * cos(angle))))

so when in our Update() function we apply the x from current position to the formula, we have the height at distance x. The update function is going to need something more than that, for example you don’t want to update the position unless the projectile has been launched and you don’t want to update the position after time > duration. But that’s easy stuff after all this.

Neat, now you can hit the target by any angle and distance and you are doing it all by yourself! What do you think? Do you have any suggestions or improvements? Leave comments!

Simple projectile calculations, first in 2D by using rigid bodies

It’s been a very long time since I posted anything programming related here. The reason being I have been busy at work working with two different games and I have felt I didn’t have the energy to do anything extra at home.

But just recently I was working with a new game play feature where I needed to calculate a projectile movement. This was not something I have done before and I had to dig up some stuff to make it work and I wanted to share some of the ways how to do this. It’s basically not rocket science but there are some considerations how you want to do it. This is the first part of the series where I cover some techniques how to do the calculations. First we concentrate on 2D space and later how to do that same in 3D. The reason is it’s easier to understand what’s needed with just 2 axis rather than with 3 axis. I have done the code by using Unity3d but the principles applied are universal.

So in my task I needed to calculate projectile trajectory in 3D space where I know the start and end coordinates, possible throw angle but not the velocity needed to hit the target. In the game I absolutely want the projectile to hit the target so this is directly not applicable to calculation in a game mechanic where you can freely select the angle and possible velocity (thrust / power), and calculate how far the projectile will go. The formula is still the same but you would need to solve different factors from the formula.

So firstly, if you use Unity3d you can choose at least two different ways to do the projectile. 1) Using rigid bodies and applying a force to the rigid body and let Unity take care of the projectile movement. This is the easy way. You don’t need to calculate a whole lot of stuff just apply a certain force and boom, off you go. 2) You do it manually. You calculate the projectile movement by yourself.

Solution 1) is just fine if you can do that. With ridig body you lose the control how the physics simulation takes place (it’s carried out by Unity3d). This might be ok for certain game play mechanics, but was not for me. For example I needed to be absolutely sure that the projectile will end up in the target. Also if you want to have automatic collision detection with colliders you might have a situation where you have something in front of the actual target and colliding that instead of intended target. This is of course not realistic but if you are reading this you are probably not making a realistic FPS anyway.

Solution 2) is where you do calculations manually. This gives you absolute control of the position of the projectile and still allows you to do collision detection with colliders.

Ok, let’s draw some stuff. This is your game where you have source (red diamond) and target (green cube) in 2D. Source position is x1, y1 and target position is x2, y2. The angle between x -axis and projectile is theta which is 66 degrees in the example.

projectile_2d_001

With solution 1) you need to calculate the velocity vector which is applied to the rigid body of the projectile. You have two components X and Y that you need to solve because you want the projectile to move both to X and Y directions, right?

With the formula based on Wikipedia you can solve the velocity from distance formula when both start and end y coordinates are 0. v = 1 / cos(a) * sqrt((0.5 * g * d * d) / (d * tan(a))); where v = velocity, d = distance, g = gravity and a = angle.

Distance you get by d = sqrt(pow((x2 – x1)) + pow(y2 – y1)), or Vector3.Distance(start, end) or (start,end).magnitude (where start and end are Vector3 objects)

So in our example: d = 15.0, a = 66.0, g = 9.81, replacing the variables in the equation give us v = 14.0716. This is our total velocity which needs to be used in 66 angle to hit the target. So how you apply this force to a rigid body?

Rigid body has a function AddForce() which have multiple overrides but basically it accepts velocity vector to be used as force. You can also choose what type of force you are interested applying to. Since it requires a vector or 2 to 3 components (x,y) or (x,y,z) we need to calculate how this 66 degrees and velocity are in terms of a vector.

First we get the horizontal component from the velocity. This is done by multiplying cos(angle) with total velocity. And vertical component you multiply with sin(angle). We also need to know what is the direction we want the force to be applied to. This you get by target position – source position normalized. Vector3 direction = (target.transform.position – source.transform.position).normalized; What this does it gives the direction without the length.

For Y component it’s always a positive so we don’t need to do anything. (We are firing upwards, right?) For X component we need to multiply the direction.x with horizontal velocity. Like this: float xDir = direction.x * horizontal; These are the values for your velocity vector which you can apply to the rigid body.

So this is the code:

var distance = Vector3.Distance(target.transform.position, position);
var velocity = (float)(1 / Mathf.Cos(angle * Mathf.Deg2Rad)) * Mathf.Sqrt((float)(0.5f * 9.81 * distance * distance) / (distance * Mathf.Tan(angle * Mathf.Deg2Rad)));
float horizontal = Mathf.Cos(angle * Mathf.Deg2Rad) * velocity;
var direction = (target.transform.position - position).normalized;
var rbVelocity = new Vector2(direction.x * horizontal, Mathf.Sin(angle * Mathf.Deg2Rad) * velocity);
rigidBody.AddForce(rbVelocity, ForceMode.Impulse);

Some stuff outside the code: I have local reference to rigidBody of the projectile which I have instantiated at source position and I am applying this force once when I instantiate the projectile. This can be done several ways but I did mine on left mouse click so I would be able to see multiple projectiles flying from source to target.

Now you have code for a projectile using rigid body flying constantly to the target position with a certain angle and range. Nice. What do you think of this? Do you have any comments, ideas or improvements? Next time we do this same exercise by calculating things manually.

–small after post note–

If you run into problems where the projectile do not land correctly even if you think the formula and calculations are correctly, this might be caused by Unity’s physics engine with too few velocity solving iterations. My projectile hit the target always when angle was more than approx 30 degrees but would always go over the target when lower. If your calculations are correct then try to add the “solver velocity iterations” in the project settings, in physics tab.

Particle systems, continuation with healing effect

Last time I wrote a small tutorial how to create a simple smoke with Unity particle system and how it would be very easy to adjust the settings to create another type of effects. Now we modify the particle system so that with very small changes we can create a neat basic healing effect.

Let’s create a new GameObject and name it ie. HealingEffect or something you like. Add the ParticleSystem component into the newly created GameObject. (if you don’t remember how to do this, check the previous post)

Then if you remember what I wrote about the textures and seeing the effect of the texture, change the texture first. We are going to need a image of a cross or something similar. Green cross is very often used as “healing effect” throughout the gaming history so that’s what we use now. You can easily draw one if you don’t have one available.

So drag the texture under Unity’s assets. Unity prepares the texture as an asset if it’s running or when started the next time from that project. Create a material and add the newly created texture into the material. Set the Shader to particles additive or particles additive (soft).

Now change the material in the particle system. Whoa! You already have flying crosses. Rotate the particle system -90 degrees on X -axis. This way the particles flying vertically away from the origin.

Now we tweak few values so that the effect looks good.

1) Size over lifetime. Create a curve where start and end are smaller (say 50% depending on your texture) and 100% in the middle. This way the particles start small, grow in size to become smaller again.

2) Color over lifetime. Create a curve with white color and then change the start alpha to 0 so it’s fully transparent, add a control point around 25% where alpha should be 255 (full opaque), another control point around 75% with full opaque and set the end alpha to 0. This way the effect is full transparent at start, opaque in the middle and transparent in the end. This gives nice fade effect at the start and in the end.

Some of the base settings need adjustment as well. It all depends on your texture but I used 100 max particles, start lifetime of 2.05, start speed of 3.0, start size of 0.85. Set the emission and shape to your liking but emission rate should be pretty small like 3. Also keep the shape narrow so particles are not sprayed too wide.

I used the same scene as before but I added an untextured low poly dog and applied the healing effect on it. If you did everything correctly you should have something similar, something like this:

What do you think? Leave a comment!

How to create simple smoke in Unity3d

This is a very short and simple tutorial for creating simple smoke in Unity by using Shuriken particle system. Similar tutorials can be found from the YouTube and interwebs all over. Things you need to be able to complete this tutorial. Unity3d (my version is 4.6.2) but you can use older version as well as long it has the Shuriken particle system. I think it’s 3.5 and later. A painting program to create the texture what we will be using, or modifying an existing one. I am using Photoshop. You need some basic understanding of Unity, game objects and prefabs too.

The outlooks of the smoke will be very highly dependent on your texture and how you tweak the parameters in the particle system but this tutorial should give you basic understanding what parameters will do.

Steps:

1) Start with a new project and new scene. Basically when you start Unity you select folder and let unity to create a new project. I created mine with the 3D presets.

2) Create an new game object. Menu -> GameObject -> Create Empty

3) Add a new component into your newly created game object and select particle system. You can rename your game object i.e. “Smoke”. Now you should have a GameObject at the center of the screen (0,0,0) with a Shuriken particle system component attached to it.

Default particle system rotation is 0,0,0 which causes the particles fly horizontally. You might want to change this depending on your needs. Usually it’s good practice to have position and rotation to be set to 0,0,0 and control them from the code if needed. If you are sure you use this particle system just one way you can of course set position and rotation to the game object it self. If particle system is part of a larger entity then you might want to set the position and rotation according to the parented object. (i.e. space ship engine exhaust)

4) Texture and material. Start with the material and texture because you want to see the how parameters affect to the texture. With the default material it’s rather difficult to see what¬†i.e. rotation over lifetime does.

So, create a material. Menu -> Assets -> Create -> Material. For the shader select “Particles Additive” or “Particles Additive Soft” depending on your texture. For the texture drag the texture from the Assets folder to the material. You can copy the texture to the Assets folder and Unity imports it automatically.

Small remarks regarding the texture. Ideal texture would be large enough to have some details and the smoke on the texture should be white. Do not have smoke on the edges of the texture because when rendered it will be visible. Try to create a texture where smoke is in the middle and not touching the edges of the texture. It might be a good idea to have the texture smoke gray scale, preferably white, so you can use the color in the particle system to tint the color for your preference.

5) Parameters:

Color over lifetime. At the end we need a fade, otherwise the smoke disappears instantly which is not realistic and does not look good. Values: at the start color should be white and full opaque. In the end color should be white with full transparency.

Size over lifetime. Depending on the texture you use it might be a good idea to start with the very small size at the start and full size at the end. While the color over lifetime also does fade together with this we have a small opaque texture at start and full size transparent texture at the end. You can use preset curves for the ease.

Size by speed.¬†We can also control the size by the particles speed. Since we already control the size over life and we don’t control the speed that much this is now not needed.

Rotation over lifetime. This controls the rotation of the texture over lifetime. If you don’t use this the effect becomes very static since texture is not rotated. I used “Random Between two curves”. You can play with the values and keep the ones you like the most. On the X axis you have the lifetime and on Y axis the¬†angular velocity. The higher value causes more rotation.

Rotation by speed. This also controls the rotation but by the speed. The Y -axis is the angular velocity and X -axis is the remapped speed range that you have used. I had mine from 0 to 1 so that at the start I have stronger velocity and towards the end it doesn’t rotate at all.

Rest of the parameters. There are multiple parameters in the particle system itself and try out different values for the lifetime, speed, size and so on. There are no correct values because a lot depends on your texture.

Last thing to do is to create a prefab out of the GameObject so that you can reuse and instantiate the prefab where it is needed. Menu -> Assets -> Create -> Prefab. Rename to i.e “Smoke”. Now drag and drop the smoke from your hierarchy view to the prefab in the Assets. Now you can delete the “Smoke” GameObject from your scene since everything is stored at the prefab. Remember to save project. NOTE: If you change the GameObject in the scene after this the changes are not reflected to the prefab unless you press apply from the GameObject next to¬†prefab and save the project.

When you are done you should have a simple smoke particle system similar to this:

Here the particle system is part of Unity Terrain in a simple scene where it could be like a signal smoke or something similar. By changing the parameters it’s easily adjusted to i.e. a smoke coming from a building on fire etc.

What do you think? Leave a comment!

Rigging characters in Blender

When I started to create models and animations with Blender in February this year (2014) I wanted to understand what it takes to create 3d models and import them into a gaming engine.

Until now I have mostly just studied how Blender works and how you create models and animations. Now I took the next step and I wanted to create a low poly character and create a rig for it. Rig is a set bones that control a mesh (a model). One could say it’s a skeleton of some kind. When you have a rig that is attached to a mesh, controlling the rig you can animate the mesh more easily.

So, I started from a very simple person who doesn’t have a facial features due to being low poly. But he/she has arms and legs, head and fingers. This should be simple enough to create the rig.

Rigging in Blender is in my opinion very easy. You can find numerous tutorials in YouTube and it’s easy to get started with beginner knowledge in Blender. Blender even has a nice add-on called Rigify¬†which creates a simple human rig you can easily extend.

After a weekend practicing and learning I created a rig and two simple animations. One with a simple walk cycle and second one a bit more complex, a round house kick.

What you think?