WEBVTT

00:02.330 --> 00:02.860
De acuerdo.

00:02.870 --> 00:05.720
¿Cómo está afrontando la Semana Santa hasta ahora?

00:05.750 --> 00:07.400
Bueno, aún no hemos entrado en el código.

00:07.400 --> 00:10.370
Y hay un montón de código que tenemos que escribir.

00:10.370 --> 00:15.290
Pero espero que te resulte bastante familiar porque hemos repasado todo lo básico y

00:15.290 --> 00:16.220
cómo funciona.

00:16.460 --> 00:20.500
Así que vamos a empezar ahora dentro de esta clase.

00:20.510 --> 00:26.060
En primer lugar, tenemos que agarrar nuestro laberinto real para poder obtener su mapa.

00:26.060 --> 00:29.300
Así que laberinto público, laberinto.

00:29.960 --> 00:38.570
Ahora, esto va a ser un poco de una combinación entre la ejecución real del algoritmo y luego también mostrarlo,

00:38.570 --> 00:42.170
visualizarlo en la pantalla.

00:42.170 --> 00:46.970
Así que vamos a tener algunas construcciones que son sólo para todo el cálculo de números

00:46.970 --> 00:50.600
y todo y luego otros que van a mostrar las cosas para usted.

00:50.630 --> 00:50.880
De acuerdo.

00:50.930 --> 00:57.050
Así que en primer lugar, sólo voy a añadir en dos materiales que vamos a utilizar para cambiar nuestros nodos de un color

00:57.050 --> 00:58.790
a otro, ya que se procesan.

00:58.790 --> 01:02.390
Así que material, material cerrado.

01:03.830 --> 01:10.370
Y probablemente puedas adivinar cuál es el siguiente, material público, material abierto.

01:11.630 --> 01:18.170
A continuación, tenemos que crear nuestras dos listas abiertas y cerradas.

01:18.800 --> 01:24.470
Así que vamos a tener una lista de marcadores de ruta.

01:27.280 --> 01:33.910
Cuatro Abrir equivale a un nuevo marcador de ruta de la lista.

01:37.000 --> 01:39.700
Y también necesitamos uno para la ropa.

01:39.700 --> 01:41.830
Así que vamos a copiar eso.

01:43.600 --> 01:46.450
Y que esto esté cerrado.

01:47.290 --> 01:53.560
Y luego tenemos que traer nuestros objetos de juego que van a ser nuestros marcadores físicos reales en el mapa

01:53.560 --> 01:54.550
que podemos ver.

01:54.550 --> 01:58.600
Así que el objeto de juego público.

02:00.100 --> 02:01.030
Comienza.

02:02.450 --> 02:07.010
Objeto de juego público y.

02:07.520 --> 02:09.260
Y público.

02:09.410 --> 02:09.830
Juego.

02:09.830 --> 02:10.760
Objeto.

02:10.760 --> 02:11.750
Camino.

02:13.500 --> 02:16.690
Punto o marcador de ruta o lo que sea.

02:16.710 --> 02:17.180
De acuerdo.

02:17.190 --> 02:18.090
Voy a llamarlo así.

02:18.090 --> 02:22.140
Así que vamos a guardar esto y vamos a cambiar de nuevo en la unidad.

02:22.650 --> 02:29.670
Y queremos ir al objeto del Juego del Laberinto en la jerarquía y arrastrar y soltar encontrar el camino un script de la estrella

02:29.670 --> 02:30.690
en allí.

02:30.840 --> 02:35.190
Ahora vamos a rellenar estos elementos en el script.

02:35.190 --> 02:41.100
Así que el laberinto es el script que está generando el laberinto, que es este script recursivo.

02:41.100 --> 02:44.190
Así que arrastra eso hasta allí.

02:44.730 --> 02:53.280
A continuación, tenemos un inicio y un final y nuestro camino p marcadores, así como un material cerrado y abierto.

02:53.280 --> 02:59.610
Ahora adjunto a esta conferencia hay un pequeño paquete de unity con algunos materiales y prefabricados en él.

