projectile object arching movement

Unity Engine
1

What I’m trying to do is move a GameObject from start to end position in a form of arc, I currently have this working with Vector3.Lerp but unfortunately as the gameobject gets closer to the objects that it fires from it gets slower when it fired, I hope I’ve explained that correctly.

  private void Update()
  {
   if (mIsMoving == true)
     {
      mIncrementor += 0.02f;
      Vector3 mPosition = Vector3.Lerp(mStartPosition, mEndPosition, mIncrementor);
      mPosition.y += mForceUpwards * Mathf.Sin(Mathf.Clamp01(mIncrementor) * Mathf.PI);
      transform.position = mPosition;

      if (transform.position == mEndPosition)
        {
         mIsMoving = false;
         mIncrementor = 0;

         Collider[] mColliders = Physics.OverlapSphere(this.transform.position, DamageRadius, MonsterMask);
         if (mColliders != null && mColliders.Length > 0)
         {
          for (int i = 0; i < mColliders.Length; i++)
          {
           MonsterComponent mMonster = mColliders[i].GetComponent<MonsterComponent>();
           if (mMonster != null)
            mMonster.UpdateHealth(this.Damage * (Vector3.Distance(mMonster.Transform.position, this.transform.position) / this.Damage));
          }
         }

         Destroy(this.gameObject);
        }
     }
  }

I tried to use MoveTowards but the arching just did not work anymore, does anybody and Idea for a solution for this problem.

Cheers

2

Hello Piggybank1974,

The reason why your projectiles gets slower and slower the closer you are to the end is because of your use of lerp. Every frame, you move your interpolation forward 0.02 units. If your starting point and end point are close, the amount you move every frame is less than if your starting point and end point are further away.

Example:

Vector3 result = Vector3.Lerp(new Vector3(0f, 0f, 0f), new Vector3(10f, 0f, 0f), 0.02f);
// x result - 0.2f

Vector3 result = Vector3.Lerp(new Vector3(0f, 0f, 0f), new Vector3(1f, 0f, 0f), 0.02f);
// x result - 0.02

If your goal is to move the projectile at a constant speed, my advice would be to move the projectile with a constant amount every frame, without the distance being a factor in the speed.

Good luck!

3

My question is, could he adjust the mass and gravity on the rigidbody component to maintain consistent speed? I’m thinking adjusting them through code using Time.fixedDeltatime or something along them lines. Would that actually work?

4

I can’t help you with .Lerp () because it’s a complex thing to understand and I didn’t see it very well.
But I can help with what you are trying to do. First, are you moving the GameObject through a Rigidbody? Second, is the GameObject a projectile? Correct me if I’m wrong.

If this is a projectile. Then you can apply the physics projectile motion formula.

The formula says this:

Note: T is time.
X is the distance between the two points horizontally.
Y it’s the height.
A is the acceleration of gravity, in this case it will be -9.81. (If you look at Unity Physics, you will see this value. For more information here).
Pow means “elevated to the power of”.

X = V0x * Cos(angle) * T

Y = V0y * Sin(angle) - 1/2 * A * Pow(T, 2)

After seeing this, maybe you noticed that you have X, Y and in T you can give a value. So, in this case, you need V0x and V0y for the initial momentum. But first you need to know the angle generated by the two points. Then we need to apply the trigonometric functions to get the angles.

If you see vectors you can do this:

float Acos(float c) => Mathf.Acos(c) * 180 / Mathf.PI; // function to get the arc-cosine in degrees
float Asin(float s) => Mathf.Asin(s) * 180 / Mathf.PI; // function to get the arc-sine in degrees

Vector2 distSide = target - origin; // Subtract target by origin to get side distance
float h = distSide.magnitude; // Get the magnitude of distSide. This will be the hypotenuse.

// Angle by the Cos method

float cos = dist.x / h // adjacent over the hypotenuse
float resultCos = cos >= 0 ? Mathf.Round(Acos(cos)) : Mathf.Round(Acos(-cos)); // Make a check because it will always return positive grades

// ---

// Angle by Sin method

float sin = dist.y / h // opposite over the hypotenuse
float resultSin = Mathf.Round(Asin(sin));

// ---

Now we need two values that we don’t know. And these are V0x and V0y. Then we can make an equation and the result will be this:

V0x = X / Cos(angle) * T

V0y = Y / Sin(angle) * T + 1/2 * A * T

So now we need to know these values. And if we pass this to the script, it will be something like this:

// Formulas
float Vx(float x, float t) => x / (Mathf.Cos(resultCos / 180 * Mathf.PI) * t);
// I do a Mathf.Abs to the Mathf.Sin because sometimes this returns a negative value.
// And also apply .Abs to Physics2D.gravity.y because this is negative
float Vy(float y, float t) => y / (Mathf.Abs(Mathf.Sin(resultSin / 180 * Mathf.PI)) * t) + .5f * Mathf.Abs(Physics2D.gravity.y) * t;
// ----

float hY = target.y - origin.y; // Get the hight
float dX = target.x - origin.x; // Get the distance on the X axis
        
