WEBVTT

00:10.660 --> 00:17.620
Nesta segunda aula sobre nós Sequenciais, veremos mais de perto como eles funcionam e alguns dos problemas que você

00:17.620 --> 00:21.330
pode ter quando tenta criar seus próprios e executá-los.

00:21.340 --> 00:28.320
Então, primeiro de tudo, vamos criar uma nova Árvore de Comportamento baseada no 'Wander'. Então crie um novo.

00:28.330 --> 00:36.160
O que eu costumo fazer é apenas duplicar o que eu tenho e vou chamar isso de Patrulha. BT.

00:36.640 --> 00:44.410
Vamos fazer com que o bot patrulhe pelo mapa, então definiremos os destinos nos

00:44.410 --> 00:45.660
cantos específicos.

00:45.730 --> 00:49.170
Agora é lembrado o que estava em Wander, porque era uma duplicata.

00:49.380 --> 00:55.750
O que queremos fazer é poder dizer aonde ir, em vez de escolher um destino aleatório.

00:55.750 --> 01:01.600
Portanto, para isso, precisaremos de um novo método de volta à nossa classe de IA e vamos chamá-lo

01:01.960 --> 01:07.300
de PickDestination e dizeremos que queremos que ele chegue aos nossos pontos extremos que configuramos.

01:07.300 --> 01:11.040
Portanto, começaremos com -100 e este é um

01:11.260 --> 01:18.250
exemplo de como você pode passar argumentos do script da Árvore de Comportamento para seus

01:18.250 --> 01:19.190
métodos.

01:19.210 --> 01:24.070
Então, quando você os declara, eles podem ser 'int's que você está enviando, eles podem

01:24.100 --> 01:26.500
ser' bool's, eles podem ser 'float's.

01:26.500 --> 01:32.890
Vamos fazer esses carros alegóricos, na verdade, eu vou colocar '. 0 'no final, porque eles são locais no espaço

01:33.220 --> 01:39.850
e, depois disso, podemos reutilizar o MoveToDestination porque o MoveToDestination está apenas monitorando o nosso bot se movendo

01:39.930 --> 01:42.240
em direção a um destino.

01:42.310 --> 01:47.770
Se você não tivesse isso e tivesse apenas PickDestination, PickDestination, PickDestination,

01:47.770 --> 01:56.740
PickDestination, ele falharia em se mover em qualquer lugar porque, antes que tivesse a chance de se mover, obteria

01:56.740 --> 02:04.840
um novo destino definido no Nav Mesh Agent. É o MoveToDestination aqui que monitora o que o Nav Mesh

02:04.840 --> 02:10.740
Agent está fazendo em segundo plano, dando a você tempo para ir de um local para outro.

02:10.900 --> 02:18.310
Agora haverá 4 (copiarei e coloco aqui) porque temos 4 cantos diferentes que

02:18.310 --> 02:19.800
queremos ir.

02:19.960 --> 02:24.440
Então, vamos começar em -100, -100 e

02:24.520 --> 02:36.020
depois vamos para -100, 100 e depois vamos para 100, 100 e depois vamos para 100, -100 assim.

02:36.020 --> 02:37.330
Então salve isso.

02:37.610 --> 02:39.960
Então você quer voltar para a Unity.

02:40.160 --> 02:45.380
Você deseja selecionar o Droid e alterar sua Árvore de Comportamento

02:45.380 --> 02:52.850
para patrulha, então arraste e solte Patrulha. Entre na sua Árvore de Comportamento e você verá aqui a nova que está surgindo.

02:52.850 --> 03:00.090
Agora, se você esperar um pouco, receberá uma mensagem de erro que será exibida e elas ficarão vermelhas se não

03:00.200 --> 03:07.590
existirem como um método na sua classe de IA. Eu já escrevi o meu, então ele encontrou e está bem.

03:07.610 --> 03:10.750
Mesmo se você tiver um erro de ortografia nos nomes dos

03:10.850 --> 03:11.720
seus métodos, ele

03:11.750 --> 03:15.720
será exibido e verifique se você verificou se é o mesmo nos dois lugares.

