WEBVTT

00:02.330 --> 00:02.860
Certo.

00:02.870 --> 00:05.720
Como você está lidando com a Páscoa até agora?

00:05.750 --> 00:07.400
Bem, nós ainda nem entramos no código.

00:07.400 --> 00:10.370
E há um monte de códigos que temos que escrever.

00:10.370 --> 00:15.290
Mas esperamos que pareça bastante familiar, pois já passamos por todas as coisas básicas

00:15.290 --> 00:16.220
e como funciona.

00:16.460 --> 00:20.500
Portanto, vamos começar agora dentro desta classe.

00:20.510 --> 00:26.060
Antes de mais nada, precisamos agarrar nosso labirinto real para que possamos obter seu mapa.

00:26.060 --> 00:29.300
Portanto, labirinto público, labirinto.

00:29.960 --> 00:38.570
Agora, isto vai ser um pouco uma combinação entre executar realmente o algoritmo e depois mostrá-lo

00:38.570 --> 00:42.170
também, visualizando-o na tela.

00:42.170 --> 00:46.970
Por isso, vamos ter algumas construções que são apenas para todo o número de trituradores

00:46.970 --> 00:50.600
e tudo e depois outras que vão mostrar as coisas para você.

00:50.630 --> 00:50.880
Certo.

00:50.930 --> 00:57.050
Portanto, antes de tudo, vou apenas adicionar dois materiais que usaremos para mudar nossos nós de uma cor para a outra

00:57.050 --> 00:58.790
à medida que forem processados.

00:58.790 --> 01:02.390
Portanto, material, material fechado.

01:03.830 --> 01:10.370
E você provavelmente pode adivinhar qual é o próximo, material público, material aberto.

01:11.630 --> 01:18.170
Então, precisamos criar nossas duas listas abertas e fechadas.

01:18.800 --> 01:24.470
Portanto, vamos ter uma lista de marcadores de caminho.

01:27.280 --> 01:33.910
Quatro Abertos é igual ao novo marcador de caminho de lista.

01:37.000 --> 01:39.700
E depois precisamos também de um para as roupas.

01:39.700 --> 01:41.830
Portanto, vamos copiar isso.

01:43.600 --> 01:46.450
E faça isto fechado.

01:47.290 --> 01:53.560
E então precisamos trazer nossos objetos de jogo que serão nossos verdadeiros marcadores físicos no mapa

01:53.560 --> 01:54.550
que podemos ver.

01:54.550 --> 01:58.600
Portanto, objeto de jogo público.

02:00.100 --> 02:01.030
Comece.

02:02.450 --> 02:07.010
Objeto de jogo público e.

02:07.520 --> 02:09.260
E público.

02:09.410 --> 02:09.830
Jogo.

02:09.830 --> 02:10.760
Objeto.

02:10.760 --> 02:11.750
O caminho.

02:13.500 --> 02:16.690
Marcador de ponto ou caminho ou seja lá o que for.

02:16.710 --> 02:17.180
Certo.

02:17.190 --> 02:18.090
Vou chamá-lo assim.

02:18.090 --> 02:22.140
Portanto, vamos apenas salvar isto e voltaremos à unidade.

02:22.650 --> 02:29.670
E queremos ir ao objeto Maze Game na hierarquia e arrastar e largar para lá encontrar um roteiro

02:29.670 --> 02:30.690
estelar.

02:30.840 --> 02:35.190
Agora vamos povoar estes itens no roteiro.

02:35.190 --> 02:41.100
Portanto, o labirinto é o roteiro que está gerando o labirinto, que é este roteiro recursivo.

02:41.100 --> 02:44.190
Portanto, basta arrastar isso até lá.

02:44.730 --> 02:53.280
Temos então um início e um fim e nossos marcadores de p caminho, assim como um material fechado e aberto.

02:53.280 --> 02:59.610
Agora anexado a esta palestra há um pequeno pacote de unidade com alguns materiais e pré-fabricados nele.

