WEBVTT

00:11.050 --> 00:18.080
Nesta terceira parte do workshop, vamos criar peixes que podem detectar obstáculos em

00:18.080 --> 00:21.500
seu ambiente e se afastar deles.

00:22.010 --> 00:29.300
Agora, para começar, o que eu criei aqui é exatamente o mesmo programa que você teve antes do

00:29.300 --> 00:37.580
anterior, mas eu adicionei em um plano de terra com alguma textura de areia e este pilar, que será nosso obstáculo .

00:37.580 --> 00:40.640
Você pode adicionar qualquer coisa à cena como um obstáculo.

00:40.730 --> 00:46.420
Esse pilar em particular que recebi da Asset Store aqui, é gratuito,

00:46.490 --> 00:55.670
é chamado Stylize Sand Pillar, se você quiser usá-lo. A primeira coisa que você precisa fazer é adicionar um colisor ao seu objeto, então selecione-o

00:55.760 --> 01:01.010
e vá até o Inspetor ... [Adicionar componente] ... Box Collider.

01:01.340 --> 01:06.560
Então, vamos testar se o peixe está prestes a colidir com esses objetos.

01:06.560 --> 01:13.460
É um pouco diferente dos testadores de caixa delimitadora que estávamos fazendo antes. Para testar isso minuciosamente, você também

01:13.460 --> 01:19.090
precisará garantir que os peixes vão nadar através do seu objeto.

01:19.160 --> 01:24.510
Então, para começar, iremos ao FlockManager e o FlockManager no meu caso,

01:24.530 --> 01:27.380
aqui, está sentado acima deste pilar.

01:27.380 --> 01:35.600
Vou movê-lo para baixo para que fique dentro desse pilar e os peixes precisem nadar através dele para

01:35.600 --> 01:41.900
chegar à posição do FlockManager como sua posição de meta e para garantir que

01:41.900 --> 01:43.650
isso não mude

01:43.760 --> 01:48.670
enquanto estamos Nos testes, você precisará acessar o código do FlockManager

01:48.680 --> 01:56.600
e, na parte aleatória desta atualização, vamos comentar a nossa configuração da localização aleatória da meta e usar

01:56.600 --> 01:59.570
a localização definida para o FlockManager.

01:59.820 --> 02:06.360
Portanto, se você salvar isso, volte e jogue para testar se os peixes realmente nadam através do

02:06.360 --> 02:13.080
seu objeto, você pode vê-los agora, começando a nadar em direção à meta do FlockManager e atravessando o

02:13.110 --> 02:13.810
colisor.

02:14.010 --> 02:21.930
O que é realmente importante neste momento é porque colocamos um Box Collider em nosso pilar, não queremos um colisor

02:21.930 --> 02:25.890
de física nos peixes, porque não faremos dessa maneira.

02:25.890 --> 02:28.600
Portanto, verifique se o seu peixe não tem um colisor.

02:28.860 --> 02:35.730
Se você precisar que seus objetos reunidos tenham um colisor, precisará usar

02:35.730 --> 02:43.820
diferentes camadas de física para garantir que os peixes não colidam com seus objetos na cena.

02:43.830 --> 02:48.840
Agora, a maneira como conseguiremos evitar obstáculos com um colisor de física é fazer um radiodifusão

02:48.840 --> 02:53.720
física a partir da posição de cada peixe ao longo de seu vetor avançado.

02:54.120 --> 02:59.690
Depois testamos se esse raio colidiu com alguma coisa e, se tiver, afastamos o peixe.

03:02.610 --> 03:08.970
Integraremos essa funcionalidade ao script do Flock, portanto, abra seu script do Flock. Na atualização, onde determinamos se ainda

03:09.090 --> 03:14.690
estamos dentro de nossa caixa delimitadora (que estava aqui), adicionaremos um segundo

03:14.790 --> 03:21.890
teste que é o nosso raycast de física e será um 'OU' nessa declaração if .

03:21.900 --> 03:30.510
Portanto, se estamos fora da caixa OU atingimos algo com nosso raycast. Para executar um raycast, precisamos criar

03:30.510 --> 03:40.380
nosso item RaycastHit 'hit' e depois usamos a Física. Raycast, a posição em que o raio está começando

