Comment puis-je calculer l'angle et la bonne direction de virage entre deux vecteurs 2D?

Je travaille sur un mouvement AI où il n'y a pas d'obstacles et le mouvement est limité au plan XY. Je calcule deux vecteurs, v , la direction opposée du navire 1 et w , le vecteur pointant de la position du navire 1 au navire 2.

Je calcule ensuite l'angle entre ces deux vecteurs en utilisant la formule

arccos((v · w) / (|v| · |w|))

Le problème que j'ai, c'est qu'il arccosne renvoie que des valeurs comprises entre 0 ° et 180 °. Cela rend impossible de déterminer si je dois tourner à gauche ou à droite pour faire face à l'autre navire.

Y a-t-il une meilleure manière de faire cela?

Il est beaucoup plus rapide d'utiliser un produit croisé 2D. Aucune fonction trigonométrique coûteuse n'est impliquée.

b2Vec2 target( ... );
b2Vec2 heading( ... );

float cross = b2Cross( target, heading );

if( cross == -0.0f )
   // turn around

if( cross == 0.0f )
  // already traveling the right direction

if( cross < 0.0f)
  // turn left

if( cross > 0.0f)
  // turn right

Si vous avez toujours besoin des angles réels, je recommande d'utiliser atan2. atan2vous donnera l'angle absolu de n'importe quel vecteur. Pour obtenir l'angle relatif entre l'un et les vecteurs, calculez leurs angles absolus et utilisez une soustraction simple.

b2Vec2 A(...);
b2Vec2 B(...);

float angle_A = std::atan2(A.y,A.x);
float angle_B = B.GetAngle(); // Box2D already figured this out for you.

float angle_from_A_to_B = angle_B-angle_A;
float angle_from_B_to_A = angle_A-angle_B;

Utilisez l'arcsin du produit croisé 2D (c'est-à-dire la composante z du vecteur du produit croisé). Cela vous donnera -90 à 90, ce qui vous permettra de savoir si vous devez aller à gauche ou à droite.

Attention car la croix A n'est pas la même chose que la croix A.

Une autre stratégie (mais probablement pas aussi simple) consiste à calculer le "cap" des deux vecteurs en utilisant atan2, puis à déterminer si A pointant vers X degrés doit aller à gauche ou à droite pour aller à B pointant à y degrés.

Utilisez des vecteurs pour rediriger le navire. C'est ainsi que fonctionnent les "comportements de direction" - vous n'avez jamais besoin de calculer l'angle, utilisez simplement les vecteurs dont vous disposez. C'est beaucoup moins cher sur le plan informatique.

Le vecteur w(vecteur du navire 1 au navire 2) contient toutes les informations dont vous avez besoin. Modifiez le vecteur de vitesse du navire 1 ou le vecteur d'accélération du navire 1 (ou même le vecteur de cap directement) à l'aide d'une version pondérée de w.

L' amplitude de la distance par rapport au navire 1 (à quel point v ne correspond pas à w) peut être trouvée en utilisant ( 1 - dot(v,w))

• ( dot(v,w)est maximisé quand vet waligné exactement)
• ( 1 - dot(v,w)) Donne 0 quand vet wsont complètement alignés, à condition vet wsont normalisés)

Il existe un moyen simple de trouver l'angle absolu d'un vecteur à travers une géométrie normale.

par exemple le vecteur V = 2i - 3j;

valeur absolue du coefficient x = 2;

valeur absolue du coefficient y = 3;

angle = atan (2/3); [l'angle sera compris entre 0 et 90]

Basé sur l'angle du quadrant sera modifié.

si (coefficient x <0 et coefficient y> 0) alors angle = angle 180;

si (coefficient x <0 et coefficient y <0) alors angle = 180 + angle;

si (coefficient x> 0 et coefficient y <0) alors angle = 360 °;

si (coefficient x> 0 et coefficient y> 0) alors angle = angle;

après avoir trouvé l'angle des premier et deuxième vecteurs, il suffit de soustraire le premier angle de vecteur du deuxième vecteur. Ensuite, vous obtiendrez un angle absolu entre deux vecteurs.

Je devrais peut-être poster une question légèrement différente et y répondre moi-même; c'est la question la plus proche que j'ai pu trouver à celle que j'avais.

Je fais du travail 2D dans le canevas html, où j'ai des angles de rotation en radians plutôt qu'en vecteurs. J'avais besoin de «l'angle de virage» (ta) pour passer du «cap actuel» (h) au «cap cible» (t).

Voici ma solution:

var ta = t - h,
    ata = Math.abs(ta)
;
if (ta > Math.PI) ta = (ta / ata) * (Math.PI - ata)
return ta;