Pianificazione dell'azione orientata agli obiettivi con più agenti

Sono un po 'bloccato:

Ho implementato un'intelligenza artificiale con GOAP (Goal oriented Action Planning, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf ) per un gioco di simulazione. Funziona benissimo.

Ora voglio che gli agenti possano collaborare (ad es. Facendo azioni insieme). Qual è in questo caso il miglior design AI che le GoapActions mantengano libero il distico?

Dovrebbero pianificare insieme? (che cos'è in questo caso lo "stato del mondo"?) O dovrebbero condividere i loro piani? una specie di sistema di messaggi?

Esempio
Agent1: Worldstate Agent 1: isLonely = true
Obiettivo Agent1: isLonely = false

Pianifica Agent1: AskAgent2ToTalk -> TalkToAgent2

Agent2 Worldstate Agent 2: hasWood = false L'
obiettivo hasWood = true

Pianifica Agent2: GetAxe -> ChopWood -> BringWoodToSupply

Come ottengo questa costellazione?

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

O se stanno parlando e uno degli agenti viene interrotto (ad es. Da un nemico attaccante) l'altro agente deve sapere che la sua Azione TalktoAgent2 è terminata.

Consiglio vivamente di non utilizzare la pianificazione aciton. È molto difficile estendere, progettare e correggere bug. Abbiamo abbandonato la pianificazione delle attività molto presto in DwarfCorp perché è troppo complesso per progettare rapidamente nuovi comportamenti. Ma se è necessario, è necessario interpretarlo come un problema di pianificazione con più agenti.

Un modo per raggiungere questo obiettivo è attraverso la pianificazione gerarchica . Devi creare un meta-agente per assegnare i sottoproblemi ai tuoi agenti di livello inferiore. Il meta-agente, o "Task Planner", cerca di raggiungere un obiettivo generale e utilizza i sub-agenti sotto il suo controllo come meta-azioni.

Ad esempio, il tuo meta-agente potrebbe avere un obiettivo "Costruisci una casa". Ha l'azione "raccogliere legno" che prende come input un agente e un luogo in cui raccogliere il legno. Può quindi assegnare agenti diversi a diverse attività secondarie. Forse un agente va e raccoglie il legno mentre l'altro usa il legno raccolto per costruire la casa.

Potrebbe avere altri obiettivi, come "ridurre la solitudine". Tali obiettivi devono essere ordinati per priorità in modo che possano sussistere a vicenda. Il pianificatore di attività centrale decide in qualsiasi momento quali sono gli obiettivi più importanti e assegna loro gli agenti utilizzando diversi sotto-argomenti. Cerca agenti inattivi, scopre quale sia la sottoattività migliore da assegnare all'agente e quindi li inserisce nel caso.

Penso che goap sia una nuova versione di macchine a stati che tenta di impostare gli stati per raggiungere un obiettivo. devi solo definire quali scenari stanno accadendo in ogni stato.

ad esempio, hai alcuni nemici dell'IA che hanno stati di pattuglia, inseguimento, ricerca e attacco. Puoi semplicemente scrivere un codice che quando uno dei nemici ha trovato giocatore, tutti cambiano stato per attaccare o inseguire lo stato. altro esempio hai uno scenario in cui uno o 2 nemici devono affiancare il giocatore e altri devono sostenerlo. quindi ogni nemico controlla se c'è un fianco nemico o qualche altra condizione (puoi semplicemente definire una variabile bool per questo). se non c'è, vai al fianco altrimenti vai al supporto. tutto dipende dagli scenari e dalle regole definiti.

Non so se si tenta di ottenere un accoppiamento libero tra agenti, dal momento che è quello che ho interpretato, comunque, che sarebbe l'approccio migliore, è necessario verificare il modello di osservatore , che è un sistema di abbonamento di eventi che evita le dipendenze. Potresti usarlo in questo modo (cercherò di essere agnostico):

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

Quindi spetterebbe a te fare la logica per iscriverti / annullare l'iscrizione quando l'agente è occupato e non può fare compagnia.

Se dovessi usare C #, dovresti controllare i Delegati Evento , che implementano già il modello sopra menzionato.

Spero che ti dia almeno un'idea.

Dovresti A: usare il passo e valutare e B: devi avere più obiettivi con priorità.

Se Agent1 vuole X e Agent2 non vuole mai X, non possono lavorare insieme . Ciò non può accadere in nessun sistema . Per risolvere questo problema, dovrai tenere traccia di più obiettivi. Puoi anche stabilire le priorità degli obiettivi in ​​base alla misura in cui uno ha progredito verso di loro e alla facilità con cui altri obiettivi possono essere raggiunti . Nel tuo scenario senza priorità, questo diventa:

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

Pianifica Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Obiettivo: hasWood = true

Obiettivo: isLonely = false

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

L'Agente1 avrebbe quindi continuamente chiedere all'Agente2 di parlare fino a quando non avesse ottenuto un risultato affermativo, cosa che sarebbe avvenuta dopo aver completato la sua prima attività.

Dovranno essere valutati i passi da compiere verso ciascun obiettivo e, sebbene con un solo obiettivo questo non sia un grosso problema, un numero maggiore di obiettivi potrebbe potenzialmente rallentare il gioco.

Per risolvere questo problema, sono necessari alberi generati da attività che possono nascondere il controllo di più obiettivi alla volta, accelerando l'elaborazione delle decisioni.