Cómo hacer una aplicación de Android usando Unity

Antes de comenzar, probablemente debería mencionar que este será un tutorial bastante largo. Así que prepárense. Al final de este tutorial podrás enfrentarte al mundo (en sentido figurado).

Hace aproximadamente 2 años, me adentré en un nuevo territorio y tomé un curso de Diseño de juegos. Nunca antes había intentado hacer un juego correctamente. Intenté ingresar a la programación, pero no pude comprometerme. Escribí tal vez un par de programas de línea de comandos muy básicos que duraban unas pocas líneas y luego me rendí porque no podía entenderlo.

Entonces, cuando realmente comencé mi curso, definitivamente no estaba acostumbrado. Durante los dos años, aprendí mucho e hice un progreso muy bueno e incluso diseñé y programé algunos juegos y aplicaciones, 2 de los cuales son para Android.

Entrando en un poco más de detalle. Como este era un curso, tenía que aprender todo lo relacionado con el diseño y desarrollo de juegos. Aprendí a generar ideas de juegos, cómo escribir una historia para el juego, cómo conceptualizar personajes (en realidad no he diseñado ningún personaje), cómo crear un documento de diseño del juego (que es muy útil, no tiene para ser extremadamente detallado si eres un desarrollador independiente), cómo usar Unity Game Engine para crear el juego, cómo probarlo correctamente y cómo construir un juego para diferentes plataformas.

Paso 1: tabla de contenido

1. Tabla de contenido
2. Cosas que debe saber antes de comenzar
3. Cómo configurar Unity y Android Studio
4. Configuración de proyectos y creación de prefabricados de partículas
5. Crear y agregar secuencia de comandos de efectos
6. Crear y agregar controles táctiles
7. Pruebas
8. Crear menú principal y HUD
9. Jerarquía Organizadora
10. Conclusión

Paso 2: Cosas que debes saber antes de comenzar

Mucha gente podría tener la idea errónea de que el diseño / desarrollo del juego es extremadamente difícil y requiere muchos conocimientos previos para poder crear uno. Sin embargo, esto está lejos de la verdad. El uso de un motor de juego reducirá drásticamente la curva de aprendizaje y le permitirá concentrarse más en hacer que el juego sea divertido. Hay una variedad de motores de juego diferentes, las opciones más populares son:

• Unidad
• Motor irreal
• Motor grito

Unity y Unreal Engine son más populares que CryEngine. Esto se debe a que están dirigidos a desarrolladores independientes junto con desarrolladores de AAA, a diferencia de CryEngine, que está dirigido solo a desarrolladores de AAA. La diferencia entre Indie y AAA:

Las Indias están formadas por pequeños equipos, generalmente de 1 a 20 personas y no tienen grandes cantidades de fondos, etc.

Algunos ejemplos de desarrolladores independientes:

• Estudios de manchas de café
• Halfbrick Studios
• Mojang
• Creaciones Ndmeic

Los AAA están compuestos por equipos mucho más grandes y tienen mucha experiencia en la industria junto con muchos fondos. Algunos ejemplos:

• EA
• Ubisoft
• Gameloft
• Treyarch
• Activision

Un motor de juego es un programa diseñado para facilitar el diseño / desarrollo del juego. En lugar de tener que codificar cada aspecto del juego usted mismo, simplemente puede escribir el comportamiento usando un motor de juego. Esto es posible por el hecho de que los motores de los juegos hacen mucho trabajo por usted, cosas como la física, la iluminación, el renderizado, etc., se hacen por usted. Todo lo que tiene que hacer es crear los objetos del juego (estos son solo contenedores con diferentes elementos adjuntos), configurar el orden y el diseño, asignar las propiedades relevantes a los objetos del juego y escribir el comportamiento.

Algunos motores de juego en realidad te permiten crear un juego completo sin ningún tipo de codificación, el más popular es Unreal Engine. Cuenta con un sistema Blueprints, que utiliza una estructura basada en nodos (que es esencialmente un sistema que usa cuadros y flechas. Estos cuadros y flechas están vinculados si son parte de la misma función). Digamos que desea interceptar la entrada del teclado (esto solo significa decirle al programa que busque una tecla presionada en el teclado) y luego hacer que el reproductor se mueva mientras se mantenga presionada esa tecla específica. Crearía un nodo base, que contendría las subfunciones necesarias. En ese nodo base, declararía la clave que deseaba usar, luego crearía otro nodo que le indicaría al juego qué hacer. El nodo base sería una caja que contiene la función para presionar la tecla.

En este caso, el segundo nodo hará que el jugador se mueva en una dirección (hacia adelante, por ejemplo) siempre que la tecla "W" se mantenga presionada. El segundo nodo sería otro cuadro vinculado al primer cuadro. Esto es extremadamente útil, no solo para diseñadores, sino también para programadores, ya que les permite crear rápidamente prototipos. Unity también tiene esta característica, que se conoce como scripting visual. Sin embargo, toma la forma de un activo que debe comprar.

La unidad es realmente mejor para los principiantes que buscan hacer juegos, ya que te enseña a escribir. Unreal Engine es mucho más avanzado, aunque presenta secuencias de comandos visuales. Lo que significa que hay una curva de aprendizaje más grande.

Paso 3: Cómo configurar Unity y Android Studio

Así que ahora sabes un poco más sobre los motores de juego y cómo funcionan. Este tutorial utilizará Unity 5.3.5, que es la última versión en este momento. Te enseñaré cómo crear una aplicación de Android estéticamente agradable. Este tutorial asume que tienes una comprensión básica del uso de Unity. Si es un principiante completo y desea seguir este tutorial, visite este enlace para familiarizarse con los conceptos básicos de Unity: //pixelnest.io/tutorials/2d-game-unity/

Asegúrese de tener siempre la última versión de Unity, ya que contienen correcciones de errores y mejoras. Si tiene una versión anterior de Unity, podría encontrarse con errores. Estos errores generalmente se pueden solucionar actualizando. También debo mencionar que la construcción de cualquier plataforma móvil requiere el SDK respectivo instalado en su computadora (para Android, necesita Android Studio. Para iOS, necesita una Mac con Xcode instalado). Para descargar Android Studio, siga este enlace y configúrelo usando las instrucciones proporcionadas en el sitio web: //developer.android.com/studio/index.html

Una vez que esté instalado, deberá instalar los controladores para su teléfono abriendo Android Studio, haciendo clic en Configurar> Administrador de SDK y luego en Iniciar Administrador de SDK independiente. Se abrirá una nueva ventana, desplácese hasta el final y asegúrese de que tanto el USB de Google como los controladores web estén seleccionados. Puede dejar los otros componentes seleccionados por defecto. Luego haga clic en Instalar paquetes en la parte inferior derecha y espere a que se instale. Una vez hecho esto, vaya a la aplicación Configuración en su teléfono> Acerca / Acerca del teléfono> Información del software y busque el encabezado "Número de compilación". Debe ser una colección de números con decimales y "teclas de liberación" añadidas al final. Toca el "Número de compilación" varias veces hasta que aparezca "Felicitaciones, ahora eres un desarrollador" o algo similar. Luego, regrese a la página de Configuración principal y busque "Opciones de desarrollador". Haga clic en él y busque la casilla de verificación "Depuración de USB". Asegúrese de que esté marcado. Luego, conecte su teléfono a su computadora y asegúrese de que se muestre "Depuración USB habilitada" o algo similar en la barra de notificaciones, lo más probable es que necesite expandir la barra para ver el mensaje.

