3) EJERCICIO Cámaras (Con solución al final)

¡Muy buenas!

Al llegar al final del apartado 3, ¡ya podéis hacer vuestros experimentos con cámaras! Y por ello os propongo un reto:

Tratar de realizar una cámara que siempre siga lateralmente al Pawn, como si fuera de una cámara Sidescroller pero con el Pawn pudiendo moverse libremente.

Para ello os dejo algunas anotaciones:

- Las variables locales en UnrealScript se colocan siempre justo debajo de un método o función. No podéis declararlas justo antes de dónde las necesitéis. Unreal es así de caprichoso... ¡Por cierto! Se declaran como otra variable pero en vez de poner var, se pone local ;)

- Podéis realizar "castings" de tipos en UDK, pero se realiza de manera inversa a como se realiza en C.
Se coloca la clase que queréis convertir primero y entre paréntesis a continuación, la clase a convertir. De este modo, os dejo una de las primeras pistas: Vector (Rotator).

Podéis coger la rotación del Pawn para ver dónde está mirando y convertirlo a un Vector con coordenadas de mundo para poder colocar la cámara dónde deseemos. Del mismo modo, podemos añadir a la rotación del Pawn un valor (offset en grados).

Os recuerdo que la clase Rotator tiene tres variables: Roll, Pitch y Yaw. Yaw es la variable que necesitáis para rotar "alrededor" de un objeto. Igualmente, las unidades de dicho valor están en Unreal Rotator, pero tranquilos, que existe una constante global por la que podéis multiplicar una variable que tenga esas unidades para pasarlas a grados y viceversa. Las constantes son: unrrottodeg y degtounrrot.

- Existe un método llamado Normal que recibe como parámetro un Vector y os lo "escupe" normalizado :D

¡A darle al coco y las mates!

------------------------------------------------------------------------------------------------------------

¿Ya lo tienes? ¿Seguro? No hagas trampas ehhhh

******************SOLUCIÓN*********************

Bueno, ahora si. En primer lugar, le decimos a NULLPlayerController.uc que queremos usar nuestra nueva cámara:

NULLPlayerController.uc

class NULLPlayerController extends PlayerController
    //Como vimos antes, hace referencia a un fichero de
    //configuración del que se podrá configurar variables
    //Bajo el apartado [NULLGame.NULLPlayerController]
    config(Game);
 
defaultproperties
{
CameraClass=class'NULLGame.NULLCameraSideScrollerFree'

}


Y ahora la clase nueva de cámara:

NULLCameraSideScrollerFree.uc

class NULLCameraSideScrollerFree extends Camera;
    /**
    * Query ViewTarget and outputs Point Of View.
    *
    * @param    OutVT        ViewTarget to use.
    * @param    DeltaTime    Delta Time since last camera update (in seconds).
    */
    function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
    {

local Vector pawnFacingVector;
local Rotator tempRotator;

    // Don’t update outgoing viewtarget during an interpolation
    if( PendingViewTarget.Target != None && OutVT == ViewTarget && BlendParams.bLockOutgoing )
    {
    return;
    }

//Cogemos la rotación de nuestro Pawn para darle un offset de 90 grados
tempRotator = OutVT.Target.Rotation;
//Le damos un offset en Yaw (alrededor del Pawn)
tempRotator.Yaw -= 90.0f*DegToUnrRot;

//Convertimos la rotación del Pawn (Target en nuestro caso) y la convertimos a coordenadas de mundo
pawnFacingVector = Vector(tempRotator);
pawnFacingVector = Normal(pawnFacingVector);

//Le damos la vuelta y lo alargamos una distancia que deseemos. Podemos usar una variable para ello
//(Mucho más correcto) que darle un valor a pelo
pawnFacingVector *= -250.0f;

//Ahora tenemos el vector que nos indica dónde debe colocarse la cámara
//Debemos añadir a dicha posición la posición de nuestro Pawn (Target)
OutVT.POV.Location = OutVT.Target.Location + pawnFacingVector;

//Ahora tenemos que mirar siempre hacia nuestro Pawn!!!
OutVT.POV.Rotation = Rotator(OutVt.Target.Location-OutVT.POV.Location);

    // Apply camera modifiers at the end (view shakes for example)
    ApplyCameraModifiers(DeltaTime, OutVT.POV);

    }

    DefaultProperties
    {
    }