Instituto de las Naciones Unidas

DAVID ALBERTO FALFÁN ESPINOZA 1

CONTENIDO
Introducción e instalación...................................................................................................................... 4

Interfaz de Unity 3D .............................................................................................................................. 5

Ventana del proyecto (Project) .......................................................................................................... 5

Barra de herramientas (Toolbar) ....................................................................................................... 5

Vista de escena (Scene View) ........................................................................................................... 6

Vista del juego (Game View) ............................................................................................................. 6

Ventana de jerarquía (Hierarchy)....................................................................................................... 6

Ventana de inspección (Inspector) .................................................................................................... 6

Conceptos básicos................................................................................................................................ 7

Escena............................................................................................................................................... 7

GameObjects ..................................................................................................................................... 7

Objetos primitivos .............................................................................................................................. 7

Configuración del juego ........................................................................................................................ 8

Activación/Desactivación de rejilla. .................................................................................................... 9

Cambiar tamaño objeto ..................................................................................................................... 9

Objeto jugador ................................................................................................................................... 9

Agregar color ..................................................................................................................................... 9

Variación de la dirección de luces ................................................................................................... 10

Movimiento del objeto jugador ............................................................................................................ 11

Componente de cuerpo rígido (RigidBody)...................................................................................... 11

Movimiento de la cámara .................................................................................................................... 15

Método mediante Child .................................................................................................................... 15

Método mediante Script ................................................................................................................... 15

Configuración del área de juego ......................................................................................................... 17

Limitar el área de juego ................................................................................................................ 17

DAVID ALBERTO FALFÁN ESPINOZA 2

 Objetos coleccionables (Pick Up Objects) .................................................................................... 18

Colisiones ..................................................................................................................................... 20

Despliegue de texto ............................................................................................................................ 24

Modificar fuente ............................................................................................................................... 28

Movimiento del enemigo ..................................................................................................................... 29

NavMesh Baking.............................................................................................................................. 29

Agente NavMesh ............................................................................................................................. 31

Escena de entrada .............................................................................................................................. 33

Asignación de imagen de fondo ...................................................................................................... 33

Opciones de juego ........................................................................................................................... 34

INSERCIÓN DE SONIDO ................................................................................................................... 36

Creación del juego como una aplicación independiente ..................................................................... 37

Ejercicios............................................................................................................................................. 39

DAVID ALBERTO FALFÁN ESPINOZA 3

INTRODUCCIÓN E INSTALACIÓN
Unity es un software enfocado al diseño de videojuegos para la mayoría de sistemas operativos, tales
como iOS, Android, Windows Phone, Xbox One.

Para instalar Unity basta con ingresar a la siguiente liga: https://unity3d.com/es/get-unity, puesto que
este manual está pensado para el diseño básico, se utilizará la edición personal, la cual es gratuita.

Usuario: [email protected]
Pass: dafeAV137…
El espacio en disco necesario para instalar los paquetes por defecto es de 9.5 GB, Figura 1.

Figura 1. Asistente de descarga de Unity

El proceso de instalación dura aproximadamente 2 horas, mientras tanto puede crear una cuenta en
Unity 3D mediante el siguiente enlace: https://accounts.unity3d.com/sign-up.

Para usar Unity 3D se debe ejecutar la primera vez como administrador, para configurar el perfil de
cuenta; en seguida puede crear un nuevo proyecto presionando el botón de New Project o el botón
New ubicado en la esquina superior derecha, Figura 2.

Figura 2. Botón para la creación de un nuevo proyecto

DAVID ALBERTO FALFÁN ESPINOZA 4

INTERFAZ DE UNITY 3D
La ventana principal del editor está compuesta por varios paneles tipo pestañas conocidos en Unity
como Vistas (Views). Hay varios tipos de vistas en Unity, todas tienen funciones específicas descritas
en esta sección.
Barra de título

Ventana o panel
de jerarquía

Barra de menú

Barra de herramientas

Ventana o panel
de inspección

Vista de escena

Ventana o panel
Vista de juego de proyecto

Figura 3. Interfaz de Unity 3D

Ventana del proyecto (Project)

Despliega todos los elementos disponibles en el proyecto actual, desde aquí se accede a los elementos
que pertenecen al proyecto. El panel izquierdo del navegador muestra la estructura de carpetas del
proyecto como una lista de jerarquía. Cuando una carpeta es seleccionada de una lista haciendo clic,
su contenido va a ser mostrado en el panel a la derecha. Usted puede hacer clic en el triángulo
pequeño para expandir o contraer la carpeta, mostrando cualquier carpeta anidada que contenga.

Barra de herramientas (Toolbar)

La Barra de Herramientas consiste en cinco controles básicos. Cada uno se relaciona con diferentes
partes del Editor.

