Calculate mortar parabolic trajectory knowing the shot angle but not velocity

Question

The problem is that when I set the y position of the mortar to a different one to 0 the tajectories dont work. But it does work if the bullet I shoot has to impact on different altitudes.

I have two scripts Mortar Script:

 public class Projectile1: MonoBehaviour
 {
     // launch variables
     [Range(20.0f, 75.0f)] public float LaunchAngle;
     public float waitTime;
 
     public GameObject Bullet;
     public GameObject Canon;
     public GameObject Mark;
     
     // state
     private bool bTouchingGround;
     private bool Reloading = false;
 
     // cache
     public RaycastHit hit;
 
     //-----------------------------------------------------------------------------------------------
 
     // Use this for initialization
     void Start()
     {
         
     }
 
     // resets the projectile to its initial position
 
     // Update is called once per frame
     void Update()
     {
         if (Input.GetMouseButtonUp(0))
         {
             Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
             
 
             if (Physics.Raycast(ray, out hit, Mathf.Infinity))
             {
                 Debug.DrawLine(Camera.main.transform.position, hit.point, Color.red);
                 //Debug.Log(hit.transform.position.x);
                 if (hit.transform != null & Reloading == false)
                 {                                    
                     Instantiate(Mark, new Vector3(hit.point.x, hit.point.y+0.01f, hit.point.z), Quaternion.Euler(new Vector3(90,0,0)));
                     Instantiate(Bullet, Canon.transform.position, Quaternion.Euler(new Vector3(90, 0, 90)));
                     StartCoroutine(Reload(waitTime));
                 }
             }
             
         }
 
     }
     IEnumerator Reload(float waitTime)
     {
         Reloading = true;
         yield return new WaitForSeconds(waitTime);
         Reloading = false;
     }
    
 }

Bullet Script:

 public class Bullet: MonoBehaviour
 {
     Rigidbody rigid;
     public GameObject Mortar;
     private Quaternion initialRotation;
     
     // Start is called before the first frame update
     void Start()
     {
         Mortar = GameObject.FindGameObjectWithTag("Arma");
         
         //Debug.Log(Mortar.GetComponent<Projectile1>().hit.transform.position.x);
         rigid = GetComponent<Rigidbody>();
         initialRotation = transform.rotation;
         Launch(Mortar.GetComponent<Projectile1>().hit.point, Mortar.GetComponent<Projectile1>().LaunchAngle);
     }
 
     private void Update()
     {
         transform.rotation = Quaternion.LookRotation(rigid.velocity) * initialRotation;
     }
     void Launch(Vector3 hit, float LaunchAngle)
     {
         //GameObject Disparo = Instantiate(Bullet, Canon.transform.position, Quaternion.identity);
         
         // think of it as top-down view of vectors: 
         //   we don't care about the y-component(height) of the initial and target position.
         Vector3 projectileXZPos = new Vector3(transform.position.x, 0.0f, transform.position.z);
         Vector3 targetXZPos = new Vector3(hit.x, 0.0f, hit.z);
 
         // rotate the object to face the target
         transform.LookAt(targetXZPos);
 
         // shorthands for the formula
         float R = Vector3.Distance(projectileXZPos, targetXZPos);
         float G = Physics.gravity.y;
         float tanAlpha = Mathf.Tan(LaunchAngle * Mathf.Deg2Rad);
         float H = hit.y - transform.position.y;
         // calculate the local space components of the velocity 
         // required to land the projectile on the target object 
         float Vz = Mathf.Sqrt(G * R * R / (2.0f * (H - R * tanAlpha)));
         
         float Vy = tanAlpha * Vz;
 
         // create the velocity vector in local space and get it in global space
         Vector3 localVelocity = new Vector3(0f, Vy, Vz);
         Vector3 globalVelocity = transform.TransformDirection(localVelocity);
 
         // launch the object by setting its initial velocity and flipping its state
         rigid.velocity = globalVelocity;
         
     }
 
     private void OnTriggerEnter(Collider other)
     {
         if(other.tag == "Mark")
         {
             Destroy(other.gameObject);
             Destroy(this.gameObject);
         }
     }
 }

Answer 1

A lot of code can be made a bit better

  Instantiate(Mark, new Vector3(hit.point.x, hit.point.y+0.01f, hit.point.z), Quaternion.Euler(new Vector3(90,0,0)));

can be

 Instantiate(Mark, hit.point + Vector3.up * 0.01f, Quaternion.Euler(-90, 0, 0));

You should also avoid using a rigidbody's transform, so

 transform.rotation = Quaternion.LookRotation(rigid.velocity) * initialRotation;

should be

 rigid.rotation = Quaternion.LookRotation(rigid.velocity) * initialRotation;

To avoid using FindObject, you can call Launch from the Mortar script:

 GameObject bulletGO = Instantiate(Bullet, Canon.transform.position, Quaternion.Euler(new Vector3(90, 0, 90)));
 bulletGO.GetComponent<Bullet>().Launch(hit.point + Vector3.up * 0.01f, LaunchAngle);

It's good to keep data transfer in one direction, usually from weapon to projectile

Now your math can be made a bit simpler. We know the shot direction, which can be calculated like so

 Vector3 xzdir = (hit - rigid.position);
 xzdir.y = 0f;

 Vector3 shotDir = Quaternion.LookRotation(xzDir) * Quaternion.AngleAxis(LaunchAngle, Vector3.right) * Vector3.forward;

But the velocity is a bit more complicated, I decided to figure out my own equation for fun. We know

 rigidbody.positon + shotDir * vel * time + Physics.gravity * time * time / 2 == hit;

or

 shotDir * vel * time - Physics.gravity * time * time / 2 == deltaPos

We can extract two equations:

 shotDir.y * vel * time + Physics.gravity.y * time * time / 2 == deltaPos.y
 shotDir.x * vel * time == deltaPos.x

Using the second, we can find the confusing

 vel * time == deltaPos.x / shotDir.x

And if we use it the first equation, we get

 shotDir.y * deltaPos.x / shotDir.x + Physics.gravity.y * time * time / 2 == deltaPos.y

After further refining, we get a negative a positive solution for time (we discard the negative)

 float time = Mathf.Sqrt((shotDir.y * deltaPos.x / shotDir.x - deltaPos.y) / -Physics.gravity.y * 2);

And by reversing the second equation we get:

  float vel = deltaPos.x / shotDir.x / time;

And thus the code

 void Launch(Vector3 hit, float LaunchAngle)
 {
         Vector3 deltaPos = hit - rigid.position;
         Vector3 xzDelta = deltaPos;
         xzDelta.y = 0f;
         Vector3 shotDir = Quaternion.LookRotation(xzDelta) * Quaternion.AngleAxis(-LaunchAngle, Vector3.right) * Vector3.forward;
 
         float time = Mathf.Sqrt((shotDir.y * deltaPos.x / shotDir.x - deltaPos.y) / -Physics.gravity.y * 2);
         float vel = deltaPos.x / shotDir.x / time;
 
         if (float.IsNaN(vel))
         {
             Debug.Log("Impossible Trajectory")
         }
         rigid.velocity = vel * shotDir;
 }

Calculate mortar parabolic trajectory knowing the shot angle but not velocity

1 Reply

Your answer

Follow this Question

Related Questions