WEBVTT

00:09.780 --> 00:12.180
Nesta palestra, examinaremos 'Reunindo-se'.

00:12.270 --> 00:15.060
Reunir tem que ser um dos meus A. favoritos EU. técnicas.

00:15.070 --> 00:21.220
Envolve regras simples que geram comportamentos complexos que são fascinantes. O flocagem pode ser usado para gerar procedimentalmente o

00:21.220 --> 00:26.680
movimento de grupos de indivíduos que gostam de ficar juntos, enquanto caminham em direção a

00:26.680 --> 00:28.190
um objetivo comum.

00:28.210 --> 00:33.850
O vôo dos pássaros vem à mente, mas essa técnica pode ser usada praticamente em qualquer lugar em que

00:33.850 --> 00:38.660
você tenha um grupo que precise de comportamentos móveis complexos que você não deseja programar manualmente.

00:38.710 --> 00:46.930
Neste workshop, criaremos peixes reunidos (ou escolarizados). Para acompanhar, faça o download do pacote 'AIfish'

00:46.930 --> 00:49.500
Unity que acompanha esta palestra.

00:49.510 --> 00:54.570
Abra um novo projeto do Unity para 3D e leve esse pacote.

00:54.640 --> 01:03.740
Ao adicioná-lo ao recurso, você encontrará um peixe verde, um peixe rosa e uma cena chamada Natação. Se você abrir a cena da Natação, obterá

01:03.750 --> 01:06.250
o peixe verde sozinho

01:06.250 --> 01:11.880
com a câmera configurada para ele e se pressionar Play,

01:12.070 --> 01:17.730
verá que esse peixe verde tem uma animação de natação anexada.

01:21.610 --> 01:25.950
Agora, para criar o agrupamento, você precisa de mais de 1 peixe neste

01:25.960 --> 01:29.290
caso, porque o agrupamento é uma atividade de grupo.

01:29.380 --> 01:32.240
Então, vamos criar um Flocking Manager e,

01:32.500 --> 01:38.660
na Hierarquia, clique com o botão direito do mouse lá e adicione um vazio e chame-o de FlockManager.

01:38.680 --> 01:45.070
Isso não é diferente dos outros Gerentes que tivemos anteriormente para outros agentes, onde

01:45.100 --> 01:51.160
queríamos criar várias versões deles para que possamos enviar mensagens e acompanhá-las.

01:51.190 --> 01:56.920
Nesse caso, os peixes precisam conhecer um ao outro, para que o FlockManager crie um monte

01:56.920 --> 02:05.530
de peixes e seja capaz de dizer a todos os indivíduos sobre os outros peixes no rebanho (ou escola, eu acho, mas eu estou

02:05.530 --> 02:06.940
chamando de rebanho).

02:07.060 --> 02:14.060
Certo, temos o nosso FlockManager, que é um 'vazio'. Crie um script C # e chame-o de FlockManager

02:16.310 --> 02:20.090
e, em seguida, esse script será anexado ao nosso FlockManager.

02:20.950 --> 02:27.390
Agora vamos abrir esse script e adicionar esse código. O código é bastante simples.

02:27.400 --> 02:35.950
Ele cria uma variedade de peixes, instancia todos esses objetos de peixes e os coloca em um

02:36.010 --> 02:40.810
local aleatório em torno do local do seu FlockManager.

02:40.810 --> 02:41.020
Direita.

02:41.020 --> 02:48.510
Então, antes de tudo, você precisará de uma variável exposta public fishPrefab e passamos aqui na nossa pré-fabricada de peixes (que pode ser

02:48.520 --> 02:55.140
seu peixe verde ou rosa ou qualquer outra coisa). Você também pode fazer isso com cubos, não fará

02:55.150 --> 02:56.610
nenhuma diferença e,

02:56.740 --> 03:03.220
em seguida, um número público que definimos como 20 (mas isso permitirá que você altere o número de

03:03.220 --> 03:07.270
peixes que você tem em um rebanho em particular, através de Inspetor).

03:07.600 --> 03:12.240
Em seguida, criaremos nossa matriz de allFish e, à medida

03:12.370 --> 03:17.690
que os instanciamos, eles entrarão nesse allFish e, em seguida, teremos um