Vector2 v0 = new Vector2(dX, 0).normalized; // Assign a new normailized Vector2 in v0.
v0 *= Vx(Mathf.Abs(dX)); // Multiply the Vx by the v0. Use Mathf.Abs to convert negative values to positive.
v0.y = Vy(hY); // Assign in Y the Vy

// Assign v0 to rigidbody

rb2D.velocity = v0;

You can even remove t from the formulas. Since this value affects how the parabola is formed at the time of the flight. But if you want to generate a normal parable. So just having the angles is enough, because they apply a normal time without needing t.

I hope this helps.

4 Likes
5

This is truly a magnificent work of art! Well done!
If no one else appreciates it, I do!
I needed to see this :slight_smile:

1 Like
6

Thanks!!

7

I’m looking to improve these functions a bit. Then I made these changes:

For trigonometric functions it’s just this.

// Removed Acos and Asin functions.

Vector2 distSide = target - origin; // Subtract target by origin to get side distance
float h = distSide.magnitude; // Get the magnitude of distSide. This will be the hypotenuse.

// Angle in radians by the Cos method

float cos = dist.x / h; // adjacent over the hypotenuse
float resultCos = cos >= 0 ? cos : -cos; // Make a check because it will always return positive radians

// ---

// Angle in radians by Sin method

float sin = dist.y / h; // opposite over the hypotenuse
float resultSin = sin;

// ---

So, for formulas, just change this:

// Formulas

float Vx(float x, float t) => x / resultCos * t; // When using the previous method. I noticed that Mathf.Cos gives the same result as dist.x / h. So replace the Mathf.Cos only with the resultCos.
// I use Mathf.Abs for the resultSin because sometimes this returns negative values.
// And also apply .Abs to Physics2D.gravity.y because this is negative.
float Vy(float y, float t) => y / (Mathf.Abs(resultSin) * t) + .5f * Mathf.Abs(Physics2D.gravity.y) * t; // Here the same as Vx.

// ----
float hY = target.y - origin.y; // Get the hight
float dX = target.x - origin.x; // Get the distance on the X axis

Vector2 v0 = new Vector2(dX, 0).normalized; // Assign a new normailized Vector2 in v0.
v0 *= Vx(Mathf.Abs(dX)); // Multiply the Vx by the v0. Use Mathf.Abs to convert negative values to positive.
v0.y = Vy(hY); // Assign in Y the Vy

// Assign v0 to rigidbody
rb2D.velocity = v0;

For more flexibility, you can create extension methods for this and separate the code. Like this:

using UnityEngine;

namespace ExtensionMethods
{
     public static class MathfP
     {
          /// <summary>
          /// Returns the angle of the vector in radians. Through Cos method generated by the origin and the target.
          /// </summary>
          /// <param name="origin">The point in 2D space where the vector start.</param>
          /// <param name="target">The point in 2D space where the vector ends.</param>
          /// <returns><seealso cref="float"/> angle in radians.</returns>
          public static float AngleCosRadian(Vector2 origin, Vector2 target)
          {
               Vector2 distSide = target - origin;
               float h = distSide.magnitude;
               float cos = distSide.x / h;
               float result = cos >= 0 ? cos : -cos;
               return result;
          }
      
      
          /// <summary>
          /// Returns the angle of the vector in radians. Through Sin method generated by the origin and the target.
          /// </summary>
          /// <param name="origin">The point in 2D space where the vector start.</param>
          /// <param name="target">The point in 2D space where the vector ends.</param>
          /// <returns><seealso cref="float"/> angle in radians.</returns>
          public static float AngleSinRadian(Vector2 origin, Vector2 target)
          {
               Vector2 distSide = target - origin;
               float h = distSide.magnitude;
               float sin= distSide.y / h;
               return sin;
          }
      
      
          /// <summary>
          /// Generates a projectile motion between origin and target.
          /// </summary>
          /// <param name="origin">The point in 2D space where the projectile motion start.</param>
          /// <param name="target">The point in 2D space where the projectile motion ends.</param>
          /// <returns><seealso cref="Vector2"/> with the initial momentum.</returns>
          public static Vector2 ProjectileMotion(Vector2 origin, Vector2 target)
          {
                // As I said in the previous post. You can remove t from the formulas
                float Vx(float x) => x / AngleCosRadian(origin, target);
                float Vy(float y) => y / Mathf.Abs(AngleSinRadian(origin, target)) + .5f * Mathf.Abs(Physics2D.gravity.y);
       
                float hY = target.y - origin.y;
                float dX = target.x - origin.x;
       
                Vector2 v0 = new Vector2(dX, 0).normalized;
                v0 *= Vx(Mathf.Abs(dX));
                v0.y = Vy(hY);

                return v0;
           }

