Práctica 2 - RollABall
Unity – Práctica 2. RollABall
En la siguiente práctica vamos a crear un nuevo proyecto que va a imitar uno existente en
la Asset Store de Unity y con él vamos a aprender conceptos y añadir funcionalidad…
Crearemos un nuevo proyecto 3D.
Creación del terreno de juego
Una vez tengamos creado el proyecto vamos a crear un plano que colocaremos en la
posición (0, 0, 0) de nuestra escena:
Además, cambiaremos su escala (2, 1, 2) para que sea más grande y le daremos un
material del color que nos apetezca:
Página 1
Práctica 2 - RollABall
Creación Muros
Vamos a continuación a crear unos muros que “rodeen” nuestro terreno. Lo haremos de
manera similar a como lo hacíamos en el tema a partir de un elemento Cubo:
Player
Vamos a crear el jugador. Nuestro jugador será una bola (3D->Sphere) que de momento
estará en el centro de la escena (la subiremos medio metro), y tendrá un RigidBody, así
como un Sphere Collider.
Le vamos a crear un Script para mover al jugador. Recordar crear la carpeta de Scripts en
el Proyecto.
Este será el contenido del Script:
public class Player : MonoBehaviour
{
// Variables públicas para la velocidad y los textos
public float speed;
// Rigidbody del objeto y la cuenta de pick-ups recogidos
private Rigidbody rb;
// Comienzo del juego..
void Start()
{
// Recogemos el RigidBody del objeto
rb = GetComponent<Rigidbody>();
Página 2
Práctica 2 - RollABall
// Los movimientos físicos se hacen el FixedUpdate, con intervalos
// fijos. No se pueden hacer en el Update.
// El intervalo es 0.02 segundos definido en Edit->Project Settings->
Time
void FixedUpdate()
{
// Recogemos el valor de las flechas
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
// Creamos un Vector3 X será el horizontal y Z el vertica
Vector3 movement = new Vector3(moveHorizontal, 0.0f,
moveVertical);
// Aplicamos una fuerza teniendo en cuenta los ejes y la velocidad
rb.AddForce(movement * speed);
}
}
Es importante que pongamos velocidad en el editor al jugador en su script:
Si ejecutamos el juego, vemos que podemos mover al jugador utilizando fuerzas físicas.
Pero este movimiento no se ve demasiado bien.
Cámara
Vamos a cambiar en primer lugar la posición de la cámara para que podamos ver “desde
arriba”:
Además, le vamos a añadir un script a la cámara, para que “siga” al jugador:
public class CameraController : MonoBehaviour
{
// El objeto al que sigue la cámara. Se asigna en el editor de Unity
public GameObject player;
// Vector que guardará la distancia entre la cámara y el objeto que
sigue
private Vector3 offset;
Página 3
Práctica 2 - RollABall
void Start()
{
// Obtenemos al principio del juego la distancia entre
// la cámara y el objeto que sigue.
offset = transform.position - player.transform.position;
}
// Se ejecuta después de hacer los Update y FixedUpdate. Ya tendríamos
// los movimientos calculados del resto de elementos
void LateUpdate()
{
// Hacemos que la posición de la cámara sea la posición
// del jugador más la distancia calculada al principio.
transform.position = player.transform.position + offset;
}
No hacemos como en el tema en el que hacíamos que la cámara fuera “hija” del jugador,
ya que así evitamos que la cámara rote junto con el mismo…
En el editor podríamos cambiar el objeto al que sigue la cámara:
Si por ejemplo hiciéramos que “siguiera” a una pared, lógicamente no se moverá…
Pick Ups (elementos a recoger).
Vamos a crear a continuación una serie de elementos, que nuestro jugador recogerá.
Tendremos 12 elementos. Yo os recomiendo que creéis uno, le deis características y a
continuación creemos un prefab, para crear el resto de elementos cambiando únicamente
su posición.
El elemento inicial que tendremos será un cubo, que vamos a rotar, darle un material, un
rigidbody (será Kinematic para que no le afecte la gravedad) y un box collider (que será
de tipo IsTrigger):
Página 4
Práctica 2 - RollABall
Tendrá asignado un Script Rotator que hará que gire automáticamente:
public class Rotator : MonoBehaviour
{
public Vector3 giro = new Vector3(15, 30, 45);
// Before rendering each frame..
void Update()
{
transform.Rotate(giro * Time.deltaTime);
}
}
Una vez que tengamos todo dispuesto crearemos el prefab y a partir del mismo crearemos
los 12 elementos situados como las horas de un reloj:
Página 5
Práctica 2 - RollABall
Textos UI
Vamos a añadir a nuestra escena dos textos, uno para contar los pick ups recogidos (lo
implementaremos más adelante) que estará arriba a la izquierda y otro para dar un
mensaje de victoria al ganar, centrado en la escena.
Recogida de los Pick Ups.
Vamos a implementar en el script del jugador la recogida de los Pick Ups. Tener en cuenta
que deberemos etiquetar a los mismos para que el funcionamiento sea correcto, además
de asignar en el editor los textos correspondientes que hemos creado en el apartado
anterior.
public class Player : MonoBehaviour
{
// Variables públicas para la velocidad y los textos
public float speed;
public Text countText;
public Text winText;
// Rigidbody del objeto y la cuenta de pick-ups recogidos
private Rigidbody rb;
private int count;
// Comienzo del juego..
void Start()
{
// Recogemos el RigidBody del objeto
rb = GetComponent<Rigidbody>();
// Cero pick-ups recogidos
count = 0;
// Llamamos a la función que se encarga de los textos(abajo)
SetCountText();
// En blanco el texto de ganador…
winText.text = "";
}
// Los movimientos físicos se hacen el FixedUpdate, con intervalos
// fijos. No se pueden hacer en el Update.
// El intervalo es 0.02 segundos definido en Edit->Project Settings->
Time
Página 6
Práctica 2 - RollABall
void FixedUpdate()
{
// Recogemos el valor de las flechas
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
// Creamos un Vector3 X será el horizontal y Z el vertica
Vector3 movement = new Vector3(moveHorizontal, 0.0f,
moveVertical);
// Aplicamos una fuerza teniendo en cuenta los ejes y la velocidad
rb.AddForce(movement * speed);
}
// Controlamos las colisiones con otros objetos
void OnTriggerEnter(Collider other)
{
// Con la etiqueta Pick Up
if (other.gameObject.CompareTag("Pick Up"))
{
// Lo desactiva haciéndolo desaparecer
other.gameObject.SetActive(false);
// Contamos uno más
count = count + 1;
SetCountText();
}
}
// Función que se encarga de los textos…
void SetCountText()
{
// Actualiza el texto contador
countText.text = "Count: " + count.ToString();
// Si hemos recogido 12 pick-ups ganamos
if (count >= 12)
{
// Set the text value of our 'winText'
winText.text = "You Win!";
}
}
}
Hasta aquí es el juego original de RollAPlayer. Vamos a ampliar posibles cosas a hacer
y aprovechamos para aprender más conceptos.
Página 7
Práctica 2 - RollABall
Material Player.
Lo primero que podemos hacer es cambiar crear un material para la bola Player. Incluso
podemos ponerle una textura.
Creamos en primer lugar el material:
Y podemos darle un color que nos apetezca o incluso meterle una textura.
Este es un campo muy extenso. Yo, por ejemplo, le he puesto una textura parecida a la
bola de Pixar. Para ello he creado una carpeta Textures, en ella he importado un jpg con
esa textura y luego lo he arrastrado al Albedo del material…
Página 8
Práctica 2 - RollABall
En esta página web podéis encontrar texturas gratuitas:
https://www.poliigon.com/textures/free
Rebote mediante material físico.
Vamos a crear un material físico que va a hacer que la bola “rebote”.
Para ello en la carpeta Materials pulsamos el botón derecho Create->Physic Material:
Página 9
Práctica 2 - RollABall
Le podemos llamar Rebote. El material tiene los siguientes parámetros:
Tenemos la fricción dinámica (cuando el objeto se mueve) y la fricción estática (cuando
está parado). Pensad en cuando movemos un mueble, la diferencia al empujarlo parado o
cuando ya lo tenemos en movimiento…
Bounciness hace referencia al Rebote…
Y las combinaciones hace referencia a qué pasa cuando hacemos fricción o rebote con
otro objeto con material físico…
Vamos a poner un 1 en Bounciness. A continuación, debemos asignar el material físico
al Player, bien arrastrándolo directamente sobre él, o bien en su Sphere Collider, dentro
la propiedad Material…
Si probamos ahora y lanzamos la bola contra las paredes veremos que tiene un cierto
rebote…
Si queremos hacer que este rebote sea más grande podemos poner el material físico
también a las paredes. Puede ser una buena prueba de lo que ocurre ponérselo de
momento únicamente a dos de las paredes.
Modificación del color del jugador.
Vamos a cambiar el color del jugador aleatoriamente cuando choque con las paredes. Para
ello, en primer lugar, le vamos a poner de nuevo un material sin textura y con color
blanco como teníamos al principio. Podemos crear un nuevo material y asignárselo…
A continuación, vamos a asignarle una nueva etiqueta a las paredes, para poder después
detectar en el código si el choque se ha producido con una pared. Esto ya sabemos
hacerlo…
Ahora nos vamos al script del Player. Vamos a crear al igual que antes un miembro de
tipo Renderer para poder acceder después al color del material. En el Start lo
inicializamos:
private Renderer r;
// At the start of the game..
Página 10
Práctica 2 - RollABall
void Start ()
{
// Assign the Rigidbody component to our private rb variable
rb = GetComponent<Rigidbody>();
r = GetComponent<Renderer>();
A continuación, debemos detectar la colisión con las paredes. Aquí es importante
entender que va a funcionar de manera distinta a lo que ocurre con los Pick-Ups, ya que
las paredes no tienen el Is Trigger activado (si lo tuvieran las atravesaríamos).
Por ello no vamos a utilizar el OnTriggerEnter sino el evento OnCollisionEnter:
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.CompareTag("Pared"))
{
r.material.color = new Color(Random.value, Random.value,
Random.value);
}
}
Random.value devuelve una valor float aleatorio entre 0 y 1.
Si queremos que se muestren solo colores entre los 16 principales podemos redondear
para que solo tome valores 0 ó 1:
r.material.color = new Color(Mathf.Round(Random.value),
Mathf.Round(Random.value),
Mathf.Round(Random.value));
Añadiendo Salto a nuestro Player
Por último, vamos a añadirle al script de nuestro Player la posibilidad de saltar cuando se
pulse el botón de salto (normalmente asignado a la barra espaciadora).
En primer lugar, añadimos una variable pública para indicar la fuerza del salto:
public float fuerzaDeSalto = 5;
La fuerza de salto se aplica en el Update ya que es una fuerza de impulso no una fuerza
gradual como ocurre al mover al jugador (cosa que hacemos en el FixedUpdate).
private void Update()
{
if (Input.GetButtonDown("Jump"))
{
rb.AddForce(Vector3.up * fuerzaDeSalto, ForceMode.Impulse);
}
}
Lo que estamos haciendo es, cuando se pulse la barra espaciadora, añadirle una fuerza
en el eje Y (Vector3.up) y esta fuerza es de tipo impulso. Podemos cambiar en el editor
la fuerza de salto.
Página 11
Práctica 2 - RollABall
También puede ser interesante en el material físico comprobar la diferencia entre los
distintos Bounce combine.
Vamos también a arreglar un pequeño problema. Si os fijáis al ejecutar el programa,
podemos “saltar en el aire”. Una posible forma de evitar esto (en el siguiente tema
veremos otra) es comprobar si la bola está parada verticalmente con su velocidad Y:
private void Update()
{
if (Input.GetButtonDown("Jump") && Mathf.Abs(rb.velocity.y) < 0.1f)
{
rb.AddForce(Vector3.up * fuerzaDeSalto, ForceMode.Impulse);
}
}
Escalar las paredes
También vamos a escalar las paredes en su eje Y para que queden más altas:
Lo haremos con todos los muros. El muro sur podemos desactivarle el Renderer para
que nos permita ver el juego:
Página 12
Práctica 2 - RollABall
Página 13
Práctica 2 - RollABall
Entrega de la Práctica
Para la entrega de la práctica se pide que hagáis las modificaciones que se han ido
incorporando a lo largo de la misma.
También realizaremos las siguientes modificaciones:
• Reducir el tamaño del Player cada vez que colisionamos con las paredes Norte y Sur
y aumentarlo al chocar con las paredes Este Oeste. Podemos poner un límite inferior
y superior en este tamaño.
• Reducir la altura de una pared cada vez que colisionemos con ella.
• Reproducir sonido al recoger un Pick Up.
• Hacer que los Pick-Ups gire cada uno de manera diferente aleatoriamente (el giro se
mantendrá igual durante toda la ejecución).
• Hacer que cambie el color de los Pick-Ups aleatoriamente cada cierto tiempo.
• Activar un sistema de partículas (tipo explosión) al chocar con la pared o al recoger
un pick-up (que sean distintos).
• Si el Player cae al vacío lo devolvemos a la posición inicial. Si cae tres veces
perderemos la partida.
• Se valorarán ideas propias desarrolladas, así como la jugabilidad y aspecto del juego.
Implementando las ideas desarrolladas hasta aquí se podrá conseguir hasta un 7,5 de nota.
Para los dos puntos y medio restantes hasta el 10 se puede implementar una nueva escena
a la que pasaremos al recoger todos los Pick-Ups.
En esta escena implementaremos un laberinto de manera similar a lo desarrollado en el
Tema 3. Tendremos 3 vidas y mostraremos al final un mensaje de victoria o derrota.
Para la entrega de la práctica hacedlo comprimiendo la carpeta entera eliminando
primero las subcarpetas Library, Build y Temp.
Además, entregad un vídeo (lo podéis subir a One Drive o Youtube) demostrando la
ejecución del juego.
Entregad un pdf con aquellos detalles de implementación que consideréis interesantes (no
expliquéis aquellas cosas que se han visto en el tema o se han desarrollado paso a paso
en el enunciado de la práctica.).
Importante realizar comentarios en el código tanto poniendo el nombre del autor como
explicando las distintas opciones implementadas.
Página 14
