WEBVTT

00:11.320 --> 00:15.070
Até agora, vimos algumas árvores de comportamento seqüencial bastante simples.

00:15.070 --> 00:23.290
Agora vamos adicionar uma condição que testa se algo é 'verdadeiro' ou 'falso' antes que a Árvore

00:23.290 --> 00:24.960
de Comportamento continue

00:25.030 --> 00:30.940
sendo executada e, portanto, adicionamos um 'Nó de Decisão' no código.

00:30.940 --> 00:34.260
Nós vamos fazer isso dentro do nosso ataque,

00:34.270 --> 00:39.520
mas antes de tudo, precisamos escrever nosso método que tomará a decisão por nós.

00:39.520 --> 00:46.030
Atualmente estamos atacando o tempo todo. Você realmente quer que o bot ataque, se ele puder

00:46.030 --> 00:47.110
realmente ver o

00:47.110 --> 00:52.080
jogador e, nesse caso, quando você começar, não poderá porque o jogador está atrás de um muro.

00:52.150 --> 00:57.440
Além disso, se o jogador estiver fora do alcance visível, você também não quer que ele ataque.

00:57.580 --> 01:05.920
Agora, se você se lembrar no topo deste programa, há um visibleRange e um shotRange configurados,

01:06.220 --> 01:15.550
portanto esse visibleRange (que é 80) vai determinar se o jogador está dentro de 80 unidades do bot,

01:15.550 --> 01:21.670
então ele pode vê-lo . Ele também testará ao mesmo tempo se não houver barreira entre o

01:21.670 --> 01:28.180
jogador e o bot, o que é uma boa situação inimiga, porque você deseja que o bot esteja ciente de que há infraestrutura em torno dele.

01:28.180 --> 01:36.700
Portanto, como o último método aqui embaixo do Fire, adicionarei um novo método que usaremos em nosso código da

01:36.730 --> 01:38.170
Árvore de Comportamento.

01:38.170 --> 01:40.350
Então, é chamado SeePlayer.

01:40.630 --> 01:41.710
É um

01:41.710 --> 01:48.220
booleano, como é o que tínhamos antes, mas desta vez vamos usá-lo como um teste lógico na

01:48.250 --> 01:49.480
Árvore de Comportamento.

01:49.480 --> 01:57.280
Então, o que isso está fazendo é calcular o vetor do bot

01:57.280 --> 01:59.370
para o

01:59.530 --> 02:03.500
player e também teremos um RaycastHit.

02:03.940 --> 02:12.520
Então, transmitiremos ao longo desse vetor de distância para ver se atingimos algo e se atingimos algo (que é, neste caso, uma parede),

02:12.610 --> 02:17.800
então obviamente não podemos ver o jogador porque há uma parede na estrada. temos

02:17.800 --> 02:18.480
um

02:18.480 --> 02:22.130
pequeno bool definido aqui, dizendo 'seeWall = false' para começar.

02:22.180 --> 02:28.900
Eu também estou fazendo uma depuração. DrawRay no ambiente, para que possamos ver onde esse vetor

02:28.900 --> 02:30.600
de distância está sendo projetado.

02:30.610 --> 02:35.840
Isso é muito bom se você estiver tentando depurar visualmente o que está acontecendo e onde estão seus vetores.

02:35.980 --> 02:38.520
Eu sempre uso isso.

02:38.740 --> 02:46.180
Agora ele vai projetar um raio, fazer a física. Raycast como fizemos antes e depois veja se

02:46.420 --> 02:48.770
atingimos algo chamado "muro".

02:48.970 --> 02:53.140
Se tivermos, o seeWall será igual a 'true'.

02:53.260 --> 02:59.490
Agora, por um momento, de volta à Unity, se você for ao Mapa e soltá-lo, há todas essas paredes e cada uma

02:59.650 --> 03:06.160
delas foi marcada com 'parede' e é assim que a Física. Raycast está indo para o trabalho.

03:06.250 --> 03:14.420
Agora, certifique-se de que seu raio que você está projetando realmente atravesse a parede (ou qualquer outro objeto que você esteja tentando

03:14.440 --> 03:17.400
detectar como um obstáculo) e é por isso

03:17.500 --> 03:20.880
que esta depuração. DrawRay é uma ótima idéia.

03:21.880 --> 03:31.870
Depois de fazer isso, também estou imprimindo o valor seeWall em algum código de depuração da própria Árvore de Comportamento, para que você possa vê-lo

03:31.870 --> 03:37.210
quando estiver trabalhando nos diferentes nós e no que eles estão fazendo, o que

