Project Diva Miku

Este es el nombre de un juego musical, parecido al Guitar Hero pero para mi gusto algo mas difícil. Partiendo de eso hice el siguiente ejemplo que espero que os sea útil, sobre todo para alguien que conozco.

Lo primero de todo, como es común en estos proyecto es la llamada a la librería y su inicializacion.

#include <allegro.h>

#define ALTO  480
#define ANCHO 640

int objx, objy;
int desx, desy;
int vel;
int cont;

int vida;
int vidax;

int p;

BITMAP *buffer;

// Aqui antes del programa principal debes de poner las funciones creadas

int main() 
{
    char c1[30];
    allegro_init();
    install_keyboard();
    
    set_color_depth(32);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED, ANCHO, ALTO, 0, 0);
    

Hasta el momento, lo que tenemos son variables globales que se van a utilizar en el programa, dos constantes que son ANCHO y ALTO, que se utilizan para tener almacenado las dimensiones de la ventana, en este caso tienen el valor 640, 480 respectivamente. Dentro del main se inicializa la librería allegro, se instala el teclado, se crea la ventana. Recordar que todas las funciones que se crean deben ponerse antes del main.

    buffer = create_bitmap(640, 480);
    srand ( time(NULL) );
    
    vidax = 100;
    vida = vidax;
    otro();

Se crea un bitmap para el buffer, se inicializa los números aleatorios, se asigna valores a las variables, vida y vidax, que son las que contiene la vida actual y el máximo de vida respectivamente. Y finalmente hacemos una llamada a una función propia llamada otro().

void otro(){
    desx = 320 + (rand()%25)*10;
    desy = 50  + (rand()%33)*10;
    objx = -50;
    objy = desy;     
    vel = 1 + rand()%5;  
    cont = 0;  
};

La función otro, inicializa las variables. Dando una nueva posición a desx, desy de forma aleatoria, y una velocidad que irá de 1 a 6. Pone a cero cont, que es la variable encargada de contar el tiempo de espera, ya que la velocidad esta puesto de manera de que 1 es el mas rápido y 6 el mas lento. Las variables objx, objy son las que se encarga del objeto en movimiento.

 while ( !key[KEY_ESC] && vida > 0 ){
          clear_to_color(buffer, 0x000000);
          blit(fondo, buffer, 0, 0, 0, 0, 640, 480);
          movercuadro();  
          muestra();

Continuando con el programa principal se inicia un bucle que se repite hasta que se pulse la tecla ESC o vida llega a cero. Con la instrucción clear_to_color borramos el contenido del buffer rellenándolo de un color 0x000000 que es el negro. Lo siguiente son dos llamadas a funciones propias que detallare a continuación:

void movercuadro(){
     cont++;
     if ( cont >= vel ) {
          cont = 0;
          objx++;
     }
     
     if ( objx > ANCHO ){
          otro();
          vida-=10;
     }
};

Cada vez que el contador cont llega al valor de vel, la posición del objeto objx se aumenta. Si la posición del cuadro llega a superar el ANCHO de la pantalla, nos resta vida y llama a otro para generar un nuevo cuadro.

void muestra(){
   // pintamos el que se mueve por pantalla 
    rectfill(buffer, 1+objx, 1+objy, 51+objx, 51+objy, color);
     
    // pintamos el fijo que se indica por desx, desy 
    rect(buffer, desx, desy, 52+desx, 52+desy, 0xF1D079);
    rect(buffer, 1+desx, 1+desy, 51+desx, 51+desy, 0x21D059);
    rect(buffer, 2+desx, 2+desy, 50+desx, 50+desy, 0x000000);
};

En esta funcion mostramos el cuadro que se desplaza ( objx,objy ) y el marco indicado por desx, desy. El cuadrado que se desplaza es relleno y el otro no, por eso la diferencia entre rectfill y rect.

          if ( key[KEY_SPACE] )
          {
               if ( choca() )
               {
                    puntuacion();
               }else{
                    vida-=5; 
               }
               key[KEY_SPACE]=0;
               otro();
          }

Este if va en el main, y es el que se encarga de controlar si se pulsa la tecla espacio. Cuando se pulsa se controla si chocan los objetos cuadro y marco, en el caso de que choque llamará a la función puntuación para que nos evalue nuestro grado de acierto o precisión al pulsar la tecla, en caso contrario, es decir no ha chocado nos quitará vida. Y finalmente genera otra nueva pieza.

void puntuacion(){
     int num = 50 - abs( objx-desx );
     p += num;
     
};

Aqui tenemos la función puntuacion, que calcula los puntos que ganamos según la proximidad entre el cuadro y el marco (objx - desx).

bool choca(){
     return ( abs (objx-desx) < 50 );  
};

Esta pequeña función, comprueba si chocan el cuadro y el marco, en este caso como el tamaño es de 50 es tan fácil como preguntar si la diferencia entre ellos es menor de 50. Como se puede ver se han hecho muchas funciones y algunas de ellas muy simples, pero todo esto va enfocado para que luego podamos añadir nuevas funciones de forma fácil y rápida.

          Marcador_Vida(buffer, 25, 25, vida, vidax);
         textout_centre_ex(buffer, font, itoa(p,c1,10), ANCHO-40, 25,  0xffff00, 0);
        textout_centre_ex(buffer, font, " Pulsa ESPACIO cuando este encima ", ANCHO/2, ALTO-25,  0xffffff, 0);
          blit(buffer, screen, 0, 0, 0, 0, ANCHO,ALTO);
    }
 
 destroy_bitmap(buffer);
 
 return 0;
}
END_OF_MAIN();

Y llegamos al final, a continuación mostramos la vida, los puntos, un comentario y con la instrucción blit volcamos todo el contenido del buffer en pantalla.

void Marcador_Vida(BITMAP* fondo, int x, int y, int actual, int max)
{
     int vida = (actual * 154) / max;
     if ( vida < 0 ) vida=0;

     rectfill(fondo, x+4, y, x+158, y+15, 0x000000);
     rectfill(fondo, x+5, y+1, x+5+vida, y+14,  0xFFFFFF);
};

La función marcador, muestra un rectángulo de tamaño variable según el parámetro indicado por actual y max.

Ya tenemos nuestro juego acabado ahora solo queda decorar lo con algunas imágenes y le añadimos algunos sonidos y obtendremos un mini juego similar a lo siguiente:

Espero que les haya gustado el tutorial, y disfruten de su juego. Y todo esto en una mañana inspirada.