03:15.740 --> 03:17.240
O mesmo vale para seus parâmetros.

03:17.240 --> 03:18.440
Estamos enviando através de carros alegóricos.

03:18.440 --> 03:23.560
Deve estar esperando por um carro alegórico dentro da classe de IA.

03:23.620 --> 03:28.460
Portanto, na sua aula de IA (porque você provavelmente está vendo erros no momento,

03:28.460 --> 03:28.910
vamos

03:28.910 --> 03:32.870
abri-lo e dar uma olhada, aqui está, aqui) acima de PickRandomDestination.

03:32.870 --> 03:39.410
Eu criei um novo método chamado PickDestination com um valor X e Z para o nosso mapa e,

03:39.950 --> 03:47.330
em seguida, estamos usando 'dest' como um novo vetor que está em X e Z, em vez de ser um

03:47.330 --> 03:48.300
valor aleatório.

03:48.320 --> 03:49.840
Y é definido como

03:49.970 --> 03:53.120
0 porque nosso plano de terra está sentado em 0.

03:53.150 --> 03:56.810
Se o seu plano básico não for 0, convém

03:56.960 --> 04:03.180
ajustar isso e executar o SetDestination e retornar com um sucesso e é tudo o que

04:03.410 --> 04:08.780
precisamos fazer para patrulhar agora, porque o código do MoveToDestination já está fazendo

04:08.780 --> 04:10.700
o que precisamos. Faz.

04:11.160 --> 04:19.750
Então adicione isso, salve-o e depois voltemos ao Unity e pressione Play e veremos o Droid em ação.

04:19.760 --> 04:28.400
Se você clicar no Droid na Hierarquia, poderá assistir a cada um desses nós de folhas sendo executados enquanto

04:29.450 --> 04:34.230
o Droid percorre o caminho. Portanto, o MoveToDestination está em execução no momento.

04:34.340 --> 04:39.660
Vai passar rapidamente para PickDestination (ou foi o que foi feito) até o próximo MoveToDestination,

04:39.890 --> 04:47.190
quando atingir cada waypoint que você está configurando através do código para acessar e, porque essa 'Repetir raiz' está marcada na

04:47.190 --> 04:53.850
parte superior, vai dar voltas e voltas e voltas e voltas nessa sequência, que é o que você deseja

04:53.850 --> 04:55.260
que ela faça.

04:56.150 --> 05:03.170
Portanto, com tudo isso funcionando bem, vamos forçar a ocorrência de um erro para que você possa ver o que acontece.

05:03.200 --> 05:10.020
Então, vamos ao script da IA e estamos procurando por PickDestination.

05:10.220 --> 05:15.600
Portanto, o PickDestination tem no final uma tarefa. atual. Succeed (); '.

05:15.650 --> 05:23.510
Esta NÃO é uma declaração de retorno, portanto, não o tira deste método e você pode chamá-lo de

05:23.670 --> 05:28.460
qualquer lugar dentro do código. Ele apenas enviará um Sucesso de volta à Árvore de Comportamentos.

05:28.520 --> 05:30.620
Assim, você pode realmente deixar de fora

05:30.640 --> 05:36.970
e não receberá um erro, e é isso que vamos fazer. Vamos apenas comentar e salvá-lo, e depois voltaremos

05:36.980 --> 05:39.080
ao Unity e pressionar Play.

05:40.730 --> 05:45.100
Agora vamos dar uma olhada no que estamos chegando aqui.

05:45.140 --> 05:49.810
Você pode ver que o PickDestination foi executado.

05:50.060 --> 05:51.430
Vê que é azul?

05:51.440 --> 05:53.370
Não terminou de executar.

05:53.420 --> 05:55.550
É verde quando termina a corrida.

05:55.550 --> 06:01.070
Agora você provavelmente está se perguntando "Bem, o bot ainda está se movendo, ainda está se movendo para o destino. "e ele será movido para o

06:01.070 --> 06:06.920
destino porque o código do Nav Mesh Agent é o que o leva adiante.

