ReGoap
version 0.3.0
Biblioteca genérica de C# goap (planificación de acción orientada a objetivos) con ejemplos de Unity3D y clases de ayudantes.
Esta biblioteca es muy genérica, si no incluye la carpeta Unity, puede usarla en cualquier motor de juego.
Comience revisando el ejemplo de Unity FSM aquí.
Este ejemplo utiliza la biblioteca REGOAP en Unity con un FSM simple (máquina de estado finito) para manejar los comportamientos macro (en la mayoría de los juegos, tres estados FSM deberían ser suficientes: inactivo, goto, animado).
Para usarlo, cree un nuevo proyecto de unidad, abra el shell, vaya al directorio de activos y clone todo el repositorio allí:
git clone https://github.com/luxkun/ReGoap.git(En Windows puede hacer lo mismo con la línea de comandos o cualquier cliente GIT, también puede hacer clic en "Clon o descargar" y luego "Descargar zip")
También puede descargar el paquete Unity de la última versión, que probablemente no tendrá los últimos cambios, aquí o en la tienda de activos Unity.
(Si solo desea usar la biblioteca y desea un ejemplo explicado, saltea cómo usar RECOAP )
Antes de explicar cómo usar esta biblioteca en tu juego, déjame explicar cómo funciona un sistema Goap, comenzando con una cita de Jeff Orkin
Goal-Oriented Action Planning (aka GOAP, rhymes with soap) refers to a simplfied STRIPS-like planning architecture specifically designed for real-time control of autonomous character behavior in games.
Básicamente, todo lo que hace es encontrar un plan (una lista de acciones) que cumpla con los objetivos del objetivo elegido.
El concepto principal que debe comprender son: estados, acción, objetivo, memoria y sensores
es una definición del mundo, en esta biblioteca se manejan como un diccionario de cadena a objeto (diccionario <string, objeto>).
Echa un vistazo a la clase REgoApState en este archivo: https://github.com/luxkun/regoap/blob/master/regoap/core/regoapstate.cs
Ejemplo: 'isat': 'enemigo', 'iswarned': verdadero, 'hasado': verdadero
Se puede definir como una lista de condiciones previas y efectos, estas son las acciones que el agente (AI peón, se llamará agente a partir de ahora) puede hacer.
Las condiciones previas son el requisito de que la acción requiere ser ejecutada, descrita como un estado, los efectos, como su nombre lo indica, son los efectos de la acción, tan bien descritos como un estado.
Ejemplos:
IMPORTANTE : Las condiciones previas falsas no son compatibles importantes : los efectos de acción no se escriben en la memoria cuando se realiza la acción, este es un comportamiento buscado porque en la mayoría de los juegos querrás establecer estas variables de la memoria o de los sensores . Si desea, puede anular la salida en su regoapaction y establecer los efectos en la memoria, ejemplo siguiente.
Se puede definir como una lista de requisitos, descritos como un estado, esto es básicamente lo que el agente debe hacer.
Ejemplos:
es la memoria del agente, todo lo que el agente sabe y siente que se debe insertar aquí. Una memoria también puede tener muchos sensores, en esta biblioteca, que son un ayudante de memoria. Básicamente, el trabajo de la memoria es crear y mantener actualizado un estado 'mundial'.
es un ayudante de memoria, debe manejar un alcance específico.
Ejemplo:
Ahora debe comprender para qué es una biblioteca Goap y para qué debe usarlo, si aún tiene preguntas o quiere saber más sobre este campo, le aconsejo que lea los documentos de Jeff Orkin aquí: http://alumni.media.mit. edu/~ jorkin/
git clone https://github.com/luxkun/ReGoap.git¿Qué es más? Nada realmente, la biblioteca manejará toda la planificación, elegirá las acciones para completar un objetivo y ejecutará el primero hasta que esté listo, luego la segunda y así sucesivamente, todo lo que necesita hacer es implementar sus propias acciones y objetivos.
En los próximos párrafos, explicaré cómo crear sus propias clases (pero para la mayoría de los comportamientos, todo lo que necesita implementar es Goapaction y Goapgoal).
Consulte las acciones en este ejemplo: https://github.com/luxkun/regoap/tree/master/regoap/unity/fsmexample/acciones
Echa un vistazo a la implementación de ReloPaction, para ver qué funciones puede anular: https://github.com/luxkun/regoap/blob/master/regoap/unity/regoapaction.cs
Debe implementar su propia referencia implementando la interfaz IREGOAPACTION o heredando la referencia. Elija sabiamente los tipos genéricos, deben ser los mismos en todas las clases del agente. Por lo general, la cadena, el objeto es el objeto más genérico, también int/enum, también es genérico pero más ligero.
Para una implementación simple, todo lo que tiene que hacer es esto:
public class MyGoapAction : ReGoapAction < string , object >
{
protected override void Awake ( )
{
base . Awake ( ) ;
preconditions . Set ( " myPrecondition " , myValue ) ;
effects . Set ( " myEffects " , myValue ) ;
}
public override void Run ( IReGoapAction < string , object > previous , IReGoapAction < string , object > next , ReGoapState < string , object > settings , ReGoapState < string , object > goalState , Action < IReGoapAction < string , object > > done , Action < IReGoapAction < string , object > > fail )
{
base . Run ( previous , next , goalState , done , fail ) ;
// do your own game logic here
// when done, in this function or outside this function, call the done or fail callback, automatically saved to doneCallback and failCallback by ReGoapAction
doneCallback ( this ) ; // this will tell the ReGoapAgent that the action is succerfully done and go ahead in the action plan
// if the action has failed then run failCallback(this), the ReGoapAgent will automatically invalidate the whole plan and ask the ReGoapPlannerManager to create a new plan
}
}Como se escribe antes de que la RenoPaction, por defecto, no escriba los efectos en la memoria, pero la memoria debe verificar si los efectos se realizan de manera efectiva, si por alguna razón desea establecer los efectos al final de la acción que puede agregar Este código a su implementación de ReloPaction:
public override void Exit ( IReGoapAction < string , object > next )
{
base . Exit ( next ) ;
var worldState = agent . GetMemory ( ) . GetWorldState ( ) ;
foreach ( var pair in effects ) {
worldState . Set ( pair . Key , pair . Value ) ;
}
}También puede tener condiciones previas y efectos que se cambian dinámicamente en función de las preacondiciones/efectos de la próxima acción, por ejemplo, así es como puede manejar una acción GOTO en su agente.
Echa un vistazo a FSmexample para ver cómo hacer esto: https://github.com/luxkun/regoap/blob/master/regoap/unity/fsmexample/acciones/genericgotoaction.cs
Esto es menos complicado, la mayor parte del objetivo solo anulará la función despierta para agregar su propio estado de objetivo (objetivos).
De todos modos, consulte Rgoapgoal, como todo lo que tiene para implementar su propia clase desde cero implementando la interfaz IREGOAPGOAL o heredando a Regoapgoal: https://github.com/luxkun/regoap/blob/regoap/unity/regoapgoal.cs
También consulte los objetivos en este ejemplo: https://github.com/luxkun/regoap/tree/master/regoap/unity/fsmexample/goals
public class MyGoapGoal : ReGoapGoal < string , object >
{
protected override void Awake ( )
{
base . Awake ( ) ;
goal . Set ( " myRequirement " , myValue ) ;
}
}Nota : Asegúrese de usar RenoPGoalAdvanced si desea advertir automáticamente al agente que un objetivo está/no está disponible.
Echa un vistazo a la clase básica de Goapsensor aquí: https://github.com/luxkun/regoap/blob/master/regoap/unity/goapsensor.cs
Echa un vistazo a los ejemplos aquí: https://github.com/luxkun/regoap/tree/master/regoap/unity/fsmexample/sensors
Como siempre, debe implementar su propia clase heredando el regoapsensor o implementando la interfaz IREGoApsensor.
public class MySensor : ReGoapSensor < string , object >
{
void FixedUpdate ( )
{
var worldState = memory . GetWorldState ( ) ;
worldState . Set ( " mySensorValue " , myValue ) ; // like always myValue can be anything... it's a GoapState :)
}
}Nota : Asegúrese de usar RenoApMemoryAdVanced cuando trabaje con sensores, ya que la clase básica no verifica y actualiza los sensores.
Para depurar su propio agente, puede, por supuesto, depurar por su cuenta, con su editor favorito.
Pero REGROAP tiene un depurador muy de usuario para agentes en Unity (https://github.com/luxkun/regoap/blob/master/regoap/unity/editor/regoapnodeeditor.cs y https://github.com/luxkun/regoap/ blob/master/regoap/unity/editor/regoapnodeBaseEditor.cs).
Para usarlo, simplemente haga clic en la ventana del menú de Unity y luego se abierta RECOAP DEBUGGER , se abrirá una ventana de Unity, este es el depurador del agente.
Ahora, si hace clic en cualquier agente de su escena (mientras juega, trabaja solo en los agentes en ejecución), la ventana actualizará automáticamente que sepa los "pensamientos" del agente (el estado mundial actual, el objetivo elegido y el plan actual, los objetivos posibilidades, las posibles acciones, ¡Qué se puede hacer y qué no, pruébalo!).
Se agradece cualquier solicitud de extracción, solo asegúrese de verificar las pruebas de unidad ( ventana del menú -> Pruebas del editor Runner -> Ejecutar todo ) antes de comprometerse y mantener el mismo estilo de código.
