WEBVTT

00:12.520 --> 00:16.960
Nesta palestra, vamos implementar um sistema GOAP no Unity.

00:16.960 --> 00:19.840
Agora você pode baixar o arquivo inicial a seguir e ele

00:19.840 --> 00:21.740
se chama GOAP. fecho eclair.

00:21.820 --> 00:25.950
Existem 2 arquivos iniciais com esta palestra ... há o GOAP. zip e também há

00:26.170 --> 00:28.310
um goap-master. fecho eclair.

00:28.390 --> 00:36.040
O goap-master é a versão completa desta biblioteca GOAP que eu peguei da URL que você pode ver na

00:36.040 --> 00:36.760
tela.

00:36.760 --> 00:41.230
Portanto, há outros exemplos e outras coisas para você ver mais

00:41.380 --> 00:47.290
tarde e o que fiz com apenas o GOAP é que retirei o máximo que

00:47.290 --> 00:55.000
posso e também o modifiquei para permitir uma navegação Mesh Agent porque usaremos um NavMesh para colocar nossos agentes na

00:55.240 --> 00:57.560
tela entre seus diferentes destinos.

00:58.330 --> 01:05.500
Agora, se você trouxer o GOAP. zip no Unity, você encontrará ISTO quando abrir a cena

01:05.500 --> 01:06.320
da vila.

01:06.460 --> 01:09.770
Eu tenho um agente e ele vai ser um padeiro.

01:09.940 --> 01:11.590
Esta é a padaria dele ...

01:11.590 --> 01:14.100
este é o moinho de vento que fornece a farinha ...

01:14.320 --> 01:22.110
e aqui, temos alguns mercados. Agora, em cada um desses edifícios, incluí um

01:22.110 --> 01:23.140
cubo (que

01:23.140 --> 01:31.390
chamei de 'Porta') e você pode ver isso na Hierarquia. O agente precisa de um local para ir, para executar a tarefa e você

01:31.540 --> 01:35.460
pode levá-los ao prédio real para executar a tarefa, mas eu pensei que seria

01:35.470 --> 01:39.380
bom ter apenas um pequeno marcador para onde eles poderiam ir, então

01:39.400 --> 01:43.920
é por isso que eu os adicionamos aqui e você os verá em uso mais tarde.

01:44.080 --> 01:48.080
Agora, esse agente está em um avião, que é um NavMesh.

01:48.100 --> 01:54.510
Se você abrir a guia Navegação, verá que o NavMesh já está aplicado.

01:54.700 --> 02:02.410
O agente (que se chama Baker porque vamos fazê-lo assar um pouco de pão) na Hierarquia já

02:02.710 --> 02:04.960
tem algumas coisas configuradas.

02:04.960 --> 02:10.870
Então, primeiro de tudo, ele tem o Nav Mesh Agent lá, que é o que todos usamos para

02:10.870 --> 02:12.080
navegar pela cena.

02:12.280 --> 02:21.820
Você também precisa adicionar a qualquer agente (que é um agente GOAP) o script 'Goap Agent' e esse script do Goap Agent está

02:22.060 --> 02:24.410
nos ativos na pasta GOAP.

02:24.460 --> 02:30.100
Chegaremos a isso em um momento, que já está escrito para você. Então, as coisas que você precisa

02:30.100 --> 02:36.340
escrever sobre o sistema GOAP são os scripts que executam o agente em si.

02:36.340 --> 02:44.780
Estamos chamando-o de trabalhador e o agente também tem um inventário, e eu voltarei para ver aqueles em um segundo.

02:44.980 --> 02:49.120
Vamos para o Ativos e dar uma olhada na pasta AI.

02:49.270 --> 02:52.770
Você descobrirá que há uma pasta FSM (Finite State Machine).

02:52.780 --> 02:58.630
Essa é a pequena máquina de estado que apenas direciona o agente de um local para outro para

02:58.690 --> 03:00.010
executar as tarefas.

03:00.010 --> 03:04.880
Ele não usa o State Machine System incorporado ao Unity, tudo é feito por código.

