WEBVTT

00:10.220 --> 00:16.520
Na última palestra, configuramos o sistema GOAP básico com um agente simples e agora vamos adicionar algumas ações.

00:16.750 --> 00:19.470
Portanto, crie um novo arquivo C

00:19.600 --> 00:26.520
# chamado 'BakeBread' e trarei um que já escrevi antes e veremos o que está lá.

00:26.770 --> 00:28.180
Então, se abrirmos ...

00:28.180 --> 00:33.880
todas as ações que você escreve terão esse mesmo formato.

00:33.880 --> 00:39.440
Agora, todos são módulos separados e individuais por si mesmos, portanto não há vinculação.

00:39.460 --> 00:41.550
Lembre-se: o que os

00:41.960 --> 00:45.850
une são suas condições prévias e seus efeitos correspondentes.

00:45.940 --> 00:51.750
Agora, isso se chama BakeBread e é um GoapAction, portanto, ele herdará

00:51.910 --> 00:55.740
nossas coisas que estão nesse conjunto GoapAction.

00:55.810 --> 01:02.020
A primeira coisa que faremos é definir 'concluído' como Falso, para que este seja um valor booleano

01:02.020 --> 01:08.260
que mantemos, para saber quando terminarmos nossa tarefa. As tarefas também levam

01:08.290 --> 01:16.120
tempo, portanto, acompanharemos o startTime da tarefa, inicializaremos com 0 e definiremos uma workDuration

01:16.120 --> 01:22.660
(por quanto tempo a tarefa leva). É público, para que você possa configurá-lo no Inspetor.

01:22.960 --> 01:27.210
Então, eu tenho isso por 2 segundos e você pode alterá-lo como quiser.

01:27.310 --> 01:36.940
Em seguida, temos nosso construtor público para essa classe, que é onde adicionamos nossas pré-condições e nossos efeitos.

01:36.970 --> 01:43.390
Portanto, essas são provavelmente as coisas mais importantes em todo esse sistema, porque elas

01:43.390 --> 01:45.760
precisam se combinar, em

01:45.880 --> 01:52.900
outras ações, para que elas possam se conectar. Agora você pode ver aqui que nossa pré-condição

01:52.900 --> 02:00.730
para o BakeBread é que 'hasFlour' é True e nosso addEffect (depois de assar o pão)

02:00.880 --> 02:04.230
vai dizer que 'doJob' é True.

02:04.330 --> 02:17.560
Então 'doJob' é verdadeiro em nosso objetivo que estabelecemos, aqui no Worker, que está aqui em cima ... ISSO está combinando ISSO.

02:17.570 --> 02:24.300
Então, isso fará com que o objetivo seja encadeado de volta para ESTE, para que ele possa executá-lo e, se 'hasFlour'

02:24.620 --> 02:31.250
for, de fato, True, então ele começará a executar essa ação específica, caso contrário, será encadeado de volta à lista

02:31.250 --> 02:33.970
, se houver outras ações, para ver

02:34.010 --> 02:39.500
se ele pode continuar satisfazendo-as em algum momento. Agora, neste caso, nós temos farinha

02:39.500 --> 02:40.480
(porque lembre-se

02:40.490 --> 02:46.490
de ter dado ao nosso agente 5 sacos de farinha) e, de volta ao sistema

02:46.490 --> 02:53.340
Worker aqui, estamos injetando o hasFlour, que fornecerá um True porque a farinha é maior que 1.

02:53.480 --> 02:53.770
Certo.

02:53.770 --> 03:00.560
Portanto, o nome aqui é apenas para fins de depuração, para que possamos imprimi-lo se precisarmos (no console) para ver

03:00.560 --> 03:01.990
o que está acontecendo.

03:02.030 --> 03:08.770
Certo, toda ação precisa de um 'reset', para que, quando essa ação for executada novamente, comece com novos

03:08.780 --> 03:09.950
valores.

03:09.980 --> 03:13.170
Portanto, startTime obviamente volta para 0

03:13.520 --> 03:20.150
e 'concluído' volta para False e existem alguns outros métodos necessários: o retorno

03:20.150 --> 03:28.280
de 'concluído' (isDone, para dizer "Terminamos ou não? "), temos outro chamado 'requireInRange' e esta é uma função

03:28.280 --> 03:34.760
que você pode definir como False se permitir que seu agente execute uma tarefa quando ele não

03:34.760 --> 03:37.790
estiver realmente no local em que precisa.

03:37.790 --> 03:45.800
Então, estamos dizendo que "Sim, você precisa estar no local designado para executar sua tarefa (ou esta tarefa

03:45.800 --> 03:47.130
em particular).

03:47.170 --> 03:54.710
Você tem outra opção para pré-condições mais processuais, para poder verificar se outras coisas

03:54.800 --> 04:03.110
no ambiente também são Verdadeiras ou Falsas, antes de o agente executar qualquer uma dessas ações.

04:03.120 --> 04:05.170
Então, no momento, não temos nenhum.

04:05.340 --> 04:07.320
Estamos apenas assando pão,