02:59.610 --> 03:06.510
Si lo traes, verás que obtienes una carpeta de modelos aquí que tiene materiales y prefabricados.

03:06.900 --> 03:16.110
Así que si vamos a nuestros prefabricados primero y luego seleccionamos nuestro laberinto, podemos poner el objeto de

03:16.200 --> 03:22.740
inicio en el inicio, el final en el final, y luego el marcador de camino en el camino.

03:22.740 --> 03:32.250
P Ahora también podemos establecer nuestros materiales para los nodos cerrados y abiertos a medida que avanzamos.

03:32.250 --> 03:39.180
Así que para el cerrado voy a usar el rojo y para el abierto el verde.

03:39.180 --> 03:45.960
Así que esto hará que todo sea más visual para que puedas ver exactamente lo que está pasando cuando el algoritmo de la

03:46.200 --> 03:48.120
estrella comienza a trabajar.

03:48.540 --> 03:52.590
Bien, ahora volvamos a nuestro código.

03:53.250 --> 03:59.760
Ahora, estas tres cosas son nuestros objetos de juego que vamos a instanciar y luego mantenerlos dentro

03:59.760 --> 04:02.460
de los objetos marcadores de ruta.

04:02.820 --> 04:12.630
Así que crearemos un marcador de ruta para el nodo dorado y también crearemos uno para el inicio.

04:12.630 --> 04:17.280
Así que marcador de camino, empieza.

04:17.880 --> 04:18.810
Nodo.

04:19.740 --> 04:22.350
También necesitaremos otro marcador de camino.

04:22.590 --> 04:29.670
Y este camino, marca, va a mantener el seguimiento del último punto en el que estamos, por lo que la última posición

04:29.670 --> 04:30.690
en este caso.

04:30.990 --> 04:38.670
Y también vamos a hacer un seguimiento de un toro llamado Done, que será verdadero cuando hayamos encontrado el

04:38.670 --> 04:41.100
camino hasta el final de la ruta.

04:41.100 --> 04:45.000
Así que vamos a establecer inicialmente esto a falso como eso.

04:45.000 --> 04:45.240
¿De acuerdo?

04:45.240 --> 04:50.940
Así que eso es todo lo que necesitamos en la parte superior, todas nuestras variables.

04:51.120 --> 04:51.540
Muy bien.

04:51.540 --> 04:56.610
Así que voy a guardar eso de nuevo, cambiar de nuevo a Unity y mostrarte algo antes de continuar.

04:56.610 --> 05:04.140
Así que si entramos en nuestros prefabricados donde tengo estos marcadores y simplemente hacemos clic en uno, si

05:04.140 --> 05:08.490
vas al inspector, verás que están etiquetados como marcador.

05:08.670 --> 05:16.470
Lo he hecho para que podamos eliminarlos con una pulsación de tecla fuera del mapa, lo que será útil en un

05:16.470 --> 05:17.280
momento.

05:17.640 --> 05:25.770
Así que lo que vamos a hacer es tener la capacidad de ser capaz de eliminar todos ellos y luego hacer el ASR una y otra vez sin reiniciar nuestro código,

05:25.770 --> 05:30.540
lo que significa que usted puede tener un poco de un juego alrededor con él y acostumbrarse

05:30.540 --> 05:32.370
a los resultados.

05:32.520 --> 05:41.430
Así que vamos a crear un vacío, eliminar todos los marcadores, y esto es sólo va a ser un bucle muy rápido que sólo

05:41.430 --> 05:42.780
destruye todo.

05:42.780 --> 05:44.700
Así que objeto del juego.

05:46.750 --> 05:49.030
Un rayo de Marcus.

05:50.980 --> 05:53.280
Equivale a los objetos del juego.

05:53.420 --> 05:57.040
Encuentra los objetos del juego con.

06:00.230 --> 06:00.770
Etiqueta.

06:00.770 --> 06:05.530
Asegúrate de utilizar los objetos del juego con el SE y eso será un marcador.

06:07.450 --> 06:07.870
De acuerdo.

