WEBVTT

00:11.840 --> 00:17.520
Até agora, criamos um monte de pequenas árvores de comportamento e agora é hora de reuni-las.

00:17.780 --> 00:22.150
Se desenhá-los em um diagrama, eles se pareceriam com isso e

00:22.220 --> 00:28.070
o que você verá na tela é uma representação próxima do que estamos caminhando, mas

00:28.070 --> 00:33.530
não está completo (por qualquer meio) porque não há o suficiente espaço na tela

00:33.530 --> 00:41.870
para fazer isso, mas você pode ver as principais áreas. Você pode ver todas as principais árvores que criamos até agora

00:41.870 --> 00:45.370
e todas as maneiras pelas quais elas estão interconectadas.

00:45.380 --> 00:49.240
A questão é: como você os junta?

00:49.250 --> 00:57.670
porque não são uma 'sequência' e não são algo que deva ser selecionado. O que eu fiz aqui é apenas uma

00:57.670 --> 01:05.050
maneira de estruturá-los logicamente e você verá que há um novo tipo de nó

01:05.050 --> 01:12.790
adicionado na parte superior chamado 'Paralelo'. Paralelo permite que você corra 2 ou mais lados da árvore

01:12.910 --> 01:20.530
de uma só vez (neste caso, são apenas 2) e um lado é chamado de Patrulha e o outro lado é chamado

01:20.650 --> 01:21.530
de Morto.

01:21.700 --> 01:28.150
O lado morto está pegando o código que já escrevemos para a árvore morta.

01:28.870 --> 01:35.950
A Patrulha combina todos os comportamentos que o bot pode fazer quando estiver vivo.

01:36.010 --> 01:45.580
Queremos que os nós no Patrol sejam executados em um tipo quase de ordem seqüencial, para que, a cada Atualização, o bot

01:45.580 --> 01:50.260
verifique se deve Fugir, Atacar, Olhar ao Redor ou Desviar.

01:51.210 --> 01:54.360
Começaremos indo direto para a árvore de

01:54.390 --> 01:59.490
comportamento da AI do bots, que combina tudo o que fizemos até agora.

01:59.700 --> 02:08.640
Portanto, crie um novo script chamado 'BotAI. BT 'e nisso combinaremos todas as árvores.

02:08.760 --> 02:16.740
Você não precisa colocar todas as árvores em um arquivo, você pode colocá-las em arquivos separados

02:16.740 --> 02:22.140
e anexá-las ao comportamento do Panda anexado ao seu agente.

02:22.150 --> 02:28.050
No entanto, acho muito mais fácil ver o que está acontecendo quando estamos depurando se eles estão todos em

02:28.050 --> 02:29.250
um único arquivo.

02:29.250 --> 02:31.810
Então, aqui está como eles serão.

02:31.890 --> 02:36.990
Primeiro de tudo, começamos com o nó 'Root' da nossa árvore.

02:37.020 --> 02:40.260
É aqui que a árvore começará a correr.

02:40.260 --> 02:46.080
Então temos o nó 'paralelo', que executará seus filhos ao mesmo tempo e você

02:46.380 --> 02:52.740
pode ver que há uma árvore chamada Patrol que será executada e uma árvore chamada Dead.

02:52.740 --> 02:54.940
Já escrevemos o Dead.

02:54.960 --> 03:03.260
Eles são prefixados por um nó 'repeat', um nó 'mute' e, é claro, pelo nó 'tree'. O nó 'repeat' continuará

03:03.270 --> 03:06.490
repetindo (repetidamente)

03:06.540 --> 03:16.650
essa parte da árvore inteira. 'mute' não se importa se o nó abaixo dele é bem-sucedido ou falha,

03:16.650 --> 03:18.050
apenas continua executando-o.

03:18.180 --> 03:24.220
Então, está dizendo "Não ouça se você é bem-sucedido ou não", que permite que essa

03:24.220 --> 03:24.750
árvore

03:24.780 --> 03:31.120
morta aqui, quando seu agente não está morto, continue correndo e verifique se o agente está morto.

03:31.170 --> 03:33.270
Agora, o que há em cada uma dessas árvores?

03:33.360 --> 03:40.380
Você verá que é uma parte separada no código para cada árvore, então há Patrulha ... e aqui está o ataque e cada um é

03:40.380 --> 03:41.130
nomeado.

03:41.130 --> 03:43.980
Eles não têm mais a raiz no topo.

03:43.980 --> 03:49.090
Eles precisam de um nome para descobrir como estão todos ligados.

03:49.440 --> 03:56.550
Agora você pode colocar isso em uma grande árvore sem todas essas pequenas subárvores, mas isso