03:04.900 --> 03:10.870
É uma coisa tão simples que ele realmente não precisa do Sistema de Animação para configurar

03:10.870 --> 03:17.110
todos os diferentes estados e transições entre ele, porque são basicamente apenas dois estados com os quais

03:17.110 --> 03:18.540
você precisa lidar.

03:18.670 --> 03:24.940
Depois, há uma pasta GOAP. Vá para a pasta GOAP e é aqui que

03:25.120 --> 03:34.150
você encontrará todas as classes que atendem às diferentes partes da arquitetura GOAP. Primeiro, há o agente GOAP, que cuida das ações básicas do

03:34.300 --> 03:40.000
agente e garante que ele execute o Planejador, procure Objetivos e acompanhe o

03:40.000 --> 03:43.510
Estado Mundial à medida que ele muda.

03:43.510 --> 03:45.760
Temos então uma ação Goap.

03:45.760 --> 03:53.290
Agora, cada ação que você adicionar herdará dessa classe específica e permitirá criar várias ações,

03:53.290 --> 03:56.100
mesmo que não sejam usadas.

03:56.090 --> 04:00.690
Lembre-se: uma ação no sistema GOAP pode ser adicionada.

04:00.760 --> 04:07.840
Ele não está conectado a nada, apenas está sentado ali, como ele mesmo, e possui Condições Prévias e Efeitos, e o que

04:08.080 --> 04:09.390
acontece quando há

04:09.640 --> 04:12.060
um Objetivo que chega é que o

04:12.060 --> 04:18.280
Planejador reúne todas essas Ações e tenta reuni-las. , para ver onde as Condições prévias e os Efeitos se

04:18.280 --> 04:24.550
unem para formar uma cadeia, que se torna seu Plano. Portanto, você pode adicionar o máximo possível

04:24.550 --> 04:28.120
dessas ações ao seu agente, mas se elas

04:28.210 --> 04:33.700
não tiverem condições e efeitos que se unirão a outras ações, elas nunca serão

04:33.700 --> 04:34.150
usadas.

04:34.150 --> 04:39.540
Portanto, essa é uma das coisas que você realmente precisa observar ao projetar suas ações,

04:39.550 --> 04:45.520
mas abordaremos isso quando começarmos a fazer nossas próprias ações e o quão importante é, para que

04:45.830 --> 04:47.060
elas se reúnam.

04:47.200 --> 04:54.180
O próprio GoapPlanner reúne todas as ações disponíveis e as verifica em relação às condições, ao

04:54.190 --> 05:01.350
estado do mundo e a quaisquer metas em particular e cria seu plano de ações encadeado, depois

05:01.360 --> 05:09.270
relata isso ao agente que usa a máquina de estados finitos para executar as ações ao longo da cadeia.

05:10.140 --> 05:16.290
Agora, o código em que estamos interessados e o código que escrevemos para interagir com o sistema GOAP está atualmente em

05:16.290 --> 05:22.890
nosso Baker e esse é o script Worker e o inventário. O script Inventário, se você o soltar

05:22.890 --> 05:27.420
no Inspetor, verá que ele possui níveis para Farinha e Pão.

05:27.420 --> 05:33.330
Então, essas são as coisas que o agente tem, é como a "mochila" ou o "inventário". Se você der uma olhada nesse

05:33.330 --> 05:35.870
código, é realmente bastante simples.

05:35.940 --> 05:39.510
Só existem alguns números inteiros com os valores

05:39.510 --> 05:43.640
e estamos começando nosso agente como tendo 5 sacos de farinha.

05:43.830 --> 05:49.950
Existe um OnGUI realmente simples lá, apenas para imprimi-lo na tela, para que possamos ver esses

05:49.980 --> 05:52.400
valores mudarem enquanto executamos a simulação.

05:52.410 --> 06:01.710
Agora, o código Worker que também está em nosso agente herdará da nossa interface GOAP aqui (IGoap), que é essencialmente nosso

06:01.710 --> 06:03.070
agente GOAP.

