WEBVTT

00:06.490 --> 00:11.740
Na palestra anterior, começamos a montar esta aplicação com pontos de passagem nela.

00:11.740 --> 00:20.560
Portanto, vamos agora criar uma classe gráfica que nos permitirá aplicar o algoritmo e fazer com que nosso pequeno tanque se mova

00:20.560 --> 00:25.770
automaticamente entre estes pontos e calcular seu próprio caminho.

00:25.780 --> 00:33.400
Portanto, no ativo, o que eu vou fazer é criar uma pasta chamada gráficos.

00:33.880 --> 00:39.250
Agora abra que aqui dentro queremos ter três classes C afiadas.

00:39.250 --> 00:43.000
Então, C-sharp, vamos criar um gráfico.

00:43.300 --> 00:45.100
Então queremos outro.

00:45.100 --> 00:56.020
Portanto, vamos criar o C aguçado, que chamaremos de Nó e mais um criaremos o C aguçado, que é borda.

00:56.830 --> 01:04.210
Agora, como você já viu anteriormente no curso, um gráfico é composto por nós que são basicamente nossos pontos

01:04.210 --> 01:08.320
de passagem e bordas, que são os caminhos que vão entre eles.

01:08.320 --> 01:16.360
Assim, estas três classes vão nos permitir ligar essas coisas, assim como correr e uma estrela através delas.

01:16.360 --> 01:23.140
Portanto, comecemos abrindo a mais simples delas, que é a nossa vantagem.

01:23.230 --> 01:29.620
Portanto, dentro do limite, o que vamos fazer aqui é na verdade nos livrarmos do fato de ser um comportamento mono porque

01:29.620 --> 01:35.830
não precisamos que ele tenha nenhuma característica especial de comportamento mono, o que significa que ele não

01:35.860 --> 01:39.040
precisa de uma atualização ou uma inicialização aqui.

01:39.040 --> 01:43.450
Vamos ter nó público, nó de partida.

01:43.450 --> 01:46.600
Agora não definimos Nodo, mas voltaremos e o faremos em um momento.

01:46.690 --> 01:50.440
Nó e nó público.

01:50.650 --> 01:54.970
Portanto, esse é o nó inicial e final do caminho.

01:54.970 --> 02:00.070
Assim, aqueles que podem realmente viajar no meio, então criaremos um construtor.

02:00.070 --> 02:10.360
Então, borda pública de onde colocaremos um nó e um nó dois e então dentro daqui colocaremos apenas

02:10.810 --> 02:24.520
o nó inicial igual ao final e o nó igual ao ok, isso é praticamente tudo para sua classe de borda, então é só salvar isso.

02:24.550 --> 02:27.880
Agora abra sua classe de nós.

02:28.540 --> 02:36.760
Na classe de nós, vamos novamente nos livrar de nosso comportamento de monitor e nos livrar de nossos métodos de unidade

02:36.760 --> 02:38.950
de restos que vêm com ele.

02:39.220 --> 02:42.180
Agora, um nó é como um ponto de passagem.

02:42.180 --> 02:48.460
É uma posição em seu mapa e pode ter estas bordas saindo dele.

02:48.460 --> 02:56.050
Portanto, pode ter tantas arestas quantas precisar para ter aresta de lista pública.

02:56.050 --> 03:05.920
Portanto, faça uma lista de todas essas bordas, que será nossa lista de bordas igual a nova lista de bordas.

03:06.700 --> 03:12.190
Então queremos um caminho de nó público igual a nulo.

03:12.190 --> 03:21.970
Assim, isto nos permitirá definir ou manter um caminho que vai desde nosso objeto de jogo de nó I. D. Agora este vai ser o objeto de jogo que está

03:21.970 --> 03:29.950
no local do nosso caminho ou desculpe, a localização do nosso nó, eu deveria dizer aquele que está

03:29.950 --> 03:32.920
representando onde ele está.

03:32.920 --> 03:37.750
Se você estiver usando este gráfico em um tipo de situação diferente, então obviamente você não teria um objeto

