Implémentation d'une navigation proportionnelle simple pour un missile à tête chercheuse

J'essaie de mettre en œuvre la forme de navigation proportionnelle la plus simple possible , c'est-à-dire que le missile tourne dans la direction dans laquelle son relèvement vers la cible change, et une fois que son relèvement vers la cible ne change pas, il est sur une trajectoire d'interception.

Donc, j'ai un missile 2D se déplaçant à une vitesse constante dans la direction à laquelle il fait face, qui peut tourner à une vitesse constante, et à chaque intervalle, je mets à jour le missile avec quelque chose comme:

Position += VectorProduct (Direction * Speed * TimePassed)

PreviousTargetBearing = TargetBearing
TargetBearing = AngleBetween(TargetPosition, Position)
TargetBearingDelta = TargetBearing - PreviousTargetBearing

If TargetBearingDelta > 0: MissileDirection += TurnRate * TimePassed
If TargetBearingDelta < 0: MissileDirection -= TurnRate * TimePassed

Le problème est que le missile oscille toujours autour de sa direction de lancement, car dès que le missile tourne la première fois, cela inverse le signe de TargetBearingDelta, le faisant ensuite tourner dans la direction opposée, etc.

Quelle est la manière la plus simple de résoudre ce problème? Je suis sûr que je manque quelque chose de simple.

Question StackOverflow connexe: Comment créer un «missile d'interception» pour un jeu?

Pour réitérer, je m'intéresse spécifiquement à la mise en œuvre de l' algorithme de navigation proportionnelle , et non aux algorithmes de référencement en général.

Mise à jour: je suppose que la réponse évidente est de ne pas vérifier le relèvement et d' ajuster le cap à chaque virage, mais d'alterner entre les deux. Je vais essayer ça.

Étape 1) Calculez le temps à viser si vous allez en ligne droite

Étape 2) Calculez où sera la cible avec son cap actuel à ce moment-là.

Étape 3) Réglez le cap du missile à cet endroit.

Étape 4) Mettez à jour si nécessaire

Au début, ce ne sera pas très précis, mais à mesure que la distance se rapproche, elle deviendra plus précise; au fur et à mesure que le temps de voyage passe à zéro, la cible du missile se rapproche de la cible.

Donnez-lui un tourbillon. C'est assez simple à mettre en œuvre. Faites-moi savoir comment cela fonctionne parce que je veux mettre des missiles à tête chercheuse dans mon jeu et ce fut ma première pensée.

Et pour cette partie:

If TargetBearingDelta > 0: MissileDirection += TurnRate * TimePassed
If TargetBearingDelta < 0: MissileDirection -= TurnRate * TimePassed

J'aurais plutôt deux variables missileDirection. Un pour ce qu'il est vraiment et un pour ce qu'il devrait être à l'avenir. Ensuite, le mouvement du missile se dirige vers le cap souhaité par sa vitesse de rotation. Si le cap souhaité est plus grand que le cap actuel, ajoutez le taux de virage. S'il est plus petit, soustrayez. Si vous passez, mettez-le à égalité.

Comme le dit Nailer, vous pouvez limiter le changement de mouvement d'une manière ou d'une autre.

Découvrez PID , une belle façon de faire avancer les choses à une certaine «valeur» rapidement, mais sans le dépasser, cela pourrait vous donner quelques idées.

Vous pouvez également consulter cette question , un peu plus bas est une explication de la «courbe de chien», un algorithme de référencement très précis utilisé par les chiens.

À mon avis, il y aurait une autre méthode impliquant deux vecteurs, l'un pour la direction d'un missile à frapper, et un autre pour lui-même lerping (ou dire la transition de sa direction pour correspondre au premier vecteur).

De cette façon, nous pouvons produire un temps de latence permettant à un missile de changer en douceur sa direction en fonction d'un changement dans un premier vecteur. Je crois que cela éliminera le problème en "signe" d'opération mathématique.

PS. Le point principal est que nous lerpons le propre vecteur d'un missile à un vecteur directionnel (pour frapper) en ce qui concerne un petit retard dans le temps.

La navigation proportionnelle est simple à mettre en œuvre dans les jeux.

Un exemple d'implémentation dans le jeu est:

Accélération requise = LOS * LOS_Rate * NC + APN_bias

LOS = Vector3 (TargetPosition) - Vector3 (MissilePosition)

NC = multiplicateur de constante de navigation (en fonction de la fréquence d'images)

APN_bias = LOS_Rate / delta_T * (NC / 2)

LOS_Rate = LOS Rotation Rate est le taux angulaire de changement de ligne de visée entre le missile et la cible. Ceci est mesuré en enregistrant à la fois le missile et le vecteur cible positionne chaque image à delta_T, et en soustrayant chacun pour obtenir la différence. Delta_T est la référence temporelle (c'est-à-dire la fréquence d'images) à laquelle votre missile à tête cherchée fonctionne en jeu.

Pour obtenir LOS_Rate, demandez simplement à votre boucle de guidage de missile de faire ce qui suit à chaque trame (delta_T):

// New LOS rate

LOS_Delta = Vector3( LOS ) - Vector3( LOS_previous_frame ) 

LOS_Rate = LOS_Delta.Vector3Length()

// Update LOS before we finish

LOS_previous_frame = Vector3( LOS )

Vous pouvez trouver plus d'informations sur la façon dont nous avons implémenté le jeu PN pour World in Conflict aux URL suivantes ci-dessous. J'espère que vous les trouverez utiles.

http://www.moddb.com/mods/wicmw/features/flint-lead-pursuit-guidance-principles

http://download.wicmwmod.com/Fun_Mod/presentations/FLINT%20Jul%202012.pdf

-blahdy

Ne pouvez-vous pas simplement plafonner le taux de rotation afin qu'il ne puisse jamais dépasser TargetBearing en une seule image?

Si un tour devait faire passer le missile au-delà de son cap cible, il vous suffit de définir le nouveau cap égal au cap cible.

Cela a-t-il du sens?