En el último tutorial empezamos a añadir el juego básico ofrece en nuestro juego Bomberman. Ahora, vamos a terminar la aplicación de las características de un solo jugador, tales como: bombas cayendo, creando explosiones y la adición de un número de vidas al jugador. A continuación, en el siguiente tutorial podemos añadir el material multijugador y terminar la serie.

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

    Tabla de contenidos

    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í.
    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

      Bombas de caída

      Hasta ahora nuestro jugador puede moverse por el mapa de batalla. Sin embargo, todavía no es capaz de lanzar bombas en el juego. Esto es lo que vamos a añadir ahora.

      Lo primero que tenemos que hacer es crear una bomba prefabricada. Por lo tanto, crear una nueva prefabricada y lo llaman bomba. Este prefabricada necesitará un Sprite Renderizador, un animador (puede crear uno la misma manera que lo hizo para el animador jugador) y una caja Colisionador 2D. La caja Colisionador será un disparador, a fin de comprobar la caja es de disparo. De esta manera, no va a empujar al jugador lejos de ella cuando la bomba se acaba de caer. Además, como lo hicimos con los otros objetos de la escena de batalla, es necesario configurar correctamente su escala y establecer la capa de selección del Sprite Procesador de la capa del juego.


      Ahora tenemos que crear la bomba explotando animación. Ya hemos creado el BombAnimator, para que pueda crear una nueva animación llamada explosión y arrastre a la BombAnimator en el editor de animador.

      El BombAnimator será mucho más simple que el jugador uno. Sólo se tendrá la animación de explosión, por lo que no es necesario añadir ningún parámetro o transiciones. Sin embargo, todavía es necesario para crear esta animación.

      Con el fin de editar fácilmente la animación, puede agregar temporalmente una bomba para el juego. Así pues, con el objeto de bomba seleccionado, abra el editor de animación para editar la animación de explosión. A continuación, arrastre todos los marcos spritesheet la bomba a la misma, como se muestra a continuación. Recuerde que debe configurar correctamente el número de muestras. Después de terminar la edición de la animación se puede retirar el objeto bomba del juego.


      Ahora que tenemos una casa prefabricada bomba de trabajo, vamos a permitir al jugador para lanzar bombas en el juego.

      Con el fin de hacer eso, vamos a crear el guión BombDropping de la siguiente manera. En el método de actualización de este script que vamos a comprobar si la tecla Espacio (o cualquier otra tecla se prefiere). Si se pulsa esta tecla, el guión va a llamar a un método DropBomb.

      El método DropBomb va a crear una instancia de una nueva bomba de su casa prefabricada (el prefabricada es un atributo de la secuencia de comandos). La posición de la nueva bomba va a ser el mismo que el jugador.
      BombDropping clase pública: MonoBehaviour {[SerializeField] privada GameObject bombPrefab; // actualización se llama una vez por cuadro de actualización de vacío () {if (Input.GetKeyDown ( «espacio»)) {DropBomb (); }} Void DropBomb () {Instantiate (bombPrefab, this.gameObject.transform.position, Quaternion.identity); }} 12345678910111213141516publicclassBombDropping: MonoBehaviour {[SerializeField] privateGameObject bombPrefab; // actualización se llama una vez por framevoidUpdate () {if (Input.GetKeyDown ( «espacio»)) {DropBomb ();}} voidDropBomb () {Instantiate (bombPrefab, este .gameObject.transform.position, Quaternion.identity);.}}

      al final, se añade esta secuencia de comandos para el jugador prefabricada


      Y con eso, ya se puede tratar de jugar el juego y lanzar bombas. Sin embargo, se dará cuenta de que el jugador no está colisionando con las bombas ya hemos configurado sus colisionadores como disparador. Vamos a fijarlos ahora, cuando permitimos que las bombas para explotar.


      Creación de explosiones

      Mientras el colisionador bomba es un disparador, el jugador no chocan con ella. Sin embargo, se desactive la casilla Is gatillo, el jugador será empujado a un lado cuando se deja caer una bomba, ya que chocarán entre sí.

      Una forma de resolver esto está creando la bomba con un colisionador gatillo. Pero, una vez que el jugador no está colisionando con la bomba más, cambiamos el colisionador bomba para que no sea un disparador más. Desde este punto el jugador y la bomba chocarán con normalidad.

      Vamos a hacer eso en un nuevo guión llamado BombExplosion. Este script se utiliza para explotar la bomba, así, pero por ahora sólo vamos a hacer de la siguiente manera: vamos a poner en práctica el método OnTriggerExit2D y, cuando se le llama, que va a cambiar el colisionador bomba a no ser un disparador nunca más. El método se llama cuando OnTriggerExit2D colisionador de otro objeto deja el gatillo bomba. Por lo tanto, se llamará una vez que el jugador no ha terminado la bomba más.
      BombExplosion clase pública: MonoBehaviour {void OnTriggerExit2D (Collider2D otra) {this.collider2D.isTrigger = false; }} 123456publicclassBombExplosion: MonoBehaviour {voidOnTriggerExit2D (Collider2D otra) {this.collider2D.isTrigger = false;}}

      Nuestro siguiente paso es explotar bombas cuando sus extremos de animación. Vamos a empezar por la creación de una casa prefabricada de explosión. Entonces, podemos añadir un método de explotar en el guión BombExplosion que crea explosiones.

      Por lo tanto, crear una nueva prefabricada y lo llaman explosión. Este prefabricada tendrá un Sprite Procesador (en la capa de juego de clasificación), una caja Colisionador 2D y una Rigidbody2D. Tenga en cuenta que el colisionador de explosión también será un factor desencadenante. Esto se debe a que no quieren a la explosión físicamente interactuar con otros objetos, tales como el jugador. Sin embargo, se necesita un Rigidbody2D con el fin de comprobar las colisiones con las paredes en el juego, porque la unidad solamente comprobar las colisiones cuando al menos uno de los objetos tiene un cuerpo rígido (otra opción sería añadir un cuerpo rígido a las paredes). Sin embargo, el aviso de que la explosión es un cuerpo rígido Cinemática uno, porque no queremos que las explosiones que se mueven en el juego.

      Ahora que tenemos el prefabricada explosión, podemos crear explosiones en el guión BombExplosion. Así que en primer lugar, vamos a crear un explosivo aumento en el método de la siguiente manera. En primer lugar, se creará una explosión en la posición bomba. Además, esta explosión debe ser destruido después de algún tiempo, por lo que llamará al método destruir por ello con una duración dada la explosión. Por último, se va a crear explosiones en las cuatro direcciones (izquierda, derecha, arriba y abajo) y destruirse a sí misma. La creación explosiones se realiza mediante un método CreateExplosions, que vamos a poner en práctica ahora.
      [SerializeField] privada GameObject explosionPrefab; [SerializeField] explosionDuration flotador privado; public void Explode () {explosión GameObject = Instantiate (explosionPrefab, this.gameObject.transform.position, Quaternion.identity) como GameObject; Destruye (explosión, this.explosionDuration); CreateExplosions (Vector2.left); CreateExplosions (Vector2.right); CreateExplosions (Vector2.up); CreateExplosions (Vector2.down); Destruye (this.gameObject); } 123456789101112131415 [SerializeField] privateGameObject explosionPrefab; [SerializeField] privatefloatexplosionDuration; publicvoidExplode () {GameObject explosión = Instantiate (explosionPrefab, this.gameObject.transform.position, Quaternion.identity) asGameObject; Destruye (explosión, this.explosionDuration); CreateExplosions (Vector2 .left); CreateExplosions (Vector2.right); CreateExplosions (Vector2.up); CreateExplosions (Vector2.down); Destruye (this.gameObject);}

      Los CreateExplosions se muestra el método a continuación. Este método creará explosiones en una dirección dada. El número de explosiones está dada por un atributo explosionRange del guión. Por lo tanto, va a iterar entre 0 y el número de explosiones crearlos. Sin embargo, una vez que encuentra una pared o un bloque, se debe dejar de crear explosiones. Si encuentra un bloque de este proceso, el bloque debe ser destruido.

      puede hacerlo utilizando el método Physics2D.OverlapBox de la Unidad. Este método recibe como parámetro una caja, un ángulo, una ContactFilter y una lista de Colliders. Entonces, rellenará esta lista de Colliders con todos los colisionadores que se superponen al cuadro de consulta. De esta manera, podemos comprobar si la región donde será la explosión ya está ocupada por una pared o un bloque. En nuestro caso, el ángulo será 0 y no vamos a utilizar cualquier ContactFilter especial, por lo que sólo debe preocuparse de la caja.

      La caja será la región de la explosión va a ocupar, por lo que podemos utilizar los valores explosionPosition y explosionDimensions. Una vez que tenemos la lista de los colisionadores, que iterar a través de él en busca de paredes o bloques. Si nos encontramos con una pared o bloque, hemos creado una variable como verdadera y romper el bucle. Si nos encontramos con un bloque, lo destruimos. Finalmente, en el bucle exterior, si hemos encontrado un bloque o una pared, también romper este bucle. Si no es así, creamos una nueva explosión de la explosionPrefab y ponerlo a ser destruida después de la duración explosión.
      [SerializeField] int explosionRange privado; CreateExplosions private void (Vector2 dirección) {ContactFilter2D contactFilter = nuevo ContactFilter2D (); Vector2 explosionDimensions = explosionPrefab.GetComponent () .bounds.size; Vector2 explosionPosition = (Vector2) this.gameObject.transform.position + (explosionDimensions.x * dirección); para (explosionIndex = 1 int; explosionIndex () bounds.size;. Vector2 explosionPosition = (Vector2) this.gameObject.transform.position + (explosionDimensions.x * dirección); for (intexplosionIndex = 1; explosionIndex La última cosa que tenemos que hacer es añadir una devolución de llamada en el final de la animación de explosión para llamar al método explotar. Puede hacerlo mediante la apertura de la explosión en el editor de animación, a continuación, hacer clic derecho en el último fotograma y la selección y seleccionando Añadir animación de eventos. La función de evento animación será el método explotar.


      Y con eso, puede intentar jugar el juego y dejar que la bomba explote. A ver si las explosiones se crean correctamente (parando en las paredes y bloques). La siguiente cosa que vamos a hacer es permitir que las explosiones para dañar otros objetos, tales como el Jugador y bombas.


      cosas explosión

      Las explosiones debe interactuar con el jugador y bombas. Si hay una explosión toca al jugador, que debe matar al jugador. Si toca una explosión de una bomba, la bomba debe explotar de inmediato.

      Empecemos añadiendo la vida del jugador, por lo que puede morir a una bomba. Esto se hará mediante el script PlayerLife a continuación. El guión será responsable de actualizar el número actual de vida, sino también para hacer que el jugador invulnerable durante un corto período de tiempo justo después de que se haya dañado. Esto evita que el jugador para que explosione por varias bombas a la vez.

      Por lo tanto, el método LoseLife inicia verificando si el jugador no está en invulnerable. Si es vulnerable, se reducirá el número actual de vida y comprobar si ésta era la última vida. Si es así, sino que también va a destruir el objeto del jugador. Después de disminuir el número de vidas, que hará que el jugador invulnerable, e invocar el método BecomeVulnerable después de que el tiempo de duración de la invulnerabilidad. El método BecomeVulnerable, por su parte, sólo hará que el jugador vulnerable de nuevo.
      PlayerLife clase pública: MonoBehaviour {[SerializeField] numberOfLives private int = 3; [SerializeField] flotador invulnerabilityDuration privado = 2; private bool isInvulnerable = false; pública LoseLife void () {if (this.isInvulnerable!) {this.numberOfLives–; si (this.numberOfLives == 0) {Destruir (this.gameObject); } This.isInvulnerable = true; Invoke ( «BecomeVulnerable», this.invulnerabilityDuration); }} Void BecomeVulnerable privada () {this.isInvulnerable = false; }} 12345678910111213141516171819202122232425publicclassPlayerLife: MonoBehaviour {[SerializeField] privateintnumberOfLives = 3; [SerializeField] privatefloatinvulnerabilityDuration = 2; privateboolisInvulnerable = false; publicvoidLoseLife () {if (this.isInvulnerable!) {This.numberOfLives -; si (this.numberOfLives == 0 ) {Destruir (this.gameObject);} this.isInvulnerable = true; Invoke ( «BecomeVulnerable», this.invulnerabilityDuration);}} privatevoidBecomeVulnerable () {this.isInvulnerable = false;}}

      Ahora vamos a crear un guión para la explosión que se llame al método LoseLife al chocar con el jugador. Este script se llamará ExplosionDamage, y se muestra a continuación. Vamos a poner en práctica el método OnTriggerEnter2D, el cual será llamado cada vez que otro objeto colisiona con la explosión. Cuando esto sucede, vamos a comprobar el tipo del objeto por su etiqueta (recuerde ajustar correctamente las etiquetas prefabricadas). Si se trata de una etiqueta de “carácter”, se llama al método LoseLife en el guión PlayerLife. Si se trata de una etiqueta de “bomba”, se llama al método explotar en el guión BombExplosion. Este estalla el método es el mismo que ya estaba utilizando, por lo que no es necesario para poner en práctica una nueva.
      ExplosionDamage clase pública: MonoBehaviour {void OnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == «carácter») {collider.gameObject.GetComponent () .LoseLife (); } Else if (collider.tag == «bomba») {collider.gameObject.GetComponent () .Explode (); }}} 12345678910publicclassExplosionDamage:. MonoBehaviour {voidOnTriggerEnter2D (Collider2D colisionador) {if (collider.tag == «carácter») {collider.gameObject.GetComponent () LoseLife ();} elseif (collider.tag == «Bomba «) {collider.gameObject.GetComponent () Explotar ();.}.}}

      a continuación, añadimos esos guiones a sus respectivas casas prefabricadas


      A estas alturas, ya se puede intentar jugar y comprobar si las explosiones interactuar correctamente con el jugador y las bombas. Sin embargo, todavía no se puede ver en el juego el número actual de vidas jugador. Esto es lo siguiente que vamos a hacer.

      Mostrando el jugador vive

      De forma similar a la forma en que mostramos el título y el texto en la pantalla de título, vamos a crear un lienzo para mostrar el número de jugador de vidas. Vamos a empezar por la creación de un nuevo lienzo (haga clic derecho en la Jerarquía, entonces UI-> Canvas) y decir que es HUDCanvas. Este lienzo se configurará de la misma manera que hicimos con los BackgroundCanvas:


      • Establecer modo de procesado de espacio de pantalla – Cámara
      • Seleccione la cámara principal como el Render cámara
      • Seleccione la capa de clasificación según Juego
      • Modo de fijar la escala de interfaz de usuario como escala con Tamaño de la pantalla


        Ahora vamos a crear un objeto que representará una cuadrícula para mostrar las vidas jugador. Podemos hacer eso mediante la creación de un objeto vacío como elemento secundario de la tela, y luego añadir un componente Diseño de cuadrícula Grupo a ella. Entonces, tenemos que CONFIGURACION adecuadamente esta Disposición grupo de la rejilla para mostrar el jugador vive la manera que queremos.

        Básicamente, lo que tenemos que hacer es cambiar el campo Restricción de Recuento de filas fijo, y el conde de restricción a 1. Esto hará que la red para mostrar la vida en una sola fila. Además, tenemos que cambiar el tamaño de celda de 20 x 20. Figura a continuación muestra el objeto PlayerLivesGrid.


        Ahora tenemos que crear objetos para representar las vidas de los jugadores, y los administran en la red de la vida. Por lo tanto, vamos a crear una nueva imagen como un niño de los HUDCanvas, llamándolo PlayerLifeImage y lo que es una casa prefabricada. En esta imagen, sólo tenemos que configurar la fuente de imagen para ser el sprite corazón.


        Ahora, vamos a cambiar el guión PlayerLife para gestionar las vidas jugador en la red. En primer lugar, tenemos que añadir dos nuevos atributos: un atributo de la imagen prefabricada vida de los jugadores, y otro con una lista, almacenar todas las imágenes de la vida del jugador. Luego, en el método de inicio creamos un objeto PlayerLifeImage para cada uno de los jugadores vidas. Tenga en cuenta que tenemos el objeto PlayerLivesGrid para que podamos crear las imágenes como hijos de ella. Después de crear cada imagen, lo añadimos a la lista lifeImages.

        También es necesario cambiar el método para destruir una LoseLife PlayerLifeImage cuando el jugador pierde una vida. Podemos hacer eso mediante la recuperación del último elemento de la lista lifeImages, destruyéndolo, y después de sacarlo de la lista.
        PlayerLife clase pública: MonoBehaviour {[SerializeField] numberOfLives private int = 3; [SerializeField] flotador invulnerabilityDuration privado = 2; private bool isInvulnerable = false; [SerializeField] privada GameObject playerLifeImage; Lista privada lifeImages; vacío Inicio () {GameObject playerLivesGrid = GameObject.Find ( «PlayerLivesGrid»); this.lifeImages = new List (); for (int lifeIndex = 0; lifeIndex lifeImages; voidStart () {GameObject playerLivesGrid = GameObject.Find ( «PlayerLivesGrid» ); this.lifeImages = newList (); para (intlifeIndex = 0; lifeIndex Ahora, ya podemos jugar el juego y ver las vidas jugador en la pantalla. La última cosa que vamos a hacer en este tutorial es la adición de un mensaje Juego encima cuando el jugador pierde todas sus vidas.


        Game over mensaje

        El juego sobre el mensaje será un texto que se muestra en el HUD de la lona cuando el jugador pierde todas sus vidas. Por lo tanto, vamos a empezar por la creación de esos textos en el HUD lienzo.

        En primer lugar, a fin de permitir con facilidad y textos deshabilitar, vamos a agruparlas en un objeto. Por lo tanto, empezar por crear un objeto vacío llamado GameOverPanel. A continuación, vamos a colocar el guión startGame a ella. El guión startGame es el mismo que se utiliza en la escena Título, y vamos a usarlo de nuevo aquí, ya que queremos que reiniciar el juego después de que el juego ha terminado.


        Ahora que añadir dos textos (UI-> texto) como hijos de la GameOverPanel. La primera de ellas se llamará GameOverMessage y mostrará el texto “Juego encima!”. El segundo se llama RetryMessage y mostrará el texto “Pulse cualquier tecla para volver a intentar”. Puede cambiar el tamaño de la fuente a ser la manera que prefiera.


        Además, con el fin de asegurarse de que los HUDCanvas aparecerá por encima de todo, puede crear otra capa de clasificación llamado HUD y asignar el lienzo a la misma.


        Ahora, desactivar el GameOverPanel desmarcando la casilla junto a su nombre. Hacemos esto porque queremos que el GameOverPanel que aparezca sólo cuando el jugador pierde el juego.


        Por último, cambiar la secuencia de comandos para mostrar la PlayerLife GameOverPanel cuando su juego. Hacemos esto mediante la adición de la GameOverPanel como un atributo de la secuencia de comandos. Entonces, en el método LoseLife, cuando el número actual de vida es igual a 0 establecemos el panel como activa.
        [SerializeField] privada GameObject gameOverPanel; LoseLife pública void () {if (this.isInvulnerable!) {This.numberOfLives–; GameObject lifeImage = this.lifeImages [this.lifeImages.Count – 1]; Destruye (lifeImage); this.lifeImages.RemoveAt (this.lifeImages.Count – 1); si (this.numberOfLives == 0) {Destruir (this.gameObject); this.gameOverPanel.SetActive (true); } This.isInvulnerable = true; Invoke ( «BecomeVulnerable», this.invulnerabilityDuration); }} 1234567891011121314151617 [SerializeField] privateGameObject gameOverPanel; publicvoidLoseLife () {if (this.isInvulnerable!) {This.numberOfLives -; GameObject lifeImage = this.lifeImages [this.lifeImages.Count-1]; Destruir (lifeImage); esto. lifeImages.RemoveAt (this.lifeImages.Count-1), si (this.numberOfLives == 0) {Destruir (this.gameObject); this.gameOverPanel.SetActive (true);} this.isInvulnerable = true; Invoke ( «BecomeVulnerable «, this.invulnerabilityDuration);}}

        Ahora, puede intentar jugar el juego y morir, para ver si se visualiza correctamente el juego sobre el mensaje. Además, verifique si puede reiniciar el juego.


        Y con esto concluye las características de un solo jugador de nuestro juego. En el siguiente tutorial vamos a hacer nuestro juego multijugador, añadiendo dos jugadores en una batalla!

        Mensajes relacionados
         unidad escena del juego de multijugador espacio de juego de disparos

Deja una respuesta

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