06:07.870 --> 06:20.980
Y luego haremos un rápido luego haremos un rápido para cada objeto de juego m marcador en marcadores.

06:24.240 --> 06:26.100
Destrúyelos.

06:27.870 --> 06:30.750
Así que se llamará en breve.

06:31.110 --> 06:33.720
Muy bien, ahora vamos a empezar nuestra búsqueda.

06:33.720 --> 06:34.890
Tan nulo.

06:35.610 --> 06:37.560
Comienza, busca.

06:37.770 --> 06:42.990
Permitiremos que esto se llame una y otra vez, como dije antes.

06:42.990 --> 06:46.860
Así que cada vez que lo hagamos, vamos a poner done igual a false.

06:48.540 --> 06:50.010
Y entonces correremos.

06:50.010 --> 06:53.910
Retire todos los marcadores.

06:56.770 --> 06:57.460
De acuerdo.

06:57.460 --> 07:02.170
Así que ahora podemos ir creando nuestros objetivos y todo eso.

07:02.950 --> 07:13.030
Así que, en primer lugar, tenemos que elegir dos posiciones en el laberinto real que van a ser nuestro inicio y final.

07:13.030 --> 07:19.840
Y podríamos hacerlo de forma bastante aleatoria, en la que vamos eligiendo valores al azar y viendo si son un espacio

07:19.840 --> 07:23.440
o una pared y, por supuesto, utilizar el espacio.

07:23.560 --> 07:30.760
Una mejor manera es poner todos los espacios o todas las ubicaciones del laberinto que no son una pared en una pequeña

07:30.760 --> 07:31.690
lista.

07:31.720 --> 07:38.050
Baraja esa lista usando el método de barajar que encontrarás en el archivo de extensiones y luego como escogerlas

07:38.050 --> 07:39.280
de la parte superior.

07:39.640 --> 07:50.950
Así que voy a crear una lista de ubicaciones del mapa, y que va a ser llamado Ubicaciones Igual a la nueva

07:51.700 --> 07:52.720
lista.

07:53.810 --> 07:56.120
Ubicación en el mapa.

07:58.390 --> 07:58.640
De acuerdo.

07:58.720 --> 08:04.030
A continuación, vamos a crear nuestros bucles anidados para hacer un bucle alrededor de nuestro mapa.

08:04.030 --> 08:12.940
Así que si queremos para int z es igual a uno a Z es menor que nuestra profundidad del laberinto.

08:14.590 --> 08:18.070
Menos uno y luego Z más.

08:18.070 --> 08:18.750
Además.

08:18.820 --> 08:20.560
Lo mismo para.

08:21.830 --> 08:22.800
X.

08:23.510 --> 08:27.080
Así que cambiemos eso por X y X.

08:27.080 --> 08:32.420
Y en este caso, queremos que nuestro ancho y hacer que x.

08:32.420 --> 08:41.750
Y dentro de aquí vamos a probar si puede dejar de mapa para que x.

08:41.990 --> 08:47.750
Z no es igual a uno, entonces lo pondremos en nuestra lista.

08:48.170 --> 08:55.550
El punto de ubicación añade una nueva ubicación en el mapa.

08:56.770 --> 08:57.580
X.

08:57.610 --> 08:58.420
Z.

08:59.050 --> 09:03.640
Entonces, ¿por qué usamos no es igual a uno en este código?

09:03.670 --> 09:09.520
Bueno, en el código de los ratones, si echas un vistazo allí y el algoritmo recursivo que está escribiendo

09:09.730 --> 09:15.340
en los laberintos que estamos generando, hay un valor de cero donde hay un espacio vacío y un uno donde

09:15.340 --> 09:16.570
hay una pared.

09:16.600 --> 09:22.660
Sin embargo, cuando estás creando laberintos, puedes tener otros valores que representen otras cosas dentro

09:22.660 --> 09:24.140
de esa área del laberinto.

09:24.160 --> 09:30.730
Así que sólo nos preocupa realmente si hay un muro en este momento en cuanto a dónde podemos movernos.

09:30.730 --> 09:35.600
Y es por eso que aquí usamos no igual a uno.

