WEBVTT

00:11.130 --> 00:16.320
A maneira mais simples de criar um NPC que toma decisões sobre o que fazer, com base na

00:16.320 --> 00:18.870
localização do jogador, é a Linha de Visão.

00:19.350 --> 00:24.100
O Line Of Sight funciona calculando o ângulo e a distância do PNJ ao jogador e

00:24.150 --> 00:27.460
usando esses dados para decidir sobre a ação a ser tomada.

00:27.570 --> 00:33.570
É uma maneira muito fácil de criar um agente puramente reativo, cujo comportamento é determinado pela capacidade de ver

00:33.570 --> 00:34.920
ou não o jogador.

00:35.040 --> 00:38.420
Para implementar isso, o NPC recebe um campo de visão.

00:38.550 --> 00:44.670
Este é um cone que se estende desde a localização do NPC em sua direção voltada para a frente, pelo comprimento de

00:44.670 --> 00:51.060
seu alcance visível e se espalhando por um ângulo de visão. Para determinar se um jogador cai dentro

00:51.060 --> 00:55.110
deste cone, calculamos o vetor do NPC para o jogador.

00:55.110 --> 01:00.270
Depois, determinamos se a 'distância do jogador' é menor que o 'alcance visível' e se o 'ângulo da

01:00.270 --> 01:06.690
posição do jogador' é menor que o do 'ângulo de visão'. Se ambas as condições forem verdadeiras, o jogador estará visível

01:06.690 --> 01:08.040
para o NPC.

01:08.040 --> 01:14.610
Acompanhe como eu mostro como configurar esse tipo de NPC de linha de visão. Faça o download do AIRobotGuard. unitypackage que acompanha

01:14.610 --> 01:16.360
esta palestra.

01:16.440 --> 01:21.880
Crie um novo projeto do Unity 3D e arraste e solte esse arquivo de pacote em seus ativos.

01:21.990 --> 01:28.860
Ao fazê-lo, você receberá esses 2 itens. Você obterá uma cena chamada RobotGuard (que você pode abrir

01:28.860 --> 01:34.110
e verá o guarda do robô em pé na cena) e uma pasta com seu trabalho artístico.

01:34.170 --> 01:36.780
Os outros itens, você vai adicionar.

01:37.110 --> 01:43.560
Então, quando você estiver pronto, adicionaremos um controlador em primeira pessoa, para que possamos andar

01:43.560 --> 01:47.700
por aí e testar nossa proximidade com o NPC.

01:47.700 --> 01:54.680
Vá para 'Assets> Import Package' e traga o pacote 'Characters'. Esse é o da

01:54.690 --> 02:01.710
primeira pessoa, terceira pessoa etc. coisas nele, então traga todos esses itens e

02:01.800 --> 02:06.100
isso lhe dará uma pasta de Ativos Padrão na qual você

02:06.540 --> 02:11.800
encontrará Personagens e, em seguida, queremos a primeira pessoa 'Prefabs' e o FPSController.

02:11.820 --> 02:13.690
Então segure-o, arraste-o

02:13.740 --> 02:18.900
para a cena e apenas levante-o para que fique acima do solo.

02:19.470 --> 02:23.010
Agora que você tiver feito isso, ela terá sua própria câmera.

02:23.310 --> 02:28.370
Portanto, a câmera que está em cena, você pode excluir (ou simplesmente desligar).

02:28.410 --> 02:33.430
Agora, para testar se está funcionando, basta pressionar Play e você poderá passear pelo ambiente ...

02:37.100 --> 02:38.860
Curtiu isso.

02:40.080 --> 02:40.540
Está bem.

02:40.700 --> 02:45.120
Pressione a tecla Esc para recuperar o mouse e parar de jogar.

02:45.410 --> 02:45.680
Está bem.

02:45.680 --> 02:49.950
Então, de volta ao Assets, vamos criar um script AIController.

02:50.000 --> 02:57.290
Eu já tenho um aqui, mas você deseja 'Criar> Script C #' e chamá-lo de AIController. Dentro desse script, você

02:57.290 --> 03:00.380
adicionará isso.

03:00.800 --> 03:05.440
Portanto, este é o script básico para que nossa Linha de Visão funcione.

03:05.510 --> 03:11.300
Primeiro de tudo, precisamos saber onde o jogador está, então teremos uma transformação

03:11.300 --> 03:14.550
pública no topo para passar pelo jogador.

