Programar videojuegos con la librería SDL (10)

CREANDO AL HEROE

Una vez tenemos el escenario vamos a crear el personaje del héroe que será el que maneje el usuario:


Para manejar el héroe de nuestro juego tenemos que declarar unas variables globales dentro de nuestra unidad UPlataformas.pas:

var
  Fondo, Temporal, Piezas, Heroe: TSprite;
  Mapa: array[1..16, 1..12] of char;
  iPosicion, iEstado: Integer;
  bMoviendo: Boolean; // ¿se esta moviendo el héroe?

La variable iPosicion va a a encargarse de controlar la posición de las piernas del héroe. Conforme vaya andando se irá incrementando la posición para dar el efecto de la animación.

La variable iEstado la vamos a utilizar la saber que está haciendo el personaje. Los posibles estados los vamos a definir en estas constantes al principio de la unidad:

const
  // Estados del heroe
  ANDANDO   = 0;
  ESCALERAS = 1;
  CAYENDO   = 2;
  SALTANDO  = 3;

La variable booleana bMoviendo va a ser nuestra bandera para controlar si el héroe se mueve o no. Si no se mueve tenemos que volver a ponerle las piernas en el suelo.

Lo siguiente a realizar es ampliar los métodos de cargar y destruir los sprites:

procedure CargarSprites;
begin
  Fondo := TSprite.Create;
  Fondo.CargarSuperficie( ExtractFilePath( ParamStr( 0 ) ) +
    'fondo.jpg' );

  Temporal := TSprite.Create;
  Temporal.CargarSuperficie( ExtractFilePath( ParamStr( 0 ) ) +
    'fondo.jpg' );

  Piezas := TSprite.Create;
  Piezas.CargarSuperficie( ExtractFilePath( ParamStr( 0 ) ) +
    'piezas.png' );
  Piezas.bSubsprites := True;
  Piezas.iAnchoSub := 40;
  Piezas.iAltoSub := 40;

  Heroe := TSprite.Create;
  Heroe.CargarSuperficie( ExtractFilePath( ParamStr( 0 ) ) +
    'heroe.png' );
  Heroe.bSubsprites := True;
  Heroe.iAnchoSub := 40;
  Heroe.iAltoSub := 40;
  Heroe.rx := 40;
  Heroe.ry := 400;

  CargarPantalla( 'pantalla1.txt' );
  DibujarPiezasEnTemporal;
end;

procedure DestruirSprites;
begin
  Heroe.Free;
  Piezas.Free;
  Temporal.Free;
  Fondo.Free;
end;

En este juego vamos a controlar al héroe utilizando coordenadas en formato real en vez de con enteros. La razón es porque necesito más precisión para las rutinas de salto y caída al vacío.

Ahora vamos a reprogramar el procedimiento ControlarEventos para mover el héroe por pantalla:

procedure ControlarEventos;
begin
  bMoviendo := False;
  ComprobarDerecha;
  ComprobarIzquierda;
  ComprobarArriba;
  ComprobarAbajo;

  // Si no se esta moviendo lo dejamos en la posición inicial
  if not bMoviendo then
    Heroe.iSubX := 0;

  // Transformarmos las coordenadas reales en formato entero
  Heroe.x := Round( Heroe.rx );
  Heroe.y := Round( Heroe.ry );
end;

Cada una de las direcciones en las que se mueve el héroe las he separado en un procedimiento para dar más claridad al código fuente:

procedure ComprobarDerecha;
begin
  if ( Teclado.bDerecha or Joystick.bDerecha ) and
    ( Heroe.rx <> ESCALERAS ) then
  begin
    Heroe.iSubY := 0;  // Hacemos que mire a la derecha
    Heroe.rx := Heroe.rx + 2;
    CambiarPosicion;
    bMoviendo := True;
  end;
end;

Cuando el usuario pulsa la tecla del cursor hacia la derecha tenemos que comprobar que no se salga de la pantalla y que no esté en las escaleras.

Igual lo hacemos hacia la izquierda:

procedure ComprobarIzquierda;
begin
  if ( Teclado.bIzquierda or Joystick.bIzquierda ) and
    ( Heroe.rx > 40 ) and ( iEstado <> ESCALERAS ) then
  begin
    Heroe.iSubY := 1;  // Hacemos que mire a la izquierda
    Heroe.rx := Heroe.rx - 2;
    CambiarPosicion;
    bMoviendo := True;
  end;
end;

Lo más difícil viene ahora, comprobar cuando pulsamos hacia arriba si estamos o no debajo de las escaleras:

procedure ComprobarArriba;
var
  xMapa, yMapa: Integer;
