Publicaciones Vistas: 19374

Hablamos sobre cómo puedes crear tu propio juego en Android usando Unreal Engine. En este artículo, veremos otro motor de desarrollo de juegos igualmente popular: Unidad.

Unity es un motor muy famoso entre los desarrolladores independientes. Básicamente, es un motor multiplataforma que le permite desarrollar 3D- y 2D-juegos. Una característica que distingue a Unity del resto de los motores es la baja barrera de entrada para principiantes con un rico conjunto de herramientas para profesionales. La naturaleza multiplataforma le permite desarrollar aplicaciones para cualquier plataforma, desde juegos de escritorio hasta dispositivos móviles.

El sistema de suscripción debe mencionarse por separado, ya que Unity no es un producto completamente gratuito. Hay varios tipos de suscripciones:

• Personal... Versión gratuita que contiene todas las características principales del motor. Tiene la siguiente limitación: los ingresos por año o la cantidad de fondos recaudados no deben exceder 100000$ .
• Más... Detrás 35 dólares por mes se proporcionan varios informes y análisis, así como la capacidad de cambiar la pantalla de inicio, 20% -th descuento en compras en Tienda de activos y varios beneficios menores. Tiene la siguiente limitación: los ingresos por año o la cantidad de fondos recaudados no deben exceder 200000$ .
• Pro... Detrás $ 125 por mes incluye todos los beneficios de la versión Más y además servicio profesional y soporte premium. Sin restricciones de volumen de negocios o cantidad de fondos.
• Versiones independientes para empresas (utilizadas por grandes empresas).

Por lo tanto, para los desarrolladores independientes con presupuestos reducidos, la versión Personal o Más, de lo contrario tendrás que suscribirte Pro... En este artículo, usaremos la versión gratuita para el primer lanzamiento.

Paso 1. Instalar Unity

Para comenzar a instalar Unity, debe ir al sitio web de Unity Store, donde se le pedirá que seleccione un tipo de suscripción. Como se mencionó anteriormente, elegimos Personal.

A continuación, se le pedirá que acepte los términos de uso y descargue el instalador. También puede ver los requisitos del sistema para trabajar con Unity.

Después de iniciar el instalador, se le pedirá que seleccione los componentes que desea instalar. Dado que necesitamos crear una aplicación para Android, marque la casilla para Soporte de compilación de Android... Además, si lo desea, en lugar de con Unity, puede instalar Comunidad de Visual Studio 2017 para programar en C #.

Después de eso, todo lo que queda es elegir la ruta de instalación y comenzar a instalar Unity.

Paso 2. Regístrese y configure Unity

Después de finalizar la instalación y ejecutar Unity, se nos invita a iniciar sesión con nuestra cuenta.

Luego, nuevamente se le pedirá que elija una suscripción, también nos centraremos en Personal. En este caso, deberá confirmar que los ingresos anuales de la empresa son inferiores a $ 100,000 o que Unity se está utilizando para fines de capacitación.

Al final, se le solicita que complete una pequeña encuesta en la que debe responder qué está haciendo y con qué propósito está instalando Unity.

Paso 3. Creando un nuevo proyecto

Una vez configurado Unity, llegamos a la pantalla de selección / creación de proyectos. Aquí tienes que hacer clic Nuevopara crear su nuevo proyecto.

Después de eso, en la ventana que aparece, se le pedirá que ingrese el nombre del proyecto y el directorio donde se ubicará. Además, no olvide marcar la casilla 3Dpara utilizar el editor en 3D.

Cuando haya terminado, haga clic en Crear proyectopara crear un proyecto. Después de eso, se abrirá una ventana del editor con una escena pregenerada.

Todavía no nos ocuparemos de las complejidades de la programación y tomaremos un juego terminado como ejemplo. Para esto hay Tienda de activos, que contiene una gran cantidad de modelos, animaciones, sonidos (e incluso juegos) listos para usar, tanto de pago como gratuitos.

Para abrir la Asset Store, necesita en el menú Ventana escoger Tienda de activos (combinación de teclas Ctrl-9).

Se abrirá el escaparate. Ingresemos en la barra de búsqueda " ejemplo de juego de flappy bird style"y abra un ejemplo gratuito que usaremos en nuestro proyecto.

Haciendo click Descargar y así, una vez descargado, puede importarlo a su proyecto. Para hacer esto, haga clic en Importar, después de lo cual aparecerá una advertencia indicando que la configuración del proyecto se cambiará después de la importación.

Después de aceptar la importación, verá una ventana en la que debe seleccionar qué componentes importar. Seleccione todo y haga clic Importar.

Una vez finalizada la importación, verá los nuevos archivos en el Explorador de proyectos. Estos son los archivos del juego. Para abrir la escena en el editor, expanda Estilo pájaro flappy - Escenas y haga doble clic en Principal.

Como resultado, la escena del juego aparecerá en la ventana del editor 3D.

Puedes comprobar cómo funciona el juego en Unity haciendo clic en el botón Tocar encima de la ventana del editor.

Paso 4. Configurar las herramientas de Android

Nota: si utiliza Estudio de Android, entonces ya tiene todos los componentes necesarios instalados y, por lo tanto, puede continuar con seguridad con el siguiente paso.

Para construir el juego resultante en Android, necesita instalar las siguientes herramientas:

• Kit de desarrollo de Java (JDK). Puede descargarlo del sitio web de Java. Al hacer clic en el enlace, verá en la parte superior Plataforma Java (JDK), haga clic en Descargar junto a la etiqueta, luego seleccione su sistema operativo y comience a descargar. Después de eso, simplemente siga las instrucciones del instalador.
• SDK de Android... La forma más sencilla de obtener la última versión es descargar Android Studio, que viene con este SDK. Para hacer esto, vaya al sitio web de Android Studio y haga clic en Descarga Android Studio... El instalador de Android Studio instala los componentes básicos del SDK de Android necesarios para el desarrollo de Android.

Paso 5. Preparación del proyecto para su lanzamiento

Primero, debe cambiar su plataforma de desarrollo a Android. Para hacer esto, en Unity, abra el menú Archivo y seleccione Configuración de compilación.

En la ventana que aparece, seleccione Androide y luego presione Plataforma de cambio.

El cambio de plataforma nos dice que crearemos una aplicación para Android. Esto significa que cuando compilemos la aplicación, Unity creará Archivo APK... El cambio de plataforma también obliga a Unity a volver a importar todos los activos del proyecto. No tomará mucho tiempo en un proyecto pequeño, pero tenga en cuenta que en proyectos grandes esta operación puede llevar mucho tiempo.

Ahora necesitamos proporcionar un nombre de paquete para la aplicación.

Nota: El nombre del paquete es un identificador único para la aplicación, está escrito en estilo DNS inverso en el formato com.CompanyName.ProductName... Una vez que la aplicación se publica en Google Play, el nombre del paquete no se puede cambiar.

Para hacer esto, vaya al menú Editar y elige Configuración del proyecto: reproductor.

En el lado derecho de Unity, se abrirá una ventana con muchas configuraciones diferentes, como la versión de la aplicación, el SDK de destino y mínimo, la selección de iconos, etc. Aquí lo necesitamos en el bloque Otros ajustes encontrar Identificación y establezca el nombre del paquete en el campo Nombre del paquete... También se pueden cambiar otros parámetros si se desea.

Ahora todo lo que queda es especificar la ruta al SDK y JDK de Android. Para hacer esto, vaya al menú y seleccione Editar preferencias.

En la ventana que aparece, ve a Herramientas externas y en los campos SDK y JDK especifique las rutas apropiadas y luego cierre la ventana.

Paso 6. Cree y ejecute la aplicación

