Share
Lo que vas a crearEn este tutorial, exploraremos un enfoque para crear un juego de sokoban o de empujar cajas utilizando una lógica basada en mosaicos y una matriz bidimensional para mantener los datos de nivel. Estamos utilizando Unity para el desarrollo con C # como lenguaje de scripting. Por favor, descargue los archivos fuente provistos con este tutorial para seguirlos.
Puede que haya pocos entre nosotros que no hayan jugado una variante de juego de Sokoban. La versión original puede incluso ser más antigua que algunos de ustedes. Por favor, echa un vistazo a la página wiki para algunos detalles. Esencialmente, tenemos un personaje o elemento controlado por el usuario que tiene que empujar cajas o elementos similares en su mosaico de destino.
El nivel consiste en una cuadrícula cuadrada o rectangular de baldosas donde una baldosa puede ser una no transitable o una transitable. Podemos caminar sobre las baldosas transitables y empujar las cajas sobre ellas. Los azulejos transitables especiales se marcarían como azulejos de destino, que es donde la caja debería eventualmente descansar para completar el nivel. El personaje generalmente se controla mediante un teclado. Una vez que todas las cajas han alcanzado una ficha de destino, el nivel está completo.
El desarrollo basado en mosaicos esencialmente significa que nuestro juego se compone de una serie de mosaicos distribuidos de una manera predeterminada. Un elemento de datos de nivel representará cómo se necesitarían los mosaicos para crear nuestro nivel. En nuestro caso, usaremos una cuadrícula basada en baldosas cuadradas. Puedes leer más sobre juegos basados en azulejos aquí en Envato Tuts+.
Veamos cómo hemos organizado nuestro proyecto Unity para este tutorial..
Para este proyecto tutorial, no estamos usando ningún activo de arte externo, pero usaremos los primitivos de sprites creados con la última versión de Unity 2017.1. La imagen de abajo muestra cómo podemos crear diferentes sprites con forma dentro de Unity..
Usaremos el Cuadrado sprite para representar una sola ficha en nuestra cuadrícula de nivel sokoban. Usaremos el Triángulo sprite para representar a nuestro personaje, y vamos a utilizar el Circulo sprite para representar una caja, o en este caso una bola. Los azulejos de suelo normales son blancos, mientras que los azulejos de destino tienen un color diferente para destacar.
Estaremos representando nuestros datos de nivel en forma de una matriz bidimensional que proporciona la correlación perfecta entre la lógica y los elementos visuales. Utilizamos un archivo de texto simple para almacenar los datos de nivel, lo que nos facilita editar el nivel fuera de Unity o cambiar los niveles simplemente cambiando los archivos cargados. los Recursos carpeta tiene una nivel Archivo de texto, que tiene nuestro nivel por defecto..
1,1,1,1,1,1,1 1,3,1, -1,1,0,1 -1,0,1,2,1,1 -1 -1,1,1,3, 1,3,1 1,1,0, -1,1,1,1
El nivel tiene siete columnas y cinco filas. Un valor de 1 significa que tenemos una baldosa de tierra en esa posición. Un valor de -1 significa que es un azulejo no transitable, mientras que un valor de 0 significa que es una ficha de destino. El valor 2 representa a nuestro héroe, y 3 representa una pelota empujable. Con solo mirar los datos de nivel, podemos visualizar cómo se vería nuestro nivel.
Para mantener las cosas simples, y como no es una lógica muy complicada, solo tenemos una Sokoban.cs archivo de script para el proyecto, y se adjunta a la cámara de escena. Manténgalo abierto en su editor mientras sigue el resto del tutorial..
Los datos de nivel representados por la matriz 2D no solo se usan para crear la cuadrícula inicial, sino que también se usan a lo largo del juego para rastrear los cambios de nivel y el progreso del juego. Esto significa que los valores actuales no son suficientes para representar algunos de los estados de nivel durante el juego.
Cada valor representa el estado del mosaico correspondiente en el nivel. Necesitamos valores adicionales para representar una bola en la ficha de destino y el héroe en la ficha de destino, que respectivamente -3 y -2. Estos valores podrían ser cualquier valor que asigne en el script del juego, no necesariamente los mismos valores que hemos usado aquí.
El primer paso es cargar nuestros datos de nivel en una matriz 2D desde el archivo de texto externo. Usamos el ParseLevel método para cargar el cuerda Valorar y dividirlo para poblar nuestra levelData Matriz 2D.
void ParseLevel () TextAsset textFile = Resources.Load (levelName) como TextAsset; string [] lines = textFile.text.Split (new [] '\ r', '\ n', System.StringSplitOptions.RemoveEmptyEntries); // dividido por nueva línea, devuelve string [] nums = lines [0] .Split (new [] ','); // split by, rows = lines.Length; // número de filas cols = nums.Length; // número de columnas levelData = new int [rows, cols]; para (int i = 0; i < rows; i++) string st = lines[i]; nums = st.Split(new[] ',' ); for (int j = 0; j < cols; j++) int val; if (int.TryParse (nums[j], out val)) levelData[i,j] = val; else levelData[i,j] = invalidTile;
Mientras analizamos, determinamos el número de filas y columnas que tiene nuestro nivel al rellenar nuestro levelData.
Una vez que tenemos nuestros datos de nivel, podemos dibujar nuestro nivel en la pantalla. Usamos el método CreateLevel para hacer precisamente eso..
Accentsconagua
void CreateLevel () // calcula el desplazamiento para alinear todo el nivel con la escena middleOffset.x = cols * tileSize * 0.5f-tileSize * 0.5f; middleOffset.y = rows * tileSize * 0.5f-tileSize * 0.5f ;; Azulejo de GameObject; SpriteRenderer sr; GameObject pelota; int destinationCount = 0; para (int i = 0; i < rows; i++) for (int j = 0; j < cols; j++) int val=levelData[i,j]; if(val!=invalidTile)//a valid tile tile = new GameObject("tile"+i.ToString()+"_"+j.ToString());//create new tile tile.transform.localScale=Vector2.one*(tileSize-1);//set tile size sr = tile.AddComponent(); // agregue un renderizador de sprites sr.sprite = tileSprite; // asigne un sprite de azulejo tile.transform.position = GetScreenPointFromLevelIndices (i, j); // coloque en la escena según los índices de nivel if (val == destinationTile) // si es un mosaico de destino, dale un color diferente sr.color = destinationColor; destinationCount ++; // contar destinos else if (val == heroTile) // the hero hero hero = new GameObject ("hero"); hero.transform.localScale = Vector2.one * (tileSize-1); sr = hero.AddComponent(); sr.sprite = heroSprite; sr.sortingOrder = 1; // el héroe debe estar sobre el mosaico del suelo sr.color = Color.red; hero.transform.position = GetScreenPointFromLevelIndices (i, j); occupants.Add (hero, new Vector2 (i, j)); // almacena los índices de nivel de hero en dict else if (val == ballTile) // ball tile ballCount ++; // incrementa el número de bolas en level ball = nuevo GameObject ("ball" + ballCount.ToString ()); ball.transform.localScale = Vector2.one * (tileSize-1); sr = ball.AddComponent(); sr.sprite = ballSprite; sr.sortingOrder = 1; // la bola debe estar sobre el azulejo del suelo sr.color = Color.black; ball.transform.position = GetScreenPointFromLevelIndices (i, j); occupants.Add (ball, nuevo Vector2 (i, j)); // almacena los índices de nivel de ball en dict if (ballCount> destinationCount) Debug.LogError ("hay más bolas que destinos"); Para nuestro nivel, hemos establecido un tamaño del azulejo valor de 50, que es la longitud del lado de un azulejo cuadrado en nuestra cuadrícula de nivel. Recorremos nuestra matriz 2D y determinamos el valor almacenado en cada uno de los yo y j Índices de la matriz. Si este valor no es un invalidTile (-1) luego creamos una nueva GameObject llamado azulejo. Adjuntamos un SpriteRenderer componente a azulejo y asignar las correspondientes Duende o Color Dependiendo del valor en el índice de matriz.
Mientras se coloca el héroe o la bola, Primero debemos crear un mosaico de suelo y luego crear estos mosaicos. Como el héroe y la bola deben superponerse a la baldosa del suelo, damos su SpriteRenderer una mayor ordenando. A todas las fichas se les asigna un Escala local de tamaño del azulejo entonces ellos son 50x50 en nuestra escena.
Realizamos un seguimiento del número de bolas en nuestra escena utilizando el ballCount variable, y debería haber el mismo o un mayor número de casillas de destino en nuestro nivel para que sea posible completar el nivel. La magia ocurre en una sola línea de código donde determinamos la posición de cada ficha usando el GetScreenPointFromLevelIndices (int row, int col) método.
//… tile.transform.position = GetScreenPointFromLevelIndices (i, j); // colocar en escena según los índices de nivel // ... Vector2 GetScreenPointFromLevelIndices (int row, int col) // convertir los índices en valores de posición, col determina x & la fila determina y devuelve el nuevo Vector2 (col * tileSize-middleOffset.x, row * -tileSize + middleOffset.y);
La posición mundial de una baldosa se determina multiplicando los índices de nivel con el tamaño del azulejo valor. los middleOffset La variable se usa para alinear el nivel en el centro de la pantalla. Tenga en cuenta que el fila El valor se multiplica por un valor negativo para respaldar la inversión invertida. y eje en la unidad.
Ahora que hemos mostrado nuestro nivel, procedamos a la lógica del juego. Necesitamos escuchar la entrada de la tecla del usuario y mover la héroe basado en la entrada. La pulsación de tecla determina una dirección de movimiento requerida, y la héroe necesita ser movido en esa dirección Hay varios escenarios a considerar una vez que hayamos determinado la dirección de movimiento requerida. Digamos que la baldosa al lado de héroe en esta dirección es azulejo.
Si la posición de tileK está fuera de la cuadrícula, no necesitamos hacer nada. Si tileK es válido y es manejable, entonces debemos movernos héroe a esa posición y actualizar nuestra levelData formación. Si tileK tiene una bola, entonces debemos considerar al próximo vecino en la misma dirección, digamos azulejo.
Solo en el caso de que tileL sea una baldosa no ocupable transitable, deberíamos mover la héroe y la bola en tileK a tileK y tileL respectivamente. Después de un movimiento exitoso, necesitamos actualizar el levelData formación.
La lógica anterior significa que necesitamos saber qué mosaico nuestro héroe se encuentra actualmente en. También debemos determinar si una determinada ficha tiene una bola y debería tener acceso a esa bola.
Para facilitar esto, utilizamos un Diccionario llamado ocupantes que almacena un GameObject como clave y sus índices de matriz almacenados como Vector2 como valor. En el CrearNivel método, poblamos ocupantes cuando creamos héroe o pelota Una vez que tenemos el diccionario poblado, podemos usar el GetOccupantAtPosition para recuperar el GameObject en un índice de matriz dado.
