Certo.
Como você está lidando com a Páscoa até agora?
Bem, nós ainda nem entramos no código.
E há um monte de códigos que temos que escrever.
Mas esperamos que pareça bastante familiar, pois já passamos por todas as coisas básicas
e como funciona.
Portanto, vamos começar agora dentro desta classe.
Antes de mais nada, precisamos agarrar nosso labirinto real para que possamos obter seu mapa.
Portanto, labirinto público, labirinto.
Agora, isto vai ser um pouco uma combinação entre executar realmente o algoritmo e depois mostrá-lo
também, visualizando-o na tela.
Por isso, vamos ter algumas construções que são apenas para todo o número de trituradores
e tudo e depois outras que vão mostrar as coisas para você.
Certo.
Portanto, antes de tudo, vou apenas adicionar dois materiais que usaremos para mudar nossos nós de uma cor para a outra
à medida que forem processados.
Portanto, material, material fechado.
E você provavelmente pode adivinhar qual é o próximo, material público, material aberto.
Então, precisamos criar nossas duas listas abertas e fechadas.
Portanto, vamos ter uma lista de marcadores de caminho.
Quatro Abertos é igual ao novo marcador de caminho de lista.
E depois precisamos também de um para as roupas.
Portanto, vamos copiar isso.
E faça isto fechado.
E então precisamos trazer nossos objetos de jogo que serão nossos verdadeiros marcadores físicos no mapa
que podemos ver.
Portanto, objeto de jogo público.
Comece.
Objeto de jogo público e.
E público.
Jogo.
Objeto.
O caminho.
Marcador de ponto ou caminho ou seja lá o que for.
Certo.
Vou chamá-lo assim.
Portanto, vamos apenas salvar isto e voltaremos à unidade.
E queremos ir ao objeto Maze Game na hierarquia e arrastar e largar para lá encontrar um roteiro
estelar.
Agora vamos povoar estes itens no roteiro.
Portanto, o labirinto é o roteiro que está gerando o labirinto, que é este roteiro recursivo.
Portanto, basta arrastar isso até lá.
Temos então um início e um fim e nossos marcadores de p caminho, assim como um material fechado e aberto.
Agora anexado a esta palestra há um pequeno pacote de unidade com alguns materiais e pré-fabricados nele.
Se você trouxer isso, você encontrará aqui uma pasta de modelos que tem materiais e pré-fabricados.
Assim, se formos primeiro aos nossos pré-fabricados e depois selecionarmos nosso labirinto, podemos colocar o objeto
inicial no início, o final no final, e depois o marcador de caminho no caminho.
P Agora também podemos definir nossos materiais para os nós fechados e abertos à medida que passamos.
Portanto, para fechado, vou usar vermelho e para aberto, vou usar verde.
Portanto, isto só tornará tudo mais visual para que você possa ver exatamente o que está acontecendo quando o algoritmo das
estrelas começar a funcionar.
Muito bem, então agora vamos voltar ao nosso código.
Agora, estas três coisas são nossos objetos de jogo que vamos instanciar e depois segurá-los dentro
de objetos marcadores de caminho.
Assim, vamos criar um marcador de caminho para o nó dourado e também criaremos um para o início.
Então, marcador de caminho, comece.
Nó.
Também precisaremos de outro marcador de caminho.
E este caminho, marca, vai acompanhar o último ponto em que nos encontramos, portanto, a última posição
neste caso.
E então também vamos acompanhar um touro chamado Done, que será verdade quando tivermos encontrado o caminho
para o final do caminho.
Portanto, vamos inicialmente definir isto como falso assim.
Está bem?
Por isso, todas essas são as coisas de que precisamos no topo, todas as nossas variáveis.
Muito bem.
Portanto, vou salvar isso novamente, mudar de volta para a Unidade e mostrar algo antes de continuarmos.
Portanto, se entrarmos em nossos pré-fabricados onde eu tenho esses marcadores e clicarmos em um, se você for
ao inspetor, verá que eles estão marcados como marcadores.
Fiz isso para que possamos removê-los com uma tecla pressionada fora do mapa, o que será útil em um
momento.
Portanto, o que vamos fazer é ter a capacidade de remover todos eles e depois fazer o ASR repetidamente sem reiniciar nosso código,
o que significa que você pode ter um pouco de brincadeira com ele e se acostumar
com os resultados.
Então vamos criar um vazio, remover todos os marcadores, e isto será apenas um loop realmente rápido que
destrói tudo.
Portanto, objeto de jogo.
Um raio de Marcus.
Igual a objetos de jogo.
Encontre objetos de jogo com.
Tag.
Certifique-se de usar objetos de jogo com o SE e isso será um marcador.
Certo.
E então faremos um rápido, então faremos um rápido para cada objeto de jogo m marcador em marcadores.
Destroy em.
Portanto, isso será chamado em breve.
Muito bem, vamos agora começar nossa busca.
Tão nulo.
Começar, procurar.
Permitiremos que isto seja chamado repetidamente, como eu disse antes.
Portanto, cada vez que o fizermos, vamos fazer o mesmo com falsidade.
E então nós vamos correr.
Remover todos os marcadores.
Certo.
Assim, agora podemos realmente criar nossos objetivos e tudo mais.
Portanto, antes de tudo, temos que escolher duas posições no labirinto real que serão nosso início e nosso
fim.
E poderíamos fazê-lo de forma bastante aleatória, onde simplesmente continuamos a escolher valores aleatórios e
ver se eles são um espaço ou uma parede e, claro, usar o espaço.
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
lista.
Embaralhe essa lista usando o método de embaralhamento que você encontrará no arquivo de extensões e, em seguida, assim como
retirá-las do topo.
Portanto, vou criar uma lista de locais de mapas, e isso será chamado de Localizações Igual a Nova
Lista.
Localização do mapa.
Certo.
Vamos então criar nossos laços aninhados para dar a volta ao nosso mapa.
Portanto, se quisermos para int z igual a um a Z é menos do que a profundidade do nosso labirinto.
Menos um e depois Z mais.
E mais.
A mesma coisa para.
X.
Portanto, vamos mudar isso para X e X.
E, neste caso, queremos nossa largura e fazemos esse x.
E dentro daqui vamos testar se podemos parar o mapa para esse x.
Z não é igual a um, então nós o colocaremos em nossa lista.
Os pontos de localização adicionam nova localização do mapa.
X.
Z.
Então por que não estamos usando igual a um neste código?
Bem, no código dos ratos, se você tiver um olhar e o algoritmo recursivo que o está escrevendo
nos labirintos que estamos gerando, há um valor de zero onde há um espaço vazio e um onde
há uma parede.
Entretanto, quando você está criando labirintos, você pode ter outros valores que representam outras coisas dentro
daquela área de labirinto.
Portanto, só estamos realmente preocupados se houver um muro no momento, até onde podemos nos mover.
E é por isso que não estamos usando igual a um aqui.
Portanto, sabemos que são as paredes e as posições de partida podem ser qualquer outro valor neste ponto.
Então é por isso que não tenho igual a um.
Então, mas o tempo que passamos por isso, agora temos todos esses locais.
E assim, se simplesmente baralhá-los, as localizações se baralham.
Isso nos dará um par de valores sentados no topo dessa lista, que podemos ir em frente e arrancar
e usar como o local da meta e também como o local de partida.
Portanto, vamos em frente e façamos isso.
Portanto, depois do embaralhamento, vou criar um vetor três, que será nosso local de partida.
E vamos definir isso para um novo vetor três e para obter os valores, vamos arrancá-los,
como eu disse, a localização e vamos dar-lhe localizações na posição zero ponto X e depois podemos simplesmente
colocá-lo zero para o valor Y e localizações, zero para a posição Z.
Agora estamos colocando zero como a altura porque eu fiz isso com praticamente
tudo o que estamos zerando como uma superfície plana.
Portanto, é basicamente uma espécie de dois D, no mínimo.
E então, uma vez que tenhamos este local, vamos instanciar nosso primeiro nó naquele local.
Portanto, vou criar um nó inicial.
E isso vai se igualar a um novo marcador de caminho.
O que será um novo mapa.
Localização, localizações zero ponto X, localizações zero ponto Z.
Portanto, o mesmo uso que você está usando para a posição.
E depois vamos enviar um zero, depois vamos zerar nossos valores G, nosso H e nosso F.
E para o marcador de jogo, acabei de descer uma linha para não sair da tela por você.
Vamos instanciar o início.
Comece.
Localização.
E então colocaremos Kitten em ponto de identidade para a rotação, porque isso não é realmente importante.
E finalmente, o pai vai ser nulo.
Portanto, vamos colocar isso aí.
E para a localização do objetivo, fazemos a mesma coisa.
Portanto, vou apenas copiar tudo isso, salvo digitar novamente, colocar aqui,
ter certeza de que estamos falando do local da meta, da posição do local da meta.
Vamos usar isso como o segundo valor nessa matriz de locais que embaralhamos.
Por isso, vamos definir todos esses valores em um só.
E então este nó aqui embaixo será nosso nó de objetivo.
Agora, ao mesmo tempo em que realmente criamos o marcador de caminho, vamos instanciar esses pré-fabricados.
Portanto, este aqui será na verdade o pré-fabricado final que enviamos antes.
Está bem?
Assim, agora podemos realmente correr, começar, procurar e poderemos ver esses marcadores aparecerem.
Portanto, vou fazer isso na atualização.
Portanto, só aqui, vamos colocar se o ponto de entrada para baixar a chave é o ponto de código p.
Depois faremos uma busca de barganha.
Agora, um pequeno ajuste que precisamos fazer neste código é adicionar um valor de escala porque o próprio
labirinto usa uma escala para torná-lo maior na tela para que você realmente o traga para fora e as posições reais
no mapa lá.
Não precisam ser aumentadas.
Eles ainda estão em posições de unidade leve.
Mas nossa localização inicial e nossa localização de objetivo precisam ser escaladas de acordo com o que a escala do mapa
está definida.
Portanto, para os valores reais do mapa, não estamos escalando aqueles pela escala do mapa, mas para qualquer posicionamento
que fizermos dos objetos.
Portanto, o que vou fazer aqui em cima é multiplicar.
Escala de pontos de milho.
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
aqui.
Certo.
Isso agora nos dará uma melhor localização.
Acabei de notar também que deveria ser o local da meta ali, para que possamos ver a meta no local
da meta.
Certo.
Portanto, vamos salvar isso.
Vamos voltar à unidade agora.
Vamos dar uma olhada no labirinto por um segundo antes de pressionarmos o jogo.
E neste caso, você pode ver que meu roteiro recursivo tem o tamanho do mapa em 30 por 30.
Você poderia deixá-lo deste tamanho, mas será um longo tempo para encontrar um caminho por lá.
Portanto, o que eu recomendo é que você realmente o reduza para dez e dez, de modo que isso o torne um labirinto de tamanho
manejável.
Certo, então agora, se conseguirmos jogar, seremos capazes de ver nosso pequeno labirinto aparecer.
Ali está ele para que você possa ir e se concentrar nele.
E então, se pressionarmos a tecla P, certifique-se de que você clicou na janela do jogo para que ela se torne ativa.
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
aleatoriamente e não há mais nada acontecendo entre apenas criá-las.
Certo.
Assim você pode ver muito claramente onde você tem que começar e onde você vai terminar.
Certo.
Vou deixar este vídeo aqui, por enquanto.
Quando voltarmos, continuaremos trabalhando no algoritmo aStar para fazer algumas pesquisas de caminhos.