03:14.840 --> 03:21.380
Em seguida, temos várias variáveis sobre o comportamento do próprio NPC.

03:21.380 --> 03:29.510
Portanto, temos o usual "rotationSpeed" e "speed" para girar e mover o personagem e, em seguida, temos os valores da Linha de

03:29.510 --> 03:30.230
Visão.

03:30.230 --> 03:37.870
Portanto, temos uma distância visível (portanto, a que distância do personagem ele pode detectar o jogador, neste

03:37.910 --> 03:40.360
caso, é 20), o ângulo

03:40.550 --> 03:51.940
visível é definido como 30 (para que você possa ver a uma distância de 20, dentro de um ângulo de 30 graus para ambos

03:52.090 --> 03:53.410
os lados.

03:53.410 --> 04:00.610
Portanto, esse ângulo é como metade do campo de visão completo, que seria 60).

04:00.760 --> 04:09.370
Então temos uma distância de tiro e a distância de tiro é a que distância o personagem deve estar para

04:09.370 --> 04:10.770
começar a atirar.

04:10.780 --> 04:16.630
Portanto, se não estiver perto o suficiente e o detectou, pode ocorrer até você estar perto o suficiente

04:16.630 --> 04:18.070
para tirar uma foto.

04:18.070 --> 04:27.310
Em seguida, armazenaremos um estado e esse estado nos ajudará a determinar quais animações serão

04:27.310 --> 04:34.150
executadas um pouco mais tarde. Portanto, o NPC terá três estados, terá IDLE, terá RUNNING e terá SHOOTING

04:34.330 --> 04:36.930
e você os verá entrar em jogo na atualização.

04:36.940 --> 04:41.420
Agora, na Atualização, é onde todo o trabalho está acontecendo.

04:41.770 --> 04:51.040
A primeira coisa que fazemos é calcular a direção do NPC para o jogador. Ok, lembre-se, para fazer isso, é o NPC

04:51.070 --> 04:57.940
retirado da posição do jogador e isso lhe dará seu vetor de direção.

04:57.970 --> 05:06.340
Depois, calculamos o ângulo entre esse vetor de direção e o vetor voltado para a frente do NPC e podemos fazer isso

05:06.340 --> 05:09.700
com o nosso Vector3. Método de ângulo.

05:09.700 --> 05:12.150
Então isso nos dá um ângulo em graus.

05:12.160 --> 05:20.260
Depois disso, faremos uma instrução if para testar se o comprimento desse vetor de direção está

05:20.260 --> 05:29.470
dentro do nosso alcance visível e nosso ângulo é menor que o ângulo visível, então estamos prontos para prosseguir.

05:29.800 --> 05:35.430
Depois disso, estou definindo os vetores de direção 'y' para 0.

05:35.620 --> 05:40.190
Portanto, o vetor de direção será em 3 dimensões.

05:40.360 --> 05:49.600
Se seu personagem for maior ou menor que o robô, ter um valor y diferente fará com que ele se incline e se você não

05:49.600 --> 05:55.390
quiser que se incline para cima ou para baixo para olhar para seu personagem, você

05:55.390 --> 05:58.620
quer que ele fique fundamentado em y -axis

05:58.750 --> 06:07.570
sempre voltado para cima, é uma boa ideia definir essa alteração no 'y' sempre de volta para 0 depois de fazer o cálculo.

06:07.570 --> 06:11.230
Confie em mim, isso vai manter tudo na horizontal.

06:11.230 --> 06:22.240
Em seguida, configuramos a rotação do NPC com um slerp (como fizemos no passado) para deslizar gradualmente em direção ao vetor

06:22.630 --> 06:26.240
de direção, usando o nosso rotationSpeed.

06:26.410 --> 06:34.460
Portanto, com este código, se o jogador estiver dentro do alcance visível do NPC, ele sempre estará voltado para ele.

06:34.600 --> 06:40.480
Então nós apenas temos que decidir se vamos empurrar o NPC para frente, em direção ao jogador.

06:40.480 --> 06:41.700
Então

06:41.770 --> 06:43.970
aqui embaixo, depois

06:44.130 --> 06:49.960
disso, temos 'if (direção. magnitude> shootDist) ', o que significa que

06:49.960 --> 06:57.910
estamos fora do alcance para atirar, mas ainda estamos dentro do alcance para correr atrás do personagem (porque isso

06:57.910 --> 07:01.190
está dentro dessa declaração if aqui em cima),

07:01.360 --> 07:06.920
portanto, se não podemos atirar, então vamos correr em direção ao jogador, caso

