WEBVTT

00:06.560 --> 00:13.550
Nesta palestra, vamos continuar a escrever algum código que permitirá a nossos agentes executar um

00:13.550 --> 00:14.060
plano.

00:14.060 --> 00:17.350
E então vamos colocar um plano simples em nosso agente.

00:17.360 --> 00:22.820
E antes de começar, se você quiser exatamente o mesmo arquivo de projeto que eu comecei aqui,

00:22.820 --> 00:26.490
ele está anexado a esta palestra como um projeto inicial.

00:26.510 --> 00:31.640
Agora, para fazer isso, vamos entrar em nosso roteiro de agente G.

00:31.640 --> 00:32.600
Então, abra isso.

00:32.600 --> 00:40.640
Agora, se você se lembra de antes, houve uma atualização tardia e na verdade não preenchemos isto.

00:40.640 --> 00:43.610
Portanto, agora é a hora de acrescentar o código.

00:43.610 --> 00:49.520
Certo, então a primeira coisa que vamos fazer aqui é adicionar no planejador.

00:49.790 --> 00:53.210
Portanto, só vou descer um pouco porque quero voltar e colocar outras coisas acima disto

00:53.210 --> 00:54.140
um pouco mais tarde.

00:54.140 --> 01:05.390
Primeiro de tudo, vamos dizer se o planejador é igual a nulo ou nossa deixa de ação, que é devolvida pelo planejador

01:05.390 --> 01:13.850
igual a nulo, isso significa que o agente atualmente não tem planos para trabalhar.

01:13.850 --> 01:15.890
Então, o que vamos fazer aqui?

01:15.890 --> 01:18.200
Bem, nós vamos criar um novo plano.

01:18.200 --> 01:19.820
Assim, criamos um novo planejador.

01:19.820 --> 01:23.660
Antes de mais nada, portanto, planejador é igual a novo planejador G.

01:25.340 --> 01:26.270
Assim.

01:26.600 --> 01:32.550
E então vamos classificar todos os objetivos que temos agora.

01:32.570 --> 01:41.780
Você se lembra quando criamos nosso agente e permitimos que ele tivesse múltiplos sub objetivos?

01:42.200 --> 01:49.100
Portanto, se voltarmos ao topo aqui, um objetivo não é apenas um único objetivo, mas há vários objetivos.

01:49.100 --> 01:57.320
E então também temos o nome do objetivo e estamos armazenando com ele um valor inteiro, que vai ser o quão importante

01:57.320 --> 02:01.960
este objetivo em particular é para satisfazer.

02:01.970 --> 02:09.350
Assim, vamos classificar todos os nossos objetivos e colocá-los em ordem do mais importante para o menos importante, de modo que possamos

02:09.350 --> 02:13.880
então passar por eles um de cada vez até encontrarmos um que possamos fazer.

02:14.030 --> 02:23.150
Portanto, vou fazer uma classificação var, que vai igualar nosso dicionário classificado, que

02:23.150 --> 02:25.670
usará um comando de link.

02:25.670 --> 02:35.900
Portanto, vai ser a partir da entrada em metas, ordem por valor de entrada descendente.

02:37.600 --> 02:39.940
Selecione a entrada.

02:40.600 --> 02:40.960
Certo.

02:41.110 --> 02:43.030
E isso vai levar nossos objetivos.

02:43.030 --> 02:43.750
Muito bem.

02:44.020 --> 02:48.100
E encomende-o e coloque-o em objetivos ordenados.

02:48.260 --> 02:48.520
Certo.

02:48.520 --> 02:52.180
Agora, quando tivermos isso, vamos realmente passar por cada um de cada vez.

02:52.180 --> 02:57.940
Portanto, para cada um deles, queremos o par de valores-chave do sub objetivo.

02:59.140 --> 03:00.820
E int.

03:00.820 --> 03:05.740
Portanto, este é um sub-golo em metas ordenadas.

03:07.570 --> 03:10.390
Então aqui diremos que a deixa de ação.

03:11.570 --> 03:14.570
É igual ao plano de pontos do planejador.

