WEBVTT

00:11.040 --> 00:14.090
Nesta palestra, examinaremos o conceito de 'Fugir'.

00:14.380 --> 00:19.410
É uma técnica comum usada em A. EU. para fazer com que um NPC se afaste de um local.

00:19.450 --> 00:24.580
A técnica pode ser usada em qualquer tipo de NPC. Nesse caso, aplicaremos à nossa multidão

00:24.580 --> 00:31.300
em que estamos trabalhando. Matematicamente, fugir funciona assim ... um objeto ou local é introduzido

00:31.300 --> 00:32.570
em um ambiente.

00:32.940 --> 00:38.740
O NPC determina onde o objeto está em relação à sua própria posição. Eles então calculam um novo local da

00:38.740 --> 00:41.560
meta que está longe do objeto.

00:41.650 --> 00:45.410
Nesse caso, usaremos a direção oposta exata.

00:45.430 --> 00:51.280
Isso pode ser calculado usando o vetor em direção ao objeto e retirando-o da posição dos NPCs.

00:52.150 --> 00:53.800
Com a nova localização do objetivo,

00:53.800 --> 00:59.020
o agente pode se virar e começar a segui-lo, sendo retirado do objeto em questão. Outros fatores que podemos considerar são

00:59.250 --> 01:05.020
o 'raio de influência do objeto' e o 'período de espera'. O raio determina o quão perto um

01:05.020 --> 01:10.990
NPC deve estar de um objeto a ser afetado e a recarga é por quanto

01:10.990 --> 01:18.820
tempo o NPC foge antes de retornar ao comportamento normal. Para implementar a fuga na multidão atual da cidade e chegar

01:18.820 --> 01:25.180
ao ponto em que estou agora, você precisará adicionar um cilindro e fazer uma pré-fabricação a partir dele.

01:25.180 --> 01:34.280
Então, o que eu fiz foi acessar a Hierarquia e clicar com o botão direito do mouse> Objeto 3D> Cilindro 'e eu

01:34.280 --> 01:41.760
não alteramos o tamanho, mas o que fiz foi criar um material verde e anexá-lo a esse cilindro.

01:41.780 --> 01:49.730
Peguei esse cilindro da Hierarquia e arrastei-o para o Ativo, o que criará uma

01:50.210 --> 01:55.980
pré-fabricação desse cilindro para você. Vou apenas excluir minha segunda versão.

01:56.060 --> 02:02.670
Agora, este cilindro não está fazendo nada além de marcar o local em que vamos clicar.

02:02.750 --> 02:10.490
Então, precisamos de algum código para posicionar o cilindro no NavMesh, onde clicamos com o mouse.

02:10.610 --> 02:20.330
Então, vamos criar um novo código C # e vamos chamá-lo de 'DropCylinder', abrir esse código e

02:20.390 --> 02:22.270
adicionaremos esse código.

02:22.340 --> 02:27.420
Então, primeiro de tudo, temos um objeto de jogo público exposto que estamos chamando de 'obstáculo'.

02:27.440 --> 02:31.350
É aqui que passaremos pela nossa pré-fabricada do cilindro.

02:31.430 --> 02:38.650
Vamos então manter uma matriz de todos os agentes que estão em cena e,

02:38.900 --> 02:46.870
portanto, no Start, coletaremos todos esses agentes encontrando os objetos do jogo que possuem a

02:46.870 --> 02:48.500
tag 'agent'.

02:48.580 --> 02:56.090
Isso significa que você terá que criar a tag 'agente' e adicioná-la aos seus personagens.

02:56.110 --> 03:05.590
Então, eu tenho meus personagens. Coloquei-os em 'Multidão' e os duplicou. Eu criei alguns deles. Não tenha muitos, porque quanto mais

03:05.800 --> 03:10.900
você tem, mais lento isso vai acontecer, mas você quer apenas

03:11.170 --> 03:12.570
o suficiente.

03:12.580 --> 03:18.550
Agora, sob esse 'Multidão', se você clicar em todos eles, poderá adicionar uma tag 'agente'.

03:18.550 --> 03:25.840
Então, eu criei uma nova tag chamada 'agent', com uma letra minúscula 'a' e apenas defini-a para todos os personagens que

03:25.840 --> 03:27.100
estão na multidão.

03:27.280 --> 03:33.040
Então, voltando ao código, esses agentes estarão sentados nessa matriz de 'agentes' e isso significa que,