03:17.710 --> 03:19.480
Vector3 chamado swimLimits.

03:19.480 --> 03:27.210
Esse é o intervalo de locais em que os peixes podem ser gerados.

03:27.220 --> 03:35.020
Portanto, isso é como uma caixa que está ao redor do seu gerente de rebanho e é 5x5x5, o que a

03:35.020 --> 03:38.340
torna 10x10x10, porque esse é um valor de

03:38.650 --> 03:44.790
raio e, em seguida, usaremos os swimLimits para gerar a localização de nossos peixes dentro dessa caixa.

03:44.800 --> 03:48.060
Então, tudo isso está acontecendo no Start.

03:48.160 --> 03:55.130
Antes de tudo, criamos todos os peixes e aumentamos o tamanho da matriz para mantê-los.

03:55.180 --> 04:01.540
Depois, há o loop 'for', que gira em torno desse número de vezes e

04:01.540 --> 04:11.650
cada vez cria uma posição para colocar o peixe, e essa posição é baseada na posição do gerente do rebanho, mais um

04:11.680 --> 04:18.160
valor Vector3 aleatório ao redor desses swimLimits (então entre 'menos swimLimits' e 'swimLimits positivo'),

04:18.160 --> 04:21.260
que fornecerão o intervalo de posições.

04:21.280 --> 04:26.980
Agora, se você deseja que ele seja uma caixa de posições maior, basta aumentar esses valores

04:26.980 --> 04:30.810
aqui ou diminuir os valores, se quiser um grupo unido.

04:30.910 --> 04:37.660
Então, uma vez que temos essa posição que calculamos, colocamos o peixe (instanciamos do

04:38.140 --> 04:43.930
nosso pré-fabricado) na posição que acabamos de calcular, usando uma rotação neutra.

04:43.930 --> 04:47.180
Você também pode definir isso para a

04:47.290 --> 04:51.790
rotação pré-fabricada de peixes, se você os apontar em uma direção específica,

04:52.090 --> 04:55.520
isso realmente não importa e isso preencherá essa matriz.

04:55.600 --> 05:04.090
Portanto, se você salvar isso, volte para o Unity, selecione seu FlockManager e deseja definir a pré-fabricada de peixe.

05:04.390 --> 05:09.100
O peixe pré-fabricado não é esse peixe verde que está em cena.

05:09.130 --> 05:09.450
Está bem.

05:09.460 --> 05:12.530
Então esse foi o usado para fazer a pré-fabricação inicial.

05:12.550 --> 05:20.200
Na verdade, basta excluí-lo, para que você não fique confuso com ele e, em seguida, agarre sua pré-fabricada

05:20.200 --> 05:26.440
de peixe (que está em seus ativos) e arraste e solte-a no FlockManager.

05:26.680 --> 05:31.270
Vamos criar 20 peixes e ele preencherá essa matriz aqui.

05:31.270 --> 05:35.910
Então pressione Play e seus 20 peixes (e se eu

05:36.200 --> 05:41.850
diminuir o zoom, você os verá) dentro dos limites de natação que criamos.

05:41.850 --> 05:51.700
Agora, se você quiser mais peixes do que isso, digamos que você queira 50 peixes ... 50 aqui e pressione Play e você receberá 50 peixes.

05:51.700 --> 05:57.690
Você pode vê-los, todos eles apareceram na Hierarquia e no Inspetor, sob a matriz allFish, para

05:57.730 --> 05:58.210
que

05:58.240 --> 06:03.670
cada peixe possa encontrar todos os outros peixes que estão em seu rebanho.

06:06.220 --> 06:13.130
Ok, é hora de colocar o peixe em movimento. Para começar, vamos definir alguns valores de velocidade para

06:13.130 --> 06:19.070
o peixe e faremos isso no FlockManager. Portanto, tornaremos o FlockManager um local onde podemos definir

06:19.070 --> 06:23.930
todas as variáveis diferentes para os peixes específicos que pertencem a esse rebanho e, em seguida,

06:23.930 --> 06:28.010
você pode ter vários rebanhos para diferentes tipos de peixes em sua cena.

06:28.010 --> 06:33.860
Então, estive com o script FlockManager novamente. O que você vai fazer é adicionar alguns valores públicos

