En esta tercera entrega, vamos a ver como mover el personaje por el escenario, así como hacer que la cámara lo siga, y que ninguno de los dos se salga del escenario.
Para que la cámara siga el personaje, debemos cambiar el enfoque en nuestro código.Cuando se pulse una tecla, se desplazará el personaje, y después situaremos la cámara dónde esté el personaje.
Organizando el código (Refactoring)
Cómo el código empieza a ser cada vez más grande, y con el objetivo de hacerlo más legible, antes de continuar vamos a hacer algunos cambios en el código.
En la parte privada de TViewMain declara las siguientes funciones para mover el personaje:
|
1 2 3 4 5 6 |
function MoveLeft: boolean; function MoveRight: boolean; function MoveDown: boolean; function Jump: boolean; function PlayerOnGround: boolean; function FireWeapon: boolean; |
Tras declararlas, si pulsas shift+c sobre cada una de ellas, el IDE Lazarus, creará el código correspondiente. Cada una de estas funciones se ocupará de realizar una acción sobre el personaje. En cada una de ellas, se evaluará si se ha pulsado la tecla correspondiente a la acción, en tal caso devolverá TRUE, sino devolverá FALSE. Además cuando la tecla es pulsada, se realizarán ciertas operaciones sobre el personaje.
Veamos el código de las funciones que se encargan de mover el personaje hacia la derecha y la izquierda.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
//Personaje hacia la izquierda function TViewMain.MoveLeft: boolean; begin Result := False; if Container.Pressed[keyArrowLeft] then begin if Arthur.Rotation.W = 0 then begin Arthur.Rotation := Vector4(0, 1, 0, Deg(180)); end; Result := True; end; end; //Personaje hacia la derecha function TViewMain.MoveRight: boolean; begin Result := False; if Container.Pressed[keyArrowRight] then begin if Arthur.Rotation.W <> 0 then begin Arthur.Rotation := Vector4(0, 1, 0, 0); end; Result := True; end; end; |
En estas funciones, en el caso que se pulse la tecla correspondiente, aparte de retornar TRUE, se comprobará si el personaje se le ha aplicado alguna rotación. Por defecto el personaje, tal como creamos el sprite, está mirando a la izquierda.
Observa que su ángulo de rotación “Angle(W)” es cero, esto indica que el sprite del personaje “está tal cual”. Ya además no se aplica sobre ningún eje (aunque se aplicara, al ser el ángulo igual a cero no se produciría ninguna rotación).
Si, cambiamos el valor del ángulo a 180 grados, e indicamos que la rotación sea sobre el eje Y, cambiando su valor de cero a uno, el personaje rotará 180 grados sobre su eje Y.
Es operación que hemos hecho sobre las propiedades del personaje, es lo que se realiza por código en estas funciones.
Ten en cuenta que los ángulos, en CGE, son en radianes. Por eso se usa la función Deg para convertir un valor en grados a radianes. Esta función está la unidad CastleUtils, por lo cual debemos añadirla para poder usarla.
Así que justo al empezar la implementación añade esta unidad a la clausula uses.
La función PlayerOnGround, devuelve el estado de la variable OnGround. Define esta variable en la parte privada de TViewMain.
|
1 2 3 4 |
function TViewMain.PlayerOnGround: boolean; begin Result := OnGround; end; |
Las funciones restantes, simplemente devolverán si la tecla correspondiente ha sido pulsada.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
function TViewMain.MoveDown: boolean; begin Result := False; if Container.Pressed[keyDown] then begin Result := True; end; end; function TViewMain.Jump: boolean; begin Result := False; if Container.Pressed[keyCtrl] then begin Result := True; end; end; function TViewMain.PlayerOnGround: boolean; begin Result := OnGround; end; function TViewMain.FireWeapon: boolean; begin Result := False; if Container.Pressed[keySpace] then begin Result := True; end; end; |
La variable OnGround, indicará si el personaje está sobre el suelo o no. Necesitamos saber dónde está para activar o desactivar ciertas acciones. Su estado dependerá si el personaje colisiona con el suelo, o deja de colisionar con este. Así que definiremos dos eventos para el suelo, OnCollisionEnter, y OnColisionExit, esto lo haremos evento Start.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
procedure TViewMain.Start; begin inherited; {$IFDEF FPC} Suelo1.RigidBody.OnCollisionEnter:=@Suelo1CollisionEnter; Suelo1.RigidBody.OnCollisionExit:=@Suelo1CollisionExit; {$ELSE} Suelo1.RigidBody.OnCollisionEnter := Suelo1CollisionEnter; Suelo1.RigidBody.OnCollisionExit := Suelo1CollisionExit; {$ENDIF} OnGround := True; end; |
Para definir automáticamente los procedimientos asignados a cada evento, puedes pulsar CLTR+C, sobre cada uno de ellos, para que se genere la código correspondiste.
Recuerda que debes definir en la sección Published de TmainView, los elementos que usemos en el código.
|
1 2 3 4 5 6 7 |
published { Components designed using CGE editor. These fields will be automatically initialized at Start. } LabelFps: TCastleLabel; Navigation2D1: TCastle2DNavigation; Arthur: TCastleScene; Suelo1: TCastleBox; |
Cuando entre en colisión algún objeto con el suelo, se ejecutará Suelo1CollisionEnter, así que dentro de este evento, comprobaremos si el objeto que ha colisionado es nuestro personaje, en tal caso pondremos la variable OnGround a TRUE.
|
1 2 3 4 5 |
procedure TViewMain.Suelo1CollisionEnter( const CollisionDetails: TPhysicsCollisionDetails); begin OnGround := CollisionDetails.OtherTransform.Name = Arthur.Name; end; |
De la misma manera, cuando un objeto deje de colisionar con el suelo, se ejecutará Suelo1CollisionExit, si el objeto que sale de la colisión es el personaje, pondremos la variable OnGround a False.
|
1 2 3 4 5 |
procedure TViewMain.Suelo1CollisionExit( const CollisionDetails: TPhysicsCollisionDetails); begin OnGround := not (CollisionDetails.OtherTransform.Name = Arthur.Name); end; |
Reescribir el evento Update
El objetivo de los cambios que vamos a realizar es simplificar el evento Update.
Lo primero que hacemos en guardar en una variable la velocidad actual del personaje.
|
1 |
vel := Arthur.RigidBody.LinearVelocity; |
Luego comprobar si se ha pulsado si el personaje debe ir a la izquierda o la derecha, y si está en el suelo. De esta manera si el personaje no estuviera en el suelo, no se le aplicaría ninguna velocidad en el X, ya que queremos que se desplaza solamente cuando esté en el suelo.
|
1 2 3 4 5 6 7 8 |
if MoveRight and PlayerOnGround then begin vel.x := 1500 * SecondsPassed; end; if MoveLeft and PlayerOnGround then begin vel.X := -1500 * SecondsPassed; end; |
Lo siguiente, es comprobar si se ha pulsado la tecla saltar( jump), y si está en el suelo, se aplica una velocidad en eje Y, que es el eje vertical.
|
1 2 3 4 |
if Jump and PlayerOnGround then begin vel.y := 1500 * SecondsPassed; end; |
Por último comprobamos que sino se ha pulsado ninguna tecla , y el personaje está en el suelo, ajustamos la velocidad del eje X a cero.
|
1 2 3 4 |
if (MoveLeft = False) and (MoveRight = False) and (PlayerOnGround = True) then begin vel.x := 0; end; |
Para terminar, aplicamos la velocidad al personaje.
|
1 |
Arthur.RigidBody.LinearVelocity := Vel; |
Ahora debemos actualizar la animación del personaje, en función de su velocidad y si está en el suelo o no.
|
1 2 3 4 5 6 7 8 9 |
if (Arthur.RigidBody.LinearVelocity.X = 0) or (not PlayerOnGround) then begin Arthur.StopAnimation(); end else begin if Arthur.CurrentAnimation = nil then Arthur.PlayAnimation('walk', True); end; |
Por último, guardamos en la variable llamada PosicionCamara, un vector que contiene en el eje X la posición del personaje, y en la coordenada Y, la posición de la cámara. Y eso será posición de la cámara.
|
1 2 |
PosicionCamara := Vector2(Arthur.TranslationXY.X, Navigation2D1.Camera.TranslationXY.Y); Navigation2D1.Camera.TranslationXY := PosicionCamara; |
Si probamos el juego ahora, veremos que, tanto,el jugador como la cámara se salen del escenario. Para ello, vamos a limitar el movimiento de ambos. Definimos al inicio de la unidad, una clase llamada TLevelBounds.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
type { TLevelBounds } TLevelBounds = class(TComponent) public Left: single; Right: single; Top: single; Down: single; constructor Create(AOwner: TComponent); override; end; |
Esta nos contendrá 4 propiedades, las cuales representaran los límites del escenario.
En su constructor definimos los límites.
|
1 2 3 4 5 6 7 8 |
constructor TLevelBounds.Create(AOwner: TComponent); begin inherited Create(AOwner); Left := -1780; Right := 1780; Top := 104; Down := -104; end; |
Y en el evento OnStart, creamos el objeto.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
procedure TViewMain.Start; begin inherited; LevelBounds := TlevelBounds.Create(Self); //Límites del escenario {$IFDEF FPC} Suelo1.RigidBody.OnCollisionEnter:=@Suelo1CollisionEnter; Suelo1.RigidBody.OnCollisionExit:=@Suelo1CollisionExit; {$ELSE} Suelo1.RigidBody.OnCollisionEnter := Suelo1CollisionEnter; Suelo1.RigidBody.OnCollisionExit := Suelo1CollisionExit; {$ENDIF} OnGround := True; end; |
Usando logging
Para conocer dónde está el jugador en cualquier momento, y así conocer los límites del escenario, use la técnica del logging. Esto es que el juego muestre información en cualquier momento.
En la parte de abajo del editor, existe la pestaña Output, está muestra información cuando el juego se inicia. Y también puede mostrar información que nuestro programa quiera.
Añade la unidad castlelog, justo debajo de la implementación.
Ahora en el evento Press, escribe lo siguiente
|
1 2 3 4 5 6 7 8 9 |
if Event.IsKey(keyEnter) then begin WritelnLog(Arthur.TranslationXY.ToString); Exit(true); end; |
Este código mostrará por la ventana output la posición de Arthur.
Ahora, podemos limitar la posición del personaje con las siguiente instrucciones, de nuevo en el evento Update.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
if Arthur.TranslationXY.X < LevelBounds.Left then begin //Detener el movimiento Arthur.RigidBody.LinearVelocity := Vector3(0, 0, 0); Arthur.TranslationXY := Vector2(LevelBounds.Left, Arthur.TranslationXY.Y); end; if Arthur.TranslationXY.X > LevelBounds.Right then begin //Detener el movimiento Arthur.RigidBody.LinearVelocity := Vector3(0, 0, 0); Arthur.TranslationXY := Vector2(LevelBounds.Right, Arthur.TranslationXY.Y); end; |
Ahora, el personaje no se sale de escenario, pero la cámara si, ya que siempre lo mantiene en el centro. Para evitar este efecto, vamos limitar el movimiento de la cámara, de manera que si su centro, más la mitad de su ancho del campo de visión, es menor o mayor a los límites, corregiremos su posición.
Debemos obtener el ancho del campo de visión de esta manera:
|
1 |
ViewWidth := ViewPort1.Camera.Orthographic.EffectiveRect.Width; |
Recuerda definir es la parte published de la unidad la variable ViewPort1 para acceder al componente ViewPort1 del editor.
|
1 2 3 4 5 6 7 8 |
published { Components designed using CGE editor. These fields will be automatically initialized at Start. } LabelFps: TCastleLabel; Navigation2D1: TCastle2DNavigation; Arthur: TCastleScene; Suelo1: TCastleBox; ViewPort1: TCastleViewport; //Define esta variable |
Obtenemos la posición de la cámara, centrada en el eje X, con respecto al personaje.
|
1 2 |
PosicionCamara := Vector2(Arthur.TranslationXY.X, Navigation2D1.Camera.TranslationXY.Y); |
Y antes de asignar la nueva posición a la cámara hacemos unas comprobaciones. Si la posición en el eje X, menos la mitad del ancho es menor del límite izquierdo, cargamos la posición del límite más la mitad del ancho del campo de visión. Hacemos lo mismo para el límite izquierdo.
|
1 2 3 4 5 6 7 8 |
if PosicionCamara.X - (ViewWidth / 2) < LevelBounds.Left then begin PosicionCamara.X := LevelBounds.Left + (ViewWidth / 2); end; if PosicionCamara.X + (ViewWidth / 2) > LevelBounds.Right then begin PosicionCamara.X := LevelBounds.Right - (ViewWidth / 2); end; |
Y asignamos la nueva posición a la cámara.
|
1 |
Navigation2D1.Camera.TranslationXY := PosicionCamara; |
Tienes todo el código completo en el Github.
Saludos.