03:14.570 --> 03:16.340
Portanto, é aqui que estamos chamando de plano.

03:16.340 --> 03:22.940
Por isso, estamos assumindo o objetivo mais importante que conhecemos e tentando criar um plano para isso.

03:22.940 --> 03:29.060
Portanto, planejar um plano precisa do conjunto de ações que temos o objetivo.

03:29.060 --> 03:34.370
Portanto, temos esse é o sub objetivo, objetivos chave.

03:35.780 --> 03:38.930
Portanto, são todos esses sub objetivos que compõem esse objetivo.

03:38.930 --> 03:46.490
E então precisamos passar pelo estado, não pelos estados do mundo, mas estas são as crenças do agente e nós na

03:46.490 --> 03:48.950
verdade ainda não as colocamos.

03:48.950 --> 03:51.950
Por isso, neste momento, vamos passar por nulo.

03:52.820 --> 03:59.240
Certo, então não estamos usando o sistema de crenças, ele só vai usar os objetivos mundiais que temos.

03:59.240 --> 04:01.730
Então, se agirmos, vamos.

04:01.730 --> 04:08.930
P Depois de termos feito isto não é igual a nulo, então devemos ter um plano que possamos seguir.

04:09.260 --> 04:16.910
E nesse caso, vamos estabelecer o objetivo atual em que estamos trabalhando para igualar

04:16.910 --> 04:20.030
o g, o sub objetivo, o valor chave.

04:20.120 --> 04:26.660
E então vamos fugir porque não precisamos continuar a procurar esses objetivos para outro

04:26.660 --> 04:28.730
plano, porque já temos um.

04:28.730 --> 04:32.000
Portanto, esse é basicamente o nosso plano.

04:32.000 --> 04:36.260
E agora lembre-se da atualização tardia, é um loop, ele vai loop e loop e loop.

04:36.260 --> 04:36.540
Certo.

04:36.620 --> 04:44.270
Assim, quando ele se desdobrar na primeira vez e não tivermos um plano ou uma execução, então teremos um planejador.

04:44.420 --> 04:51.380
Agora, se temos uma ação, então, logo acima disto, quero testá-la primeiro.

04:51.380 --> 04:56.150
Portanto, se estamos no meio de uma ação, então eu vou voltar desta atualização tardia

04:56.150 --> 04:58.940
antes de entrarmos na fase de planejamento.

04:59.060 --> 05:10.430
Portanto, aqui em cima iremos se a ação atual não for igual a um ponto de ação nulo e corrente.

05:10.610 --> 05:15.560
Portanto, podemos dizer que estamos realmente trabalhando em nossa ação.

05:15.560 --> 05:22.610
Agora, se estamos trabalhando em nossa ação, o que vamos fazer é colocar se a ação atual.

05:23.550 --> 05:24.990
Agente de ponto.

05:25.760 --> 05:30.890
O ponto tem caminho e corrente.

05:31.600 --> 05:32.350
Ação.

05:32.710 --> 05:38.970
A distância restante do agente é inferior a um f.

05:38.980 --> 05:44.470
Agora, isto, como você reconhecerá, é código de malha de navegação.

05:44.650 --> 05:50.590
E por isso precisamos ter isto aqui para que o agente se aproxime do objetivo.

05:50.860 --> 05:59.890
Agora, assim que o agente tiver uma meta e ela tiver realmente atingido essa meta, e estamos dizendo

05:59.890 --> 06:08.440
neste caso, como a menos de uma distância, então vamos correr o fim de nossa ação, que é correr basicamente

06:08.650 --> 06:11.650
a conclusão da mesma.

06:11.800 --> 06:12.070
Certo.

06:12.070 --> 06:16.930
Agora lembre-se de que colocamos em cada ação uma duração.

06:17.200 --> 06:23.680
Assim, quando chegamos a este ponto, atingimos nosso objetivo de localização, então precisamos esperar pela duração do mesmo.

06:23.680 --> 06:29.650
Então, digamos que você tenha balançado até a mesa de registro e está se registrando, então você

06:29.650 --> 06:36.430
chegou lá fisicamente, e então vai levar 10 segundos para realmente completar a tarefa que o agente está fazendo

