Quel type de comportement ou de logique de pilotage puis-je utiliser pour que les mobiles en entourent un autre?

J'utilise la recherche de chemin dans mon jeu pour diriger une foule vers un autre joueur (pour les poursuivre). Cela fonctionne pour les faire dépasser le joueur, mais je veux qu'ils s'arrêtent légèrement avant leur destination (donc choisir l'avant-dernier nœud fonctionne très bien).

Cependant, lorsque plusieurs mobs poursuivent le mobile, ils "s'empilent parfois les uns sur les autres". Quelle est la meilleure façon d'éviter cela? Je ne veux pas traiter les foules comme opaques et bloquées (parce qu'elles ne le sont pas, vous pouvez les traverser) mais je veux que les foules aient un certain sens de la structure.

Exemple:

Imaginez que chaque serpent se guide vers moi et devrait entourer "Setsuna". Remarquez comment les deux serpents ont choisi de me tailler? Ce n'est pas une exigence stricte; même être légèrement décalé est correct. Mais ils devraient «entourer» Setsuna.

Donnez à vos agents une faible "charge électrostatique" pour les faire se repousser, selon la loi de Coulomb .

En supposant pour simplifier que les mobs devraient se repousser avec une force équivalente, il devrait suffire d'appliquer une force entre chaque paire de mobs avec une magnitude some_constant / distance^2, où se some_constanttrouve une force de répulsion configurable et distancela distance qui les sépare.

Les forces de répulsion tombent alors au carré de la distance.

Nature of Code en a un excellent exemple (avec une démonstration en direct) ici . Cela ressemble à ceci:

Faire correspondre chaque élément les uns aux autres est une opération quadratique ( O(n^2)). Si vous avez vraiment beaucoup d' agents, vous souhaiterez peut-être optimiser les calculs de force avec une approximation de Barnes-Hut , ce qui le ramène à log-linear ( O(n log n)) mais nécessite un quadtree .

Mon approche est similaire à celle de @ Anko, mais basée sur le travail de Millington et Funge de Artificial Intelligence for Games .

Voici à quoi ressemblerait un comportement de séparation, mais vous devez tenir compte du fait que cette vitesse doit être calculée avec la vitesse de l'agent dans sa fonction de mise à jour.

public Vector3 GetSeparationVel (float threshold, float decayCoefficient)
{
    threshold = threshold * threshold;
    Vector3 separationVelocity = Vector3.Zero;
    for (int i = 0; i < enemies.Length; i++) {
        if (enemies[i] == this) {
            continue;
        }
        Vector3 direction = this.position - enemies[i].position;
        float distance = direction.LengthSquared();
        float strenght = 0.0f;
        if (distance < (threshold)) {
            strenght = Math.Min(decayCoefficient / distance, this.maxAccel);
            direction.Normalize();
            separationVelocity += strenght * direction;
        }
    }
}