De acuerdo.
¿Cómo está afrontando la Semana Santa hasta ahora?
Bueno, aún no hemos entrado en el código.
Y hay un montón de código que tenemos que escribir.
Pero espero que te resulte bastante familiar porque hemos repasado todo lo básico y
cómo funciona.
Así que vamos a empezar ahora dentro de esta clase.
En primer lugar, tenemos que agarrar nuestro laberinto real para poder obtener su mapa.
Así que laberinto público, laberinto.
Ahora, esto va a ser un poco de una combinación entre la ejecución real del algoritmo y luego también mostrarlo,
visualizarlo en la pantalla.
Así que vamos a tener algunas construcciones que son sólo para todo el cálculo de números
y todo y luego otros que van a mostrar las cosas para usted.
De acuerdo.
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
a otro, ya que se procesan.
Así que material, material cerrado.
Y probablemente puedas adivinar cuál es el siguiente, material público, material abierto.
A continuación, tenemos que crear nuestras dos listas abiertas y cerradas.
Así que vamos a tener una lista de marcadores de ruta.
Cuatro Abrir equivale a un nuevo marcador de ruta de la lista.
Y también necesitamos uno para la ropa.
Así que vamos a copiar eso.
Y que esto esté cerrado.
Y luego tenemos que traer nuestros objetos de juego que van a ser nuestros marcadores físicos reales en el mapa
que podemos ver.
Así que el objeto de juego público.
Comienza.
Objeto de juego público y.
Y público.
Juego.
Objeto.
Camino.
Punto o marcador de ruta o lo que sea.
De acuerdo.
Voy a llamarlo así.
Así que vamos a guardar esto y vamos a cambiar de nuevo en la unidad.
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
en allí.
Ahora vamos a rellenar estos elementos en el script.
Así que el laberinto es el script que está generando el laberinto, que es este script recursivo.
Así que arrastra eso hasta allí.
A continuación, tenemos un inicio y un final y nuestro camino p marcadores, así como un material cerrado y abierto.
Ahora adjunto a esta conferencia hay un pequeño paquete de unity con algunos materiales y prefabricados en él.
Si lo traes, verás que obtienes una carpeta de modelos aquí que tiene materiales y prefabricados.
Así que si vamos a nuestros prefabricados primero y luego seleccionamos nuestro laberinto, podemos poner el objeto de
inicio en el inicio, el final en el final, y luego el marcador de camino en el camino.
P Ahora también podemos establecer nuestros materiales para los nodos cerrados y abiertos a medida que avanzamos.
Así que para el cerrado voy a usar el rojo y para el abierto el verde.
Así que esto hará que todo sea más visual para que puedas ver exactamente lo que está pasando cuando el algoritmo de la
estrella comienza a trabajar.
Bien, ahora volvamos a nuestro código.
Ahora, estas tres cosas son nuestros objetos de juego que vamos a instanciar y luego mantenerlos dentro
de los objetos marcadores de ruta.
Así que crearemos un marcador de ruta para el nodo dorado y también crearemos uno para el inicio.
Así que marcador de camino, empieza.
Nodo.
También necesitaremos otro marcador de camino.
Y este camino, marca, va a mantener el seguimiento del último punto en el que estamos, por lo que la última posición
en este caso.
Y también vamos a hacer un seguimiento de un toro llamado Done, que será verdadero cuando hayamos encontrado el
camino hasta el final de la ruta.
Así que vamos a establecer inicialmente esto a falso como eso.
¿De acuerdo?
Así que eso es todo lo que necesitamos en la parte superior, todas nuestras variables.
Muy bien.
Así que voy a guardar eso de nuevo, cambiar de nuevo a Unity y mostrarte algo antes de continuar.
Así que si entramos en nuestros prefabricados donde tengo estos marcadores y simplemente hacemos clic en uno, si
vas al inspector, verás que están etiquetados como marcador.
Lo he hecho para que podamos eliminarlos con una pulsación de tecla fuera del mapa, lo que será útil en un
momento.
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,
lo que significa que usted puede tener un poco de un juego alrededor con él y acostumbrarse
a los resultados.
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
destruye todo.
Así que objeto del juego.
Un rayo de Marcus.
Equivale a los objetos del juego.
Encuentra los objetos del juego con.
Etiqueta.
Asegúrate de utilizar los objetos del juego con el SE y eso será un marcador.
De acuerdo.
Y luego haremos un rápido luego haremos un rápido para cada objeto de juego m marcador en marcadores.
Destrúyelos.
Así que se llamará en breve.
Muy bien, ahora vamos a empezar nuestra búsqueda.
Tan nulo.
Comienza, busca.
Permitiremos que esto se llame una y otra vez, como dije antes.
Así que cada vez que lo hagamos, vamos a poner done igual a false.
Y entonces correremos.
Retire todos los marcadores.
De acuerdo.
Así que ahora podemos ir creando nuestros objetivos y todo eso.
Así que, en primer lugar, tenemos que elegir dos posiciones en el laberinto real que van a ser nuestro inicio y final.
Y podríamos hacerlo de forma bastante aleatoria, en la que vamos eligiendo valores al azar y viendo si son un espacio
o una pared y, por supuesto, utilizar el espacio.
Una mejor manera es poner todos los espacios o todas las ubicaciones del laberinto que no son una pared en una pequeña
lista.
Baraja esa lista usando el método de barajar que encontrarás en el archivo de extensiones y luego como escogerlas
de la parte superior.
Así que voy a crear una lista de ubicaciones del mapa, y que va a ser llamado Ubicaciones Igual a la nueva
lista.
Ubicación en el mapa.
De acuerdo.
A continuación, vamos a crear nuestros bucles anidados para hacer un bucle alrededor de nuestro mapa.
Así que si queremos para int z es igual a uno a Z es menor que nuestra profundidad del laberinto.
Menos uno y luego Z más.
Además.
Lo mismo para.
X.
Así que cambiemos eso por X y X.
Y en este caso, queremos que nuestro ancho y hacer que x.
Y dentro de aquí vamos a probar si puede dejar de mapa para que x.
Z no es igual a uno, entonces lo pondremos en nuestra lista.
El punto de ubicación añade una nueva ubicación en el mapa.
X.
Z.
Entonces, ¿por qué usamos no es igual a uno en este código?
Bueno, en el código de los ratones, si echas un vistazo allí y el algoritmo recursivo que está escribiendo
en los laberintos que estamos generando, hay un valor de cero donde hay un espacio vacío y un uno donde
hay una pared.
Sin embargo, cuando estás creando laberintos, puedes tener otros valores que representen otras cosas dentro
de esa área del laberinto.
Así que sólo nos preocupa realmente si hay un muro en este momento en cuanto a dónde podemos movernos.
Y es por eso que aquí usamos no igual a uno.
Así que sabemos que los unos son las paredes y las posiciones iniciales pueden ser cualquier otro valor en este momento.
Así que por eso tengo no igual a uno.
Así que pero el tiempo que hemos pasado por esto, ahora tenemos todos estos lugares.
Y así, si los barajamos, las ubicaciones se barajan.
Eso nos va a dar un par de valores en la parte superior de esa lista que podemos seguir adelante y arrancar y utilizar
como la ubicación de la meta y también como la ubicación de partida.
Así que vamos a hacerlo.
Así que después de la baraja, voy a crear un vector tres, que será nuestra ubicación de inicio.
Y vamos a establecer que a un nuevo vector tres y para obtener los valores,
vamos a arrancar, como he dicho, la ubicación y vamos a darle ubicaciones en la posición cero punto X y luego
podemos simplemente poner cero para el valor Y y ubicaciones, cero para la posición Z.
Ahora vamos a poner el cero como la altura porque he hecho eso con casi todo
lo que estamos poniendo a cero como una superficie plana.
Así que es básicamente una especie de dos D al menos.
Y una vez que tengamos esta ubicación, vamos a instanciar nuestro primer nodo en esa ubicación.
Así que voy a crear un nodo de inicio.
Y eso va a equivaler a un nuevo marcador de camino.
Que será un nuevo mapa.
Ubicación, ubicaciones cero punto X, ubicaciones cero punto Z.
Así que los mismos usos que está utilizando para la posición.
Y luego vamos a enviar a través de un cero, entonces vamos a cero nuestra G, nuestra H y nuestros valores F.
Y para el marcador del juego, acabo de bajar una línea para no salirme de la pantalla por ti.
Vamos a instanciar el inicio.
Comienza.
Ubicación.
Y entonces pondremos a Gatito en la identidad de punto para la rotación porque eso no es realmente importante.
Y por último, el padre va a ser nulo.
Así que lo pondremos ahí.
Y para la ubicación de la meta, hacemos lo mismo.
Así que voy a copiar todo eso, para ahorrarme escribirlo de nuevo, ponerlo aquí abajo, asegurarme
de que estamos hablando de la ubicación de la meta, la posición de la ubicación de la meta.
Vamos a usar eso como el segundo valor en esa matriz de ubicaciones que barajamos.
Así que vamos a establecer todos esos valores allí a uno.
Y luego este nodo de aquí abajo va a ser nuestro nodo meta.
Ahora, al mismo tiempo que creamos el marcador de ruta, vamos a instanciar esos prefabricados.
Así que este de aquí va a ser en realidad el prefabricado final que enviamos antes.
¿De acuerdo?
Así que ahora podemos correr, comenzar, buscar y podremos ver esos marcadores aparecer.
Así que voy a hacer eso en la actualización.
Así que aquí, vamos a poner si el punto de entrada obtener la clave hacia abajo es el código clave punto p.
Entonces haremos una búsqueda de gangas.
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í
utiliza una escala para que sea más grande en la pantalla para que usted pueda realmente llevar a cabo y las posiciones reales
en el mapa allí.
Bien, no necesitan ser escalados.
Todavía están en posiciones de unidades ligeras.
Pero nuestra ubicación de inicio y nuestra ubicación de meta necesitan ser escaladas de acuerdo a lo que la escala del mapa
se establece.
Así que para los valores reales del mapa, no estamos escalando esos por la escala del mapa, pero para cualquier posicionamiento
que hacemos de los objetos.
Así que lo que voy a hacer aquí es poner en multiplicar.
Escala de puntos del maíz.
Y luego queremos usar ese valor allí y ponerlo para nuestra ubicación Z y también para nuestra ubicación de la meta
aquí.
De acuerdo.
Sí.
Así que ahora nos va a dar una mejor ubicación.
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
de la meta.
De acuerdo.
Así que guardemos eso.
Ahora volveremos a la unidad.
Vamos a echar un vistazo al laberinto un segundo antes de pulsar el play.
Y en este caso, puedes ver que mi script recursivo tiene el tamaño del mapa en 30 por 30.
Podrías dejarlo así de grande, pero tardarás en encontrar un camino por ahí.
Así que lo que recomiendo es que lo reduzcas a diez y diez, para que sea un laberinto de tamaño manejable.
Bien, ahora si le damos al play, podremos ver aparecer nuestro pequeño laberinto.
Ahí está para que puedas ir y enfocar en él.
Y si pulsamos la tecla P, asegúrate de que has hecho clic en la ventana del juego para que se active.
Pulsa la tecla P y verás que te aparecen tus posiciones de inicio ahí porque recuerda que las estamos estableciendo
aleatoriamente y no hay nada más entre sólo crearlas.
De acuerdo.
Así puedes ver muy claramente dónde tienes que empezar y dónde vas a terminar.
De acuerdo.
Voy a dejar este vídeo aquí por ahora.
Cuando volvamos, seguiremos trabajando en el algoritmo aStar para hacer un pathfinding.