ReGoap
version 0.3.0
Biblioteca genérica C# GOAP (Planejamento de Ação Orientada por Objetivos) com Exemplos Unity3D e Aulas de Auxiliares.
Esta biblioteca é muito genérica, se você não incluir a pasta Unity, poderá usá -la em qualquer mecanismo de jogo.
Comece confira o exemplo do Unity FSM aqui.
Este exemplo usa a biblioteca RegOAP em unidade com um simples FSM (Máquina de Estado Finito) para lidar com os comportamentos macro (na maioria dos jogos, três estados FSM devem ser suficientes: ocioso, goto, animado).
Para usá -lo, crie um novo projeto de unidade, abra o shell, vá para o diretório de ativos e clone todo o repositório lá:
git clone https://github.com/luxkun/ReGoap.git(No Windows, você pode fazer o mesmo com a linha de comando ou qualquer cliente Git, também pode clicar em "Clone ou Download" e depois "Download Zip")
Além disso, você pode simplesmente baixar o pacote de unidades do último lançamento, que provavelmente não terá as últimas alterações, aqui ou na loja de ativos da Unity.
(Se você deseja apenas usar a biblioteca e deseja um exemplo explicado, pule como usar o ReGoAP )
Antes de explicar como usar esta biblioteca em seu jogo, deixe -me explicar como funciona um sistema GOAP, começando com uma citação 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.
Basicamente, tudo o que faz é encontrar um plano (uma lista de ações) que cumprirá os objetivos do objetivo de escolher.
O principal conceito que você precisa entender são: estados, ação, objetivo, memória e sensores
é uma definição do mundo, nesta biblioteca eles são tratados como um dicionário de string para objeto (dicionário <string, objeto>).
Confira a classe Regoapstate neste arquivo: https://github.com/luxkun/regoap/blob/master/regoap/core/regoapstate.cs
Exemplo: 'isat': 'inimigo', 'iswarned': true, 'hasweapon': verdadeiro
Pode ser definido como uma lista de pré -condições e efeitos, essas são as ações que o agente (ai peão, será chamado de agente a partir de agora) pode realizar.
As pré -condições são o requisito de que a ação exige ser executada, descrita como um estado, os efeitos, como o nome indica, são os efeitos da ação, bem descritos como um estado.
Exemplos:
IMPORTANTE : As pré -condições falsas não são apoiadas importantes : os efeitos da ação não são escritos na memória quando a ação é feita, esse é um comportamento procurado, porque na maioria dos jogos você deseja definir essas variáveis da memória ou dos sensores . Se você quiser, pode substituir a saída em sua regoapação e definir os efeitos para a memória, exemplo seguindo.
Pode ser definido como uma lista de requisitos, descritos como um estado, é basicamente isso que o agente deve fazer.
Exemplos:
é a memória do agente, tudo o que o agente conhece e sente deve ser inserido aqui. Uma memória também pode ter muitos sensores, nesta biblioteca, que são um ajudante de memória. Basicamente, o trabalho da memória é criar e manter um estado "mundial".
é um ajudante de memória, ele deve lidar com um escopo específico.
Exemplo:
Agora você deve entender para que é uma biblioteca GOAP e para que você deve usá -la, se ainda tiver perguntas ou quiser saber mais sobre esse campo, aconselho você a ler os papéis de Jeff Orkin aqui: http://alumni.media.mit. edu/~ jorkin/
git clone https://github.com/luxkun/ReGoap.gitO que há mais? Nada realmente, a biblioteca lidará com todo o planejamento, escolherá as ações para concluir uma meta e executar a primeira até que seja concluída, depois a segunda e assim por diante, tudo o que você precisa fazer é implementar suas próprias ações e objetivos.
Nos próximos parágrafos, explicarei como criar suas próprias classes (mas para a maioria dos comportamentos, tudo o que você precisa implementar é Goapaction e Goapgoal).
Confira as ações neste exemplo: https://github.com/luxkun/regoap/tree/master/regoap/unity/fsmexample/actions
Confira a implementação do RegoApaction, para ver quais funções você pode substituir: https://github.com/luxkun/regoap/blob/master/regoap/unity/regoapaction.cs
Você deve implementar sua própria regoapaction implementando a interface do Iregoapaction ou herdando o regoapaction. Escolha sabiamente os tipos genéricos, eles devem ser os mesmos em todas as classes do agente. Geralmente, o objeto é o objeto mais genérico, também int/enum, também é genérico, mas mais leve.
Para uma implementação simples, tudo o que você precisa fazer é o seguinte:
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
}
}Conforme escrito antes da regoapaction, por padrão, escreva os efeitos na memória, mas a memória deve verificar se os efeitos são efetivamente feitos, se por algum motivo você deseja definir os efeitos no final da ação que você pode adicionar Este código para sua implementação regoapaction:
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 ) ;
}
}Você também pode ter pré -condições e efeitos que são alterados dinamicamente com base nas pré -condições/efeitos da próxima ação, por exemplo, como você pode lidar com uma ação Goto em seu agente.
Confira FSMexample para ver como fazer isso: https://github.com/luxkun/regoap/blob/master/regoap/unity/fsmexample/actions/genericgotoaction.cs
Isso é menos complicado, a maior parte do objetivo substituirá apenas a função acordada para adicionar seu próprio estado de meta (objetivos).
De qualquer forma, confira Regoapgoal, como tudo o que você tem para implementar sua própria classe do zero, implementando a interface Iregoapgoal ou herdando Regoapgoal: https://github.com/luxkun/regoap/blob/master/regoap/unity/regoapgoal.cs
Confira também os objetivos neste exemplo: 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 : Certifique -se de usar o RegoApgoAlAdvanced se desejar alertar automaticamente o agente de que uma meta está/não está disponível.
Confira a classe Basic Basic aqui: https://github.com/luxkun/regoap/blob/master/regoap/unity/goaptensor.cs
Confira os exemplos aqui: https://github.com/luxkun/regoap/tree/master/regoap/unity/fsmexample/sensors
Como sempre, você precisa implementar sua própria classe herdando o regostensor ou implementando a interface do IregoapseseSor.
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 : Certifique -se de usar o RegOapMemoryAdvanced ao trabalhar com sensores, pois a classe básica não verifica e atualiza os sensores.
Para depurar seu próprio agente, você pode, é claro, depurar por conta própria, com seu editor favorito.
Mas o Regoap tem um depurador muito usuário para agentes em unidade (https://github.com/luxkun/regoap/blob/master/regoap/unity/editor/regoapnodeeditor.cs e https://github.com/luxkun/regoap/ blob/master/regoap/unity/editor/regoapNodeBaseEditor.cs).
Para usá -lo, basta clicar na janela do menu da unidade e, em seguida, Regoap Debugger , uma janela de unidade será aberta, este é o depurador do agente.
Agora, se você clicar em qualquer agente da sua cena (enquanto joga, funcionará apenas em agentes em execução), a janela atualizará automaticamente, informando que você sabe os "pensamentos" do agente (estado mundial atual, objetivo escolhido e plano atual, objetivos de possibilidade, possíveis ações, ações, possíveis ações, O que pode ser feito e o que não, tente!).
Qualquer solicitação de tração é apreciada, apenas verifique os testes de unidade ( janela do menu -> Testes do editor Runner -> Execute tudo ) antes de se comprometer e manter o mesmo estilo de código.