06:36.430 --> 06:36.990
lá.

06:37.000 --> 06:38.860
Este é o código que fará isso.

06:38.860 --> 06:48.790
Portanto, vamos dizer, se não for invocado e explicarei isto em um momento e se não for invocado,

06:48.790 --> 06:55.900
então vamos invocar um método externo chamado completo.

06:57.270 --> 06:58.230
Ação.

06:58.960 --> 07:06.790
E isso vai ser enviado através da ação atual de curta duração.

07:07.840 --> 07:13.270
Bem, na verdade, vai ser invocado nesses 10 segundos mais tarde e depois invocado.

07:14.760 --> 07:17.430
Igual a verdade.

07:17.700 --> 07:22.860
Agora, quando começarmos a ser invocados, será falso e eu vou apenas colocá-lo aqui.

07:23.190 --> 07:27.450
Portanto, bool invocado e equivale a falso.

07:27.450 --> 07:31.150
Portanto, sabemos que a primeira vez que entrarmos aqui, isto será falso.

07:31.170 --> 07:40.580
Ele nos permitirá entrar aqui, invocar este método de ação completo em quaisquer segundos, e então ele se define invocado

07:40.580 --> 07:42.030
como verdadeiro.

07:42.030 --> 07:46.530
Portanto, nunca mais voltaremos a entrar aqui neste ponto.

07:46.530 --> 07:48.270
Não podemos deixar que isso não nos deixe.

07:48.270 --> 07:56.280
Mas o método de ação completo que vamos utilizar aqui em cima vai ser invocado de novo como falso

07:56.280 --> 07:57.120
para nós.

07:57.120 --> 08:02.130
Portanto, queremos uma ação nula e completa.

08:03.510 --> 08:11.690
E então, dentro deste método, a ação atual em execução é igual a falsa.

08:11.700 --> 08:18.060
Portanto, é aqui que finalmente dizemos que terminamos de executar nossa ação atual e isso forçará nosso sistema de planejamento

08:18.060 --> 08:20.130
a seguir o plano novamente.

08:20.430 --> 08:26.340
E por isso queremos que o atual posto de ação seja realizado.

08:27.630 --> 08:34.260
Que é o método que executamos logo no final e, em seguida, vamos voltar a invocar a falsidade.

08:35.830 --> 08:36.370
Certo.

08:36.370 --> 08:44.350
Então é isso que acontece quando terminamos uma ação atual e depois de quantos anos de duração

08:44.350 --> 08:48.580
ela vai durar, o que significa que ela vai falhar.

08:49.180 --> 08:55.090
Desculpe-me por um momento enquanto eu comprava em meu próprio vídeo só para dizer que eu perdi uma declaração de retorno que você

08:55.090 --> 08:58.000
precisará colocar dentro disso se a declaração for feita.

08:58.630 --> 09:05.920
Agora, nesse ponto, ou você ficou sem ações ou ainda tem mais ações em sua fila.

09:05.920 --> 09:08.890
Portanto, se for esse o caso, precisamos agora considerar isso.

09:08.890 --> 09:18.970
Portanto, abaixo de nossa declaração para nosso planejador, vamos considerar se a ação Q não é igual a nula.

09:18.970 --> 09:30.460
Portanto, temos realmente uma fila de ação e a contagem de pontos da fila de ação é igual a zero, o que significa que temos uma

09:30.460 --> 09:35.380
fila de ação vazia e ficamos sem coisas para fazer.

09:35.380 --> 09:39.610
Então, podemos ir se a meta atual for removida.

09:39.610 --> 09:46.750
Portanto, se a meta na qual temos trabalhado é uma dessas metas removíveis, então podemos dizer

09:47.230 --> 09:57.370
metas, remover nossa meta atual de lá e então vamos fazê-lo depois de termos feito aquele planejador definido para igualar nulo, o que vai

09:57.370 --> 10:03.370
desencadear a obtenção de outro plano e da próxima vez que este loop passar.

10:03.670 --> 10:12.820
Agora, finalmente, há mais uma condição de declaração que precisamos considerar aqui que