02:59.610 --> 03:06.510
Se você trouxer isso, você encontrará aqui uma pasta de modelos que tem materiais e pré-fabricados.

03:06.900 --> 03:16.110
Assim, se formos primeiro aos nossos pré-fabricados e depois selecionarmos nosso labirinto, podemos colocar o objeto

03:16.200 --> 03:22.740
inicial no início, o final no final, e depois o marcador de caminho no caminho.

03:22.740 --> 03:32.250
P Agora também podemos definir nossos materiais para os nós fechados e abertos à medida que passamos.

03:32.250 --> 03:39.180
Portanto, para fechado, vou usar vermelho e para aberto, vou usar verde.

03:39.180 --> 03:45.960
Portanto, isto só tornará tudo mais visual para que você possa ver exatamente o que está acontecendo quando o algoritmo das

03:46.200 --> 03:48.120
estrelas começar a funcionar.

03:48.540 --> 03:52.590
Muito bem, então agora vamos voltar ao nosso código.

03:53.250 --> 03:59.760
Agora, estas três coisas são nossos objetos de jogo que vamos instanciar e depois segurá-los dentro

03:59.760 --> 04:02.460
de objetos marcadores de caminho.

04:02.820 --> 04:12.630
Assim, vamos criar um marcador de caminho para o nó dourado e também criaremos um para o início.

04:12.630 --> 04:17.280
Então, marcador de caminho, comece.

04:17.880 --> 04:18.810
Nó.

04:19.740 --> 04:22.350
Também precisaremos de outro marcador de caminho.

04:22.590 --> 04:29.670
E este caminho, marca, vai acompanhar o último ponto em que nos encontramos, portanto, a última posição

04:29.670 --> 04:30.690
neste caso.

04:30.990 --> 04:38.670
E então também vamos acompanhar um touro chamado Done, que será verdade quando tivermos encontrado o caminho

04:38.670 --> 04:41.100
para o final do caminho.

04:41.100 --> 04:45.000
Portanto, vamos inicialmente definir isto como falso assim.

04:45.000 --> 04:45.240
Está bem?

04:45.240 --> 04:50.940
Por isso, todas essas são as coisas de que precisamos no topo, todas as nossas variáveis.

04:51.120 --> 04:51.540
Muito bem.

04:51.540 --> 04:56.610
Portanto, vou salvar isso novamente, mudar de volta para a Unidade e mostrar algo antes de continuarmos.

04:56.610 --> 05:04.140
Portanto, se entrarmos em nossos pré-fabricados onde eu tenho esses marcadores e clicarmos em um, se você for

05:04.140 --> 05:08.490
ao inspetor, verá que eles estão marcados como marcadores.

05:08.670 --> 05:16.470
Fiz isso para que possamos removê-los com uma tecla pressionada fora do mapa, o que será útil em um

05:16.470 --> 05:17.280
momento.

05:17.640 --> 05:25.770
Portanto, o que vamos fazer é ter a capacidade de remover todos eles e depois fazer o ASR repetidamente sem reiniciar nosso código,

05:25.770 --> 05:30.540
o que significa que você pode ter um pouco de brincadeira com ele e se acostumar

05:30.540 --> 05:32.370
com os resultados.

05:32.520 --> 05:41.430
Então vamos criar um vazio, remover todos os marcadores, e isto será apenas um loop realmente rápido que

05:41.430 --> 05:42.780
destrói tudo.

05:42.780 --> 05:44.700
Portanto, objeto de jogo.

05:46.750 --> 05:49.030
Um raio de Marcus.

05:50.980 --> 05:53.280
Igual a objetos de jogo.

05:53.420 --> 05:57.040
Encontre objetos de jogo com.

06:00.230 --> 06:00.770
Tag.

06:00.770 --> 06:05.530
Certifique-se de usar objetos de jogo com o SE e isso será um marcador.

06:07.450 --> 06:07.870
Certo.

06:07.870 --> 06:20.980
E então faremos um rápido, então faremos um rápido para cada objeto de jogo m marcador em marcadores.