Es hora de crear su primera aplicación Unity. Para hacer esto, seleccione del menú Archivo - Configuración de compilación... Se abrirá una ventana, en ella deberá agregar una escena que debe ensamblarse. Como ya tenemos esta escena abierta en el editor, simplemente haga clic en Agregar escenas abiertaspara agregarlo al ensamblaje, luego de agregarlo lo verá en la lista de escenas.

Solo queda presionar Construiry luego Unity comenzará a construir la aplicación. Antes de eso, se le puede pedir que seleccione la carpeta donde se guardarán los archivos de la aplicación recopilados, así como el nombre del archivo APK.

Nota: por el momento, si tiene una versión alfa instalada en el SDK de Android Herramientas de construcción (versión 28.0.0-rc1), al construir Gradle, dará un error. Para solucionar este problema, simplemente elimine esa versión del SDK de Android.

Como resultado, el archivo APK ensamblado aparecerá en la carpeta que especificó, listo para su instalación en un emulador o en un dispositivo real.

Veamos qué hay dentro del APK ensamblado. Para hacer esto, usaremos la utilidad Analizador de APKque se incluye con Android Studio,

El tamaño del archivo APK sin comprimir es 21,1 MB, en comprimido 20,9 MB... Como puede ver en el gráfico, la mayor parte del volumen lo ocupan bibliotecas de terceros agregadas por Unity. Entonces en bienesse ubican todos los recursos que se utilizan en la escena ensamblada. Archivo classes.dex contiene todo 89 clases y 479 métodos.

Además, si miras en AndroidManifest.xml, la aplicación consta de una actividad.

Conclusión

Eso es todo. En este artículo, aprendimos cómo instalar y configurar Unity, y también creamos nuestra primera aplicación para Android.

Cómo escribir rápidamente un juego de Android en Unity

Hoy en día, cualquiera puede convertirse en un exitoso desarrollador de juegos o aplicaciones móviles sin los esfuerzos titánicos. Un ejemplo de tal caso es Dong Nguyen, quien desarrolló Flappy Bird. El juego no contaba con mecánicas ni gráficos complejos, pero eso no impidió que se popularizara y le aportara a su creador cincuenta mil dólares diarios. Sin embargo, no hubo nada extraordinario en el juego. Todo lo que se necesitaba para tener éxito era estar en el lugar correcto en el momento adecuado y un poco de suerte. Esto puede suceder hoy, solo necesitas la idea correcta.

Para demostrar lo fácil que es escribir algo como esto, hoy escribiremos nuestro Flappy Bird con Unity en solo 10 minutos.

Personaje jugable

Primero cree un nuevo proyecto y asegúrese de que 2D esté seleccionado.

Carga tu pájaro sprite en la escena. ¡No olvides encender tu fantasía!

Luego, ajusta el tamaño del sprite como quieras arrastrándolo por la esquina en la dirección deseada. El objeto debe estar visible en la ventana de jerarquía de la izquierda. Todos los objetos de la escena son visibles en ella, y por el momento solo debería haber dos de ellos: una cámara y un pájaro.

Arrastra la cámara hacia el pájaro y suéltala. La cámara debe estar debajo del pájaro, lo que significa que la cámara ahora es el "hijo" del pájaro. La posición de la cámara ahora se fijará en relación con el pájaro. Si el pájaro avanza, la cámara hace lo mismo.

Seleccione el pájaro nuevamente en la escena o en la ventana de jerarquía. Verá una lista de opciones y atributos a la derecha en una ventana llamada Inspector. Aquí puede administrar varias variables vinculadas a un objeto específico.

Ahora haga clic en Agregar componente. Elija Physics2D\u003e Rigidbody2D: este es un conjunto de instrucciones listas para usar para aplicar la gravedad a nuestro personaje. Haga clic en Restricciones en este panel y luego seleccione congelar rotación Z. Esto evitará que el pájaro gire con la cámara en un círculo.

De la misma manera, agrega un Polygon Collider que le dice a Unity dónde están los límites del personaje. Pulsa Play y observa cómo el sprite, junto con la cámara, cae infinitamente.

¡Hasta ahora tan bueno!

Ahora toca empezar a volar el personaje, ya que no será difícil.

Primero necesita crear un script C #. Cree una carpeta para él (haga clic con el botón derecho en algún lugar de los activos y cree una carpeta "Scripts"), haga clic con el botón derecho y elija Crear\u003e C # Script.

Llamémoslo "Carácter". Haga doble clic en él para abrirlo en su IDE, ya sea MonoDevelop o Visual Studio. Luego agregue el siguiente código:

Carácter de clase pública: MonoBehaviour (public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // Esto es necesario para inicializar void Start () (rb \u003d GetComponent ();) // La actualización se llama una vez por cuadro void Update () (rb .velocity \u003d new Vector2 (moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown (0)) (rb.velocity \u003d new Vector2 (rb.velocity.x, flapHeight);) if (transform.position.y\u003e 18 || transform.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }

Este código hace dos cosas. Hace que el personaje avance a una velocidad que definimos en el inspector, y crea la sensación de un pájaro volando. El método Update () se llama repetidamente a lo largo del juego, por lo que lo que pongas aquí se ejecutará continuamente. En este caso, estamos agregando algo de velocidad a nuestro objeto. La variable rb es el script RigidBody2D que aplicamos a nuestro objeto anteriormente, así que cuando escribimos rb.velocity nos referimos a la velocidad del objeto.

Unity interpreta un toque en la pantalla como un clic del mouse si está utilizando un dispositivo móvil. Después de hacer clic, hacemos que el personaje se mueva un poco hacia arriba.

La variable moveSpeed \u200b\u200bserá responsable de la velocidad de movimiento y la variable flapHeight, del aumento en la altura de vuelo del pájaro después de cada clic. Dado que estas variables se declaran públicas, podemos cambiarlas fuera del script.

El método Death () también se declara público, lo que significa que otros objetos y scripts pueden llamarlo. Este método simplemente devuelve la posición del personaje al inicio. También se utilizará cada vez que el personaje vuele demasiado alto o demasiado bajo. Pronto comprenderá por qué se declara pública. Línea rb.velocity \u003d Vector3.zero; es necesario para eliminar el impulso: ¿no queremos que el personaje caiga cada vez más rápido después de cada muerte?

Ahora puedes salir del IDE y agregar el script como un componente a tu personaje. Para hacer esto, seleccione nuestro pájaro y haga clic en Agregar componente\u003e Scripts\u003e Personaje. Ahora podemos definir moveSpeed \u200b\u200by flapHeight en el inspector (para esto son las variables públicas). Asignemos a las variables los valores 3 y 5, respectivamente.

Y una cosa más: en el inspector, debes agregar una etiqueta al personaje. Para hacer esto, haga clic donde dice Etiqueta: Sin etiqueta y luego seleccione Jugador en la lista desplegable.

Obstáculos

Ahora agreguemos obstáculos: tuberías. Alguien encuentra hongos en las tuberías y otro encuentra su muerte.

Arrastra el sprite de tubería a la escena donde debería estar el primer obstáculo y asígnale el nombre pipe_up.
Ahora creemos un nuevo script llamado Pipe:

Clase pública Pipe: MonoBehaviour (carácter de carácter privado; // Esto es necesario para la inicialización void Start () (character \u003d FindObjectOfType ();) // La actualización se llama una vez por cuadro void Update () (if (character.transform.position.x - transform.position.x\u003e

Agrega este script al sprite de tubería de la misma manera que antes. Por lo tanto, la tubería volverá a la pantalla después de superar su borde izquierdo. Todavía no hemos hecho nada aquí, pero volveremos a esto.

El método OnCollisionEnter2D () se llama cada vez que la tubería interactúa con el personaje. Después de eso, se llama al método Death () creado previamente, devolviendo al jugador al punto de partida.

Así que tenemos una tubería que aparecerá y desaparecerá de vez en cuando en el otro extremo de la pantalla. Si lo golpeas, morirás.

Tuberías invertidas

En este momento solo tenemos un sprite de tubería. Agreguemos otro. Para hacer esto, haga clic derecho en la ventana de jerarquía, haga clic en Nuevo objeto 2D\u003e Sprite y luego seleccione el objeto que desea usar. Es incluso más fácil volver a arrastrar y soltar el archivo en la escena.

Nombra este sprite pipe_down. En el inspector debajo del Sprite Renderer, seleccione la opción Voltear Y para voltear la tubería al revés. Agregue el mismo RigidBody2D.

Ahora escribamos un nuevo script en C # llamado PipeD. Contendrá un código similar:

Clase pública PipeD: MonoBehaviour (carácter de carácter privado; // Esto es necesario para la inicialización void Start () (character \u003d FindObjectOfType ();) // La actualización se llama una vez por cuadro void Update () (if (character.transform.position.x - transform.position.x\u003e 30) ()) void OnCollisionEnter2D (Collision2D otro) (if (other.gameObject.tag \u003d\u003d "Player") (character.Death ();)))

Prefabricados

Entonces, este código es suficiente para hacer todo el juego. Podríamos mover las pipas al lado derecho de la pantalla cada vez que desaparezcan, o copiar y pegar tantas pipas como queramos ver a lo largo del juego.

Si va por el primer camino, entonces asegurarse de que las tuberías estén como deberían después de una generación aleatoria y mantener un curso honesto de las cosas sería difícil. Después de la muerte del personaje, ¡podrían aparecer a kilómetros de la primera tubería!

Si vas por el segundo camino, todo terminará con un consumo de memoria excesivo, con la consiguiente ralentización del juego y una capacidad de reproducción limitada, porque todo está en el mismo lugar cada vez.

En su lugar, usemos casas prefabricadas. En pocas palabras, convertiremos nuestras tuberías en plantillas que luego podremos usar para crear de manera eficiente más tuberías según lo desee. Si hay programadores aquí, trate el script Pipe como una clase y los pipe como instancias de este objeto.

Para hacer esto, cree una nueva carpeta "Prefabs". Luego, arrastre pipe_up y pipe_down desde la ventana de jerarquía a la carpeta.

Cada vez que arrastre un objeto desde esta carpeta a la escena, tendrá las mismas propiedades, por lo que no tendrá que agregar componentes constantemente. Además, si cambia el tamaño de un componente en una carpeta, afectará a todas las tuberías del juego y no tendrá que cambiar cada una individualmente.

Como puede imaginar, esto ahorrará enormemente nuestros recursos. También significa que podemos interactuar con objetos del código. Podemos crear instancias de nuestras tuberías.

Primero, agregue este código a la declaración condicional en el método Update () del script Pipe, que dejamos en blanco:

Void Update () (if (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); Instanciar (gameObject, nuevo Vector2 (character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy (gameObject);))

Esto es necesario para crear una instancia de nuestro gameObject. El resultado es una nueva copia idéntica. En Unity, cada vez que usa la palabra gameObject, se refiere al objeto al que está adjunto el script, en nuestro caso, la tubería.

Estamos volviendo a generar nuestras pipas en variaciones aleatorias para hacerlo más divertido.

Pero en lugar de hacer lo mismo en el script PipeD, generamos ambos objetos en el mismo lugar. Por lo tanto, podemos establecer fácilmente la posición de la segunda tubería en relación con la primera. También significa que necesitamos menos código para PipeD.

Crea un gameObject público llamado pipeDown. Luego actualice su código de esta manera:

If (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); float gapRan \u003d Random.Range (0, 3); Instantiate (gameObject, new Vector2 (character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate (pipeDown, new Vector2 (character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Destroy (gameObject);)

Regrese a Unity y arrastre el prefabricado pipe_down desde la carpeta prefabricada (¡esto es importante!) Al lugar donde dice "Pipe Down" (observe cómo nuestro caso camel se reemplaza con un espacio) en el sprite pipe up. Si recuerdas, definimos Pipe Down como un gameObject público, lo que nos da la capacidad de determinar qué es este objeto desde cualquier lugar, en este caso, a través del inspector. Al elegir una prefabricada para este objeto, nos aseguramos de que al crear una instancia de la tubería, incluirá todos los atributos y el script que agregamos anteriormente. No solo estamos creando un sprite, sino recreando un objeto con un colisionador que puede matar al personaje.

Todo lo que agregamos en el mismo lugar en el script PipeD es simplemente Destroy (gameObject) para que la tubería se autodestruya cuando salga del borde izquierdo de la pantalla.

Si comienzas el juego ahora, la pantalla avanzará más automáticamente y morirás si te encuentras con alguna de las tuberías. Vuela lo suficientemente lejos y estas tuberías desaparecerán y reaparecerán más adelante.

Desafortunadamente, hay mucho espacio entre las tuberías y la pantalla parece vacía. Podríamos arreglar esto agregando algunos prefabricados a nuestra escena para crear una tubería de tuberías que aparecen constantemente. Sin embargo, sería mejor generar tuberías en un script. Esto es importante, porque de lo contrario, después de la muerte del personaje, las tuberías al comienzo del camino se destruirán y se volverá a formar un espacio vacío.

Por lo tanto, podemos crear las primeras tuberías durante cada carga del juego y devolver todo a su lugar después de la muerte del personaje.

Vuelo sin fin

Ahora creemos las variables públicas pipe_up y pipe_down en el script Character. Esto le dará la capacidad de hacer referencia a los objetos generados arrastrando y soltando prefabricados en el objeto de carácter, al igual que cuando agregamos pipe_down al script Pipe.

Necesitamos agregar estas variables:

Public GameObject pipe_up; public GameObject pipe_down;

Luego escribiremos un método como este:

Public void BuildLevel () (Instantiate (pipe_down, new Vector3 (14, 12), transform.rotation); Instantiate (pipe_up, new Vector3 (14, -11), transform.rotation); Instantiate (pipe_down, nuevo Vector3 (26, 14), transform.rotation); Instantiate (pipe_up, new Vector3 (26, -10), transform.rotation); Instantiate (pipe_down, new Vector3 (38, 10), transform.rotation); Instantiate (pipe_up, nuevo Vector3 ( 38, -14), transform.rotation); Instantiate (pipe_down, nuevo Vector3 (50, 16), transform.rotation); Instantiate (pipe_up, nuevo Vector3 (50, -8), transform.rotation); Instantiate (pipe_down, new Vector3 (61, 11), transform.rotation); Instanciar (pipe_up, new Vector3 (61, -13), transform.rotation);)

Lo llamaremos una vez en el método Update () y una vez en el método Death ().

Una vez que comienza el juego, se llama a Update () y nuestras tuberías se instalan de acuerdo con la configuración dada. Debido a esto, los primeros obstáculos siempre estarán en el mismo lugar. Después de la muerte del jugador, las tuberías irán a los mismos lugares.

Regrese a la escena en Unity y elimine las dos tuberías que están allí actualmente. Tu "juego" se verá como una pantalla en blanco con un pájaro. Presiona Reproducir y aparecerán las tuberías, después de las primeras, su posición se determinará al azar.

Finalmente

¡Así que hicimos todo el juego! Agrega un contador de puntuación, intenta hacerlo más original y aumenta la dificultad del juego a medida que avanzas. Tampoco será superfluo hacer un menú. También es una buena idea destruir las tuberías en la pantalla después de la muerte del personaje. Una vez que hayas terminado con eso, ¡considera tener un juego listo para Play Store en tu bolsillo! Un juego que alguna vez fue similar hizo a otro desarrollador muy rico, lo que demuestra que no es necesario ser un genio de la programación o tener un editor rico detrás para tener éxito. ¡Solo necesitas una buena idea y diez minutos!

¿Quiere escribir aplicaciones de Android pero no sabe por dónde empezar? Entonces echa un vistazo a nuestro excelente para aprender el desarrollo de Android.

El desarrollo de aplicaciones móviles es una de las actividades más lucrativas de la industria informática. Cuesta varios cientos o miles de dólares crear un juego en Android, y las ganancias pueden llegar a un millón de dólares. En este sentido, muchas personas están interesadas en desarrollar aplicaciones para el teléfono. En este artículo, aprenderá cómo crear un juego de Android desde cero a través de una computadora, qué motor y constructor es mejor elegir.

Ningún juego exitoso está completo sin hermosos gráficos, por lo que crear un diseño es una de las etapas más importantes del desarrollo. El diseño del sistema operativo Android se implementa mediante un "documento de diseño" o base de diseño. Debe comenzar a crear un juguete con precisión con su estudio detallado. El archivo contiene:

1. Modelos de objetos;
2. Especificaciones funcionales;
3. Contenido del juego;
4. Interfaz.

Consideremos cada uno de los puntos con más detalle.

Modelos de objetos

Ésta es información sobre la funcionalidad de cada elemento. Los modelos de objetos son responsables de la capacidad de comprar y vender artículos, así como de mejorar las características de juego de los personajes.

Especificaciones funcionales

Describe la jugabilidad, las principales características de cada personaje. También proporciona una descripción de las características de los elementos del juego: armas, botiquines de primeros auxilios, armaduras y otros. Básicamente, las especificaciones funcionales son las reglas por las que se desarrolla el juego. Cuanto mejor se resuelva esta sección, más fácil será crear un juego de Android de alta calidad.

Contenido del juego

Este es el relleno de texto del juego. Describe los diálogos de los personajes y qué armas se pueden usar para infligir daño, cuánta salud tomará un golpe, qué características aumentarán al usar varios equipos. También contiene una descripción detallada de cada artículo.

Interfaz

La interfaz es la forma en que el usuario interactuará con el juego. Incluye botones con los que puedes controlar al personaje y secciones del menú: por ejemplo, juego, puntuación, configuración, mejores jugadores, ayuda. Si no tienes experiencia en la creación de aplicaciones para Android, antes de crear las tuyas propias, descárgalas de Play Store y analiza juegos populares y transfiere las mejores soluciones a tu proyecto.

Motor de juegos

El núcleo de cualquier juego es el motor. Es el software que le permite desarrollarlo y ejecutarlo. Contiene un conjunto completo de programas que incluyen motor de renderizado, motor de física, sonido, animación y más. Para facilitar el proceso de escritura de programas, los desarrolladores externos crean sus propios motores de juegos específicamente para aplicaciones de Android.

Cada uno de ellos ofrece diferentes funciones: algunos están diseñados para 3D, otros para 2D, se puede admitir soporte multiplataforma. Hay una gran cantidad de estos motores, pero si es un principiante, es mejor elegir uno de los más populares, ya que todas las funciones necesarias estarán presentes allí.

Reino Unido

Torque 2d / 3d

¿Qué es Game Builder?

Constructor es un programa que combina un motor de juego y un entorno de desarrollo integrado. El diseñador hace que el proceso de desarrollo sea accesible para personas que no tienen habilidades de programación. Algunos de los constructores te permiten crear juegos de ciertos géneros, mientras que otros tienen la máxima funcionalidad, pero cuestan significativamente más dinero. Para un creador novato de aplicaciones móviles, elegir un diseñador es uno de los momentos más cruciales, porque el destino de la aplicación futura dependerá de sus capacidades.

El constructor te permite crear juegos de varios géneros para Windows, Android e iOS. Ofrece una gran selección de ubicaciones, objetos, personajes y diseños de sonido listos para usar, por lo que crear el primer juego de Android no llevará mucho tiempo. Los usuarios familiarizados con los lenguajes de programación JS y C ++ pueden utilizar GML incorporado. El único inconveniente es que el programa no está traducido al ruso.

Conclusión

Crear un juego para Android no es un negocio fácil, pero muy rentable. Si decides desarrollar un juego y ganar dinero con él, primero elabora la idea. A continuación, escriba un "documento de diseño" y decida un motor de juego que pueda maximizar su potencial. Después de eso, puede comenzar a crear directamente la aplicación en el diseñador.

Vídeo

Para obtener más información sobre el proceso de creación de juegos de Android, consulte la serie de videos dedicados a esta lección.

Unity es el motor detrás de la mayoría de los juegos actuales en todas las plataformas. Usando el motor, es posible crear juegos destinados a ser lanzados en computadoras (Windows, Linux, MacOS), teléfonos móviles, tabletas (Android, iOS) e incluso PlayStation, Xbox, consolas de juegos de Nintendo.

¿Cómo creo juegos en Unity?

Unity se basa en un concepto orientado a componentes. De hecho, cualquier juego consiste en una masa de objetos, diluidos con componentes adicionales. Por ejemplo, durante la creación de un juego de plataformas, creamos un GameObject, adicionalmente le adjuntamos un componente gráfico, que se encarga de mostrar el personaje, y un componente de control, que brinda control del personaje mediante el mouse, teclado, joystick o pantalla táctil. El motor no impone restricciones sobre el número de dichos módulos. Podemos agregar tantos componentes al GameObject como sea necesario. Todo el trabajo en el motor se basa en la creación misma del GameObject y en la aplicación de los componentes adecuados.

Los recién llegados pueden sentirse confundidos por la aparente simplicidad del proceso, aunque este no es el caso. Para crear un juego único y popular, debes escribir muchos componentes desde cero. Más precisamente, en el entorno de Unity, esto se denomina script. El lenguaje de programación nativo es C #, pero JavaScript y Boo (una versión truncada de Python) también se utilizan en parte. No es fácil crear sus propios componentes, incluso podría decirse: es un procedimiento complejo, directamente vinculado a la programación clásica. Sin un nivel suficiente de conocimientos en programación, será difícil.

Plataformas compatibles

Muchos proyectos grandes prefieren Unity debido a la enorme lista de plataformas compatibles con el motor. La aplicación terminada se puede ejecutar en cualquier sistema operativo de computadora, plataformas móviles populares y SmartTV. Qué podemos decir, incluso juegos de navegador y aplicaciones para plataformas específicas ( como Tizen OS) se desarrollan principalmente en Unity.

Sin embargo, no todo es tan sencillo aquí. Si es necesario, puede escribir algoritmos específicos basados \u200b\u200ben código de bajo nivel, para el mismo Android es necesario tener un conocimiento profundo de Java.

Lo mismo ocurre con iOS. Otra característica de iOS es que solo se puede desarrollar para él desde una computadora o tableta de Apple. En ausencia de una Macbook o un dispositivo similar, el lanzamiento del juego se detendrá rápidamente y Unity no tiene nada que ver con eso, la propia Apple impone una restricción similar. La conclusión es simple: si hay planes para el desarrollo de iOS, debe elegir el dispositivo adecuado para ensamblar con anticipación.

¿Cómo y dónde desarrollar un juego en el motor?

Podemos realizar un largo proceso de desarrollo de juegos tanto en Windows como en Mac OS X. Ya existen versiones del editor para Linux, pero no podemos contar con su trabajo estable hasta el momento. El desarrollador pasa la mayor parte de su tiempo creando un juego dentro del editor de Unity. Todavía lleva mucho tiempo escribir el código de script, podemos crearlo en el MonoDevelop estándar o en cualquier editor de terceros. Ahora usan activamente Visual Studio, así como Sublime Text, pero solo con la configuración adecuada.

¿Qué tan rápido y relativamente fácil es crear un juego o una aplicación simple para Android? Lea sobre esto en el artículo siguiente, que trata sobre cómo trabajar con el motor Unity3D.

¿Juegas juegos de computadora? Si es así, entonces, seguro, en el proceso de pasar el próximo éxito de taquilla del juego, a veces tenías pensamientos como: "¡Pero aquí, habría hecho mal!". ¿Quieres ser desarrollador tú mismo? Entonces, te sugiero una pequeña, pero muy entretenida "aventura";)

¿Qué es un motor y por qué se necesita?

Anteriormente, en los días de las primeras computadoras, los juegos y programas se creaban utilizando el llamado método "hardcore". Es decir, para un desarrollo completo, se requería ser un programador bastante experimentado que conociera a fondo su lenguaje de programación y pudiera escribir casi todo el juego (¡incluidos gráficos de píxeles y efectos especiales!) En un simple Bloc de notas. Había pocas personas así y eran muy apreciadas (y todavía se aprecian) ...

Hoy, el umbral para ingresar al tema de la programación se ha reducido significativamente. Y esto se ve facilitado no solo por la disponibilidad de literatura y todo tipo de materiales de capacitación, sino también por el proceso de desarrollo cada vez más simplificado. Hoy en día, ya es raro encontrar personas "incondicionales" reales, ya que han aparecido entornos de desarrollo bastante convenientes, que se denominan "motores".

La esencia del motor es que te permite importar todos los objetos del juego necesarios en un modo visual simplificado, organizarlos en el escenario virtual y configurar todos sus parámetros. Es decir, ¡la tarea del programador es solo escribir la lógica del juego correctamente!

Sin embargo, para la conveniencia del trabajo, debe pagar un ligero aumento en el tamaño del proyecto (¡a veces incluso varias veces!) En comparación con su análogo, escrito a la antigua "hardcore". Es por ello que a algunos desarrolladores no les gustan los motores o intentan escribir los suyos, en los que solo se utilizan los componentes que necesitan ...

Pero tú y yo estamos lejos de ser programadores laborales :) Por lo tanto, comencemos a crear un juego simple para Android basado en el popular y poderoso motor Unity3D.

Empezando con un proyecto en Unity3D

Entonces, ¿por qué decidimos usar Unity3D?

• la capacidad de crear juegos 2D y 3D completos;
• la capacidad de compilar el juego terminado para cualquier dispositivo;
• relativa facilidad de control del motor;
• buena extensibilidad de la funcionalidad mediante la conexión de complementos;
• tamaño relativamente pequeño del ensamblaje final del juego (en comparación con otros motores).

La principal carta de triunfo de Unity3D, por supuesto, es su versatilidad y funcionalidad multiplataforma. Puedes portar el juego terminado (posiblemente con modificaciones menores), incluso a una PC (con Windows, Linux o MacOS), incluso a Android, ¡incluso a una PlayStation o XBox! Para ello, solo necesitamos descargar el motor en sí, que, por cierto, "pesa" más de un gigabyte y los SDK necesarios (si se planea desarrollo para plataformas móviles o consolas). Si quieres hacer un juego para Windows, entonces no necesitas descargar nada adicionalmente, pero como vamos a hacer un juego para Android, también necesitaremos descargar el SDK (Software Development Kit) de Android. Le aconsejo que descargue el SDK en un archivo ZIP para mayor comodidad al trabajar con él.

Cuando todo esté descargado, puede descomprimirlo en cualquier carpeta del SDK de Android que sea conveniente para usted, y luego proceder a instalar el propio Unity3D. Se instala como cualquier programa normal en Windows, por lo que no debería haber problemas con la instalación. Después de la instalación, el motor arrancará y primero necesitamos crear un nuevo proyecto:

Para hacer esto, necesitaremos cerrar todas las ventanas de bienvenida e introductorias, y luego seleccionar el elemento "Nuevo proyecto" del menú "Archivo". En la ventana que se abre (ver la captura de pantalla anterior), se nos pedirá que especifiquemos la carpeta para guardar el proyecto (su nombre coincidirá con el nombre del proyecto), importar algunos conjuntos estándar de funciones (no las necesitamos) y especificar el modo de operación. Seleccione 2D como modo y presione el botón "Crear". Esto completa el trabajo preparatorio :)

Interfaz del motor y jerarquía del proyecto

Una vez creado el proyecto, se cargará en el espacio de trabajo de Unity3D:

Este espacio de trabajo en sí tiene una estructura modular y consta de varias ventanas anidadas que se pueden mover a su gusto. Lo tengo configurado así (de izquierda a derecha y de arriba a abajo):

1. Ventana de jerarquía: muestra la posición jerárquica de los objetos activos e inactivos en la escena. De forma predeterminada, el único objeto inmediatamente en la lista es la Cámara principal.
2. Ventana de escena: muestra toda la escena del juego y los objetos que contiene (incluidas cámaras, sonidos, texturas, etc.).
3. Ventana de inspección: muestra todas las propiedades de un objeto seleccionado en la jerarquía o en la escena y le permite editarlas, complementarlas o eliminarlas.
4. Ventana de juego: muestra el mundo del juego tal como lo ve la cámara y le permite seleccionar el tamaño de la ventana del juego de prueba virtual en píxeles. Además, te permite activar la maximización de la ventana del juego en tamaño completo (Maximizar al jugar) y activar / desactivar la visualización de información diversa para el desarrollador.
5. Ventanas de proyecto y consola. La ventana Proyecto se utiliza para navegar por los recursos del proyecto: imágenes cargadas, sonidos, modelos, etc. Además, utilizando esta ventana (menú contextual), puede crear nuevos objetos de juego vacíos de diferentes tipos y scripts. La ventana de la consola se utiliza para mostrar mensajes de error (rojo), advertencias (amarillo) y diversa información de depuración solicitada (gris).
6. Ventana Etiqueta de activos: la parte inferior de la ventana del inspector, que muestra una vista previa del objeto o archivo seleccionado en la ventana Proyecto.

Además de todo lo anterior, preste atención a los tres botones en la parte superior central. Le permiten iniciar su proyecto, pausar (a veces útil cuando se depura para ver qué se está haciendo en la Jerarquía, por ejemplo) y, en consecuencia, apagarlo.

Crearemos un simulador de un instrumento musical: una batería popular india llamada "tabla", así que para empezar, crearemos dos carpetas vacías en el proyecto en las que se almacenarán sonidos e imágenes. Puede crear una nueva carpeta llamando al menú contextual en la ventana del navegador de proyectos y eligiendo el elemento "Carpeta" en la lista "Crear".

Vale la pena decir aquí algunas palabras sobre cómo nombrar estas carpetas. Para un juego simple como nuestro simulador, en principio, las carpetas se pueden "llamar" como quieras, sin embargo, hay al menos dos nombres que es mejor no usar, ya que están reservados por el motor. Estos son los nombres de Recursos y Complementos. En proyectos grandes, la carpeta Recursos se crea de una vez y todas las "piezas de repuesto" del juego (imágenes, sonidos, modelos, texturas y prefabricados) se almacenan en ella (clasificadas por subcarpetas). Los complementos, como su nombre indica, almacenan todos los conjuntos de funciones adicionales de terceros (los llamados "activos"), de los cuales hay bastantes en la Asset Store, una tienda de extensiones para Unity3D.

Importar archivos y crear objetos de juego

Antes de crear un nuevo proyecto de juego, es recomendable preparar con antelación todos los archivos necesarios para su funcionamiento. En nuestro caso, estos archivos son imágenes y sonidos. La forma más sencilla de importarlos a un proyecto es simplemente arrastrarlos y soltarlos en la carpeta deseada. Empecemos por las fotos ...

Una vez que las imágenes aparecen en nuestra carpeta Imágenes, es necesario modificarlas un poco:

El caso es que, por defecto, Unity3D comprime todas las imágenes añadidas al proyecto con pérdida de calidad. Si no necesitamos tal pérdida (especialmente importante para juegos con gráficos HD), entonces debemos seleccionar cada imagen y en la ventana Inspector cambiar el valor del parámetro "Formato" de "Comprimido" a "Truecolor" en la pestaña "Predeterminado". Es posible que también deba cambiar el parámetro "Tamaño máximo" si es menor que el ancho real de la imagen (por defecto, 1024 píxeles). Después de todos los cambios, no olvide hacer clic en el botón "Aplicar" para aplicarlos. Si es necesario, realice acciones similares para todas las demás imágenes.

Ahora, creemos objetos de juego a partir de nuestras imágenes. Para hacer esto, simplemente arrastre la imagen deseada a la ventana de Jerarquía. La imagen o modelo 3D se convertirá automáticamente en un Objeto de juego y se mostrará en el origen frente a la cámara.

Primero que nada, agregamos una imagen de fondo que debería mostrarse en pantalla completa. Puede comprobar si esto es así seleccionando la cámara en la ventana de jerarquía y observando cómo se muestra su marco. En la captura de pantalla anterior, puede ver que parte de nuestro fondo permanece fuera de la vista de la cámara, por lo tanto, debe ajustar el tamaño de esta vista arrastrando el marco directamente en el escenario o editando el parámetro "Tamaño" en la ventana del Inspector. En nuestro caso, tuvimos que cambiar el valor predeterminado (5) a 5.4.

Eso es todo, ya no tocamos la cámara, sino que agregamos y ajustamos el resto de imágenes. Como agregamos, vemos que algunos de ellos son demasiado grandes para nuestro juego. Se pueden reducir físicamente en un editor gráfico o mediante el motor. Probemos el último método. Para hacer esto, seleccione la imagen en la ventana Jerarquía, y en la ventana Inspector cambie los valores de "Escala" para las coordenadas X e Y de 1 a 0.5 (es decir, la reducimos a la mitad). En el mismo lugar, es deseable, para evitar superposiciones, asignar a todos los objetos del juego (excepto el fondo) un orden distinto de cero en Layer:

El último paso para preparar los objetos del juego a partir de imágenes es "colgar" colisionadores en ellos. En Unity3D, los colisionadores se utilizan como detectores de interacciones entre objetos. Es decir, de hecho, se coloca un caparazón virtual en nuestra imagen, que puede registrar toques en ella.

Para agregar un colisionador a un objeto, selecciónelo en la ventana Jerarquía y luego en la ventana Inspector, presione el botón "Agregar componente". En la lista de componentes que aparece, buscamos Physics 2D (la física 3D ordinaria no funcionará en nuestro modo) y allí, de todas las opciones, "Circle Collider 2D" es la más adecuada para nosotros. Lo elegimos nosotros. Aparecerá un contorno verde alrededor de nuestro objeto, que representa los límites del colisionador. Solo queda marcar la casilla de verificación "Is Trigger" para que nuestro colisionador solo registre clics y ya no interactúe con el espacio de juego circundante:

Repetimos acciones similares para todos los objetos restantes. Solo nuestro fondo se diferenciará de otros objetos. Para ello usaremos Box Collider 2D y estableceremos la Posición Z en más de cero para empujar el colisionador y el fondo mismo al fondo (esto será útil un poco más adelante).

Trabajando con sonido

El sonido en Unity 3D parece un poco confuso a primera vista. Pero, intentemos resolverlo en orden :)

Lo primero que debemos hacer es arrastrar todos los sonidos a la carpeta Sonidos y modificarlos un poco también:

Si el nivel de volumen de todos los sonidos se ajusta inicialmente para usted, entonces todo lo que necesita hacer es desactivar el procesamiento de sonido 3D. En los juegos 3D, este procesamiento es necesario para simular el acercamiento de una fuente de sonido cuando la cámara se acerca a ella. Pero en 2D no lo necesitamos, así que seleccionamos cada sonido por turno y desmarcamos la casilla de verificación "Sonido 3D".

Ahora podemos comenzar a agregar sonidos a los objetos del juego. Para hacer esto, necesitamos seleccionar cada botón a su vez y agregarle un nuevo componente "Fuente de audio" de la sección "Audio". Cuando se agrega el componente, seleccione el botón "Clip de audio" correspondiente y desmarque la casilla de verificación "Reproducir al despertar" que está activa de forma predeterminada:

Cuando todos los sonidos se adjuntan a los botones deseados, es hora de la parte divertida: escribir guiones ...

Primer guion

Antes de comenzar a analizar nuestro primer script, probablemente valga la pena decir algunas palabras sobre el sistema de script en Unity 3D.

Unity te permite escribir código en tres lenguajes a la vez: JavaScript (más precisamente, su versión ligeramente modificada de UnityScript), C # y Boo. En varios libros y tutoriales, puede encontrar la opinión de que, para los principiantes, la creación de scripts en Unity es más fácil de aprender usando JavaScript como ejemplo. Sin embargo, este idioma no es tan fácil de usar como los demás, y en el futuro probablemente tendrá que volver a aprender. Por lo tanto, es mejor comenzar de inmediato con el aprendizaje de C # (Boo tampoco está mal, pero no hay muchos tutoriales al respecto).

Ahora sobre dónde escribir el código. El editor de código predeterminado en Unity 3D es MonoDevelop IDE. La ventaja de este entorno de desarrollo es que tiene sugerencias para ingresar rápidamente métodos, clases y funciones estándar, así como un sistema de verificación de sintaxis. Sin embargo, para mí la desventaja fue la incomodidad y la alta intensidad de recursos. Afortunadamente, en la configuración de Unity, puede configurar cualquier cosa como editor de texto, así que "colgué" el ligero y funcional Notepad ++ para mí (casi todos los ejemplos se mostrarán en él).

Y lo ultimo. Naturalmente, sin materiales de referencia para dominar todas las complejidades del motor, no irá muy lejos, por lo que aquí hay una lista de varios recursos de Internet sensibles sobre el tema de Unity 3D:

• http://docs.unity3d.com/ru/current/Manual/UnityManualRestructured.html - el manual oficial del motor con una traducción parcial al ruso (apareció recientemente y a veces es inestable hasta ahora);
• http://docs.unity3d.com/ru/current/ScriptReference/index.html: el manual oficial de secuencias de comandos en inglés;
• http://unity3d.ru/distribution/index.php - Foro en ruso para desarrolladores de Unity 3D;
• http://habrahabr.ru/post/141362/ - una serie de lecciones sobre la creación de juegos tridimensionales en Habrahabr;
• http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx: la referencia oficial de C # de Microsoft en ruso.

Bueno, para no demorar mucho tiempo, propongo crear inmediatamente el primer guión. Para los scripts, si hay muchos, es mejor seleccionar una carpeta separada, pero nuestro juego será simple, por lo que podemos crear un script directamente en la carpeta raíz del proyecto. Para hacer esto, llame al menú contextual en la ventana del Proyecto, seleccione la lista Crear y haga clic en "C # Script". Nombramos nuestro nuevo script, por ejemplo, Sonidos y lo abrimos con un doble clic. Eliminando los métodos estándar Update e Start, y luego registrando los necesarios, obtenemos el siguiente tipo de script:

Si no ha reconfigurado el editor, nuestro script se abrirá en MonoDevelop. Analicemos su estructura ...

De hecho, cada script de C # tiene tres partes principales:

1. En la parte superior están las bibliotecas que deben estar conectadas para que funcione el script (por ejemplo, "using Unity.Engine" conecta el motor en sí y "using System.Collections", una biblioteca que contiene una serie de clases integradas para que el script funcione en diferentes sistemas).
2. Declaración de clases y variables. En C #, no existe el concepto de un script como tal. En su lugar, se utiliza el concepto de "clase", que incluye varios métodos y funciones. Aunque, de hecho, en el contexto de Unity 3D es casi lo mismo :) Lo principal a recordar es que el nombre de la clase debe coincidir con el nombre que le dimos al script. La peculiaridad de las variables en C # es que se deben escribir (excepto las temporales, que se declaran en el propio script). En la práctica, esto significa que el nivel de acceso (privado o público) y el tipo (int, float, bool o, como en nuestro script, AudioClip) deben especificarse para la variable. En este caso, puede darle cualquier nombre a la variable. O puede darle un valor inmediatamente. atribuir.
3. Un conjunto de métodos y funciones. Casi cualquier función que realiza una acción específica se denomina método en C #. Básicamente, en la literatura sobre Unity 3D se denominan funciones, pero si estamos hablando de C # como un lenguaje de programación separado, entonces estos son métodos :). Las funciones en su forma pura en Unity son, por ejemplo, funciones estándar para salida de sonido, dibujar elementos GUI, etc., que se utilizan dentro de los métodos.

Conociendo ahora la estructura del script, es fácil entender su significado, que se reduce a lo siguiente ... En la clase Sounds (script), declaramos 9 variables del tipo AudioClip con los nombres que necesitamos para distinguirlas por conveniencia. Los hacemos necesariamente públicos (los privados no se mostrarán en el editor y necesitaremos "colgar" sonidos en ellos a través del editor). Y luego, en el cuerpo del script usamos el método estándar "void OnMouseDown ()". Anteriormente, solo era responsable de manejar los clics del mouse, pero en las versiones más nuevas también se interpreta como tocar la pantalla táctil. En él, escribimos las condiciones por las cuales comprobamos los nombres de los colisionadores presionados y, si detectamos la presión de uno de ellos, emitimos el sonido correspondiente (usamos la función estándar audio.PlayOneShot ()).

Al escribir código, controle cuidadosamente la presencia de todos los corchetes abiertos y cerrados; de lo contrario, recibirá informes de error constantemente en la consola y no podrá iniciar su proyecto en absoluto. Además, preste atención al uso de letras mayúsculas en los nombres de métodos y funciones. También suelen ser la causa de errores. Y, por supuesto, observe todos los signos (puntos, dos puntos y corchetes), en definitiva, la sintaxis del idioma. Será difícil al principio, ¡pero con el tiempo empezarás a escribir desde cero sin errores!

Cuando el guión esté listo, selecciónelo y asigne un sonido a cada variable en la ventana del Inspector. Ahora solo tenemos que aplicar nuestro guión a los objetos en la escena. La forma más fácil de hacer esto, nuevamente, es arrastrando el script directamente al objeto de juego deseado en la lista de Jerarquía:

Si el script se ha arrastrado y soltado correctamente, entonces debería aparecer en la ventana de inspección del objeto al que lo arrastramos. En consecuencia, arrastramos el script a todos los objetos que deberían sonar en el juego y podemos intentar ejecutarlo. Cuando haces clic en nuestros botones de juego, ¡el sonido preestablecido finalmente sonará!

Introducción a la GUI

En principio, el Juego ya está funcionando para nosotros, pero de alguna manera es demasiado "calvo". Hay algo que falta en él ... ¡Y, al menos, una inscripción con el nombre de lo que tenemos enfrente! En otras palabras, debe implementar algún tipo de interfaz de usuario coherente.

En realidad, GUI es una abreviatura de inglés. "Interfaz gráfica de usuario", es decir, interfaz gráfica de usuario. Tradicionalmente, incluye componentes como:

• botones;
• ventana;
• áreas de texto;
• casillas de verificación y / o botones de radio;
• controles deslizantes (barras de desplazamiento), etc.

En Unity 3D Todo esto (y más) está plenamente presente. ¡Lo principal es aprender a usarlo! Consideremos cómo usando la GUI en Unity puede hacer una etiqueta de título simple.

Para hacer esto, cree un nuevo script llamado Interfaz y cámbielo de la siguiente manera:

Echemos un vistazo más de cerca al script en la captura de pantalla. Aquí escribimos solo una variable pública del nuevo tipo GUIStyle para nosotros. Este tipo le permite cambiar visualmente la apariencia de los elementos a los que se asigna este estilo. Los estilos son útiles cuando hay muchos elementos de interfaz del mismo tipo (por ejemplo, botones), pero deben tener un aspecto diferente.

A continuación, creamos un botón ("GUI.Button"), que tiene la siguiente sintaxis: condición - 4 coordenadas (desplazamiento horizontal desde el borde izquierdo, desplazamiento vertical desde el borde superior, ancho, alto) - texto visible entre comillas y más, opcional, indicación de estilo. Las funciones requeridas están escritas dentro de la condición del botón. En nuestro caso, hemos registrado una transición al sitio de desarrolladores ("Application.OpenURL (" ");").

Las secuencias de comandos de la GUI pueden funcionar desde cualquier objeto del juego, pero normalmente se recomienda que se "cuelguen" de la cámara, lo que haremos arrastrando la secuencia de comandos al objeto Cámara principal. Ahora, si lo selecciona en la ventana de Jerarquía, entonces en la ventana de Inspector podremos ver la variable pública de nuestro estilo, expandiendo la cual obtendremos acceso completo a la configuración de este estilo.

Podemos especificar el color y la textura del texto para el fondo en cualquier situación (para el botón, debe registrar tres de sus variantes (Normal - vista normal, Hover - al hover y Activo - al hacer clic), establecer sangrías y establecer la fuente. Por defecto, el único disponible en Unity 3D la fuente es Arial, pero puede cargar manualmente cualquier otra en el proyecto y aplicarla en el campo "Fuente", ajustando todos los parámetros que la acompañan.

Curiosamente y al mismo tiempo no muy conveniente, los elementos de la GUI no se muestran en el escenario hasta que lanzamos el proyecto, por lo que ajustar los parámetros de cada elemento puede llevar mucho tiempo. Comencemos el proyecto y veamos cómo se verá nuestro botón creado arriba:

Modificar la interfaz por condición y variables estáticas

Ya hemos hecho mucho, pero siempre hay margen de mejora :) Por tanto, como último ejemplo, propongo crear una ventana de ayuda, en la que normalmente los desarrolladores normales suministran sus juegos y aplicaciones. Para hacer esto, agregue una imagen para dicho botón en forma de signo de interrogación a la carpeta con imágenes y conviértalo en un objeto de juego. Vamos a colgarle un colisionador y escribir un script con un nombre, por ejemplo, "Ayuda" con el siguiente contenido:

En este script, tenemos dos variables. La primera variable define la máscara que se utilizará para todos los elementos de la interfaz descritos en esta clase. A diferencia de los estilos que discutimos anteriormente, las máscaras le permiten cambiar la apariencia no solo de un solo elemento al que están asignados, sino de todos los elementos de un cierto tipo a la vez. Además, a diferencia de los estilos, las máscaras no se asignan a los elementos, sino que se declaran para todo el método a la vez y funcionan hasta que se declara otra máscara. También debe recordarse que las máscaras existen no solo como variables, sino también como archivos separados. Por lo tanto, antes de declarar una máscara, debe crearla inmediatamente en la ventana "Proyecto" del menú contextual: "Crear" - "máscara GUI".

La segunda variable es booleana (o, en otras palabras, booleana). Solo puede tener dos valores: "verdadero" (verdadero) o "falso" (falso). Debido a su naturaleza binaria, dicha variable es perfecta para implementar todo tipo de conmutadores. En nuestro caso, será el encargado de mostrar el texto que describe nuestro juego.

Sin embargo, si observa detenidamente, notará que la última variable tiene un gran parámetro: "estático". ¡Agregar este parámetro a las variables le permite hacerlas estáticas y acceder a ellas desde otros scripts!

Pero volvamos al resto del código. El método "void OnMouseDown ()", ya familiar para nosotros, servirá aquí como un cambio para la variable "isVisible" usando una condición simple. Sin embargo, hay una función más después de la condición. Esta función ("Debug.Log ();") se usa para mostrar "sobre la marcha" en la Consola los valores de las variables que necesitamos (las ingresamos sin comillas entre paréntesis). Como puede ver, dentro de una función puede combinar tanto texto inmutable (escrito entre comillas) como variables (sin comillas). Lo principal es que hay un signo "+" entre todos los datos.

Más adelante en el texto del script, tenemos el método de representación de la interfaz ("void OnGUI () ()"), dentro del cual vemos la declaración de una nueva máscara ("GUI.skin \u003d HelpSkin;") y un nuevo elemento de interfaz del tipo GUI.Box. A diferencia de un botón, un cuadro es un elemento inactivo y generalmente se usa para mostrar varios datos de texto o gráficos.

Observe cómo colocamos la caja. Aquí, todos los valores no se especifican directamente, sino utilizando expresiones matemáticas, que, de hecho, es un análogo del "diseño fluido" en el desarrollo web. El problema es que al especificar los tamaños exactos de los elementos de la GUI en diferentes resoluciones de pantalla, no se adaptarán y pueden ser demasiado pequeños o, por el contrario, grandes. En la próxima versión del motor, los desarrolladores prometen hacer que la GUI responda, pero hasta ahora tenemos que ser pervertidos :(

El último paso en el camino hacia el éxito será personalizar nuestra piel. Especifique el archivo de máscara en la variable de secuencia de comandos y luego seleccione este archivo en la ventana del proyecto. Al igual que con otros archivos, la configuración de la máscara se mostrará en la ventana del Inspector. Aquí buscamos el elemento que está sujeto a cambios (en nuestro caso, Box), expandirlo y configurarlo de manera similar al estilo comentado anteriormente:

Para ver si nuestro script funciona correctamente, iniciemos el proyecto e intentemos hacer clic en el botón de ayuda:

Ahora todo funciona, pero no siempre es conveniente hacer clic en el botón de ayuda para ocultar la descripción. Es más habitual pinchar cualquier espacio libre para que desaparezcan las notificaciones que apuntar a los botones. Y aquí solo necesitamos el hecho de que hicimos la variable "isVisible" estática, así como el colisionador colgado en la imagen de fondo ...

Volvamos a nuestro primer guión ("Sonidos"), que rastreaba los clics de los botones para reproducir sonidos. En él (más precisamente, dentro del método "void OnMouseDown ()"), solo necesitamos escribir una sola línea:

if (this.name! \u003d "HelpButton") (Help.isVisible \u003d false;)

Con esta línea establecemos la condición: si el nombre del colisionador presionado no es igual al nombre del botón de ayuda, entonces la variable "isVisible" en el script "Ayuda" será igual a "falso". Solo necesita la variable "isVisible" para tener la posdata "estática", de lo contrario obtendremos un error.

Ahora, en el lanzamiento, veremos que nuestra ventana de ayuda se cierra cuando hacemos clic no solo en el botón de la esquina superior derecha, sino también cuando tocamos cualquier parte libre de la pantalla. Lo único que todavía se puede mejorar es hacer que la ventana se oculte y haciendo clic en ella ... Esta será su "tarea";) Solo puedo decir que la caja de la GUI deberá cambiarse a un botón de diseño similar, nuevamente, con la configuración skin y prescribir una función que cambie la variable "isVisible". Eso es todo, me quedaré callado :)

Compilar el juego y guardar el proyecto

¡Finalmente, todo funciona para nosotros! Esto significa que es hora de guardar nuestro juego y probarlo en un dispositivo real. Y para ello hay que compilarlo en un archivo ejecutable (para Windows, por ejemplo, en EXE, y para Android en APK).

Si desea compilar el juego para PC, no es necesario realizar ninguna configuración preliminar. Sin embargo, para Android, primero deberá conectar el SDK de Android que descargamos al principio. Esto se hace de manera muy simple: vaya al menú "Editar", llame al elemento "Preferencias" y en la ventana que se abre, vaya a la pestaña "Herramientas externas". Aquí buscamos la línea "Ubicación del SDK de Android" y en ella especificamos la ruta al archivo descomprimido con el SDK (vea la captura de pantalla a continuación). Por cierto, aquí también puede cambiar el monstruoso editor de texto activo predeterminado MonoDevelop a su favorito :)

¡Y ahora ha llegado el momento de la verdad! Vaya al menú "Archivo" y busque el elemento "Configuración de compilación". En la ventana que se abre, necesitaremos agregar inmediatamente escenas para el ensamblaje. Si solo hay una escena (como en nuestro proyecto), entonces será suficiente presionar el botón "Agregar actual". Si hay varios de ellos, entonces deberá abrir cada uno de ellos y agregarlos a la lista de escenas de la misma manera, y luego, arrastrando y soltando, configurar la secuencia deseada:

El siguiente paso es seleccionar la plataforma de compilación (estamos planeando un juego para Android, lo que significa que lo elegimos) y hacer clic en el botón "Configuración del jugador" a continuación. Se abrirán varios ajustes en la ventana del Inspector, algunos de los cuales son obligatorios o muy deseables. Es conveniente indicar los nombres de la empresa desarrolladora, el programa y su icono (Nombre de la empresa, Nombre del producto e Icono predeterminado, respectivamente) en la parte superior de la lista de configuraciones.

En la parte inferior, en la sección "Otras configuraciones", hay dos parámetros obligatorios: "Identificador de paquete" y "Versión de paquete". La versión predeterminada está configurada como 1.0, pero el identificador deberá crearse manualmente y, preferiblemente, será único. Debe constar de tres partes, separadas entre sí por puntos: la palabra reservada "com", luego el nombre de la empresa desarrolladora y al final el nombre de la propia aplicación.

El resto de la configuración de ensamblaje se puede cambiar a su discreción o no cambiar en absoluto. Lo principal es que ahora la compilación ya puede comenzar. Para hacer esto, simplemente haga clic en el botón "Compilar" en la ventana "Configuración de compilación" y espere hasta que los programas nos den una aplicación lista para usar empaquetada en un archivo APK :)

Conclusión

Con esto concluye nuestra lección de revisión sobre la creación de las aplicaciones más simples para Android llega a su fin. Para que puedas repetir todo de lo que hablamos, al final del artículo te daré un enlace al archivo, que almacenará todos los recursos del juego como una carpeta separada (si quieres hacer todo desde cero) y como un archivo con la extensión unitypackage. Este último le permite importar todo el proyecto a Unity a la vez, incluidas las dependencias, etc.

Para importar nuestro proyecto (y, por cierto, cualquier complemento descargado de Internet o de la Tienda de Activos), debe ir al menú "Activos", seleccionar el elemento "Importar paquete", y en él "Paquete personalizado", luego especificar la ruta a nuestro archivo y haga clic en el botón "Importar". Por cierto, puede hacer una copia de seguridad completa de su proyecto guardando en un paquete unitario desde el mismo menú ("Activos") haciendo clic en el elemento "Exportar paquete".

Parece que todo :) Como persona que dominó Unity 3D desde cero, en el artículo traté de dar respuestas al número máximo de preguntas y destacar los principales matices de trabajar con el motor que surgen al principio. Pero, tal vez, esto no sea suficiente para alguien, así que si tienes alguna pregunta, puedes contactarme directamente por correo electrónico o en el foro: ¡Te ayudaré tanto como pueda!

¡Les deseo a todos buena suerte y una implementación exitosa de todos los proyectos!

PD Se permite copiar y citar libremente este artículo, siempre que se indique un enlace activo abierto a la fuente y se preserve la autoría de Ruslan Tertyshny.