Cómo crear un juego básico de Android con Unity

En un tutorial de Appual anterior titulado «Cómo crear un juego básico de plataforma Unity» (y es 2), repasamos el uso de Unity y el complemento WebGL incorporado para crear un juego de navegador simple basado en HTML5En este tutorial similar, veremos cómo crear un fondo básico. Androide juego usando Unity.

Requisitos:

Si aún no lo tiene, debe comenzar descargando e instalando el SDK de Unity y el SDK de Android. Necesitamos el SDK de Android para poder probar el APK del juego dentro de un entorno Android.

Inicie Unity y cree un nuevo proyecto. Conviértalo en un proyecto 2D.

Hay una serie de paneles a los que hay que acostumbrarse: el panel Jerarquía, que contendrá todos nuestros elementos visuales (escena = cualquier «nivel» en el que esté trabajando actualmente). Luego está la pestaña Juego que se usa para jugar / probar su juego mientras está dentro del editor, y en el lado derecho tiene el panel Inspector donde editará varias cosas como iluminación, física, etc.

Lo primero que queremos hacer es crear un objeto: este será nuestro personaje principal (a quién controlamos). Puede dibujar su propio objeto, como dibujar un cuadrado con ojos, o puede tocar un objeto de Internet; asegúrese de que sea un archivo .PNG (fondo transparente).

Arrastra y suelta tu objeto en la ventana de la vista principal (ventana principal); también aparecerá en el panel Jerarquía a la izquierda.

Así que ahora crearemos algunas plataformas: estos son cuadrados simples, ya que podremos cambiarlos fácilmente para hacer paredes y otras plataformas.

Así que crea un nuevo «sprite» cuadrado y arrástralo y suéltalo en la ventana Ver como lo hiciste con tu personaje de sprite.

Ahora necesitamos instruir a Unity para que le dé a nuestro personaje principal la física: haga clic en su personaje sprite principal (debe estar resaltado en azul en la ventana Escena), luego en el panel del Inspector, vea «GameObjects».

Haga clic en «Agregar componente> Física 2D> RigidBody2D». Esto agregará automáticamente la física a su sprite, que de otra manera tendría que escribir en otro SDK.

Queremos evitar que el personaje principal del sprite gire en control, así que busque la pestaña Restricciones en el panel Inspector (con el sprite principal aún resaltado en la ventana Ver) y marque la casilla de «Congelar rotación Z».

Si presionas el botón «Reproducir», tu personaje principal debe caer del cielo y caer sin parar; nos ocuparemos de eso más tarde, pero fíjate cómo pudimos aplicar la física fácilmente. La física que aplicamos depende de la forma en la que se apliquen, por lo que si aplica la misma física a una esfera, por ejemplo, ruede.

También queremos establecer nuestra orientación para evitar que el personaje gire y se caliente libremente. Busque «restricciones» en el inspector con el jugador seleccionado y marque la casilla para congelar la rotación Z. Ahora haz clic en jugar nuevamente y deberías encontrar que tu jugador ahora caerá del cielo a su infinita invencibilidad.

Para evitar que el personaje principal de nuestro sprite caiga sin parar, necesitamos agregar un colisionador. Básicamente, esto es solo el contorno sólido de una forma que agregaremos al personaje principal del sprite. Para resaltar el personaje principal de tu sprite, haz clic en «Agregar componente> Física 2D> BoxCollider2D».

Ahora haga exactamente lo mismo con la plataforma que creó anteriormente. Tu personaje de sprite principal debería «chocar» con la plataforma y permanecer allí.

Así que ahora queremos asegurarnos de que la cámara siga a tu personaje de sprite principal; dentro de la escena, ya debería haber un objeto de cámara. Quieres dibujar esto encima el personaje principal de sprite.

Esto es especialmente importante si está creando una Ruedas basadas en 3D, algo como Pendiente cuando necesitas que la cámara esté siempre detrás del objetivo principal del juego (tu personaje principal de sprite).

Ahora vaya al panel Jerarquía y en la lista GameObjects, desea arrastrar la cámara abajo el personaje de sprite principal (GameObject Player). Eso hará que el personaje principal sea el sprite del ‘padre ‘ de la cámara. Entonces, siempre que GameObject Player se mueva por la pantalla, la cámara debería seguirlo.