09:35.620 --> 09:44.230
Así que sabemos que los unos son las paredes y las posiciones iniciales pueden ser cualquier otro valor en este momento.

09:44.230 --> 09:46.530
Así que por eso tengo no igual a uno.

09:46.540 --> 09:50.890
Así que pero el tiempo que hemos pasado por esto, ahora tenemos todos estos lugares.

09:50.890 --> 09:56.080
Y así, si los barajamos, las ubicaciones se barajan.

09:57.690 --> 10:04.920
Eso nos va a dar un par de valores en la parte superior de esa lista que podemos seguir adelante y arrancar y utilizar

10:04.920 --> 10:09.630
como la ubicación de la meta y también como la ubicación de partida.

10:10.680 --> 10:12.570
Así que vamos a hacerlo.

10:12.570 --> 10:18.930
Así que después de la baraja, voy a crear un vector tres, que será nuestra ubicación de inicio.

10:20.660 --> 10:27.320
Y vamos a establecer que a un nuevo vector tres y para obtener los valores,

10:27.320 --> 10:36.830
vamos a arrancar, como he dicho, la ubicación y vamos a darle ubicaciones en la posición cero punto X y luego

10:36.830 --> 10:44.990
podemos simplemente poner cero para el valor Y y ubicaciones, cero para la posición Z.

10:45.320 --> 10:49.910
Ahora vamos a poner el cero como la altura porque he hecho eso con casi todo

10:49.910 --> 10:53.600
lo que estamos poniendo a cero como una superficie plana.

10:53.900 --> 10:57.260
Así que es básicamente una especie de dos D al menos.

10:57.410 --> 11:04.550
Y una vez que tengamos esta ubicación, vamos a instanciar nuestro primer nodo en esa ubicación.

11:04.550 --> 11:07.190
Así que voy a crear un nodo de inicio.

11:09.690 --> 11:14.310
Y eso va a equivaler a un nuevo marcador de camino.

11:15.490 --> 11:18.370
Que será un nuevo mapa.

11:19.490 --> 11:28.310
Ubicación, ubicaciones cero punto X, ubicaciones cero punto Z.

11:28.310 --> 11:31.100
Así que los mismos usos que está utilizando para la posición.

11:31.160 --> 11:41.480
Y luego vamos a enviar a través de un cero, entonces vamos a cero nuestra G, nuestra H y nuestros valores F.

11:41.750 --> 11:48.320
Y para el marcador del juego, acabo de bajar una línea para no salirme de la pantalla por ti.

11:48.560 --> 11:53.900
Vamos a instanciar el inicio.

11:54.620 --> 11:55.640
Comienza.

11:57.130 --> 11:58.570
Ubicación.

11:59.830 --> 12:08.350
Y entonces pondremos a Gatito en la identidad de punto para la rotación porque eso no es realmente importante.

12:08.440 --> 12:11.260
Y por último, el padre va a ser nulo.

12:11.260 --> 12:12.730
Así que lo pondremos ahí.

12:12.730 --> 12:16.000
Y para la ubicación de la meta, hacemos lo mismo.

12:16.240 --> 12:22.180
Así que voy a copiar todo eso, para ahorrarme escribirlo de nuevo, ponerlo aquí abajo, asegurarme

12:22.180 --> 12:28.210
de que estamos hablando de la ubicación de la meta, la posición de la ubicación de la meta.

12:28.210 --> 12:33.850
Vamos a usar eso como el segundo valor en esa matriz de ubicaciones que barajamos.

12:33.850 --> 12:36.250
Así que vamos a establecer todos esos valores allí a uno.

12:36.400 --> 12:41.470
Y luego este nodo de aquí abajo va a ser nuestro nodo meta.

12:41.740 --> 12:50.020
Ahora, al mismo tiempo que creamos el marcador de ruta, vamos a instanciar esos prefabricados.

12:50.320 --> 12:56.170
Así que este de aquí va a ser en realidad el prefabricado final que enviamos antes.

12:56.470 --> 12:57.040
¿De acuerdo?