06:34.220 --> 06:35.790
como eu tenho aqui.

06:35.840 --> 06:42.590
Primeiro, no Inspetor, acabei de adicionar uma pequena linha de 'Cabeçalho', que a separa e facilita a localização

06:42.590 --> 06:44.950
quando você está tentando defini-las.

06:44.960 --> 06:51.280
Então eu tenho um 'Range' aqui, entre 0. 0f e 5. 0f que fornecerá

06:51.380 --> 07:01.580
um controle deslizante no Inspetor e, em seguida, minSpeed público e maxSpeed público, com os mesmos valores para o intervalo.

07:01.960 --> 07:08.790
Depois de adicionar essas 5 linhas, salve isso e volte para o Unity, clique no Flock Manager e

07:08.840 --> 07:16.100
você encontrará no Inspector que agora temos essas configurações. Temos 'Fish Settings', Min e Max Speed (que você pode

07:16.190 --> 07:22.100
alterar com os controles deslizantes que quiser e poderá fazer isso em tempo real também e

07:22.100 --> 07:29.150
passar esses valores de velocidade para o peixe) . Para os peixes, agora criaremos um

07:29.150 --> 07:33.380
novo arquivo C # e o chamaremos de 'Flock'.

07:33.440 --> 07:39.800
Este é o código que segue para a pré-fabricação de peixes, então arraste e solte no seu peixe verde e enquanto estivermos

07:40.020 --> 07:43.150
aqui, nós o arrastaremos e soltaremos no peixe rosa também.

07:43.220 --> 07:50.000
Basta selecionar o peixe verde em Ativos e verificar no Inspetor para garantir que o script esteja realmente

07:50.000 --> 07:51.230
anexado a ele.

07:51.230 --> 07:58.670
Agora abra-o e a primeira coisa que precisaremos é um link para o

07:59.120 --> 08:08.710
nosso gerente, por isso criaremos um 'FlockManager público myManager' e, em seguida, precisaremos de um flutuador para a velocidade.

08:08.740 --> 08:17.530
Agora, no Start, vamos definir a velocidade como igual a Random. Intervalo entre a configuração de velocidade mínima dos gerentes e a configuração de

08:17.620 --> 08:20.710
velocidade máxima dos gerentes. Na atualização, colocaremos

08:20.740 --> 08:28.130
uma instrução Translate para impulsionar o peixe para frente ao longo do eixo dianteiro ou do eixo Z.

08:28.150 --> 08:32.340
Portanto, observe que o valor de 'speed' está indo para o eixo Z.

08:32.340 --> 08:35.710
Se o seu peixe estiver em uma direção diferente ...

08:35.710 --> 08:46.680
então, se eu voltar para o meu peixe e pegar um peixe, o eixo azul aqui está voltado para a frente e é esse

08:46.680 --> 08:48.950
que ele o empurrará.

08:49.080 --> 08:54.060
Se o seu peixe tiver um eixo diferente, será necessário ajustar seu código para empurrá-lo ao

08:54.060 --> 08:55.180
longo desse eixo.

08:55.210 --> 09:03.430
Ok, vamos excluir o peixe e voltar ao código e salvá-lo. Em seu script FlockManager,

09:03.430 --> 09:12.900
se o abrirmos, depois de criar um peixe dentro desse loop for, você deseja definir é FlockManager

09:13.220 --> 09:17.690
(ou myManager) para este FlockManager em particular.

09:17.700 --> 09:26.060
Portanto, adicione esse código e agora os dois arquivos (o Flock e o FlockManager) serão vinculados.

09:26.290 --> 09:31.790
De volta ao Editor, pressione Play e você verá os resultados do código.

09:31.790 --> 09:34.350
Então você tem o seu peixe que está avançando agora.

09:34.370 --> 09:37.090
Eles têm velocidades aleatórias neles.

09:37.640 --> 09:40.910
Claro, eles vão sair de cena muito rapidamente.

09:40.910 --> 09:47.310
Você pode ver que eles estão se movendo em velocidades diferentes (se você puder se aproximar). Sim.

09:47.460 --> 09:50.500
Então, todos eles têm velocidades diferentes,

09:50.550 --> 09:59.350
mas todos estão se movendo ao longo do eixo Z. Ok, agora é hora de adicionar nossas 'regras de agrupamento'.