03:37.210 --> 03:39.070
também é bastante útil.

03:39.190 --> 03:43.750
Finalmente, para determinar se podemos ver o jogador ou

03:43.750 --> 03:51.820
não, o teste é: Se a magnitude dessa distância do vetor de direção entre os dois jogadores

03:51.820 --> 04:03.050
for menor que o alcance visível E não houver barreira no caminho. Desta vez, não estamos preocupados se o bot está na direção

04:03.110 --> 04:04.700
certa ou não.

04:04.700 --> 04:09.620
Então, vamos imaginar que ele tenha um pequeno sistema de radar a bordo e não precise estar

04:09.620 --> 04:17.420
olhando em uma direção para saber se o jogador está por perto. Agora, se o jogador estiver nesse raio

04:17.420 --> 04:23.590
e não houver barreira no caminho, retornaremos 'true' ao ver o

04:23.930 --> 04:27.390
jogador; caso contrário, retornaremos um 'false'.

04:27.410 --> 04:31.650
Portanto, este é o método para o nosso novo nó.

04:31.700 --> 04:36.020
Ok, salvaremos isso e entraremos no script de ataque, e o que faremos é

04:36.080 --> 04:43.070
adicionar um novo nó em nossa árvore acima da 'sequência'. Então, aqui em

04:44.310 --> 04:52.090
cima, agora vou adicionar isso. Portanto, o código é 'while SeePlayer' Agora este nó

04:52.140 --> 05:00.750
'while' é um nó de teste especial e permitirá que você execute algo que seja um valor verdadeiro ou falso

05:00.750 --> 05:02.260
e até inverta-o

05:02.490 --> 05:06.660
para verificar (não precisa ser verdadeiro para executar, também pode

05:06.720 --> 05:11.060
ser falso) e não impedirá a execução da sua árvore.

05:11.170 --> 05:20.220
Ok, então você pode até colocar, por exemplo, 'embora não seja o SeePlayer', se você quiser mudar a lógica e faremos um pouco

05:20.220 --> 05:23.380
mais tarde, mas não neste caso aqui.

05:23.460 --> 05:27.780
Agora, esse nó 'while' pode ter apenas 1 filho.

05:27.950 --> 05:34.730
Portanto, precisamos garantir que recuamos tudo isso dessa maneira, caso contrário, o sistema da Árvore de

05:34.730 --> 05:36.430
Comportamento reclamará disso.

05:36.440 --> 05:44.890
Portanto, agora a sequência de filmagens só acontecerá se o método SeePlayer nos der um 'verdadeiro' aqui.

05:44.890 --> 05:47.810
Então, vamos salvar isso e vamos testá-lo.

05:47.810 --> 05:55.220
Então, de volta ao Unity, clique no Droid para verificar se o script está ok e você receberá um texto rosa onde

05:55.220 --> 05:57.660
tudo está bem com o script Attack.

05:57.680 --> 06:00.680
Ok, vamos pressionar Play e dar uma olhada no que obtemos.

06:00.710 --> 06:10.940
Então, na Árvore do Comportamento, enquanto o SeePlayer está sentado lá, wall = True, você pode ver isso lá.

06:10.940 --> 06:17.780
Você também pode ver na cena que o raio de depuração atravessa e atinge a parede, o que está causando

06:17.780 --> 06:23.750
o 'wall = True' aqui e está nos tornando para que não possamos ver o jogador.

06:23.750 --> 06:25.510
Vamos colocar o

06:26.660 --> 06:37.870
jogador à vista, então, se eu virar a esquina e pronto. Assim que eu aparecer e estiver dentro do alcance visual, o Droid

06:37.990 --> 06:41.510
começará a disparar e se eu

06:41.530 --> 06:47.950
me virar e voltar novamente, ele parará assim que houver uma parede na estrada.

06:50.790 --> 06:57.840
Se eu atravessar esse muro porque não sou constrangido como jogador pelo NavMesh,

06:58.230 --> 07:05.670
ele não poderá mais me ver. Se eu voltar, ele voltará e, por causa do código anterior, ele também será

07:05.670 --> 07:08.950
voltado para o jogador, a fim de filmar e você poderá

07:09.110 --> 07:15.980
ver a Árvore do Comportamento passando bem com esse pouco de lógica. Então você está começando a ver o poder das

07:15.980 --> 07:22.910
Árvores de Comportamento, que você pode criar um monte de métodos que executam uma única ação para o