03:40.380 --> 03:47.010
e a direção do raio (nesse caso, será a direção para a frente do

03:47.010 --> 03:52.760
seu peixe, multiplicada por quanto tempo você deseja que esse raio).

03:52.760 --> 03:59.640
Agora, se você fizer isso por muito tempo, o peixe pensará que está colidindo com algo quando estiver

03:59.640 --> 04:01.050
muito longe dele.

04:01.140 --> 04:04.650
Se você o fizer curto, o peixe chegará perto dele antes

04:04.650 --> 04:06.570
de decidir que precisa virar.

04:07.020 --> 04:12.340
Portanto, este aqui (o próprio vetor direto) terá apenas 1 comprimento.

04:12.420 --> 04:18.840
Então já está normalizado e multiplicado por ... depende de você, é o quanto você deseja que o peixe reaja com

04:18.840 --> 04:26.220
base no quão perto eles estão e então estamos agarrando o ponto de impacto do nosso raycast. Agora, há outra função raycast que você pode executar

04:26.220 --> 04:31.410
que apenas informa que você atingiu alguma coisa e não retorna onde atingiu,

04:31.650 --> 04:33.110
mas usaremos esse

04:33.180 --> 04:36.400
ponto de vida um pouco mais tarde.

04:36.550 --> 04:38.490
Agora essa é a nossa parte 'OU'

04:38.520 --> 04:40.080
e depois vamos para

04:40.110 --> 04:43.470
'virar = verdadeiro' se nosso raio de transmissão atingiu alguma coisa.

04:43.500 --> 04:49.530
Agora, o que vou fazer aqui embaixo é colocado em uma pequena linha de depuração (e você também pode fazer isso) porque

04:49.530 --> 04:54.630
quando você está tentando depurar A. EU. é uma dor de

04:54.690 --> 05:00.360
cabeça absoluta se você estiver sentado olhando a tela e tentando descobrir o que seus

05:00.360 --> 05:07.770
personagens estão fazendo e se estão fazendo a coisa certa. Nesse caso, queremos saber QUANDO o peixe está virando e queremos saber POR

05:07.770 --> 05:09.430
QUE o peixe está virando.

05:09.630 --> 05:20.400
Então, eu vou desenhar o raio real que o peixe está projetando quando está no modo de rotação e isso vai nos

05:20.400 --> 05:21.540
ajudar muito.

05:21.540 --> 05:27.070
Portanto, salve isso depois que você tiver feito e depois voltaremos ao Unity e pressione Play.

05:27.180 --> 05:27.490
Está bem.

05:27.510 --> 05:30.390
Agora você pode ver muitas linhas vermelhas acontecendo. Estes são seus

05:30.450 --> 05:31.150
raios

05:31.160 --> 05:39.390
de peixes quando eles estão girando; portanto, se eles estão voltados para o pilar, o raio deles quando atinge o

05:39.390 --> 05:45.600
pilar, aparecerá vermelho e indicará que eles estão entrando no modo de rotação como bem.

05:45.600 --> 05:49.950
Agora você pode ver, neste caso, eles estão circulando ao redor, entraram nesse tipo de ritmo em

05:49.950 --> 05:51.690
que não estão se transformando aqui.

05:51.750 --> 05:57.980
Poderíamos entrar no FlockManager e aumentar a velocidade de rotação, para que eles girassem.

05:57.980 --> 06:04.650
Você pode ver lá. Agora todos estão se transformando nesse pilar, mas não parecem estar

06:04.710 --> 06:06.320
se afastando do pilar.

06:06.370 --> 06:12.450
A razão para isso é a maneira como codificamos para onde eles vão virar.

06:12.700 --> 06:14.060
Se você

06:14.410 --> 06:24.100
se lembrar (vamos voltar ao código) quando estivermos mudando, vamos nos voltar para o centro do FlockManager e

06:24.140 --> 06:27.850
o centro do FlockManager também é o

06:27.960 --> 06:33.560
objetivo, e atualmente o colocamos no meio do nosso pilar.

06:33.570 --> 06:41.540
Portanto, isso não vai funcionar, neste caso, porque toda vez que nosso raio colide com algo, ele diz: "Ok, eu tenho que