06:06.920 --> 06:11.630
Depois que vamos agente. SetDestination ', o agente vai fazer isso.

06:11.840 --> 06:16.640
É o MoveToDestination que está sentado monitorando, esperando que ele chegue aonde

06:16.640 --> 06:19.530
deve ir, para que ele possa escolher

06:19.640 --> 06:25.420
o PRÓXIMO destino, mas você pode ver agora que concluiu que 1 caminho encontrado até

06:25.820 --> 06:29.410
aqui está parado. Toda a Árvore de Comportamentos parou completamente.

06:29.510 --> 06:35.840
Para que Succeed seja absolutamente necessário, e se você achar que suas Árvores de Comportamento estão apenas parando, você

06:35.990 --> 06:38.480
esqueceu de colocar um Succeed or Fail.

06:38.480 --> 06:41.610
Agora você também pode colocar um Fail aqui

06:41.720 --> 06:47.610
e, como está repetindo, ele irá girar, girar, girar e constantemente falhar, de modo que ele

06:47.610 --> 06:54.080
se moverá pelas seqüências até atingir um Fail e dispará-lo para fora e podemos realmente forçar isso

06:54.320 --> 06:56.770
a acontecer e dar uma olhada.

06:56.770 --> 06:59.570
Então, voltemos ao código e

07:00.920 --> 07:03.470
colocarei Succeed de

07:03.470 --> 07:06.490
volta para que possamos descer,

07:06.650 --> 07:13.560
mas o que eu quero fazer é ter esse aqui, o PickRandomDestination.

07:13.580 --> 07:24.450
Vamos definir isso como Fail. Então, para o Panda, é assim, então isso retornará uma 'falha' quando tentarmos fazer

07:24.450 --> 07:25.370
um PickRandomDestination.

07:25.560 --> 07:28.230
Vamos entrar em

07:28.240 --> 07:39.340
nossa patrulha e, como a segunda configuração de destino, nos livraremos dos parâmetros e colocaremos isso como PickRandomDestination como

07:39.970 --> 07:45.410
fizemos antes, quando estávamos vagando. Então salve isso e

07:45.460 --> 07:47.550
vamos voltar aqui,

07:47.600 --> 07:55.510
pressione Play e vamos assistir a árvore. Então o PickDestination agora foi bem-sucedido (é verde) e estamos

07:55.510 --> 08:01.350
nos mudando para o nosso destino, então isso continuará passando até o bot subir no canto;

08:01.350 --> 08:05.430
nesse momento, ele tentará executar esse PickRandomDestination que sabemos que vai falhou.

08:05.650 --> 08:07.400
Então está

08:07.520 --> 08:16.920
chegando à esquina, parou e aí, você pode ver que está vagando tentando se

08:16.920 --> 08:25.620
virar porque esse é o 'agente. SetDestination 'é constantemente chamado, neste PickDestination e, em seguida, tenta passar para

08:25.620 --> 08:29.650
ele e escolhe o mesmo destino para o qual já fomos.

08:29.700 --> 08:33.390
Então, quando tentamos fazer um MoveDestination, já estamos lá.

08:33.390 --> 08:36.950
Em seguida, fazemos um PickDestination que

08:37.140 --> 08:42.750
falha imediatamente e, como estamos percorrendo essa rota, ele fica preso.

08:42.780 --> 08:49.580
Você pode ver que está travado e os valores de Sucesso e Falha passando rapidamente para lá em cima e, como é vermelho, você

08:49.770 --> 08:55.680
sabe que é onde há um ponto de falha em sua árvore e você pode querer um ponto de falha

08:55.680 --> 09:02.340
em sua árvore, se é isso que a sequência vai fazer. Se uma determinada condição NÃO

09:02.400 --> 09:09.030
for atendida na sequência, não será necessário continuar com a sequência.

09:09.030 --> 09:14.400
Então, vamos tirar isso de lá e voltar e reparar nosso código.

09:14.460 --> 09:22.710
Então, aqui, pressionarei Ctrl-Z para recuperar o que tinha antes e voltar ao meu script de IA. Vou definir

