Comment lancer un GameObject sur une cible si on me donne tout sauf son angle de lancement?

J'essaie de lancer un objet sur une cible, étant donné sa position, sa position cible, la vitesse de lancement et la gravité. Je suis cette formule de Wikipedia :

J'ai simplifié le code au mieux de mes capacités, mais je ne parviens toujours pas à atteindre la cible de manière cohérente. Je ne considère que la trajectoire plus haute, des deux disponibles à partir du choix + - dans la formule.

Est-ce que quelqu'un sait ce que je fais mal?

using UnityEngine;

public class Launcher : MonoBehaviour
{
    public float speed = 10.0f;

    void Start()
    {
        Launch(GameObject.Find("Target").transform);
    }

    public void Launch(Transform target)
    {
        float angle = GetAngle(transform.position, target.position, speed, -Physics2D.gravity.y);
        var forceToAdd = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * speed;
        GetComponent<Rigidbody2D>().AddForce(forceToAdd, ForceMode2D.Impulse);
    }

    private float GetAngle(Vector2 origin, Vector2 destination, float speed, float gravity)
    {
        float angle = 0.0f;

        //Labeling variables to match formula
        float x = Mathf.Abs(destination.x - origin.x);
        float y = Mathf.Abs(destination.y - origin.y);
        float v = speed;
        float g = gravity;

        //Formula seen above
        float valueToBeSquareRooted = Mathf.Pow(v, 4) - g * (g * Mathf.Pow(x, 2) + 2 * y * Mathf.Pow(v, 2));
        if (valueToBeSquareRooted >= 0)
        {
            angle = Mathf.Atan((Mathf.Pow(v, 2) + Mathf.Sqrt(valueToBeSquareRooted)) / g * x);
        }
        else
        {
            //Destination is out of range
        }

        return angle;
    }
}

Je suis un peu sceptique quant à l'utilisation atanici, car le rapport de tangence se déclenche à l'infini sous certains angles, et peut conduire à des erreurs numériques (même en dehors de l'indéfini / diviser par zéro pour la prise de vue droite / haute).

En utilisant les formules élaborées dans cette réponse , nous pouvons paramétrer cela en termes de temps (initialement inconnu) pour l'impact, Ten utilisant l'initiale speeddu projectile:

// assuming x, y are the horizontal & vertical offsets from source to target,
// and g is the (positive) gravitational acceleration downwards
// and speed is the (maximum) launch speed of the projectile...

b = speed*speed - y * g
discriminant = b*b - g*g * (x*x + y*y)

if(discriminant < 0)
  return CANNOT_REACH_TARGET; // Out of range, need higher shot velocity.

discRoot = sqrt(discriminant);

// Impact time for the most direct shot that hits.
T_min = sqrt((b - discRoot) * 2 / (g * g));

// Impact time for the highest shot that hits.
T_max = sqrt((b + discRoot) * 2 / (g * g));

Vous pouvez choisir T_min ou T_max (ou quelque chose entre les deux si vous souhaitez tirer avec des vitesses allant jusqu'à mais pas nécessairement égales à un certain maximum)

( T_minest la trajectoire rouge peu profonde en bas, et T_maxest la grande verte. Toute trajectoire entre eux est viable à une vitesse réalisable. Lorsque les deux fusionnent dans la trajectoire jaune, l'objet est hors de portée.)

Maintenant que nous avons calculé une valeur pour T, le reste est simple:

vx = x/T;
vy = y/T + T*g/2;

velocity = (vx, vy);

Vous pouvez utiliser cette vitesse directement (elle a une longueur égale à speedpar construction), ou si vous avez vraiment besoin de connaître l'angle, vous pouvez utiliseratan2(vy, vx)

Edit: pour rendre cela applicable à plus de cas, voici une version 3D:

Vector3 toTarget = target.position - transform.position;

// Set up the terms we need to solve the quadratic equations.
float gSquared = Physics.gravity.sqrMagnitude;
float b = speed * speed + Vector3.Dot(toTarget, Physics.gravity);    
float discriminant = b * b - gSquared * toTarget.sqrMagnitude;

// Check whether the target is reachable at max speed or less.
if(discriminant < 0) {
    // Target is too far away to hit at this speed.
    // Abort, or fire at max speed in its general direction?
}

float discRoot = Mathf.Sqrt(discriminant);

// Highest shot with the given max speed:
float T_max = Mathf.Sqrt((b + discRoot) * 2f / gSquared);

// Most direct shot with the given max speed:
float T_min = Mathf.Sqrt((b - discRoot) * 2f / gSquared);

// Lowest-speed arc available:
float T_lowEnergy = Mathf.Sqrt(Mathf.Sqrt(toTarget.sqrMagnitude * 4f/gSquared));

float T = // choose T_max, T_min, or some T in-between like T_lowEnergy

// Convert from time-to-hit to a launch velocity:
Vector3 velocity = toTarget / T - Physics.gravity * T / 2f;

// Apply the calculated velocity (do not use force, acceleration, or impulse modes)
projectileBody.AddForce(velocity, ForceMode.VelocityChange);

Grâce à DMGregory, j'ai maintenant un script d'extension C # qui peut être utilisé pour cela. La version la plus récente peut être trouvée sur GitHub .

using UnityEngine;

public static class Rigidbody2DExtensions
{
    /// <summary>
    /// Applies the force to the Rigidbody2D such that it will land, if unobstructed, at the target position.  The arch [0, 1] determines the percent of arch to provide between the minimum and maximum arch.  If target is out of range, it will fail to launch and return false; otherwise, it will launch and return true.  This only takes the Y gravity into account, and X gravity will not affect the trajectory.
    /// </summary>
    public static bool SetTrajectory(this Rigidbody2D rigidbody2D, Vector2 target, float force, float arch = 0.5f)
    {
        Mathf.Clamp(arch, 0, 1);
        var origin = rigidbody2D.position;
        float x = target.x - origin.x;
        float y = target.y - origin.y;
        float gravity = -Physics2D.gravity.y;
        float b = force * force - y * gravity;
        float discriminant = b * b - gravity * gravity * (x * x + y * y);
        if (discriminant < 0)
        {
            return false;
        }
        float discriminantSquareRoot = Mathf.Sqrt(discriminant);
        float minTime = Mathf.Sqrt((b - discriminantSquareRoot) * 2) / Mathf.Abs(gravity);
        float maxTime = Mathf.Sqrt((b + discriminantSquareRoot) * 2) / Mathf.Abs(gravity);
        float time = (maxTime - minTime) * arch + minTime;
        float vx = x / time;
        float vy = y / time + time * gravity / 2;
        var trajectory = new Vector2(vx, vy);
        rigidbody2D.AddForce(trajectory, ForceMode2D.Impulse);
        return true;
    }
}

Personnellement, je ne prendrais même pas la peine d'utiliser n'importe quel type de formule compliquée.

GetComponent<Rigidbody2D>.AddForce((target.transform.position - transform.position) * someSortOfMultiplier());

Il tire simplement dans la direction de la cible. Et si vous souhaitez compenser la gravité, la distance, etc., définissez someSortOfMultiplier()une fonction qui renvoie un flotteur qui compensera une fois multiplié avec le code ci-dessus.