03:37.750 --> 03:39.040
de jogo associado a ele.

03:39.040 --> 03:40.420
Você poderia ter algo mais.

03:41.080 --> 03:47.110
Agora queremos que o público flutue sua posição x.

03:48.990 --> 04:01.740
Flutuação pública é o porquê da posição e você adivinhou a flutuação pública para a posição Z para nos ajudar a calcular onde eles estão, as distâncias entre

04:01.740 --> 04:07.080
eles e para onde nosso tanque tem que ir, quando ele vai para um desses

04:07.080 --> 04:08.130
nós.

04:08.370 --> 04:08.880
Certo.

04:08.880 --> 04:19.020
Portanto, também para o algoritmo aStar, teremos que montar um flutuador para os valores F, g e H do algoritmo estelar

04:19.200 --> 04:21.750
que usaremos mais tarde.

04:21.750 --> 04:28.410
E queremos um nó público que venha de agora.

04:28.410 --> 04:30.930
Isto vai armazenar outro nó.

04:30.930 --> 04:40.050
Portanto, se nosso personagem se mudou para um nó em particular, então é de lá que eles vieram para chegar lá.

04:40.320 --> 04:49.230
Certo, então agora queremos um construtor de nó público, vamos passar pelo

04:49.230 --> 05:00.240
objeto de jogo, IA, e então dentro daqui vamos definir ID para igualar IA e esse é nosso objeto de

05:00.240 --> 05:16.290
jogo x pausa vai igualar AI ponto transform posição x y pausa vai igual ai ponto transform ponto posição ponto y e z pose vai igual AI ponto transform

05:16.530 --> 05:25.890
ponto posição ponto z e então caminho inicialmente vai igual nulo.

05:25.890 --> 05:30.120
Isto é algo que vai ser construído à medida que passamos com uma estrela.

05:30.420 --> 05:40.830
Então, aqui embaixo, criaremos outro objeto de jogo público, o get ai d e que nos permitirá obter nossa identificação do nó, que neste caso

05:41.580 --> 05:48.360
é nosso objeto de jogo para que possamos usá-lo para comparar com outros nós mais tarde.

05:49.020 --> 05:51.810
Então esse é o nó.

05:51.810 --> 05:53.010
Portanto, economize isso.

05:53.040 --> 06:00.810
Agora podemos abrir o gráfico, que é onde grande parte do trabalho vai continuar.

06:01.560 --> 06:02.190
Certo.

06:02.190 --> 06:10.050
Portanto, o gráfico também não será um comportamento mono e os métodos iniciais que estão ali também não são necessários.

06:10.350 --> 06:14.580
Primeiro, vamos ter cada gráfico uma lista de bordas.

06:14.580 --> 06:23.670
Portanto, queremos uma margem de lista, vamos chamá-la de margem igual a uma nova margem de lista, exatamente como isso.

06:23.670 --> 06:25.470
Em seguida, queremos uma lista.

06:26.070 --> 06:34.470
Nós de nós é igual à nova lista de nós.

06:35.790 --> 06:43.660
E depois queremos também uma lista de nós, que será chamada de lista de caminhos.

06:43.680 --> 06:49.830
Agora, esta é a lista que será preenchida pelo algoritmo aStar, enquanto os outros dois são apenas

06:49.830 --> 06:52.440
as bordas e nós que existem o tempo todo.

06:52.590 --> 06:59.250
Portanto, esta será também uma nova lista de nossa classe de nós.

06:59.910 --> 07:00.450
Certo.

07:00.450 --> 07:08.010
Agora teremos um construtor gráfico público, o que realmente não vai fazer muito.

07:08.040 --> 07:08.710
Assim sem mais nem menos.

07:08.730 --> 07:09.000
Certo.

07:09.000 --> 07:18.660
Agora dois métodos precisarão colocar bordas e nós serão um vazio público adicionar nó e nós passaremos

07:18.660 --> 07:23.370
pelo ID do objeto do jogo por enquanto.