Entonces, para este tutorial del juego, no vamos a crear un juego básico de corredor sin fin, algo así como Ejecutar 3, donde tu personaje principal corre por la pantalla y encuentra obstáculos (o «el juego termina» si chocas con un obstáculo «). Esto requerirá algunos guiones, la mayoría de los cuales se proporcionarán en esta guía.

Haga clic con el botón derecho en la carpeta «Activos» y cree una nueva carpeta, asígnele un nombre Guiones. Ahora haga clic derecho en esta nueva carpeta y presione «Crear> Script C #» y asígnele un nombre PlayerControls. Este script es para definir el comportamiento de nuestro personaje sprite principal.

Cuando haga doble clic en este nuevo script, hágalo coro abrir en Visual Studio; alternativamente (y mi preferencia personal), puede editarlo en algo como NotePad ++.

El archivo de secuencia de comandos ya debería contener un poco de código de «placa de caldera»; se trata básicamente de una secuencia de comandos que debe dejarse solo o simplemente adaptarse a sus necesidades, y nos ahorrará mucho tiempo. Entonces vamos a agregar un nuevo objeto.

Sobre el vacío de Frontline ():

público Rigidbody2D rb;

El siguiente fragmento de código que debemos agregar irá dentro de Start (), y se usa para encontrar el código rígido; básicamente, estamos guiando a Unity hacia la física que conectamos con los GameObjects (nuestro personaje principal de sprite). y Start () se ejecuta cuando se crea un nuevo objeto o script.

Así que encuentra el objeto de la física.

rb = GetComponent<Rigidbody2D>();

Y pones esta línea dentro de Update ()

rb.velocity = new Vector2(3, rb.velocity.y);

Lo que hace Update () siempre se actualiza, por lo que cualquier código insertado en él se ejecutará continuamente (a menos que se elimine el objeto). Entonces, lo que hemos hecho es indicarle al script que queremos que el rígido tenga un nuevo vector usando la misma velocidad en el eje Y (rb.velocity.y), pero con una velocidad de 3 en el eje horizontal. En el futuro, puedes ‘FixedUpdate () ‘ que es similar pero diferente, por eso puede controlar la cantidad de actualización / actualización del script.

Guarde el script y vuelva a Unity, luego haga clic en el personaje principal de su objeto para resaltarlo. En el panel Inspector, vaya a Agregar componente> Scripts y agregue el script que acabamos de guardar. Ahora, cuando haces clic en el botón Reproducir, el personaje principal del objeto debe moverse continuamente hacia el borde de la plataforma.

Creación de controles de entrada del reproductor

Entonces, debido a que este es un juego de corredor sin fin con obstáculos, debemos agregar controles al jugador como un botón de «salto».

Vuelva a abrir el script de antemano y vamos a agregar este código adicional:

if (Input.GetMouseButtonDown(0))  {
         rb.velocity = new Vector2(rb.velocity.x, 5);
         }

Tienes que poner eso dentro del modo de actualización (), y lo que básicamente hace es decirle a Unity cuando el jugador hace clic en el botón del mouse (que se traducirá como un toque de pantalla en Android), que saltará el sprite del personaje principal «en el Esto se debe a que establecemos una velocidad en el eje Y con un valor de 5 (un valor más alto significaría un salto más alto, por supuesto).

Si no está muy familiarizado con la codificación, solíamos Ambos declaración sobre Ambos es esencialmente una especie de instrucción de «hacer o no hacer» – literalmente dice Si esto sucede, ejecute este comando. Entonces, si el jugador no está haciendo clic con el mouse (o tocando su pantalla de Android), obviamente el script no se ejecutará.

Continúe y haga clic en el botón «Reproducir» y asegúrese de que funcione correctamente antes de continuar.

Luego agregaremos nuestros obstáculos (que pueden «destruir el sprite del personaje principal»), una puntuación del juego y un menú de «fin del juego».

Si has probado el juego hasta ahora, el único problema que tenemos hasta ahora es que presionar el botón «saltar» que creamos forzará al personaje, ya sea que esté establecido o no, es básicamente Flappy Birds, y no un corredor. así queremos. Pero estamos a punto de arreglar eso.

En el script, agregue este fragmento de código encima Método de actualización ():

