WEBVTT

00:07.240 --> 00:14.800
Na palestra anterior, deixei-lhe com o desafio de criar uma desova para desovar pacientes.

00:14.920 --> 00:20.150
Muito bem, então o que vamos fazer agora é realmente escrever isso, e eu lhe mostrarei meu método.

00:20.170 --> 00:26.110
O seu pode ser um pouco diferente, mas contanto que os pacientes se instanciem e se coloquem em seu mapa,

00:26.110 --> 00:28.000
então estamos todos bem.

00:28.120 --> 00:33.840
Certo, então, antes de tudo, precisamos realmente que nosso paciente seja um pré-fabricado.

00:33.850 --> 00:40.750
Agora, se você se lembra, ele começou como um pré-fabricado, então fizemos algumas mudanças em nosso paciente básico.

00:40.760 --> 00:46.270
Então você quer ir e clicar em seu paciente e depois vamos arrastar isso para dentro e eu

00:46.270 --> 00:52.210
vou subir no inspetor e queremos anular todas essas coisas que fizemos com nosso paciente.

00:52.210 --> 00:58.570
Portanto, clique em Aplicar tudo para aplicar os de volta ao pré-fabricado.

00:59.020 --> 01:04.630
Certo, então agora vamos criar uma chave de fenda em nossa hierarquia.

01:04.630 --> 01:07.480
Deixe-me apenas rolar todas essas coisas para cima.

01:08.020 --> 01:13.400
Vamos clicar com o botão direito e criar um vazio de chave inglesa.

01:14.080 --> 01:14.310
Está bem?

01:14.440 --> 01:17.440
E essa será a posição de onde nossa chave de porcas estará.

01:17.440 --> 01:21.210
Agora, ela está apenas posicionada ali, então vamos arrastá-la para cá.

01:21.220 --> 01:27.370
Agora, se você quiser ver onde está, além destes eixos, você pode usar o truque que já fiz antes com a área

01:27.370 --> 01:34.480
de espera e a recepção, que é adicionar um renderizador de malha em cubo ou um colisor de caixa ou algo assim, para que você

01:34.480 --> 01:36.220
possa realmente vê-lo.

01:36.250 --> 01:41.710
Agora é preciso estar fora do hospital e perto do chão.

01:41.710 --> 01:43.030
Agora o chão está em zero.

01:43.030 --> 01:46.690
Então, no inspetor, vou dar uma olhada no meu Y para isso.

01:46.690 --> 01:49.540
Na verdade, eu vou definir, digamos sete.

01:49.540 --> 01:53.920
Não importa se é um pouco para cima porque eles vão desovar lá e depois simplesmente

01:53.920 --> 01:56.650
descer para o chão e depois avançar.

01:56.830 --> 01:57.310
Muito bem.

01:57.310 --> 01:59.380
Portanto, vamos deixar isso aí agora.

01:59.380 --> 02:01.960
Vamos criar o código para isso.

02:01.960 --> 02:06.100
Portanto, crie um roteiro afiado em C e chame-o de Spawn.

02:06.670 --> 02:10.210
E vamos em frente, abramos isso e editamos.

02:10.840 --> 02:14.950
Vai exigir, antes de mais nada, nosso objeto de jogo.

02:14.950 --> 02:16.030
Portanto, nossa casa pré-fabricada.

02:16.030 --> 02:21.820
Assim, será objeto de jogo público pré-fabricado do paciente.

02:24.860 --> 02:27.740
E então quantos pacientes queremos.

02:27.740 --> 02:31.370
Portanto, vamos colocar isso aqui em um número público.

02:32.630 --> 02:33.740
Pacientes.

02:35.130 --> 02:42.060
E depois, no início, vamos criar um loop for int i igual a zero.

02:42.090 --> 02:47.040
Eu sou menos que um número de pacientes.

02:48.160 --> 02:48.460
Muito bem.

02:48.520 --> 02:48.790
E mais.

02:48.790 --> 02:49.570
E mais.

02:50.080 --> 02:55.120
E então, dentro deste laço, instanciaremos nossos pacientes.

02:55.310 --> 03:02.470
Certo, então queremos instanciar e vamos usar nosso pré-fabricado paciente.

03:03.040 --> 03:11.830
E vejamos, queremos colocá-lo nesta posição de parada de transformação, que é a sua desova de posição

03:11.830 --> 03:21.430
e virar em identidade para basicamente uma rotação padrão e nós soletramos transformar corretamente.

03:21.430 --> 03:28.300
Agora o problema com isso que estou pensando agora é que se passarmos por tudo isso no início,

03:28.300 --> 03:32.770
vamos acabar com o quê, 100 pacientes de imediato?

03:32.800 --> 03:34.520
Agora, isso pode ser o que você quer.

