WEBVTT

00:06.490 --> 00:11.740
En la conferencia anterior, empezamos a montar esta aplicación con waypoints en ella.

00:11.740 --> 00:20.560
Así que ahora vamos a crear una clase gráfica que nos permita aplicar el algoritmo y conseguir que nuestro pequeño tanque se

00:20.560 --> 00:25.770
mueva automáticamente entre estos puntos y calcule su propio camino.

00:25.780 --> 00:33.400
Así que en los activos, lo que voy a hacer es crear una carpeta llamada gráficos.

00:33.880 --> 00:39.250
Ahora abre eso dentro de aquí queremos tener tres clases de C-sharp.

00:39.250 --> 00:43.000
Así que C-sharp, vamos a crear un gráfico.

00:43.300 --> 00:45.100
Entonces queremos otro.

00:45.100 --> 00:56.020
Así que vamos a crear C sharp, que vamos a llamar Node y otro más crear C sharp, que es edge.

00:56.830 --> 01:04.210
Ahora bien, como has visto anteriormente en el curso, un gráfico se compone de nodos que son básicamente nuestros puntos

01:04.210 --> 01:08.320
de paso y aristas, que son los caminos que van entre ellos.

01:08.320 --> 01:16.360
Así que estas tres clases nos van a permitir enganchar esas cosas así como correr y una estrella a través de ellas.

01:16.360 --> 01:23.140
Así que empecemos por abrir el más simple de ellos, que es nuestro borde.

01:23.230 --> 01:29.620
Así que dentro del borde, lo que vamos a hacer aquí es realmente deshacerse de que sea un comportamiento mono porque

01:29.620 --> 01:35.830
no necesitamos que tenga ninguna característica especial de comportamiento mono en absoluto, lo que significa

01:35.860 --> 01:39.040
que no necesita una actualización o un inicio aquí.

01:39.040 --> 01:43.450
Vamos a tener un nodo público, un nodo de inicio.

01:43.450 --> 01:46.600
Ahora no hemos definido el Nodo, pero volveremos a hacerlo en un momento.

01:46.690 --> 01:50.440
Nodo público y nodo.

01:50.650 --> 01:54.970
Así que ese es el nodo inicial y el nodo final de la ruta.

01:54.970 --> 02:00.070
Así que los que realmente puede viajar en el medio, entonces vamos a crear un constructor.

02:00.070 --> 02:10.360
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

02:10.810 --> 02:24.520
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.

02:24.550 --> 02:27.880
Ahora abre tu clase de nodo.

02:28.540 --> 02:36.760
En la clase del nodo, vamos a deshacernos de nuevo de nuestro comportamiento del monitor y a deshacernos de nuestros métodos de unidad

02:36.760 --> 02:38.950
sobrantes que vienen con él.

02:39.220 --> 02:42.180
Ahora, un nodo es como un waypoint.

02:42.180 --> 02:48.460
Es una posición en tu mapa y puede tener estos bordes que salen de ella.

02:48.460 --> 02:56.050
Así que puede tener tantos bordes como necesite tener el borde de la lista pública.

02:56.050 --> 03:05.920
Así que hacer una lista de todos estos bordes, que será nuestra lista de borde es igual a la nueva lista de borde.

03:06.700 --> 03:12.190
Entonces queremos un nodo público path igual a null.

03:12.190 --> 03:21.970
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á

03:21.970 --> 03:29.950
en nuestra ubicación de la ruta o lo siento, nuestra ubicación del nodo, debería decir el que está

03:29.950 --> 03:32.920
representando donde está.

03:32.920 --> 03:37.750
Si estás usando este gráfico en un tipo de situación diferente, entonces obviamente no tendrías un objeto

03:37.750 --> 03:39.040
de juego asociado a él.

03:39.040 --> 03:40.420
Podrías tener algo más.

03:41.080 --> 03:47.110
Ahora queremos que el público flote su posición x.

03:48.990 --> 04:01.740
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

04:01.740 --> 04:07.080
dónde tiene que moverse nuestro tanque, cuando va a ir a uno de estos

04:07.080 --> 04:08.130
nodos.

04:08.370 --> 04:08.880
De acuerdo.

04:08.880 --> 04:19.020
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

04:19.200 --> 04:21.750
que usaremos más adelante.

04:21.750 --> 04:28.410
Y queremos que un nodo público venga desde ahora.

04:28.410 --> 04:30.930
Esto va a almacenar otro nodo.

04:30.930 --> 04:40.050
Así que si nuestro personaje se ha movido a un nodo en particular, entonces este es el lugar de donde vino para llegar allí.

04:40.320 --> 04:49.230
Bien, ahora queremos un constructor de nodo público, vamos a pasar por el objeto de

04:49.230 --> 05:00.240
juego, AI, y luego dentro de aquí vamos a establecer ID igual a AI y ese es nuestro objeto de juego x pausa

05:00.240 --> 05:16.290
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

05:16.530 --> 05:25.890
transformación posición punto z y luego camino inicialmente va a ser igual a null.

05:25.890 --> 05:30.120
Esto es algo que se irá construyendo a medida que avancemos con la estrella a.

05:30.420 --> 05:40.830
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

05:41.580 --> 05:48.360
objeto del juego para que podamos utilizarlo para comparar contra otros nodos más adelante.

05:49.020 --> 05:51.810
Bien, ese es el nodo.