12:57.040 --> 13:03.760
Así que ahora podemos correr, comenzar, buscar y podremos ver esos marcadores aparecer.

13:03.760 --> 13:06.310
Así que voy a hacer eso en la actualización.

13:06.310 --> 13:19.030
Así que aquí, vamos a poner si el punto de entrada obtener la clave hacia abajo es el código clave punto p.

13:20.190 --> 13:23.390
Entonces haremos una búsqueda de gangas.

13:23.850 --> 13:32.070
Ahora, un pequeño ajuste que tenemos que hacer a este código es añadir en un valor de escala porque el laberinto en sí

13:32.070 --> 13:40.770
utiliza una escala para que sea más grande en la pantalla para que usted pueda realmente llevar a cabo y las posiciones reales

13:40.770 --> 13:42.150
en el mapa allí.

13:42.150 --> 13:43.620
Bien, no necesitan ser escalados.

13:43.620 --> 13:45.870
Todavía están en posiciones de unidades ligeras.

13:45.870 --> 13:52.530
Pero nuestra ubicación de inicio y nuestra ubicación de meta necesitan ser escaladas de acuerdo a lo que la escala del mapa

13:52.530 --> 13:53.560
se establece.

13:53.790 --> 14:00.540
Así que para los valores reales del mapa, no estamos escalando esos por la escala del mapa, pero para cualquier posicionamiento

14:00.540 --> 14:02.280
que hacemos de los objetos.

14:02.280 --> 14:06.420
Así que lo que voy a hacer aquí es poner en multiplicar.

14:08.180 --> 14:10.940
Escala de puntos del maíz.

14:11.390 --> 14:20.090
Y luego queremos usar ese valor allí y ponerlo para nuestra ubicación Z y también para nuestra ubicación de la meta

14:20.090 --> 14:20.900
aquí.

14:21.920 --> 14:22.720
De acuerdo.

14:22.730 --> 14:23.090
Sí.

14:23.090 --> 14:27.440
Así que ahora nos va a dar una mejor ubicación.

14:27.590 --> 14:33.500
También me acabo de dar cuenta de que debería haber ubicación de la meta allí también, para que podamos ver la meta en la ubicación

14:33.500 --> 14:34.460
de la meta.

14:34.490 --> 14:34.790
De acuerdo.

14:34.790 --> 14:35.910
Así que guardemos eso.

14:35.930 --> 14:38.120
Ahora volveremos a la unidad.

14:38.120 --> 14:41.870
Vamos a echar un vistazo al laberinto un segundo antes de pulsar el play.

14:42.140 --> 14:49.220
Y en este caso, puedes ver que mi script recursivo tiene el tamaño del mapa en 30 por 30.

14:49.490 --> 14:54.260
Podrías dejarlo así de grande, pero tardarás en encontrar un camino por ahí.

14:54.260 --> 15:03.320
Así que lo que recomiendo es que lo reduzcas a diez y diez, para que sea un laberinto de tamaño manejable.

15:03.470 --> 15:09.890
Bien, ahora si le damos al play, podremos ver aparecer nuestro pequeño laberinto.

15:09.890 --> 15:12.980
Ahí está para que puedas ir y enfocar en él.

15:13.640 --> 15:20.120
Y si pulsamos la tecla P, asegúrate de que has hecho clic en la ventana del juego para que se active.

15:20.150 --> 15:29.450
Pulsa la tecla P y verás que te aparecen tus posiciones de inicio ahí porque recuerda que las estamos estableciendo

15:29.450 --> 15:35.570
aleatoriamente y no hay nada más entre sólo crearlas.

15:35.740 --> 15:36.030
De acuerdo.

15:36.080 --> 15:41.840
Así puedes ver muy claramente dónde tienes que empezar y dónde vas a terminar.

15:41.870 --> 15:42.170
De acuerdo.

15:42.170 --> 15:44.410
Voy a dejar este vídeo aquí por ahora.

15:44.420 --> 15:51.500
Cuando volvamos, seguiremos trabajando en el algoritmo aStar para hacer un pathfinding.