03:33.070 --> 03:38.740
quando descartamos o objeto, podemos enviar uma mensagem a todos eles dizendo que esse objeto

03:38.830 --> 03:40.720
está lá. É

03:40.720 --> 03:48.850
como o Agent Manager que tivemos em palestras anteriores. Agora, na atualização, é onde o botão do

03:48.850 --> 03:57.250
mouse será testado e, em seguida, faremos um RaycastHit no mundo a partir da posição da tela, usando

03:57.250 --> 04:01.090
a posição do mouse na câmera principal.

04:01.090 --> 04:05.700
Isso significa que sua câmera está marcada

04:05.700 --> 04:07.250
como 'MainCamera'.

04:07.430 --> 04:09.420
Então lembre-se de onde isso é ... vá para

04:09.440 --> 04:14.660
a câmera e a etiqueta deve ser 'MainCamera' aqui, para que ela capte isso.

04:14.660 --> 04:21.110
Agora, estamos fazendo nosso Raycast de física no mundo, descobrindo onde ele atinge ... onde ele atinge, instanciamos uma

04:21.110 --> 04:24.200
cópia do nosso cilindro.

04:24.200 --> 04:30.300
Então esse é o obstáculo, vamos colocá-lo no local da ocorrência e depois usaremos a rotação padrão

04:30.320 --> 04:34.090
da pré-fabricada para isso, porque realmente não é tão importante.

04:34.430 --> 04:40.040
Em seguida, temos uma declaração 'foreach' que percorre todos os agentes da

04:40.460 --> 04:47.840
cena e chama um método para eles (que ainda não escrevemos), mas será chamada 'DetectNewObstacle' e

04:47.840 --> 04:53.990
nós ' vou passar o hitInfo. point, que é o local de onde estamos colocando o cilindro.

04:53.990 --> 05:00.830
Então, isso é essencialmente dizer ao nosso agente que há um obstáculo sendo colocado e agora

05:00.830 --> 05:07.520
é seu trabalho fugir dele. Então salve isso ... isso lhe dará um pequeno erro, porque ainda não

05:07.580 --> 05:08.570
escrevemos esse DetectNewObstacle,

05:08.590 --> 05:10.410
mas é isso que faremos a seguir.

05:10.550 --> 05:17.930
Abra o script AIControl e este é o script que você deve anexar a cada

05:18.020 --> 05:19.280
agente na

05:19.280 --> 05:24.020
cena; portanto, é sempre uma boa ideia criar um e

05:24.020 --> 05:30.740
duplicá-lo para que você não precise adicioná-lo. Meu código AIControl é um pouco diferente do que eu

05:30.740 --> 05:34.490
deixei na última palestra, então eu o analisarei rapidamente e mostrarei as alterações.

05:34.490 --> 05:41.660
Primeiro de tudo, eu criei esse 'speedMult' aqui em cima. Ele foi incorporado no código mais abaixo, como uma

05:41.660 --> 05:42.340
variável

05:42.380 --> 05:45.740
local, mas agora vamos usá-lo em alguns lugares diferentes.

05:45.770 --> 05:51.140
Portanto, o objetivo agora é ter 2 tipos diferentes de animações e 2 tipos diferentes de velocidade. Temos a caminhada e também

05:51.140 --> 05:51.960
a

05:52.160 --> 05:57.830
corrida, de modo que, quando o obstáculo for derrubado e o personagem

05:57.830 --> 06:00.530
estiver fugindo, queremos que ele fuja.

06:00.620 --> 06:02.270
Então coloque isso no topo. Em

06:02.300 --> 06:12.140
seguida, criei uma função chamada 'ResetAgent', porque eu redefiniria a velocidade do agente aqui e ali, dependendo de você estar fugindo

06:12.140 --> 06:16.850
ou apenas vagando e, portanto, é bom ter tudo disso

06:16.850 --> 06:22.080
em um único local, para que seja fácil mudar e atualizar.

06:22.100 --> 06:30.640
Agora, aqui você pode ver no ResetAgent, quando isso acontecer, ele definirá o multiplicador de velocidade como um valor aleatório.

06:30.800 --> 06:36.160
Antes, fazia isso e a função Iniciar para que o agente sempre tivesse a mesma velocidade.

06:36.170 --> 06:39.170
Agora isso mudará a velocidade do

06:39.380 --> 06:42.430
agente toda vez que houver uma redefinição.

06:42.440 --> 06:48.560
Portanto, é uma ótima maneira de tornar seus personagens um pouco mais aleatórios em seus movimentos, para