03:34.540 --> 03:38.170
Prefiro ter esta desova em intervalos específicos.

03:38.170 --> 03:42.160
Então, em vez disso, vou descer aqui e colocar o vazio.

03:42.880 --> 03:45.370
Vamos desovar o paciente.

03:47.090 --> 03:51.890
E dentro daqui vou mover este código instanciado.

03:51.890 --> 03:55.800
Então, controle x, coloque isso aí embaixo.

03:55.820 --> 04:01.010
Agora isso realmente torna supérfluos nossos pacientes NUM e nosso laço.

04:01.010 --> 04:06.350
Mas agora você já viu como faria isso se quisesse criar um monte de pacientes todos de uma

04:06.350 --> 04:06.920
só vez.

04:07.010 --> 04:09.440
E vamos deixar isso aí, de fato.

04:09.440 --> 04:10.910
E vamos fazer isso de qualquer maneira.

04:11.300 --> 04:12.920
Assim o faremos.

04:14.540 --> 04:16.730
Colocar este instante de volta lá em cima.

04:17.870 --> 04:20.000
Portanto, esta é toda a sua paciência inicial.

04:20.000 --> 04:22.190
E então o que vamos fazer é invocar.

04:24.200 --> 04:25.640
Paciente desovado.

04:32.680 --> 04:41.020
Após, digamos, 5 segundos e depois dentro do paciente desovado, conseguiremos que ele se invoque a si mesmo.

04:45.180 --> 04:49.530
Assim, você continua recebendo pacientes sendo desovados.

04:50.220 --> 04:56.640
E agora aqui vamos ter alcance aleatório para o tempo entre os pacientes.

04:56.640 --> 05:03.840
Portanto, digamos que queremos pacientes a cada 2 a 10 segundos que o façam.

05:03.840 --> 05:07.590
Então agora você pode ver duas maneiras de realmente desovar, certo?

05:07.590 --> 05:16.650
Portanto, vamos salvar isto e vamos voltar à unidade e queremos pegar nosso roteiro de desova e arrastá-lo

05:16.650 --> 05:19.350
para nossa desova aqui.

05:19.440 --> 05:26.190
E depois vamos designar nosso pré-fabricado paciente, que está de volta em nossa pasta de pré-fabricados.

05:26.190 --> 05:31.980
Assim, se formos para nossa pasta de Prefabs, temos nosso paciente lá, podemos arrastá-lo e soltá-lo

05:31.980 --> 05:35.130
no pré-fabricado do paciente e o número de pacientes.

05:35.130 --> 05:41.130
Este é o número inicial que é criado e depois é gerado a cada 5 segundos ou o que quer que tenha sido

05:41.130 --> 05:41.950
definido.

05:42.000 --> 05:48.750
Então vamos criar uma quantidade inicial de cinco e depois eles vão cair do céu basicamente e começar

05:48.750 --> 05:50.550
a vir para o hospital.

05:50.550 --> 05:56.250
Agora, este pequeno rapaz aqui que já está no hospital, você pode apagá-lo ou simplesmente desligá-lo se quiser

05:56.250 --> 05:58.980
usá-lo para testar as coisas um pouco mais tarde.

05:59.220 --> 05:59.700
Está bem.

05:59.700 --> 06:04.290
Portanto, vamos apenas pressionar o jogo e dar uma olhada no que recebemos aqui.

06:04.290 --> 06:10.320
Portanto, há nossos cinco que são inicialmente desovados e todos eles estão vindo para o hospital e, em seguida,

06:10.320 --> 06:11.700
aqui vêm os extras.

06:11.700 --> 06:17.610
Por isso, se entrarmos em nossa visão de jogo aqui, deixe-me apenas definir isto para uma imagem de alta resolução para você.

06:17.790 --> 06:23.100
Agora eles virão e se registrarão e, uma vez registrados, eles se mudarão.

06:24.390 --> 06:28.710
Depois de se baralharem um ao outro e depois entrarem aqui.

06:29.070 --> 06:29.520
Certo.

06:29.520 --> 06:34.290
Portanto, alguns pequenos pedaços de informação de depuração neste ponto.

06:34.290 --> 06:43.250
Se você descobrir que eles não estão chegando ao seu destino, saltando etapas ou o que quer que seja, como, você sabe, isso vai acontecer

06:43.410 --> 06:46.710
enquanto você está tentando testar isto.

06:46.860 --> 06:55.620
O mais comum neste cenário particular, ou o uso da malha de navegação, é que os agentes não podem chegar

06:55.620 --> 06:57.700
ao seu destino.

06:57.720 --> 07:02.380
Por exemplo, aqui em baixo, estamos recebendo uma grande pilha nesta sala de espera.