10:12.820 --> 10:16.600
pode ocorrer e que é se fila de ação.

10:17.800 --> 10:19.230
Não é igual a nulo.

10:20.240 --> 10:22.880
E a ação.

10:23.090 --> 10:26.660
A contagem dos pontos de taco é maior que zero.

10:26.660 --> 10:32.980
Isso significa que ainda temos ações deixadas em nossa fila que voltaram do planejador.

10:32.990 --> 10:35.450
Nesse caso, podemos começar a executá-los.

10:35.450 --> 10:41.290
Por isso, agora vamos ter a ação atual e vamos ser iguais à ação.

10:41.300 --> 10:42.080
Q.

10:42.920 --> 10:43.870
Ponto D.

10:43.880 --> 10:50.390
P E isto tomará a ação que está sentada no topo de nossa fila fora da fila e a colocará em

10:50.390 --> 10:51.500
ação atual.

10:51.530 --> 10:57.530
Agora executamos então o método de pré-desempenho que temos para nossa ação.

10:57.530 --> 11:02.600
Por isso, vai ser um ponto de ação atual de pré-apresentação.

11:03.860 --> 11:09.140
E ali podemos fazer todas as verificações que precisamos fazer, como para atributos físicos que precisam

11:09.140 --> 11:14.060
ser ditos se o número de, digamos, cubículos estiver disponível e todo esse tipo de coisas.

11:14.270 --> 11:24.800
E então, se isso for verdade, queremos ir se a meta de ação atual for igual a zero.

11:25.990 --> 11:34.870
E a marca de alvo de ação atual não equivale a uma corda vazia.

11:35.110 --> 11:48.430
Então o que vamos fazer é ir que o alvo de ponto de ação atual é igual ao alvo de ponto de ação do jogo com tag

11:48.730 --> 11:51.640
ponto de ação atual.

11:52.370 --> 12:05.060
Marca do alvo para que possamos definir o alvo para o agente de malha de navegação, definindo-o no inspetor.

12:05.570 --> 12:08.390
Ou podemos encontrá-lo usando uma etiqueta.

12:08.390 --> 12:14.720
Portanto, se você fez um pré-fabricado de seu personagem, será muito mais fácil para você apenas definir a etiqueta.

12:14.720 --> 12:19.330
Então, ele faz esta busca quando entra no ambiente para procurá-la.

12:19.340 --> 12:23.390
Agora, como você pode ver, estou recebendo erros com nossa tag alvo aqui.

12:23.660 --> 12:30.260
Se eu salvar isso rapidamente e voltar à minha ação G e você talvez queira dar uma olhada aqui,

12:30.260 --> 12:37.670
você pode ver que nós definimos a tag alvo para ser um objeto de jogo quando de fato é para ser uma corda.

12:37.670 --> 12:41.780
Então isso foi apenas um pequeno erro que eu cometi antes e que ainda estará em seu código.

12:41.780 --> 12:46.520
Portanto, basta salvar isso e depois podemos voltar para nosso agente.

12:46.790 --> 12:53.930
A outra coisa que você pode ver aqui é que os objetos de jogo a serem encontrados com tag precisam ser um G maiúsculo lá dentro.

12:54.050 --> 12:55.550
Agora vamos terminar isto.

12:55.550 --> 13:00.410
Se temos nossa declaração de que temos nosso objeto-alvo, então vamos embora.

13:00.410 --> 13:06.800
Se a meta de ação atual não for igual a zero.

13:06.800 --> 13:14.360
Portanto, ainda pode ser que acabemos não tendo para onde ir, a ponto de mudar nosso agente de lugar.

13:14.360 --> 13:20.180
E se for esse o caso, vamos verificar se não é igual a nulo.

13:20.180 --> 13:31.340
Portanto, se não for igual a zero, o alvo, não a etiqueta, eu deveria dizer que o ponto de ação atual é igual a verdadeiro.

13:31.340 --> 13:35.240
E é aqui que a ação realmente começa a ter lugar.

13:35.330 --> 13:46.310
Vamos nos livrar desse T e do ponto de ação atual do agente de ponto de ajuste de destino e esse é nosso agente de malha de navegação