05:51.810 --> 05:53.010
Así que guarda eso.

05:53.040 --> 06:00.810
Ahora podemos abrir el gráfico, que es donde se va a desarrollar gran parte del trabajo.

06:01.560 --> 06:02.190
De acuerdo.

06:02.190 --> 06:10.050
Así que el gráfico tampoco será un comportamiento mono y los métodos iniciales que están ahí tampoco son necesarios.

06:10.350 --> 06:14.580
En primer lugar, vamos a tener cada gráfico una lista de aristas.

06:14.580 --> 06:23.670
Así que queremos un borde de la lista, vamos a llamarlo bordes es igual a nuevo borde de la lista, al igual que.

06:23.670 --> 06:25.470
Entonces queremos una lista.

06:26.070 --> 06:34.470
Los nodos son iguales a la nueva lista de nodos.

06:35.790 --> 06:43.660
Y también queremos una lista de nodos, que se llamará lista de rutas.

06:43.680 --> 06:49.830
Ahora, esta es la lista que será poblada por el algoritmo aStar, mientras que las otras dos son sólo las

06:49.830 --> 06:52.440
aristas y nodos que existen todo el tiempo.

06:52.590 --> 06:59.250
Así que esta será una nueva lista de nuestra clase de nodo también.

06:59.910 --> 07:00.450
De acuerdo.

07:00.450 --> 07:08.010
Ahora tendremos un constructor gráfico público, que realmente no va a hacer mucho.

07:08.040 --> 07:08.710
Así de fácil.

07:08.730 --> 07:09.000
De acuerdo.

07:09.000 --> 07:18.660
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

07:18.660 --> 07:23.370
a través de la ID del objeto de juego por ahora.

07:23.400 --> 07:24.300
Eso es todo.

07:25.500 --> 07:27.120
Y luego dentro de aquí, iremos.

07:27.120 --> 07:29.850
Nodo es igual a nodo.

07:29.850 --> 07:33.300
El nodo es igual al nuevo nodo.

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

07:37.770 --> 07:43.470
Y luego la lista de nodos punto añadir nodo.

07:45.340 --> 07:45.700
De acuerdo.

07:45.700 --> 07:47.020
Así que eso es añadir nuestro nodo.

07:47.020 --> 07:56.680
Luego, aquí abajo, iremos a public void, añadiremos edge y me permitirán poner una mayúscula por coherencia.

07:56.680 --> 08:00.220
Y dentro de aquí, se crea una arista entre dos nodos.

08:00.220 --> 08:08.770
Así que será objeto del juego desde el nodo, objeto del juego al nodo.

08:09.400 --> 08:17.890
Y entonces nodo de nodo es igual a encontrar nodo de.

08:18.600 --> 08:19.440
Nodo.

08:19.560 --> 08:29.790
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

08:29.790 --> 08:33.600
este nodo para devolverlo como la forma de nodo.

08:33.600 --> 08:38.490
Así que todavía tenemos que escribir, encontrar el nodo y déjame poner una F mayúscula para allí.

08:38.490 --> 08:49.110
Así es como a partir de sin embargo entonces vamos a ir nodo dos, que será igual a nuestro nodo de encontrar a nodo.

08:52.610 --> 08:52.970
De acuerdo.

08:52.970 --> 08:53.980
Volveremos a esto.

08:53.990 --> 08:57.530
Vamos a poner este método de encontrar el nodo.

08:57.530 --> 09:08.480
Así que el nodo encontrar el objeto de juego o ID y vamos a bucle a través de nuestra lista y buscarlo.

09:08.480 --> 09:13.370
Así que para cada nodo n en los nodos.

09:14.690 --> 09:30.440
Si n punto get ID es igual a ID, entonces devolveremos n, de lo contrario devolveremos null.

09:31.850 --> 09:39.560
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,

09:39.560 --> 09:42.040
que es, de hecho, el objeto de juego.

09:42.050 --> 09:44.210
Luego vuelve a subir en el borde de la adición.

09:44.210 --> 09:51.590
Vamos a ir si desde no es igual a null y dos no es igual a null.

09:51.590 --> 09:55.160
Así que estamos comprobando que estos dos nodos existen realmente.

09:55.280 --> 09:56.520
Entonces podemos irnos.

09:56.540 --> 10:11.390
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

10:11.390 --> 10:21.140
de aristas a agregar una así que recuerda que nuestra lista de aristas es lo que tiene nuestro nodo.

10:21.380 --> 10:26.690
Así que estamos añadiendo en el borde que está saliendo de nuestra de justo ahí abajo.

10:26.840 --> 10:27.440
De acuerdo.

10:27.440 --> 10:31.910
Así que este es el inicio de nuestro gráfico.

10:32.180 --> 10:32.600
De acuerdo.

10:32.600 --> 10:37.730
Ahora tengo un pequeño problema que está pasando aquí abajo porque no tengo un corchete de cierre para

10:37.760 --> 10:38.060
eso.

10:38.060 --> 10:40.250
Así que vamos a poner eso para deshacernos de él.

10:40.250 --> 10:47.030
Y ahora puedo guardar eso y terminaremos con esta conferencia porque ya hemos hecho bastante.

10:47.030 --> 10:54.410
La siguiente parte de esto será poner en el un algoritmo de estrella para buscar y encontrar los

10:54.410 --> 10:57.110
caminos de un nodo dado a otro.