begin
  if ( Teclado.bArriba or Joystick.bArriba ) then
  begin
    // Pasamos de las coordenadas de pantalla a las coordenadas del mapa
    xMapa := ( Round( Heroe.rx ) + 20 ) div 40 + 1;
    yMapa := ( Round( Heroe.ry ) + 39 ) div 40 + 1;

    if iEstado = ESCALERAS then
    begin
      Heroe.ry := Heroe.ry - 2;
      CambiarPosicion;

      // Si ha terminado de subir las escaleras lo dejamos de nuevo andando
      if Mapa[xMapa,yMapa] <> '3' then
      begin
        Heroe.ry := ( yMapa - 1 ) * 40; // Ajustamos el heroe al suelo
        Heroe.iSubY := 0;
        iEstado := ANDANDO;
      end;
    end
    else
    begin
      // ¿hay unas escaleras para subir?
      if Mapa[xMapa,yMapa] = '3' then
      begin
        Heroe.rx := ( xMapa - 1 ) * 40; // centramos el heroe en las escaleras
        Heroe.iSubY := 2;
        iEstado := ESCALERAS;
      end;
    end;

    bMoviendo := True;
  end;
end;

Para comprobar esto he tenido que convertir las coordenadas del los pies del héroe en coordenadas de mapa, a fin de averiguar si tenemos delante las escaleras.

Lo mismo hay que hacer para bajar las escaleras:

procedure ComprobarAbajo;
var
  xMapa, yMapa: Integer;
begin
  if ( Teclado.bAbajo or Joystick.bAbajo ) then
  begin
    // Pasamos de las coordenadas de pantalla a las coordenadas del mapa
    xMapa := ( Round( Heroe.rx ) + 20 ) div 40 + 1;
    yMapa := ( Round( Heroe.ry ) + 41 ) div 40 + 1;

    if iEstado = ESCALERAS then
    begin
      Inc( Heroe.y, 2 );
      CambiarPosicion;

      // Si ha terminado de subir las escaleras lo dejamos de nuevo andando
      if Mapa[xMapa,yMapa] <> '3' then
      begin
        Heroe.ry := ( yMapa - 2 ) * 40; // Ajustamos el heroe al suelo
        Heroe.iSubY := 0;
        iEstado := ANDANDO;
      end;
    end
    else
    begin
      // ¿hay unas escaleras para bajar?
      if Mapa[xMapa,yMapa] = '3' then
      begin
        // centramos el heroe en las escaleras 
        Heroe.rx := ( xMapa - 1 ) * 40; 
        Heroe.iSubY := 2;
        iEstado := ESCALERAS;
      end;
    end;

    bMoviendo := True;
  end;
end;

En estos cuatro procedimientos para comprobar las direcciones del héroe he llamado a un nuevo procedimiento que comprueba si una parte del mapa es sólido o no:

function Choca( x, y: Integer ): Boolean;
var
  xMapa, yMapa: Integer;
begin
  // Pasamos de las coordenadas de pantalla a las coordenadas del mapa
  xMapa := x div 40 + 1;
  yMapa := y div 40 + 1;
  Result := ( Mapa[xMapa,yMapa] = '1' ) or ( Mapa[xMapa,yMapa] = '2' );
end;

Lo que hacemos es comprobar si chocamos con el suelo de piedra (1) o el de madera (2).

Otro procedimiento que también llamo es el siguiente:

procedure CambiarPosicion;
begin
  Inc( iPosicion );

  if iPosicion > 4 then
  begin
    if Heroe.iSubX = 0 then
      Heroe.iSubX := 1
    else
      Heroe.iSubX := 0;
 
    iPosicion := 0;
  end;
end;

Lo que hace es cambiar la posición del héroe al andar o al subir las escaleras. Cada vez que el personaje se mueve 4 pixels volvemos a cambiar de posición.

LA LEY DE LA GRAVEDAD

Para darle más emoción al juego vamos a hacer unos agujeros en el mapa para que el héroe tenga que saltar por encima de ellos, aunque lo primero que tenemos que hacer es que se caiga por ellos.

Como vimos en el artículos anterior, el mapa se guardar en un archivos de texto llamado pantalla1.txt. A ese archivo le vamos a hacer unos agujeros en el suelo para que el héroe tenga que saltar:

1111111111111111
1000000000000001
1000400000000001
1222222022322221
1000000000300001
1000000000300041
1232202222222221
1030000000000001
1030004000000001
1222222202232221
1000000000030041
1111111111111111

El procedimiento ComprobarSiCae va a encargarse de estar continuamente vigilando si debajo del héroe hay un suelo al que agarrarse:

procedure ComprobarSiCae;
var
  xMapa, yMapa: Integer;
begin
  if ( iEstado = ESCALERAS ) or ( iEstado = SALTANDO ) then
    Exit;

  // Pasamos de las coordenadas de pantalla a las coordenadas del mapa
  xMapa := ( Round( Heroe.rx ) + 20 ) div 40 + 1;
  yMapa := ( Round( Heroe.ry ) + 40 ) div 40 + 1;

  // ¿No estaba cayendo anteriormente?
  if iEstado <> CAYENDO then
    // Inicializamos la aceleración
    rAceleracion := 0.1;

  // ¿No ha chocado con el suelo?
  if ( Mapa[xMapa,yMapa] <> '1' ) and ( Mapa[xMapa,yMapa] <> '2' ) and
    ( Mapa[xMapa,yMapa] <> '3' ) then
  begin
    iEstado := CAYENDO;
    Heroe.ry := Heroe.ry + rAceleracion;

    if rAceleracion <= 4 then
      rAceleracion := rAceleracion + 0.5;
  end
  else
  begin
    iEstado := ANDANDO;
    // Ajustamos el heroe al suelo
    Heroe.ry := ( yMapa - 2 ) * 40;
  end;