06:03.390 --> 06:08.340
Está aí, obviamente, o nosso NavMeshAgent, do qual precisamos contorná-lo.

06:08.340 --> 06:15.120
Há também um vetor de destino3 anterior que está sendo armazenado pelo motivo da navegação, que você verá em um

06:15.120 --> 06:16.260
momento e também

06:16.440 --> 06:21.350
temos um link para o nosso sistema de inventário que está nesse agente.

06:21.360 --> 06:26.460
Essas duas coisas (o NavMeshAgent e o Inventory) são configuradas dentro do Start.

06:26.460 --> 06:29.070
Então, agarramos esses dois componentes, para que

06:29.160 --> 06:32.090
não precisemos continuar fazendo isso por todo o código.

06:32.310 --> 06:41.400
Agora, passando esse código, chegamos a algumas das partes mais importantes desse agente e são

06:41.400 --> 06:51.780
esses dois próximos métodos: GetWorldState e CreateGoalState. O GetWorldState injeta no sistema GOAP,

06:51.780 --> 06:55.630
o estado do mundo.

06:55.710 --> 06:59.910
Agora, vamos usar os estados 'verdadeiro'

06:59.910 --> 07:07.040
e 'falso', como vimos originalmente na palestra anterior e vamos defini-los aqui.

07:07.050 --> 07:14.430
Portanto, isso continuará sendo executado e atualizado para o seu agente, para que o sistema de planejamento possa verificar se

07:14.430 --> 07:16.840
determinados estados foram alcançados ou não.

07:16.860 --> 07:27.000
Agora, neste caso, inicialmente, estamos definindo nosso estado mundial 'hasFlour' como True ou False com

07:27.060 --> 07:33.330
base no inv. flourLevel. Antes de continuarmos, gostaria de explicar a

07:33.330 --> 07:38.700
estrutura das Condições e Efeitos, pois elas são essencialmente a cola que mantém todas as Ações juntas na cadeia.

07:38.880 --> 07:43.130
Todos eles são armazenados em um HashSet no formato 'string, objeto'.

07:43.380 --> 07:49.190
Nesse caso, estamos representando-os com uma sequência que explica o estado e, em seguida, um verdadeiro ou um falso.

07:49.380 --> 07:58.380
Por exemplo, ("hasFood", true) ("hasBread", false). Você verá esses conjuntos de ações posteriormente e elas

07:58.590 --> 08:06.450
são verdadeiramente as condições que unirão cada ação, de modo que, para cada ação Pré-requisito,

08:06.450 --> 08:14.850
você precisará ter outra ação que tenha um efeito que os magnetize e combine-os juntos, para que

08:14.850 --> 08:18.050
eles possam formar uma corrente.

08:18.180 --> 08:26.010
Se você não tiver pessoas em nenhum lugar do seu conjunto de ações, essa ação não será usada e você poderá descobrir que

08:26.010 --> 08:28.800
o Planejador não pode encontrar um plano.

08:28.800 --> 08:36.600
Então, voltando ao nosso código. Onde colocamos essas Condições e Efeitos está dentro

08:36.600 --> 08:46.260
desses 2 métodos que acabamos de falar, entre a declaração inicial para o conjunto 'worldData' e também para o conjunto 'goal'.

08:46.260 --> 08:52.770
Então, este é todos os estados do mundo, como eu disse. Ele é atualizado o tempo todo, portanto, essa

08:52.770 --> 08:59.300
função é chamada o tempo todo para continuar verificando se esse 'hasFlour', por exemplo, é True ou False

08:59.310 --> 09:04.110
e é por isso que podemos colocar essas variáveis aqui, que podemos mudar.

09:04.110 --> 09:11.130
Esse é o nível de farinha no inventário e não vai dizer que você tem farinha a menos que o

09:11.460 --> 09:14.310
nível de farinha seja maior que 1.

09:14.310 --> 09:19.590
Portanto, neste caso, não considera que você tenha farinha suficiente para fazer qualquer coisa até ter 2 sacos

09:19.650 --> 09:20.300
de farinha.