06:24.240 --> 06:26.100
Destroy em.

06:27.870 --> 06:30.750
Portanto, isso será chamado em breve.

06:31.110 --> 06:33.720
Muito bem, vamos agora começar nossa busca.

06:33.720 --> 06:34.890
Tão nulo.

06:35.610 --> 06:37.560
Começar, procurar.

06:37.770 --> 06:42.990
Permitiremos que isto seja chamado repetidamente, como eu disse antes.

06:42.990 --> 06:46.860
Portanto, cada vez que o fizermos, vamos fazer o mesmo com falsidade.

06:48.540 --> 06:50.010
E então nós vamos correr.

06:50.010 --> 06:53.910
Remover todos os marcadores.

06:56.770 --> 06:57.460
Certo.

06:57.460 --> 07:02.170
Assim, agora podemos realmente criar nossos objetivos e tudo mais.

07:02.950 --> 07:12.550
Portanto, antes de tudo, temos que escolher duas posições no labirinto real que serão nosso início e nosso

07:12.550 --> 07:13.030
fim.

07:13.030 --> 07:19.840
E poderíamos fazê-lo de forma bastante aleatória, onde simplesmente continuamos a escolher valores aleatórios e

07:19.840 --> 07:23.440
ver se eles são um espaço ou uma parede e, claro, usar o espaço.

07:23.560 --> 07:30.760
Uma maneira melhor é realmente colocar todos os espaços ou todos os locais do labirinto que não são uma parede em uma pequena

07:30.760 --> 07:31.690
lista.

07:31.720 --> 07:38.050
Embaralhe essa lista usando o método de embaralhamento que você encontrará no arquivo de extensões e, em seguida, assim como

07:38.050 --> 07:39.280
retirá-las do topo.

07:39.640 --> 07:50.950
Portanto, vou criar uma lista de locais de mapas, e isso será chamado de Localizações Igual a Nova

07:51.700 --> 07:52.720
Lista.

07:53.810 --> 07:56.120
Localização do mapa.

07:58.390 --> 07:58.640
Certo.

07:58.720 --> 08:04.030
Vamos então criar nossos laços aninhados para dar a volta ao nosso mapa.

08:04.030 --> 08:12.940
Portanto, se quisermos para int z igual a um a Z é menos do que a profundidade do nosso labirinto.

08:14.590 --> 08:18.070
Menos um e depois Z mais.

08:18.070 --> 08:18.750
E mais.

08:18.820 --> 08:20.560
A mesma coisa para.

08:21.830 --> 08:22.800
X.

08:23.510 --> 08:27.080
Portanto, vamos mudar isso para X e X.

08:27.080 --> 08:32.420
E, neste caso, queremos nossa largura e fazemos esse x.

08:32.420 --> 08:41.750
E dentro daqui vamos testar se podemos parar o mapa para esse x.

08:41.990 --> 08:47.750
Z não é igual a um, então nós o colocaremos em nossa lista.

08:48.170 --> 08:55.550
Os pontos de localização adicionam nova localização do mapa.

08:56.770 --> 08:57.580
X.

08:57.610 --> 08:58.420
Z.

08:59.050 --> 09:03.640
Então por que não estamos usando igual a um neste código?

09:03.670 --> 09:09.520
Bem, no código dos ratos, se você tiver um olhar e o algoritmo recursivo que o está escrevendo

09:09.730 --> 09:15.340
nos labirintos que estamos gerando, há um valor de zero onde há um espaço vazio e um onde

09:15.340 --> 09:16.570
há uma parede.

09:16.600 --> 09:22.660
Entretanto, quando você está criando labirintos, você pode ter outros valores que representam outras coisas dentro

09:22.660 --> 09:24.140
daquela área de labirinto.

09:24.160 --> 09:30.730
Portanto, só estamos realmente preocupados se houver um muro no momento, até onde podemos nos mover.

09:30.730 --> 09:35.600
E é por isso que não estamos usando igual a um aqui.