07:02.400 --> 07:10.190
Agora, lembre-se que a sala de espera tem uma localização específica, o que é um pequeno ponto.

07:10.200 --> 07:16.020
Se eu selecionar isso e viermos até aqui, é bem ali.

07:16.020 --> 07:23.550
Isso significa que os agentes têm que chegar a esse ponto específico para serem considerados na sala de espera.

07:23.550 --> 07:27.870
E se tivermos um olhar no código para isto, vamos apenas fazer uma pausa.

07:28.020 --> 07:38.910
Vamos voltar ao código de alcance dos agentes e dar uma olhada em nosso código de agente G para considerar que eles realmente

07:38.910 --> 07:41.040
chegaram a um destino.

07:41.040 --> 07:46.230
Se tivermos uma olhada na atualização tardia, temos aqui esta linha para a distância restante.

07:46.230 --> 07:51.900
Portanto, vai considerar que você chegou a um ponto de destino na malha de navegação.

07:51.900 --> 07:55.190
Se você estiver a uma distância.

07:55.200 --> 08:00.570
Agora, se você estiver usando agentes de tamanho unitário como eu, eu acho que um é bastante aceitável.

08:00.630 --> 08:06.270
Talvez você queira tornar isto um pouco maior se descobrir que seus agentes simplesmente não estão chegando

08:06.270 --> 08:07.440
a esse local.

08:07.830 --> 08:14.520
Agora, a outra coisa que pode acontecer é se você definir isto como 20, então o agente se considerará como tendo chegado a um ponto de

08:14.520 --> 08:20.370
passagem quando ele estiver a umas 20 unidades de distância, o que fará as ações parecerem um pouco estranhas.

08:20.370 --> 08:26.040
Portanto, pode fazer parecer que um agente chegou à sala de espera quando ainda está de pé aqui,

08:26.040 --> 08:27.840
o que é algo que você não quer.

08:28.380 --> 08:29.810
Portanto, isso é uma coisa.

08:29.820 --> 08:38.790
Agora, qualquer agente que não atinja um ponto de passagem ainda estará tentando executar uma das ações.

08:39.120 --> 08:39.510
Certo.

08:39.510 --> 08:43.170
E você pode dizer se você selecionou um agente.

08:43.170 --> 08:46.170
Então, vamos encontrar alguém que ainda esteja realmente fazendo coisas.

08:46.170 --> 08:53.610
Este cara aqui e ali no inspetor, vamos encontrar seu paciente pai.

08:54.090 --> 08:57.240
Vá para a sala de espera, vá para o hospital e registre-se.

08:57.240 --> 09:04.380
Se você der uma olhada em todas essas coisas, você verá que há uma caixa de seleção pública

09:04.380 --> 09:11.460
no fundo chamada corrida que lhe dirá qual ação ele ainda está tentando executar.

09:11.550 --> 09:16.170
Então, este agente em particular aqui, ele está na recepção.

09:16.170 --> 09:18.060
Portanto, ele obviamente ainda está se registrando.

09:18.060 --> 09:23.430
E se dermos uma olhada em seu registro, é sinal de que ele ainda está, de fato, funcionando.

09:23.430 --> 09:30.330
Agora, se pressionarmos e pressionarmos pausarmos e esperarmos um momento até que ele termine, você pode

09:30.330 --> 09:35.250
ver agora que isso foi assinalado e ele agora vai para a sala de espera.

09:36.390 --> 09:37.140
Certo.

09:37.140 --> 09:43.680
Por isso, enquanto isso acontece, vamos fazer uma nova pausa para dar uma olhada na depuração.

09:43.680 --> 09:51.030
Isto se entrarmos no console, você verá que está imprimindo os planos.

09:51.240 --> 09:57.810
E assim você pode ver aqui diz que o plano é ir ao hospital, registrar-se, ir à sala de espera.

09:57.810 --> 10:04.950
Portanto, este plano está de fato acontecendo em ordem e eu tombei o que está acontecendo no console porque ele estará apenas

10:04.950 --> 10:08.010
escrevendo isto para cada agente em particular.

10:08.010 --> 10:13.110
Mas isto está lhe mostrando que é isto o que o plano é que eles inventaram, que é o plano que

10:13.110 --> 10:15.300
você queria que eles inventassem.

10:15.300 --> 10:18.600
Então isso é pelo menos tudo bom, certo?

10:18.600 --> 10:24.570
Isto é, colocar um grupo inteiro de agentes em funcionamento e desová-los.

10:24.570 --> 10:30.600
Quando voltarmos na próxima palestra, terei que falar um pouco mais sobre como depurar esses

10:30.600 --> 10:37.950
cenários, pois isso é realmente uma grande parte disso, e começaremos a trabalhar para que nossa enfermeira

10:37.950 --> 10:39.300
se candidate.