13:46.310 --> 13:49.910
ajustando o destino para a corrente.

13:51.580 --> 13:52.510
Ação.

13:53.290 --> 13:57.340
Ponto alvo, ponto transform.

13:57.970 --> 14:00.160
Posição do ponto.

14:00.940 --> 14:01.420
Está bem.

14:01.420 --> 14:09.460
Portanto, este é o ponto de partida para definir o destino de nosso agente.

14:09.460 --> 14:14.320
E então para cima é onde estamos realmente testando se conseguimos chegar ao destino.

14:14.320 --> 14:20.080
Agora, lembre-se que o código do agente de malha de navegação vai fazer sua coisa automaticamente em

14:20.080 --> 14:22.720
segundo plano, até o ponto de mover o agente.

14:22.750 --> 14:23.200
Certo.

14:23.200 --> 14:25.890
Por isso, vamos terminar essa declaração agora mesmo.

14:25.900 --> 14:34.540
Caso contrário, se não pudermos fazer nosso método de pré-desempenho, vamos dizer fila de ação.

14:35.850 --> 14:37.290
Igual a nulo.

14:37.770 --> 14:43.170
E isso nos obrigará a ter um novo plano.

14:43.200 --> 14:44.310
Voltar para os objetivos.

14:44.310 --> 14:45.160
Adquira um novo plano.

14:45.180 --> 14:53.010
Agora, se qualquer uma de suas ações pelas quais você está trabalhando ou tentando trabalhar falhar, então ele vai replanear

14:53.010 --> 14:58.890
tudo, o que pode de fato planejar exatamente a mesma seqüência de ações, mas enviá-lo de

14:58.890 --> 15:04.110
volta para o início para que ele se certifique de que você faça isso.

15:04.110 --> 15:09.480
E também garante que seu agente não fique preso em algum lugar no meio de um plano.

15:09.960 --> 15:14.220
Certo, então agora que já temos isso, vamos apenas salvá-lo.

15:14.250 --> 15:20.130
Esse é nosso principal código para nossa atualização tardia.

15:20.730 --> 15:21.180
Certo.

15:21.180 --> 15:23.130
Vamos voltar à unidade.

15:23.130 --> 15:28.040
Agora vamos criar nossa classe básica para nosso paciente.

15:28.050 --> 15:32.690
Portanto, clique com o botão direito do mouse e crie um novo roteiro em C afiado.

15:32.700 --> 15:36.960
Vamos ligar para este paciente e depois abrir isto.

15:36.960 --> 15:38.940
Vai ser um código muito curto.

15:38.940 --> 15:42.720
Assim, o paciente vai herdar de G.

15:42.720 --> 15:46.380
Agente e não vai ter uma atualização.

15:46.380 --> 15:48.240
Vai ter um começo.

15:48.240 --> 15:56.730
Agora, no início, queremos chamar o início da base que está acontecendo no roteiro do agente G e depois vamos criar um

15:56.730 --> 15:57.900
sub objetivo.

15:57.900 --> 16:09.060
Portanto, um sub-golo S é igual a um novo sub-golo e o sub-golo estará esperando e daremos prioridade a um e diremos que é verdade,

16:09.060 --> 16:17.250
o que o removerá de ser um objetivo e então teremos que adicioná-lo a nossos objetivos.

16:17.250 --> 16:19.470
Portanto, os objetivos acrescentam.

16:20.480 --> 16:26.360
S um e sua prioridade neste caso são três.

16:26.540 --> 16:33.680
Agora este início em particular e nosso agente G, vamos apenas salvar isto, vamos voltar para os agentes G querem

16:33.680 --> 16:41.450
apontar algo que você precisa consertar aqui que eu acabei de fazer antes é adicionar um público ao início, caso contrário,

16:41.450 --> 16:46.430
você vai receber um erro quando tentar chamar esse início de base.

16:46.430 --> 16:51.230
Mas basicamente o ponto de base começa a configurar todas as suas ações que você prendeu ao seu

