WEBVTT

00:02.830 --> 00:03.520
Certo.

00:03.520 --> 00:07.830
Vamos voltar a este algoritmo Astra e terminá-lo.

00:07.840 --> 00:14.020
Portanto, ainda estamos em busca inicial e criamos nossos locais de início e fim.

00:14.020 --> 00:18.700
Portanto, aqui embaixo, o que vamos fazer é limpar nossas listas abertas e fechadas.

00:18.700 --> 00:31.270
Então aberto, ponto claro e fechado, não claro onde eles vão adicionar a posição inicial à lista aberta.

00:31.270 --> 00:36.460
Então, abra o nó de partida.

00:37.180 --> 00:45.100
E então, finalmente, se você se lembra, criamos essa última pausa, vamos definir isso para igualar

00:45.640 --> 00:47.770
o nó inicial neste ponto.

00:47.980 --> 00:48.550
Certo.

00:48.550 --> 00:52.540
Portanto, estamos prontos para começar a procurar aqui embaixo.

00:52.540 --> 00:54.670
Vamos criar outro método de busca.

00:55.030 --> 00:59.640
E aqui é realmente onde você verá tudo o que temos falado até agora se reunir.

00:59.920 --> 01:08.410
Portanto, a busca nula e nós passaremos pelo marcador de caminho deste nó.

01:10.250 --> 01:10.630
Certo.

01:10.640 --> 01:15.380
A primeira coisa que vamos fazer é testar se atingimos o objetivo.

01:15.590 --> 01:19.400
Portanto, este é o tipo de condição final para tudo.

01:19.520 --> 01:30.920
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

01:30.920 --> 01:35.600
dun igual a true e simplesmente voltar.

01:35.960 --> 01:36.320
Certo.

01:36.350 --> 01:41.300
E basicamente o objetivo foi encontrado.

01:41.960 --> 01:42.390
Certo.

01:42.410 --> 01:50.300
Em seguida, vamos percorrer e encontrar todos os vizinhos.

01:51.080 --> 01:51.380
Certo.

01:51.380 --> 01:55.930
Agora, isto é muito semelhante ao que estávamos fazendo em todos os nossos algoritmos de labirinto.

01:56.030 --> 01:56.400
Certo.

01:56.420 --> 02:01.640
Como conseguimos o vizinho da posição atual?

02:01.670 --> 02:04.040
Bem, vamos voltar ao Labirinto.

02:04.490 --> 02:09.890
Já temos essa construção definida para nós aqui mesmo.

02:09.960 --> 02:13.930
Ok, então isto está levando nossos vizinhos para o mapa.

02:13.940 --> 02:19.940
Também podemos usá-la para nossa estrela porque queremos apenas as horizontais e as verticais.

02:20.180 --> 02:26.390
Entretanto, se você quiser poder pesquisar em diagonais, não há razão para não poder colocar aqui

02:26.390 --> 02:28.220
as coordenadas diagonais.

02:28.220 --> 02:33.740
E o algoritmo de ASR que estamos prestes a escrever funcionará exatamente da mesma forma.

02:33.940 --> 02:37.400
Ok, então vamos começar fazendo looping através dessas direções do mapa.

02:37.400 --> 02:49.400
Portanto, para cada localização do mapa, querida em direções de ponto de labirinto, deixe-me rolar isto para cima para você.

02:49.550 --> 02:52.370
Vamos encontrar o vizinho.

02:52.640 --> 02:58.520
Portanto, a localização do mapa vizinho vai igualar a direção.

02:58.520 --> 03:03.020
Além deste ponto de nó de localização.

03:03.770 --> 03:11.410
Neste momento, antes de podermos processar este vizinho em particular, ele precisa atender a algumas condições.

03:11.420 --> 03:14.900
A primeira é que não deve ser uma parede.

03:15.080 --> 03:21.330
Se for uma parede, então não vamos processá-la e vamos para o próximo vizinho.

03:21.350 --> 03:27.740
Portanto, como um desafio, o que eu gostaria que você fizesse é escrever esta declaração para verificar

03:27.740 --> 03:31.720
se o vizinho é um muro e se é um muro, então para continuar.

03:31.730 --> 03:32.570
Então, faça uma pausa no vídeo.