public Transform groundCheck;
public Transform startPosition;
public float groundCheckRadius;
public LayerMask whatIsGround;
private bool onGround;
And then add this next line to the Update method above the if statement:
onGround = Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, whatIsGround);
And next you will change this following line to include “&& onGround”
if (Input.GetMouseButtonDown(0) && onGround) {
So our entire script should basically look like this:
public class PlayerControls : MonoBehaviour
 {
     public Rigidbody2D rb;
     public Transform groundCheck;
     public Transform startPosition;
     public float groundCheckRadius;
     public LayerMask whatIsGround;
     private bool onGround;


void Start() {
     rb = GetComponent<Rigidbody2D>();
     }


    void Update() {
         rb.velocity = new Vector2(3, rb.velocity.y);
         onGround = Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, whatIsGround);       
         if (Input.GetMouseButtonDown(0) && onGround) {
                 rb.velocity = new Vector2(rb.velocity.x, 5);
                 }


    }


}

Para explicar lo que hemos hecho, hemos creado una nueva “transformación”, que significa estar en el espacio del mundo del juego. Hemos establecido su radio y le hemos dado instrucciones a Unity para que verifique si el rayo se superpone con nuestra capa de «suelo», por lo que si nuestro rayo se combina con el «suelo», nuestro personaje debería poder saltar, y si ya estamos en el aire desde un salto, no deberíamos poder volver a saltar. Básicamente, arGround será verdad ambos la transformación nombrada landCheck superponiendo la capa del suelo. Espero que tenga sentido.

Así que guarde el guión y vuelva a Unity, y notará que se han agregado más opciones al Inspector después de resaltar el jugador. Son variables públicas y podemos adaptarlas a nuestro gusto.

Ahora haga clic derecho en la Jerarquía y cree un nuevo objeto vacío, y arrástrelo para que esté debajo del sprite del personaje principal en la ventana principal de Vista: coloque este objeto vacío donde queremos que se detecte el piso. Cambie el nombre del objeto a «Check Ground», luego arrástrelo debajo del objeto del juego del jugador como hicimos anteriormente con la cámara (para crear una relación padre-hijo entre los objetos). Ahora el objeto vacío seguirá al sprite del personaje principal, al igual que la cámara, y comprobará continuamente el área del suelo.

Ahora seleccione el sprite del personaje principal y vaya al panel del Inspector – arrastre el objeto Check Ground al espacio llamado «groundCheck». La posición de ‘transformado’ debería ser igual a la posición de este nuevo objeto, y si dice «rayo», hazlo 0.1.

Necesitamos definir la capa de suelo. Seleccione el terreno y en el Inspector, busque el botón «Establecer: Predeterminado» (es un cuadro desplegable) y seleccione «Agregar capa».

Ahora seleccione «suelo» como capa para nuestra plataforma, y ​​repita esto para cualquier otra plataforma en la ventana del juego. Seleccione «La capa de la tierra» en nuestro objeto de sprite de personaje principal, también seleccione la capa de tierra.

Lo que hemos hecho es indicarle al reproductor de guiones que haga una comprobación: ambos el pequeño punto en la pantalla se superpone con cualquier cosa que coincida con la capa, el personaje solo saltará si eso es cierto.

Game Over on Collision y menú de juego

Entonces, para devolverlo, las últimas cosas que queremos hacer son A: cruzar un juego con obstáculos, y B: crear una pantalla de menú de «fin de juego» con un botón de reproducción nuevamente.

Lo que básicamente quieres hacer es:

  1. Poner un Jugador objetar y asignar cuerpo rígido y un impactador de tu preferencia.
  2. Pon el Enemigo objetar y asignar cuerpo rígido y un impactador de tu pie por él. (y opcional, agregue Etiqueta enemiga él)
  3. Crear nuevo Secuencia de comandos de C # y agregarlo como un componente con Jugador (o use cualquier script adjunto al jugador, no es necesario crear uno nuevo si ya tiene uno)
  4. Incluya esto en su guión:
void OnCollisionEnter(Collision coll){
           Debug.Log("Collision"); //Check to see if it even registers a collision, if it works you can remove this line
           if(coll.gameobject.tag == "Enemy"){ //sees if the object your player collided with has a tag called "Enemy", this can be replaced with if(coll.gameobject.name == ... but using a tag is an easy way to do it.
                    //Add your code here, like:
                    Application.LoadLevel("GameOver");
                    Debug.Log("Working");  //if working, you can remove this line.
           }

Juega con ese script de ejemplo: con un poco de prueba y error, logras que haga exactamente lo que queremos.

Ahora, para ver exactamente cómo crear un GameOver de «nivel» con un botón de reproducción, consulte la última parte de la guía Appual «Cómo crear un juego básico de plataforma Unity Pt. 2 ”.

Deja un comentario