09:22.710 --> 09:29.810
meu destino aleatório de volta para Succeed ... Curtiu isso.

09:30.120 --> 09:32.840
Vamos agora considerar uma sequência de ataque.

09:32.850 --> 09:36.700
Então, nesta sequência, eu vou ter 3 comportamentos diferentes.

09:36.870 --> 09:46.400
Queremos que o próprio bot seja capaz de se voltar para um destino específico, e não para esse destino.

09:46.410 --> 09:52.200
Então, isso envolverá definir o ponto que queremos observar e, na verdade, fazer

09:52.890 --> 10:01.630
a curva e, depois que isso acontecer, poderemos executar uma ação de disparo / Ok, então a Árvore de

10:01.790 --> 10:07.880
Comportamento para isso, chame de 'Ataque. BT 'e aí você quer algo parecido com isso.

10:07.890 --> 10:08.860
Então,

10:08.880 --> 10:18.420
temos nossa 'Root', nossa 'sequência', 'TargetPlayer', 'LookAtTarget' e depois 'Fire'.

10:18.500 --> 10:27.140
Agora, isso significa que cada um deles precisa ser um método em nossa classe de IA. Para cada um dos nós da folha na

10:27.140 --> 10:31.940
nova árvore de ataque, é preciso haver um método correspondente.

10:31.940 --> 10:33.780
Primeiro de tudo, eu tenho o 'TargetPlayer'.

10:33.800 --> 10:41.380
Tudo o que está fazendo é definir um Vector3 que é declarado no topo do nosso programa para a posição do jogador.

10:41.630 --> 10:48.200
É tudo o que está fazendo, portanto, basta definir o valor de 'target'. Agora, fazê-lo dessa maneira significa que poderíamos

10:48.200 --> 10:55.820
ter outros nós de folha que diriam 'olhar para árvore' ou 'olhar aleatoriamente' e ser capaz de definir esse

10:55.820 --> 10:59.160
valor 'alvo' sem avançar em direção a ele.

10:59.240 --> 11:06.110
Depois disso, eu tenho um 'LookAtTarget', então este é genérico, que mudará o bot e estará

11:06.110 --> 11:10.420
voltado para onde quer que esse alvo seja definido.

11:10.640 --> 11:15.230
Então, basta rolar um pouco e aumentar um pouco para que você possa ver a coisa toda.

11:15.380 --> 11:20.770
Esse é praticamente o mesmo código que usamos antes (vou colocar isso na próxima

11:21.200 --> 11:22.710
linha para você,

11:22.750 --> 11:27.200
lá vamos nós) para direcionar algo e avançar em direção a ele,

11:27.200 --> 11:34.670
mas, neste caso, estamos direcionando e virando em direção a. Então você verá aqui o familiar

11:34.680 --> 11:37.300
Quaternion. Código Slerp que usamos

11:37.400 --> 11:45.310
anteriormente e nosso cálculo do vetor de direção. Tão... direção... deslize em direção a ela.

11:45.330 --> 11:51.590
Agora eu tenho um Debug. Entre aqui, do qual vou me livrar, porque não precisamos

11:51.780 --> 11:59.850
dele e, em vez disso, há uma 'Tarefa. isInspected '. Essa linha aqui nos permitirá ver

12:00.000 --> 12:09.420
o ângulo atual entre o bot e onde o nosso jogador está (neste caso, o alvo) na linha de depuração dentro

12:09.420 --> 12:14.640
da Árvore de Comportamento, o que é fantástico, porque podemos realmente

12:15.000 --> 12:26.370
ver esse valor mudando como o bot se vira e então estamos dizendo no final, se o ângulo estiver dentro de 5 graus, essa tarefa

12:26.370 --> 12:27.480
foi bem-sucedida.

12:27.540 --> 12:33.150
Então, vamos continuar girando, continuar girando, continuar girando e, em seguida, obteremos um 'sucesso'

12:33.150 --> 12:39.270
nessa tarefa em particular, porque não houve uma falha e até que uma falha recebida

