Zielorientierte Aktionsplanung mit mehreren Agenten

Ich stecke ein bisschen fest:

Ich habe eine KI mit GOAP implementiert (Zielorientierte Aktionsplanung, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf) ) für ein Simulationsspiel . Das funktioniert gut.

Jetzt möchte ich, dass die Agenten zusammenarbeiten können (z. B. gemeinsam Aktionen ausführen). Was ist in diesem Fall das beste AI-Design, das die GoapActions lose Couplet halten?

Sollten sie zusammen planen? (Was ist in diesem Fall der "Weltstaat"?) Oder sollten sie ihre Pläne teilen? eine Art Nachrichtensystem?

Beispiel
Agent1: Worldstate Agent 1: isLonely = true
Ziel Agent1: isLonely = false

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Plan Agent2: GetAxe -> ChopWood -> BringWoodToSupply

Wie bekomme ich diese Konstellation?

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

Oder wenn sie sprechen und einer der Agenten unterbrochen wird (z. B. durch einen angreifenden Feind), muss der andere Agent wissen, dass seine TalktoAgent2-Aktion beendet wurde.

Ich empfehle dringend, keine Aciton-Planung zu verwenden. Es ist sehr schwierig zu erweitern, zu entwerfen und Fehler zu beheben. Wir haben die Aufgabenplanung in DwarfCorp sehr früh aufgegeben weil sie zu komplex ist, um schnell neue Verhaltensweisen zu entwickeln. Wenn Sie dies jedoch tun müssen, müssen Sie dies als Planungsproblem für mehrere Agenten interpretieren.

Ein Weg, dies zu erreichen, ist die heirarchische Planung . Sie müssen einen Meta-Agenten erstellen , um Ihren untergeordneten Agenten Unterprobleme zuzuweisen. Der Meta-Agent oder "Task-Planer" versucht, ein Gesamtziel zu erreichen, und verwendet die von ihm kontrollierten Sub-Agenten als Meta-Aktionen.

Zum Beispiel könnte Ihr Meta-Agent das Ziel "Ein Haus bauen" haben. Es hat die Aktion "Holz sammeln", die als Eingabe einen Agenten und einen Ort zum Sammeln des Holzes verwendet. Es kann dann verschiedene Agenten verschiedenen Unteraufgaben zuweisen. Vielleicht geht ein Agent und sammelt das Holz, während der andere das gesammelte Holz verwendet, um das Haus zu bauen.

Es kann andere Ziele haben, wie "Einsamkeit reduzieren". Diese Ziele müssen nach Priorität geordnet werden, damit sie sich gegenseitig zusammenfassen können. Der zentrale Aufgabenplaner entscheidet zu einem bestimmten Zeitpunkt über die wichtigsten Ziele und weist ihnen Agenten anhand verschiedener Unterziele zu. Es sucht nach inaktiven Agenten, findet heraus, welche Unteraufgabe dem Agenten am besten zuzuweisen ist, und legt sie dann auf den Fall.

Ich denke, goap ist eine neue Version von Zustandsautomaten, die versucht, Zustände einzurichten, um ein Ziel zu erreichen. Sie müssen nur definieren, welche Szenarien in jedem Zustand auftreten.

Zum Beispiel haben Sie einige KI-Feinde, die Patrouillen-, Verfolgungs-, Such- und Angriffszustände haben. Sie können einfach einen Code schreiben, der, wenn einer der Feinde den Spieler gefunden hat, alle den Zustand in Angriffs- oder Verfolgungszustand ändert. In einem anderen Beispiel haben Sie ein Szenario, in dem im Angriffszustand ein oder zwei Feinde den Spieler flankieren und andere ihn unterstützen müssen. Jeder Feind prüft also, ob ein Feind flankiert oder eine andere Bedingung vorliegt (Sie können einfach eine Bool-Variable dafür definieren). Wenn dies nicht der Fall ist, gehen Sie zur Flanke, sonst gehen Sie zur Unterstützung. Alles hängt von den von Ihnen definierten Szenarien und Regeln ab.

Ich weiß nicht, ob Sie versuchen, eine lose Kopplung zwischen Agenten zu erreichen, da dies sowieso das war, was ich interpretiert habe. Das wäre der beste Ansatz. Sie sollten nach dem Beobachtermuster suchen , einem Ereignisabonnementsystem, das Abhängigkeiten vermeidet. Sie könnten es so verwenden (ich werde versuchen, sprachunabhängig zu sein):

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();
    }
}

Es liegt also an Ihnen, die Logik zum Abonnieren / Abbestellen festzulegen, wenn der Agent beschäftigt ist und keine Firma bilden kann.

Wenn Sie C # verwenden, sollten Sie Ereignisdelegierte aktivieren , die das oben genannte Muster bereits implementieren.

Hoffe, es gibt Ihnen zumindest eine Idee.

Sie müssten A: Schritt und Bewertung verwenden und B: Sie müssen mehrere haben Ziele mit Prioritäten haben.

Wenn Agent1 X will und Agent2 niemals X will, können sie nicht zusammenarbeiten . Das kann in keinem System passieren . Um dies zu beheben, müssen mehrere Ziele verfolgt werden. Sie können Ziele sogar danach priorisieren, wie weit man sie erreicht hat und wie einfach andere Ziele erreicht werden können . In Ihrem Szenario ohne Prioritäten lautet dies:

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

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Ziel: hasWood = true

Ziel: isLonely = false

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

Agent1 bat dann Agent2 fortlaufend, zu sprechen, bis er eine Bestätigung erhielt, was nach Abschluss seiner ersten Aufgabe geschehen würde.

Schritte in Richtung jedes Ziels müssen bewertet werden, und obwohl dies mit nur einem Ziel keine große Sache ist, können mehr Ziele Ihr Spiel möglicherweise verlangsamen.

Um dieses Problem zu lösen, benötigen Sie Bäume, die aus der Ausführung von Aufgaben generiert wurden, bei denen möglicherweise mehrere Ziele gleichzeitig überprüft werden, um die Verarbeitung von Entscheidungen zu beschleunigen.