07:22.940 --> 07:30.560
seu jogador e, em seguida, pode reuni-los na Árvore de Comportamentos, o que facilita muito para alguém quem não

07:30.560 --> 07:33.700
está realmente familiarizado com o código, mas

07:33.710 --> 07:41.330
também cria seu A. EU. bastante poderoso, onde você pode misturar e combinar comportamentos diferentes. Apenas por interesse, vamos

07:41.330 --> 07:50.330
voltar ao Attack e alterar esse código no topo com a declaração while para ser um "não" e reverter essa lógica, para

07:50.330 --> 07:56.150
que, quando NÃO VÊMOS o jogador, vamos ataque o jogador, o que não faz

07:56.150 --> 08:04.060
sentido lógico, mas o que isso significa é que, enquanto você não está na visão visível do bot com

08:04.070 --> 08:07.320
seu personagem, ele estará atirando em sua direção.

08:07.430 --> 08:09.110
Então apenas salve isso. Enquanto estou

08:09.110 --> 08:13.130
aqui, também devo mencionar essa declaração while por causa da programação

08:13.520 --> 08:20.450
normal, você vai pensar que a declaração significa 'looping'. No caso das árvores de comportamento, isso não significa loop.

08:20.450 --> 08:22.190
Portanto, este não é um loop.

08:22.230 --> 08:24.700
Se alguma coisa, é uma declaração if,

08:24.710 --> 08:28.860
se você quiser pensar nisso como algo, então não fará com que isso

08:29.210 --> 08:37.030
circule por aqui e é chamado de 'while'. Certo, então salve isso. Vamos voltar e dar uma olhada em como isso afeta nossa Árvore de Comportamentos.

08:37.040 --> 08:43.610
Então, pressione Play e esperamos que levemos um tiro imediatamente porque não conseguimos ver o

08:43.610 --> 08:44.300
jogador.

08:44.480 --> 08:50.030
Agora, se eu avançar para o alcance, não seremos atingidos e, de fato, toda a

08:50.300 --> 08:55.300
sequência para de correr, por isso nem vamos virar e olhar para o

08:55.640 --> 09:02.290
jogador porque esse trecho aqui não está sendo satisfeito, na medida em que ser capaz de ver o jogador.

09:02.490 --> 09:02.700
Direita.

09:02.700 --> 09:07.800
É assim que você também pode adicionar lógica.

09:07.800 --> 09:16.440
Agora você não precisa usar o 'enquanto não' nesse caso, porque o SeePlayer pode fazer parte da sequência.

09:16.830 --> 09:27.360
Se você colocar o SeePlayer na sequência (vamos voltar aqui e tirar isso de lá e colocá-lo

09:27.360 --> 09:28.480
aqui

09:30.320 --> 09:35.070
em baixo), é legitimamente permitido que falhe ...

09:38.340 --> 09:45.330
e como essa é uma sequência, o restante não será executado de qualquer maneira, então vamos salvá-la e dar uma

09:45.330 --> 09:46.090
olhada nela.

09:47.030 --> 09:48.990
Verifique se está recarregado aqui.

09:49.190 --> 09:56.460
Agora temos uma sequência. Se pressionarmos Play ... ok, não podemos ver o jogador.

09:56.460 --> 10:03.120
Então a sequência parou com o SeePlayer e vamos tentar nos aproximar dela para ver o que acontece ...

10:03.840 --> 10:06.870
ele disparará o SeePlayer e

10:07.110 --> 10:10.220
o restante será executado como antes.

10:10.350 --> 10:17.010
Portanto, nesse caso, a declaração while não está nos ajudando com o SeePlayer, porque precisa ser verdadeira para

10:17.040 --> 10:19.920
que o restante do código seja executado.

10:19.920 --> 10:26.670
Portanto, neste caso, o que fizemos foi virar a árvore de cabeça para baixo, na medida em que este

10:26.700 --> 10:34.200
SeePlayer agora é um Nó Folha, enquanto antes era um Nó Decorador porque tinha filhos por baixo e estava permitindo que

10:34.200 --> 10:40.680
você tomasse uma decisão. e a decisão nesse caso se aplica quando você deseja inverter o valor que

10:40.680 --> 10:41.760
sai dela.

10:41.760 --> 10:48.980
Portanto, o 'enquanto não' será muito mais comum nesse caso específico, mas depende do que você está tentando

10:48.990 --> 10:49.800
fazer.

10:49.950 --> 10:51.710
Então essa é

10:51.720 --> 10:58.900
a sequência e também a adição dessa lógica. No próximo vídeo, veremos os nós do seletor.