03:56.550 --> 04:04.790
se tornaria uma bagunça e muito difícil de depurar. A árvore Patrulha tem uma sequência e ela chama a árvore

04:04.800 --> 04:07.490
'Fugir', portanto, vamos verificar se podemos fugir.

04:07.500 --> 04:15.540
Isso também continuará dizendo: 'enquanto nossa saúde não for inferior a 40',

04:15.630 --> 04:17.790
faremos nossa pequena

04:18.030 --> 04:26.610
sequência de Attack, LookAround e Wander. Este é o código para a árvore do Attack, extraído diretamente do nosso pequeno

04:26.610 --> 04:28.850
arquivo que criamos antes, para o Attack.

04:29.010 --> 04:35.870
A única diferença é que eu mudei o Attack aqui, que tinha Root de volta no arquivo Attack, se eu o encontrar ...

04:35.870 --> 04:44.260
é só lá, você pode ver e é o mesmo para todos os outros. Então Dead está aqui em baixo.

04:44.370 --> 04:50.410
Temos Flee, LookAround e depois Wander.

04:50.410 --> 05:00.360
Então, depois de conseguir isso, você pode salvá-lo e deseja ir ao seu Droid e defini-lo como sua Árvore de

05:00.360 --> 05:01.060
Comportamento.

05:01.120 --> 05:07.900
No momento, não precisamos alterar nada no código da classe AI porque não criamos

05:07.900 --> 05:09.160
novos métodos.

05:09.190 --> 05:15.280
Sua árvore, se estiver rosa e vermelha durante todo o percurso, significa que está pronta para ser usada, e

05:15.280 --> 05:16.980
encontrou todos os métodos necessários.

05:17.230 --> 05:21.550
Ok, então vamos pressionar Play e ver o que acontece.

05:21.590 --> 05:21.900
Certo.

05:21.950 --> 05:30.880
Se formos até o inspetor e dar uma olhada, as duas coisas 'paralelas' estão funcionando e o bot

05:30.910 --> 05:42.610
em si está apenas sentado lá ... sob patrulha. Ele disparou o 'Fugir' e o Fugir que ele

05:42.610 --> 05:51.040
disparou está aqui embaixo e está dizendo 'enquanto IsHealthLessThan (40. 0) ', portanto, ele não pode satisfazer esse nó

05:51.040 --> 05:58.040
e, portanto, nada mais será executado. Aqui em cima, onde esse Flee está

05:58.120 --> 06:05.190
sendo chamado, está falhando nessa árvore; portanto, nada mais está acontecendo porque uma sequência não

06:05.200 --> 06:14.620
continuará quando um nó falhar; portanto, imediatamente temos um problema com nossa árvore não sendo capaz de continuar. e passar

06:14.620 --> 06:20.890
por todos os processos que o bot pode fazer quando ainda está vivo.

06:20.890 --> 06:27.070
Agora, o mesmo aconteceu com a árvore morta, mas tudo bem, porque nosso bot não está

06:27.070 --> 06:33.680
morto, por isso está preso nesse 'IsHealthLessThan (0. 1) 'o que não é, então não vai explodir imediatamente.

06:33.810 --> 06:34.360
Está tudo

06:34.360 --> 06:35.750
bem, está funcionando paralelo aqui em cima.

06:35.770 --> 06:40.340
O problema está aqui com o Flee, que queremos continuar.

06:40.340 --> 06:46.320
Portanto, se essa árvore (para Flee) falhar, ainda queremos que ela vá e verifique as outras.

06:46.330 --> 06:58.640
Então pare de jogar e eu apresentarei um novo tipo de nó. Volte para o seu código de árvore bot. No Patrol, faremos 2

06:58.640 --> 07:02.560
alterações. Onde houver 'sequência'

07:02.610 --> 07:08.370
aqui, chamaremos isso de 'fallback' e essa outra 'sequência' aqui

07:08.400 --> 07:12.300
em baixo, chamaremos isso de 'fallback'.

07:12.350 --> 07:22.200
Agora, o nó de fallback é um nó de sequência, mas permite que os nós abaixo dele falhem.

07:22.230 --> 07:29.190
Portanto, mesmo que eles falhem, ainda assim continuará executando as coisas por baixo e é isso que

07:29.280 --> 07:36.480
queremos usar neste caso, porque Flee falhará quando não precisarmos fugir e coisas como Wander e LookAround, eles

07:36.480 --> 07:38.070
falharão quando estivermos

07:38.070 --> 07:43.410
ao alcance do jogador e, na verdade, estamos atacando-o e o ataque falhará

07:43.400 --> 07:45.150
quando o jogador não

07:45.150 --> 07:47.700
estiver por perto, então precisamos permitir isso.