12:39.270 --> 12:47.910
pela Árvore de Comportamento, ela ainda continue estar executando isso. Agora, depois de olharmos para o 'alvo', vamos disparar e o código de

12:48.000 --> 12:50.780
disparo é bem familiar. Nesse caso, não

12:50.790 --> 12:56.330
será o mesmo tipo de configuração que temos aqui, onde você tem um

12:56.490 --> 13:00.600
vazio público e, em seguida, um retorno de Succeed.

13:00.740 --> 13:08.880
O que você também pode fazer com esses métodos para esses nós folha é que eles retornem um valor 'true' ou 'false' para

13:08.910 --> 13:16.170
que você possa verificar se eles ocorreram ou não e executar uma pequena lógica booleana na própria árvore de comportamento,

13:16.200 --> 13:17.410
mesmo apesar

13:17.550 --> 13:20.420
de não estarmos fazendo isso com isso, neste

13:20.430 --> 13:22.620
caso, mas você verá isso acontecer

13:22.770 --> 13:29.130
no futuro e, se não estiver, poderá configurá-lo da mesma maneira que os outros com o sucesso

13:29.820 --> 13:31.120
devolvido. em vez de.

13:31.320 --> 13:41.270
Agora, aqui, estamos apenas obtendo a pré-fabricação de balas e instanciando uma cópia dela no final do bulletSpawn. Novamente, o mesmo que fizemos na demonstração dos

13:41.280 --> 13:48.690
tanques, muito antes no curso. Então, estamos adicionando uma força à

13:49.020 --> 13:53.060
bala, apenas para impulsioná-la no ambiente mundial.

13:53.070 --> 14:00.200
Certo, então, com essas coisas feitas, vamos salvá-lo. Salve seu script AI e seu ataque e volte para

14:00.210 --> 14:01.320
o Unity.

14:01.370 --> 14:09.180
Então, apenas seleciono o Droid, para que possamos ver sua Árvore de Comportamentos, coloque 'Attack. BT 'aqui como o script e, quando estiver

14:09.180 --> 14:19.800
pronto, pressione Play e o Droid vira para o nosso droid, ok. No momento, não se preocupa com paredes nem nada, está apenas se voltando

14:20.160 --> 14:22.830
(é o que dissemos para fazer)

14:22.840 --> 14:28.620
para onde ele sabe que está o nosso jogador e, se eu o mover,

14:28.620 --> 14:30.500
ele continuará girando e

14:35.710 --> 14:37.270
atirando assim. ..

14:44.820 --> 14:49.690
Agora não há explicação para a velocidade do disparo em nossa sequência atual.

14:49.690 --> 14:55.960
Ele estará circulando rapidamente por toda a árvore, mirando constantemente no jogador, olhando para o

14:55.960 --> 14:58.020
jogador e depois disparando.

14:58.180 --> 15:05.830
Se você quiser adicionar uma 'espera' aqui, você pode fazer isso facilmente neste sistema da Árvore de Comportamentos.

15:05.830 --> 15:14.950
Se voltarmos ao nosso script de ataque aqui, é que há 'esperas' embutidas nele,

15:15.880 --> 15:23.970
para que possamos colocar 'Wait (0. 5) 'e esperará meio segundo antes de disparar e, em seguida,

15:23.980 --> 15:31.080
retornará novamente e esperará meio segundo antes de disparar. Então, salve isso e volte para o Unity e pressione Play.

15:31.100 --> 15:36.710
Agora você pode ver que haverá meio segundo entre cada cena

15:38.050 --> 15:43.550
e assim adicionar atrasos agradáveis à própria Árvore de Comportamento.

15:50.840 --> 15:51.130
Tudo certo.

15:51.140 --> 15:54.980
Então, vamos deixar essa palestra aqui. Na próxima palestra, começaremos

15:54.980 --> 16:01.930
a adicionar algumas condições e o bot deve realmente testar se consegue ver o jogador antes de

16:01.930 --> 16:03.390
começar a filmar.

16:03.440 --> 16:04.880
Então, faremos isso a seguir.