09:35.620 --> 09:44.230
Portanto, sabemos que são as paredes e as posições de partida podem ser qualquer outro valor neste ponto.

09:44.230 --> 09:46.530
Então é por isso que não tenho igual a um.

09:46.540 --> 09:50.890
Então, mas o tempo que passamos por isso, agora temos todos esses locais.

09:50.890 --> 09:56.080
E assim, se simplesmente baralhá-los, as localizações se baralham.

09:57.690 --> 10:04.920
Isso nos dará um par de valores sentados no topo dessa lista, que podemos ir em frente e arrancar

10:04.920 --> 10:09.630
e usar como o local da meta e também como o local de partida.

10:10.680 --> 10:12.570
Portanto, vamos em frente e façamos isso.

10:12.570 --> 10:18.930
Portanto, depois do embaralhamento, vou criar um vetor três, que será nosso local de partida.

10:20.660 --> 10:27.320
E vamos definir isso para um novo vetor três e para obter os valores, vamos arrancá-los,

10:27.320 --> 10:36.830
como eu disse, a localização e vamos dar-lhe localizações na posição zero ponto X e depois podemos simplesmente

10:36.830 --> 10:44.990
colocá-lo zero para o valor Y e localizações, zero para a posição Z.

10:45.320 --> 10:49.910
Agora estamos colocando zero como a altura porque eu fiz isso com praticamente

10:49.910 --> 10:53.600
tudo o que estamos zerando como uma superfície plana.

10:53.900 --> 10:57.260
Portanto, é basicamente uma espécie de dois D, no mínimo.

10:57.410 --> 11:04.550
E então, uma vez que tenhamos este local, vamos instanciar nosso primeiro nó naquele local.

11:04.550 --> 11:07.190
Portanto, vou criar um nó inicial.

11:09.690 --> 11:14.310
E isso vai se igualar a um novo marcador de caminho.

11:15.490 --> 11:18.370
O que será um novo mapa.

11:19.490 --> 11:28.310
Localização, localizações zero ponto X, localizações zero ponto Z.

11:28.310 --> 11:31.100
Portanto, o mesmo uso que você está usando para a posição.

11:31.160 --> 11:41.480
E depois vamos enviar um zero, depois vamos zerar nossos valores G, nosso H e nosso F.

11:41.750 --> 11:48.320
E para o marcador de jogo, acabei de descer uma linha para não sair da tela por você.

11:48.560 --> 11:53.900
Vamos instanciar o início.

11:54.620 --> 11:55.640
Comece.

11:57.130 --> 11:58.570
Localização.

11:59.830 --> 12:08.350
E então colocaremos Kitten em ponto de identidade para a rotação, porque isso não é realmente importante.

12:08.440 --> 12:11.260
E finalmente, o pai vai ser nulo.

12:11.260 --> 12:12.730
Portanto, vamos colocar isso aí.

12:12.730 --> 12:16.000
E para a localização do objetivo, fazemos a mesma coisa.

12:16.240 --> 12:22.180
Portanto, vou apenas copiar tudo isso, salvo digitar novamente, colocar aqui,

12:22.180 --> 12:28.210
ter certeza de que estamos falando do local da meta, da posição do local da meta.

12:28.210 --> 12:33.850
Vamos usar isso como o segundo valor nessa matriz de locais que embaralhamos.

12:33.850 --> 12:36.250
Por isso, vamos definir todos esses valores em um só.

12:36.400 --> 12:41.470
E então este nó aqui embaixo será nosso nó de objetivo.

12:41.740 --> 12:50.020
Agora, ao mesmo tempo em que realmente criamos o marcador de caminho, vamos instanciar esses pré-fabricados.

12:50.320 --> 12:56.170
Portanto, este aqui será na verdade o pré-fabricado final que enviamos antes.

12:56.470 --> 12:57.040
Está bem?

12:57.040 --> 13:03.760
Assim, agora podemos realmente correr, começar, procurar e poderemos ver esses marcadores aparecerem.

