WEBVTT

00:11.250 --> 00:16.370
Nesta seção, começaremos a analisar a simulação de um grupo de agentes nos quais eles

00:16.370 --> 00:22.550
são tratados menos como indivíduos e mais em massa. O comportamento da multidão difere do comportamento individual,

00:22.550 --> 00:29.180
pois as propriedades dentro da multidão (como emoção, colisão, direção e velocidade) se propagam de uma pessoa para

00:29.420 --> 00:35.870
a outra, dando ao grupo inteiro sua própria identidade. Simular cada indivíduo de um grupo e produzir uma

00:35.870 --> 00:38.260
multidão exigiria muito trabalho e, de

00:38.390 --> 00:43.160
fato, muitas das coisas que você pode considerar importantes tomadores de decisão para o

00:43.250 --> 00:47.410
movimento individual de uma multidão podem ser resumidas em simples matemática vetorial.

00:47.450 --> 00:52.610
Existem vários métodos que os pesquisadores investigaram para simular multidões, incluindo fazer com que as pessoas

00:52.610 --> 00:57.270
se movam como partículas em um fluido para usar dados do mundo real.

00:57.310 --> 01:03.320
Uma multidão não se move como um conjunto caótico de indivíduos, mas de uma maneira quase organizada.

01:03.410 --> 01:09.480
Diz-se que é um sistema auto-organizado em que as linhas de fluxo aparecem na direção do movimento.

01:09.500 --> 01:14.990
No entanto, verificou-se que se uma multidão se tornar mais densa que seis pessoas por metro quadrado,

01:14.990 --> 01:16.430
ocorrerão bolsões de turbulência.

01:16.610 --> 01:22.280
Uma das maneiras mais populares e mais simples de simular uma multidão é com o algoritmo de

01:22.280 --> 01:26.790
rebanho de Reynolds, usado em filmes para simular rebanhos e exércitos de animais.

01:26.840 --> 01:33.140
É baseado em 3 regras simples. Vire para o cabeçalho médio do grupo, vire para o

01:33.140 --> 01:36.830
centro médio do grupo e evite os que estão ao seu redor.

01:36.850 --> 01:42.700
Usaremos essas regras em combinação com navmeshes e reformulação para criar multidões e bandos

01:42.710 --> 01:44.040
nesta seção.

01:44.330 --> 01:49.910
Se você quiser explorar algumas dinâmicas simples de multidões, faça isso usando uma navmesh.

01:50.300 --> 01:53.750
Abra o Unity e crie um plano de terra.

01:53.830 --> 01:55.810
Crie também 2 paredes.

01:55.820 --> 02:05.110
Acabei de criar o plano de aterramento a partir de um plano 3D normal e criei duas paredes de alguns cubos e as

02:05.540 --> 02:10.430
paredes estão posicionadas de modo que haja um corredor no meio.

02:10.430 --> 02:18.620
A cápsula azul que eu adicionei aqui terá que subir aqui, pelo corredor e até

02:18.710 --> 02:20.300
este cubo.

02:20.720 --> 02:28.280
Esta cápsula aqui terá que subir e descer até lá. Então crie 2 cápsulas para que elas

02:28.280 --> 02:33.020
cheguem à Hierarquia. 'Objeto 3D> Cápsula' e eu

02:33.020 --> 02:38.170
os colori de maneira diferente e depois nomeei um RedAgent e um BlueAgent.

02:38.420 --> 02:47.270
Eu também adicionei alguns objetivos. Adicionei um cubo chamado BlueGoal e esse cubo está no extremo oposto

02:47.330 --> 02:54.740
do caminho que vamos criar para o BlueAgent ... e o RedGoal está no extremo oposto

02:54.950 --> 02:56.360
do RedAgent.

02:56.360 --> 03:01.400
Agora o RedAgent precisa de uma navmesh adicionada a ele.

03:01.400 --> 03:03.350
Essas são apenas todas as configurações padrão.

03:03.350 --> 03:08.350
O BlueAgent também possui uma navmesh adicionada

03:08.510 --> 03:16.130
e, em ambos, tenho um script chamado 'AIController' e, nesse script, você

03:16.190 --> 03:17.810
encontrará isso.

03:17.810 --> 03:23.630
Primeiro de tudo, eu tenho uma variável exposta (variável pública) chamada 'objetivo' e é isso

03:23.630 --> 03:29.480
que daremos aos agentes, os 2 cubos de objetivo, para que eles saibam para onde estão indo.

03:29.480 --> 03:36.190
Depois disso, pegamos o NavMeshAgent que é anexado ao nosso personagem.

03:36.320 --> 03:43.220
Não se esqueça de incluir 'usando o UnityEngine. AI; ' biblioteca no topo. No Start, pegamos o agente

03:43.220 --> 03:49.760
conectado à cápsula e também podemos, nesse momento, definir a meta de destino

03:49.760 --> 03:56.500
que será a meta. transformar. posição 'e é tudo o que precisamos fazer.