07:23.400 --> 07:24.300
Isso serve.

07:25.500 --> 07:27.120
E então, dentro daqui, nós iremos.

07:27.120 --> 07:29.850
Nó é igual a nó.

07:29.850 --> 07:33.300
Nó igual a novo nó.

07:35.490 --> 07:36.460
I. D..

07:37.770 --> 07:43.470
E, em seguida, listar pontos de adição de nódulos.

07:45.340 --> 07:45.700
Certo.

07:45.700 --> 07:47.020
Então, isso é acrescentar nosso nó.

07:47.020 --> 07:56.680
Depois, aqui embaixo, vamos ao vazio público, acrescentamos vantagem e me deixamos colocar lá um capital para que haja consistência.

07:56.680 --> 08:00.220
E dentro daqui, uma borda é criada entre dois nós.

08:00.220 --> 08:08.770
Portanto, será objeto de jogo de nó, objeto de jogo para nó.

08:09.400 --> 08:17.890
E então nó de nó é igual a nó de achado.

08:18.600 --> 08:19.440
Nó.

08:19.560 --> 08:29.790
Portanto, estamos basicamente tomando isto do Nodo como um objeto de jogo e temos que olhar através de nossa lista de nós para conseguir

08:29.790 --> 08:33.600
que este nó o devolva como a forma do nó.

08:33.600 --> 08:38.490
Portanto, ainda temos que escrever, encontrar o nó e deixar-me colocar um F maiúsculo para lá.

08:38.490 --> 08:49.110
Então, é assim que a partir de então vamos para o nó dois, que igualará nosso nó de encontro a nó.

08:52.610 --> 08:52.970
Certo.

08:52.970 --> 08:53.980
Voltaremos a este assunto.

08:53.990 --> 08:57.530
Vamos colocar neste método de encontrar nódulos.

08:57.530 --> 09:08.480
Então, encontre o objeto de jogo ou ID do nó e nós faremos um loop através de nossa lista e o procuraremos.

09:08.480 --> 09:13.370
Assim, para cada nó nó em nós.

09:14.690 --> 09:30.440
Se n ponto for igual a ID, então retornaremos n, caso contrário, retornaremos nulo.

09:31.850 --> 09:39.560
Então isso é apenas fazer um looping através desses, encontrando o nó particular que estamos procurando, usando a identificação

09:39.560 --> 09:42.040
do nó, que é de fato o objeto do jogo.

09:42.050 --> 09:44.210
Em seguida, voltar para cima na borda de adição.

09:44.210 --> 09:51.590
Iremos se a partir de não for igual a zero e dois não for igual a zero.

09:51.590 --> 09:55.160
Portanto, estamos verificando se esses dois nós realmente existem.

09:55.280 --> 09:56.520
Então, podemos ir.

09:56.540 --> 10:11.390
Borda E é igual a nova borda a partir de duas e depois o ponto de borda adiciona essa borda em nossa lista de borda e depois podemos ir da lista de

10:11.390 --> 10:21.140
ponto de borda adicionar um, então lembre-se que nossa lista de borda é o que nosso nó tem.

10:21.380 --> 10:26.690
Portanto, na verdade estamos acrescentando na borda que está saindo do nosso, de lá de baixo.

10:26.840 --> 10:27.440
Certo.

10:27.440 --> 10:31.910
Assim são as entradas do nosso gráfico.

10:32.180 --> 10:32.600
Certo.

10:32.600 --> 10:37.730
Agora eu tenho um pequeno problema que está acontecendo aqui porque eu não tenho um parêntese final para

10:37.760 --> 10:38.060
isso.

10:38.060 --> 10:40.250
Portanto, vamos apenas colocar isso aí para nos livrarmos dele.

10:40.250 --> 10:47.030
E agora posso salvar isso e vamos terminar com esta palestra porque já fizemos o suficiente.

10:47.030 --> 10:54.410
A próxima parte disto será colocar um algoritmo estrela para procurar e encontrar os caminhos

10:54.410 --> 10:57.110
de um determinado nó para outro.