06:41.550 --> 06:43.270
me virar, mas preciso

06:43.410 --> 06:43.860
me

06:43.920 --> 06:47.700
virar para o centro do meu gerente" e, portanto, a coisa

06:47.730 --> 06:53.120
estamos tentando nos afastar está em conflito com o lugar para onde vamos nos virar.

06:53.220 --> 06:59.430
Então, temos que criar um local diferente e um objetivo diferente para o nosso peixe 'virar' e, para

06:59.730 --> 07:03.650
isso, tiraremos um pouco de inspiração de um jogo de bilhar.

07:03.720 --> 07:08.600
Quando o raio do peixe atinge o obstáculo, ele o faz em um ângulo específico.

07:08.610 --> 07:13.860
Agora, se o peixe fosse uma bola, você poderia prever como ele ricochetearia na superfície do obstáculo, assim como

07:13.860 --> 07:19.950
uma bola de bilhar salta do lado de uma mesa. Pela física, sabemos que o ângulo de incidência (a)

07:20.100 --> 07:22.910
é igual ao ângulo de reflexão (b).

07:23.010 --> 07:29.850
Portanto, podemos calcular uma nova localização da meta para nossos peixes usando o vetor que se afasta

07:29.940 --> 07:31.190
do obstáculo.

07:31.200 --> 07:36.600
Em outras palavras, queremos alinhar o vetor avançado do peixe com o vetor de reflexão. Para calcular o vetor

07:36.600 --> 07:42.660
de reflexão, usamos o ponto de vida que o raycast gera

07:42.660 --> 07:49.470
e o método 'reflect' disponível no Unity. O método de reflexão requer o vetor recebido e o normal da superfície

07:49.470 --> 07:55.170
atingida e retorna o vetor enviado. Para colocar isso em nosso código, voltamos ao rebanho. script cs, no

07:55.180 --> 08:03.700
método Update e o que vamos fazer é recalcular essa direção com base no que está acontecendo.

08:03.700 --> 08:09.910
Portanto, se você atingiu o lado do contêiner (saiu da caixa delimitadora), queremos que a direção

08:09.910 --> 08:12.130
volte ao centro dessa caixa.

08:12.130 --> 08:17.460
Caso contrário, se você acertar alguma coisa, então você quer se virar de acordo com o vetor de reflexão.

08:17.470 --> 08:20.850
Então, vamos começar por aqui. Após o RaycastHit, observe que

08:20.860 --> 08:27.280
também acabei de adicionar este novo RaycastHit aqui, para que não receba um resultado indefinido quando for usá-lo

08:27.280 --> 08:28.450
mais tarde.

08:28.450 --> 08:32.630
Então, configuramos para pelo menos alguma coisa e inicializamos. Aqui embaixo, vou mover

08:32.650 --> 08:37.350
essa "direção" de baixo para "girar". Vamos tirar isso

08:38.280 --> 08:40.980
daqui e colocá-lo aqui.

08:41.160 --> 08:47.130
Agora você não precisa defini-lo como nada aqui e pode defini-lo como 0, pois será

08:47.160 --> 08:50.040
definido nas próximas duas instruções if.

08:50.040 --> 08:55.940
Então, depois disso (deixe-me colocar um espaço para torná-lo mais claro), faremos 2 testes 'se'.

08:55.950 --> 08:58.010
Não usaremos mais esse 'OU'.

08:58.010 --> 09:04.780
Então, vamos nos livrar do 'OR', transformaremos isso em uma declaração if independente.

09:06.040 --> 09:14.420
Portanto, se a posição estiver fora da caixa delimitadora, colocaremos 'virar = verdadeiro' e, nesse ponto, é onde

09:14.600 --> 09:19.010
queremos que a direção seja igual a ISSO.

09:19.010 --> 09:24.530
Agora já está definido para isso, então, se estiver definido para isso, você não precisará defini-lo novamente. Se você definir isso

09:24.530 --> 09:29.630
como 0 lá em cima, poderá pegar ISTO, coloque-o

09:30.050 --> 09:36.020
aqui e depois defina-o como Vector3. zero; Agora, a próxima instrução