09:59.490 --> 10:01.970
Mencionei as regras de agrupamento no início desta

10:01.980 --> 10:04.210
seção, mas vamos examiná-las novamente, em detalhes.

10:04.290 --> 10:10.860
São eles: Mover para a posição média do grupo; Alinhe com o cabeçalho médio do grupo e

10:10.860 --> 10:13.200
evite aglomerar outros membros do grupo.

10:15.150 --> 10:20.010
Avançar para a posição média do grupo envolve assumir todas as posições individuais dos

10:20.100 --> 10:23.190
membros, juntando-as e dividindo pelo número do grupo.

10:23.190 --> 10:29.190
Podemos então descobrir onde está um indivíduo, em relação à localização média e fazer com que ele

10:29.190 --> 10:32.310
se volte para ele. Para alinhar com o

10:32.310 --> 10:37.220
cabeçalho médio do grupo, adicionamos todos os cabeçalhos dos indivíduos e dividimos pelo tamanho do grupo.

10:37.230 --> 10:44.230
Isso fornece um vetor médio para os indivíduos tentarem alinhar seus movimentos. Para evitar vizinhos, um indivíduo deve estar ciente

10:44.260 --> 10:46.780
de onde os vizinhos

10:46.820 --> 10:49.360
estão e depois se afastar deles.

10:50.440 --> 10:55.780
Em seguida, para calcular um novo título, um indivíduo adicionará o vetor para avançar em direção ao centro

10:55.780 --> 11:01.530
de um grupo, o vetor para alinhar com o título do grupo e o vetor para se afastar de um vizinho.

11:04.720 --> 11:10.810
Antes de começarmos a editar o código do Flock, adicionaremos mais alguns valores ao FlockManager (aqueles

11:10.810 --> 11:16.180
que você pode alterar em tempo de execução, para poder ver comportamentos diferentes no

11:16.690 --> 11:22.090
peixe) e essas configurações para os comportamentos serão disponível para todos os peixes desse rebanho

11:22.120 --> 11:23.170
em particular.

11:23.200 --> 11:32.350
Então, eu estou adicionando aqui outro Range para algo chamado neighbourDistance e outro Range para

11:32.350 --> 11:33.550
rotationSpeed.

11:33.550 --> 11:40.660
Assim que os peixes começarem a encontrar locais para os quais precisam se mover, eles terão que se virar em

11:40.660 --> 11:46.720
algum momento e usaremos um slerp para isso e isso precisa de uma velocidade de rotação, então

11:46.720 --> 11:48.250
eu adicionei que lá.

11:48.260 --> 11:57.580
Agora, a outra coisa com essa vizinhançaDistância é que você pode ter um bando de alguma coisa e tudo nesse bando

11:57.580 --> 12:00.740
pode ser considerado seu vizinho ou

12:01.560 --> 12:09.600
você pode apenas considerar os poucos mais próximos (a um metro de você) como seu vizinho real, então

12:09.660 --> 12:16.890
portanto, você pode modificar isso e obter comportamentos diferentes de todo o grupo quando eles

12:17.310 --> 12:24.320
consideram apenas os que estão imediatamente ao seu redor como vizinhos e não como todos.

12:24.360 --> 12:28.490
Agora, as mudanças no rebanho. Vá para o seu rebanho. código cs.

12:28.650 --> 12:36.710
Vamos criar um novo método chamado 'ApplyRules' e esse método está sendo chamado aqui em baixo, para

12:36.750 --> 12:42.270
que não haja outras alterações na parte superior, apenas dentro da Atualização

12:42.270 --> 12:45.510
e, em seguida, adicionamos o ApplyRules.

12:45.510 --> 12:52.830
Agora, este ApplyRules está fazendo essas três regras sobre as quais acabamos de falar, com os diferentes cálculos de vetores.

12:52.830 --> 13:02.200
Antes de tudo, é criar um suporte para se apossar de todos os peixes do rebanho atual.

13:02.220 --> 13:08.060
Então, esses são os peixes que queremos tentar e encontrar a posição média, a posição média etc. e eles são os peixes que serão

13:08.070 --> 13:13.620
considerados seus vizinhos (ou pelo menos são o conjunto inteiro e os vizinhos farão

13:13.620 --> 13:17.240
parte desse conjunto, como você verá em um minuto).

