Haz un videojuego 2D con Unity

En este Instructable, te mostraré cómo hacer un videojuego 2D realmente simple. Es un juego de estilo corredor infinito, como "Fly with Me" o "DoodleJump".

Pruébalo aquí !!

He proporcionado un zip del exe del juego que te mostraré cómo hacer. Descárgalo y pruébalo.

Está completamente incompleto en lo que respecta a un juego, pero me sirvió como una oportunidad fantástica para aprender un poco de las secuencias de comandos de C # y para consolidar el conocimiento de Unity que he adquirido desde que lo descargué hace dos semanas. Con el fin de compartir, decidí usar Instructables Robot propio como el personaje principal. Fui por una mirada simplista en homenaje a esas caricaturas de antaño realizadas en el mismo estilo. Siempre me encantó cuando el lápiz interactuaba con la caricatura.

Tengo que decir que Unity es una herramienta increíble. Hay una gran cantidad de información disponible en la sección de aprendizaje del sitio de Unity, le recomiendo que lo revise una vez que haya visto lo simple que es comenzar a hacer juegos en 2D.

Todo lo que les muestro aquí, lo aprendí del sitio de Unity, tienen excelentes tutoriales y sesiones de capacitación en video.

Soy nuevo en Unity como puede ser o no, así que esto es solo para compartir mi amor por el medio ambiente y mi experiencia de aprendizaje hasta el momento.

Proporcionaré los recursos de sprites para cada paso para que puedas seguirlos y hacer el juego tú mismo. Recomiendo no usar mi código como está, sino seguir y escribir su propia versión de los mismos scripts.

Tengo poca o ninguna experiencia en programación en C y, sin embargo, estaba escribiendo scripts en C # bastante rápido ... me recuerda muchísimo a Arduino y Processing, con los que estoy familiarizado.

Entonces, incluso si no está familiarizado con la programación, creo que también podría hacerlo. Al menos sigue mi aventura para ver lo fácil que fue.

Paso 1: descargue el software gratuito de Unity

Bascillay Unity es lo suficientemente amable como para permitir que aquellos de nosotros que deseen poder entrar en el desarrollo del juego, aprendan a aprenderlo gratis, siempre y cuando no ganemos dinero con los productos que hacemos usando su software. Increíble. Muchas gracias Unity, por el aliento y la libertad de probarlo, y por el increíble software.

Si planea seguirlo, deberá ir a la página de inicio de Unity y descargar la versión gratuita del software.
También deberá crear un inicio de sesión de Unity, solo siga los pasos después de la instalación.

Paso 2: abre la unidad

Si es la primera vez que abre Unity, se le presentará un cuadro de diálogo para crear un nuevo proyecto. Busque una ubicación adecuada y asigne un nombre a su proyecto, algo así como "Iblejump".
Es muy importante verificar la selección 2D en la parte inferior del formulario donde dice "Configuración predeterminada para".

No necesitarás importar ninguno de los paquetes para el juego que haremos. Aconsejaría no molestarse con ellos a menos que los necesite para su juego. No tiene sentido incluir un volumen adicional en nuestros archivos de compilación.

Cuando haya hecho las selecciones adecuadas, continúe y presione 'crear'.

Ahora el Editor de Unity abrirá nuestro nuevo proyecto vacío y nos presentará una agradable ventana emergente de bienvenida. Cerremos eso por ahora y exploremos un poco la interfaz.

El área de trabajo se divide en cuatro secciones diferentes, que puede organizar para adaptarse a su flujo de trabajo.

La ventana de jerarquía en el lado izquierdo muestra todos los objetos que están actualmente en su escena. La ventana de escena es donde construiremos y colocaremos nuestros objetos de juego.

Abajo tenemos otra área de trabajo donde puedes acoplar y desacoplar diferentes pestañas. La mayoría de las pestañas se pueden acoplar en un área que le resulte conveniente. Así es como configuro mi área, puede que haga las cosas de manera un poco diferente. Lo principal a tener en cuenta es que puede acceder a todas estas ventanas desde el menú desplegable de la ventana y agregarlas o restarlas según sea necesario. No necesita preocuparse si su ventana no se ve idéntica. Le mostraré cada una de las áreas que utilizaremos con más detalle a medida que avancemos.

Por ahora, simplemente haga clic en su "Cámara principal" para que pueda ver lo que sucede a la derecha en el Inspector y las ventanas de escena.
Observe cómo ahora tiene una vista previa de su escena vacía en la esquina inferior de la ventana de escena, y todos los componentes y valores de propiedad de la cámara están expuestos.

Paso 3: Crea tu primer objeto de juego


Primero necesitará la carpeta Sprites que he incluido como un archivo comprimido. Extraiga la carpeta a un lugar donde pueda encontrarla.

En Unity, en el área de trabajo del proyecto, debajo de la pestaña del proyecto, con Activos seleccionados, arrastre la carpeta descomprimida al área gris a la derecha. Todos los sprites que necesitarás para duplicar mi proyecto están en esta carpeta.

Navegue a la nueva carpeta Sprites y busque un sprite llamado "navbar". Arrastra eso hacia la ventana de escena. Colóquelo en algún lugar cerca del fondo de su escena, como lo hice en la imagen.

Si hace clic en Cámara principal en su ventana de jerarquía después de colocarla, ya puede ver cómo se verá en su juego.

Tendremos que agregar algunos componentes, comencemos con un colisionador de cajas, para que nuestra caja sea sólida.

Con su nuevo objeto seleccionado, en el Inspector, haga clic en "Agregar componente" y luego agregue un Box Collider 2D, que se encuentra en Physics2D

Sigue adelante y agrega un segundo 2D Box Collider a tu objeto, este lo usaremos para evitar que el jugador se caiga accidentalmente del costado de la barra de navegación justo al comienzo del juego.

Como quería que Robot comenzara acerca de dónde está en la página web de Instructables, reduje un poco el colisionador principal. Y el segundo colisionador está sentado en un espacio abierto, lo que evitará que nuestro jugador salga corriendo del lado izquierdo cuando comience el juego.

Configure sus colisionadores de caja para que coincidan con los tamaños en la imagen, también establezca el tamaño x e y del parámetro de transformación en 1.5. Observe los cambios que tienen lugar en la ventana de la escena.

Archivos adjuntos

  • Descargar Sprites.zip

Paso 4: agrega un jugador

Ahora que tenemos una plataforma para que nuestro jugador se pare, necesitaremos un jugador.

Haga clic en GameObject en la barra de menú superior, seleccione crear vacío.

Seleccione su nuevo objeto de juego vacío en la ventana Jerarquía y, en el Inspector, cambie su nombre a Jugador.
A continuación, agregue un componente Sprite Renderer, que se encuentra en Renderizado.

En la carpeta de activos / sprites del proyecto, busque Idle_Sprite, haga clic en el pequeño triángulo junto a él y luego arrastre una de las imágenes al valor Sprite del componente de representación de sprites.

Necesitaremos algunos componentes más para nuestro reproductor. Primero agregue un Rigidbody2D de las opciones de Physics2D.

Si presiona el botón de reproducción ahora, nuestro jugador caerá a través de la barra de navegación. Ve y pruébalo.

Lo arreglaremos agregando algunos colisionadores. Algo contrario al intuitivo, agregaremos un colisionador circular a nuestros pies y cuerpo, y un colisionador de caja a nuestra cabeza.

Ahora, si presionamos play, nuestro pequeño robot rodará sobre su espalda como lo haría cualquier robot con fondo circular. Solucione esto marcando la casilla de verificación Ángulo fijo, y luego cuando presione reproducir, su robot debería caer a la barra de navegación y descansar allí agradablemente.

Él es un poco grande para mi gusto, así que cambié su tamaño en transformar a .75 x y .75 y.

Luego jugueteé con el posicionamiento de la barra de navegación y el robot hasta que estuve feliz.

Ahora es un buen momento para guardar su escena, asígnele un nombre que le parezca bien y guárdela.

Paso 5: Agregue algo de vida al robot

Bien, ahora que tenemos el objeto jugador en su lugar, podemos comenzar a agregarle animación y funcionalidad.

Con el objeto Player seleccionado, agregue un componente Animator. Agregar componente -> Varios -> Animador.
Desmarca "Aplicar movimiento de raíz" y marca la casilla "Física animada".

Ahora abra su ventana Animator. Puede hacerlo a través de la ventana desplegable si aún no está abierto en el área de trabajo del proyecto. Me gusta atracar el mío en la parte inferior.

Con Player todavía seleccionado en Jerarquía, abra la ventana Animación. También se puede encontrar en la ventana desplegable. Me gusta acoplar el mío en la misma área que mi escena y las ventanas del juego.

En la ventana Animación, haga clic en los pequeños triángulos al lado de "muestra" para crear un nuevo clip.

Abajo, abra su carpeta de activos / sprites y abra el sprite inactivo nuevamente. Shift selecciona la serie completa de imágenes y arrástralas hasta la ventana de animación.

Debido a que el animador (yo) era barato en marcos, restablezca el tamaño de la muestra a 10.

Ahora mire su Animator, debería agregar automáticamente dos estados, un estado cualquiera y un nuevo estado predeterminado, Inactivo. El color naranja nos dice que es el estado de animación predeterminado.

Si ha seguido estos pasos correctamente, debería tener un Robot animado ahora cuando presiona reproducir.

Crea otra animación y llámalo conducir. Usa la hoja de Sprite Drive. Nuevamente, baje la velocidad de fotogramas. Lo estoy poniendo a las 20 por ahora. Puedes retocarlo más tarde a tu gusto.

En la ventana Animator, verá que se ha creado automáticamente un segundo estado. ¡Excelente! Agreguemos un parámetro flotante llamado "Velocidad" a nuestro Animador antes de crear las transiciones.

Ahora haga clic derecho en el estado Inactivo y seleccione "hacer transición". Luego arrastre al estado de la unidad. Esto debería hacer una pequeña barra de flecha. seleccione el triángulo en el centro de la barra de transición. Cambie la condición de transición en el inspector para que sea cuando la velocidad sea mayor que 0.01. Ahora cree una transición de la unidad de disco a la inactiva con la condición de que la velocidad sea inferior a 0.01.

A continuación, tendremos que crear un script de controlador para Robot.

Paso 6: El script del controlador del robot

Ahora que tenemos un reproductor con algunos estados de animación, necesitamos un script para controlar el personaje. Agregaremos un script simple de C # a nuestro proyecto para controlar nuestro reproductor.

En la ventana Proyecto, cree una nueva carpeta y llámela Scripts. Abra esa carpeta y cree un nuevo script de C #, llámelo RobotController.

Haga doble clic en el script para iniciar MonoDevelop. Puede tomar un momento abrirse, ser paciente.
Ingrese el siguiente código para comenzar
 usando UnityEngine; usando System.Collections; RobotController de clase pública: MonoBehaviour {// Esta será nuestra velocidad máxima ya que siempre estaremos multiplicando por 1 flotante público maxSpeed ​​= 2f; // un valor booleano para representar si estamos mirando hacia la izquierda o no bool faceLeft = true; // un valor para representar nuestro Animator Animator anim; // Use esto para la inicialización void Start () {// establezca anim en nuestro animador anim = GetComponent (); } // Se llama a Update una vez por cuadro void FixedUpdate () {float move = Input.GetAxis ("Horizontal"); // Nos da uno si nos movemos con las teclas de flecha // mueve nuestros jugadores rigidbody2D.velocity = nuevo Vector3 (move * maxSpeed, rigidbody2D.velocity.y); // establece nuestra velocidad anim.SetFloat ("Speed", Mathf.Abs (move)); // si nos estamos moviendo hacia la izquierda pero no estamos mirando hacia la izquierda, y viceversa if (mover 0 && enfrentando hacia la izquierda) {Flip (); }} // voltear si es necesario void Flip () {enfrentando a la izquierda =! enfrentando a la izquierda; Vector3 theScale = transform.localScale; theScale.x * = -1; transform.localScale = theScale; }} 

Guarde el script y regrese a la ventana de Unity. Arrastre el nuevo script RobotController desde el trabajo del proyecto hasta el objeto Player en la ventana Jerarquía. Presiona el botón de reproducción para ejecutar el juego y deberías poder controlar el robot con las teclas de flecha izquierda y derecha. Si abre la ventana Animator debajo del juego, debería ver que la animación cambia de estado de conducción a inactivo, dependiendo de si Robot se está moviendo o no.

Paso 7: Salta - Continúa la secuencia de comandos del controlador del jugador

Solo unos pocos pasos para implementar para que nuestro jugador salte.
Necesitaremos un estado de animación para saltar y caer, y también un poco más de código para controlar las cosas.

Comencemos agregando dos parámetros más a nuestro Player Animator. Agregue un flotador llamado `vSpeed`` y un Bool llamado` Ground`. Usaremos vSpeed ​​para mantener nuestra velocidad vertical, y Ground estará en su lugar para ayudarnos a detectar cuándo nuestro personaje está en el suelo, lo que permite un salto más realista. (Saltar por el aire sin tocar el suelo es más como volar).

De vuelta en la ventana de escena, crea un nuevo Objeto de juego vacío. Llámalo Groundcheck y agrégale un 2D Circle Collider.
Arrastre el nuevo Collider al objeto Player en la ventana Jerarquía. Cambia el radio del colisionador Groundcheck a 0.1, y cambia su posición de transformación y a -1. Esto pone un pequeño círculo justo debajo de los pies de Robots. También etiquetarlo como jugador y ponerlo en la capa de jugador.

Ahora vamos a actualizar nuestro script para usar nuestros nuevos parámetros y poner el código en su lugar para hacer que Robot salte cuando se presiona la barra espaciadora.

Actualice su script RobotController para que sea el siguiente.

 usando UnityEngine; usando System.Collections; RobotController de clase pública: MonoBehaviour {// Esta será nuestra velocidad máxima ya que siempre estaremos multiplicando por 1 flotante público maxSpeed ​​= 2f; // un valor booleano para representar si estamos mirando hacia la izquierda o no bool faceLeft = true; // un valor para representar nuestro Animator Animator anim; // para verificar el terreno y tener una fuerza de salto, podemos cambiar en el editor bool grounded = false; Transformación pública GroundCheck; suelo flotante Radio = 0.2f; public LayerMask whatIsGround; flotador público jumpForce = 700f; // Use esto para la inicialización void Start () {// establezca anim en nuestro animador anim = GetComponent (); } void FixedUpdate () {// establece nuestro vSpeed ​​anim.SetFloat ("vSpeed", rigidbody2D.velocity.y); // establece nuestro bool conectado a tierra = Physics2D.OverlapCircle (groundCheck.position, groundRadius, whatIsGround); // establece el terreno en nuestro Animador para que coincida con anim.SetBool conectado a tierra ("Ground", conectado a tierra); float move = Input.GetAxis ("Horizontal"); // Nos da uno si nos movemos con las teclas de flecha // mueve nuestros jugadores rigidbody rigidbody2D.velocity = new Vector3 (move * maxSpeed, rigidbody2D.velocity.y); // establece nuestra velocidad anim.SetFloat ("Speed", Mathf.Abs (move)); // si nos estamos moviendo hacia la izquierda pero no estamos mirando hacia la izquierda, y viceversa if (mover 0 && enfrentando hacia la izquierda) {Flip (); }} void Update () {// si estamos en el suelo y presionamos la barra espaciadora, cambie nuestro estado fundamental y agregue una fuerza hacia arriba if (tierra && Input.GetKeyDown (KeyCode.Space)) {anim.SetBool (" Ground ", falso); rigidbody2D.AddForce (nuevo Vector2 (0, jumpForce)); }} // voltear si es necesario void Flip () {enfrentando a la izquierda =! enfrentando a la izquierda; Vector3 theScale = transform.localScale; theScale.x * = -1; transform.localScale = theScale; }} 
Regrese de nuevo a la secuencia de comandos del controlador del robot en el Inspector y asegúrese de configurar What Is Ground en todo excepto el jugador. Seleccione todo, luego abra el cuadro de diálogo nuevamente y deseleccione Player. (Gracias c0)

En el siguiente paso crearemos un árbol de mezcla Animator para manejar saltos y caídas.



Paso 8: crea una animación de árbol de mezcla

Hagamos un árbol de mezcla para mantener nuestros diferentes estados de caída / salto. Podríamos hacer animaciones separadas para ambos, pero esto es más eficiente y requiere menos volumen para nuestro pequeño juego. Además, es genial. (¿Mencioné que Unity alberga un excelente material de aprendizaje?)

Regrese a la ventana de animación de su reproductor, con su objeto Player seleccionado, cree 5 nuevos clips de animación, asígneles el nombre jump1 -jump5.

Para cada clip, arrastre un cuadro desde la hoja de saltos, en orden. es decir, la primera imagen de salto a jump1, y así sucesivamente.

Abra la ventana Animator nuevamente, haga clic derecho, cree ... nuevo desde el árbol soso. Nómbralo JumpFall.
Haga doble clic en el nuevo estado JumpFall, abriendo el árbol de mezcla en el inspector.

Haga clic en el pequeño signo más y en el campo Agregar movimiento, haga esto cinco veces.

Cambie el Umbral para que oscile entre -13 y 10, y cambie el parámetro del umbral para que sea vSpeed.

Si no está satisfecho con la animación, puede modificar los valores desmarcando Automatizar umbral. Para este juego simple, parece lo suficientemente bueno. (Animador se volvió flojo ... otra vez)

Ahora regrese a la ventana Animator, verá el árbol de mezcla abierto, haga clic en Capa base en la esquina superior izquierda para volver a nuestros estados base.

Debe eliminar todos los estados de salto generados automáticamente, Jump1 a Jump5 ahora también. (Gracias c0)

Cree una transición del estado Any al nuevo estado JumpFall, y luego una de JumpFall a inactiva. Esto significa que podemos entrar en la animación de salto desde cualquier estado, es decir, si caemos.

Establezca la transición de Cualquier estado a JumpFall para que sea cuando Ground es falso, y la transición de JumpFall a inactivo cuando Ground es verdadero.

Listo, ejecuta el juego nuevamente y deberías poder hacer que Robot salte y se anime con la barra espaciadora. La animación es un poco desigual por falta de cuadros, puedes jugar con el campo de movimiento para cambiarlo un poco si quieres.

Paso 9: destructores

En los próximos pasos, crearemos objetos que engendrarán más objetos y sin que se realice alguna limpieza, nuestro juego se empantanará rápidamente. Con eso en mente, nos encargaremos de limpiar colocando algunos objetos fuera de la pantalla para destruir los objetos cuando salgan del área de juego.

Nuestro juego será un desplazamiento lateral, por lo que colocaremos uno debajo de la escena para atrapar los objetos que caen (como el Jugador) y uno fuera de la pantalla a la izquierda para limpiar todo lo que ya se haya desplazado.

Comienza creando un quad. Haga clic en GameObject -. Crear otro -> Quad. Cambie su posición de transformación a x a -25 ey a 0. Luego configure la escala de transformación para que X sea 1 e y sea 25.

Dale un nombre genial al objeto cuádruple, como Destructor. Elimina el componente Mesh Collider y agrega un cuadro colisionador 2D, pero esta vez marca la casilla marcada "Is Trigger".

Agregue también un cuerpo rígido 2D, pero establezca la escala de gravedad en la ventana del Inspector en cero.

En el área de trabajo Proyecto, abra la carpeta Scripts y agregue un nuevo script C #, asígnele el nombre Destroyer. Haga doble clic en él y abra Monodevelop.

Ingrese el siguiente código en el nuevo script y guárdelo.

 usando UnityEngine; usando System.Collections; Destructor de clase pública: MonoBehaviour {// Use esto para la inicialización void Start () {} void OnTriggerEnter2D (Collider2D other) {// si el objeto que activó el evento está etiquetado como jugador if (other.tag == "Player") {Debug .Romper (); regreso; } if (other.gameObject.transform.parent) {Destroy (other.gameObject.transform.parent.gameObject); } else {Destruye (other.gameObject); }}} 

Arrastre el script Destruir al objeto Destructor.
Ahora haga clic derecho en el objeto Destroyer en la ventana Jerarquía y seleccione Duplicar. Cambia la transformación del nuevo Destructor para que esté en la posición x = 0, y = -15, y la escala a x = 50 e y = 1.

Si ejecuta su juego ahora y sale de la plataforma (recuerde, hay una barrera invisible a la izquierda), debería pausar el juego y regresarlo al editor.

Lo arreglaremos en un paso posterior.

Lo último que se debe hacer con nuestros objetos Destroyer es hacer que sean niños fuera del objeto de la cámara, ya que queremos que nos sigan o no harán mucho en absoluto. Para hacer esto, selecciónelos y arrástrelos al objeto Cámara principal.

Paso 10: la mano

La mano que dibuja la línea es bastante simple. Vamos a hacerlo.

Primero arrastre el sprite de la mano a la ventana de su escena, colóquelo usando el objeto de su cámara para ver en qué parte de la escena está sentado.

Transforme la escala de modo que x = 2 e y = 2.

Crea un nuevo objeto de juego vacío y llámalo Penciltip. Use el editor de escenas para colocarlo en la punta del lápiz.

Dele una pequeña etiqueta para que pueda encontrarla fácilmente si es necesario. Haga esto haciendo clic en el pequeño icono del cubo en el Inspector.

Ahora arrastre Penciltip al objeto de la mano para emparejarlos. Finalmente, arrastre el objeto de la mano a la Cámara principal en la ventana Jerarquía.

Todavía no hace nada, pero las piezas están en su lugar. configuremos algunos otros bits que necesitaremos.

Paso 11: línea de lápiz

Un prefabricado es como una grabación de un objeto, convierte el objeto en un prefabricado y puede usarlo a voluntad en su escena.
Los usaremos durante gran parte del resto del juego, ya que el nivel se genera mediante programación.

Comience creando una nueva carpeta en la carpeta Activos y llámela Prefabricados. Cree un nuevo Prefab haciendo clic derecho y seleccionando Prefab. Nombra la nueva pencilina prefabricada.

Encuentra el sprite llamado pencilline en la carpeta sprite y arrástralo al nuevo objeto de juego en la ventana de jerarquía.

Agregue un cuadro colisionador 2D y cambie su tamaño para que se ajuste a la imagen de pencilina. 0.03 por 0.05 obras.

Abra su carpeta Prefab, luego arrastre el GameObject sobre el prefab. El icono cambiará para coincidir con el nuevo prefabricado.

Elimina el objeto del juego una vez que lo hayas colocado en tu prefabricado. Ya no necesitaremos el original.

Ahora agregue un nuevo script C # a su carpeta Scripts, llámelo pencilina. Ábrelo e ingresa el siguiente script.

 usando UnityEngine; usando System.Collections; pencilina de clase pública: MonoBehaviour {// para referirse a nuestra pencilina prefabricada public GameObject obj; flotador lastx = 0f; // Use esto para la inicialización void Start () {} // Se llama a Update una vez por cuadro void Update () {// si nos hemos movido lo suficiente, cree una nueva pencilina if (transform.position.x> (lastx + 0.02f )) {Instanciar (obj, transform.position, Quaternion.identity); lastx = transform.position.x; lastx = transform.position.x; }}} 
Arrastre el guión al objeto de punta de lápiz en la mano. Luego, con la punta de lápiz aún seleccionada, abra su carpeta prefabricada y arrastre su prefabricado de pencillina al nuevo parámetro obj en su controlador de script.

Nuestra cámara aún no tiene secuencia de comandos de control, pero si ejecuta el juego, debería ver un objeto de pencilina generado en la punta del lápiz. Puede verlo porque el fondo es azul y la línea se hizo para un fondo blanco.

Paso 12: ¡rueda la cámara!

Pongamos la cámara en marcha.
El objeto Camera está hecho, por lo que realmente solo necesitamos un script de controlador.

Solo un pequeño cambio antes de escribir el guión. El color de fondo. Debe ser blanco, la línea se verá migaja si no, sin mencionar la publicación que anota si decide usarlos.

Simplemente seleccione la cámara principal en la ventana de jerarquía y haga clic en la muestra de color en el Inspector; aparecerá un selector de color. Elige blanco

Bien, nuevo guión, llamé al mío pancam. Cree uno en su carpeta de script y ábralo en Monodevelop, e ingrese lo siguiente.

 usando UnityEngine; usando System.Collections; pancam de clase pública: MonoBehaviour {float ydir = 0f; jugador público de GameObject; // Use esto para la inicialización // Se llama a Update una vez por cuadro void Update () {// verifique que el reproductor existe y luego proceda. de lo contrario, obtenemos un error cuando el jugador muere si (jugador) {// si el jugador ha pasado la posición x de -1 y luego comenzamos a mover la cámara hacia adelante con una posición Y aleatoria si (player.transform.position.x> -1) {float randy = 0f; randy = Random.Range (0f, 100f); if (randy 20 && randy 80) {ydir = 0f; } transform.position = new Vector3 (transform.position.x + 0.03f, transform.position.y + ydir, -10); }}}} 
Ahora solo necesita aplicar el script a su cámara principal en jerarquía y luego arrastrar el objeto Player al parámetro del script.

Prueba el juego nuevamente, ¡acabas de hacer un corredor infinito! Bueno, casi. Todavía necesitamos algunas cosas, pero se está acercando ahora.

Mi mano está un poco más alta de lo que quiero, pero la empujaré un poco en el editor de escenas.

Paso 13: agregar una puntuación

Agrega un nuevo objeto GUIText desde el menú GameObject y nómbralo Score.

Cambie el valor de Texto a Puntuación y el color a negro en el Inspector.
Abra la ventana Juego, si no está disponible, puede encontrarla debajo de la ventana desplegable en la parte superior.

Ajuste la posición Transformar, funciona de forma extraña para los objetos GUI por alguna razón, piense en ello como el porcentaje de la pantalla visible, donde 0.5 es 50% y 0.0 es la esquina inferior izquierda.
X = 0.3 e y = 0.97 lo coloca cerca de la parte superior en la esquina izquierda.

Ahora necesitamos agregar un poco más de código a nuestro script de cámara. Actualice el script con estos cambios.
 usando UnityEngine; usando System.Collections; pancam de clase pública: MonoBehaviour {float ydir = 0f; jugador público de GameObject; // para nuestro objeto GUIText y nuestra puntuación public GUIElement gui; flotante playerScore = 0; // esta función actualiza nuestro objeto guitext void OnGUI () {gui.guiText.text = "Score:" + ((int) (playerScore * 10)). ToString (); } // esta es una función genérica a la que podemos llamar para aumentar la puntuación en una cantidad public void raiseScore (int cantidad) {playerScore + = cantidad; } // Se llama a Update una vez por cuadro void Update () {// comprueba que el jugador existe y luego procede. de lo contrario, obtenemos un error cuando el jugador muere si (jugador) {// si el jugador ha pasado la posición x de -1 y luego comenzamos a mover la cámara hacia adelante con una posición Y aleatoria si (player.transform.position.x> -1) {/ / Actualizamos nuestra puntuación en cada tic del reloj playerScore + = Time.deltaTime; flotador randy = 0f; randy = Random.Range (0f, 100f); if (randy 20 && randy 80) {ydir = 0f; } transform.position = new Vector3 (transform.position.x + 0.03f, transform.position.y + ydir, -10); }}}} 

Guarde el script de pancam y regrese a la unidad.

Seleccione la Cámara principal de nuevo y verá que hay un nuevo parámetro disponible en el componente Script en el Inspector. Arrastre el objeto Score GuiText al parámetro Gui.

Intenta jugar de nuevo, ahora deberías tener una puntuación más alta.

Paso 14: bombas lejos

Todavía no hay peligro real para nuestro héroe. Arreglaremos eso. Hagamos que algunas bombas de dibujos animados caigan del cielo y rompan la línea.

Crea un nuevo objeto de juego vacío y nómbralo Bomb. En la carpeta de sprites, encuentra el sprite de bomba, ábrelo y agrega el primer cuadro a Bomb. Ajuste la escala de transformación a X = 0.5, Y = 0.5.

Agregue un colisionador de círculo 2D y cambie su escala y posición para que se vea bien. Queremos que caigan las bombas, por lo que también necesitaremos un 2D de cuerpo rígido, agregue ese componente también.

También necesitaremos un Animador para controlar nuestros estados de bomba, así que agrégalo también. Desmarque Aplicar movimiento de raíz y marque la casilla Física animada en el Inspector.

Abra la ventana de animación, asegúrese de que todavía tiene seleccionado Bomb_0 de bomba. Agregue una animación y llámela bombidle, esto creará un nuevo estado predeterminado en nuestro Animator. Use los primeros 3 fotogramas de la hoja de sprites (arrastre y suelte) y luego reduzca la velocidad de fotogramas colocando la Muestra en alrededor de 20.

Crea otro nuevo clip, llama a este bombexplode y usa los marcos restantes de la hoja de sprites de la bomba. Nuevamente, reduzca el framerate a aproximadamente 20.

Abajo en la ventana Animator, cree una transición de bombidle a bombexplode, deje la condición para el tiempo de salida y cambie el valor a 5.00. Esto significa que nuestra bomba permanecerá inactiva (fusible encendido) durante 5 segundos antes de cambiar los estados para explotar.

Cree una tercera animación en la ventana Animación, llámela bombardeada y déjela en blanco. En Animator, crea una transición de bombexplode a bombdead.

Cree un nuevo guión llamado bomba en su carpeta de guiones.

 usando UnityEngine; usando System.Collections; bomba de clase pública: MonoBehaviour {// un soporte para nuestro Animator Animator anim; // un flotante público para el radio de explosión public float explodeRadius = 1f; // Use esto para la inicialización void Start () {anim = GetComponent (); } // Update se llama una vez por frame void Update () {// si hemos terminado de explotar if (anim.GetCurrentAnimatorStateInfo (0) .IsName ("bombdead")) {// destruye todos los objetos en un radio a menos que estén etiquetado Jugador o mano Collider2D [] colisionadores = Physics2D.OverlapCircleAll (transform.position, explodeRadius); foreach (Collider2D col en colisionadores) {if (col.tag! = "Player" && col.tag! = "hand") {Destroy (col.collider2D.gameObject); }} Destruir (this.gameObject); }}} 
Finalmente, arrastre el script de bomba a su objeto bomb_0.

Una pequeña cosa que casi olvido, es etiquetar mano a mano. para hacer esto, seleccione su objeto de mano en la ventana de jerarquía y luego, debajo de la etiqueta, seleccione agregar etiqueta. Cree una nueva etiqueta en element0 llamada hand, luego con su objeto hand seleccionado, cambie la etiqueta a hand. También cambie la etiqueta del objeto de punta de lápiz a mano.

Intenta ejecutar el juego, la bomba debería caer, explotar y sacar la barra de navegación. (dependiendo del curso donde lo haya colocado)

Paso 15: Generación de bombas

Ahora es un poco difícil jugar el juego, lo que haremos es hacer un objeto de generación para generar las bombas, de manera muy parecida a la punta de un lápiz genera la pencilina.

Lo primero que necesitamos es un prefabricado de nuestra bomba. Navegue a la carpeta prefabricada y cree una nueva prefabricada, asígnele el nombre bomba. Arrastre el objeto Bomba al prefabricado de bomba Elimine el Objeto de bomba original en la jerarquía una vez que lo tenga como Prefabricado.

Crea un nuevo objeto quad llamado BombSpawn. Colóquelo encima de la cámara y verifique en la vista Cámara principal o en la ventana Juego.

Cree un nuevo script en su carpeta de script llamado BombSpawner y dele el siguiente código.

 usando UnityEngine; usando System.Collections; public class BombSpawner: MonoBehaviour {// una matriz de objetos públicos para los que generar objetos públicos GameObject [] obj; // tiempos mínimos y máximos para otro spawn público float spawnMin = 3f; flotante público spawnMax = 2f; void Start () {// start spawn Spawn (); } void Spawn () {// obtener un número aleatorio float rand = Random.Range (0, 1000); // si el número aleatorio es mayor que 700, haga una bomba if (rand> 700) {Instantiate (obj [Random.Range (0, obj.GetLength (0))], transform.position, Quaternion.identity); } // invocar spawn en un intervalo de tiempo aleatorio entre min y max Invoke ("Spawn", Random.Range (spawnMin, spawnMax)); }} 
Primero haga que el objeto BombSpawn sea hijo de la cámara principal arrastrándolo a la cámara a través de la ventana de jerarquía.
Ahora arrastre el script al objeto BombSpawn en la ventana Jerarquía. Ahora con BombSpawn abierto en el Inspector, arrastre el prefabricado de Bomb al pequeño triángulo etiquetado Obj en el componente de script.

Tenemos que agregar una declaración if en nuestro script de Bomb (desde el último paso) para retrasar la caída de las bombas hasta que el jugador haya comenzado a caminar en la línea. Una revisión rápida en mi escena muestra la mano sentada a las 7, así que retrasaré las gotas hasta que las bombas pasen de las 12.
Aquí está el script modificado de Bomb.

 bomba de clase pública: MonoBehaviour {// un soporte para nuestro Animator Animator anim; // un flotante público para el radio de explosión public float explodeRadius = 1f; // Use esto para la inicialización void Start () {anim = GetComponent (); } // Update se llama una vez por frame void Update () {// si esta bomba se genera después de que el generador alcanza una posición más allá de x = 12 if (transform.position.x> 12) {this.gameObject.SetActive (true) ; } // de lo contrario no bombardearía ningún trabajo más {this.gameObject.SetActive (false); } // si hemos terminado de explotar if (anim.GetCurrentAnimatorStateInfo (0) .IsName ("bombdead")) {// destruye todos los objetos en un radio a menos que estén etiquetados Player o hand Collider2D [] colliders = Physics2D.OverlapCircleAll ( transform.position, expldeRadius); foreach (Collider2D col en colisionadores) {if (col.tag! = "Player" && col.tag! = "hand") {Destroy (col.collider2D.gameObject); }} Destruir (this.gameObject); }}} 
Ahora Robot puede saltar en la línea y caminar un poco antes de que las bombas comiencen a caer ... pruébelo. Todavía no es muy desafiante. ¡Dupliquemos el objeto BombSpawn! Luego, muévelo un poco y tenemos dos generadores de bombas, juguemos.

Paso 16: plataformas (o garabatos)

Para generar las plataformas de doodle, comenzamos creando algunos prefabricados. Cree una nueva carpeta en la carpeta Prefab y llámela Doodles.

Sin embargo, cree 10 prefabricados nuevos llamados doodle1 para doodle10.

Cree un nuevo objeto de juego vacío, sin necesidad de nombrarlo.

Abra la carpeta de sprites y busque la hoja de garabatos, ábrala y seleccione el primer garabato. Arrástrelo al objeto de juego vacío en la ventana de jerarquía.

Agregue un colisionador de caja 2D en el inspector, luego juegue con la escala y el centro para que quede bien en el garabato. Recuerde, esto es en lo que aterrizará Robot.

Abra su carpeta Prefabs / Doodles con los prefabs vacíos y luego arrastre el nuevo GameObject al doodle1 prefab.

Ahora, en lugar de repetir todo este proceso, solo navegue de regreso a la carpeta de sprites, tome el siguiente garabato y arrástrelo al componente Sprite Renderer del objeto de juego, ajuste la posición del colisionador y colóquelo en el siguiente prefabricado de garabatos.

Repita esto para los prefabricados de doodle restantes. Una vez que estén todos grabados como prefabricados, puede eliminar el GameObject que creamos para crearlos.

Ahora duplique un objeto BombSpawn debajo de nuestra cámara principal y muévalo fuera de la pantalla a la derecha. Déle un nuevo nombre en el Inspector, algo así como DoodleSpawn.

Luego arrastre cada uno de los nuevos prefabricados al parámetro Obj de nuestro componente de script. Arrastre el primero al elemento 0 para reemplazar la bomba, y los otros al pequeño triángulo al lado de Obj para agregarlos a la lista.

Juega con el parámetro min / max en el componente de script para cambiar la frecuencia con la que se generan. Duplique el objeto DoodleSpawn y muévalo hacia arriba si desea otro conjunto de niveles.

Una cosa que noté mientras jugaba es que la velocidad máxima de los robots era demasiado baja, la aumenté aquí. Vaya a su objeto Player y ajuste la variable maxSpeed ​​en el componente Script si encuentra el mismo problema.

Paso 17: Recolección de puntos de bonificación

Hacer las pastillas es muy similar a hacer los garabatos. Algunas pequeñas diferencias. Comience creando una nueva carpeta en la carpeta Prefabs llamada Bonus, y llénela con 6 prefabs en blanco.

Necesitaremos un script para manejar la adición de los puntos de bonificación al objeto GUIText, por lo tanto, en la carpeta de scripts, cree un nuevo script llamado BonusPoints. Aquí está el script para ingresar en Monodevelop.

 usando UnityEngine; usando System.Collections; BonusPoints de clase pública: MonoBehaviour {// crea un contenedor para la pantalla de visualización frontal pancam hud; nulo OnTriggerEnter2D (Collider2D col) {if (col.tag == "Player") {hud = GameObject.Find ("Cámara principal"). GetComponent (); hud.increaseScore (10); Destruye (this.gameObject); }}} 

Ahora regrese a la escena y cree un nuevo GameObject vacío. Encuentra potenciadores en la carpeta de sprites y arrastra el primer sprite al nuevo GameObject.

Transforme la escala a x = 2, y = 2 en el inspector, luego agregue un cuadro colisionador 2D. Esta vez queremos marcar la casilla marcada como Trigger.

Ahora arrastre el script BonusPoints a powerups_0. Abra la carpeta prefabs / bonus y arrastre el GameObject al prefab.

Como en el paso anterior, simplemente reemplace el Sprite Renderer Sprite para cada prefabricado y guárdelos.

Una vez que se hacen los seis Prefabs de bonificación, podemos eliminar el GameObject que usamos para construirlos.

Para generar nuestros bonos, simplemente duplicaremos el objeto DoodleSpawn, le cambiaremos el nombre BonusSpawn, lo moveremos un poco hacia arriba y reemplazaremos el objeto que genera.

Paso 18: juego terminado

El tramo de casa! Todo lo que necesitamos ahora es que el jugador muera en lugar de una ruptura en el código. Eso, y necesitaremos una segunda escena, para mostrar que el juego ha terminado y ofrecer la oportunidad de volver a jugar.

Agreguemos esta escena a la construcción antes de comenzar la nueva escena. En el menú desplegable Archivo, seleccione Configuración de compilación.
En el cuadro de diálogo que se abre, haga clic en el botón Agregar actual y verifique que la escena tenga un número de escena cero. Cierra el cuadro de diálogo.

Asegúrese de guardar su escena actual y luego seleccione Nueva escena. Asigne un nombre a la escena GameOver y colóquela en la carpeta Activos.

Agregue un objeto GUIText desde el menú desplegable GameObject. En el inspector, cambie Ancla al centro superior y alineación al centro. También cambie el tamaño de fuente a 20 y el color a negro.

De vuelta en la escena, arrastre la nota adhesiva llamada notes_score a la escena y colóquela aproximadamente al centro, use la ventana Juego para ver cómo se verá. Haz lo mismo con el sprite Game Over, solo déjalo donde se ve bien.

Cree una secuencia de comandos gameOver en la carpeta de secuencias de comandos, como esta.

 usando UnityEngine; usando System.Collections; GameOver de clase pública: MonoBehaviour {int score = 0; GUI pública GUI; // Use esto para la inicialización void Start () {// obtenga nuestra puntuación de playerprefs score = PlayerPrefs.GetInt ("Score"); // multiplica por 10 como lo hicimos en la puntuación mostrada score = score * 10; } void OnGUI () {// establece nuestro texto en nuestra puntuación gui.guiText.text = score.ToString (); // si se presiona el botón de reintento, cargue la escena 0 del juego if (GUI.Button (new Rect (Screen.width / 2-50, Screen.height / 2 +150, 100, 40), "Retry?")) {Application.LoadLevel (0); } // y botón para salir if (GUI.Button (new Rect (Screen.width / 2-50, Screen.height / 2 +200, 100, 40), "Quit")) {Application.Quit (); }}} 

Guárdelo y arrástrelo a la cámara principal en nuestra nueva escena.

Casi todo terminado, necesitamos agregar una función a nuestro script de cámara para pasar la puntuación hacia adelante, y necesitamos alterar nuestro script destructor donde tenemos el salto de código para enviarnos a la escena de GameOver.

El nuevo script de cámara.

 usando UnityEngine; usando System.Collections; pancam de clase pública: MonoBehaviour {float ydir = 0f; jugador público de GameObject; // para nuestro objeto GUIText y nuestra puntuación public GUIElement gui; flotante playerScore = 0; // esta función actualiza nuestro objeto guitext void OnGUI () {gui.guiText.text = "Score:" + ((int) (playerScore * 10)). ToString (); } // esta es una función genérica a la que podemos llamar para aumentar la puntuación en una cantidad public void raiseScore (int cantidad) {playerScore + = cantidad; } // La cámara se deshabilitará cuando carguemos un nivel, establezca la puntuación en playerprefs void OnDisable () {PlayerPrefs.SetInt ("Score", (int) (playerScore)); } // Se llama a Update una vez por cuadro void Update () {// comprueba que el jugador existe y luego procede. de lo contrario, obtenemos un error cuando el jugador muere si (jugador) {// si el jugador ha pasado la posición x de -1 y luego comenzamos a mover la cámara hacia adelante con una posición Y aleatoria si (player.transform.position.x> -1) {/ / Actualizamos nuestra puntuación en cada tic del reloj playerScore + = Time.deltaTime; flotador randy = 0f; randy = Random.Range (0f, 100f); if (randy 20 && randy 80) {ydir = 0f; } transform.position = new Vector3 (transform.position.x + 0.03f, transform.position.y + ydir, -10); }}}} 

El script del destructor fijo

 usando UnityEngine; usando System.Collections; Destructor de clase pública: MonoBehaviour {void OnTriggerEnter2D (Collider2D otro) {// si el objeto que activó el evento está etiquetado como jugador if (other.tag == "Player") {Application.LoadLevel (1); } if (other.gameObject.transform.parent) {Destroy (other.gameObject.transform.parent.gameObject); } else {Destruye (other.gameObject); }}} 

¿Adivina qué? ¡Acabas de hacer un juego! ¡¡Yo también lo hice!! woot para nosotros!
Ok, entonces no es el mejor juego del mundo, pero ese no es el punto. Al menos no fue para mí. Me sorprendió lo simple que se ha vuelto todo, y tuve que compartir. Ve a hacer, ¡no puedo esperar para jugar nuevos juegos geniales!

Paso 19: archivos, etc.

Incluí este último paso para hacer que los guiones que acabamos de escribir juntos sean un poco más fáciles de acceder.
Así que aquí están los guiones que acabamos de leer.

Muchas gracias por pasar, espero que lo hayan disfrutado tanto como yo.
Comparte y Disfruta.

Ah, y ... ¿votan fjordcarver?

Archivos adjuntos

  • bomb.zip Descargar
  • BombSpawner.zip Descargar
  • BonusPoints.zip Descargar
  • Destroyer.zip Descargar
  • GameOver.zip Descargar
  • Descargar pancam.zip
  • pencilline.zip Descargar
  • RobotController.zip Descargar

Artículos Relacionados