13:03.760 --> 13:06.310
Portanto, vou fazer isso na atualização.

13:06.310 --> 13:19.030
Portanto, só aqui, vamos colocar se o ponto de entrada para baixar a chave é o ponto de código p.

13:20.190 --> 13:23.390
Depois faremos uma busca de barganha.

13:23.850 --> 13:32.070
Agora, um pequeno ajuste que precisamos fazer neste código é adicionar um valor de escala porque o próprio

13:32.070 --> 13:40.770
labirinto usa uma escala para torná-lo maior na tela para que você realmente o traga para fora e as posições reais

13:40.770 --> 13:42.150
no mapa lá.

13:42.150 --> 13:43.620
Não precisam ser aumentadas.

13:43.620 --> 13:45.870
Eles ainda estão em posições de unidade leve.

13:45.870 --> 13:52.530
Mas nossa localização inicial e nossa localização de objetivo precisam ser escaladas de acordo com o que a escala do mapa

13:52.530 --> 13:53.560
está definida.

13:53.790 --> 14:00.540
Portanto, para os valores reais do mapa, não estamos escalando aqueles pela escala do mapa, mas para qualquer posicionamento

14:00.540 --> 14:02.280
que fizermos dos objetos.

14:02.280 --> 14:06.420
Portanto, o que vou fazer aqui em cima é multiplicar.

14:08.180 --> 14:10.940
Escala de pontos de milho.

14:11.390 --> 14:20.090
E então queremos usar esse valor ali e colocá-lo para nossa localização Z e também para nossa localização de objetivo

14:20.090 --> 14:20.900
aqui.

14:21.920 --> 14:22.720
Certo.

14:22.730 --> 14:23.090
Certo.

14:23.090 --> 14:27.440
Isso agora nos dará uma melhor localização.

14:27.590 --> 14:33.500
Acabei de notar também que deveria ser o local da meta ali, para que possamos ver a meta no local

14:33.500 --> 14:34.460
da meta.

14:34.490 --> 14:34.790
Certo.

14:34.790 --> 14:35.910
Portanto, vamos salvar isso.

14:35.930 --> 14:38.120
Vamos voltar à unidade agora.

14:38.120 --> 14:41.870
Vamos dar uma olhada no labirinto por um segundo antes de pressionarmos o jogo.

14:42.140 --> 14:49.220
E neste caso, você pode ver que meu roteiro recursivo tem o tamanho do mapa em 30 por 30.

14:49.490 --> 14:54.260
Você poderia deixá-lo deste tamanho, mas será um longo tempo para encontrar um caminho por lá.

14:54.260 --> 15:02.390
Portanto, o que eu recomendo é que você realmente o reduza para dez e dez, de modo que isso o torne um labirinto de tamanho

15:02.390 --> 15:03.320
manejável.

15:03.470 --> 15:09.890
Certo, então agora, se conseguirmos jogar, seremos capazes de ver nosso pequeno labirinto aparecer.

15:09.890 --> 15:12.980
Ali está ele para que você possa ir e se concentrar nele.

15:13.640 --> 15:20.120
E então, se pressionarmos a tecla P, certifique-se de que você clicou na janela do jogo para que ela se torne ativa.

15:20.150 --> 15:29.450
Aperte a tecla P e você verá que suas posições iniciais vão aparecer lá em cima porque lembre-se que as estamos colocando

15:29.450 --> 15:35.570
aleatoriamente e não há mais nada acontecendo entre apenas criá-las.

15:35.740 --> 15:36.030
Certo.

15:36.080 --> 15:41.840
Assim você pode ver muito claramente onde você tem que começar e onde você vai terminar.

15:41.870 --> 15:42.170
Certo.

15:42.170 --> 15:44.410
Vou deixar este vídeo aqui, por enquanto.

15:44.420 --> 15:51.500
Quando voltarmos, continuaremos trabalhando no algoritmo aStar para fazer algumas pesquisas de caminhos.