07:07.330 --> 07:10.150
contrário, vamos atirar e, portanto, estamos

07:10.270 --> 07:12.920
definindo esse valor de 'estado'.

07:13.120 --> 07:20.020
Se o jogador estiver fora do nosso alcance, basta definir o estado como IDLE com esse 'mais' aqui,

07:20.020 --> 07:24.000
para garantir que você tenha essa declaração if correta, caso

07:24.010 --> 07:26.530
contrário, isso dará errado para você.

07:26.530 --> 07:29.820
Então, depois disso (e fora dessa

07:29.830 --> 07:39.260
instrução if-else, temos um 'if (state == "RUNNING")' e, em seguida, empurre o caractere para frente, nesta linha aqui.

07:39.290 --> 07:43.870
Portanto, é a única vez que você deseja Traduzir o personagem, quando está

07:44.200 --> 07:48.050
no estado RUNNING, caso contrário, fica parado (Ocioso) ou TIRO.

07:48.170 --> 07:51.310
Certo, salve isso, volte para o Unity e adicionaremos

07:51.440 --> 07:56.110
esse código (arraste e solte-o no seu robô), selecione o robô, descubra

07:57.270 --> 08:02.390
onde está o código e onde 'Player' está exposto, arraste e solte seu FPSController

08:02.390 --> 08:09.450
nele, para que o A. EU. sabe sobre isso.

08:09.450 --> 08:09.660
Tudo certo.

08:09.660 --> 08:10.770
Vamos testar isso.

08:10.850 --> 08:14.620
Pressione Play e, se olharmos em volta e encontrarmos o robô ...

08:14.630 --> 08:15.850
ali está ele.

08:15.920 --> 08:19.900
Agora, suas animações não vão funcionar neste momento.

08:19.910 --> 08:22.780
Só queremos verificar, se nos afastarmos, perceber como

08:22.790 --> 08:24.770
ele está nos seguindo.

08:24.770 --> 08:27.360
Este é ele nos perseguindo e

08:27.830 --> 08:31.910
quando ele chegar perto o suficiente, ele irá parar e então ele

08:32.090 --> 08:37.420
irá para o tiroteio e se nos virarmos, ele também continuará se voltando para nós.

08:37.680 --> 08:43.710
Portanto, deve haver um ponto (se pudermos ficar fora do alcance dele) de

08:44.280 --> 08:46.230
que ele realmente

08:46.560 --> 08:56.640
parará de se mover, o que está por aí; se ficarmos fora do alcance e caminharmos atrás dele (fora do ângulo visível),

08:56.640 --> 09:03.040
deveríamos estar capaz de esgueirar-se de lado e ele não vai nos detectar.

09:03.250 --> 09:13.280
Então ele não está nos detectando porque não está se virando para nós, mas se nos movermos dentro do alcance (vamos sair aqui) lá, ele nos detectou,

09:13.280 --> 09:17.400
virou-se para nós e começou a se mover ao nosso alcance.

09:17.420 --> 09:23.040
Ok, essa é a lógica básica dessa linha de visão.

09:23.210 --> 09:27.280
Agora que a lógica da Linha de Visão está lá, podemos adicionar as animações.

09:27.320 --> 09:31.980
Agora, o robô que lhe dei tem animações e está pronto para ser usado.

09:32.180 --> 09:36.740
Se você clicar no robô, verá que ele possui um Animador no Inspetor.

09:36.920 --> 09:42.710
Se você clicar duas vezes no RobotGuard, ele abrirá a janela do Animator e você poderá ver o que

09:42.710 --> 09:43.600
está lá.

09:43.760 --> 09:44.930
É muito simples.

09:44.930 --> 09:51.930
Ele é configurado de maneira bem parecida com as coisas que usamos antes e basicamente são

09:52.370 --> 09:53.950
os estados de

09:53.960 --> 10:00.600
animação, 'ocioso', 'executado' e 'disparado', e todos estão ligados por transições e gatilhos nessas transições.

10:00.620 --> 10:05.860
Então, eu as configurei, há um 'isRunning' e 'isShooting' e

10:06.080 --> 10:11.780
um 'isIdle' e todos eles se vinculam entre esses estados de animação.

10:11.990 --> 10:16.660
Portanto, não há nada que você precise fazer para isso, no que diz respeito à

10:16.670 --> 10:26.810
configuração, mas o que faremos é acioná-los no código com base no estado em que o NPC está. A propósito, esse modelo de robô em particular veio com

10:26.810 --> 10:33.050
um projeto do Unity há muitos e muitos anos e nem me

10:33.050 --> 10:35.330
lembro qual versão era.

10:35.330 --> 10:40.730
Talvez um de vocês se lembre. Talvez tenha sido a versão 2 ou

10:40.730 --> 10:45.530
algo assim, porque essas animações eram animações herdadas, então atualizei as para o sistema mecanim.

10:45.530 --> 10:53.690
Então, vamos voltar ao código, voltar à nossa cena lá ... Ativos e abra o código.

10:53.690 --> 10:58.280
A primeira coisa que precisamos fazer (como sempre) é agarrar seu animador.

10:58.700 --> 11:07.750
Então, configuramos isso no topo e, em seguida, no Start, agarramos-no, então 'anim = this. GetComponent 'para o Animator, assim e

11:09.920 --> 11:12.770
depois temos que

11:12.840 --> 11:18.300
definir os gatilhos junto com cada estado.

11:18.300 --> 11:23.480
Então, na atualização, vamos ao primeiro para RUNNING.

11:24.300 --> 11:35.250
Agora aqui, podemos colocar 'anim. SetTrigger ("isRunning"); ' - lembre-se de soletrar seus gatilhos e colocar letras maiúsculas

11:35.250 --> 11:40.690
exatamente da mesma maneira que são configuradas nos parâmetros no Animator.

11:40.920 --> 11:47.460
Agora isso definirá o gatilho para fazer com que a animação 'isRunning' funcione.

11:47.460 --> 11:55.080
O único problema de fazê-lo dessa maneira é que, se o personagem já estiver em execução, ele será

11:55.110 --> 11:56.770
reativado, reativado e

11:56.820 --> 12:01.560
reativado, e você poderá acabar com coisas estranhas acontecendo com vários disparos.

12:01.710 --> 12:14.450
Para que possamos testar ... 'if (estado! = "RUNNING") ', então definiremos o estado como RUNNING e o

12:14.450 --> 12:16.460
gatilho para' isRunning '.

12:16.460 --> 12:20.150
Portanto, isso indica que, se você não estiver executando, comece a

12:20.270 --> 12:24.430
executar e, se já estiver executando, não há necessidade de começar a executar novamente.

12:24.470 --> 12:30.460
A mesma coisa para todos esses outros, então faremos o mesmo com as filmagens. Então é 'if

12:30.460 --> 12:33.350
(estado! = "TIRO") ','

12:33.350 --> 12:36.530
state = "TIRO"; e 'anim. SetTrigger ("isShooting"); '

12:36.740 --> 12:39.320
e mais uma vez, ocioso.

12:39.530 --> 12:47.150
Portanto, agora isso definirá nossas animações com base no estado e garantirá que elas não sejam definidas

12:47.390 --> 12:51.620
duas vezes seguidas e logo na parte inferior, do

12:51.620 --> 12:55.850
lado de fora, se as estiver executando, ainda executaremos

12:56.060 --> 12:57.890
nosso avanço Tradução.

12:57.980 --> 12:59.770
Tudo bem, então salve

13:00.620 --> 13:03.240
isso e vamos voltar e experimentar.

13:03.250 --> 13:10.430
Então, pressione Play ... ele vai começar a atirar (o que é porque estamos bem

13:10.610 --> 13:14.270
ao lado dele) e agora, se ficarmos fora do alcance, ele

13:15.210 --> 13:23.520
vai correr atrás de nós e começar a atirar (eu vou fazer minha janela de jogo um pouco maior) e se eu conseguir ficar fora

13:23.520 --> 13:26.950
do alcance, ele perderá o interesse e voltará ao estado ocioso

13:26.950 --> 13:28.350
que você pode

13:28.890 --> 13:30.570
ver lá e poderemos ...

13:35.310 --> 13:40.320
esgueirar-se e porque não estamos dentro desse intervalo, ele não está

13:41.080 --> 13:48.760
nos notando e eu posso me virar ... volte ao alcance e ele começará

13:48.760 --> 13:56.980
a atirar e nos perseguir e se virarmos enquanto estivermos ao alcance, ele irá virar.

13:57.560 --> 14:00.740
Então isso é muito

14:00.840 --> 14:09.140
simples A. EU. mecânica chamada Line Of Sight, para fazer seu NPC perseguir o jogador com base

14:09.140 --> 14:10.190
em uma variedade de visibilidade.
