Planejamento de ação orientado a objetivos com vários agentes

Estou um pouco preso:

Eu implementei uma IA com GOAP (Planejamento de Ação Orientado a Objetivos, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf ) para um jogo de simulação. Isso funciona bem.

Agora eu quero que os agentes possam cooperar (por exemplo, fazendo ações juntos). Qual é, neste caso, o melhor design de IA que as GoapActions mantêm dístico solto?

Eles devem planejar juntos? (o que é, neste caso, o "estado mundial"?) Ou devem compartilhar seus planos? algum tipo de sistema de mensagens?

Exemplo
Agent1: Worldstate Agent 1: isLonely = true
Objetivo Agent1: isLonely = false

Planejar Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Planejar Agent2: GetAxe -> ChopWood -> BringWoodToSupply

Como obtenho essa constelação?

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

Ou, se estiverem conversando e um dos agentes for interrompido (por exemplo, por um inimigo atacante), o outro agente deve saber que a ação do TalktoAgent2 terminou.

Eu recomendo que você não use o planejamento aciton. É muito difícil estender, projetar e corrigir erros. Abandonamos o planejamento de tarefas muito cedo no DwarfCorp porque é muito complexo projetar rapidamente novos comportamentos. Mas, se necessário, você deve interpretar isso como um problema de planejamento de vários agentes.

Uma maneira de conseguir isso é através do Planejamento Heirárquico . Você precisa criar um meta-agente para atribuir subproblemas aos seus agentes de nível inferior. O meta-agente, ou "Planejador de Tarefas", tenta atingir uma meta geral e usa os subagentes sob seu controle como meta-ações.

Por exemplo, seu meta-agente pode ter um objetivo "Construir uma casa". Ele tem a ação "recolher madeira", que recebe como entrada um agente e um local para coletar a madeira. Em seguida, ele pode atribuir diferentes agentes a diferentes subtarefas. Talvez um agente vá e recolhe a madeira, enquanto o outro usa a madeira recolhida para construir a casa.

Pode ter outros objetivos, como "reduzir a solidão". Esses objetivos precisam ser ordenados por prioridade, para que possam se subsumir. O planejador de tarefas central decide a qualquer momento quais são os objetivos mais importantes e atribui agentes a eles usando sub-objetivos diferentes. Ele procura agentes inativos, descobre qual é a melhor subtarefa a ser atribuída ao agente e os coloca no caso.

Acho que o goap é uma nova versão das máquinas de estado que tenta configurar os estados para atingir uma meta. você apenas precisa definir quais cenários estão acontecendo em todos os estados.

por exemplo, você tem alguns inimigos da IA ​​que possuem estados de patrulha, perseguição, busca e ataque. você pode simplesmente escrever um código que quando um dos inimigos encontra um jogador, todos mudam de estado para atacar ou perseguir. outro exemplo, você tem um cenário em que no estado de ataque, um ou dois inimigos precisam flanquear o jogador e outros precisam apoiá-lo. portanto, todo inimigo verifica se há um flanqueador inimigo ou alguma outra condição (você pode apenas definir uma variável bool para isso). se não houver, flanqueie ou apoie. tudo depende dos cenários e regras que você define.

Não sei se você tenta se soltar entre os agentes, já que foi isso que eu interpretei, de qualquer maneira, que seria a melhor abordagem. Você deve procurar o Observer Pattern , que é um sistema de assinatura de eventos que evita dependências. Você pode usá-lo desta maneira (tentarei ser independente do idioma):

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

Portanto, cabe a você criar a lógica de assinar / cancelar a assinatura quando o agente estiver ocupado e não puder fazer companhia.

Se você usar C #, verifique os Delegados de Eventos , que já implementam o padrão mencionado acima.

Espero que isso lhe dê uma idéia, pelo menos.

Você teria que A: usar a etapa e avaliar e B: você deve ter vários objetivos com prioridades.

Se o Agent1 quiser X e o Agent2 nunca quiser X, eles não poderão trabalhar juntos . Isso não pode acontecer em nenhum sistema . Para corrigir isso, você precisará ter vários objetivos rastreados. Você pode até priorizar metas com base em até que ponto a pessoa progrediu em direção a elas e com que facilidade outras metas podem ser alcançadas . No seu cenário sem prioridades, isso se torna:

Agente1: Worldstate Agente 1: isLonely = true Objetivo: isLonely = false

Planejar Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Objetivo: hasWood = true

Objetivo: isLonely = false

Planejar o Agent2: GetAxe -> ChopWood -> BringWoodToSupply, AskAgent1ToTalk -> TalkToAgent1

O Agent1 pedia continuamente que o Agent2 falasse até obter uma afirmativa, o que aconteceria após a conclusão de sua primeira tarefa.

Tomar medidas para cada objetivo terá que ser avaliado e, embora com apenas um objetivo não seja grande coisa, mais objetivos podem potencialmente diminuir a velocidade do seu jogo.

Para resolver esse problema, você precisa de árvores geradas com a realização de tarefas que podem ocultar a verificação de várias metas de cada vez, acelerando o processamento de decisões.