Planification des actions orientée vers les objectifs avec plusieurs agents

Je suis un peu coincé:

J'ai implémenté une IA avec GOAP (Goal Based Action Planning, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf ) pour un jeu de simulation. Ça marche bien.

Maintenant, je veux que les agents puissent coopérer (par exemple en faisant des actions ensemble). Quel est dans ce cas le meilleur AI-Design que les GoapActions gardent distique lâche?

Doivent-ils planifier ensemble? (quel est dans ce cas l '"état mondial"?) Ou devraient-ils partager leurs plans? une sorte de système de messagerie?

Exemple
Agent1: Worldstate Agent 1: isLonely = true
Goal Agent1: isLonely = false

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

Agent2 Worldstate Agent 2: hasWood = false
Goal hasWood = true

Plan Agent2: GetAxe -> ChopWood -> BringWoodToSupply

Comment puis-je obtenir cette constellation?

Plan Agent1: TalkToAgent2
Plan Agent2: TalkToAgent1 -> GetAxe -> ChopWood -> BringWoodToSupply

Ou s'ils parlent et que l'un des agents est interrompu (par exemple par un ennemi attaquant), l'autre agent doit savoir que son action TalktoAgent2 est terminée.

Je vous recommande fortement de ne pas utiliser la planification d'aciton. Il est très difficile d'étendre, de concevoir et de corriger les bogues. Nous avons abandonné la planification des tâches très tôt dans DwarfCorp car il est trop complexe de concevoir rapidement de nouveaux comportements. Mais si vous le devez, vous devez l'interpréter comme un problème de planification multi-agents.

Une façon d'y parvenir est la planification hiérarchique . Vous devez créer un méta-agent pour attribuer des sous-problèmes à vos agents de niveau inférieur. Le méta-agent ou "Task Planner" essaie d'atteindre un objectif global et utilise les sous-agents sous son contrôle comme méta-actions.

Par exemple, votre méta-agent peut avoir un objectif "Construire une maison". Il a pour action "ramasser du bois" qui prend en entrée un agent et un emplacement pour ramasser le bois. Il peut ensuite affecter différents agents à différentes sous-tâches. Peut-être qu'un agent va chercher le bois tandis que l'autre utilise le bois ramassé pour construire la maison.

Il peut avoir d'autres objectifs, comme "réduire la solitude". Ces objectifs doivent être classés par priorité afin qu'ils puissent se subsumer mutuellement. Le planificateur de tâches central décide à tout moment quels sont les objectifs les plus importants et leur affecte des agents en utilisant différents sous-objectifs. Il recherche les agents inactifs, détermine quelle est la meilleure sous-tâche à attribuer à l'agent, puis les met sur le boîtier.

Je pense que goap est une nouvelle version des machines à états qui essaie de configurer des états pour atteindre un objectif. il vous suffit de définir les scénarios qui se produisent dans chaque état.

Par exemple, certains ennemis de l'IA ont des états de patrouille, de poursuite, de recherche et d'attaque.Vous pouvez simplement écrire un code qui, lorsque l'un des ennemis a trouvé un joueur, change d'état pour attaquer ou poursuivre. autre exemple, vous avez un scénario selon lequel en état d'attaque, un ou 2 ennemis doivent flanquer le joueur et les autres doivent les soutenir. donc chaque ennemi vérifie s'il y a un flanc ennemi ou une autre condition (vous pouvez simplement définir une variable booléenne pour cela). s'il n'y en a pas, allez sur le flanc sinon allez sur le support. tout dépend des scénarios et des règles que vous définissez.

Je ne sais pas si vous essayez de réaliser un couplage lâche entre les agents, car c'est ce que j'ai interprété, de toute façon, ce serait la meilleure approche, vous devriez vérifier le modèle d'observateur , qui est un système d'abonnement aux événements qui évite les dépendances. Vous pouvez l'utiliser comme ça (je vais essayer d'être indépendant de la langue):

public interface ILonelyObserver
{
    void ItsLonely();
}

public class Agent implements ILonelyObserver
{
    private static List<ILonelyObserver> observers;
    private bool busy;

    public static void IAmLonely()
    {
        for(int i = 0; i < observers.Count; i++)
        {
            observers.ItsLonely();
        }
    }

    public static void Subscribe()
    {
        if(observers == null) observers = new List<IObserver>();
        observers.Add(this);
    }

    public static void Unsubscribe()
    {
        if(observers != null) observers.Remove(this);
    }

    public void ItsLonely()
    {
        /// Do what it takes to make company...
    }

    public Agent()
    {
        Subscribe();
    }

    ~Agent()
    {
        Unsubscribe();
    }
}

Il vous appartiendrait donc de faire la logique pour vous abonner / vous désinscrire lorsque l'agent est occupé et ne peut pas faire société.

Si vous deviez utiliser C #, vous devriez vérifier les délégués d'événement , qui implémentent déjà le modèle susmentionné.

J'espère que cela vous donne au moins une idée.

Vous devez A: utiliser l'étape et évaluer et B: vous devez avoir plusieurs objectifs avec des priorités.

Si l'agent1 veut X et l'agent2 ne veut jamais X, ils ne peuvent pas travailler ensemble . Cela ne peut se produire dans aucun système . Pour résoudre ce problème, vous devrez suivre plusieurs objectifs. Vous pouvez même hiérarchiser les objectifs en fonction de la mesure dans laquelle vous avez progressé vers eux et de la facilité avec laquelle d'autres objectifs peuvent être atteints . Dans votre scénario sans priorités, cela devient:

Agent1: Worldstate Agent 1: isLonely = true Objectif: isLonely = false

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

Agent2 Worldstate Agent 2: hasWood = false, isLonely = true

Objectif: hasWood = true

Objectif: isLonely = false

Plan Agent2: GetAxe -> ChopWood -> BringWoodToSupply, AskAgent1ToTalk -> TalkToAgent1

L'Agent1 demanderait alors continuellement à l'Agent2 de parler jusqu'à ce qu'il obtienne une affirmative, ce qui se produirait après avoir terminé sa première tâche.

Prendre des mesures vers chaque objectif devra être évalué, et bien qu'avec un seul objectif ce ne soit pas un problème, plus d'objectifs pourraient potentiellement ralentir votre jeu.

Pour résoudre ce problème, vous avez besoin d' arbres générés par l'accomplissement de tâches qui peuvent masquer la vérification de plusieurs objectifs à la fois, accélérant ainsi le traitement des décisions.