07:47.700 --> 07:54.330
Então salve isso agora e vamos voltar aqui e pressione Play novamente.

07:54.570 --> 08:02.820
Agora, quando o rodarmos, você descobrirá que o bot se moverá e responderá ao código que lhe permite

08:02.820 --> 08:10.200
mudar porque estamos definindo nosso fallback: Attack (que falha porque não pode atacar no momento), então

08:10.200 --> 08:15.680
ele tem uma árvore LookAround (que você pode fazer e, portanto, apenas

08:15.900 --> 08:17.610
olha em volta).

08:17.610 --> 08:24.500
Você verá que o Wander não está sendo acionado, não está chegando tão longe

08:24.540 --> 08:32.100
e, se olharmos para o LookAround (vamos descer ainda mais), você verá que dentro do LookAround,

08:32.130 --> 08:34.960
não há nada aqui que

08:35.010 --> 08:44.200
possa causar falhar enquanto estiver saudável e longe do jogador. Assim, podemos forçá-lo a falhar de vez em

08:44.210 --> 08:53.210
quando, para permitir um retorno de chamada, até a árvore Patrol que chamará Wander, para que o

08:53.210 --> 08:57.470
LookAround possa terminar. Realmente não tem um estado final.

08:57.470 --> 08:58.900
Acho que é isso

08:59.000 --> 09:02.540
que estou dizendo e queremos que volte aqui, para que Wander possa correr.

09:02.540 --> 09:03.860
Então

09:03.860 --> 09:06.000
pare de jogar, abra

09:06.200 --> 09:12.110
seu código novamente e, no LookAround, adicionaremos outro nó nessa sequência.

09:12.140 --> 09:20.720
Então, depois de esperarmos um período aleatório de tempo, colocaremos outro 'aleatório'

09:20.720 --> 09:32.390
aqui e, quando criança, colocaremos 'Fail' e 'Succeed'. Tão aleatoriamente, ele falhará ou será bem-sucedido, o que o jogará de volta desta árvore

09:32.510 --> 09:41.420
para a árvore Patrol, onde será permitido seguir para o Wander. Salve isso e

09:41.440 --> 09:45.150
pressione Play.

09:45.150 --> 09:45.540
Tudo certo.

09:45.540 --> 09:54.910
Então o Droid agora fez um LookAround, mas também acionou um Wander, como você viu acontecer

09:55.110 --> 10:00.240
lá e depois volta para o LookAround ...

10:00.480 --> 10:05.990
e quando isso falhar, ele vagará novamente e aqui você pode vê-lo sair vagando.

10:06.000 --> 10:07.340
Agora, se tivermos sorte ...

10:07.350 --> 10:08.040
sim,

10:08.100 --> 10:13.250
conforme passa por aqui, o que aconteceu foi que o ataque foi acionado e é

10:14.040 --> 10:20.880
porque ele tem um SeePlayer, um TargetPlayer e um LookAtTarget, que é o que fez com que ele se voltasse

10:20.880 --> 10:23.190
para o jogador e você não quer

10:23.190 --> 10:27.220
que isso aconteça, a menos que seja na verdade no modo Ataque.

10:27.420 --> 10:33.600
Agora ele entrou aqui (novamente no modo Ataque) e está começando a atacar nosso lpayer

10:33.600 --> 10:39.960
porque o encontrou, o que é interessante por si só, mas nós realmente não queremos que isso

10:39.960 --> 10:46.820
aconteça, então precisamos adicionar mais algumas instruções condicionais no nossa árvore para fazê-la se comportar exatamente como queremos.

10:47.610 --> 10:54.360
Quando o bot vê o jogador e vai atacá-lo (ou sabe que é capaz de atacá-lo), ele deve

10:54.360 --> 11:03.900
ser capaz de se mover em direção ao jogador também, para que ele fique dentro do alcance e possamos modificar o script de ataque para fazer isso

11:03.900 --> 11:04.320
.

11:04.320 --> 11:07.360
Então, de volta à nossa completa

11:07.380 --> 11:14.510
Árvore de Comportamentos, substituiremos a sequência de Ataque que tínhamos antes por algo um pouco mais complicado.

11:14.500 --> 11:18.540
Então deixe-me colocar, certo, então eu vou explicar e explicar.

11:18.540 --> 11:22.140
Primeiro, vamos verificar se podemos ver o jogador no

11:22.140 --> 11:23.890
ataque, antes de continuarmos

11:23.910 --> 11:32.720
e, se pudermos, iniciaremos uma sequência que faz o TargetPlayer, LookAtPlayer. Então teremos um retorno

11:32.720 --> 11:36.290
em 2 'whiles'.

11:36.410 --> 11:39.260
O primeiro será

11:39.380 --> 11:41.040
'enquanto