03:56.540 --> 04:06.950
Podemos até nos livrar da atualização porque não precisamos dela. Salve isso e anexe esse código

04:06.980 --> 04:11.070
ao RedAgent e BlueAgent.

04:11.250 --> 04:20.490
Em seguida, você deseja selecionar o plano e os dois cubos que são as paredes e garantir que eles estejam definidos

04:20.490 --> 04:26.030
como Navegação estática. Você pode fazer isso na guia Navegação> Objeto, marcando

04:26.130 --> 04:32.860
esta caixa de seleção aqui ou também pode configurá-los no Inspetor como nós temos antes.

04:32.940 --> 04:38.640
Uma vez que tudo esteja configurado, você deseja ir ao Bake e clicar no botão [Bake] e isso lhe dará

04:38.970 --> 04:40.030
uma área azul

04:40.040 --> 04:41.370
como você está vendo aqui.

04:41.430 --> 04:45.240
Portanto, as únicas partes que não podem ser passadas são as paredes.

04:45.240 --> 04:49.860
Isso forçará os agentes a passarem de um extremo ao outro.

04:50.280 --> 05:00.350
Agora, para garantir que isso aconteça, selecione BlueAgent e, em seguida, no Inspetor, no código do AIController, você

05:00.720 --> 05:04.650
deseja usar o cubo que está aqui.

05:04.770 --> 05:10.020
Desculpe, ao lado de RedAgent como objetivo da BlueAgent.

05:10.230 --> 05:17.910
Então pegue o cubo (que eu chamei de BlueGoal) e arraste-o e solte-o no slot de

05:17.910 --> 05:22.820
objetivo da cápsula azul. Para a cápsula vermelha, é

05:22.830 --> 05:24.200
o contrário.

05:24.240 --> 05:30.410
O objetivo será o cubo na outra extremidade.

05:30.420 --> 05:41.100
Agora, quando você joga isso, os agentes percorrem o caminho e trocam entre si.

05:41.110 --> 05:43.860
Agora isso foi acelerado pela mágica da edição

05:43.870 --> 05:49.750
de vídeo, mas se você deseja que seus agentes se movam mais rapidamente, não se esqueça de que pode selecioná-los

05:49.750 --> 05:53.390
na Hierarquia, vá até o Inspetor e altere o valor da velocidade.

05:53.540 --> 05:57.450
Atualmente, o meu está definido como 10, o que é bastante rápido por si só.

05:57.580 --> 06:01.440
Quando começamos a adicionar mais agentes, convém que ele corra um pouco mais devagar.

06:01.630 --> 06:10.930
Então, primeiro de tudo, vamos dar uma olhada no fenômeno de 'auto-organização por fluxo', que é onde dois

06:10.930 --> 06:18.940
grupos se unindo, movendo-se em direções opostas, formarão linhas de fluxo através da multidão.

06:18.940 --> 06:27.460
Tudo o que precisamos fazer é selecionar nossos agentes e, em seguida, pressionar Ctrl-D e criar um monte de cópias.

06:27.460 --> 06:36.690
Vamos criar 20 cópias. Agora, com os que estão no lugar, pressione Play e podemos assisti-los.

06:36.750 --> 06:41.310
Eles estão todos no mesmo local, então vão explodir da mesma posição em que estão. Agora, quando eles se juntarem, eles

06:41.340 --> 06:42.770
formarão linhas de

06:44.290 --> 06:46.450
fluxo e isso é apenas

06:46.450 --> 06:52.290
um pequeno grupo, então você terá duas linhas de fluxo claras onde elas se sobrepõem.

06:52.570 --> 07:00.640
A partir daqui, você pode selecionar todas essas duplicatas e duplicá-las duas vezes novamente para obter um pouco

07:01.000 --> 07:04.700
mais e pressionar Reproduzir. Novamente, eles explodem

07:04.730 --> 07:11.870
do lugar único e agora vão se aglomerar nesta área aqui e descobriremos que

07:11.870 --> 07:14.700
eles formarão linhas de fluxo.

07:15.550 --> 07:22.180
Você vê um pouco de turbulência, como você viu lá, onde ficou bastante denso e alguns

07:22.180 --> 07:25.670
caras aqui também ficaram presos nessa multidão também.

07:25.720 --> 07:30.710
Você pode modificar a simulação o quanto quiser, adicionando mais paredes e mais agentes.

07:30.730 --> 07:36.610
Aqui pode ver que tenho 4 agentes de cores diferentes e, mesmo quando eles se amontoam, você pode ver claramente

07:36.610 --> 07:38.490
as linhas de fluxo se formando.

07:38.510 --> 07:44.800
Em um. EU. , quando esse tipo de comportamento ocorre em um sistema

07:44.800 --> 07:48.300
que não está especificamente programado para isso, é chamado de comportamento emergente e são esses resultados inteligentes

07:48.320 --> 07:54.850
e reais que estamos tentando obter em nossos NPCs com o mínimo esforço de programação possível. Na próxima palestra, trabalharemos em

07:54.850 --> 07:58.740
uma simulação de multidão com personagens humanos animados.