03:32.570 --> 03:35.510
Agora, quando voltarmos, eu digitarei isso para você.

03:36.630 --> 03:37.040
Certo.

03:37.080 --> 03:37.880
Como você foi?

03:37.890 --> 03:39.450
Bem, é bastante simples.

03:39.450 --> 03:53.910
Se o mapa de pontos de milho no ponto vizinho x e ponto z é igual a um, é uma parede e nós continuaremos.

03:53.910 --> 04:02.490
Assim, continua apenas nos permitindo ir até a próxima direção do mapa que nos levará até o próximo vizinho.

04:02.490 --> 04:11.460
Agora, a próxima declaração que teremos que considerar é se o vizinho está fora do domínio de nosso

04:11.460 --> 04:12.750
labirinto.

04:12.780 --> 04:13.260
Certo.

04:13.260 --> 04:15.240
Então, outro desafio para você, certo?

04:15.240 --> 04:22.890
Esta se declaração para verificar se aquele vizinho está fora de onde você quer que ele esteja, então continue também pausando

04:22.920 --> 04:23.580
o vídeo.

04:23.580 --> 04:27.330
Agora digite que quando você voltar, eu continuarei.

04:28.300 --> 04:28.680
Certo.

04:28.690 --> 04:29.660
Como foi com essa linha?

04:29.680 --> 04:46.090
Bem, é se o ponto vizinho X for menor que um ou o ponto vizinho X for maior ou igual à largura do ponto de maio

04:46.090 --> 05:03.880
ou o ponto vizinho z for menor que um ou o ponto vizinho z for maior ou igual à profundidade do ponto de maio.

05:04.120 --> 05:07.990
E se for esse o caso, então vamos continuar.

05:08.440 --> 05:10.240
Agora, uma última condição.

05:10.360 --> 05:18.220
Se o vizinho já está na lista fechada, então também vamos continuar porque não queremos processá-la, mas

05:18.220 --> 05:25.180
ainda não colocamos nada em nenhuma lista fechada, mesmo que tenhamos uma lista fechada.

05:25.330 --> 05:34.060
Portanto, vamos criar nosso próprio método que verifica se um vizinho está nessa lista.

05:34.480 --> 05:36.790
Portanto, logo abaixo da busca, vou colocá-lo aqui.

05:36.790 --> 05:49.240
Então vamos colocar uma bola é fechada e então passaremos de fato pelo marcador de localização do mapa e depois.

05:50.850 --> 05:52.080
Para cada um deles.

05:54.090 --> 05:55.050
O caminho.

05:56.390 --> 05:58.810
Marcador p in.

06:00.200 --> 06:10.190
Vamos testar se a localização do ponto p é igual a um marcador.

06:10.250 --> 06:12.410
Então, vamos voltar.

06:13.100 --> 06:14.060
É verdade.

06:14.570 --> 06:17.210
Caso contrário, vamos voltar.

06:19.530 --> 06:20.340
Falso.

06:20.390 --> 06:20.900
Certo.

06:20.910 --> 06:27.630
Agora, parece um pouco longo o caminho que estamos passando por um marcador e depois estamos realmente

06:27.630 --> 06:34.740
passando por um loop fechado que tem marcadores de caminho nele, e depois realmente testando contra um marcador

06:34.740 --> 06:41.430
e a localização de um caminho, porque este é o caminho que temos que fazer neste ponto.

06:41.430 --> 06:45.210
Aqui em cima, o vizinho é apenas um local de mapa.

06:45.210 --> 06:46.350
É apenas uma posição no mapa.

06:46.350 --> 06:49.110
Nós não lhe demos um marcador de caminho.

06:49.110 --> 06:58.050
Portanto, não tem como uma instanciação de um daqueles objetos de jogo de caminho que já passamos

06:58.050 --> 06:58.890
acima.

06:59.070 --> 07:06.720
É por isso que temos estes testes em um local do mapa contra a existência de um marcador de caminho com

07:06.720 --> 07:07.770
esse local.

07:07.920 --> 07:08.370
Certo.

07:08.370 --> 07:15.750
Portanto, aqui em baixo podemos colocar outra declaração se for um vizinho fechado, então vamos simplesmente