Independientemente de si desea instalar los controladores para que su teléfono lo use en Unity, necesitará tener instalado Android Studio, ya que sin él no puede construir la aplicación para su teléfono. Si configurar los controladores es demasiado tedioso, siga las opciones alternativas en la sección Pruebas de este tutorial. Una vez que haya instalado Android Studio y configurado la depuración USB, puede volver y seguir este tutorial.

Este tutorial se basó en otro tutorial, le proporcionaré el enlace si desea verlo. //pixelnest.io/tutorials/unity-touch-controls ...

Mi tutorial cubre más que el original (Menú, HUD y Pruebas). El lenguaje de programación que usaré para este tutorial es C #. Unity también admite JavaScript, sin embargo, C # tiene características más avanzadas, aunque es un poco más difícil de aprender. Usted es libre de convertir el código C # a JS si ya conoce JS, pero desafortunadamente, no podré dar cuenta de ningún error específico de idioma si elige usarlo. También te enseñaré algunos consejos y trucos que he aprendido durante mi tiempo haciendo juegos. Vamos a empezar.

Paso 4: configuración del proyecto y creación de prefabricados de partículas

Configuración de proyecto

Una vez que haya creado con éxito su proyecto, asegúrese de tener las siguientes carpetas en su carpeta de activos:

• Fuentes
• Materiales
• Menú
• Prefabricados
• Escenas
• Guiones
• Texturas

Estas son las únicas carpetas que necesitará para este proyecto. Sin embargo, si decide ampliarlo, puede agregar otras carpetas como mejor le parezca (sonidos, animaciones, etc.)

Una vez que haya creado las carpetas anteriores, vaya a Archivo> Configuración de compilación. En esta ventana, haga clic en la opción de Android debajo del encabezado "Plataformas", luego haga clic en "Cambiar plataforma" en la esquina inferior izquierda. Esto le dirá a Unity que estás compilando para Android y configurará el proyecto respectivamente. Necesitará Android Studio instalado para que esto funcione. Luego guarde la escena presionando Ctrl + S o eligiendo "Guardar escena" en el menú Archivo. Guarde esta escena como "Escena principal" en su carpeta "Escenas".

Crear prefabricados de partículas

Arriba hay una imagen de una estrella con un fondo negro. Guarde esta imagen en su carpeta Texturas. Lo usará para el sistema de partículas.

Establezca el Tipo de textura en Textura haciendo clic en la imagen en su carpeta Texturas y seleccionando el valor apropiado en el Inspector, luego haga clic en Aplicar. Asegúrese de que la casilla "Alfa es Transparencia" está marcada. Esto hará que el fondo de la estrella sea transparente.

Luego cree un Sistema de partículas y configúrelo utilizando los valores que se muestran en la captura de pantalla anterior.

Si lo desea, puede modificar estos valores, son solo una guía. Jugar con estos valores le dará una mejor comprensión de cómo funciona.

Asegúrese de que la textura del sistema de partículas esté establecida en la textura de estrella expandiendo el sombreador y seleccionando la textura de estrella en el cuadro de la derecha. O simplemente arrastre y suelte la imagen de su carpeta Texturas en el cuadro. También seleccione Mobile / Particle / Alpha Blended Shader haciendo clic en el cuadro desplegable junto a Shader, luego Mobile> Particles> Alpha Blended. Esto le indicará al sistema de partículas que haga que el fondo de Star sea transparente y lo optimizará para Android. Cambie el nombre en la parte superior del Inspector a "Explosión" y haga lo mismo en la Jerarquía. Luego arrastre este Sistema de partículas de explosión desde la Jerarquía a su carpeta Prefabs en la vista Proyecto. Esto creará una prefabricación de ese sistema de partículas.

A continuación, crearemos un Trail Prefab, que dibujará un rastro siempre que arrastre el dedo por la pantalla. Cuando levantas el dedo, el rastro desaparecerá después de un par de segundos.

Cree un nuevo Objeto de juego vacío (haga clic con el botón derecho en la jerarquía y seleccione "Crear vacío") y llámelo Trails o algo similar. Luego agregue un componente Trail Renderer. Configúrelo utilizando los valores proporcionados en la captura de pantalla anterior.

Cree un nuevo material haciendo clic en la carpeta Materiales en la vista del proyecto, luego haga clic con el botón derecho en la vista del proyecto y haga clic en Crear> Material. Nombre el material como material de senderos o estera de senderos.

Luego haga clic en el Objeto de Juego de Senderos en la Jerarquía y arrastre y suelte el Tapete de Senderos desde la vista de Proyecto a la ventana del Inspector. Esto asignará el material al objeto del juego Trails. Luego arrastre este Objeto de juego de Trails a su carpeta Prefabs para convertirlo en Prefab.

Finalmente, crearemos otro sistema de partículas que será diferente al primero. Este explotará hacia afuera lentamente, no tendrá gravedad y se desvanecerá lentamente. Cree otro Sistema de partículas, etiquételo Explosión de pellizco (usaremos un gesto de pellizco para inicializarlo). Asegúrese de que el material estelar esté asignado a este sistema de partículas y luego hágalo en un prefabricado.

Estos son todos los efectos que utilizaremos. Siéntase libre de crear más si lo desea, o modificar los existentes. Una última cosa antes de que podamos pasar a la programación. Haga clic en la cámara principal en la jerarquía. Cambie el Color de fondo a negro u otro color oscuro y cambie su Tamaño (debajo del cuadro desplegable Proyección) de 5 a 10. Esto le permitirá ver más fondo. Mire la captura de pantalla final anterior si está confundido.

Paso 5: Crear y agregar secuencia de comandos de efectos

Creando el Script

Ahora que hemos creado todos los prefabricados, podemos pasar a la programación. Tendrá que escribir bastante código, ya que este es un tutorial más avanzado. De hecho, tengo un documento que explica los conceptos básicos de la programación si estás interesado. Esta es también otra lectura extensa. Lo he subido a Dropbox, aquí está el enlace:

//bit.ly/29qhLDx

