Planificación de acción orientada a objetivos con múltiples agentes

Estoy un poco atascado:

Implementé una IA con GOAP (Planificación de acción orientada a objetivos, http://alumni.media.mit.edu/~jorkin/gdc2006_orkin_jeff_fear.pdf ) para un juego de simulación. Eso funciona bien

Ahora quiero que los agentes puedan cooperar (por ejemplo, haciendo acciones juntos). ¿Cuál es en este caso el mejor diseño AI que las acciones GoapActions mantienen acoplado?

¿Deberían planear juntos? (¿Cuál es en este caso el "estado mundial"?) ¿O deberían compartir sus planes? algún tipo de sistema de mensajes?

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

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Plan Agent2: GetAxe -> ChopWood -> BringWoodToSupply

¿Cómo consigo esta constelación?

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

O si están hablando y uno de los agentes es interrumpido (por ejemplo, por un enemigo atacante), el otro agente debe saber que su Acción TalktoAgent2 ha finalizado.

Le recomiendo que no utilice la planificación de acciones. Es muy difícil extender, diseñar y corregir errores. Abandonamos la planificación de tareas muy pronto en DwarfCorp porque es demasiado complejo diseñar rápidamente nuevos comportamientos. Pero si debe hacerlo, debe interpretar esto como un problema de planificación de múltiples agentes.

Una forma de lograr esto es a través de la planificación jerárquica . Debe crear un metaagente para asignar subproblemas a sus agentes de nivel inferior. El metaagente o "Planificador de tareas" intenta alcanzar un objetivo general y utiliza los subagentes bajo su control como meta-acciones.

Por ejemplo, su metaagente podría tener el objetivo "Construir una casa". Tiene la acción "recolectar madera" que toma como entrada un agente y un lugar para recolectar la madera. Luego puede asignar diferentes agentes a diferentes subtareas. Tal vez un agente va y recoge la madera mientras que el otro usa la madera recolectada para construir la casa.

Puede tener otros objetivos, como "reducir la soledad". Esos objetivos deben ordenarse por prioridad para que puedan subsumirse entre sí. El planificador central de tareas decide en cualquier momento cuáles son los objetivos más importantes y les asigna agentes mediante diferentes objetivos secundarios. Busca agentes inactivos, descubre cuál es la mejor subtarea para asignar al agente y luego los coloca en el caso.

Creo que Goap es una nueva versión de máquinas de estado que intenta configurar estados para lograr un objetivo. solo tiene que definir qué escenarios están sucediendo en cada estado.

por ejemplo, tienes algunos enemigos con IA que tienen estados de patrullaje, persecución, búsqueda y ataque. Simplemente puedes escribir un código que cuando uno de los enemigos encuentra un jugador, todo cambia de estado a estado de ataque o persecución. En otro ejemplo, tienes un escenario en el que en estado de ataque, uno o 2 enemigos tienen que flanquear al jugador y otro tiene que apoyarlos. así que cada enemigo verifica si hay un enemigo flanqueando o alguna otra condición (solo puedes definir una variable bool para eso). si no lo hay, ve al flanco o ve al soporte. todo depende de los escenarios y las reglas que defina.

No sé si intenta lograr un acoplamiento suelto entre agentes, ya que eso fue lo que interpreté, de todos modos, ese sería el mejor enfoque, debe verificar el Patrón de observador , que es un sistema de suscripción de eventos que evita las dependencias. Podrías usarlo de esta manera (trataré de ser independiente del lenguaje):

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

Por lo tanto, dependerá de usted hacer la lógica para suscribirse / darse de baja cuando el agente está ocupado y no puede hacer compañía.

Si fuera a usar C #, debería verificar los Delegados de eventos , que ya implementan el patrón mencionado anteriormente.

Espero que al menos te dé una idea.

Tendría que A: usar paso y evaluar y B: debe tener múltiples objetivos con prioridades.

Si el Agente1 quiere X y el Agente2 nunca quiere X, no pueden trabajar juntos . Eso no puede suceder en ningún sistema . Para solucionar esto, necesitará tener varios objetivos rastreados. Incluso puede priorizar objetivos en función de cuánto ha progresado uno hacia ellos y con qué facilidad se pueden lograr otros objetivos . En su escenario sin prioridades, esto se convierte en:

Agente1: Agente del Estado Mundial 1: isLonely = verdadero Objetivo: isLonely = falso

Plan Agent1: AskAgent2ToTalk -> TalkToAgent2

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

Objetivo: hasWood = verdadero

Objetivo: isLonely = false

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

El Agente1 luego le pedía continuamente al Agente2 que hablara hasta obtener una respuesta afirmativa, lo que sucedería después de completar su primera tarea.

Habrá que evaluar los pasos hacia cada objetivo, y si bien con un solo objetivo esto no es un gran problema, más objetivos podrían ralentizar su juego.

Para resolver este problema, necesita árboles generados a partir de la realización de tareas que pueden ocultar la verificación de múltiples objetivos a la vez, acelerando el procesamiento de decisiones.