07:15.780 --> 07:16.680
continuar.

07:18.270 --> 07:24.540
A seguir, vamos calcular nosso valor G, nosso H e nosso F.

07:24.560 --> 07:38.040
Então flutuar g equivale a ser o vetor a dois pontos de distância deste ponto de localização do nó, ponto

07:38.040 --> 07:48.630
para vetor e vizinho, ponto para vetor, ponto para vetor, ponto para vetor.

07:48.630 --> 07:50.760
Então, isso é encontrar seu Pitágoras.

07:50.790 --> 07:59.010
Agora encontramos a distância entre o nó K atual e seu vizinho.

07:59.010 --> 08:03.180
Portanto, este nó aqui é basicamente o que vai estar ao lado do vizinho.

08:03.270 --> 08:10.950
Mas você precisa encontrar a distância que foi percorrida durante todo o caminho até aquele nó e depois para além dele.

08:10.950 --> 08:20.430
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,

08:20.430 --> 08:27.030
além de somar toda a distância do caminho que você acumulou ao longo da viagem.

08:27.300 --> 08:27.660
Certo?

08:27.660 --> 08:29.010
E depois vamos para flutuar.

08:29.010 --> 08:35.730
H Agora esta é a distância entre onde está aquele vizinho e o objetivo final.

08:35.730 --> 08:41.940
Portanto, novamente, vamos usar um vetor para distanciar e, desta vez, estamos

08:41.940 --> 08:46.770
encontrando a distância entre o ponto vizinho e o vetor para.

08:47.930 --> 08:50.000
E o nó de objetivo.

08:50.780 --> 08:51.350
Nó da meta.

08:52.670 --> 08:55.790
Localização para vetor.

08:56.900 --> 09:00.140
De volta ao vetor, não ao vetor também.

09:00.380 --> 09:06.080
E isso é tudo o que você precisa fazer pelo seu valor h e depois flutuar.

09:06.110 --> 09:12.620
F Agora você deve saber o que é isto porque é provavelmente o cálculo mais fácil

09:12.620 --> 09:15.970
em toda uma estrela e isso é g mais h.

09:15.980 --> 09:23.060
Portanto, basicamente é apenas um resumo das distâncias de nosso caminho ou dos custos envolvidos em sua viagem.

09:23.570 --> 09:26.600
Pronto, então agora temos isso feito.

09:26.600 --> 09:33.800
O que podemos fazer é criar um objeto de jogo para colocar em nosso caminho para este lugar em particular.

09:33.800 --> 09:38.690
Portanto, este vizinho basicamente vai ter um bloco aberto.

09:38.690 --> 09:51.080
Então objeto de jogo, bloco de caminho igual a instanciado e queremos esse caminho P que passamos

09:51.260 --> 09:55.100
antes e novo vetor três.

09:55.100 --> 10:00.860
Esta é a posição no mundo real do jogo onde vamos colocar isso de modo que será

10:01.070 --> 10:11.510
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

10:11.540 --> 10:20.780
e depois em zero na escala Y e depois ponto z vizinho multiplicado pela escala de pontos do labirinto.

10:20.900 --> 10:30.110
E depois queremos apenas colocar a identidade do ponto catalão no final disso.

10:31.190 --> 10:39.260
Agora o caminho se bloqueia ou eu deveria dizer o caminho este objeto de jogo, se você der uma olhada, vamos voltar

10:39.260 --> 10:42.380
a unir este pré-fabricado por caminho.

10:42.380 --> 10:51.410
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

10:51.410 --> 10:53.180
F anexada a ele.

10:53.180 --> 10:57.500
E é assim que eu estou exibindo os valores de G, H e F.

10:57.500 --> 11:03.410
Claro, quando você estiver usando isto na produção para fazer uma estrela, você não precisa se preocupar com todo

11:03.420 --> 11:08.690
tipo de interface e coisas chiques, mas eu quero que você seja capaz de vê-la à medida que avança.

11:08.720 --> 11:09.080
Está bem?

11:09.080 --> 11:15.470
Isso significa que nosso código precisa definir esses valores e nós voltaremos no próximo vídeo e continuaremos trabalhando

11:15.470 --> 11:16.850
neste código.
