En la conferencia anterior, empezamos a montar esta aplicación con waypoints en ella.
Así que ahora vamos a crear una clase gráfica que nos permita aplicar el algoritmo y conseguir que nuestro pequeño tanque se
mueva automáticamente entre estos puntos y calcule su propio camino.
Así que en los activos, lo que voy a hacer es crear una carpeta llamada gráficos.
Ahora abre eso dentro de aquí queremos tener tres clases de C-sharp.
Así que C-sharp, vamos a crear un gráfico.
Entonces queremos otro.
Así que vamos a crear C sharp, que vamos a llamar Node y otro más crear C sharp, que es edge.
Ahora bien, como has visto anteriormente en el curso, un gráfico se compone de nodos que son básicamente nuestros puntos
de paso y aristas, que son los caminos que van entre ellos.
Así que estas tres clases nos van a permitir enganchar esas cosas así como correr y una estrella a través de ellas.
Así que empecemos por abrir el más simple de ellos, que es nuestro borde.
Así que dentro del borde, lo que vamos a hacer aquí es realmente deshacerse de que sea un comportamiento mono porque
no necesitamos que tenga ninguna característica especial de comportamiento mono en absoluto, lo que significa
que no necesita una actualización o un inicio aquí.
Vamos a tener un nodo público, un nodo de inicio.
Ahora no hemos definido el Nodo, pero volveremos a hacerlo en un momento.
Nodo público y nodo.
Así que ese es el nodo inicial y el nodo final de la ruta.
Así que los que realmente puede viajar en el medio, entonces vamos a crear un constructor.
Así que el borde público donde vamos a poner un nodo de y un nodo dos y luego dentro de aquí vamos a establecer
el nodo de inicio es igual a la final y el nodo es igual a bien, eso es más o menos para su clase de borde, por lo que sólo guardar eso.
Ahora abre tu clase de nodo.
En la clase del nodo, vamos a deshacernos de nuevo de nuestro comportamiento del monitor y a deshacernos de nuestros métodos de unidad
sobrantes que vienen con él.
Ahora, un nodo es como un waypoint.
Es una posición en tu mapa y puede tener estos bordes que salen de ella.
Así que puede tener tantos bordes como necesite tener el borde de la lista pública.
Así que hacer una lista de todos estos bordes, que será nuestra lista de borde es igual a la nueva lista de borde.
Entonces queremos un nodo público path igual a null.
Así que esto nos permitirá definir o mantener un camino que va desde nuestro nodo objeto de juego I. D. Ahora que va a ser el objeto de juego que está
en nuestra ubicación de la ruta o lo siento, nuestra ubicación del nodo, debería decir el que está
representando donde está.
Si estás usando este gráfico en un tipo de situación diferente, entonces obviamente no tendrías un objeto
de juego asociado a él.
Podrías tener algo más.
Ahora queremos que el público flote su posición x.
Public float es el por qué de la posición y lo has adivinado public float para la posición Z para ayudarnos a calcular dónde están, las distancias entre ellos y hacia
dónde tiene que moverse nuestro tanque, cuando va a ir a uno de estos
nodos.
De acuerdo.
Así que también para el algoritmo aStar, tendremos que poner un flotador para los valores F, g y H del algoritmo de la estrella
que usaremos más adelante.
Y queremos que un nodo público venga desde ahora.
Esto va a almacenar otro nodo.
Así que si nuestro personaje se ha movido a un nodo en particular, entonces este es el lugar de donde vino para llegar allí.
Bien, ahora queremos un constructor de nodo público, vamos a pasar por el objeto de
juego, AI, y luego dentro de aquí vamos a establecer ID igual a AI y ese es nuestro objeto de juego x pausa
va a ser igual a AI punto de transformación posición x y pausa va a ser igual ai punto de transformación posición punto y y z pose va a ser igual a AI punto de
transformación posición punto z y luego camino inicialmente va a ser igual a null.
Esto es algo que se irá construyendo a medida que avancemos con la estrella a.
A continuación, aquí abajo se creará otro objeto público del juego, get ai d y que nos permitirá obtener nuestro ID de nodo, que en este caso es nuestro
objeto del juego para que podamos utilizarlo para comparar contra otros nodos más adelante.
Bien, ese es el nodo.
Así que guarda eso.
Ahora podemos abrir el gráfico, que es donde se va a desarrollar gran parte del trabajo.
De acuerdo.
Así que el gráfico tampoco será un comportamiento mono y los métodos iniciales que están ahí tampoco son necesarios.
En primer lugar, vamos a tener cada gráfico una lista de aristas.
Así que queremos un borde de la lista, vamos a llamarlo bordes es igual a nuevo borde de la lista, al igual que.
Entonces queremos una lista.
Los nodos son iguales a la nueva lista de nodos.
Y también queremos una lista de nodos, que se llamará lista de rutas.
Ahora, esta es la lista que será poblada por el algoritmo aStar, mientras que las otras dos son sólo las
aristas y nodos que existen todo el tiempo.
Así que esta será una nueva lista de nuestra clase de nodo también.
De acuerdo.
Ahora tendremos un constructor gráfico público, que realmente no va a hacer mucho.
Así de fácil.
De acuerdo.
Ahora dos métodos tendrán que poner los bordes y los nodos en será un vacío público añadir nodo y vamos a pasar
a través de la ID del objeto de juego por ahora.
Eso es todo.
Y luego dentro de aquí, iremos.
Nodo es igual a nodo.
El nodo es igual al nuevo nodo.
I. D..
Y luego la lista de nodos punto añadir nodo.
De acuerdo.
Así que eso es añadir nuestro nodo.
Luego, aquí abajo, iremos a public void, añadiremos edge y me permitirán poner una mayúscula por coherencia.
Y dentro de aquí, se crea una arista entre dos nodos.
Así que será objeto del juego desde el nodo, objeto del juego al nodo.
Y entonces nodo de nodo es igual a encontrar nodo de.
Nodo.
Así que básicamente estamos tomando esto de Node como un objeto de juego y tenemos que buscar a través de nuestra lista de nodos para obtener
este nodo para devolverlo como la forma de nodo.
Así que todavía tenemos que escribir, encontrar el nodo y déjame poner una F mayúscula para allí.
Así es como a partir de sin embargo entonces vamos a ir nodo dos, que será igual a nuestro nodo de encontrar a nodo.
De acuerdo.
Volveremos a esto.
Vamos a poner este método de encontrar el nodo.
Así que el nodo encontrar el objeto de juego o ID y vamos a bucle a través de nuestra lista y buscarlo.
Así que para cada nodo n en los nodos.
Si n punto get ID es igual a ID, entonces devolveremos n, de lo contrario devolveremos null.
Así que eso es sólo un bucle a través de los, encontrar el nodo particular que estamos después, utilizando el ID del nodo,
que es, de hecho, el objeto de juego.
Luego vuelve a subir en el borde de la adición.
Vamos a ir si desde no es igual a null y dos no es igual a null.
Así que estamos comprobando que estos dos nodos existen realmente.
Entonces podemos irnos.
La arista E es igual a la nueva arista de dos y luego el punto de aristas agrega esa arista a nuestra lista de aristas y luego podemos ir desde el punto de la lista
de aristas a agregar una así que recuerda que nuestra lista de aristas es lo que tiene nuestro nodo.
Así que estamos añadiendo en el borde que está saliendo de nuestra de justo ahí abajo.
De acuerdo.
Así que este es el inicio de nuestro gráfico.
De acuerdo.
Ahora tengo un pequeño problema que está pasando aquí abajo porque no tengo un corchete de cierre para
eso.
Así que vamos a poner eso para deshacernos de él.
Y ahora puedo guardar eso y terminaremos con esta conferencia porque ya hemos hecho bastante.
La siguiente parte de esto será poner en el un algoritmo de estrella para buscar y encontrar los
caminos de un nodo dado a otro.