Cree un nuevo script C # en su carpeta Scripts (haga clic en la carpeta Scripts, luego haga clic con el botón derecho en la ventana del proyecto> Crear> C # Script) y etiquete este script como "Efectos especiales". Ábralo en su IDE (Entorno de desarrollo integrado) deseado y escriba el código a continuación, palabra por palabra. La razón por la que le estoy diciendo que lo escriba palabra por palabra en lugar de copiarlo / pegarlo es porque escribirlo le permitirá comprender qué hace mejor el código. También lo llevará a la práctica de verificar su código en busca de errores. Aquí está el código:

 {/ * Hace que esta secuencia de comandos sea una estática privada, lo que significa que no se puede acceder a las funciones de esta secuencia de comandos fuera de esta secuencia de comandos y sus valores nunca cambian a menos que se lo indique específicamente a * / instancia de efectos especiales estáticos privados; 

 // Estos son los prefabricados públicos ParticleSystem explosionEffect, pinchExplosionEffect; GameObject trailPrefab público; 

 / * Esta función se activa cuando el script se inicializa por primera vez, antes de la función de Inicio. La función Inicio requiere que este script esté habilitado, pero la función Awake se ejecuta independientemente de si este script está habilitado * / void Awake () {// Asignando el valor de instancia a este script instancia = this; } 

 // Use esto para la inicialización void Start () {// Asegurarse de que todos los prefabricados estén activados si (explosionEffect == null) Debug.LogError ("Falta el efecto de explosión"); if (pinchExplosionEffect == null) Debug.LogError ("Falta el efecto de explosión de pellizco"); if (tracksPrefab == null) Debug.LogError ("Missing Trails Prefab"); } 

 // Explosion Effect public static ParticleSystem MakeExplosion (posición Vector3) {// Si esta secuencia de comandos está desactivada, registre un error if (instancia == nulo) {Debug.LogError ("No hay secuencia de comandos SpecialEffects en la escena"); volver nulo; } 

 // Crea el efecto de explosión en la posición dada ParticleSystem effect = Instantiate (instance.explosionEffect) como ParticleSystem; effect.transform.position = position; // Destruye el efecto de explosión después de que el efecto haya completado la destrucción (effect.gameObject, effect.duration); efecto de retorno; } 

 // Pinch Explosion Effect public static ParticleSystem MakePinchExplosion (posición Vector3) {// Si esta secuencia de comandos está desactivada, registre un error if (instancia == nulo) {Debug.LogError ("No hay secuencia de comandos de efectos especiales en la escena"); volver nulo; } 

 // Crea una explosión de pellizco en la posición especificada ParticleSystem effect = Instantiate (instance.pinchExplosionEffect) como ParticleSystem; effect.transform.position = position; efecto de retorno; } 

 // Trail Effect public static GameObject MakeTrail (posición Vector3) {// Si esta secuencia de comandos está deshabilitada, registre un error if (instancia == nulo) {Debug.LogError ("No hay secuencia de comandos de efectos especiales en la escena"); volver nulo; } // Crea una nueva ruta en la posición establecida GameObject trail = Instantiate (instance.trailsPrefab) como GameObject; trail.transform.position = position; camino de regreso; } 

Agregar el guión a la escena

Mira, eso no fue demasiado difícil, ¿verdad? Ahora que tenemos este guión listo, podemos agregarlo a la escena. Cree un nuevo Objeto de juego vacío, etiquételo como Scripts y arrastre el Script desde su carpeta Scripts al Objeto de juego Scripts.

Ahora asigne las Variables a sus respectivos Prefabs arrastrando el Prefab desde la carpeta Prefabs en la Vista del Proyecto a las propiedades de Scripts en la Ventana del Inspector. Vea la captura de pantalla anterior como referencia.

Paso 6: Crear y agregar secuencia de comandos de controles táctiles

Creando el Script

Ahora es el momento de programar los controles táctiles para esta aplicación. La función principal de esta aplicación es desencadenar efectos cuando se toca la pantalla. Los tres gestos que utilizaremos serán un toque, un deslizamiento y un pellizco para hacer zoom. También puede agregar más gestos si lo desea, pero tendrá que hacerlo por su propia cuenta.

Los efectos que activamos variarán según el tipo de entrada táctil (tocar, deslizar, pellizcar para hacer zoom, etc.) Esto nos permitirá garantizar que se reconozca el gesto correcto.

El método en el que detectaremos estos gestos es usar la clase "Entrada" de Unity, que consolida toda la información sobre cada tipo de Entrada en una ubicación. Algunos ejemplos de otras entradas son teclado, controladores de consola o táctiles.

Unity tiene una subclase específica llamada Input.touches y contiene los eventos para los distintos tipos de toques junto con su estado en un marco determinado.

Un Touch es un contenedor que contiene la información sobre los distintos dedos, que analizaremos mientras programamos los controles táctiles.

El primer tipo de método táctil que implementaremos es un pellizco, luego el toque y luego el deslizamiento. Un pellizco es cuando la pantalla se toca con dos dedos y se arrastra hacia afuera o hacia adentro. Un toque es cuando se toca la pantalla por un corto período de tiempo (generalmente un segundo). Es similar a hacer clic con el mouse. Un deslizamiento es cuando se toca la pantalla con un dedo y se arrastra a lo largo de la pantalla.

Cree un nuevo script en su carpeta Scripts y etiquételo como "TouchControls". Luego escriba el siguiente código en la función Actualizar.

 usando UnityEngine; usando System.Collections.Generic; 

 TouchControls de clase pública: MonoBehaviour {private Dictionary trail = new Dictionary (); toque privado pinchFinger1, pinchFinger2; ParticleSystem pinchExplosion privado; 

 // Use esto para la inicialización void Start () {} // Update se llama una vez por frame void Update () {// Estos son los controles táctiles 

 // Utiliza un bucle para buscar todos los dedos // Controles para pellizcar para hacer zoom, solo funciona con 2 dedos // Si hay 2 dedos en la pantalla si (Input.touchCount == 2) {// Asigna estos 2 dedos a sus propias variables var finger1 = Input.GetTouch (0); var finger2 = Input.GetTouch (1); 

 if (finger1.phase == TouchPhase.Began && finger2.phase == TouchPhase.Began) {this.pinchFinger1 = finger1; this.pinchFinger2 = finger2; } 

 // Cuando los dedos se hayan movido, actualice el script a la nueva ubicación si (finger1.phase == TouchPhase.Moved || finger2.phase == TouchPhase.Moved) {float baseDistance = Vector2.Distance (this.pinchFinger1.position, this.pinchFinger2.position); float currentDistance = Vector2.Distance (finger1.position, finger2.position); 

 // Float flotante currentDistancePurcent = currentDistance / baseDistance; 

 // Crea el efecto entre los dedos si actualmente no existe if (pinchExplosion == null) {Vector3 finger1Position = Camera.main.ScreenToWorldPoint (this.pinchFinger1.position); Vector3 finger2Position = Camera.main.ScreenToWorldPoint (this.pinchFinger2.position); 

 // Encuentra el centro entre los 2 dedos Vector3 pinchExplosionPosition = Vector3.Lerp (finger1Position, finger2Position, 0.5f); pinchExplosion = SpecialEffects.MakePinchExplosion (pinchExplosionPosition); } 

 // Toma la escala base y la aumenta o disminuye pinchExplosion.transform.localScale = Vector3.one * (currentDistancePurcent * 1.5f); }} 

 else {// Si se ha liberado el pellizco if (pinchExplosion! = null) {// Crear explosiones para (int i = 0; i <10; i ++) {var explosion = SpecialEffects.MakeExplosion (pinchExplosion.transform.position); explosion.transform.localScale = pinchExplosion.transform.localScale; } 

 // Destruye el efecto Pinch Explosion Destroy (pinchExplosion.gameObject); } 

 // Efecto Tap // Comprueba todos los dedos para (int i = 0; i <Input.touchCount; i ++) {Touch touch = Input.GetTouch (i); 

 // Un toque es un toque rápido y suelta si (touch.phase == TouchPhase.Ended && touch.tapCount == 1) {// Los toques son ubicaciones de pantalla, esto los convierte en ubicaciones mundiales Vector3 position = Camera.main. ScreenToWorldPoint (touch.position); 

 // Crea el efecto de explosión SpecialEffects.MakeExplosion ((position)); } 

 else {// Controles para el gesto de deslizamiento if (touch.phase == TouchPhase.Began) {// Almacene este nuevo valor if (tracks.ContainsKey (i) == false) {// Los toques son ubicaciones de pantalla, esto los convierte en ubicaciones mundiales Vector3 position = Camera.main.ScreenToWorldPoint (touch.position); // Asegura que el camino sea visible position.z = 0; 

 // Crea el efecto Trails GameObject trail = SpecialEffects.MakeTrail (position); 

 // Si el camino todavía está habilitado if (trail! = Null) {// Registre el camino Debug.Log (trail); // Agrega más senderos Trails.Add (i, trail); }}} 

 de lo contrario if (touch.phase == TouchPhase.Moved) {// Mueve el camino if (tracks.ContainsKey (i)) {// Matriz para el GameObject Trails trail = trail [i]; 

 // Convierte toques en ubicaciones mundiales Camera.main.ScreenToWorldPoint (touch.position); Vector3 position = Camera.main.ScreenToWorldPoint (touch.position); // Asegura que el rastro sea visible position.z = 0; 

 // Establece la posición de los senderos en la posición del dedo trail.transform.position = position; }} 

 sino if (touch.phase == TouchPhase.Ended) {// Borra todos los senderos visibles if (tracks.ContainsKey (i)) {GameObject trail = tracks [i]; 

 // Los fundidos desaparecen Destroy (trail, trail.GetComponent (). Time); senderos. Eliminar (i); }}}}}}} 

Para la función Tap, recuperamos la ubicación de todos los dedos colocados en la pantalla, ya sea uno o cuatro, y luego creamos un efecto de Explosión cuando el dedo ha sido retirado de la pantalla, en la posición donde estaba, antes de se quitó el dedo.

Para la función Arrastrar, se creó una nueva variable. Necesitamos esta variable para crear el enlace entre un dedo y un Trail. Lo que hace el código:

Si se ha creado un nuevo toque, cree un nuevo Trail y vincúlelo al dedo por medio del diccionario.

Cuando se mueve el dedo, siempre que el dedo tenga un rastro vinculado a él, la posición del objeto del juego de rastro se mueve junto con el dedo.

Cuando se levanta el dedo, se destruye el rastro.

Para la función Pinch se crearon tres nuevas variables más. Estas variables almacenaron la primera posición de los dedos, que luego usamos para calcular la diferencia entre la distancia de los dedos. También se creó una variable para el efecto Pinch Explosion para que podamos actualizarlo y destruirlo.

La función Pinch era más complicada, debido al hecho de que no queríamos que se confundiera con otra cosa.

Para la función Pinch, si se detectan dos dedos en la pantalla, se crea un nuevo efecto Pinch Explosion entre las dos posiciones. Después de eso, el gesto se declara como un pellizco. Si se mueven los dedos, el objeto del juego Pinch Explosion también se mueve y se escala junto con él.

Una vez que la Explosión de pellizco se ha completado, o si se levanta un dedo de la pantalla, cambia a la Explosión de toque normal.

Agregar el guión a la escena

Ahora que la secuencia de comandos de controles está completa, agréguela a la escena de la misma manera que la secuencia de comandos anterior o no funcionará.

Esa es la programación principal realizada. Todavía tendremos que programar un poco más para el Menú y el HUD, pero será mucho menos y más fácil de entender. Pero, antes de pasar al Menú, necesitamos probar la aplicación para ver si funciona como debería.

Paso 7: prueba

Las pruebas son cruciales al desarrollar cualquier tipo de software. Sin pruebas, no sabría si todo funciona como debería.

Idealmente, debería realizar pruebas tan pronto como implemente una nueva característica, sin embargo, para los fines de este tutorial, estamos probando después de haber implementado la mayoría de las características.

Existen múltiples métodos de prueba. La más efectiva es construir y ejecutar la aplicación en un teléfono Android a medida que avanza. En realidad, Unity le permite administrar esto fácilmente, siempre que tenga instalados los controladores correctos.

Antes de que realmente pueda construir y probar la aplicación, deberá configurar un par de cosas. Vaya a Edición> Configuración del proyecto> Reproductor. En la parte superior de la ventana del Inspector verá "Nombre de la empresa" y "Nombre del producto". Cambie estos a lo que desee. A continuación, expanda la pestaña "Otras configuraciones" si aún no lo está y vaya a "Identificador de paquete". Cambie esto a com.CompanyNameYouSet.ProductNameYouSet. En mi caso, el nombre de mi compañía es U y el nombre de mi producto es Instructables, por lo que mi Identificador de paquete es Com.U.Instructables. Si no cambia esto, no podrá compilar la aplicación para Android.

Si tiene instalados los controladores, simplemente vaya a Configuración de compilación en el menú Archivo. Luego haga clic en "Agregar escenas abiertas". Debe agregar la "Escena principal" a la lista y darle el número "0". Una vez hecho esto, asegúrese de que su plataforma seleccionada sea Android y que su teléfono esté conectado a su computadora, luego haga clic en "Build and Run". Sin embargo, Unity comenzará a compilar su aplicación, antes de que pueda completar completamente la compilación, requerirá la ubicación de su SDK de Android. Para encontrar esta ubicación, abra Android Studio> Configurar opciones> Administrador de SDK y luego busque en la parte superior la "Ubicación del SDK de Android". Esta es la ubicación a la que debe apuntar Unity. Una vez que Unity sepa dónde está el SDK, continuará construyendo su aplicación. Una vez que la aplicación haya terminado de compilarse, la ejecutará automáticamente en su teléfono. Entonces puedes jugar con la aplicación y disfrutar de tu arduo trabajo. Pruebe todos los gestos para asegurarse de que todos funcionen.

Otro método simple de prueba sería hacer clic en "Construir" en lugar de "Construir y ejecutar" y luego elegir una ubicación para guardar el .apk (extensión de archivo de Android para sus aplicaciones). Una vez que este archivo se haya guardado y creado, deberá transferirlo al almacenamiento de su teléfono e instalarlo manualmente en su teléfono. Este es el modo en que enviará su aplicación a otras personas si así lo desea.

Otra forma de prueba es a través del Editor de Unity. Al presionar el botón Reproducir en la parte superior de la pantalla en el medio, Unity creará y ejecutará su aplicación / juego. Esto le evita tener que usar su teléfono para pruebas menores. Sin embargo, si desea utilizar este método para probar su juego en Android, deberá descargar Unity Remote 4 desde Google Play Store o iOS App Store. El control remoto de Unity te permite probar tu juego en Unity, sin tener que crear una versión completa cada vez. Ahorra mucho tiempo. Una cosa para mencionar es que reduce la calidad de los gráficos en su teléfono. Pero esto es necesario. Todavía hace un buen trabajo al mostrarle cómo se verá su aplicación / juego en su teléfono. Si está compilando para PC (Windows), puede probar el juego en el editor sin herramientas adicionales. Asegúrese de salir del modo Play en Unity después de haber probado su juego, ya que cualquier cambio realizado en cualquier componente se revierte cuando sale del modo Play.

Estos métodos son los más efectivos cuando se trata de probar tu juego, ya que puedes ver si tu código funciona como debería. Sin embargo, existen otros métodos que también puede usar, estos métodos son para Microsoft Visual Studio, que es el IDE que uso, pero también deberían ser sinónimos de otros IDE.

Un método son los puntos de interrupción. Digamos que escribes un código y luego te encuentras con un error. No sabes exactamente dónde va mal tu código, pero tienes una idea general. Por lo tanto, agregaría puntos de interrupción arriba, abajo y en el código defectuoso. Los puntos de interrupción detendrán el programa cuando llegue al punto de interrupción y le brindarán información sobre el programa hasta ese punto de interrupción.

Para crear un punto de interrupción, busque la línea donde cree que su código está yendo mal y haga clic en el primer margen a la izquierda. Debe ser un color más claro que la página principal. Debería aparecer un punto rojo y si pasa el cursor sobre el punto rojo, le indicará la ubicación del punto de interrupción. Vea la captura de pantalla como referencia.

En la captura de pantalla, he usado la línea "if (explosionEffect == null" como error. Una vez que tenga el punto de interrupción, aún en Visual Studio, haga clic en Debug> Start Debugging o presione F5 en el teclado. Esto ejecutará el programa dentro Unidad y vincúlelo a VS y en la parte inferior de la ventana VS aparecerá una barra roja que dice "Listo".

Ahora ve a Unity y haz clic en el ícono Play. Esto ejecutará la aplicación / juego hasta el punto de interrupción, momento en el que volverá a la ventana VS con información sobre cómo se ejecuta el programa hasta el punto de interrupción. Si su juego / aplicación funciona bien hasta el punto de interrupción, entonces esa línea no es la que tiene el error. Sin embargo, si su programa arroja un error antes del punto de interrupción o no se ejecuta en absoluto, entonces podría ser esa línea o las líneas por encima de ella. Para encontrar la línea errónea, deberá seguir agregando puntos de interrupción hasta que la haya localizado. El método más rápido es agregar múltiples puntos de interrupción a la vez en lugar de uno. Esta es una muy buena forma de prueba y le permite ser más preciso.

Una vez que haya completado su prueba, presione Shift + F5 para finalizar la depuración en VS o regrese al menú Depurar y haga clic en "Detener depuración". Esto detendrá la depuración y permitirá que el proyecto de Unity se reproduzca normalmente.

Al realizar la prueba, asegúrese de utilizar una combinación de estos métodos en lugar de solo uno, ya que le permitirá ubicar exactamente dónde se equivocó.

También tenga cuidado con la ortografía y la sintaxis, los lenguajes de programación pueden ser bastante implacables y C # es uno de estos lenguajes. Si deletrea algo incorrecto, obtendrá un error, y será difícil localizar este error ya que ni VS ni Unity tienen en cuenta los errores ortográficos. He pasado horas tratando de corregir un error, solo para descubrir que deletreé mal una función o variable. Revisar su ortografía y sintaxis a medida que avanza es un buen hábito, ya que le ahorrará horas en la depuración. Si llega al punto en que ha cuadruplicado su código y aún no puede descubrir qué está mal, pídale a otra persona que lo vea. Lo ideal sería que quisieras otro programador o alguien que al menos tenga conocimientos de programación, pero si no tienes a nadie que conozca la programación, busca a alguien que esté contigo en ese momento para verlo. Dígales que busquen específicamente los errores ortográficos, ya que podrían identificarlos cuando usted no pueda.

Trate de no frustrarse demasiado si comete un error de ortografía y le toma años encontrarlo. Le pasa a todo el mundo. Es una de las alegrías de ser programador.

Ahora que hemos cubierto las pruebas, podemos pasar a crear el Menú y el HUD.

Paso 8: Creación del menú principal y HUD

Crear un Menú / HUD para su aplicación es realmente crucial. El menú principal le da al jugador información sobre su aplicación y generalmente les permite controlar ciertos aspectos de la aplicación. Para este tutorial, no aprenderemos cómo programar el Menú para que el reproductor pueda cambiar la configuración porque en realidad no hay nada que el jugador pueda cambiar (no hay sonido, música, etc.) Estoy contemplando agregar algunos efectos de sonido y posiblemente música, pero vendrán en un tutorial posterior. El menú principal que crearemos será bastante básico pero estéticamente agradable. Tendremos un Título y tres botones (Reproducir, Ayuda y Salir). El botón Reproducir lo llevará a la escena principal, el botón Ayuda lo llevará a un Panel con el Archivo de ayuda y el botón Salir simplemente se cerrará el juego. Le mostraré dos formas de implementar el botón Salir, el primer método será un poco más simple.

Puedes usar cualquier fuente, imagen de fondo, etc. que desees, siempre que se ajuste al tema del juego. También asegúrate de que tus activos para tu juego estén libres de derechos de autor o se puedan usar comercialmente si planeas lanzarlo en una tienda de aplicaciones, de lo contrario podrías encontrarte con algunos problemas legales. Para este tutorial, usaré esta imagen de la Región del Centro Galáctico:

//bit.ly/29eP2jB

Y estas fuentes:

//www.dafont.com/fineliner-script.font

//www.dafont.com/post-it-penscript.font

Las fuentes se adjuntan al final de este paso y la imagen se encuentra en la parte superior si desea utilizar estos activos para su aplicación.

Una vez que haya descargado las fuentes e imágenes que desea usar, impórtelas a su proyecto de Unity en sus carpetas respectivas (las fuentes van en la carpeta de fuentes y la imagen va en la carpeta del menú).

Crear el menú

Para crear el menú necesitamos crear una nueva escena. Presione Ctrl + N o vaya a Archivo> Nueva escena. Guárdelo como Menú o Menú principal.

Ahora que tenemos nuestra escena, necesitamos agregar un lienzo. Este lienzo nos permite utilizar todas las características de la interfaz de usuario que requerimos. Piense en ello como una superposición que siempre tiene el tamaño exacto de su pantalla.

Para crear un lienzo, haga clic derecho en Jerarquía> UI> Lienzo. En la ventana del Inspector del lienzo, asegúrese de que el Modo de renderizado esté configurado en Espacio de pantalla - Superponer y marque la opción Pixel Perfect. Debajo del componente Canvas Scaler, cambie el modo de escala de Tamaño de píxel constante a Escalar con tamaño de pantalla. Esto permite que todos los componentes del lienzo se escalen hacia arriba o hacia abajo si la resolución de la pantalla aumenta o disminuye. Cambie la resolución de referencia a la resolución de la pantalla de su teléfono en la vista horizontal (la mía es 1920 x 1080) y cambie el valor de coincidencia de 0 a 0.5. Esto asegurará que los componentes se escalen por igual en Ancho y Altura.

Ahora necesita cambiar su Vista de juego para que coincida con la Resolución de referencia de su Canvas. Para hacer esto, haga clic en la pestaña Juego en la parte superior, debe tener un ícono de Pacman a la izquierda. Si no puede verlo, vaya a Ventana> Juego, o presione Ctrl + 2. Mire a la esquina superior izquierda de la ventana Juego y debería ver un cuadro desplegable que dice Aspecto libre. Haz click en eso. En la parte inferior, debe haber un ícono Más, haga clic en eso y cambie el Tipo de Relación de aspecto a Resolución fija. Rotúlelo a la resolución de pantalla de su teléfono (la mía es 1080p) y cambie el ancho y la altura para que coincida con la resolución deseada. Esto le permitirá escalar sus componentes para que se muestren correctamente en su teléfono. Si lo mantuvieras en Free Aspect, sería difícil escalar tus componentes adecuadamente.

Cree un Panel (de la misma manera que creó el Canvas, solo que esta vez, elija el Panel). Si su lienzo ya está seleccionado, entonces el panel debería convertirse automáticamente en hijo del lienzo.

En Unity, los niños y los padres son extremadamente importantes. Un hijo es un subconjunto del padre, hereda ciertas cualidades del padre. Para diferenciar entre un niño y un padre: un padre tendrá una flecha a la izquierda de su nombre en la que puede hacer clic para mostrar u ocultar a los niños.

Para crear un hijo, simplemente necesita hacer clic derecho en un objeto en la Jerarquía y luego crear su objeto hijo desde el Menú que aparece o puede arrastrar cualquier objeto sobre otro para convertirlo en hijo de ese objeto. En la captura de pantalla anterior, he creado un objeto de juego vacío y lo he arrastrado al lienzo para convertir el objeto de juego vacío en un elemento secundario del lienzo. Esto es extremadamente útil y, en algunas ocasiones, crítico. Por ejemplo, si creó un panel fuera del Lienzo (si el Panel era un padre) y deseaba escalarlo al mismo tamaño que el Lienzo, necesitaría averiguar las dimensiones del Lienzo y luego configurar manualmente el Las dimensiones del Panel son las mismas. Sin embargo, si el Panel era un Hijo del Lienzo, entonces podría escalarlo usando los Anclajes (que explicaré más adelante). Si creó el Panel para que sea, de forma predeterminada, un elemento secundario del Lienzo, el Panel se escalará automáticamente al Lienzo. También existe el pequeño problema de que los elementos de la interfaz de usuario no son visibles a menos que sean todos hijos del lienzo. Los padres / hijos también son útiles para organizar la Jerarquía, que también revisaré pronto.

Ahora que tenemos este panel, podemos configurar la imagen de fondo. Antes de hacer eso, debemos nombrarlos apropiadamente, cambiar el nombre del lienzo en la jerarquía a lienzo de menú y cambiar el nombre del panel a imagen de fondo. Ahora haga clic en el Panel de imagen de fondo y mire la ventana del Inspector. Debe haber un componente de Imagen (Script) adjunto. Busque la imagen de origen. Para cambiar esta imagen, arrastre y suelte la imagen descargada desde la ventana de su proyecto al cuadro o haga clic en el símbolo de un círculo con un pequeño punto en el medio. Eso debería abrir otra ventana llamada Seleccionar Sprite. Desde esta ventana puede elegir su fondo. Si no puede ver su imagen, asegúrese de que el tipo de imagen esté configurado como Sprite (2D y UI).

Una vez que haya seleccionado su Fondo, necesitará aumentar el Alfa, para hacerlo, haga clic en el cuadro Color y en la parte inferior habrá un cuadro deslizante con la etiqueta A. Arrastre esto completamente hacia la derecha hasta que esté al final de la sección blanca y su valor se establece en 255. También puede teñir la imagen de un cierto color desde esta misma ventana si lo desea.

Para configurar el título, cree un objeto de texto como elemento secundario de la imagen de fondo. Renombrarlo a Título. Cambia el color del texto a blanco y asegúrate de que cualquier objeto de juego de texto posterior que crees también sea blanco. En la sección de Texto, cámbielo de Nuevo Texto a lo que quiera que sea su Título (en este caso son Instructables) y cambie la fuente a su fuente preferida (usaré la fuente Postit-Penscript). Debajo del encabezado Párrafo, cambie la Alineación a lo que desee, centraré mi texto en los ejes Vertical y Horizontal. A continuación, haga clic en Mejor ajuste y cambie el Tamaño máximo a lo que mejor se adapte a su fuente. Mi fuente es bastante delgada, así que usaré 90 como mi Tamaño máximo. Asegúrese de hacer clic en la opción Mejor ajuste para cada Objeto de juego de texto posterior que cree.

Luego mire hacia la parte superior derecha debajo del encabezado Rect Transform y debería ver un cuadro con líneas y algo de texto en los lados superior e izquierdo del cuadro. Debería decir centro en la parte superior y centro a la izquierda. Haga clic en este cuadro, mantenga presionadas las teclas Alt y Mayús y haga clic en el ícono sobre el ícono central / central. Verifique la captura de pantalla para referencia. Ahora, si cierra el cuadro, debería decir centrar en la parte superior y superior a la izquierda y su texto debería centrarse en la parte superior. Este es el ancla y es extremadamente útil al organizar objetos de juego. Mantener Alt establece la posición del objeto en el nuevo punto de anclaje, y mantener Shift establece el pivote. Le ahorra tener que establecer manualmente las ubicaciones de los objetos.

Si mira a la derecha del cuadro Rect Transform, debería ver un montón de números. Estas son las dimensiones y la ubicación del objeto. En los que desea centrarse son: los cuadros Pos X, Pos Y, Ancho y Altura. El ancho y la altura se explican por sí mismos. La posición X mueve el objeto horizontalmente y la posición Y lo mueve verticalmente. Sin embargo, estos cuadros cambiarán según el Anchor que use. Si usa el anclaje de estiramiento uniforme, la posición X e Y cambiará a derecha, izquierda arriba y abajo, lo que hace lo mismo, pero le permite un mayor control. Puede arrastrar a lo largo de la etiqueta de estos cuadros para mover el objeto, escribir los números manualmente o usar las herramientas de Unity para moverlos. Cambie la Pos Y de 0 a -10. Esto le dará 10 píxeles de espacio desde la parte superior de la imagen de fondo, haciendo que se vea un poco más limpio.

Haga clic en Agregar componente y agregue una sombra y un esquema. Aumenta el alfa de ambos a 255. Esto hará que se destaque más en el fondo. Asegúrate de agregar un componente de sombra y contorno a cada objeto de juego de texto posterior que crees.

Ahora que tenemos nuestro fondo, es hora de configurar los botones. Cree un Objeto de juego vacío como elemento secundario del Panel de imagen de fondo y llámelo Administrador de diseño de botones. En la ventana del Inspector de este Objeto de juego vacío, haga clic en Agregar componente y busque Grupo de diseño vertical y agréguelo al objeto. Este objeto del juego mantendrá la ubicación de los botones consistente. Cambie el Ancla a Estiramiento Uniforme (está en la parte inferior derecha) y cambie la posición y pivote con ella. El Administrador de diseño de botones ahora debería ocupar toda la pantalla. Arrástrelo hacia abajo desde la parte superior hasta que ocupe 3 cuadros de cuadrícula y arrástrelo desde la derecha hasta que ocupe dos cuadros de cuadrícula. Si no puede ver la cuadrícula, mire en la parte superior de la ventana de la escena donde dice Gizmos. Haga clic en eso y luego haga clic en Mostrar cuadrícula.

Ahora cree otro objeto de juego de texto como elemento secundario de la imagen de fondo y configúrelo como desee. Etiquetarlo como Inicio. Si usa varias fuentes, use su segunda fuente para el botón y conserve la primera fuente solo para sus títulos. Usaré la fuente Fineliner_Script para mis botones. Puede hacer que los botones tengan el tamaño que desee, siempre que sean claramente visibles. Una buena regla es hacer que el tamaño del botón sea 10 o 20 píxeles más pequeño que el Título, por lo que si el Título se establece en el tamaño 90, establecería el tamaño del botón en 80 o 70. Estableceré el tamaño de mi botón en 70 Cambie el Texto a Inicio y configure la alineación a lo que desee. Agregue un componente de botón y cambie los colores resaltados y presionados a sus colores preferidos, asegúrese de que el color presionado sea más oscuro que el resaltado. Estableceré mi resaltado en azul claro y el color presionado en un azul más oscuro. Ahora agregue un componente de Sombra y un Esquema y aumente el Alfa al máximo.

Duplica este botón dos veces (haciendo clic derecho en el botón y seleccionando Duplicar o haciendo clic en el botón y presionando Ctrl + D) para que termines con tres botones en total, llama a uno de ellos Ayuda y al otro Salir. Cambie el texto de estos para reflejar sus etiquetas. Conviértalos en hijos del Layger Manager.

Cree un Panel, llámelo Panel de ayuda y configure la Imagen de origen para que sea la misma que la Imagen de fondo. Ya debería ser del tamaño correcto. Aumenta el alfa al máximo. Duplique el Título y conviértalo en un elemento secundario del Panel de ayuda. Cambie el nombre del objeto del juego al título del panel de ayuda y el texto al panel de ayuda. Ya debería estar en la ubicación correcta.

Duplique uno de los botones y cámbiele el nombre a Atrás. Conviértalo en un elemento secundario del Panel de ayuda y luego cambie el Texto del botón a Atrás. Establezca el ancla, posición y pivote en la parte inferior izquierda y cambie la Pos X a 10.

Cree otro Objeto de juego de texto como elemento secundario del Panel de ayuda, etiquételo Cuerpo de texto de ayuda y establezca su Ancla en Estirar uniforme. Cambie el cuadro Superior de 0 a 110. Cambie los cuadros Izquierdo, Derecho e Inferior a 10. Configure la Fuente, use la misma fuente que los Botones. Cambie el Tamaño máximo a 80. Centre el texto en ambos ejes. Luego copie y pegue el siguiente texto en el cuadro Texto:

Esta aplicación te permite crear varios efectos en tu teléfono. Tocar la pantalla creará una explosión, pellizcar la pantalla creará una explosión más grande y arrastrar la pantalla creará un rastro.

O cree su propio texto de ayuda.

Ahora vaya a Archivo> Configuración de compilación> Agregar escenas abiertas. Tu escena del menú ahora debería agregarse. Arrastre su escena de menú a la parte superior para que su número sea 0 y la escena principal sea 1. Si no hace esto, no podrá ver su menú cuando cree la aplicación, ni podrá hacerlo. para cargar la escena principal al hacer clic en Inicio.

Ahora que hemos configurado el menú, podemos pasar a programarlo para que realmente haga algo.

Programando el Menú

Cree un nuevo script y llámelo Menú. Luego escriba el siguiente código:

 usando UnityEngine; // Este espacio de nombres es necesario para usar cualquier componente de la interfaz de usuario usando UnityEngine.UI; // Este espacio de nombres es necesario para usar SceneManager usando UnityEngine.SceneManagement; usando System.Collections; menú de clase pública: MonoBehaviour {// Estos son todos los botones // ------------------------------- inicio de botón público; Ayuda pública del botón; Botón público de salida; Botón público atrás; // ------------------------------- // Este es el Panel de ayuda público GameObject helpPanel; // ------------------------------- // Use esto para la inicialización void Start () {// Desactiva el panel de ayuda del panel .SetActive (falso); } // Se llama a Update una vez por cuadro void Update () {} // Función para el botón de inicio, carga Main Scene public void StartPress () {SceneManager.LoadScene (1); } // Función para el botón de ayuda, habilita el panel de ayuda public void HelpPress () {helpPanel.SetActive (true); } // Función para el botón Salir, sale de la aplicación public void ExitPress () {Application.Quit (); } // Función para el botón Atrás, deshabilita el panel de ayuda public void BackPress () {helpPanel.SetActive (false); }} 

Arrastre esta secuencia de comandos al lienzo del menú, luego desplácese hacia abajo hasta la ventana Inspector. Deberías:

comienzo

Ayuda

Salida

atrás

Panel de ayuda

Arrastre los objetos de juego relevantes a sus respectivos campos. Vea la captura de pantalla anterior si no está seguro.

Ahora presione Ctrl y haga clic en los botones Inicio, Ayuda, Salir y Atrás y desplácese hacia abajo hasta el componente Botón (Script). Al final de este componente habrá una lista vacía que dice On Click (). Haga clic en el símbolo más. Ahora arrastre el objeto del juego del lienzo del menú al campo que dice Ninguno (objeto). El cuadro desplegable Sin función ahora debería estar activo.

Haga clic en el botón Inicio, luego haga clic en el menú desplegable Sin función y vaya al final de la lista donde dice Menú. Luego haga clic en StartPress (). Ahora debería decir Menú. StartPress en el cuadro desplegable. Haga lo mismo con los botones Ayuda, Salir y Atrás, pero asegúrese de seleccionar la función de Prensa correcta para ellos. El botón Ayuda debería tener HelpPress, el botón Salir ExitPress y el botón Atrás BackPress. Ahora haga clic en el icono Reproducir y pruébelo, haga clic en el botón Ayuda y vea si el Panel de ayuda se carga. Hacer clic en el botón Salir en realidad no hará nada a menos que haya creado la aplicación para Android. Tendrá que probar el botón Salir en su teléfono. Al hacer clic en el botón Reproducir, debería ir a la escena principal.

Ahora podría ser un buen momento para probar su aplicación en su teléfono, así que compílela y ejecútela y asegúrese de que su Menú sea completamente funcional.

Como mencioné antes, hay varios métodos para crear la función de salida. Te acabo de mostrar la forma más fácil. Este es el segundo método.

Cree otro Panel como hijo de la Imagen de fondo y llámelo Panel de salida. Establezca el Color de fondo para que coincida con el Fondo para que parezca combinarse (elegí un Azul oscuro) y configure la Parte superior e inferior en 450 y la Derecha e izquierda en 760. Esto centrará el cuadro en la pantalla.

Duplique el Título y conviértalo en un elemento secundario del Panel de salida. Disminuya un poco el tamaño del texto para que sea visible pero no ocupe demasiado espacio. Asegúrese de que esté centrado en la parte superior.

Duplica el botón Reproducir dos veces, crea los dos duplicados hijos del Panel de salida y cambia el Ancla, Posición y Pivote de uno de los botones a la parte inferior izquierda. Cambia el otro a la parte inferior derecha.

Cambie el nombre del botón en la parte inferior derecha a Sí y haga lo mismo con el texto. Cambie el botón inferior izquierdo a No (nombre y texto).

Abra su Script de menú y agregue 2 botones debajo del botón Atrás y un GameObject debajo del Panel de ayuda usando el código a continuación:

 Botón público sí; Botón público no; 

 GameObject public exitPanel; 

Agregue el siguiente código en la Función de inicio, en helpPanel.SetActive (false); línea:

 exitPanel.SetActive (falso); 

Cambie la función ExitPress de

 Application.Quit (); 

a

 exitPanel.SetActive (verdadero); 

Luego desplácese hasta la parte inferior del script y debajo de la función BackPress () agregue el siguiente código:

 público vacío YesPress () {Application.Quit (); } public void NoPress () {exitPanel.SetActive (false); } 

Finalmente, regrese a Unity, haga clic en el botón Sí y cambie su Función de StartPress () a YesPress () y cambie el botón No a NoPress (). También asegúrese de asignar las nuevas variables públicas en la secuencia de comandos del lienzo del menú (haga clic en el lienzo del menú y arrastre los botones y el panel a sus respectivos campos). Ahora presione Reproducir y pruebe el botón Salir, debe cargar el Panel de salida y cerrarlo cuando presione el botón No. Como puede ver, este método es un poco más largo pero ofrece protección en caso de que el jugador haga clic accidentalmente en el botón Salir. Siéntase libre de usar el método que elija.

Ahora pasamos al paso final, creando el HUD, que es extremadamente básico y consta de un botón. Podría agregar otro tutorial que cubra un HUD más extenso (con un control deslizante de salud, un contador de puntaje y un menú de pausa real) pero por ahora, esto será suficiente.

Crear y programar el HUD

Regrese a su escena principal y cree un nuevo lienzo. Rotúlelo HUD Canvas y configúrelo de la misma manera que el Main Menu Canvas.

Agregue un objeto de juego de texto como elemento secundario del lienzo, llámelo de nuevo al menú principal y configure las fuentes, el tamaño y la alineación a su gusto. Alternativamente, puede hacer que uno de los botones del menú principal sea prefabricado, luego simplemente arrástrelo a su lienzo. Una vez que haya configurado el botón, cambie su Ancla, posición y pivote hacia la parte inferior izquierda. Cree un nuevo script llamado HUD y escriba el siguiente código:

 usando UnityEngine; // Este espacio de nombres es necesario para usar cualquier componente de la interfaz de usuario usando UnityEngine.UI; // Este espacio de nombres es necesario para usar SceneManager usando UnityEngine.SceneManagement; usando System.Collections; HUD de clase pública: MonoBehaviour {// Button public Button backToMainMenu; // Use esto para la inicialización void Start () {} // Se llama a Update una vez por cuadro void Update () {} // Función para el botón BackToMainMenu, carga la escena del menú public void BackToMainMenuPress () {SceneManager.LoadScene (0); }} 

Arrastre esta secuencia de comandos al HUD Canvas, configure la secuencia de comandos de la misma manera que el menú principal (arrastrando el objeto de juego Volver al menú principal en el campo Volver al menú principal). Luego configure el botón arrastrando el lienzo de HUD al campo Al hacer clic (). Elija la función BackToMainMenuPress y pruebe el botón haciendo clic en el icono Reproducir y ver si lo lleva de regreso al Menú principal.

Archivos adjuntos

• 
  
  Fineliner_Script.ttf Descargar

• 
  
  Postit-Penscript.otf Descargar

Paso 9: organización de la jerarquía

¿Recuerdas cómo dije que crear objetos de juego vacíos te ayudará a organizar la jerarquía? Bueno, ya lo has estado haciendo usando niños y padres.

Sin embargo, la escena principal todavía está un poco desorganizada. Regrese a la escena principal y cree un objeto de juego vacío etiquetado como efectos. Arrastre todas las Explosiones y los Objetos del juego Senderos a este script de Efectos. Luego arrastre este Objeto de juego de Efectos debajo de los Scripts. La cámara principal y el sistema de eventos pueden permanecer donde están.

Use este sistema para organizar cualquier proyecto que cree. Cualquier cosa del mismo tipo puede pasar por debajo de su propio Objeto de juego vacío (por ejemplo, varios enemigos pueden ser hijos de un Objeto de juego de Enemigos, Cámaras múltiples - Objeto de juego de cámaras, etc.) Esto mantendrá su Jerarquía luciendo ordenada y le impedirá obtener confundido si creas muchos objetos de juego

Paso 10: Conclusión

Uf. Ese fue todo el viaje. Pero finalmente hemos llegado al final (probablemente todos estén contentos de eso). Pero ahora tiene una aplicación totalmente funcional que puede mostrar a sus amigos y mejorar. Deberías estar orgulloso, como se mencionó anteriormente, este fue un tutorial más avanzado. Así que tómate un momento y disfruta de tu creación.

Espero que este tutorial haya sido de ayuda. If you get stuck on anything, a good habit to get in to is searching Google for your error, then typing in Unity after it. Because Unity is so widely used, there is a lot of documentation available and there will most likely be at least one person who has had the same issue as you.

If you're not sure about any of the programming functions (void Update, void Start, public void etc.) then search for the function along with unity c# and check the official Unity documentation.

If you can't find an answer to your issues, you can leave a comment and i'll do my best to help you resolve the error.

If there is something you think I could add or if you want to learn how to program an actual game, feel free to leave a comment.

Thanks for taking the time to read this tutorial. Until next time!