09:20.310 --> 09:26.220
Portanto, isso define o limite de quantos sacos de farinha são considerados 'ter farinha suficiente para

09:26.220 --> 09:26.730
assar'.

09:26.730 --> 09:31.860
Agora, se você tem outras condições nos Estados do mundo que deseja fazer e

09:32.190 --> 09:35.850
que possuem um valor variável, é possível adicioná-las aqui.

09:36.210 --> 09:43.000
Você não pode colocar valores de tipo variável como este dentro de suas Ações, porque não funcionará.

09:43.000 --> 09:47.130
As ações devem corresponder exatamente quando for

09:47.430 --> 09:52.490
planejado e, se não o fizerem, o sistema será paralisado.

09:52.500 --> 09:54.380
Então, vamos ver isso daqui a pouco de qualquer maneira.

09:54.390 --> 09:56.070
Então esse é o seu worldData.

09:56.070 --> 09:59.160
Agora, as próprias metas variam entre o local

09:59.190 --> 10:04.070
em que você declara o conjunto de metas e o local em que as devolve.

10:04.080 --> 10:10.770
Então aqui dentro, quero que você adicione um novo objetivo para o nosso Baker e será assim.

10:10.820 --> 10:16.280
Então aqui está a nossa pequena string aqui e aqui está o nosso valor Verdadeiro ou Falso.

10:16.290 --> 10:20.850
Agora, esse é um objetivo global para o nosso agente e

10:20.900 --> 10:22.890
será chamado de "doJob",

10:23.030 --> 10:29.270
então "doJob" é True e continuará forçando isso no agente, e ele continuará se certificando de

10:29.270 --> 10:31.820
que está tratando disso. objetivo particular.

10:31.910 --> 10:35.040
Então, teremos apenas um objetivo aqui.

10:35.120 --> 10:39.570
Então adicione isso e, mais abaixo, vamos dar uma olhada no restante do código.

10:39.590 --> 10:42.250
Temos o código para mover o agente.

10:42.320 --> 10:47.480
Este é apenas o código de tipo típico que move o NavMeshAgent e

10:47.500 --> 10:50.430
o que ele faz são algumas coisas.

10:50.450 --> 10:56.890
Antes de tudo, ele verifica nosso destino anterior (lembre-se de que Vector3 na parte superior deste código)

10:56.900 --> 11:04.970
verifica se não é o mesmo de onde precisamos ir para o próximo porque se um NavMeshAgent estiver no seu destino

11:05.000 --> 11:12.020
quando receber um novo objetivo, então, ele não planejará um caminho e isso se tornará um problema para

11:12.020 --> 11:16.840
determinar se alcançamos nosso próximo destino para realizar nossa próxima tarefa.

11:16.850 --> 11:24.260
Portanto, se a tarefa estiver na mesma posição que a última, isso será resolvido porque o

11:24.260 --> 11:30.460
agente não precisa se mover fisicamente pelo ambiente, no momento em que

11:30.560 --> 11:32.750
definimos nextAction. setInRange para true.

11:32.840 --> 11:41.350
Agora, cada ação não será executada, A menos que o seu agente esteja dentro do alcance de onde isso precisa acontecer.

11:41.360 --> 11:43.710
Então é isso que esta linha aqui está fazendo.

11:45.140 --> 11:50.810
Então, se não formos obrigados a permanecer no mesmo destino (precisamos ir para outro lugar), usaremos nosso NavMesh

11:50.810 --> 11:57.860
com SetDestination usando o nextAction. alvo. transformar. posição para nos empurrar

11:57.860 --> 12:04.730
para o próximo local e, em seguida, executaremos verificações como fizemos anteriormente com o NavMeshes para verificar

12:04.730 --> 12:06.740
se chegamos ao nosso destino.

12:06.740 --> 12:15.560
Portanto, se temos um caminho e estamos a uma distância de 2, chegamos ao nosso destino.

12:15.590 --> 12:19.450
Essa é basicamente a sua precisão de quão perto você deseja chegar e, em seguida,