           // In this method you can add t in the parameters
           /// <summary>
           /// Generates a projectile motion between origin and target.
           /// </summary>
           /// <param name="origin">The point in 2D space where the projectile motion start.</param>
           /// <param name="target">The point in 2D space where the projectile motion ends.</param>
           /// <param name="t">The time of flight of a projectile motion.</param>
           /// <returns><seealso cref="Vector2"/> with the initial momentum.</returns>
           public static Vector2 ProjectileMotion(this Vector2 origin, Vector2 target, float t)
           {
                float Vx(float x) => x / AngleCosRadian(origin, target) * t;
                float Vy(float y) => y / (Mathf.Abs(AngleSinRadian(origin, target)) * t) + .5f * Mathf.Abs(Physics2D.gravity.y) * t;

                float hY = target.y - origin.y;
                float dX = target.x - origin.x;

                Vector2 v0 = new Vector2(dX, 0).normalized;
                v0 *= Vx(Mathf.Abs(dX));
                v0.y = Vy(hY);

                return v0;
           }
     }
}

And if you want to use these methods. Just do this:

using UnityEngine;
using ExtensionMethods; // We access the namespace and the whole class that has.

public class Projectile : MonoBehaviour
{
     [SerializeField, Tooltip("The target position")]
     private Transform target;

     private Rigidbody2D rb2D;

     void Awake()
     {
          rb2D = GetComponent<Rigidbody2D>();
     }

     void Update()
     {
          rb2D.velocity = MathfP.ProjectileMotion(rb2D.position, target.position); // I call the ExtensionMethods class with its method.
     }
}

For more information about Extension methods here.
For more information about namespaces here

1 Like
8

@Ted_Wikman
@Tim-Duval
@Ledesma099

Sorry for the delay in replying guys, My emails where down last night, I figured it was the timing on the lerp,

I thought I tried that Ted but it does not work, and I think I know why it’s because of the arcing I’m putting on the gameobject, for example the mForceUpwards is based on the angle of the turret the bomb is firing out off, if the turret is pointing forward no mForceUpwards will be applied but if it’ lets say 30% it will be 3F, this makes it arc I also tried movetowards but again could not get it working correctly they just went you and down like I ping pong if I remember.

What do you think of this solution, the bomb can travel a max distance of 9 unity units and a minimum of 2 units so we know that 0.02F is for units could a adjust that for less?

then as the fire is less it should be the same move the same speed, I hope I’ve explained that correctly.

I know I’m wanting to do a Parabola Curve, just could not work this out, I do have an example I wrote of this for the Wiki pages, but that’s if both start/end are on the ground.

Ledesma099 yes I do have a rigidbody but as you can see I’m not moving with it, the collider is set to trigger not collision.

Ledesma099 these are not extension methods, I’m sure the first parameter should be this?

Ledesma099 I could not see a height for the arcing, I’m I missing something

Thanks for all your help guys, I’m sure we can figure it out, I’ll create a little unity package if that helps to see it better, I don’t mind :).

9

I found an angle to reach method I wrote a while back

  /// <summary>
  ///  Calculates the angle to hit target
  /// </summary>
  /// <param name="distance">The distance from Source(Enemy) to Target(hero) e.g (Source-Target).magnitude</param>
  /// <param name="pvelocity">The projectiles velocity e.g (Speed)</param>
  /// <param name="angle">The angle that is been calculated</param>
  /// <returns>True if angle can be calculated or false if it cannot, the result is in angle</returns>
  private Boolean AngleOfReach(float distance, Single pvelocity, out Single angle)
  {
   angle = 0.5F * (Mathf.Asin((-Physics.gravity.y * distance) / (pvelocity * pvelocity)) * Mathf.Rad2Deg);
   if (float.IsNaN(angle) == true)
   {
    angle = 0;
    return false;
   }

   return true;
  }

But I’m sure this will only work if it’s level?

10

Yes you’re right. But I create a MathfP class and call its methods as Mathf of unity.

What specific part?

11

@Iron-Warrior
@Ledesma099
@Ted_Wikman
@Tim-Duval

Hi all not to give up on this task of getting this thing in my head, I’m in my middle 40’s so I did not tackle this sort of thing when I was younger.

This weekend I put together a little unity package with several Turrets

BombTower
Is my version although it has extra things it contains, it’s all where this started.

Tower 2
I got this idea from a YouTube video

this does work but you have no way I can see to increase the speed.

Tower 3
I got this from Iron-Warrior’s project he did, thanks for this, although it’s end result was above the target “probably because of the Yoffsset”, I did figure out a little solution that every iteration “point” it moves the next one down giving the end result of the ball hitting the ground/floor.

Tower 4
I started implementing Ledesma099 code but only got so far, as I wanted to release this.

Like I said I’ve not done equations so if I explain what I understand maybe I can be pointed out, I get confused when they swap things.

I know these values

Distance/Displacement
Acceleration/Speed

I don’t know these values

Angle to fire the ball from the barrel.
V1y at halfway for time?

VO = Target position/velocity
V1 = Source Position/velocity

Heading = Target - Source
Distance = Heading.Magnitude;

if we take a Ball fired from the turret

V0x = 0 has it has no initial velocity, position x?
V0y = the value of the fire position from the turret

V1x = distance it can travel.
v1y = at the midpoint/half way then it will start falling again.

5137904–508478–Projectile.unitypackage (81.6 KB)