06:48.560 --> 06:53.290
que eles nem sempre estejam na mesma velocidade para o mesmo personagem.

06:53.420 --> 06:57.700
Agora, a seguir, temos a velocidade do agente definida aqui.

06:57.800 --> 07:05.220
Lembre-se de que é 2 como padrão nos caracteres, multiplicado pelo valor speedMult.

07:05.270 --> 07:09.470
Então, é só ter certeza de que está definido como 2

07:09.710 --> 07:12.780
e também estou configurando a velocidade angular.

07:12.890 --> 07:18.620
Se você der uma olhada no angularSpeed padrão no NavMesh Agent em um de seus

07:18.620 --> 07:21.320
personagens, verá que ele é 120.

07:21.320 --> 07:25.880
A velocidade angular é a rapidez com que o personagem se vira.

07:25.880 --> 07:31.050
Agora, o que eu quero é aumentar isso quando o personagem tiver que fugir.

07:31.100 --> 07:36.020
Então você quer que eles vejam algo de que precisa fugir e se virar muito rapidamente, o

07:36.020 --> 07:41.480
que significa que você precisa aumentar a velocidade angular e também quando, quando voltarem a andar, você terá

07:41.480 --> 07:43.010
que abaixá-lo novamente. .

07:43.010 --> 07:47.600
Então, estou colocando aqui de volta para 120. No ResetAgent, quando for

07:47.630 --> 07:56.540
redefinido, ele definirá o valor speedMult que está no sistema de animação como speedMult e definirá a

07:56.540 --> 07:57.440
animação

07:57.440 --> 08:06.890
curta novamente e, em seguida, estou fazendo um ResetPath aqui que limpa o caminho atual que o agente

08:07.010 --> 08:13.910
possui. calculado e basicamente o retorna de volta a 0 para que possa

08:14.270 --> 08:18.670
estar pronto para gerar outro caminho no sistema NavMesh.

08:18.680 --> 08:24.800
Agora, a função Iniciar ... o que faz é praticamente o que tínhamos antes.

08:24.800 --> 08:28.420
Por isso, ele captura todos os locais de

08:28.550 --> 08:33.920
meta do mundo, os agentes NavMesh, define o destino com um valor

08:34.140 --> 08:39.410
aleatório (esse código é exatamente o mesmo de antes, apenas aumentarei para

08:39.410 --> 08:47.150
que você possa vê-lo), localização aleatória fora da matriz goalLocations, agarra o animador que está no personagem e

08:47.150 --> 08:55.210
também define o deslocamento de caminhada (para que eles não andem todos juntos) para um valor entre aqui e

08:55.470 --> 09:02.630
depois executamos o ResetAgent (que seguirá em frente e definirá todos esses valores que estão aqui em

09:02.780 --> 09:04.580
cima para nós).

09:04.730 --> 09:12.900
Agora, na atualização, é a mesma coisa que tínhamos antes, exceto que estamos fazendo um ResetAgent antes

09:12.900 --> 09:15.490
de definir o próximo destino.

09:15.540 --> 09:22.110
O que isso significa é que, se estivermos correndo para um local porque estamos fugindo

09:22.110 --> 09:27.480
dele, quando chegarmos lá, voltaremos a andar e buscaremos outro local

09:27.480 --> 09:34.350
de objetivo e continuaremos vagando por aí. As novidades que adicionaremos a este código para facilitar a fuga ...

09:34.410 --> 09:44.510
Em primeiro lugar, precisamos de um float, que será o 'detectionRadius' e essa é a distância de 'onde o objeto

09:44.510 --> 09:52.100
é descartado' a 'até que ponto os agentes próximos precisam estar para poder ouvi-lo'.

09:52.100 --> 09:58.280
Agora, se você tiver esse tamanho, todos os agentes da área responderão a ele. Se for menor, apenas os que estão dentro de

09:58.370 --> 10:03.770
um raio de 5 irão responder, o que é bom porque você pode ter uma pequena

10:03.770 --> 10:09.170
distração em fuga ou pode ter algo que é bastante grande como uma distração em fuga.

10:09.170 --> 10:13.380
Também precisamos de um carro alegórico para o 'fleeRadius' e é

10:13.430 --> 10:20.480
assim que você deseja que os personagens fuja do objeto antes que eles se esqueçam dele e comecem a

10:20.480 --> 10:24.290
voltar e procurar um novo local para o objetivo.

10:24.320 --> 10:27.810
Então, vamos definir isso para 10, neste caso.