04:07.500 --> 04:14.430
simplesmente, mas você pode verificar algo como "Talvez você precise de 10 pães antes de

04:14.430 --> 04:17.620
entregá-los à padaria. "ou" Você pode não conseguir assar

04:17.790 --> 04:22.040
se estiver inundando ou chovendo, dependendo do clima. ", todo tipo de

04:22.050 --> 04:28.920
coisa que não se encaixa na cadeia de ações que você colocaria

04:28.920 --> 04:29.750
aqui.

04:29.790 --> 04:37.920
Em seguida, temos o nosso método 'perform', que é interrompido enquanto a tarefa está ocorrendo; portanto, ele inicializa o startTime

04:37.920 --> 04:39.510
e também tenho alguns

04:39.540 --> 04:45.240
Debugs aqui, para que você possa vê-los no console ao iniciar um determinado trabalho

04:45.240 --> 04:45.910
e

04:46.110 --> 04:51.360
quando terminar esse trabalho, portanto, isso ocorre apenas pelo tempo necessário para executar

04:51.360 --> 04:52.150
essa tarefa.

04:52.170 --> 04:54.870
Para cada ação, isso será praticamente o

04:54.900 --> 04:59.370
mesmo, mas você poderá executar coisas diferentes com base na ação em que está.

04:59.370 --> 05:01.320
Essa é a ação do

05:01.500 --> 05:07.920
BakeBread; portanto, no final da ação do BakeBread, estou dizendo que nosso nível de farinha no nosso

05:07.920 --> 05:15.240
inventário diminuirá em 2 (porque lembre-se de que são necessários 2 sacos de farinha para fazer um pedaço de pão) e

05:15.240 --> 05:21.930
depois nós nos livramos de 2 sacos de farinha e, em seguida, adicionamos 1 pedaço de pão ao nosso

05:22.230 --> 05:24.180
inventário, e dizemos que 'concluído'

05:24.360 --> 05:29.600
é Verdadeiro, que concluirá esta tarefa porque será devolvida ao sistema aqui em cima.

05:30.490 --> 05:34.620
Portanto, esse é o código inteiro para o nosso BakeBread.

05:34.680 --> 05:42.510
Então salve isso ... volte para a Unity ... você deseja adicionar esse código ao seu agente.

05:42.750 --> 05:47.340
Portanto, essa é uma ação, você arrasta e solta no agente e

05:47.340 --> 05:51.330
agora pode criar quantas ações quiser e continua arrastando

05:51.330 --> 05:55.330
e soltando-as no agente e o agente saberá sobre essas ações.

05:56.100 --> 06:00.920
Agora, a única coisa que você precisa definir no momento é o Alvo para o BakeBread.

06:00.990 --> 06:02.340
Onde você quer assar pão?

06:02.340 --> 06:09.990
Vamos assá-lo na padaria, por isso encontramos o nosso marcador de padaria (que é a minha 'porta'

06:09.990 --> 06:16.010
da padaria) e vou arrastar e soltar ISSO como o alvo para assar.

06:16.460 --> 06:16.800
Está bem.

06:16.820 --> 06:22.730
Agora você está pronto para executá-lo, então vou mudar para o console para poder ver o que está acontecendo ... basta esclarecer isso e vamos

06:22.730 --> 06:24.350
pressionar Play.

06:24.740 --> 06:29.790
Então, ele será movido para o local em que pode executar a ação BakeBread e, quando chegar lá, começará a

06:29.930 --> 06:35.000
assar pão e você poderá ver isso no console. Quando terminar, você verá

06:35.000 --> 06:40.490
que seu inventário e sua farinha diminuirão 2 a cada vez.

06:40.490 --> 06:41.800
Agora isso aconteceu

06:41.810 --> 06:47.680
muito rapidamente, mas se você voltar e olhar pelo console, há muita coisa lá.

06:47.690 --> 06:52.830
Vamos fazer uma pausa, porque agora ele não consegue encontrar nenhum plano, continuará com o 'Plano com falha'.

06:52.930 --> 06:56.340
Podemos encontrar onde o cozimento aconteceu ... aqui vamos nós.

06:56.340 --> 06:58.670
Então, estamos nos mudando para cá.

06:58.740 --> 07:00.120
Então, nos mudamos para o BakeBread ...

07:00.120 --> 07:07.140
estamos começando o BakeBread ... BakeBread terminado ... mudou-se para BakeBread ... iniciando o BakeBread ... terminou o BakeBread.

07:07.140 --> 07:12.180
Então, nós fizemos 2 pães e depois diz NÃO PLANO e

07:12.270 --> 07:17.610
é porque ficamos sem farinha. Portanto, resta apenas 1 lote de farinha e

07:17.610 --> 07:19.650
temos 2 pães de pão.

07:19.650 --> 07:23.430
Agora não há como obter mais farinha neste momento.

07:23.430 --> 07:26.910
Portanto, o plano para fazer seu trabalho falhou.

07:26.910 --> 07:30.150
Ele não pode continuar enquanto o processa.

07:30.150 --> 07:37.500
Então, o que podemos fazer agora é adicionar outra ação que o ajude a obter um pouco de farinha, para que ele possa continuar assando.

