Na palestra anterior, começamos a montar esta aplicação com pontos de passagem nela.
Portanto, vamos agora criar uma classe gráfica que nos permitirá aplicar o algoritmo e fazer com que nosso pequeno tanque se mova
automaticamente entre estes pontos e calcular seu próprio caminho.
Portanto, no ativo, o que eu vou fazer é criar uma pasta chamada gráficos.
Agora abra que aqui dentro queremos ter três classes C afiadas.
Então, C-sharp, vamos criar um gráfico.
Então queremos outro.
Portanto, vamos criar o C aguçado, que chamaremos de Nó e mais um criaremos o C aguçado, que é borda.
Agora, como você já viu anteriormente no curso, um gráfico é composto por nós que são basicamente nossos pontos
de passagem e bordas, que são os caminhos que vão entre eles.
Assim, estas três classes vão nos permitir ligar essas coisas, assim como correr e uma estrela através delas.
Portanto, comecemos abrindo a mais simples delas, que é a nossa vantagem.
Portanto, dentro do limite, o que vamos fazer aqui é na verdade nos livrarmos do fato de ser um comportamento mono porque
não precisamos que ele tenha nenhuma característica especial de comportamento mono, o que significa que ele não
precisa de uma atualização ou uma inicialização aqui.
Vamos ter nó público, nó de partida.
Agora não definimos Nodo, mas voltaremos e o faremos em um momento.
Nó e nó público.
Portanto, esse é o nó inicial e final do caminho.
Assim, aqueles que podem realmente viajar no meio, então criaremos um construtor.
Então, borda pública de onde colocaremos um nó e um nó dois e então dentro daqui colocaremos apenas
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.
Agora abra sua classe de nós.
Na classe de nós, vamos novamente nos livrar de nosso comportamento de monitor e nos livrar de nossos métodos de unidade
de restos que vêm com ele.
Agora, um nó é como um ponto de passagem.
É uma posição em seu mapa e pode ter estas bordas saindo dele.
Portanto, pode ter tantas arestas quantas precisar para ter aresta de lista pública.
Portanto, faça uma lista de todas essas bordas, que será nossa lista de bordas igual a nova lista de bordas.
Então queremos um caminho de nó público igual a nulo.
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á
no local do nosso caminho ou desculpe, a localização do nosso nó, eu deveria dizer aquele que está
representando onde ele está.
Se você estiver usando este gráfico em um tipo de situação diferente, então obviamente você não teria um objeto
de jogo associado a ele.
Você poderia ter algo mais.
Agora queremos que o público flutue sua posição x.
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
eles e para onde nosso tanque tem que ir, quando ele vai para um desses
nós.
Certo.
Portanto, também para o algoritmo aStar, teremos que montar um flutuador para os valores F, g e H do algoritmo estelar
que usaremos mais tarde.
E queremos um nó público que venha de agora.
Isto vai armazenar outro nó.
Portanto, se nosso personagem se mudou para um nó em particular, então é de lá que eles vieram para chegar lá.
Certo, então agora queremos um construtor de nó público, vamos passar pelo
objeto de jogo, IA, e então dentro daqui vamos definir ID para igualar IA e esse é nosso objeto de
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
ponto posição ponto z e então caminho inicialmente vai igual nulo.
Isto é algo que vai ser construído à medida que passamos com uma estrela.
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
é nosso objeto de jogo para que possamos usá-lo para comparar com outros nós mais tarde.
Então esse é o nó.
Portanto, economize isso.
Agora podemos abrir o gráfico, que é onde grande parte do trabalho vai continuar.
Certo.
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.
Primeiro, vamos ter cada gráfico uma lista de bordas.
Portanto, queremos uma margem de lista, vamos chamá-la de margem igual a uma nova margem de lista, exatamente como isso.
Em seguida, queremos uma lista.
Nós de nós é igual à nova lista de nós.
E depois queremos também uma lista de nós, que será chamada de lista de caminhos.
Agora, esta é a lista que será preenchida pelo algoritmo aStar, enquanto os outros dois são apenas
as bordas e nós que existem o tempo todo.
Portanto, esta será também uma nova lista de nossa classe de nós.
Certo.
Agora teremos um construtor gráfico público, o que realmente não vai fazer muito.
Assim sem mais nem menos.
Certo.
Agora dois métodos precisarão colocar bordas e nós serão um vazio público adicionar nó e nós passaremos
pelo ID do objeto do jogo por enquanto.
Isso serve.
E então, dentro daqui, nós iremos.
Nó é igual a nó.
Nó igual a novo nó.
I. D..
E, em seguida, listar pontos de adição de nódulos.
Certo.
Então, isso é acrescentar nosso nó.
Depois, aqui embaixo, vamos ao vazio público, acrescentamos vantagem e me deixamos colocar lá um capital para que haja consistência.
E dentro daqui, uma borda é criada entre dois nós.
Portanto, será objeto de jogo de nó, objeto de jogo para nó.
E então nó de nó é igual a nó de achado.
Nó.
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
que este nó o devolva como a forma do nó.
Portanto, ainda temos que escrever, encontrar o nó e deixar-me colocar um F maiúsculo para lá.
Então, é assim que a partir de então vamos para o nó dois, que igualará nosso nó de encontro a nó.
Certo.
Voltaremos a este assunto.
Vamos colocar neste método de encontrar nódulos.
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.
Assim, para cada nó nó em nós.
Se n ponto for igual a ID, então retornaremos n, caso contrário, retornaremos nulo.
Então isso é apenas fazer um looping através desses, encontrando o nó particular que estamos procurando, usando a identificação
do nó, que é de fato o objeto do jogo.
Em seguida, voltar para cima na borda de adição.
Iremos se a partir de não for igual a zero e dois não for igual a zero.
Portanto, estamos verificando se esses dois nós realmente existem.
Então, podemos ir.
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
ponto de borda adicionar um, então lembre-se que nossa lista de borda é o que nosso nó tem.
Portanto, na verdade estamos acrescentando na borda que está saindo do nosso, de lá de baixo.
Certo.
Assim são as entradas do nosso gráfico.
Certo.
Agora eu tenho um pequeno problema que está acontecendo aqui porque eu não tenho um parêntese final para
isso.
Portanto, vamos apenas colocar isso aí para nos livrarmos dele.
E agora posso salvar isso e vamos terminar com esta palestra porque já fizemos o suficiente.
A próxima parte disto será colocar um algoritmo estrela para procurar e encontrar os caminhos
de um determinado nó para outro.