Certo.
Vamos voltar a este algoritmo Astra e terminá-lo.
Portanto, ainda estamos em busca inicial e criamos nossos locais de início e fim.
Portanto, aqui embaixo, o que vamos fazer é limpar nossas listas abertas e fechadas.
Então aberto, ponto claro e fechado, não claro onde eles vão adicionar a posição inicial à lista aberta.
Então, abra o nó de partida.
E então, finalmente, se você se lembra, criamos essa última pausa, vamos definir isso para igualar
o nó inicial neste ponto.
Certo.
Portanto, estamos prontos para começar a procurar aqui embaixo.
Vamos criar outro método de busca.
E aqui é realmente onde você verá tudo o que temos falado até agora se reunir.
Portanto, a busca nula e nós passaremos pelo marcador de caminho deste nó.
Certo.
A primeira coisa que vamos fazer é testar se atingimos o objetivo.
Portanto, este é o tipo de condição final para tudo.
Portanto, se este ponto de nó for igual para que haja um sobre igual a entrar em jogo no nó de objetivo, então vamos colocar
dun igual a true e simplesmente voltar.
Certo.
E basicamente o objetivo foi encontrado.
Certo.
Em seguida, vamos percorrer e encontrar todos os vizinhos.
Certo.
Agora, isto é muito semelhante ao que estávamos fazendo em todos os nossos algoritmos de labirinto.
Certo.
Como conseguimos o vizinho da posição atual?
Bem, vamos voltar ao Labirinto.
Já temos essa construção definida para nós aqui mesmo.
Ok, então isto está levando nossos vizinhos para o mapa.
Também podemos usá-la para nossa estrela porque queremos apenas as horizontais e as verticais.
Entretanto, se você quiser poder pesquisar em diagonais, não há razão para não poder colocar aqui
as coordenadas diagonais.
E o algoritmo de ASR que estamos prestes a escrever funcionará exatamente da mesma forma.
Ok, então vamos começar fazendo looping através dessas direções do mapa.
Portanto, para cada localização do mapa, querida em direções de ponto de labirinto, deixe-me rolar isto para cima para você.
Vamos encontrar o vizinho.
Portanto, a localização do mapa vizinho vai igualar a direção.
Além deste ponto de nó de localização.
Neste momento, antes de podermos processar este vizinho em particular, ele precisa atender a algumas condições.
A primeira é que não deve ser uma parede.
Se for uma parede, então não vamos processá-la e vamos para o próximo vizinho.
Portanto, como um desafio, o que eu gostaria que você fizesse é escrever esta declaração para verificar
se o vizinho é um muro e se é um muro, então para continuar.
Então, faça uma pausa no vídeo.
Agora, quando voltarmos, eu digitarei isso para você.
Certo.
Como você foi?
Bem, é bastante simples.
Se o mapa de pontos de milho no ponto vizinho x e ponto z é igual a um, é uma parede e nós continuaremos.
Assim, continua apenas nos permitindo ir até a próxima direção do mapa que nos levará até o próximo vizinho.
Agora, a próxima declaração que teremos que considerar é se o vizinho está fora do domínio de nosso
labirinto.
Certo.
Então, outro desafio para você, certo?
Esta se declaração para verificar se aquele vizinho está fora de onde você quer que ele esteja, então continue também pausando
o vídeo.
Agora digite que quando você voltar, eu continuarei.
Certo.
Como foi com essa linha?
Bem, é se o ponto vizinho X for menor que um ou o ponto vizinho X for maior ou igual à largura do ponto de maio
ou o ponto vizinho z for menor que um ou o ponto vizinho z for maior ou igual à profundidade do ponto de maio.
E se for esse o caso, então vamos continuar.
Agora, uma última condição.
Se o vizinho já está na lista fechada, então também vamos continuar porque não queremos processá-la, mas
ainda não colocamos nada em nenhuma lista fechada, mesmo que tenhamos uma lista fechada.
Portanto, vamos criar nosso próprio método que verifica se um vizinho está nessa lista.
Portanto, logo abaixo da busca, vou colocá-lo aqui.
Então vamos colocar uma bola é fechada e então passaremos de fato pelo marcador de localização do mapa e depois.
Para cada um deles.
O caminho.
Marcador p in.
Vamos testar se a localização do ponto p é igual a um marcador.
Então, vamos voltar.
É verdade.
Caso contrário, vamos voltar.
Falso.
Certo.
Agora, parece um pouco longo o caminho que estamos passando por um marcador e depois estamos realmente
passando por um loop fechado que tem marcadores de caminho nele, e depois realmente testando contra um marcador
e a localização de um caminho, porque este é o caminho que temos que fazer neste ponto.
Aqui em cima, o vizinho é apenas um local de mapa.
É apenas uma posição no mapa.
Nós não lhe demos um marcador de caminho.
Portanto, não tem como uma instanciação de um daqueles objetos de jogo de caminho que já passamos
acima.
É por isso que temos estes testes em um local do mapa contra a existência de um marcador de caminho com
esse local.
Certo.
Portanto, aqui em baixo podemos colocar outra declaração se for um vizinho fechado, então vamos simplesmente
continuar.
A seguir, vamos calcular nosso valor G, nosso H e nosso F.
Então flutuar g equivale a ser o vetor a dois pontos de distância deste ponto de localização do nó, ponto
para vetor e vizinho, ponto para vetor, ponto para vetor, ponto para vetor.
Então, isso é encontrar seu Pitágoras.
Agora encontramos a distância entre o nó K atual e seu vizinho.
Portanto, este nó aqui é basicamente o que vai estar ao lado do vizinho.
Mas você precisa encontrar a distância que foi percorrida durante todo o caminho até aquele nó e depois para além dele.
Portanto, você tem que fazer isso e depois também adicionar neste nó e é o valor g que lhe permitirá mover um de seu nó atual,
além de somar toda a distância do caminho que você acumulou ao longo da viagem.
Certo?
E depois vamos para flutuar.
H Agora esta é a distância entre onde está aquele vizinho e o objetivo final.
Portanto, novamente, vamos usar um vetor para distanciar e, desta vez, estamos
encontrando a distância entre o ponto vizinho e o vetor para.
E o nó de objetivo.
Nó da meta.
Localização para vetor.
De volta ao vetor, não ao vetor também.
E isso é tudo o que você precisa fazer pelo seu valor h e depois flutuar.
F Agora você deve saber o que é isto porque é provavelmente o cálculo mais fácil
em toda uma estrela e isso é g mais h.
Portanto, basicamente é apenas um resumo das distâncias de nosso caminho ou dos custos envolvidos em sua viagem.
Pronto, então agora temos isso feito.
O que podemos fazer é criar um objeto de jogo para colocar em nosso caminho para este lugar em particular.
Portanto, este vizinho basicamente vai ter um bloco aberto.
Então objeto de jogo, bloco de caminho igual a instanciado e queremos esse caminho P que passamos
antes e novo vetor três.
Esta é a posição no mundo real do jogo onde vamos colocar isso de modo que será
nosso ponto vizinho x e não se esqueça de multiplicar por nossa escala de pontos do mapa aqui atrás que está na escala de pontos do labirinto
e depois em zero na escala Y e depois ponto z vizinho multiplicado pela escala de pontos do labirinto.
E depois queremos apenas colocar a identidade do ponto catalão no final disso.
Agora o caminho se bloqueia ou eu deveria dizer o caminho este objeto de jogo, se você der uma olhada, vamos voltar
a unir este pré-fabricado por caminho.
Se você abrir isso como um pré-fabricado e der uma olhada, você verá que há uma malha de texto G e H e uma malha de texto
F anexada a ele.
E é assim que eu estou exibindo os valores de G, H e F.
Claro, quando você estiver usando isto na produção para fazer uma estrela, você não precisa se preocupar com todo
tipo de interface e coisas chiques, mas eu quero que você seja capaz de vê-la à medida que avança.
Está bem?
Isso significa que nosso código precisa definir esses valores e nós voltaremos no próximo vídeo e continuaremos trabalhando
neste código.