Juego de plataformas en C++/Allegro (Juego.cpp)

// Juego.cpp
// Base para juego de plataformas en C++ y Allegro

// Allegro
#include <allegro5/allegro.h>

// Funciones para dibujar figuras
#include <allegro5/allegro_primitives.h>

// Fnuciones para mostrar mensajes de texto
#include <allegro5/allegro_native_dialog.h>


#include "Juego.h"
#include "Nivel.h"



namespace {

// Para representar el nivel se usa una cadena de caracteres (string)
const char *nivel_prueba =
   "XXXXXXXXXXXXXXXXXXXXXXXXX"
   "X                       X"
   "X                       X"
   "X                       X"
   "X                       X"
   "X                XXXXXXXX"
   "X                       X"
   "X               XXXXXXX X"
   "X                       X"
   "X XXXXXXXX     XXXXXXXXXX"
   "X                       X"
   "X          X X          X"
   "X J XXXXXX X XX         X"
   "X   X      X XXX        X"
   "XXXXXXXXXXXX XXXXXXXXXXXX";

} // namespace


// Inicializar la librería y el juego
bool Juego::Inicializar()
{
   al_init();

   if (!al_init_primitives_addon())
   {  al_show_native_message_box(NULL, "Allegro", "Error"
                                 , "No se pudo inicializar el primitives_addon"
                                 , NULL, ALLEGRO_MESSAGEBOX_ERROR);
      return false;
   }

   if (!al_install_keyboard())
   {  al_show_native_message_box(NULL, "Allegro", "Error"
                                 , "No se pudo inicializar el teclado", NULL
                                 , ALLEGRO_MESSAGEBOX_ERROR);
      return false;
   }

   // Creación de la ventana
   ventana = al_create_display(800, 480);

   if (!ventana)
   {  al_show_native_message_box(NULL, "Allegro", "Error"
                                 , "No se pudo crear una ventana para el juego"
                                 , NULL, ALLEGRO_MESSAGEBOX_ERROR);
      return false;
   }

   al_set_window_title(ventana, "Juego de plataformas");



   // Crear el "timer" que controla la velocidad del juego
   timer = al_create_timer(1.0 / 60);

   // Lista de eventos
   lista_eventos = al_create_event_queue();

   // Array que usaremos para checar los botones del teclado
   key = new int[ALLEGRO_KEY_MAX]();



   // Generar los eventos de la ventana (display)
   al_register_event_source(lista_eventos, al_get_display_event_source(ventana));

   // ...del timer
   al_register_event_source(lista_eventos, al_get_timer_event_source(timer));

   // ...y del teclado
   al_register_event_source(lista_eventos, al_get_keyboard_event_source());


   // Crear el nivel desde la cadena "nivel_prueba" y actualizar la posición
   // de inicio del jugador.
   Crear_Nivel(nivel_prueba, jugador_x, jugador_y);

   jugador_x_inicio = jugador_x;
   jugador_y_inicio = jugador_y;


   return true;
}



void Juego::Actualizar()
{
   static float velocidad_y = 0;
   static bool saltar = false;

   // Mover el jugador a la izquierda...
   if (key[ALLEGRO_KEY_LEFT])
   {  if (!Checar_Plataforma(jugador_x - 4.0, jugador_y))
         jugador_x -= 4.0;
   }

   // Mover el jugador a la derecha...
   if (key[ALLEGRO_KEY_RIGHT])
   {  if (!Checar_Plataforma(jugador_x + 4.0, jugador_y))
         jugador_x += 4.0;
   }

   if (key[ALLEGRO_KEY_UP])
      saltar = true;


   // Por defecto, la "gravedad" del jugador será de 0.5
   velocidad_y += 0.5;

   // Actualizar la posición "y" con la velocidad
   jugador_y += velocidad_y;


   // Verificar si hay una plataforma al caer o al saltar
   Plataforma *p = Checar_Plataforma(jugador_x, jugador_y);

   if (p)
   {  // Reposicionar el jugador arriba o abajo de la plataforma.
      if (velocidad_y < 0)
         jugador_y = p->y + 32;
      else
         jugador_y = p->y - 32;

      velocidad_y = 0;
   }


   // Saltar si hay una plataforma debajo del jugador
   if (saltar)
   {  if (Checar_Plataforma(jugador_x, jugador_y + 1))
         velocidad_y = -12;

      saltar = false;
   }


   if (jugador_y > 480)
   {  jugador_x = jugador_x_inicio;
      jugador_y = jugador_y_inicio;
      velocidad_y = 0;
   }
}



void Juego::Dibujar()
{
   Dibujar_Nivel();

   // Dibujar el jugador
   al_draw_filled_rectangle(jugador_x, jugador_y, jugador_x + TAMANO_JUGADOR_X
                            , jugador_y + TAMANO_JUGADOR_Y
                            , al_map_rgb(0, 255, 0));
}



Juego::Juego()
{
   iniciado = Inicializar();
}



void Juego::Correr()
{
   if (!iniciado)
      return;

   // Empezar a correr el timer
   al_start_timer(timer);


   bool redibujar = false;


   // Ciclo principal
   while (1)
   {  ALLEGRO_EVENT event;
      al_wait_for_event(lista_eventos, &event);

      if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
      {  break;
      }
      else if (event.type == ALLEGRO_EVENT_KEY_DOWN)
      {  key[event.keyboard.keycode] = 1;

         // Cerrar el juego al pulsar <Esc>
         if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
            break;
      }
      else if (event.type == ALLEGRO_EVENT_KEY_UP)
      {  key[event.keyboard.keycode] = 0;
      }
      else if (event.type == ALLEGRO_EVENT_TIMER)
      {  Actualizar();
         redibujar = true;
      }

      if (redibujar && al_is_event_queue_empty(lista_eventos))
      {  redibujar = false;

         al_clear_to_color(C_NEGRO);

         Dibujar();

         al_flip_display();
      }
   }

   // Liberar la memoria de todos los recursos
   al_destroy_display(ventana);
   al_destroy_timer(timer);
   al_destroy_event_queue(lista_eventos);

   delete key;

   Destruir_Nivel();
}