10:28.040 --> 10:34.630
Certo, agora, com isso, o que vamos fazer é criar o método que eu

10:34.760 --> 10:42.530
falei antes (DetectNewObstacle) que está sendo chamado a partir da queda dos objetos no outro script de clique.

10:42.530 --> 10:45.630
Portanto, o novo método ficará assim.

10:45.650 --> 10:51.830
Então será público porque está sendo chamado de outro lugar e estamos passando pela

10:51.920 --> 10:55.900
posição do obstáculo que está sendo jogado em cena.

10:55.980 --> 11:03.470
Vamos então fazer um teste de distância da 'posição do objeto' e da 'posição do agente'.

11:03.470 --> 11:09.480
Agora, se estiver dentro do raio de detecção, o agente reagirá a ele.

11:09.560 --> 11:15.490
Se o agente vai fugir, ele precisa determinar em qual direção

11:15.490 --> 11:24.290
ele vai fugir, que está longe da posição do obstáculo e determinar isso, é a posição

11:24.290 --> 11:33.620
do agente menos a posição do obstáculo. Observe que eu estou normalizando para ter um vetor

11:33.620 --> 11:41.360
de comprimento 1 e vou usá-lo como 1 para multiplicá-lo pelo fleeRadius, que você pode ver aqui.

11:41.480 --> 11:51.830
Portanto, é o fleeDirection para um comprimento de fleeRadius, adicionado à posição atual do agente e é

11:51.830 --> 11:56.140
aí que está o novo objetivo.

11:56.190 --> 12:01.860
Agora, com essas novas informações sobre a meta, podemos definir o destino do

12:01.960 --> 12:07.290
agente, mas de antemão, vamos ver se conseguimos chegar a esse local.

12:07.290 --> 12:14.180
Então você poderia ter um agente. setDestination newgoal, mas, nesse caso, é

12:14.400 --> 12:23.520
possível calcular um local que esteja totalmente fora do NavMesh do agente ou não ser

12:23.580 --> 12:32.070
totalmente acessível e isso significa que você ainda deseja que o agente tente

12:32.070 --> 12:34.530
acessá-lo, se possível.

12:34.530 --> 12:39.220
Portanto, essa é uma maneira diferente de trabalhar o caminho.

12:39.270 --> 12:48.780
O que fazemos é criar um objeto de caminho NavMesh e esse objeto de caminho pode ser calculado com

12:48.780 --> 12:49.770
CalculatePath.

12:49.770 --> 12:57.270
Então, criamos esse valor para o caminho e o passamos para calcular o caminho, dada a nova posição do objetivo.

12:57.270 --> 13:02.780
Agora, esse caminho manterá o caminho que o agente seguirá para chegar

13:02.850 --> 13:09.060
ao objetivo, mas se ele puder apenas fazer parte do caminho ou não conseguir, você

13:09.060 --> 13:11.170
poderá testá-lo. status.

13:11.370 --> 13:20.700
Nesse caso, se o caminho. status não é igual a um caminho inválido,

13:21.180 --> 13:33.270
ele definirá o destino para o final do caminho que é calculado. Então, o próprio 'caminho' termina com uma matriz chamada 'cantos' e essa é uma matriz de

13:33.390 --> 13:40.000
todos os pontos de referência, essencialmente, que o personagem seguirá à medida que for de onde está

13:40.000 --> 13:42.180
até a localização do objetivo.

13:42.180 --> 13:49.560
Agora, se não for possível chegar até o local da meta, você ainda terá essa matriz de cantos,

13:49.560 --> 13:55.890
mas isso levará apenas parte do caminho, o que significa que se você obtiver o

13:55.890 --> 14:02.640
último valor na matriz de cantos (que é esse um aqui), você chegará ao final do caminho

14:02.640 --> 14:11.940
que foi calculado, mesmo que não tenha atingido a meta exata. Portanto, você fará com que o agente se afaste pelo menos de alguma maneira de onde

14:11.940 --> 14:13.140
você colocou o obstáculo.

14:13.410 --> 14:22.140
Nesse ponto, configuramos a animação para execução e, em seguida, aceleramos o agente com o agente. velocidade e aumentamos a velocidade angular bastante alta, porque

14:22.140 --> 14:27.210
queremos que o agente dê meia-volta muito rapidamente e depois

14:27.210 --> 14:30.360
siga na direção totalmente oposta.

