Trabajando con la Cámara en Unity.

Las cámaras, exagerando un poco, lo son todo en Unity. Representan como el usuario va a ver el juego. Un juego puede ser en primera persona, en tercera, puede tener una cámara fija o realizar un travelling a través del escenario, o como va a ser en nuestro caso, ir siguiendo al protagonista. Esto lo hacemos por que nuestro escenario es grande, y si lo enseñamos todo no apreciaríamos al protagonista. Así que vamos a seguirlo y mostraremos una parte del escenario.

Este post forma parte del Tutorial de desarrollo de juegos en Unity. En los post anteriores hemos creado el escenario y al protagonista. Si lo prefieres en lugar de seguir el tutorial puedes bajarte el trabajo realizado hasta ahora y empezar a trabajar con la Camara de nuestro Arcade: megafastball-protagonista.

Situando la cámara.

Si seleccionamos nuestro objeto FastBall, podemos ver que tiene tres flechas, que representan a tres ejes: X, Y, y Z. Para un juego en el que la cámara perseguirá al protagonista, lo mejor se situar a la cámara detras de los ejes Z y X. Con la inclinación que consideremos correcta y a una distancia que se pueda ver una parte del mundo, pero que nuestro protagonista continue manteniendo un tamaño decente.

Se aprecia como queda el juego visto desde la cámara.
Por ahora esta nos parece una buena vista para la cámara.

Podemos trabajar en la ventana #Scene situando la vista como queremos, para ello solo tenemos que pulsar la tecla Alt y mover como queramos el escenario con el ratón. Para alejarnos o acercarnos podemos usar la rueda central, del ratón, la que se suele usar para subir y bajar la barra de desplazamiento vertical.

En la imagen podéis ver que se ha intentado conseguir una buena relación entre tamaño del protagonista y cantidad del mundo mostrado. En este primer intento podemos acertar, o no, siempre podemos ajustarlo una vez hayamos jugado un par de veces al juego.

Cuando consigamos una posición que nos parece idónea, seleccionamos el objeto Main Camera en la sección Hierarchy y nos vamos al menú Game Object -> Align with View.

Alineamos la cámara con la vista que hemos escogido.
Alineamos la cámara con la vista que hemos escogido.

Con esto tendremos la cámara justo en posicionada de tal forma que el usuario verá nuestra misma vista.

Este es el resultado, vemos un par de problemas, quizá la vista es un poco baja, podríamos subir la cámara, pero el problema principal es que perdemos a la bola cuando esta sale de la cámara. Esto tenemos que evitarlo! Vamos a usar un script standard.

La cámara sigue a nuestra bola

Para ello vamos a utilizar un script que nos viene con lo sAssets standard de Unity y que ya hemos importado: smoothFollow. Lo encontramos en Standard Assets->Utility.

Podemos encontrar smoothFollow en la sección Project
El script standard smoothFollow.

Vamos al Inspector de la camara, para ello solo tenemos que seleccionarla y nos aparecerá en el lado derecho de nuestro IDE. Arrastramos el script dentro del inspector, o lo incorporamos con el botón add Component.

Configuración de SmootfFollow en cámara
El script SmoothFollow en nuestra cámara

Un a vez arrastrado el Script le indicamos cual va ser el Target, el elemento a seguir,  en este caso queremos que sea nuestra bola: FastBall. En el vídeo anterior no me ha acabado de convencer el resultado, así que voy a inclinar un poco la cámara y darle un ángulo diferente. Veamos como queda:

En este segundo vídeo las cosas han mejorado bastante! La cámara sigue a nuestra bola y el mundo se ve un poco mejor. Igualmente siempre podremos rectificar cuando pongamos los premiso y los enemigos. Por ahora lo dejamos aquí. Bueno, no, le damos un vistazo al script que realiza el seguimiento.

Analizando el script SmoothFollow

Le damos doble click sobre el nombre del script y se nos abrirá MonoDevelop, el edito de scripts de Unity.

namespace UnityStandardAssets.Utility
{
public class SmoothFollow : MonoBehaviour
{
// The target we are following
[SerializeField]
private Transform target;
// The distance in the x-z plane to the target
[SerializeField]
private float distance = 10.0f;
// the height we want the camera to be above the target
[SerializeField]
private float height = 5.0f;
[SerializeField]
private float rotationDamping;
[SerializeField]
private float heightDamping;
// Use this for initialization
void Start() { }
// Update is called once per frame
void LateUpdate()
{
// Early out if we don't have a target
if (!target)
return;
// Calculate the current rotation angles
var wantedRotationAngle = target.eulerAngles.y;
var wantedHeight = target.position.y + height;
var currentRotationAngle = transform.eulerAngles.y;
var currentHeight = transform.position.y;
// Damp the rotation around the y-axis
currentRotationAngle = Mathf.LerpAngle(currentRotationAngle, wantedRotationAngle, rotationDamping * Time.deltaTime);
// Damp the height
currentHeight = Mathf.Lerp(currentHeight, wantedHeight, heightDamping * Time.deltaTime);
// Convert the angle into a rotation
var currentRotation = Quaternion.Euler(0, currentRotationAngle, 0);
// Set the position of the camera on the x-z plane to:
// distance meters behind the target
transform.position = target.position;
transform.position -= currentRotation * Vector3.forward * distance;
// Set the height of the camera
transform.position = new Vector3(transform.position.x ,currentHeight , transform.position.z);
// Always look at the target
transform.LookAt(target);
}
}
}

En la función LastUpdate lo primero que hace es ver si le hemos asignado un Target. En caso de no tener ningún Target no hace nada, con el comando Return devuelve el control a quien le haya llamado, en este caso el motor de Unity. En cambió si dispone de un target recupera su posición y la utiliza para calcular la nueva posición de la cámara.

Next: Creando los tesoros y los enemigos.

Podéis obtener el proyecto de Unity, tal como ha quedado después de configurar la cámara en este enlace: megafastball-concamara.

Comentarios.