07:37.940 --> 07:40.540
Certo, pare de jogar isso

07:40.710 --> 07:45.940
e, no projeto, você criará um novo arquivo C # chamado

07:46.380 --> 07:49.490
'PickupFlour' e será parecido com este aqui.

07:49.650 --> 07:51.020
Então PickupFlour ...

07:51.180 --> 07:59.610
se for mais fácil para você, faça uma cópia completa da ação BakeBread e, em seguida, coloque-a no script PickupFlour

07:59.680 --> 08:04.090
e, em seguida, certifique-se de alterar o nome aqui ...

08:04.990 --> 08:07.180
e no construtor ...

08:07.180 --> 08:15.280
então LÁ e também o PickupFlour também. Todo o resto pode permanecer exatamente igual, porque

08:15.280 --> 08:17.890
está apenas processando a ação.

08:17.890 --> 08:25.540
Agora, a Pré-condição e o Efeito para o PickupFlour é que vamos pedir ao agente que pegue a farinha quando ficarmos

08:25.540 --> 08:26.620
sem farinha.

08:26.620 --> 08:32.770
Então, quando 'hasFlour for False' é quando essa ação deve ocorrer e o

08:33.070 --> 08:38.190
efeito depois disso é que hasFlour será igual a True.

08:38.230 --> 08:45.520
Portanto, este efeito aqui está definindo hasFlour como True, o que permitirá que a ação BakeBread seja executada.

08:45.520 --> 08:48.090
Então essa é a ligação que acontecerá lá.

08:48.910 --> 08:57.130
Agora, mais abaixo em nosso 'executar', onde precisamos configurar como o inventário vai mudar, é que, depois que terminarmos de pegar a farinha,

08:57.160 --> 09:03.640
poderemos pegar o nível de farinha em nosso inventário. Nesse caso, estou dizendo que, quando ele

09:03.640 --> 09:04.420
for

09:04.420 --> 09:10.950
ao moinho para pegar a farinha, ele poderá transportar 5 lotes de farinha e, portanto,

09:10.960 --> 09:16.780
adicionaremos 5 ao inventário, o que permitirá que ele continue e criando mais

09:16.780 --> 09:18.400
pão por um tempo.

09:18.400 --> 09:18.640
Certo.

09:18.640 --> 09:26.710
Então, quando você tiver tudo isso lá, salve isso, volte para o Unity e esse script novamente

09:27.070 --> 09:30.540
poderá ser jogado (PickupFlour) no agente.

09:30.730 --> 09:34.960
Lembre-se de que precisamos definir nosso destino de destino para pegar a farinha e, nesse caso,

09:34.960 --> 09:37.740
diremos que está na porta do moinho de vento.

09:37.750 --> 09:42.840
Então, usaremos a Porta do Moinho de Vento como nosso Alvo para pegar a farinha.

09:43.090 --> 09:50.680
Agora, quando pressionamos Play, podemos assistir a farinha diminuir (então, diminuiremos 2 com cada pedaço de pão produzido) e

09:50.680 --> 09:56.600
então saberemos quando restar 1 lote de farinha e 2 pães, ele terá que

09:56.620 --> 10:02.260
ir e pegue no moinho e aqui você pode vê-lo brincando para pegar a

10:02.260 --> 10:03.000
farinha.

10:06.380 --> 10:12.770
Agora, se tudo estiver um pouco lento demais para você, lembre-se de clicar no seu agente BAker, ir ao

10:12.770 --> 10:16.070
seu Nav Mesh Agent e alterar a velocidade dele.

10:16.070 --> 10:21.170
Portanto, se definirmos para 15, o que deve acelerar um pouco as coisas, não aumentará o

10:21.170 --> 10:23.970
tempo necessário para concluir as tarefas, apenas aumentará

10:23.990 --> 10:29.540
o tempo que leva para ele ir entre os lugares, para que você possa ver acontecendo um pouco

10:29.930 --> 10:30.680
mais rápido.

10:30.680 --> 10:37.130
Agora podemos ver que ele está voltando ... recebendo a farinha ... a farinha em seu inventário

10:37.130 --> 10:43.010
aumentará para 6 porque você tinha 1, ele adicionou 5 e depois usará essa farinha e

10:43.010 --> 10:46.910
fará mais pão; quando ele acabar, ele voltará e conseguirá.

10:46.910 --> 10:53.870
Agora você pode criar uma cadeia bastante complexa de todos os diferentes eventos que deseja que ocorram em

10:53.870 --> 10:55.300
qualquer comportamento em

10:55.310 --> 11:01.290
particular, mas apenas com alguns você pode obter coisas bastante complexas, como você pode ver aqui.

11:01.530 --> 11:04.570
Tudo bem, então isso está configurando sua pequena cadeia e,

11:04.700 --> 11:07.400
nesse caso, é como uma cadeia de suprimentos.

11:07.610 --> 11:13.610
Na próxima palestra, o que faremos com que ele entregue o pão (quando tiver o suficiente)

11:13.610 --> 11:14.600
aos mercados.