11:41.280 --> 11:52.510
ShotLinedUp' e depois 'enquanto não ShotLinedUp'. Se um tiro estiver alinhado, a sequência será 'Wait and Fire', que tínhamos

11:52.510 --> 11:54.500
antes, para o disparo.

11:54.700 --> 12:03.670
Se a foto NÃO estiver alinhada, queremos 'SetTargetDestination' e 'MoveToDestination'.

12:03.670 --> 12:11.630
Então, definir o destino alvo será definir o jogador como esse alvo específico.

12:11.950 --> 12:17.950
Os dois novos métodos aqui, que temos que escrever e adicionar ao script AI são

12:17.950 --> 12:19.250
ShotLinedUp e SetTargetDestination.

12:19.270 --> 12:26.550
Então, voltemos a esses scripts e, na parte inferior, sob as outras tarefas, vamos adicioná-los.

12:26.560 --> 12:30.090
Portanto, o primeiro é SetTargetDestination.

12:30.250 --> 12:40.750
Já definimos o alvo em si porque usamos (em nosso script) o TargetPlayer, que define esse valor para que

12:40.870 --> 12:44.280
seja igual à posição do jogador.

12:44.290 --> 12:47.870
É por isso que estamos definindo apenas um destino

12:48.010 --> 12:56.350
de destino aqui em baixo, e o que está fazendo é dizer ao nosso NavMesh para avançar agora em direção ao destino.

12:56.510 --> 13:01.910
O próximo é o ShotLinedUp, que está retornando um 'verdadeiro' ou 'falso'

13:02.000 --> 13:04.670
se conseguirmos atirar no jogador.

13:04.850 --> 13:12.740
Então, novamente, esse é um problema do tipo visibilidade, em que testamos a distância dentro do valor da faixa

13:12.740 --> 13:21.650
de tiro (que é definida na parte superior) e que o ângulo entre o vetor para frente do seu agente e

13:21.890 --> 13:27.940
o vetor para o alvo é menor que 1 (um ângulo estreito pequeno).

13:27.980 --> 13:30.560
Se for, então podemos atirar.

13:30.560 --> 13:36.730
Caso contrário, moveremos e ajustaremos nossa posição para nos aproximarmos do jogador.

13:36.800 --> 13:38.320
Portanto, salve isso

13:38.600 --> 13:44.210
e vamos voltar para o Unity e pressione Play para ver como isso acontece agora.

13:45.620 --> 13:51.890
O bot vai olhar em volta e também vagar. Agora, quando passa pelo jogador dessa

13:51.950 --> 13:59.200
vez, ele percebe o jogador e se vira para ele e está entrando para um ataque.

13:59.200 --> 14:04.850
Então, em vez de ignorar completamente e dizer "eu não te vi", ele nos viu,

14:04.850 --> 14:09.340
então agora podemos voltar e começar a atirar nele, neste momento, para

14:09.350 --> 14:11.160
que sua saúde diminua.

14:11.330 --> 14:13.560
Lá vai, vai se afastar ...

14:14.370 --> 14:16.130
encontre um esconderijo ...

14:16.170 --> 14:20.040
Agora, se apenas deixarmos em paz (não podemos vê-lo lá, podemos?

14:20.070 --> 14:22.140
Vamos apenas nos mover.

14:22.430 --> 14:23.400
Está bem).

14:23.760 --> 14:30.420
Quando a saúde estiver acima de 40, ele voltará a fazer o que estava fazendo antes, que está

14:30.540 --> 14:37.800
olhando ao redor e vagando e agora não vai atacar, a menos que nos encontre novamente ou vamos nos aproximar e

14:37.800 --> 14:39.090
tentar atirar nele.

14:39.270 --> 14:42.240
O tempo todo, a saúde continuará aumentando.

14:42.420 --> 14:48.980
Ok, então essas são árvores de comportamento em poucas palavras.

14:49.080 --> 14:54.560
Ainda há muito para você aprender. O que eu sugeriria é que

14:54.600 --> 15:03.120
agora que você conhece o caminho, eu iria ao pandabehaviour. com, de onde o plug-in do PandaBT vem e lê a

15:03.120 --> 15:09.420
documentação, porque é muito útil ver quais nós estão disponíveis, o que eles fazem e como você

15:09.420 --> 15:10.360
deve estruturá-los.

15:10.440 --> 15:18.480
Além disso, faça o download do plug-in completo do Panda Behavior na Asset Store, pois há alguns ótimos exemplos que o acompanham

15:18.690 --> 15:24.090
e alguns deles são realmente bastante complexos e mostram como fazer coisas incríveis com

15:24.090 --> 15:25.920
as Árvores de Comportamento.