13:17.260 --> 13:23.850
Agora estamos calculando o centro médio dos grupos, então vamos armazenar isso no 'vcentre'. Então, estamos calculando

13:24.090 --> 13:28.350
o vetor médio de prevenção também.

13:28.350 --> 13:32.090
Portanto, não é apenas um vizinho que queremos evitar,

13:32.190 --> 13:33.840
é TODOS e

13:33.840 --> 13:35.870
isso também é uma média.

13:35.880 --> 13:40.080
Então você tem que calcular todos os vetores de evasão e depois calculá-los.

13:40.080 --> 13:42.030
Então, inicialmente, eles são definidos como 0.

13:42.330 --> 13:44.510
Então temos esse flutuador

13:44.520 --> 13:51.960
chamado 'gSpeed' e essa é uma velocidade global do grupo (uma velocidade média na qual o grupo

13:51.960 --> 13:56.490
está se movendo) e usaremos isso também em nossos cálculos.

13:56.520 --> 14:00.690
Então nós temos um float 'nDistance', que é a nossa distância vizinha.

14:00.750 --> 14:06.870
Então, teremos que perguntar a cada peixe a que distância eles estão e

14:06.870 --> 14:10.480
depois trabalhar se considerarmos que eles estão

14:10.570 --> 14:21.100
próximos o suficiente para estar em nosso grupo e, por isso, temos esse contador 'groupSize' aqui, que contará quantas peixes no rebanho estão

14:21.100 --> 14:29.890
no nosso grupo, então o grupo é como esta pequena seção do rebanho que está dentro desse valor de

14:30.060 --> 14:30.760
neighbourDistance.

14:31.750 --> 14:38.560
Agora, com esses valores inicializados em 0, essencialmente, vamos percorrer todos os

14:39.010 --> 14:40.850
peixes do rebanho.

14:40.930 --> 14:42.600
Então, usamos um loop foreach.

14:42.610 --> 14:47.390
Então, perguntaremos se o peixe atual (que será o objeto do jogo

14:47.410 --> 14:48.870
aqui: vá), contanto que

14:49.000 --> 14:56.080
não seja igual ao peixe que está executando esse código no momento, faremos o processo porque você não precisa

14:56.080 --> 15:00.280
encontrar a média de si mesmo, não precisa calcular a

15:00.280 --> 15:01.000
distância

15:01.000 --> 15:06.640
para si mesmo; portanto, isso garante que não calculemos os dados dos peixes para si.

15:06.640 --> 15:12.760
Depois, calculamos a distância do vizinho; lembre-se de que estamos contornando esse loop for, escolhendo

15:13.420 --> 15:21.640
cada peixe e calculando a distância com um Vector3. Distância entre o objeto de jogo em

15:21.640 --> 15:29.800
nossa posição de matrizes e nossa posição no mundo e, em seguida, perguntamos se essa distância