end;

Este procedimiento hay que llamarlo dentro de ControlarEventos:

procedure ControlarEventos;
begin
  bMoviendo := False;
  ComprobarDerecha;
  ComprobarIzquierda;
  ComprobarArriba;
  ComprobarAbajo;
  ComprobarSiCae;
  ...
end;

SALTANDO OBSTÁCULOS

El último movimiento que le vamos a hacer al héroe es el salto. Realmente sólo hay que controlar la mitad de salto, una vez termina la subida empieza a caer. El salto lo vamos a realizar si el usuario pulsa la barra de espacio:

procedure ControlarEventos;
begin
  bMoviendo := False;
  ComprobarDerecha;
  ComprobarIzquierda;
  ComprobarArriba;
  ComprobarAbajo;
  ComprobarSiCae;
  ComprobarSiSalta;

  if ( Teclado.bEspacio or Joystick.Boton[0] ) and
    ( iEstado = ANDANDO ) then
  begin
    rAceleracion := 5;
    iEstado := SALTANDO;
  end;

  // Si no se esta moviendo lo dejamos en la posición inicial
  if not bMoviendo then
    Heroe.iSubX := 0;
  
  // Transformarmos las coordenadas reales en formato entero
  Heroe.x := Round( Heroe.rx );
  Heroe.y := Round( Heroe.ry );
end;

Hemos añadido la llamada al procedimiento ComprobarSiSalta para comprobar en todo momento la subida y la deceleración:

procedure ComprobarSiSalta;
begin
  if iEstado = SALTANDO then
    if rAceleracion > 0 then
    begin
      Heroe.ry := Heroe.ry - rAceleracion;
      rAceleracion := rAceleracion - 0.4;
    end
    else
      iEstado := CAYENDO;
end;

Para hacer la caída lo más suave posible primero creo una aceleración pequeña y luego incremento la aceleración hasta 4 pixels por movimiento. Cuando choque con el suelo lo volvemos a dejar andando.

Conforme sube hacia arriba decrementamos la aceleración hasta llegar a cero. Luego cambiamos el estado a CAYENDO y dejamos que nuestro código haga el resto.

EL DINERO ES LO PRIMERO

El objetivo del juego va a ser recoger las joyas sin que nos pillen los enemigos. Lo que hay que hacer es un procedimiento que compruebe si donde está el héroe hay una joya. Cuando la encuentre la eliminamos del mapa y volvemos a dibujar el mapa en la pantalla Temporal antes de llevarla a la pantalla de vídeo.

Vamos por pasos. Primero hacemos el procedimiento que recoge las joyas:

procedure ComprobarTesoro;
var
  xMapa, yMapa: Integer;
begin
  // Pasamos de las coordenadas de pantalla a las coordenadas del mapa
  xMapa := ( Round( Heroe.rx ) + 20 ) div 40 + 1;
  yMapa := ( Round( Heroe.ry ) + 20 ) div 40 + 1;

  // ¿Ha encontrado una joya?
  if Mapa[xMapa,yMapa] = '4' then
  begin
    // la quitamos del mapa
    Mapa[xMapa,yMapa] := '0';

    // copiamos la pantalla de fondo a la pantalla temporal
    Fondo.DibujarEn( Temporal.Superficie );

    // Dibujamos las piezas en la pantalla temporal
    DibujarPiezasEnTemporal;
  end;
end;

Lo que hace es mirar en el mapa si estamos encima de una joya. Si es así entonces la elimina del mapa y refresca la pantalla.

Este procedimiento hay que llamarlo desde ControlarEventos:

procedure ControlarEventos;
begin
  bMoviendo := False;
  ComprobarDerecha;
  ComprobarIzquierda;
  ComprobarArriba;
  ComprobarAbajo;
  ComprobarSiCae;
  ComprobarSiSalta;
  ComprobarTesoro;

  if ( Teclado.bEspacio or Joystick.Boton[0] ) and
    ( iEstado = ANDANDO ) then
  begin
    rAceleracion := 5;
    iEstado := SALTANDO;
  end;

  // Si no se esta moviendo lo dejamos en la posición inicial
  if not bMoviendo then
    Heroe.iSubX := 0;

  // Transformarmos las coordenadas reales en formato entero
  Heroe.x := Round( Heroe.rx );
  Heroe.y := Round( Heroe.ry );
end;

Este es el resultado final del juego:


Aunque donde mejor se aprecia es ejecutando mi proyecto. Aquí lo tenéis comprimido con ZIP en los tres servidores de siempre:

https://mega.nz/file/5FhU2SyD#ZavwnR9Amwcpub4wGaTI5zLsqEOPmUxuy201rtIUaOA

En el próximo artículo meteremos los enemigos en pantalla y terminaré esta serie de artículos dedicada a la programación en SDL.

Pruebas realizadas en Delphi 7.