En esta serie de tutoriales que se va a construir un multijugador Bomberman juego. Nuestro juego tendrá una escena título, lo que permitirá a los jugadores crear o unirse a los juegos. Además, tendrá una escena de batalla, donde los jugadores podrán luchar entre sí en un modo competitivo.

En este primer tutorial vamos a construir la infraestructura básica para nuestro juego, como el título y las escenas de la batalla, así como la adición al jugador en nuestro juego. En las próximas vamos a seguir añadiendo características a la misma.

Con el fin de seguir este tutorial, que se espera que esté familiarizado con los siguientes conceptos:


  • programación C #
  • conceptos unidad básica, como la importación de bienes, la creación de casas prefabricadas y la adición de componentes
  • Básico baldosa creación de mapas, tales como la adición de un juego de fichas y la creación de capas de mosaicos

    Antes de comenzar a leer el tutorial, crear un nuevo proyecto de la Unidad y la importación de todos los sprites disponibles a través del código fuente.
    No se pierda! extremos de la oferta en

    • Accede a los más de 200 cursos
    • Nuevos cursos añadió mensual
    • Cancelar en cualquier momento
    • Los certificados de terminación

      ACCESO ahora

      Indice

      Activos de derechos de autor

      Los activos utilizados en este tutorial fueron creados por Cem Kalyoncu / cemkalyoncu y Matt Hackett / richtaur y puestos a disposición por “usr_share” a través de los campos comunes creativos licencia, cosa que permite el uso comercial bajo la atribución. Puede descargarlos en http://opengameart.org/content/bomb-party-the-complete-set o descargando el código fuente.

      archivos de código fuente

      Puede descargar los archivos de código fuente tutorial aquí.

      rebanar spritesheets

      Una vez que haya importado los sprites desde el código fuente, se puede observar que algunos de esos sprites son simplemente imágenes, mientras que otros son spritesheets. Las imágenes que ya son buenos para ser utilizado, pero tenemos que cortar las spritesheets en tramas.

      La forma de hacerlo es mediante la selección de la spritesheet en el editor, a continuación, cambiar su modo de Sprite a múltiples. A continuación, podemos hacer clic en el botón Sprite Editor para cortarlo.


      Una vez que haya abierto la ventana Sprite Editor, el botón rebanada mostrará las opciones de sector. Por lo general, podemos cortarlas en rodajas utilizando el tipo automático y golpear el botón de la rebanada, el cual se encuentra la mejor separación para cada cuadro. Puede utilizar este tipo de sector de las bombas y spritesheets jugador.


      Sin embargo, cortar el juego de fichas, la selección del tipo automático no funciona, porque algunos de los azulejos son demasiado cerca y son demasiado similares entre sí demasiado para. Así que vamos a seleccionar la cuadrícula Por Tipo Tamaño de celda. El tamaño de celda para este conjunto de baldosas es de 16 × 16. Por último, nos encontramos con el botón de la rebanada.


      Ahora que hemos configurado todos los sprites del juego, podemos empezar a construir las escenas de juego, empezando por la escena Título.

      escena Título

      En este tutorial, la escena Título será muy simple. Simplemente se mostrará el título del juego, y un mensaje para iniciar el juego. A continuación, vamos a añadir una secuencia de comandos para iniciar el juego cuando el jugador presiona cualquier tecla. Con el fin de mostrar el título del juego y el mensaje, vamos a la necesidad de crear un lienzo.

      Título de la lona

      Un lienzo en la Unidad es un objeto donde usted puede poner sus elementos de interfaz de usuario, tales como textos, imágenes y botones. Con el fin de crear un lienzo, simplemente haga clic derecho en la jerarquía de objetos, y luego ir a UI-> Canvas. Vamos a llamar a este objeto TitleCanvas.

      tenemos que configurar algunas propiedades en el objeto Canvas. En primer lugar, vamos a establecer el modo de procesado de espacio en la pantalla – la cámara, y vamos a seleccionar nuestro Cámara principal como la cámara Render. Además, vamos a cambiar el modo de interfaz de usuario para Escala Escala Con tamaño de la pantalla, por lo que nuestros comporta lona así como los cambios de tamaño de pantalla del juego.


      Ahora que tenemos nuestro lienzo, vamos a añadir sus elementos. En primer lugar, vamos a añadir un BackgroundImage, pero la adición de una nueva imagen como un niño de la mano (UI-> Imagen). No vamos a seleccionar cualquier imagen fuente para el fondo, pero vamos a establecer su color como negro.


      El segundo hijo de los BackgroundCanvas será otra imagen, pero éste será llamado GameTitle. El título del juego será una imagen de la carpeta nuestros sprites, así como seleccionar la fuente de imagen del objeto GameTitle.


      Por último, vamos a añadir un texto como niño de la mano (UI-> texto), que se llamará StartGameText. En este objeto es necesario establecer su contenido de texto y propiedades de la fuente. La siguiente figura muestra la configuración que utilizan, pero puede elegir los que se ven mejor en su juego.


      Ahora que tenemos todos los objetos en la escena Título, sólo tenemos que añadir un evento para iniciar el juego cuando el jugador presiona cualquier tecla.

      Comenzar juego

      Vamos a empezar el juego usando un script muy simple, como a continuación.

      Tan sólo hay que poner en práctica el método de actualización de esta secuencia de comandos y, en este método, comprobamos si cualquier tecla se ha pulsado (Input.anyKey es cierto). Si es así, cargamos una escena llamada Batalla. Sin embargo, con el fin de llamar a este método LoadScene, es necesario utilizar el espacio de nombres SceneManagement en su script, así que recuerde de hacerlo.
      utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; usando UnityEngine.SceneManagement; public class startGame: MonoBehaviour {void Update () {if (Input.anyKey) {SceneManager.LoadScene ( «Batalla»); }}} 12345678910111213usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; usingUnityEngine.SceneManagement; publicclassStartGame: MonoBehaviour {voidUpdate () {if (Input.anyKey) {SceneManager.LoadScene ( «Batalla»);}}}

      Después creación del guión, lo añadimos al objeto StartGameText.


      Sin embargo, si se intenta ejecutar el juego se sigue sin abrir la siguiente escena. Con el fin de hacerlo, tenemos que:


      1. Crear una nueva escena llamada Batalla
      2. Añadir las dos escenas (Título y la batalla) en la lista de construcción de nuestro juego

        Lo primero es fácil. Basta con crear un nuevo escenario vacío y llamarlo batalla. Ahora, para la segunda cosa que necesitamos para ir a Archivo-> configuración de generación. A continuación, puede arrastrar y soltar ambas escenas a las escenas, en parte, de construcción de la ventana de configuración de generación.


        Por ahora, usted debe ser capaz de ejecutar la escena Título y comenzar el juego.


        Nuestro próximo paso será la creación de la escena de batalla.

        Escena de batalla

        La escena de batalla será el lugar donde pasa todo el juego. Jugador será capaz de moverse a través de las bombas de caída escena. Cada bomba explotará después de algún tiempo, la creación de explosiones. Las explosiones pueden destruir los bloques, pero no paredes. Si hay una explosión realiza un jugador, el jugador muere. Además, si una explosión golpea una bomba, hace que la bomba explotara al instante.

        Lo primero que tenemos que hacer en nuestra escena de batalla, es la creación de nuestro mapa de batalla.

        Creación e importación el mapa de baldosa

        Vamos a crear un mapa de baldosa para nuestra escena de batalla. Con el fin de hacer eso, vamos a utilizar el editor de mapas de baldosa.

        Desde la construcción de mapas de baldosa no es el objetivo de este tutorial, no voy a explicar los detalles de cómo construir nuestro mapa de batalla de usarlo. Por lo tanto, no dude en utilizar el mapa que aparece en el código fuente (que se muestra a continuación) o para crear su propia cuenta. Sin embargo, si crea su propio mapa, se debe tener cuidado con dos cosas:


        1. Sólo estoy añadiendo capas de mosaico para el fondo y para las paredes. Otros objetos, como el jugador y los bloques se añadirán más tarde en la Unidad.
        2. Con el fin de tener debidamente colisionadores de las paredes, tenemos que configurar algunos colisionadores de baldosas en consecuencia. Usted puede hacer esto mediante la selección de las baldosas que deben estar Collidable (por ejemplo, los azulejos de la pared) y seleccionando Tile- & gt; Azulejos colisión Editor. Esto abrirá una ventana como la de abajo, donde se puede configurar el área de colisión de la baldosa.


          Después de crear el mapa, se puede guardar con el formato de mapa de baldosa y añadirlo a una carpeta Maps, en el proyecto Unity.

          Sin embargo, no podemos simplemente abrir este mapa en la Unidad. Vamos a necesitar otra herramienta para convertirlo en un objeto de la Unidad, de manera que podemos añadir que en nuestro juego.

          Vamos a utilizar la herramienta Tiled2Unity para eso. Esta herramienta recibe como entrada un mapa de baldosa y crea un objeto Unidad en su juego que representa el mapa. En este proceso también crea los colisionadores de las baldosas cuando sea necesario.

          Después de instalar Tiled2Unity se encuentran dos archivos importantes en su carpeta de instalación:. Tiled2Unity el archivo ejecutable y el paquete Tiled2Unity Unidad

          En primer lugar, abra el paquete Tiled2Unity Unidad, de modo que se importará en su proyecto Unity. Esto creará una carpeta en la carpeta de Tiled2Unity activos, con un interior archivo Tiled2Unity.export de ella (entre muchos otros archivos y carpetas). Este archivo será importante más adelante para importar su mapa.

          Ahora, abra el archivo ejecutable Tiled2Unity. Esto abrirá una ventana como la de abajo, donde se puede seleccionar el mapa para la importación a la Unidad. Para la ubicación de exportación es el archivo Tiled2Unity.export se mencionó anteriormente.


          También puede previsualizar su mapa antes de exportar. Esto debería mostrar los colisionadores de las paredes.


          Después de exportar su mapa a la Unidad, se creará una casa prefabricada para ello en la carpeta Tiled2Unity / casas prefabricadas. A continuación, puede añadir este prefabricada a su juego. Sin embargo, tendrá que cambiar su escala, ya que será demasiado grande para la pantalla del juego, tal como es.


          Y con esto hemos terminado de importar nuestro mapa de baldosa en nuestro proyecto Unity. Ahora, vamos a añadir otros objetos de nuestra escena de batalla. A partir de bloques, que será explotado con las bombas.


          Adición de bloques

          Empecemos mediante la creación de una casa prefabricada para el bloque. El bloque simplemente tendrá un procesador de Sprite y un Colisionador de caja. El sprite será uno del conjunto de baldosas. Sin embargo, el aviso de que estamos estableciendo la capa de Ordenación del Sprite Renderizador como juego. Se trata de una capa personalizada que necesita para crear, de manera que los bloques aparecen sobre el mapa.


          A continuación, vamos a añadir un objeto vacío como elemento secundario de la battlemap. Este objeto vacío se llamará bloques, y que agrupará todos los bloques.

          Ahora, podemos añadir Bloque casas prefabricadas en nuestro juego, y convertirlos en elementos secundarios del objeto bloques. Usted puede poner los bloques whenere lo desea (la figura siguiente se muestra un ejemplo). Sin embargo, tenga en cuenta que usted necesita para configurar correctamente la escala de bloque, de forma que aparezca en un tamaño razonable.


          Ahora que tenemos las paredes y los bloques, vamos a crear el objeto jugador de nuestro juego.

          Desplazamiento del reproductor

          Lo primero que tenemos que hacer es crear una casa prefabricada jugador, y lo que le permite navegar por el mapa.

          Por lo tanto, crear una nueva prefabricada llama jugador con un Procesador de Sprite, un cuerpo rígido 2D (para que podamos controlar su velocidad), y una caja Colisionador 2D (para comprobar si hay colisiones). Además, se tendrá que ajustar su escala, de modo que tenga un tamaño razonable en nuestro mapa de batalla.


          Ahora, vamos a crear un nuevo script llamado movimiento de los jugadores de la siguiente manera. La secuencia de comandos obtiene el eje de movimiento (horizontal y vertical) con el fin de determinar la velocidad del jugador en ambas direcciones. La manera el jugador se mueve es el siguiente:. El jugador puede mover a una dirección dada (por ejemplo, a la izquierda), si aún no lo está moviendo en la dirección opuesta (a la derecha)

          Por lo tanto, la primera condición en los controles de secuencia de comandos si el jugador velocidad es menor que o igual a cero (lo que significa que el jugador no se está moviendo hacia la derecha). Si es así, podemos cambiar su velocidad en el eje X para hacer que se mueva a la izquierda. Hacemos lo mismo para todas las direcciones. Al final, nos propusimos la velocidad objeto de reproductor.
          PlayerMovement clase pública: MonoBehaviour {[SerializeField] Velocidad de flotación privado; void FixedUpdate () {float moveHorizontal = Input.GetAxis ( «horizontal»); flotar moveVertical = Input.GetAxis ( «vertical»); Vector2 currentVelocity = gameObject.GetComponent () .velocity; flotar newVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad; } Else if (moveHorizontal> 0 && currentVelocity.x> = 0) {newVelocityX = velocidad; } Flotar newVelocityY = 0f; si (moveVertical <0 && currentVelocity.y <= 0) {newVelocityY = -Velocidad; } Else if (moveVertical> 0 && currentVelocity.y> = 0) {= velocidad newVelocityY; } GameObject.GetComponent () .velocity = new Vector2 (newVelocityX, newVelocityY); }} 12345678910111213141516171819202122232425262728publicclassPlayerMovement:. MonoBehaviour {[SerializeField] privatefloatspeed; voidFixedUpdate () {floatmoveHorizontal = Input.GetAxis ( «horizontal»); floatmoveVertical = Input.GetAxis ( «vertical»); Vector2 currentVelocity = gameObject.GetComponent () velocidad ; floatnewVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad;} elseif (moveHorizontal> 0 && currentVelocity.x> = 0) {newVelocityX = velocidad;} floatnewVelocityY = 0f; si (moveVertical < 0 && currentVelocity.y <= 0) {newVelocityY = -Velocidad;} elseif (moveVertical> 0 && currentVelocity.y> = 0) {newVelocityY = velocidad;}. gameObject.GetComponent () velocidad = newVector2 (newVelocityX, newVelocityY) ;}}

          ahora, añadimos este script para el prefabricado jugador, y si se intenta jugar el juego ahora, ya se puede mover al jugador. Sin embargo, todavía no está jugando sus animaciones para caminar. Por lo tanto, nuestro siguiente paso será añadir las animaciones de los jugadores y sus transiciones.

          Animación de que el jugador

          Con el fin de agregar animaciones en la unidad, lo primero que tenemos que hacer es crear un controlador de animador. Lo que voy a hacer es crear una nueva carpeta en el Activo / Animaciones / jugador y luego voy a crear un nuevo controlador animador llamado PlayerAnimator (se puede crear el animador haciendo clic en Create-> Animador Controller). Entonces, podemos añadir este animador a la prefabricada jugador.


          Ahora vamos a crear las animaciones de los jugadores. El jugador tendrá ocho animaciones:. Cuatro animaciones ociosas (uno para cada sentido) y cuatro animaciones para caminar (uno para cada sentido)

          Una vez que haya creado todas las animaciones (que no es necesario para establecer los cuadros de animación aún), vamos a añadirlos a la PlayerAnimator. Por lo tanto, la prefabricadas seleccionado el jugador, abra el editor de animador en la Unidad. Esto mostrará la máquina de estados animador. A continuación, arrastrar y soltar las animaciones para el animador. Ahora, si se cambia al editor de animación, puede establecer los marcos para cada animación. Esto creará un estado para cada animación.

          Las animaciones de inactividad sólo mostrará el jugador situado en una dirección dada, por lo que tendrán un solo marco. Las animaciones para caminar tendrán los marcos para que el movimiento de caminar. Las siguientes figuras muestran los ejemplos para las animaciones IdleLeft y WalkingLeft. Puede crear los otros de una manera similar. Sin embargo, el aviso que usted necesita para configurar correctamente el número de muestras en las animaciones.


          Queremos una animación para jugar cuando el jugador se mueve a esa dirección, por lo que el estado animador será controlado por el guión PlayerMovement. Podemos controlar un animador mediante la adición de parámetros al animador (en la ficha Parámetros del editor de animador). Vamos a añadir dos parámetros: DirectionX y DirectionY. Cada parámetro será un número entero comprendido entre -1 y 1, y le dirá al animador si el jugador se mueve a una dirección dada. Por ejemplo, si el parámetro DirectionX es igual a 1, el jugador debe transición a la animación WalkingRight.

          Ahora tenemos que crear las transiciones entre animaciones utilizando los parámetros. Habrá tres tipos de transiciones:


          1. Si el jugador se para y comienza a moverse en cualquier dirección, se debe empezar a jugar la animación de esa dirección. Por lo tanto, tenemos que las transiciones entre cada estado inactivo a cada estado Caminar. Los parámetros de la transición dependerán de la dirección que el jugador se mueve a.
          2. Si el jugador se está moviendo en una dirección dada, y ambos parámetros DirectionX y DirectionY convertirse en 0, se debe volver a una IdleState. El estado de reposo correcta depende de la animación actual para caminar. Por ejemplo, si la animación actual es WalkingLeft, irá de nuevo al estado IdleLeft.
          3. Si el jugador se está moviendo en una dirección dada, y cambiar los parámetros DirectionX o DirectionY, debe ir a una animación de caminar diferente. Por ejemplo, si la animación actual es WalkingLeft, pero eventualmente DirectionX convertirse en 0 y DirectionY convertirse en 1, debe transición a la animación WalkingUp.

            La adición de todas esas reglas de transición, el PlayerAnimator debería tener este aspecto en el final:


            Sin embargo, todavía hay algunos detalles que necesitamos para fijar en nuestras animaciones. En primer lugar, las animaciones deben caminar bucle cuando terminan. Por lo tanto, seleccionar las animaciones, y marca la casilla salto temporal.


            Además, con el fin de tener transiciones más suaves entre las animaciones, vamos a ajustar el retardo entre ellos a 0. Podemos hacerlo mediante la selección de una transición, a continuación, marcando las casillas de la duración del tiempo de salida y fija tiene y ajuste de la Duración de la transición a 0.


            Por último, tenemos que configurar los parámetros DirectionX y DirectionY en el guión PlayerMovement. Esto se realizará tal como se muestra a continuación. Una vez que nos propusimos la velocidad en una dirección dada, actualizamos el parámetro DirectionX o DirectionY en consecuencia. Si el jugador no está en movimiento en un eje dado, establecimos su parámetro de dirección a 0.
            PlayerMovement clase pública: MonoBehaviour {[SerializeField] Velocidad de flotación privado; [SerializeField] animador animador privado; void FixedUpdate () {float moveHorizontal = Input.GetAxis ( «horizontal»); flotar moveVertical = Input.GetAxis ( «vertical»); Vector2 currentVelocity = gameObject.GetComponent () .velocity; flotar newVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad; animator.SetInteger ( "DirectionX", -1); } Else if (moveHorizontal> 0 && currentVelocity.x> = 0) {newVelocityX = velocidad; animator.SetInteger ( «DirectionX», 1); } Else {animator.SetInteger ( «DirectionX», 0); } Flotar newVelocityY = 0f; si (moveVertical <0 && currentVelocity.y <= 0) {newVelocityY = -Velocidad; animator.SetInteger ( "DirectionY", -1); } Else if (moveVertical> 0 && currentVelocity.y> = 0) {= velocidad newVelocityY; animator.SetInteger ( «DirectionY», 1); } Else {animator.SetInteger ( «DirectionY», 0); } GameObject.GetComponent () .velocity = new Vector2 (newVelocityX, newVelocityY); }} 123456789101112131415161718192021222324252627282930313233343536373839publicclassPlayerMovement: MonoBehaviour {[SerializeField] privatefloatspeed; [SerializeField] privateAnimator animador; voidFixedUpdate () {floatmoveHorizontal = Input.GetAxis ( «horizontal»); floatmoveVertical = Input.GetAxis ( «vertical»); Vector2 currentVelocity = gameObject.GetComponent < . Rigidbody2D> () velocidad; floatnewVelocityX = 0f; si (moveHorizontal <0 && currentVelocity.x <= 0) {newVelocityX = -Velocidad; animator.SetInteger ( "DirectionX", - 1);} elseif (moveHorizontal> 0 && currentVelocity.x > = 0) {newVelocityX = velocidad; animator.SetInteger ( «DirectionX», 1);} else {animator.SetInteger ( «DirectionX», 0);} floatnewVelocityY = 0f; si (moveVertical <0 && currentVelocity.y <= 0 ) {newVelocityY = -Velocidad; animator.SetInteger ( "DirectionY", - 1);} elseif (moveVertical> 0 && currentVelocity.y> = 0) {newVelocityY = velocidad; animator.SetInteger ( «DirectionY», 1);} else {animator.SetInteger ( «DirectionY», 0);}. gameObject.GetComponent () velocidad = newVector2 (newVelocityX, ne wVelocityY);}}

            A estas alturas, se puede tratar de jugar el juego y mover el jugador. Comprobar si todas las animaciones están jugando correctamente, y si el jugador está chocando con las paredes correctamente.


            Y con esto concluye esta parte de esta serie de tutoriales. En la siguiente parte vamos a permitir al jugador para lanzar bombas, así como hacer las bombas para explotar y destruir los bloques en el juego.

            Mensajes relacionados

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *