Sistemas Multimedia

Creación de Videojuegos y Mundos Virtuales

Unity Básico – Tutorial/Ejercicios

Introducción

El objetivo de estas prácticas a modo de tutorial es aprender los conceptos básicos sobre la plataforma de
desarrollo de juegos y creación de entornos virtuales Unity.
Unity es en estos momentos una de las plataformas de creación de mundos virtuales y animación más
utilizadas a nivel mundial. Con una extensa comunidad y numerosos tutoriales, le convierte en un entorno de
desarrollo adecuado tanto para aquel que quiera introducirse en la programación de videojuegos, como para
aquel que quiera desarrollarlos a nivel profesional.
Con estas prácticas se pretende adquirir las competencias en manejo de Unity mínimas necesarias para
abordar la creación de nuestro primer videojuego o mundo virtual. Adquirir un manejo experto excede los
objetivos de la asignatura y queda a la voluntad de cada alumno. Al finalizar, se conocerá:
 El significado de términos (jerga) muy utilizados en el mundo de los videojuegos como: asset, sprite,
prefab, GameObject, …
 El manejo básico de la interfaz de Unity, así como el significado de cada elemento de ella
 Cómo crear un proyecto, editarlo y guardarlo.
 Cómo crear escenas, editarlas y guardarlas.
 Cómo añadir, editar y eliminar elementos de un juego o mundo virtual.
 Cómo realizar la animación de personajes o elementos del juego mediante:
o Secuencias de sprites o
o Animando cada elemento del personaje de manera independiente
 Cómo crear un diagrama con los estados por los que pasará un determinado elemento (generalmente
el protagonista) durante la evolución del juego.
 Cómo definir y modificar los eventos que producen la transición entre esos estados.
 Cómo añadir componentes a cualquier elemento del juego. El concepto de componente es básico en
Unity y nos permite añadir comportamiento a cualquier elemento. Un componente puede ser:
o Una propiedad física. Por ejemplo, añadirle un cuerpo rígido para gestionar las colisiones con el
resto de elementos del juego o su comportamiento en situaciones de gravidez o ingravidez.
o Un programa (script), para poder definir el comportamiento de nuestro elemento.
 Los conceptos básicos para la creación de esos scripts en C#. Unity permite crear programas que
gestionen los distintos elementos del juego, su comportamiento y relaciones, así como todo lo
relacionado con puntuaciones y gestión de cómo empezar, acabar y realizar transiciones entre estados.
Estos programas se pueden crear en C# y en Javascript. Lo más usado es C# y es lo que vamos a usar
nosotros. Aunque no se conozca el lenguaje, no hay problema, lo que vamos a utilizar en tan básico,
que dada la experiencia en programación que se tiene en distintos lenguajes, no va a suponer ningún
inconveniente a la hora de usar Unity.
  El concepto de cámara, para qué sirve, los distintos tipos que hay, cómo crearla y gestionarla según el
enfoque de nuestro juego: cámara estática, cámara de tercera persona o cámara de primera persona.
 Crear y cambiar de escena.
 Introducir texto, mostrando como mostrar la puntuación.
Con Unity se pueden crear entornos virtuales en 3D y 2D. Para ser más precisos, Unity maneja siempre
entornos virtuales en 3 dimensiones, pero permite la opción de desarrollar nuestros juegos en 2D. Lo que
hace en este caso es realizar una proyección del mundo en 3D sobre el planto XY. Aunque se escoja la opción
2D, durante el desarrollo de nuestro juego, en la ventana de edición, siempre vamos a poder pasar a 3D para
editar en ese entorno si lo deseamos; siempre teniendo en cuenta que al final veremos la proyección
indicada. De igual manera, aunque estemos en 3D, podremos dar la opción en la ventana de edición de poder
ver lo que tenemos en 2D.
Como nuestro objetivo aquí es tener los conocimientos básicos de Unity para desarrollar nuestro primer
juego, en principio, se propone (y este manual está enfocado en ese sentido) empezar en 2D, que es más
sencillo. Aunque algunos de los tutoriales que manejaremos desarrollan un juego en 3D, en realidad, como
veremos, al final el juego estará en 2D. Esta es nuestra propuesta, sin embargo, si estás más interesado en
que tu juego o desarrollo de un mundo virtual sea en 3D, también lo puedes hacer. El desarrollo en 2D es un
consejo…
Introducido el tema, pasamos a la práctica. Los puntos que se proponen a continuación están pensados para
ser seguidos en secuencia, ya que su orden está pensado para adquirir competencias de manera gradual. En
la mayoría de los casos serán seguir un tutorial, aunque también se plantean la resolución de ejercicios de
seguimiento y práctica de lo aprendido. Se indica en cada caso si es un “Tutorial” o es un “Ejercicio”. En cada
punto se indicará el tiempo que se ha estimado en su realización. Debería ser suficiente, ya que la estimación
se ha hecho un poco a “lo alto”.

Instalación

La página web oficial en castellano de Unity es: https://unity3d.com/es. Ahí se puede encontrar información
del producto, tutoriales, manuales de la API, etc.
Ir a la zona de descargas. Se verá que existen varias opciones de adquirir el producto. Como no lo vamos a
usar con fines comerciales, nos descargaremos la versión gratuita, que para nuestros objetivos es suficiente.
¿Qué versión me descargo? En principio, es conveniente descargarse la última versión. El problema en estos
casos puede ser la incompatibilidad con lo que aparece en los tutoriales… Ahora bien, hasta ahora nunca se
ha tenido problema en este sentido. En caso de proyectos de distinta versión, Unity los convierte de manera
automática a la más reciente. Por otro lado, vamos a tratar con conceptos básicos, totalmente compatibles
con cualquier versión. De todas formas, en https://unity3d.com/es/get-unity/download/archive se tienen
todas las versiones de Unity.
AVISO: si no lo tenemos, instalar el IDE Microsoft Visual Studio que viene junto con Unity. Nos permitirá
editar los scripts. No es necesario, pero es aconsejable, ya que Unity “conecta” de manera automática con él
El proceso de instalación no es inmediato, por lo que para acelerarlo vamos a indicar aquí los pasos
principales (más información en https://docs.unity3d.com/Manual/GettingStartedInstallingUnity.html):
a) Conectarse a https://unity3d.com/es/get-unity/download. Hacer clic en
b) Escoger la pestaña “Individual” y escoger la opción “Personal”, la gratuita. Clic en
c) Escoger la opción de “Experienced Users”

d) Aceptar los términos de la descarga, y descargamos Unity Hub . Esto no es el editor. Es

un “concentrador” o herramienta que permite acceder a todos los recursos Unity, entre ellos el editor.
Nos permitirá, incluso acceder a distintas versiones de éste en una misma máquina
e) Instalarlo. Esta parte es rápida. Al acabar ejecutarlo
f) Ahora tenemos que instalar o conseguir la licencia gratuita, para uso no comercial. Seguir los pasos,
hasta lograr el fichero con la licencia y cargarlo en el Hub. Ahora ya podemos acceder a las herramientas
Unity.
g) Ir a la pestaña “Installs”

h) Clic en el botón “ADD”.

i) Seleccionar la versión del editor que se desee. Se recomienda la última.

j) Clic en Next. Aparecen una serie de módulos adicionales que podemos instalar. Entre ellos, si no se
tiene, el IDE Visual Studio, que se usará para la edición de los scripts. Seleccionar los que se deseen,
aunque se puede instalar lo básico, que será más rápido, y si se necesitan, instalar los módulos más
tarde. Una vez seleccionados, clic en “DONE”. Se empezará a instalar el editor y los módulos, lo que,
ahora sí, llevará un tiempo. La progresión se muestra en la pequeña barra azul superior.

k) Una vez acabada, abrir la opción “Projects”, para crear un nuevo proyecto (botón “NEW”) o añadir ya
creados (botón “ADD”). Para abrir un proyecto, clic sobre el proyecto.
Práctica

1. Tutorial. Aprendemos: Conceptos básicos, instalación y manejo básico de la interfaz de Unity. Duración
estimada: 1 a 2 horas

Leerse y realizar los ejemplos que aparecen, si los hay, en los tutoriales de los siguientes enlaces:

https://www.relaxate.com/content/programacion-tutorial-desarrollo-videojuegos-unity-2d-parte-0

https://www.raywenderlich.com/147687/introduction-unity-getting-started-part-12

Por si hay problema de acceso, en la página web de la asignatura se ha dejado el contenido de esos
tutoriales en pdf. Documentos: Tutorial_Relaxate_0.pdf y Tutorial_raywenderlich_1.pdf, respectivamente.

Ver los primeros 10 – 11 minutos de:

https://www.youtube.com/watch?v=IZ4eiIf3DBY&list=PLiplYDjUMtthTOwbzd-FPZiBHNhwbNu5e

Añade algún comentario a los objetos cámara e iluminación. Sólo verlo, no hay que hacer nada más.

2. Tutorial. Aprendemos: Conceptos básicos de creación y eliminación de elementos de un juego,

animación, diagrama de estados y creación de scripts. Duración estimada: 1 hora

Leerse, no hay que hacer de momento lo que aparece, el contenido de los siguientes tutoriales:

https://www.relaxate.com/tutorial-manuales-curso-documentacion-desarrollo-programacion-
videojuegos-unity-2d-parte-1

https://www.relaxate.com/tutorial-documentacion-manual-programacion-videojuegos-unity-2d-parte-2

Se puede acceder también a su contenido mediante los documentos Tutorial_Relaxate_1.pdf y

Tutorial_Relaxate_2.pdf de la web de la asignatura.

3. Tutorial-Ejercicio. Practicamos la creación y edición de un componente script en C#. Duración: 1 hora

Ahora sí practicamos un poco la creación y edición de scripts en C#. Muy básico, pero ayuda a entender
cómo funcionan en sus partes básicas, vistas en los tutoriales del punto anterior. Ver a partir del minuto
10 del siguiente video y practicar lo que se indica:

https://www.youtube.com/watch?v=IZ4eiIf3DBY&list=PLiplYDjUMtthTOwbzd-FPZiBHNhwbNu5e
4. Tutorial-Ejercicio. Creación de un primer juego. Aprendemos: Crear proyecto, añadir elementos, editar
elementos, crear prefabs, añadir componentes (física y scripts), añadir sonido, probar juego. Duración
estimada: 2 a 3 horas

Siguiendo paso a paso lo que aparece en el siguiente tutorial, vamos a desarrollar nuestro primer juego.
Está todo hecho, lo único que tenemos que hacer es seguir lo que se nos indica. URL del tutorial:

https://www.raywenderlich.com/149036/introduction-unity-getting-started-part-22

Como antes, se ha descargado el contenido a pdf (no se ven las animaciones, pero todo lo demás se
puede seguir) y también se ha descargado el material adicional necesario para seguir el tutorial.
Documentos: Tutorial_raywenderlich_2.pdf y Tutorial_raywenderlich_2_sample-files.zip de la página web,
respectivamente.

Avisos importantes (problemas encontrados durante la realización del tutorial):

 No se añaden por defecto, al crear el proyecto nuevo, los elementos del juego “Camera” y
“Directional light” que aparen en el tutorial:

Si no aparecen el juego no funcionará. Crearlos “a mano” (una vez creados se pueden mover en la
pantalla “Hierarchy” si queremos que aparezcan en el orden del tutorial) como se indica a
continuación:

o Camera. Clic en “Create” -> “Camera”. El nombre de se podrá cambiar a “Main Camera” como
aparece en el tutorial, pero no es necesario.
 o Directional Light. Clic en “Create” -> “Light” -> “Directional Light”

 Durante la realización del tutorial se ha perdido en la escena el sprite correspondiente a la nave

espacial. Si ocurre esto, hacer lo siguiente para poner el foco en el elemento del juego que
queramos dentro de la escena (se pega la ayuda del manual de Unity): “Centering the view on a
GameObject: To center the Scene View on a GameObject, select the GameObject in the Hierarchy,
then move the mouse over the Scene View and press F. This feature can also be found in the
menu bar under Edit > Frame Selected. To lock the view to the GameObject even when the
GameObject is moving, press Shift+F. This feature can also be found in the menu bar under Edit >
Lock View to Selected.”

5. Ejercicio. Analizar los scripts usados en el juego anterior. Aprendemos: Cómo es un script (variables,
métodos start(), update(),…), cómo se accede a componentes del elemento, cómo se accede o llama a
métodos de otros scripts añadidos al elemento, etc. Duración estimada: 1 hora.

AVISO: Si no se ha podido finalizar completamente el apartado anterior, se puede acceder al proyecto

Unity completamente funcional, para poder hacer este ejercicio, en: SpaceDebrisExported.unityPackage.

Abrir los distintos scripts usados en el juego, analizando y tratando de entender su contenido básico, para
ver qué hacen y cómo lo hacen. Para verlos se puede usar cualquier editor de texto o usando la opción
“editar” de Unity sobre el componente en la ventana “Inspector”:

Esto abrirá nuestro script en el “Microsoft Visual Studio”, pudiendo editarlo en ese IDE. Este IDE se instala
junto con Unity, si no lo tenemos.

Para entender un poco mejor la parte del movimiento, se puede ver el siguiente videotutorial, que lo
explica de manera sencilla: https://www.youtube.com/watch?v=xfp4kpM3Asw
6. Ejercicio. Crear nuevo Script (modificar comportamiento de la nave). Aprendemos: creación de scripts
en Unity, gestión del componente “collider”, añadir componente sonido. Duración estimada: 1 a 3 horas.

Vamos a modificar el script que controla la nave (“ShipController.cs”) para que ésta se destruya igual que
los asteroides (en el video “Unity_EjercicioSpaceDebrisNaveSeDestruye” de la página web se muestra en
ejemplo del objetivo de esta práctica). Para ello, primero, realizar una copia del script original y llamarle
“ShipControllerDestroy.cs”. Para no perder el original, vamos a trabajar sobre éste.

Realizar en ese script los cambios necesarios para que al chocar la nave con un asteroide la nave también
se destruya. En el script original, cuando se choca con algo, se “resetea” la nave. Aquí queremos sustituir
ese comportamiento, por el que se destruya, al igual que cuando colisionan dos asteroides entre sí o
cuando un disparo de la nave alcanza a un asteroide. Para ello, usaremos como referencia para nuestros
cambios el script que controla eso: “Debris.cs”. Para que el efecto quede mejor, haremos como con los
asteroides, que la desaparición sea paulatina (“fader”) y que se genere el sonido de destrucción.

Por si no se ha logrado realizar el juego correctamente, se deja en la web el proyecto exportado: fichero
“SpaceDebrisExported.unitypackage”. Importarle y sobre el realizar la modificación. Para importarle, abrir
un proyecto nuevo vacío, luego hacer clic con el botón derecho sobre “Assets” en la ventana “Project”,
seleccionar del menú la opción “Import Package”->”Custom Package”.

Una vez importado, hacer doble clic en la escena “Main” que aparece en “Assets”. Una vez cargada (se
tiene que ver en la ventana “Hierarchy”) ya se puede ejecutar el juego del tutorial y comprobar que todo
funciona correctamente.

AVISOS:

 El script “Debris.cs” usa para gestionar la atenuación el script “RendererFade.cs”. Deberemos usarle
también en la destrucción de la nave. En “Debris.cs” aparece cómo llamarle desde otro script. Para
hacer esto, hay que tener en cuenta que para que un objeto sea incluido en otro, el primero tiene
que estar instanciado, sino da error. Para que esto ocurra, en el elemento (GameObject)
“Spaceship” tendremos que añadir no sólo el componente “ShipControllerDestroy.cs” (quitando
primero el anterior script de control), sino también el componente “RendererFade.cs”. Así, al crear
el elemento “Spaceship” se instanciarán los objetos correspondientes a los scripts que contenga.
 Puede ser útil en la depuración de nuestro script mandar mensajes a consola (se incluye en Unity).
Para ello se puede usar la función “Debug.Log(mensaje)”.
  Problema: colisiona un asteroide con la nave, pero ésta no se destruye. Comprobar que todos los
elementos del juego están en el mismo plano. Recordar que, aunque en realidad el juego es 2D, ha
sido desarrollado en un entorno 3D. Esto puede hacer que al manipular algún elemento del juego
hayamos modificado su componente Z. Que el juego es en realidad 2D se puede ver en los scripts,
donde para gestionar el movimiento de los distintos elementos sólo se modifican las coordenadas X
e Y; también se puede ver al ejecutar el juego mirando cómo se modifican los valores de “Position”
en la ventana “Inspector”, del elemento seleccionado.
Solución: editar todos los componentes del juego y poner en sus coordenadas de posición
(atributo “Position” de su componente “Transform”), la Z con el mismo valor:

El valor de la imagen es un ejemplo de lo que hay que modificar, no indica el valor de nuestro juego.
Eso habrá que hacerlo comprobando ese valor en nuestros elementos y ver cuál se ha modificado.

7. Tutorial. Crear y animar sprites. Aprendemos: dividir una imagen en sus componentes (sprites) y a
usarles para crear una animación. Duración estimada: 1 hora

Leer y ver los tutoriales correspondientes de los siguientes enlaces:

https://docs.unity3d.com/es/current/Manual/SpriteEditor.html -> manual oficial

https://www.youtube.com/watch?v=NQVMPeOfZpc&index=2&list=PLiplYDjUMtti5bWJ1Ugystr-vUg8B5EuP ->
Verlo completo. Indica como dividir de manera automática una hoja de sprites con el movimiento del
personaje, como crear animaciones y asociarlas a estados y cómo crear transiciones entre estados.

https://www.youtube.com/watch?v=Y_PKWr_1rDw&list=PLiplYDjUMtti5bWJ1Ugystr-vUg8B5EuP&index=1 ->
ver los primeros 6 minutos (se puede ver entero, pero para esta parte nos interesa eso). Aparece como dividir
una hoja de sprites usando cuadrícula.

8. Ejercicio. Crear animación. Aprendemos: practicar crear una animación y el correspondiente diagrama
de estados asociado. Duración: 1 hora

Crear un nuevo proyecto. Añadir al proyecto la hoja de sprites “Mario.png” de la página web de la
asignatura. Dividir la hoja en sprites independientes. Crear un par de animaciones del personaje. En el
video de la página web de la asignatura “Unity_EjercicioAnimacionSecuenciaSprites”, podemos ver un
ejemplo de lo que se pide. Ver en la ventana “Inspector”, cómo al crear las animaciones se añade al
personaje el objeto “Animator” que será usado, como veremos en los siguientes tutoriales y ejercicios,
para gestionar la animación del personaje mediante scripts.

En la ventana “Animator” añadir una transición de cada estado al otro de la animación. De momento no
vamos a añadir ninguna condición a cada transición. Ejecutar el juego y ver cómo el personaje pasa de un
estado de animación a otro sin control, ya que no se ha hecho esa parte.
9. Tutorial. Animación dinámica. Aprendemos: a mover al personaje y realizar las transiciones entre
estados de manera dinámica. Duración: 30 minutos.

Ver los siguientes videos tutoriales. Nos interesa el segundo, pero depende del primero, por lo tanto hay
que ver los dos. Además, el primero nos indica cómo mover a un personaje en una dirección, lo que
también es interesante. Aunque no lo vayamos a usar aquí, sí que puede ser necesario en nuestro juego.

https://www.youtube.com/watch?v=cT4cR9PQMg8&list=PLiplYDjUMtti5bWJ1Ugystr-vUg8B5EuP&index=3 ->
Indica cómo hacer que un personaje se mueva a derecha a izquierda con una velocidad limitada.

https://www.youtube.com/watch?v=J-4o-8rr_po&list=PLiplYDjUMtti5bWJ1Ugystr-vUg8B5EuP&index=4 ->
Modifica el script anterior para añadir lo que nos interesa aquí, como conectar el personaje con la
animaciones creadas, accediendo a las condiciones indicadas en las transiciones entre estados. Lo que nos
interesa está en los 5 primeros minutos, aunque se puede ver íntegramente, ya que siempre aparecen cosas
adicionales que pueden ser interesantes.

10.Ejercicio. Animación Dinámica. Aprendemos: a practicar lo visto en el punto anterior. Duración: 0.5 – 1
hora. En el video “Unity_EjercicioAnimacionSpritesCambioEstado”, de la web de la asignatura, se muestra
un ejemplo de lo que se pretende con este ejercicio.

Partimos de lo realizado en el ejercicio 7. Añadir en el “Animator” 2 parámetros de tipo “Trigger” (vamos a

usar el teclado para cambiar entre animaciones). Llamarles, por ejemplo, “FlechaDerecha” y
“FlechaIzquierda” (vamos a usar esas teclas para las transiciones). Hacer clic en cada transición en el
diagrama de estados y añadir sendas “Conditions”. Asociar a cada “Condition” uno de los parámetros
creados (diferente en cada transición).

Vamos ahora a programar el comportamiento del personaje (recordar que debe ser el objeto al que le
hemos añadido las animaciones). Añadirle un script que haga lo siguiente: si se pulsa la flecha derecha
ejecute una animación y si se pula la flecha izquierda la otra, es decir, crear un script que “conecte” con el
componente “Animator” del personaje y permita realizar las transiciones mediante las flechas entre las
animaciones asociadas.

Para ver cómo acceder a la pulsación de las flechas desde un sript podemos usar el script
“ShipController.cs” del tutorial del primer juego. También aparece en el video-tutorial del ejercicio 3. En
ambos se muestra cómo hacerlo.

11. Ejercicio-Reto Opcional. Mi primer juego.

Antes de continuar, se propone para realización voluntaria el reto de usar todo lo aprendido (y lo que se
muestra en los tutoriales vistos) en la creación un primer juego simple que haga lo siguiente: intentar
mantener un personaje (puede ser una simple figura como un cubo o una esfera) en una plataforma.
Crearemos una plataforma (es fácil de encontrar sprites gratis ya hechos o crearla) y encima un personaje
que animaremos para que se mueva en dos direcciones izquierda y derecha, controlando eso con las
flechas correspondientes. El personaje se moverá con velocidad incremental y el reto es que no se caiga
de la plataforma. Si hubiera puntuación, ésta sería la velocidad máxima que he logrado alcanzar antes de
que se caiga o el tiempo. No sabemos cómo mostrar esto en el juego, pero sí podemos verlo en la consola,
si queremos.
 12. Tutorial. Otra forma de animar un personaje. Aprendemos: a animar un personaje en vez de mediante
secuencia de sprites, mediante la animación de cada parte que lo compone. Duración: 0.5 - 1 hora

Visionar el siguiente video que explica cómo crear una animación de un personaje construido mediante la
agregación de sprites individuales. Se muestra cómo “mover” cada sprite del personaje para lograr una
animación y cómo guardar ésta. Es otra forma interesante de lograr animaciones.

https://www.youtube.com/watch?v=NVqDAkTV2Vg&index=7&list=PLREdURb87ks2qkD9svvlIwYwN35FZ3Afv

Si se quiere ver, de manera opcional, otra animación sobre el mismo personaje:

https://www.youtube.com/watch?v=cmEI-KM4GQ8&index=8&list=PLREdURb87ks2qkD9svvlIwYwN35FZ3Afv

Si se quiere ver cómo se crea el personaje, está en el video 4 de tutorial al que pertenecen los videos
anteriores.

13. Ejercicio. Probando animación anterior. Aprendemos: practicamos lo visto en el tutorial anterior.
Duración: 30 minutos. Video – Ejemplo: “Unity_EjercicioAnimacionCubo”

Quitar el personaje de la escena. IMPORTANTE: guardarle antes en la carpeta sprites, por ejemplo, para
no perder los cambios. Añadir a la escena una figura geométrica 3D, un cubo o esfera, por ejemplo
(recodemos: en ventana “Hierarchy” -> “Create” -> “3D Object” -> objeto). Usando la técnica del video
anterior animar la figura “como si respirase”, es decir, animar del cubo su tamaño para que crezca y
decrezca. Pista: en la ventana animación añadir la propiedad (“propierty”) transform->Scale de la figura,
ya que es la que vamos a animar:

Si queremos ver la animación en 3D, hacer clic en el botón “2D” de la ventana de escena para pasar a 3D.

14.Tutorial. Manejo de la cámara. Aprendemos: a gestionar la cámara según las necesidades de nuestro
juego. Duración: 1 hora

De entre los conceptos básicos de Unity ya sólo nos falta abordar el tema del “manejo” de la cámara
principal (puede haber cámaras secundarias para efectos, por ejemplo, como el tipo Parallax, pero esto
cae fuera de esta introducción básica). Hay, básicamente, tres opciones (en
https://unity3d.com/es/learn/tutorials/topics/graphics/cameras podemos ver un tutorial básico de la web
oficial de Unity, es para la versión 4.1, pero los conceptos básicos sobre gestión de cámaras son
independientes de versión):
 1. Cámara Fija (Fixed Camera): la cámara está fija, normalmente centrada en la escena, aunque
moviendo el objeto en la escena o mediante su componente “Tranformer” la podemos situar donde
queramos. Los objetos se mueven relativamente a ésta. Es la situación que hasta ahora hemos
tenido en los tutoriales y ejercicios hechos, por ser la más sencilla.

2. Cámara de Tercera Persona (Third Person Camera): la cámara se mueve con la escena-personaje.
Situación típica en un juego de plataformas. Según se mueve el personaje, la cámara le sigue.

Un ejemplo de cómo hacerlo se puede ver en el siguiente video (cómo hacer que la cámara siga al
personaje se muestra en los primeros 6 minutos, en el resto se muestra cómo hacer que el
personaje se mueva):

https://www.youtube.com/watch?v=61QPo93VYLM&list=PLREdURb87ks2qkD9svvlIwYwN35FZ3Afv&index=12

Otro ejemplo similar, pero en un entorno 3D y para la versión 5 lo podemos encontrar en:

https://unity3d.com/es/learn/tutorials/projects/roll-ball-tutorial/moving-camera

Aquí se ve que una alternativa sencilla para que la cámara siga al personaje es poner la cámara
como hijo del objeto (personaje o jugador, player) que queramos seguir. Esto funciona, en general,
pero podemos tener efectos indeseados. En el video se ve como si trasladamos la bola
(modificamos los valores “Position” del componente “Transformer” del objeto), esa alternativa
funciona. Sin embargo, si lo hacemos girar, la cámara gira solidaria al objeto (ya que es hijo de él)
volviendo el juego loco. La solución, como en el video anterior, es primero independizar la cámara,
y luego usar un script para que la cámara se mueva con el objeto; el script modifica los valores de
“Position” del componente “Transformer” de la cámara, no los de “Rotation”. El scritp es similar en
ambos videos.

3. Cámara de Primera Persona (First Person Camera): la cámara se mueve con el personaje, muestra
lo que el protagonista ve. La escena se mueve con respecto a ella. El ejemplo típico es el de tirador
(shooter) en primera persona.

En los videos anteriores se ha visto esta opción: una alternativa fácil es colocar la cámara como
objeto hijo del objeto que hace de jugador, moviéndola luego a la posición adecuada dentro del
jugador.
15. Ejercicio. Vamos a ver cómo al hacer la cámara objeto hijo de otro objeto, esa se mueve solidaria al
objeto. Aprendemos: practicamos un poco lo visto en el punto anterior. Duración: 0.5 – 1 hora. Video –
Ejemplo: “Unity_EjercicioCamara”

En un nuevo proyecto o en otro anterior hacer lo siguiente. Colocar en la escena una o varias esferas y un
cubo. El cubo será nuestro jugador, al que va a seguir la cámara. Colocar la cámara como objeto hijo del
objeto cubo. Mostrar la ventana juego, si no se tiene. Mover (tanto en 2D como en 3D) el objeto cubo y
ver como la cámara se mueve solidaria con él. Rotarle y ver como la cámara rota solidaria con el cubo,
también. En la ventana de juego parece que movemos la escena, mientras el cubo parece que permanece
quieto, sin embargo, eso no es cierto, es el “efecto óptico” de mover la cámara solidaria con el objeto y es
además lo que logra el efecto de animación que queremos en los juegos. Es interesante ver también como
si el objeto que no se mueve sale fuera del foco de la cámara (en 2D un cuadrado blanco que rodea a la
cámara), ese desaparece de la ventana de juego.

16.Ejercicio. Vamos a ver cómo realizar un cambio de escena, para, por ejemplo, hacer una portada del
juego. Duración: 1 – 2 horas.

Hasta ahora, solo hemos tratado con escena única. Una escena es un componente que contiene todos los
elementos que permiten desarrollar una parte del juego. Una forma de verlas es plantearlas como
“niveles” o “mundos” del juego. No es exactamente lo mismo, pero ayuda a entender el concepto.

Aquí vamos a ver cómo crear nuevas escenas y cómo cambiar entre ellas. Para ello vamos a usar el juego
“Space Debris” creado en el ejercicio 4 o, si no se ha logrado finalizar, se puede descargar en la página
web siguiendo el siguiente enlace: SpaceDebrisExported.unityPackage.

Lo primero, para una mejor organización, crear la carpeta “Scenes” dentro de los “Assets” (ver figura)

Ahora movemos (arrastrando con el ratón) la escena principal (“main”) a la carpeta creada (ver figura).
Antes de continuar ejecutar el juego para comprobar que todo sigue funcionando.

Vamos a crear la nueva escena, muy simple, que será la portada del juego. Lo primero es crearla vacía.
Para ello, tenemos dos opciones: i) botón derecho sobre “Scenes””Create””Scene” o ii) teniendo
abierta la carpeta “Scenes”, clic sobre “Create” de la ventana “Project”Scene. La llamamos, por
ejemplo, “Portada”. Abrirla en la ventana “Hierarchy” para crear la escena. Para no mezclar con la otra
escena (“Main”) y facilitar la edición de la nueva podemos: i) quitar la escena “Main” de la ventana
“Hierarchy, ii) poner el ratón justo a la izquierda del nombre de la escena, aparece el icono de un ojo, si
hacemos clic, la escena no se visualiza en la pantalla de edición.
Con la nueva escena, se crean dos componentes por defecto: la cámara y la fuente de luz. Para dar
sensación de espacio en la portada, vamos a editar la cámara y poner la opción “Clear Flags” a “Solid
Color” y “Background” a color negro (ver figura). En la figura también se muestran los valores de
posición, rotación y escala que debe tener.

Vamos a crear un prefab para la portada, para hacerla más atractiva. El prefab va a estar basado en los
meteoritos. Para crear este prefab, empezamos añadiendo a la escena “Portada” un objeto vacío
(“Create””Create Empty”); darle como nombre, por ejemplo, “AsteroidePortada”; sus valores de
posición y rotación deben ser todos cero y los de scale, todos uno.

Vamos a darle contenido al prefab. Empecemos por que sea un meteorito. Ir a la carpeta “Models” y
añadir, como hijo, al objeto que acabamos de crear “Asteroid”. Modificar en “rockLP001” (hijo de
Asteroid) “materials” por “Asteroid” (ir a carpeta “Materials” y arrastrarlo a “Element 0”. En la figura se
muestra cómo tiene que quedar en este punto nuestro prefab; también se muestran los valores de
posición, rotación y escala de “rockLP001”, que deben ser los mismos en “Asteroid”.

Ahora vamos a añadirle una imagen, con la palabra “play”, para darle el significado de comienzo del
juego a nuestro prefab. Como no tenemos una carpeta para “sprites” (imágenes simples), primero la
creamos para organizar mejor el contenido. Abrir la carpeta, clic con el botón derecho”Import new
Asset” e importar la imagen .png que se ha dejado en la web (play.png). Tenemos que convertirla en un
sprite, para poderla añadir y manipular en la escena. Para ello: a) Cambiar “Texture Type” a “Sprite (2D
and UI)”, b) clic sobre botón “Apply” (abajo a la derecha). Tiene que quedar como aparece en la figura.
Ya le podemos añadir al prefab. Arrastrarlo desde la ventana “Project” a la ventana “Hierarchy”, y
situarlo como componente hijo del prefab “AsteroidePortada”. Modificar su tamaño, para encajarle en
el dibujo del asteroide, poniendo todos los valores de X e Y de scale a 0.3 (es una figura 2D). En la figura
se muestra como queda (si no se ve así el objeto en la ventana de edición, hacer clic sobre los ejes de
visualización, hasta que aparezca como se ve; no afecta a como se verá con la cámara, pero ayuda a su
edición verlo correctamente).

Podemos ya guardar nuestro prefab, arrastrándolo a la carpeta “Prefabs” de la ventana “Project” o

esperar a hacerlo al siguiente paso, donde añadiremos el script. De igual manera, es conveniente salvar
la escena, por si acaso.

Ya solo nos queda añadir funcionalidad a nuestro prefab de portada, para que se realice el cambio de
escena. Clic sobre el prefab y añadirle un nuevo script (por ejemplo, haciendo clic en “Add Component”
de la ventana “Inspector”) (ver figura).

Editar el script y añadir el código que aparece a continuación. Analizar y entender el código. Para
poderlo manipular (se hace que aparezca desde abajo) se le tiene que añadir un RigidBody, Para
capturar eventos de ratón, hay que añadirle, también, un componente Collider. Esto lo podríamos haber
hecho mediante el editor gráfico, pero se ha preferido hacer, a modo de ejemplo, mediante script. Al
ejecutar el juego, el asteroide se mueve desde la parte de abajo, hasta llegar al centro de la pantalla.
Comprobar que esto funciona así.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class StartGame : MonoBehaviour

{
private Vector2 velocidad = new Vector2(0, 0.1f);
Rigidbody2D rb;
CircleCollider2D co;

/* Ejemplo de como añadir un componente mediante Script

* En vez de añadirlo mediante el editor
* Se deja como ejemplo */
/* La funcion Awake es llamada al inicializarse el objeto, antes
* de ser habilitado; es llamada antes de Start. Sirve para inicializar
* cosas de manera segura */
void Awake()
{
rb = gameObject.AddComponent<Rigidbody2D>() as Rigidbody2D;
rb.bodyType = RigidbodyType2D.Kinematic;
co = gameObject.AddComponent<CircleCollider2D>() as CircleCollider2D;
co.isTrigger = true;
}

// Start is called before the first frame update

void Start()
{
rb = GetComponent<Rigidbody2D>();
rb.position = new Vector2(0, -5);
}

// Update is called once per frame

void Update()
{
if (rb.position.y <= 0.0f)
{
rb.MovePosition(rb.position + velocidad);
}
}

void OnMouseDown()
{
// Debug.Log("llego");
SceneManager.LoadScene("Main");
}
}

Si las dos escenas no están en la ventana “Hierarchy”, al hacer clic sobre “Play” nos sale un mensaje de
error diciendo que la escena no se ha encontrado. También nos da la solución. Tenemos que añadir las
dos escenas a la configuración de construcción de nuestro juego, a “build settings”. Para ello, hacer clic
sobre el menú “File””Build Settings” (figura de la izquierda)  ”Add Open Scenes” (se supone que
ahora sí, tenemos que tener las dos escenas abiertas en la ventana “Hierarchy”, si no es así, hacerlo).
Ordenarlas, arrastrándolas con el ratón para ponerlas en el orden correcto (figura de la derecha). Con
 esto ya podremos probar sin la necesidad de tener las escenas cargadas en la ventana “Hierarchy” y,
además, ya tenemos definida la configuración para construir, si así queremos, nuestro juego.

17.Ejercicio – Introduciendo texto. Ejemplo: mostrar resultado. Duración: 1 – 2 horas

Vamos a añadir objetos de tipo texto a nuestro juego. Mediante estos podremos mostrar mensajes o
cualquier información adicional mediante texto que se necesite. Entre estas, puede estar la puntuación
que se va obteniendo; es lo que vamos a usar como ejemplo de cómo introducir este elemento en el
juego. Seguimos usando para ello el juego del ejercicio anterior.

Para agregar un objeto de tipo texto, hacer clic en “Create”->”UI”->”Text”. Vamos a hacerlo en nuestro
juego: arrastrar, si no se tiene ya, la escena “Main” a la ventana “Hierarchy” y añadir el objeto a esa
escena. Todo elemento de texto debe ser hijo de un objeto UI “Canvas”, para que se muestre
correctamente; al agregar un objeto de texto se añade automáticamente. También se añade un objeto de
tipo “EventSystem”. El estudio en profundidad de estos elementos cae fuera del alcance de la asignatura y
se deja para el alumno. Cambiar el nombre del elemento de texto y llamarle, por ejemplo, “Score Text”.
Tiene que aparecer algo similar a lo de la figura.

Vamos a configurar los distintos elementos. Empecemos por el “Canvas”, modificar las siguientes
características del componente “Canvas” (figura izquierda): i) Poner “Render mode” a valor “Screen Space
– Camera” (lo coloca relativo a la cámara), ii) Activar la opción “Pixel perfect” (lo ajusta al tamaño de la
cámara). De esta manera ajustamos su tamaño al de la cámara (figura derecha).
Vamos ahora a configurar el texto. Empecemos por modificar el color, como se ve en la figura anterior
derecha, casi no se ve. Ponerlo de color blanco, ya que el fondo va a ser oscuro, mediante la característica
“Color” del componente “Text (Script)” (ver figura). Aunque lo vamos a cambiar mediante script, modificar
el texto que aparece a, por ejemplo, “Score: “. Ajustar el tamaño, tipo fuente, etc., si se quiere.

Ahora vamos a cambiar su ubicación en el objeto “Canvas”, para ponerlo, por ejemplo, en la zona superior
izquierda. Hay dos alternativas:

a) Mover el objeto texto o modificar sus valores de X e Y hasta ubicarlo en la zona que deseemos. Por
ejemplo, al probar esta alternativa para el tutorial se fijaron los valores X: -400, Y: 250. El problema es
que estos valores son dependientes de resolución. Por eso, es recomendable usar la otra opción.

b) Modificar posición del anclaje (“anchor”) del objeto “Rect Transform” con respecto al objeto canvas.
Hacer clic sobre la imagen de anclaje del componente “Rect Transform”, y aparecen las
configuraciones predeterminadas de colocación. Elegir, por ejemplo, la pegada a la esquina superior
izquierda. Para que no quede totalmente pegado modificar los valores de posición X o Y o mover el
objeto en la escena (imágenes centra y derecha). Se puede modificar si se desea ancho y alto del texto

Ya podemos acceder al objeto y modificarle mediante Script, en este caso para que muestre la puntuación
obtenida. Para ello, editar el script “Game Manager” (es el script principal del juego y que está asociado al
objeto “GameManager”. El código final debe ser el siguiente, donde se marcan (asterisco rojo) las líneas a
introducir:
 using UnityEngine;
* using UnityEngine.UI; // para acceder a los elementos de tipo UI del juego
using System.Collections;
[RequireComponent (typeof(AudioSource))]
public class GameManager : MonoBehaviour {
public GameObject[] debris;
public float minTime;
public float maxtime;
public int totalItemsOnScreen;
public GameObject screenDebris;
private float randomTime;
private float curTime;
* private int meteoritosEnEscena;
* public Text textoScore; // Para acceder al objeto UI de tipo texto creado
* private int contador; // para llevar la puntuación
// Use this for initialization
/**
* Get a random time at which to spawn the first Debris
*/
void Start () {
randomTime = Random.Range (minTime, maxtime);
* meteoritosEnEscena = 0;
* contador = 0;
* setTextoContador();
}
// Update is called once per frame
/**
* Spawn Debris, when time interval is bigger than randomTime and there is less Debris
than totalItemsOnScreen.
* If there is more than one model in debris[], the game will use this to randomize how
the Debris looks.
*/
void Update () {
curTime += Time.deltaTime;
* if ((meteoritosEnEscena - screenDebris.transform.childCount) == -1) {
* contador = contador + 1;
* setTextoContador();
* }
meteoritosEnEscena = screenDebris.transform.childCount;
if (curTime > randomTime && screenDebris.transform.childCount < totalItemsOnScreen) {
Vector3 spawnPoint = screenDebris.transform.position;
int index = (int) Random.Range(0, debris.Length);
GameObject debrisItem = Instantiate(debris[index], spawnPoint, Quaternion.identity)
as GameObject;
Vector3 newPosition = debrisItem.transform.position;
debrisItem.transform.position = newPosition;
debrisItem.transform.parent = screenDebris.transform;
newPosition.z = 0;
curTime = 0;
}
}
* // Para actualizar el contador y el objeto texto
* void setTextoContador() {
* textoScore.text = "Score: " + contador.ToString();
* }
}
 Para acabar, hay que dar valor al campo de tipo “Text” llamado “textoScore” que acabamos de crear. Para
ello en Unity arrastrar el objeto “Score Text” creado (que es de tipo “Text”), al nuevo campo “textoScore”
del Script “Game Manager” que acabamos de modificar y que es un componente del objeto
“GameManager”. Ver figura.

Ya se puede probar y ver como se ha creado el objeto de texto, modificado con cada meteorito destruido.

Para esta parte se ha usado como referencia el video-tutorial “3. Displaying the Score and Text” de:
https://learn.unity.com/tutorial/collecting-scoring-and-building-the-
game?projectId=5c51479fedbc2a001fd5bb9f#5c7f8529edbc2a002053b78a

18.Tutorial – Ejercicio. Juntándolo todo.

Ya se tienen los conocimientos básicos para abordar la construcción de un juego básico con el que
continuar profundizando en Unity y aprender para nuestro proyecto.

El trabajo que se propone ahora es buscar y seguir algún tutorial básico (principiantes o intermedio) que
construya un juego mediante Unity. Se deja a la elección del alumno cuál elegir. Si se tiene claro el tipo de
juego que se quiere crear, es interesante buscar y seguir un tutorial que cree algo similar. Si no, al menos
tener claro qué tipo de cámara se va a usar y elegir un tutorial que la use.

Como ya se ha comentado, se recomienda, por simplicidad, empezar por 2D. Ahora bien, si se quiere se
puede abordar, sin problema, un proyecto 3D. En algunos tutoriales de los vistos ya hemos trabajado en
ese dominio. La principal complicación se va a encontrar en localizar y manejar assets en tres
dimensiones.

Para ayudar en la búsqueda de tutoriales, aquí van algunos enlaces que pueden servir de ayuda:

1. https://unity3d.com/es/learn/tutorials/s/2d-game-creation. Tutoriales de la página oficial de Unity

sobre 2D. Como en el resto, la mayoría son video-tutoriales de aprendizaje mediante la creación de
algún juego sencillo de distintos tipos. También se tienen tutoriales sobre aspectos concretos de
Unity que pueden ser útiles.
 2. https://unity3d.com/es/learn/tutorials. Enlace más general, también oficial de Unity, sobre
tutoriales basados en la creación de un proyecto. Aquí aparecen proyectos tanto 2D como 3D (la
mayoría de este tipo). También hay enlaces a tutoriales más específicos de distintos temas que
pueden ser interesantes.
3. https://www.youtube.com/channel/UCBhkLrsmV9PVQMpT3qe-toA. Canal de youtube con muchas
referencias a tutoriales tanto generales (creación de un juego) como de aspectos específicos de
Unity. Las referencias están agrupadas por niveles, lo que es muy útil. Muy interesante para
encontrar el tutorial que nos puede interesar. Algunos de los siguientes, aparecen en ese
repositorio.
4. https://www.youtube.com/watch?v=Y_PKWr_1rDw&list=PLiplYDjUMtti5bWJ1Ugystr-vUg8B5EuP.
Tutorial para principiantes, a partir de la creación de un juego plataformas. Es para la versión 5. Son
14 de videos de muy corta duración cada uno, unos 15 minutos. La animación se logra a partir de la
concatenación de varios sprites.
5. https://www.youtube.com/watch?v=mgtQe33XBjI. Tutorial para principiantes y muy paso a paso.
Crea un juego de plataformas. Versión Unity 4.3, pero hay material adicional con los cambios
necesarios para la versión 5 (cambio, sobre todo, algunos aspectos de la programación de scripts).
Son muchos videos, pero lo básico se encuentra en los 13 primeros. El resto, en este punto, se
pueden obviar de momentos. Duración aproximada: unas 4 horas de videos. La animación del
personaje, ya se vio en algún anterior, se hace mediante la animación de las piezas que lo
componen.
6. https://www.youtube.com/watch?v=sT5sBkkmuaQ. Video con un curso completo de casi 3 horas.
Tiene un curso gratuito en: https://www.udemy.com/unity-5-primer-videojuego-2d-
multiplataforma/. Juego de personaje que salta obstáculos. Es del mismo autor que el indicado en
el punto 3.
7. https://www.youtube.com/playlist?list=PLiplYDjUMtthTOwbzd-FPZiBHNhwbNu5e. Varios videos de
curso básico. Lo compara con otro entorno: Game Maker Studio. Empieza desde 0, es decir, desde
la instalación. Aquí no crea un juego. Lo que se hace es describir Unity en sus partes básicas de
manera similar a como lo hemos hecho en estos ejercicios, pero con un poco más de profundidad
en cada punto. Si no tienes claro el tipo de juego y te interesa profundizar en lo que hemos visto
hasta ahora, es una buena opción.
8. https://www.youtube.com/watch?v=s81hQDAtvBE. Juego RPG 2D estilo Zelda. Juego en el que el
personaje se mueve en todas las direcciones sobre un espacio 2D. No está acabado, de momento.
Hay 8 videos, con una duración de cerca de 2.5 horas en total. Es interesante para ver un ejemplo
de cómo crear este tipo de juegos.
9. https://www.youtube.com/playlist?list=PLiyfvmtjWC_X6e0EYLPczO9tNCkm2dzkm. Otro tutorial
paso a paso acerca de juegos tipo RPG en 2D. Muy completo (40 videos…). Cada video se centra en
una parte, por lo que es fácil elegir de entre ellos los que nos puedan interesar.
10.. . .

IMPORTANTE: el objetivo con estos tutoriales es profundizar en el aprendizaje de Unity, lo que quiere decir
que no hay que seguirles al pie de la letra, ni hacer todo lo que aparece. Nos interesa todo lo referente al
motor. Cuando abordemos nuestro proyecto Unity, seguramente no dé tiempo a hacer todo, por lo que lo
importante será realizar las partes principales de nuestra propuesta. Cosas accesorias como pantallas de
inicio o fin, efectos visuales extra o incluso la tabla de puntos, se deben dejar para el final. Obviamente se
valorará su realización, pero si no da tiempo, lo importante será tener, al menos, las funcionalidades
básicas de nuestro juego. Esto quiere decir, que en esos tutoriales esas partes las podemos obviar en este
punto del aprendizaje. Si las necesitamos, ya volveremos más adelante sobre ellas.