12:19.730 --> 12:20.900
fazemos a mesma coisa.

12:20.900 --> 12:22.390
Portanto, estamos dentro do

12:22.700 --> 12:28.040
alcance e atualizamos nosso Destino anterior, para que isso registre onde estamos e retornemos True,

12:28.040 --> 12:34.100
para que o sistema saiba que estamos no nosso destino e que estamos prontos para a próxima ação.

12:34.100 --> 12:34.310
Tudo certo.

12:34.310 --> 12:39.150
Portanto, passando para a atualização, você não precisa de nada dentro da atualização, mas

12:39.170 --> 12:45.050
o que eu fiz aqui é apenas adicionar um pouco de código que ajudará seu agente a desacelerar

12:45.050 --> 12:51.620
e acelerar melhor nos cantos e você pode realmente aplicar isso bloco if inteiro para qualquer código do Nav Mesh

12:51.620 --> 12:52.400
Agent que

12:52.550 --> 12:55.660
você tenha, se desejar que seus agentes tomem partido.

12:55.790 --> 13:01.160
Então, desenvolvi isso para outra coisa em que estava trabalhando e pensei em colocá-lo aqui.

13:01.160 --> 13:06.170
Isso funciona muito bem se você está tentando fazer com que seus agentes se desloquem pelas ruas e estradas

13:06.170 --> 13:10.880
e deseja que eles permaneçam lá e não vire para a calçada, o que eles farão se

13:10.910 --> 13:12.500
estiverem indo muito rápido .

13:12.590 --> 13:15.580
Isso irá atrasá-los nos cantos para você, então

13:15.590 --> 13:18.070
tome nota disso e, mais adiante,

13:18.380 --> 13:25.480
temos alguns métodos que na verdade não estamos implementando, mas apenas precisamos deles, caso contrário, ele irá reclamar

13:25.850 --> 13:27.370
e mais tarde

13:27.380 --> 13:31.940
quando você Se estiver mais confortável com esse sistema, você pode voltar

13:31.940 --> 13:34.280
e colocar seu próprio código aqui.

13:34.280 --> 13:41.510
Então, primeiro de tudo, há um que é chamado quando o plano falha ... um quando o plano é encontrado ... quando sua ação

13:41.510 --> 13:43.150
terminar ...

13:43.400 --> 13:49.160
e quando seu plano foi abortado. Portanto, se você quiser explorá-las, coloque aqui as

13:49.160 --> 13:51.260
instruções Debug para ver quando

13:51.260 --> 13:54.060
elas realmente são executadas, mas não as usaremos.

13:54.350 --> 13:54.680
Está bem.

13:54.680 --> 14:01.430
Nesse ponto, se você pressionar Play, verá no console (se você for lá) as mensagens que saem do

14:01.430 --> 14:02.020
sistema.

14:02.030 --> 14:08.390
Portanto, essas mensagens estão nas instruções Debug em toda a biblioteca GOAP que você está usando e você pode encontrá-las se

14:08.390 --> 14:12.830
der uma olhada, mas elas vão lhe dar uma idéia do que está acontecendo.

14:12.830 --> 14:17.640
Então, o que estamos recebendo no momento é que são encontradas ações.

14:17.690 --> 14:21.180
Agora, na verdade, ele não encontrou nenhuma ação porque ainda não

14:21.200 --> 14:27.290
colocamos nenhuma ação, mas ainda assim foi encontrado um conjunto de ações vazio e, em seguida, tentando fazer um plano que

14:27.290 --> 14:32.660
satisfaça a meta "doJob" e não consegue encontrar uma. , obviamente, apenas faz isso (SEM PLANO) e, em

14:33.050 --> 14:35.320
seguida, fornece a mensagem 'Falha no plano'.

14:35.390 --> 14:42.320
Então você saberá à medida que avança e programa esse sistema, quando as coisas não estão funcionando. Ok, deixaremos esta palestra aqui e, na

14:42.440 --> 14:47.170
próxima palestra, começaremos a criar ações para o nosso agente.