15:29.800 --> 15:36.820
é 'menor ou igual a' neighbourDistance, o que torna esse peixe de interesse (aquele

15:36.820 --> 15:45.990
que vamos (considere parte de nosso grupo unido), então adicionaremos a posição desse peixe em particular ao 'vcentre'.

15:46.060 --> 15:49.820
vcentre será a nossa posição média do nosso grupo, portanto,

15:50.110 --> 15:54.680
temos que dar voltas e adicionar todas as posições juntas e depois

15:55.030 --> 15:57.370
a dividimos pelo tamanho do grupo.

15:57.430 --> 16:02.050
Portanto, ao mesmo tempo em que o adicionamos, também aumentamos o tamanho do grupo em 1.

16:02.080 --> 16:06.990
Então, depois que esse loop passar, podemos calcular a média.

16:07.120 --> 16:14.680
Em seguida, temos uma instrução if para testar nosso neighbourDistance sendo menor que um valor muito menor, que eu

16:14.680 --> 16:17.870
codifiquei aqui como 1. 0 e

16:17.980 --> 16:25.270
poderíamos, de fato, colocar isso no FlockManager como outro valor de distância, mas este

16:25.630 --> 16:32.090
é o quão perto estamos de outro peixe antes de pensarmos em evitá-lo.

16:32.110 --> 16:40.840
Agora, se, neste caso, a distância for menor que 1. 0f, o vetor médio de evitação será

16:40.870 --> 16:48.250
adicionado e, portanto, terá seu próprio valor + o vetor do peixe.

16:48.250 --> 16:53.620
Portanto, o vetor que está longe de algo (e analisamos isso em uma simulação de multidão

16:53.920 --> 16:58.730
que queríamos nos afastar) era a nossa posição atual menos a posição da qual

16:58.960 --> 17:03.150
queremos nos afastar e isso aumenta quando passamos por aqui também.

17:03.160 --> 17:09.860
Agora, a velocidade global está agregando todas as velocidades de um determinado peixe do rebanho.

17:09.910 --> 17:16.450
Então, vamos em frente e agarramos o código do Flock que está anexado ao peixe

17:16.450 --> 17:23.620
que estamos vendo no momento e, então, agarramos sua velocidade e o adicionamos a esse valor de gSpeed.

17:23.650 --> 17:29.500
Agora, quando o código termina esse loop foreach, passamos por todos

17:29.500 --> 17:38.770
os peixes do rebanho e o examinamos. Se é considerado um vizinho próximo, então estamos descobrindo sua posição e

17:38.890 --> 17:42.570
também seu vetor de fuga e somando tudo isso.

17:42.620 --> 17:47.170
Ah, e claro, a velocidade. Agora, abaixo do loop

17:47.260 --> 17:55.360
foreach, temos uma declaração if. A instrução if está perguntando se o tamanho do grupo é> 0. Se o peixe estiver se movendo

17:55.750 --> 18:01.920
e não houver ninguém ao seu redor e o tamanho do grupo se tornar 0,

18:02.260 --> 18:06.250
não aplicará essas regras. Só vai continuar se movendo em linha reta.

18:06.280 --> 18:14.230
Portanto, se este peixe é influenciado por outro peixe (ou outro grupo de peixes), então encontramos a média para o

18:14.230 --> 18:14.700
centro.

18:14.710 --> 18:20.130
Portanto, esse é o vetor 'vcentre' que calculamos quando os

18:20.290 --> 18:28.540
adicionamos, agora dividimos pelo tamanho do grupo. A velocidade do peixe é definida para a velocidade global,

18:28.540 --> 18:30.700
dividida pelo tamanho do grupo.

18:30.850 --> 18:37.750
Com essas informações, podemos determinar a direção em que o peixe precisa viajar (ou a direção

18:37.750 --> 18:40.840
em que o peixe deseja viajar).

18:40.900 --> 18:51.200
Portanto, sua 'direção' é igual à 'matriz vcentre' + 'matriz vavoid' - nossa posição atual.

18:51.200 --> 18:56.730
Agora, se isso significa que a direção é 0, já estamos voltados

18:56.770 --> 18:58.700
para a direção certa.

18:58.810 --> 19:02.480
Se não for igual a zero, precisamos

19:02.500 --> 19:09.310
rotacionar e, portanto, fazemos uma transformação. rodamos e usamos nosso Slerp que usamos anteriormente para outros NPCs e

19:09.310 --> 19:14.040
fazemos uma pequena rotação de acordo com nossa velocidade de rotação e o que isso fará é

19:14.170 --> 19:19.860
girar lentamente o peixe na direção que ele precisa. Ele não vai encaixar na direção

19:19.870 --> 19:21.830
perfeita e é

19:22.000 --> 19:27.970
esse slerp (e deslizando um pouquinho por um pouquinho) e constantemente atualizando sua

19:27.970 --> 19:36.120
posição e verificando onde você está com relação a todos os outros peixes, que causa esse aglomerado

19:36.190 --> 19:43.150
ocorrer, como você está prestes a ver. O tempo neste vídeo está prestes a acabar, então rapidamente

19:43.150 --> 19:49.030
pressionaremos Reproduzir (verifique se no FlockManager você fornece uma Distância vizinha e uma Velocidade de rotação, caso

19:49.030 --> 19:51.500
contrário você não terá nenhuma rotação

19:51.640 --> 19:54.560
e depois você começará a ver o aglomerado ocorrendo.

19:54.580 --> 19:57.440
Investigaremos isso mais no próximo vídeo.