DAVID ALBERTO FALFÁN ESPINOZA 5

 Herramientas de transformación (Transform9, utilizado con el SceneView

Palancas de Gizmo del Transform, afecta la visualización del SceneView.

Play/Pause/Step – utilizado con la vista del juego (GameView).

Vista de escena (Scene View)

Permite visualizar y editar la escena, dicha escena puede ser mostrada en una perspectiva de 2D y
3D, dependiendo del tipo de proyecto en el que está trabajando, a su vez se utiliza para seleccionar y
posicionar entornos, al jugador, la cámara, enemigos, y todos los demás GameObjects. Maniobrar y
manipular objetos dentro el SceneView son algunas de las más importantes funciones en Unity.

Vista del juego (Game View)

Es la representación de su juego ya finalizado. Necesitará utilizar una o más cámaras (Cameras) para
controlar lo que el jugador ve realmente cuando esté jugando su juego.

Ventana de jerarquía (Hierarchy)

Contiene cada GameObject de la escena actual, como hay objetos que están siendo agregados y
eliminados en la escena, estos van a aparecer y desaparecer de la jerarquía también. Por defecto los
GameObjects se mostrarán en la ventana Hierarchy en el orden en que se fabrican. Es posible
reordenar los GameObjects arrastrándolos arriba o abajo, o haciéndolos hijos o padres.

Ventana de inspección (Inspector)

Es usado para ver y editar propiedades de objeto y también preferencias y otros ajustes dentro de
Unity. Cuando selecciona un GameObject en Hierarchy o SceneView, la ventana Inspector muestra
las propiedades (Properties) de todos los componentes (Components) y materiales (Materials) en el
objeto, permitiendo editarlos. Para un componente Script, las variables públicas de ese script son
mostradas en la ventana Inspector. Esto le permite establecer parámetros y valores por defecto en sus
scripts fácilmente, sin modificar el código.

DAVID ALBERTO FALFÁN ESPINOZA 6

CONCEPTOS BÁSICOS
Escena
Las escenas contienen los objetos de su juego. Pueden ser usadas para crear un menú principal,
niveles individuales, y cualquier otra cosa. Piense en cada archivo de escena, como un nivel único. En
cada escena, usted va a colocar su ambiente, obstáculos, y decoraciones, el diseño esencial y la
construcción de su juego en pedazos.

GameObjects
Cada objeto en su juego es un GameObject. No obstante, los GameObjects no hacen nada por sí
mismos. Estos necesitan propiedades especiales antes de que puedan volverse un personaje, un
ambiente, o un efecto especial. Un GameObject siempre tiene el componente Transform adjunto (para
representar la posición y orientación). Los otros componentes que le dan al objeto su funcionalidad
pueden ser agregados en el menú Component del editor o desde un script.

Objetos primitivos
Unity puede trabajar con modelos 3D de cualquier forma, mientras sean creados con un software de
modelado. Sin embargo, hay un cierto número de tipos de objetos primitivos que pueden ser creados
directamente dentro de Unity, algunos de ellos son Cube, Sphere, Capsule, Cylinder, Plane and Quad.
Cualquiera de las primitivas puede agregarse a la escena desde el menú GameObject  3D Object.

DAVID ALBERTO FALFÁN ESPINOZA 7

CONFIGURACIÓN DEL JUEGO
Para aprender a usar Unity realizaremos un juego sencillo en 3D. Para ello, se crea el proyecto y se
elige proyecto 3D, una vez creado, lo primero es salvar la escena, para ello nos dirigimos a Archivo
(File)  Guardar Escena (SaveScene), en seguida se desplegará una ventana donde estará la
ubicación del archivo, dentro de la carpeta Assets, creamos una nueva carpeta con el nombre _Scenes
y finalmente guardamos nuestra escena en esa carpeta, el nombre del archivo será MiniJuego.

Ahora se crea el tablero o campo de juego, para ello nos dirigimos a la pestaña GameObject3D
ObjectPlane o desde el panel de Jerarquía (Hierarchy), Figura 4.

Figura 4. Creación de plano

En el panel de jerarquía aparecerán varios elementos entre ellos, Plane, lo renombramos y le

asignamos el nombre de Superficie.

Reseteamos el elemento presionando el engrane en la esquina superior derecha del panel

correspondiente a Transform, Figura 5, tras presionar el engrane seleccionamos la opción Reset, esto
con la finalidad de asegurar que el elemento se encuentra en el origen.

Figura 5. Opción Reset

DAVID ALBERTO FALFÁN ESPINOZA 8

El plano estará ubicado en las coordenadas (0,0,0) de la escena, este punto es conocido como punto
origen, desde dicho punto son calculadas todas las coordenadas de la escena. Ahora seleccionamos
el plano desde el panel Escena (Scene) y presionamos la tecla F para ver el elemento completamente.

Activación/Desactivación de rejilla.
En el panel de Escena, desplegamos el menú Gizmos y activamos o desactivamos la casilla “Show
Grid”, Figura 6.

Figura 6. Rejilla del elemento

Cambiar tamaño objeto

Para cambiar el tamaño o escala de un objeto 3D, seleccionamos dicho objeto, nos dirigimos a la
ventana Inspector en la sección Transform en las opciones de escala (Scale), asignando el tamaño
directamente en X, Y, Z. La unidad de medida predeterminada de Unity es 1 metro.

Objeto jugador
Para ejemplificar esta parte usaremos una esfera, la cual controlará el jugador; de igual manera que
como se creó el plano, creamos la esfera (Sphere), la renombramos como Jugador y la reseteamos
para asegurar que este ubicada en el origen. Seleccionamos la esfera y presionamos la tecla F, para
enfocar dicho elemento. La esfera parece estar enterrada en el plano, esto es debido a que se
encuentra ubicado en el origen al igual que el plano. Inicialmente todos los objetos primitivos tienen
unidades 1 a 1 o 1 a 2, la esfera es 1 a 1, es decir, tiene un diámetro de 1 metro. Puesto que del origen
de la esfera a cualquier superficie de la ella hay 0.5 unidades, basta con mover en Y esa misma
cantidad de unidades.

Agregar color
Para agregar textura o color debemos usar un Material, primero, creamos una nueva carpeta en la
ventana proyecto presionando el botón Create  New Folder, le asignamos el nombre Materiales, con
dicha carpeta seleccionada presionamos nuevamente la pestaña Create ubicada en la ventana del

DAVID ALBERTO FALFÁN ESPINOZA 9

proyecto, y seleccionamos Material; ahora, en el panel Inspector, nos dirigimos a Main maps, y
modificamos la primera propiedad Albedo.

Figura 7. Selección del color

Para aplicar el material o color a algún elemento, basta con seleccionar el material desde la ventana
proyecto y arrastrarlo hasta el elemento al cual se le desea asignar el color.

Variación de la dirección de luces

En el panel Hierarchy, seleccionamos Directional Light, ahora nos dirigimos al panel Inspector, en el
área Transform podemos variar tanto la rotación como la posición, en el área Light, se puede
seleccionar el color de la luz, así como la intensidad.

Figura 8. Configuración de luces direccionales

DAVID ALBERTO FALFÁN ESPINOZA 10

MOVIMIENTO DEL OBJETO JUGADOR
Primeramente, debemos determinar el comportamiento del elemento a mover, en este caso se desea
que la esfera ruede sobre la superficie del área de juego, rebote en las paredes, permanezca en la
superficie y no se separe de ella, para ello necesitamos física, para usarla necesitamos un componente
de cuerpo rígido asociado al elemento con las propiedades de movimiento.

Componente de cuerpo rígido (RigidBody)

Para ejemplificar esta parte usaremos la esfera. Seleccionamos el objeto a cual le asignaremos el
componente, nos dirigimos a la pestaña Component, nos ubicamos en la opción Physics y
seleccionamos RigidBody, o nos dirigimos al panel Inspector, y presionamos el botón Add Component
 Physics  RigidBody.

Para verificar que el componente de cuerpo rígido fue añadido correctamente selecciónalos la esfera,
y en la ventana Inspector deberá aparecer la sección RigidBody.

Figura 9. Componente de cuerpo rígido

Ahora necesitamos que el usuario tenga el control del elemento, para ello necesitamos obtener las
señales de entrada, las cuales provendrán del teclado. Para realizar dicha tarea haremos uso de un
script utilizando el lenguaje C#.

DAVID ALBERTO FALFÁN ESPINOZA 11

Para crear el script y asociarlo al elemento, seleccionamos dicho elemento, nos dirigimos al panel
Inspector y presionamos el botón Add Component  NewScript = ”NombreDelScript”, Figura 10,
debemos asegurarnos que este seleccionado el lenguaje C#. Para este ejemplo podemos nombrar al
Script como “ControlJugador”, finalmente seleccionamos el botón Aceptar y asociar.

Figura 10. Crear nuevo script

Para editar dicho script nos dirigimos al panel correspondiente al script del objeto y presionamos el
botón con un engrane, finalmente seleccionamos Edit Script, Figura 11.

Figura 11. Editar script

Otra forma es presionando doble clic sobre el script que se desea editar desde la ventana proyecto.

DAVID ALBERTO FALFÁN ESPINOZA 12

En seguida se desplegará el IDE (Entorno de Desarrollo Integrado) para editar el script; eliminamos el
código contenido en la clase, de tal forma que quede algo similar a las siguientes líneas de código.
using UnityEngine;
using System.Collections;
public class ControlJugador : MonoBehaviour {

}
Ahora, ¿Qué es lo que necesitamos hacer? Primero debemos checar cada cuadro o fotograma (frame)
para una instrucción dada y aplicar esa instrucción al elemento seleccionado.

Utilizaremos varios métodos, entre ellos están:

 Start. Es el método que se invoca al iniciar el juego, justo en el primer frame.

 Update. Es un método invocado antes de renderizar un cuadro, es decir, se carga en cada uno
de los frames del juego. En él se colocará la mayoría del código asociado al juego.
 FixedUpdate. Es el método invocado justo antes de realizar un cálculo físico, es decir, funciona
igual que el método Update pero carga únicamente los comportamientos físicos. En él se
colocará el código asociado a la física.

Para mover la esfera se debe aplicar una fuerza al cuerpo rígido. Usaremos la clase Input, para indicar
un movimiento sobre algún eje. Declaramos dos variables locales de tipo flotante los cuales contendrán
la coordenada asociada al objeto con respecto a cada eje. Entonces, agregamos las siguientes líneas
de código en el método correspondiente a la física.
float movimientoHorizontal = Input.GetAxis ("Horizontal");
float movimientoVertical = Input.GetAxis("Vertical");

Ahora crearemos el vector que representara el movimiento en tres dimensiones, para ello, utilizamos
la siguiente línea de código.
Vector3 movimiento = new Vector3(movimientoHorizontal, 0.0f, movimientoVertical);

Recordando sus clases de física, los vectores representan fuerza, entonces necesitamos indicar por
medio de alguna instrucción la fuerza aplicada por dicho vector el cual representará el movimiento del
objeto. Para ello declaramos la siguiente variable global.
private Rigidbody rb;

DAVID ALBERTO FALFÁN ESPINOZA 13

Creamos el método Start() e instanciamos el objeto de tipo cuerpo rígido, de la siguiente manera.
void Start() {
rb = GetComponent<Rigidbody>();
}

Finalmente usamos dicha variable para obtener el movimiento, mediante la siguiente línea de código,
la cual debe ser añadida en el método de los cálculos físicos.
rb.AddForce(movimiento);

Ahora podemos añadir movimiento a nuestra esfera, sin embargo, al hacerlo notaremos que la
velocidad del movimiento no es la adecuada. Para ello tendríamos que regresar a editar el código y
multiplicar el movimiento por algún número, esto lleva tiempo, entonces, crearemos variables públicas,
a las cuales tendremos acceso desde el panel Inspector de Unity. Agregamos una variable global de
tipo flotante llamada velocidad.
public float velocidad;

Finalmente modificamos la línea de código encargada del movimiento, dicha línea queda de la
siguiente manera.
rb.AddForce(movimiento * velocidad);

Su código debe ser similar al siguiente:

using UnityEngine;
using System.Collections;
public class ControlJugador : MonoBehaviour {
private Rigidbody rb;
public float velocidad;
void Start() {
rb = GetComponent<Rigidbody>();
}
void FixedUpdate() {
float movimientoHorizontal = Input.GetAxis ("Horizontal");
float movimientoVertical = Input.GetAxis("Vertical");
Vector3 movimiento = new Vector3(movimientoHorizontal, 0.0f,
movimientoVertical);
rb.AddForce(movimiento * velocidad);
}
}

DAVID ALBERTO FALFÁN ESPINOZA 14

MOVIMIENTO DE LA CÁMARA
La vista en tercera persona se caracteriza por ver al personaje que se controla completamente, dicha
vista tiene una perspectiva detrás del jugador.

Para colocar la cámara en tercera persona, existen dos métodos, convertir a la cámara en un hijo del
elemento que tendrá el movimiento o con un Script, para fines didácticos utilizaremos el método
mediante script, sin embargo, mencionaremos ambos.

Método mediante Child

En el panel Hierarchy, seleccione a la cámara principal (Main Camera), en seguida añada los
siguientes parámetros desde la ventana Inspector  Transform:

Parámetro X Y Z
Position 0 9.5 .10
Rotation 45 0 0
Scale 1 1 1

Ahora arrastramos el objeto Main Camera al objeto que representa la esfera para convertirlo en un hijo
(Child) de ella, de esta manera la cámara estará asociada al objeto esfera, sin embargo, al mover la
esfera, la cámara rotará junto con el movimiento de la esfera.

Método mediante Script

Elegimos el elemento MainCamera y en la ventana Inspector presionamos el botón Add Component
para agregar un nuevo script, al cual nombraremos “ControlDeCamara”.

En seguida, en la ventana del proyecto aparecerá el nuevo script, lo arrastramos a la carpeta de scripts
y lo abrimos.

El script debe incluir dos elementos; un objeto para hacer referencia al jugador, en este caso, a la
esfera, para lo cual añadiremos un objeto de tipo GameObject…
public GameObject jugador;
…y un vector de tres dimensiones para el desfase (offset) de la cámara.
private Vector3 offset;

DAVID ALBERTO FALFÁN ESPINOZA 15

Este último valor debe ser privado puesto que solo se podrá ajustar desde el script. Para el valor del
offset usaremos el valor actual que tiene la posición de la cámara, y restaremos la posición que tiene
el jugador, esto para encontrar la diferencia entre ambos.

Dicha posición debe estar inicializada al iniciar el juego, por lo tanto colocaremos lo siguiente en el
método Start().
offset = transform.position - jugador.transform.position;

Ahora, por cada frame la cámara deberá moverse a una nueva posición, alineado al objeto jugador,
para ello colocaremos la siguiente línea de código dentro del método Update().
transform.position = jugador.transform.position + offset;

Solo resta cambiar el nombre del método Update por LateUpdate, este último método se invoca
después de que el método Update haya concluido.

El script correspondiente al control de la cámara debe ser similar al siguiente.

using UnityEngine;
using System.Collections;

public class ControlDeCamara : MonoBehaviour {

public GameObject jugador;
private Vector3 offset;
void Start () {
offset = transform.position - jugador.transform.position;
}

void LateUpdate () {
transform.position = jugador.transform.position + offset;
}
}

DAVID ALBERTO FALFÁN ESPINOZA 16

CONFIGURACIÓN DEL ÁREA DE JUEGO
Añadiremos paredes en las orillas del campo de juego para que no caiga, a su vez, crearemos un
conjunto de objetos que el jugador tendrá que recolectar.
Limitar el área de juego

Primero crearemos un GameObject vacío, para ello nos dirigimos al menú GameObject  Create
Empty. Una vez creado le asignaremos el nombre Pared, dicho elemento será un elemento Padre de
los siguientes elementos correspondientes a cada una de las paredes, dichas paredes serán objetos
de tipo Cubo (Cube), al primer elemento lo renombramos como ParedOeste; cada elemento podrá
tener de alto 2 unidades, ancho 0.5 unidades y largo 20.5 unidades, finalmente asignamos el nuevo
elemento al elemento Pared, para ello, basta con arrastrarlo hasta dicho elemento.

Solo resta crear las paredes faltantes, para ello duplicamos el objeto ParedOeste, para ello
presionamos Ctrl + D o desde la pestaña Edit  Duplicate. Lo mismo para la pared del norte y sur,
todas las paredes deberán estar contenidas en el elemento Padre llamado Pared, Figura 12.

Figura 12. Elementos hijos

La interfaz de juego ahora debe ser similar a la mostrada en la Figura 13.

Figura 13. Interfaz de juego limitada

DAVID ALBERTO FALFÁN ESPINOZA 17

Objetos coleccionables (Pick Up Objects)

Objetos coleccionables se refiere a aquellos elementos que un jugador puede recolectar a lo largo del
juego. Primero creamos un objeto Pick Up el cual será un objeto de tipo cubo, lo colocamos sobre el
tablero de la misma forma que la esfera y lo hacemos más pequeño, dicho elemento debe atraer la
atención del usuario, para ello, le daremos movimiento, esto lo realizaremos por medio de un script,
se lo añadimos por medio del botón Add Component y le asignamos el nombre de Rotación. En dicho
script añadimos la siguiente línea de código dentro del método Update:
transform.Rotate(new Vector3(15, 30, 45));

Hasta este punto, si ejecutamos el juego el objeto rotara muy rápido, para corregir este error, debemos
multiplicar el vector por un retardo de tiempo, entonces la línea queda de la siguiente manera.
transform.Rotate(new Vector3(15, 30, 45) *Time.deltaTime);

El código correspondiente a la rotación del elemento PickUp debe lucir similar al siguiente:
using UnityEngine;
using System.Collections;

public class Rotacion : MonoBehaviour {

void Update () {
transform.Rotate(new Vector3(15, 30, 45) *Time.deltaTime);
}
}

Ahora crearemos un templete llamado Prefab el cual almacenará características que serán
compartidas por otros objetos. Primero, dentro del proyecto creamos una carpeta llamada Prefabs, en
seguida arrastramos el objeto Pick Up a dicha carpeta.

Figura 14. Carpeta Prefab

DAVID ALBERTO FALFÁN ESPINOZA 18

Ahora de la misma manera que usamos un objeto vacío para almacenar el conjunto de paredes,
también haremos un elemento vacío llamado PickUp para almacenar todos los objetos coleccionables,
duplicamos el objeto coleccionable para obtener ocho de ellos y los convertimos en Hijos del elemento
vacío PickUp, Figura 15.

Figura 15. Elementos PickUp ordenados

Ahora distribuimos los objetos PickUp en la superficie, para ubicar cada objeto lo podemos hacer de
la siguiente manera, primero presionamos el cono correspondiente al eje superior en Y, para que la
vista cambie a la mostrada en la Figura 16.

Figura 16. Vista superior

DAVID ALBERTO FALFÁN ESPINOZA 19

Ahora debemos cambiar al modo global (Global mode), de esta manera podremos mover nuestro
objeto de tal manera que se mantenga alineado con respecto a la superficie, para ello nos dirigimos a
la barra de herramientas y presionamos el botón Local, al presionarlo dicho botón deberá cambiar a
Global, Figura 17.

Figura 17. Modo global

Solo resta arrastrar cada elemento duplicado y distribuirlos en la superficie.

Para asignarle color a todos los objetos PickUp primero creamos el material con el color deseado,
ordenamos el material en su respectiva carpeta; en seguida arrastramos el material y se lo asignamos
al elemento almacenado en la carpeta Prefab.
Colisiones

Una colisión se da cuando dos o más objetos chocan o impactan. Para ser capaces de “recolectar” un
objeto, debemos detectar la colisión entre el objeto jugador y el objeto PickUp y asignar algún
comportamiento.

Debemos seleccionar el script asociado al jugador (el cual será el objeto encargado de recolectar a los
objetos PickUp), en este caso dicho script es ControlJugador, lo editamos y añadimos el método
OnTriggerEnter.
void OnTriggerEnter(Collider otro) {
}

Dicho método es invocado en el momento que ocurre una colisión.

Podemos añadir la siguiente línea de código para eliminar un objeto cuando ocurra la colisión
Destroy(otro.gameObject);

Con esa línea de código, cuando toquemos un elemento este será destruido, al destruir un elemento
todo lo asociado a él será eliminado de la escena.

DAVID ALBERTO FALFÁN ESPINOZA 20

Para este juego en vez de destruir el objeto simplemente lo desactivaremos, es decir, dejara de ser
visible en la escena. Para ello haremos uso de lo siguiente:

 tag. La etiqueta se encarga de identificar un objeto al compararlo con una cadena.

 SetActive. Método encargado de activar o desactivar un objeto por medio del código.
 CompareTag. Método que permite comparar la etiqueta (tag) de cualquier objeto con un valor
de cadena.

Para comparar etiquetas usaremos la siguiente línea de código.

if (otro.gameObject.CompareTag("NombreDelObjeto"))

Ahora, para desactivar el objeto utilizamos la siguiente línea de código.

otro.gameObject.SetActive(false);

Entonces, el método que debemos añadir es el siguiente:

void OnTriggerEnter(Collider otro) {
if(otro.gameObject.CompareTag("PickUp"))
otro.gameObject.SetActive(false);
}

Hasta este punto, el código correspondiente al control del jugador debe ser similar al siguiente.
using UnityEngine;
using System.Collections;

public class ControlJugador : MonoBehaviour {

private Rigidbody rb;
public float velocidad;
void Start() {
rb = GetComponent<Rigidbody>();
}

void FixedUpdate() {
float movimientoHorizontal = Input.GetAxis ("Horizontal");
float movimientoVertical = Input.GetAxis("Vertical");
Vector3 movimiento = new Vector3(movimientoHorizontal, 0.0f, movimientoVertical);
rb.AddForce(movimiento * velocidad);
}

void OnTriggerEnter(Collider otro) {

DAVID ALBERTO FALFÁN ESPINOZA 21

 if(otro.gameObject.CompareTag("PickUp"))
otro.gameObject.SetActive(false);
}
}
Ahora, debemos declarar las etiquetas en el panel de etiquetas y capas (Layers) antes de usarlas,
entonces asignaremos el valor de la etiqueta para los objetos PickUp.

En el panel de proyecto, seleccionamos el elemento prefab para los objetos PickUp, Figura 18.

Figura 18. Elemento asociado a los objetos PickUp

En el panel Inspector desplegamos las opciones de Tag y seleccionamos Add Tag, Figura 19.

Figura 19. Agregar etiqueta

DAVID ALBERTO FALFÁN ESPINOZA 22

Esto nos llevará al panel de etiquetas y capas. Para añadir una nueva etiqueta personalizada
presionamos el botón +. Añadimos el nombre tal y como está en nuestro código, respetando
mayúsculas y minúsculas, Figura 20.

Figura 20. Etiqueta correspondiente al elemento PickUp

Seleccionamos nuevamente el elemento Prefab y notaremos que la opción correspondiente a la

etiqueta continua sin valor de etiqueta, puesto que ya añadimos la etiqueta PickUp al panel de
etiquetas aparecerá como una opción al desplegar nuevamente las opciones de etiqueta, Figura 21,
la seleccionamos.

Figura 21. Nueva etiqueta añadida

Solo resta indicarle al elemento Prefab que debe disparar un evento cuando ocurra una colisión, para
ello activamos la casilla is Trigger, Figura 22.

Figura 22. Disparo colisiones

DAVID ALBERTO FALFÁN ESPINOZA 23

DESPLIEGUE DE TEXTO
En esta sección aprenderemos a utilizar un contador, el cual será desplegado en un cuadro de texto,
también se añadirá un mensaje indicando que el juego ha terminado.

Necesitamos una herramienta para almacenar el valor de los elementos que se van recolectando, y
otra herramienta para agregar y acumular los elementos coleccionables, dichas herramientas serán
agregadas en el script asociado al control del jugador. Entonces editamos el código y agregamos una
variable privada de tipo entero, la cual llevará la cuenta.
private int cuenta;

Cada vez que el juego inicie la variable de conteo deberá iniciar en cero, dicha inicialización la
realizamos dentro del método Start.
cuenta = 0;

Ahora, necesitamos incrementar en una unidad la variable de conteo cada vez que un objeto sea
recolectado, inmediatamente después de desactivar un objeto PickUp debido a una colisión, debemos
contar dicho objeto, entonces, añadimos la siguiente línea debajo de la instrucción que desactiva
objetos.

Ahora debemos añadir un texto que nos indique cuantos elementos han sido recolectados, para
desplegar texto utilizaremos el conjunto de herramientas de interfaz de usuario (UI Toolset) para
desplegar texto y valores.

Primero creamos un nuevo elemento de texto desde Hierarchy  Create  UI  Text, Figura 23.

Figura 23. Elemento de texto

DAVID ALBERTO FALFÁN ESPINOZA 24

Renombramos el elemento de texto por TextoCuenta. En la vista Game, podemos ver el texto que ha
sido añadido, para personalizarlo lo seleccionamos desde la ventana Hierarchy y nos dirigimos la
ventana Inspector, Figura 24, por medio de ella podemos modificar el color de la letra, la fuente, darle
formato de negritas y cursiva, centrarlo, editar el texto, entre otras opciones.

Figura 24. Edición de texto

Para mover el texto debemos dirigirnos a la sección Rect Transform, y presionar el botón
correspondiente al anclaje del texto, Figura 25, antes de seleccionar cualquiera de las opciones de
ubicación del texto, debemos mantener presionado la tecla Alt y Shift, y posteriormente seleccionar
cualquiera de las opciones.

Figura 25. Anclaje de texto

DAVID ALBERTO FALFÁN ESPINOZA 25

Ahora vamos a asociar el texto con la variable de conteo del script, para ello, abrimos nuevamente el
script correspondiente al control del jugador y añadimos el espacio de nombres correspondiente a la
interfaz de usuario (UI), esto con la finalidad de que el IDE reconozca los elementos asociados a dicha
UI, para añadir el espacio de nombres usaremos la siguiente línea de código.
using UnityEngine.UI;

Ahora creamos una variable pública de tipo texto, la nombramos textoConteo, dicha variable
mantendrá una referencia al componente de texto en Unity.
public Text textoConteo;

Ahora asignaremos el valor inicial de dicho elemento de texto, para ello escribimos la siguiente línea
en el método Start.
textoConteo.text = "Cuenta: " + cuenta.ToString();

Pero, también necesitamos que el elemento de texto se actualice por cada elemento recolectado, para
ello añadimos la misma línea en el método asociado a las colisiones.

Opcionalmente podemos crear una función que contenga la cuenta actualizada y sustituir las
instrucciones anteriores por la invocación del texto. Dicha función puede ser la siguiente.
void MensajeConteo() {
textoConteo.text = "Cuenta: " + cuenta.ToString();
}

Guardamos los cambios y regresamos a la interfaz de Unity, solo falta asociar el elemento referencia
a la variable pública, Figura 26.

Figura 26. Asociación del objeto texto con script

DAVID ALBERTO FALFÁN ESPINOZA 26

Ahora, añadiremos otro texto, el cual indicará que todos los objetos han sido recolectados, para ello,
agregamos el nuevo texto desde la ventana Hierarchy, lo renombramos como TextoGana, lo
personalizamos y regresamos al script de control de jugador. Agregamos una variable pública para
este texto y la nombramos como textoGana,
public Text textoGana;

Inicializamos el valor del texto como vacío, para ello, basta con abrir y cerrar comillas dobles, es decir,
dejar el texto sin contenido.
textoGana.text = "";

Ahora agregamos una condición, para cuando todos los elementos hayan sido recolectados, el límite
de la condición dependerá del número de objetos coleccionables colocados en la superficie del juego.
La condición deberá ser agregada en la función que despliega el texto de conteo o, en el método de
colisión, dicha condición debe ser la siguiente.
if(cuenta >= 8) {
textoGana.text = "¡Ganaste!";
}
Regresamos a la interfaz de Unity y asociamos el nuevo texto a la variable del script. Al iniciar el juego
y recolectar todos los objetos, en la vista juego deberá aparecer un mensaje indicando que ha ganado,
Figura 27.

Figura 27. Juego con mensaje final

DAVID ALBERTO FALFÁN ESPINOZA 27

Modificar fuente
Para ello debemos importar un tipo de fuente, los formatos aceptados son: TrueTypeFonts (.ttf),
OpenTypeFonts (.otf). Una vez obtenida la fuente, debemos colocarla en la carpeta del proyecto
(Assets), para ello debemos ubicar dicha carpeta o simplemente arrastrarla a la ventana del proyecto
en Unity, para mantener el orden podemos crear a su vez una carpeta llamada fuentes y en ella incluir
dicha fuente, Figura 28.

Figura 28. Añadir fuente al proyecto

Para asignar la fuente seleccionamos el texto al cual se le desea cambiar el tipo de fuente y en la
ventana Inspector nos dirigimos a la sección Text (Script) y modificamos la opción Font y
seleccionamos la nueva fuente.

Figura 29. Modificación de fuente

En esa misma sección podemos modificar el tamaño, color, estilo, etcétera.

DAVID ALBERTO FALFÁN ESPINOZA 28

MOVIMIENTO DEL ENEMIGO
Se recomienda que antes de iniciar esta parte realice el Ejercicio 1, ubicado en la página 39.

NavMesh Baking
Para que un enemigo pueda determinar el área en el cual se va a mover, debemos indicárselo por
medio del sistema de navegación de Unity. Para ello utilizaremos un “NavMesh” y realizaremos un
bake. Para activar la ventana de navegación nos dirigimos a Window  Navigation.

La ventana de navegación está compuesta de tres pestañas, Object, Mesh Renderers y Terrains.
Antes de realizar el bake debemos indicar a Unity que objetos son de navegación estática, es decir,
cuales son los objetos que no se moverán y puede ser utilizados para calcular las áreas caminables
(Walkable), generalmente pisos, paredes y obstáculos. Para ello, seleccionamos los objetos que serán
estáticos, y nos dirigimos a Navigation  Object y activamos la casilla Navigation Static, Figura 30.

Figura 30. Selección de objetos estáticos

Otra forma de indicar que un objeto es de navegación estática es, seleccionando el objeto y en la
ventana Inspector, desplegar el menú Static y seleccionar Navigation Static.

Figura 31. Menú Static

DAVID ALBERTO FALFÁN ESPINOZA 29

Ahora, en la ventana Navigation nos dirigimos a la pestaña bake, en ella podemos modificar las
siguientes opciones:

 Radius. Determina la distancia existente entre un objeto y una pared u obstáculo.

 Max Slope. Indica que tan inclinada puede estar una pendiente antes de ser considerada una
pared.
 Step Height. Indica que tan alto puede ser un paso individual o “escalón”, para que no bloquee
al personaje.
 Advanced, Min Region Area. Indica que el área mínima que puede tener un objeto para que
éste sea reconocido por NavMesh.

Una vez configurada las opciones como lo muestra la Figura 32 debemos presionar el botón Bake
ubicado en la esquina inferior derecha de la ventana Navigation.

Figura 32. Configuración de Bake

DAVID ALBERTO FALFÁN ESPINOZA 30

Notaremos como las superficies de los elementos seleccionamos como navegación estática cambiaran
de color, Figura 33.

Figura 33. NavMesh aplicado a los objetos

Agente NavMesh
Una vez creado el NavMesh Bake, podemos ubicar los objetos que representarán al enemigo. Para
ello crearemos cuatro esferas y las agruparemos en un objeto vacío llamado Enemigos en la ventana
Hierarchy, Figura 34.

Figura 34. Ubicación de enemigos

DAVID ALBERTO FALFÁN ESPINOZA 31

Ahora creamos un script para controlar a los enemigos, el cual nombraremos ControlEnemigo, el script
será el siguiente.
public Transform objetivo;
NavMeshAgent agente;
void Start () {
agente = GetComponent<NavMeshAgent>();
}
void Update () {
agente.SetDestination(objetivo.position);
}

Dicho script deberá estar asociado a cada uno de los enemigos existentes; el script mostrado
anteriormente incluye una variable pública llamada objetivo, a dicha variable se le asignará el elemento
al cual los enemigos se dirigirán, en este caso arrastramos el objeto Jugador y lo asignamos a dicha
variable.

Ahora seleccionamos uno de los objetos enemigo y le asignamos un NavMesh Agent, mediante
Inspector  Add component  Navigation  NavMesh Agent. Mediante dicha sección podemos
configurar algunos parámetros útiles:

 Radius. Representa el radio del agente, usado para detectar colisiones entre obstáculos y otros
agentes.
 Speed. Máxima velocidad de movimiento.
 Acceleration. Máxima aceleración.

NOTA. Recuerde asignar las etiquetas (tag) y activar la casilla Is Trigger del enemigo.

DAVID ALBERTO FALFÁN ESPINOZA 32

ESCENA DE ENTRADA
Contiene una imagen referente al juego y un menú de opciones, en este caso el menú de inicio de
juego y fin de juego. Para crearlo, añadiremos una nueva escena y en ella crearemos un plano.

Asignación de imagen de fondo

Ubicamos la imagen que deseamos añadir y la arrastramos hasta la carpeta Materiales, contenida en
la ventana Project. Asignamos al plano el material que contiene la imagen y manipulamos la cámara
(Main Camera) y las luces direccionales (Directional Light) para obtener una imagen similar a la
mostrada en la Figura 35.

Figura 35. Portada del juego

DAVID ALBERTO FALFÁN ESPINOZA 33

Opciones de juego
Para que exista interacción entre la escenas debemos añadirlas en File  Build Settings  Add Open
Scenes.

Para seleccionar las opciones primero creamos dos objetos de tipo texto las personalizamos y la
distribuimos en el plano, Figura 36.

Figura 36. Texto añadido a la portada

Ahora, añadimos un objeto vacío al cual nombraremos Textos, a su vez creamos un script al cual
nombraremos OpcionesJuego, dicho script deberá contener las siguientes funciones.
public void IniciarJuego() {
SceneManager.LoadScene("Minijuego1");
}
public void TerminarJuego() {
SceneManager.UnloadScene(0);
}
Ahora, añadiremos al objeto Textos el script OpcionesJuego.

Figura 37. Funciones asignado a textos

Ahora seleccionamos el texto para iniciar el juego y agregamos un componente de tipo Event Trigger
(Script), mediante Add Component  Event  Event Trigger.

DAVID ALBERTO FALFÁN ESPINOZA 34

En seguida presionamos el botón Add New Event Type y seleccionamos Pointer Down el cual es un
evento que se activa al momento de presionar clic del ratón, Figura 38.

Figura 38. Evento de clic del ratón

Ahora añadimos un script en dicha sección, arrastramos el objeto Textos y lo colocamos en donde se
solicita el objeto y posteriormente añadimos la función para iniciar el juego.

Figura 39. Añadir función al texto

Lo mismo para el texto de salida.

DAVID ALBERTO FALFÁN ESPINOZA 35

INSERCIÓN DE SONIDO
Los formatos de audio permitidos son: aif, wav, mp3 y ogg, al archivo de audio importado a Unity lo
llamaremos Audio Clip.

Un Audio Source se encarga de reproducir el Audio Clip en la escena. Para crear un nuevo Audio
Source haremos lo siguiente.

1. Importar archivo de audio. Para ello basta con arrastrar el archivo a la ventana de proyecto.
2. En la ventana Hierarchy, creamos un objeto vacío (Create Empty).
3. Renombramos el objeto vacío a Audio.
4. Seleccionando el objeto vacío Audio, agregamos un Audio Source. Para ello nos dirigimos a
Inspector  Add Component  Audio  Audio Source.
5. Asignamos el Audio Clip al Audio Source, Figura 40, arrastrándolo hasta Inspector  Audio
Source  AudioClip.

Figura 40. Añadir sonido a una escena

También podemos iniciar un sonido al desencadenarse un evento de colisión, para ello, agregamos

DAVID ALBERTO FALFÁN ESPINOZA 36

CREACIÓN DEL JUEGO COMO UNA APLICACIÓN INDEPENDIENTE
Una vez concluido el juego, se debe presentar a los jugadores, una de las características más
importantes de Unity es que podemos desplegar un juego en múltiples plataformas.

Antes de crear el juego debemos guardar la escena. Ahora nos dirigimos a File  Build Settings o
presionando la combinación de teclas Ctrl + Shift + B, esto nos llevara a la ventana mostrada en la
Figura 41.

Figura 41. Ventana para crear una aplicación independiente

Dicha ventana muestra la plataforma a la cual estará dirigida el juego, a su vez en el costado derecho
se muestran algunas opciones asociadas a la plataforma seleccionada. En caso de tener varias
escenas en el juego, estas deberán ser colocadas en el panel superior (Scenes In Build), si omitimos
este paso, Unity solo seleccionara la escena actual.

Tras haber seleccionado la plataforma, así como la arquitectura y el sistema operativo, presionamos
el botón Build, esto nos llevará a una ventana en la cual seleccionaremos la ubicación, opcionalmente

DAVID ALBERTO FALFÁN ESPINOZA 37

podemos crear una carpeta llamada Builds y guardar ahí el ejecutable, al nombrarlo debemos incluir
el nombre del sistema operativo con el cual será compatible nuestra aplicación.

Figura 42. Ventana de ubicación de ejecutable

Presionamos el botón guardar, y seleccionamos el archivo ejecutable del juego y presionamos doble
clic sobre él, presionamos el botón Play en la ventana que aparecerá, Figura 43, y el juego estará listo.

Figura 43. Ventana de juego

DAVID ALBERTO FALFÁN ESPINOZA 38

EJERCICIOS

Añada más obstáculos para que su interfaz sea similar a la mostrada en la Figura 44.

Figura 44. Tablero con múltiples obstáculos

DAVID ALBERTO FALFÁN ESPINOZA 39

Añada cuatro enemigos como se muestra en la Figura 45, varíe a cada enemigo los parámetros de
velocidad y aceleración.

Figura 45. Tablero con cuatro enemigos

Añada objetos pickUp como se muestra en la Figura 46.

Figura 46. Ochenta objetos PickUp añadidos

DAVID ALBERTO FALFÁN ESPINOZA 40