09:36.440 --> 09:39.600
if será um 'else if' no

09:42.410 --> 09:53.540
raycast de física e, neste caso, se tiver atingido algo, então, novamente, é verdade, removeremos nossa linha de depuração porque não precisamos

09:53.570 --> 10:02.620
mais disso e em vez disso 'direction = Vector3. Refletir'.

10:02.630 --> 10:10.820
Este é o método Reflect no Unity que podemos usar e o Reflect acontece devido a um vetor recebido (que é o nosso vetor avançado em nossos

10:10.820 --> 10:16.640
peixes) e o normal ao acerto (que será atingido). normal).

10:16.670 --> 10:22.400
Portanto, o RaycastHit contém todo tipo de informação sobre a posição atingida, é normal

10:22.430 --> 10:27.550
e várias outras coisas que você pode consultar no manual do Unity.

10:27.560 --> 10:33.650
Agora, isso criará 'direção' para ser o nosso vetor de reflexão que será usado aqui

10:33.860 --> 10:40.360
em baixo, se estivermos virando para que a direção ainda esteja aqui embaixo, não fizemos nenhuma alteração nessa.

10:40.520 --> 10:45.110
Então salve isso e agora podemos ver o que temos.

10:45.110 --> 10:51.190
Pressione Play e agora descobriremos que nossos peixes não nadam através do pilar.

10:51.350 --> 10:59.030
Eles podem cortar a borda e podem ter partes deles que atravessam o pilar porque lembre-se de que estamos fazendo um raycast, então essa é uma

10:59.030 --> 11:03.710
'única linha' para verificar se atingimos algo. Não estamos verificando se

11:03.710 --> 11:06.890
o corpo inteiro atingiu alguma coisa.

11:07.310 --> 11:12.350
Você pode colocar um colisor e fazer com que o peixe se vire quando ele atingir. Você precisaria tornar esse colisor um pouco

11:12.350 --> 11:19.240
mais longo que o peixe, para que ele soubesse quando atingisse algo e depois começasse a virar, mas essa é uma

11:19.290 --> 11:24.280
maneira muito barata (em termos de processador) de fazê-lo e você pode ver aqui, agora

11:24.410 --> 11:29.540
que temos esses peixes (e se eu voltar ao meu gerente de rebanho e apenas

11:29.540 --> 11:33.380
aumentar a velocidade de rotação deles para se aproximar um do outro),

11:33.380 --> 11:35.370
eles estão evitando a coluna.

11:35.390 --> 11:44.450
Vamos voltar ao código do FlockManager e colocar de volta nossos locais aleatórios para o nosso goalPos

11:44.990 --> 11:50.880
na atualização que removemos antes. Vamos salvar isso e agora também podemos adicionar outro rebanho.

11:50.900 --> 11:57.590
Então, o que vou fazer é pegar o FlockManager, vamos movê-lo para fora da coluna e, em seguida,

11:57.590 --> 12:01.550
pressionar Ctrl-D para duplicá-lo e movê-lo para lá e para as

12:01.730 --> 12:05.450
casas pré-fabricadas, neste caso, vou fazer o rosa peixe.

12:05.760 --> 12:07.000
Portanto, o

12:07.100 --> 12:13.410
peixe rosa que você já deveria ter incluído e terá o script Flock anexado a ele.

12:13.640 --> 12:19.430
Ok, então vamos pressionar Play e agora temos 2 bandos de peixes separados

12:22.150 --> 12:30.740
e você pode alterar o comportamento de cada rebanho apenas definindo sua velocidade de rotação, sua distância vizinha, sua velocidade

12:30.740 --> 12:33.400
máxima ... a partir daqui,

12:33.440 --> 12:35.270
as possibilidades são praticamente infinitas.

12:35.270 --> 12:39.390
Você pode ter um aquário muito bom montado com esse

12:39.560 --> 12:45.560
lote e também pode substituir o peixe por um pássaro se quiser algo no mar também.

12:45.600 --> 12:51.640
Então, espero que você tenha gostado disso, porque flocagem é realmente o meu A. favorito EU. algoritmo e acho

12:51.800 --> 12:57.050
absolutamente fascinante, os resultados obtidos com essas regras simples.