14:30.780 --> 14:39.710
Tudo bem, então salve isso e depois voltaremos para o Unity. O que você precisa fazer para testar isso (você pode

14:39.720 --> 14:43.370
ver que removi todos os prédios, dupliquei

14:43.470 --> 14:49.770
meus agentes) Tenho quatro objetivos e os coloquei em um quadrado ao redor da área,

14:49.770 --> 14:55.510
então os agentes quando eu pressiono Play, apenas andamos aleatoriamente entre esses objetivos.

14:56.820 --> 15:04.380
Agora, para configurar o clique para o cilindro, temos nosso script DropCylinder aqui. Vou apenas adicioná-lo à câmera (arraste

15:04.560 --> 15:08.040
e solte na câmera).

15:08.040 --> 15:15.990
Ele só precisa estar em cena para que seja executado e, em seguida, o script DropCylinder exija nosso Cilindro

15:15.990 --> 15:17.750
pré-fabricado que criamos anteriormente.

15:17.750 --> 15:27.860
Então pegue isso e coloque-o lá. Agora, quando pressionamos Play, se soltarmos um cilindro, você verá

15:28.290 --> 15:35.720
que os agentes fogem dele e depois voltam porque só fogem o mais longe que precisam

15:35.720 --> 15:40.890
para encontrar a localização do objetivo e então começam a vagar

15:40.890 --> 15:47.310
de volta e procurando outros objetivos. Então eles ainda estão se movendo aleatoriamente em torno

15:47.310 --> 15:52.650
desses 4 objetivos diferentes, que estão nesses quatro cantos, onde eles tendem a se agrupar.

15:52.710 --> 16:00.240
Certo, então, se você quiser mudar isso para que todos reajam, se voltarmos ao nosso AIControl, vá para o

16:00.240 --> 16:05.880
topo aqui e se mudarmos esseradio de detecção para 20, isso provavelmente deve abranger

16:05.910 --> 16:09.210
todo mundo nessa cena. Salve isso.

16:09.390 --> 16:17.170
Volte e pressione Play. Quando deixarmos isso aqui, todos vão fugir.

16:17.240 --> 16:23.990
Agora eles ainda não estão fugindo muito, porque você ainda tem esse raio de 10 (ou o que quer que

16:23.990 --> 16:28.830
tenhamos lá) e pode mudar isso se quiser empurrá-los até as bordas do NavMesh.

16:28.910 --> 16:39.200
Agora, as chances são de que, quando você estiver fazendo isso, haverá um agente estranho que aparentemente estará ignorando o

16:39.380 --> 16:49.040
obstáculo e isso acontecerá porque no seu script do AIControl logo abaixo, onde você está calculando o caminho,

16:49.040 --> 16:59.060
pode ser possível se você tem um fleeRadius muito, muito grande para tentar calcular um novo objetivo que está

16:59.060 --> 17:07.400
tão distante do NavMesh atual que apenas retornará um caminho inválido e não há realmente nada

17:07.640 --> 17:11.210
que você possa fazer sobre isso.

17:11.240 --> 17:14.060
Então você tem que viver com isso.

17:14.060 --> 17:21.680
A outra alternativa é que você teria que programar manualmente como uma parte 'outra' para isso aqui,

17:21.770 --> 17:28.070
o agente girando e saindo na direção oposta, o que significa que você perde

17:28.070 --> 17:34.150
o controle do agente e o agente não estaria mais navegando via NavMesh

17:34.190 --> 17:36.710
e isso pode causar problemas.

17:36.860 --> 17:40.390
Portanto, você decide se deseja ou não fazer isso ou

17:40.460 --> 17:44.350
se está feliz em aceitar o fato de que isso não funciona.

17:44.390 --> 17:52.910
Caso contrário, você realmente precisa ter certeza de que seu fleeRadius estará dentro do NavMesh ou, pelo menos, não

17:52.910 --> 17:59.220
muito ridiculamente longe do NavMesh, para que não calcule um caminho válido para você.

18:00.340 --> 18:05.060
Então é assim que seus NPCs fogem de um espaço.

18:05.070 --> 18:12.520
Isso está usando o método NavMesh, mas o cálculo do vetor a ser executado e a nova localização da meta é exatamente

18:12.940 --> 18:18.050
a mesma, se você quiser implementar isso em seu próprio sistema de waypoint manual.

18:18.070 --> 18:25.460
Você apenas criaria um novo waypoint em tempo real e forneceria essa nova posição de objetivo, com a matemática vetorial

18:25.540 --> 18:28.000
que está neste programa em particular.