16:51.230 --> 16:56.000
paciente, e então você pode ir em frente e executar o resto deste código de paciente, certo?

16:56.000 --> 17:03.110
Portanto, vamos salvar isso, voltar à unidade e agarrar esse roteiro paciente e arrastá-lo

17:03.110 --> 17:05.390
e soltá-lo em seu paciente.

17:05.660 --> 17:06.020
Sim.

17:06.020 --> 17:07.280
E aí está ele.

17:07.280 --> 17:13.310
Agora precisamos realmente de uma ação a ser seguida, então vamos fazer uma ação rápida.

17:13.310 --> 17:18.020
E aqui, vamos criar C-sharp e vamos chamar isso de C-sharp.

17:18.020 --> 17:20.120
Ir para o hospital.

17:20.390 --> 17:22.490
Abra isso para editá-lo.

17:22.880 --> 17:25.880
E desta vez, não vai ser um comportamento mono.

17:25.880 --> 17:28.340
Isto será na verdade uma ação g.

17:28.850 --> 17:33.050
E dentro daqui, vamos nos livrar do nosso começo e atualizar.

17:33.050 --> 17:44.330
E tudo o que precisamos fazer é colocar uma bobina de anulação pública para nossa pré-execução, a qual apenas colocaremos de volta

17:44.330 --> 17:52.880
verdadeira lá dentro e, em seguida, uma cópia disso aqui embaixo para nosso desempenho no posto.

17:54.250 --> 17:58.660
Portanto, esta é uma ação padrão básica de estoque.

17:58.660 --> 17:59.800
Portanto, poupe isso.

17:59.800 --> 18:01.480
Agora volte à unidade.

18:01.480 --> 18:09.610
Vamos anexar este hospital de ouro ao nosso paciente, o que lhe dará acesso para poder realizar

18:09.610 --> 18:12.210
essa ação em particular.

18:12.220 --> 18:17.530
Agora esta ação, lembre-se, temos condições prévias e condições pósvias que podemos colocar

18:17.530 --> 18:18.310
aqui.

18:18.310 --> 18:22.420
Digamos que, só por enquanto, não há nenhuma condição prévia.

18:22.930 --> 18:28.000
O efeito posterior terá de corresponder ao nosso objetivo, seja ele qual for.

18:28.000 --> 18:34.870
Agora, o objetivo para nosso paciente, se voltarmos ao roteiro aqui, é esperar.

18:35.470 --> 18:40.720
Muito bem, de volta à unidade em nosso paciente, vamos acrescentar um.

18:41.640 --> 18:47.890
O efeito secundário e vai ser esperado e é aqui que precisa ser soletrado corretamente.

18:47.910 --> 18:51.990
Agora, o valor neste caso não importa porque não estamos realmente usando-o para nada.

18:52.350 --> 18:58.290
A outra coisa que precisamos saber é onde o alvo desta ação vai ocorrer agora, porque

18:58.290 --> 19:06.180
o agente está no local, na hierarquia com, digamos que vamos ao hospital na área de espera, então pegue a

19:06.180 --> 19:10.340
área de espera e arraste e solte-a em seu alvo.

19:10.350 --> 19:11.400
Vai ficar tudo bem.

19:11.400 --> 19:16.560
Não é um pré-fabricado, portanto não temos que procurá-lo usando a etiqueta da área de espera.

19:16.920 --> 19:17.370
Certo.

19:17.370 --> 19:27.300
Portanto, agora se pressionarmos o jogo, nosso agente vai formular um plano para garantir que esse objetivo de espera ocorra.

19:27.300 --> 19:33.930
E, como você pode ver, fez isso porque tudo o que precisava fazer era correr o roteiro para ir ao hospital

19:33.930 --> 19:36.480
a fim de satisfazer seu objetivo.

19:36.900 --> 19:38.190
Então, lá vamos nós.

19:38.190 --> 19:46.050
Há nosso sistema de plano muito, muito básico, muito, muito simples que funciona em nosso sistema de corda, que acabamos

19:46.050 --> 19:47.160
de montar.

19:47.970 --> 19:52.260
Assim, agora em diante e para cima, para ações mais complexas.
