sábado, 31 de octubre de 2015

Crear juego RPG en C++ y Allegro 4 (27) Menu

En esta entrega le añadiremos al programa un menú inicial, donde se pueda iniciar una partida, cargar partida, o salir del juego.






Objetivo

Crear el menu inicial del juego, y utilizar las funciones se guardar y cargar partida. Se guardará la partida de forma automática cuando salgamos pulsando la tecla ESC del juego.


Programación

Para el menu se crea un archivo llamado menu.h, donde se pondrá todo lo referente al menu.

El en archivo menu.h se tendrá lo siguiente:

/*

  Name:  menu.h
  Author: KODAYGAMES
  Web: http://devcpp-allegro.blogspot.com/

*/

#define NUMOP       3

class MIMENU {
    private:
       int op;
       int max_op;   
       bool salidamenu;        
       bool pulsa;
       
    public:
       MIMENU();
       void pinta();      
       int teclado();
       bool salir();
};


MIMENU::MIMENU(){
    op = 1;
    max_op = NUMOP;
    salidamenu = false;    
    pulsa = false;     
};



void MIMENU::pinta()
{   
   if ( op == 1 )  blit(menufondo2, buffer, 0, 220, 0, 220, PANTALLA_ANCHO, 70);

   if ( op == 2 )  blit(menufondo2, buffer, 0, 310, 0, 310, PANTALLA_ANCHO, 70);
   
   if ( op == 3 )  blit(menufondo2, buffer, 0, 400, 0, 400, PANTALLA_ANCHO, 70);                                             
};


int MIMENU::teclado(){
    
    if (key[KEY_DOWN] && !pulsa ){ op++; pulsa = true; sonido_boton(); }
    
    if (key[KEY_UP] && !pulsa) {op--; pulsa=true; sonido_boton(); }        
    
    if ( pulsa && !key[KEY_DOWN] && !key[KEY_UP] ) pulsa=false;
    
    if (op > max_op) op=1;
    if (op < 1) op=max_op;  
    
    // comprueba si esta en la opcion de salir
    if ((key[KEY_ENTER] || key[KEY_ENTER_PAD]) && op == max_op ) salidamenu = true;
    
    if (key[KEY_ESC]) op=max_op;
        
    return op;
};

bool MIMENU::salir(){
     return salidamenu;
};

La variable NUMOP contiene el numero de opciones que tiene el menu, en este caso 3.
Se crea una clase llamada MIMENU, que se encarga de mostrar el menu, y controlar si se pulsa las teclas del cursor para cambiar la opcion seleccionada.
op: contiene la opcion que esta actualmente seleccionada.
max_op: contiene el máximo de opciones que tiene el menu.
salidamenu: indica si se ha salido o no del menu. En este caso se sale cuando se pulsa la tecla ENTER o INTRO.
pulsa: indica si se ha pulsado algunas de las teclas que controla el menu, la tecla del cursor arriba y la tecla abajo.

La función MIMENU::MIMENU(), inicializa las variables.

La función MIMENU::pinta(), se encarga de pintar según el valor de op una de las opciones.

La función MIMENU::teclado(), se encarga de controlar las teclas del cursor, para que cambien el valor de op. Si se pulsa la tecla abajo aumenta en 1 el valor de op, y si se pulsa arriba disminuye en 1, cuando el valor de op es menor que 1 se cambia a valer el max_op que es 3. Y cuando el valor de op supera max_op, op vale 1. De esta forma solo tendras tres posibles valores 1,2 y 3.

Si se pulsa la tecla ESC, el valor de op es 3. Lo que indica que se selecciona la ultima opción que en este caso es SALIR.

Si se pulsa alguna de las teclas ENTER o INTRO y op es igual a 3, entonces pone a true salidamenu, para indicar que se a pulsado SALIR.

La función MIMENU::salir(), se utiliza para obtener el valor de la variable salidamenu, que es la que nos indica si se ha pulsado SALIR.

Haz clic aqui para descargar en RAR el archivo menu.h

En el archivo global.h, se declaran nuevas imagenes.

BITMAP *cbuffer;
BITMAP *menufondo;
BITMAP *menufondo2;

La imagen cbuffer, contendrá el mapa de choque actual que se está mostrando por pantalla.
La imagen menufondo, y menufondo2, estas dos variables BITMAP tendrán las imágenes que se utilizan para el menú inicio del juego.

En el archivo players.h, se añade una nueva función llamada pon_choque(), que se encargará de añadir un rectángulo de choque en la imagen de choque cbuffer.

void player::pon_choque()
{
   rectfill( cbuffer, x+4, y+17, x+28, y+30, 0xffffff);                      
}

La funcion player::choca(), cambia la forma de controlar el choque, se realiza mediante la imagen cbuffer, y por tanto se simplifica, ya que no es necesario calcular la posición con respecto al mapa, sino que se realiza con respecto a la pantalla.

bool player::choca()
{
    bool resp=false;
    for (int i=2; i < 30; i++ )
    {
        for (int j=16; j < 32; j++)
        {

                // color rojo 
                if ( getpixel( cbuffer, x+i, y+j) == 0xff0000 ) resp=true;  
                
                // color verde
                if ( getpixel( cbuffer, x+i, y+j) == 0x00ff00 )
                {
                      cambio = 1;
                      resp=true;
                }
                // color azul
                if ( getpixel( cbuffer, x+i, y+j) == 0x0000ff )
                {
                      cambio = 2;
                      resp=true;
                }
                // color amarillo
                if ( getpixel( cbuffer, x+i, y+j) == 0xffff00 )
                {
                      cambio = 3;                 
                      resp=true;
                }                 
        } 
    } 
    return resp;
}

En la función player::teclado(), se ha quitado el control del mapa de choque.

void player::teclado()
{
      int ax = x;
      int ay = y;
      
      if ( !hablar && !swtienda )
      {
          // teclas control usuario
          if ( key[KEY_UP] )
          {
               y-=desplazamiento; 
               direccion = 3;              
          }
          if ( key[KEY_DOWN] )
          {
               y+=desplazamiento;
               direccion = 0;
          }
          if ( key[KEY_LEFT] )
          {
               x-=desplazamiento;
               direccion = 1;
          }
          if ( key[KEY_RIGHT] )
          {
               x+=desplazamiento;
               direccion = 2;
          }  
          if ( key[KEY_SPACE] && ataca == 0 )
          {
               ataca = 1;
          }
          if ( !key[KEY_SPACE] && ataca == 1 )
          {
               ataca = 2;
               sonido_espada_aire();                   
          }                              
      }
      if ( ax != x || ay != y )
      {
           if ( choca() )
           {
                x =ax;
                y =ay;
           }else{     
                                          
               int num = FRAME_RATE / 12; 
               if ( tiempo_total % num == 0 )
               {
                   sonido_pasos(); 
                   // entra si a cambiado alguna de las variables x,y
                   animacion++;
                   if ( animacion > 2 ) animacion = 0;
               } 
           }                
      }                            
      if ( ataca > (FRAME_RATE / 4) ) ataca = 0;   
}

La función  player::cambia_escenario(), se elimina ya que no es necesario.

Haz clic aqui para descargar RAR del archivo players.h

En el archivo npc.h, se ha cambiado la clase npc.

class npc {
    protected:       
      // posicion
      int x,y;
      int ax,ay;
      
      int direccion;
      
      int animacion; 
      
      int escena;
      
      int estado;
      
      int img;
      BITMAP* imagen;      
      
    public: 
             
      void crea( int i, int _x, int _y, int dir, int _estado, int _lugar );      
      void pinta();   
      void actualiza();  
      bool chocanpc();
      bool posicion_cerca(int num=0);
      void cambia_estado(int _estado){ estado = _estado; };
      bool frente();
      bool alineado_vertical();      
      
      const int getimg()   { return img; };
      const int getx()     { return x; };
      const int gety()     { return y; };
      const int getdir()   { return direccion; };
      const int getestado(){ return estado; };
      const int getlugar() { return escena; };      
}; 

Se ha eliminado las variables mifondo y primer. Se ha cambiado la función crear y se ha añadido algunas funciones para poder obtener los datos del npc para guardarlos.

void npc::crea( int i, int _x, int _y, int dir, int _estado, int _lugar)
{
     x = _x;
     y = _y;
     direccion = dir;
     animacion = 0;
     escena = _lugar;
     
     img = i;
     BITMAP *_img = (BITMAP *)datosjuego[i].dat;
     
     imagen = create_bitmap(_img->w, _img->h);
       
     blit( _img, imagen, 0,0, 0,0, _img->w, _img->h);
     
     estado = _estado;
}

Antes la función npc::crea(), recibía una imagen bitmap. Ahora recibe un índice, mediante el cual accede a la imagen utilizando  (BITMAP *)datosjuego[i].dat;

La función npc::pinta() cambia por completo.

void npc::pinta()
{
     if ( lugar == escena )
     {

        actualiza(); 
        
        int vx = x - desplazamiento_map_x;
        int vy = y - desplazamiento_map_y;
        
        rectfill( cbuffer, vx+2, vy+1, vx+30, vy+31, 0xff0000);
        
        masked_blit(imagen, buffer, animacion*32, direccion*32, vx, vy, 32,32);
     }  
}

La función npc::chocanpc(), tambien cambia ya que se utiliza la imagen de choque cbuffer.

bool npc::chocanpc()
{
    int ninix,niniy;
    int nfinx,nfiny;
                
    if ( direccion == 0 )
    {
         // abajo
         ninix = 0; 
         niniy = 32 - desplazamiento;
         nfinx = 32;
         nfiny = 32;
    }
    if ( direccion == 1 )
    {
         // izquierda
         ninix = 0; 
         niniy = 0;
         nfinx = desplazamiento;
         nfiny = 32;
    }
    if ( direccion == 2 )
    {
         // derecha
         ninix = 32 - desplazamiento; 
         niniy = 0;
         nfinx = 32;
         nfiny = 32;
    }
    if ( direccion == 3 )
    {
         // arriba
         ninix = 0; 
         niniy = 0;
         nfinx = 32;
         nfiny = desplazamiento;
    }            

          int vx;
          int vy;          
    // comprobar si colisiona con el mapa  
    for ( int ci=ninix; ci < nfinx; ci++)
    {
        for (int cj=niniy; cj < nfiny; cj++)
        {
 
           vx = x - desplazamiento_map_x;
           vy = y - desplazamiento_map_y;  
            // color rojo
            if ( getpixel( cbuffer, vx+ci, vy+cj) == 0xff0000 || 
                 getpixel( choque, x+ci, y+cj) == 0xff0000 ){
                 return true;
            }  
            // color blanco prota
            if ( getpixel( cbuffer, vx+ci, vy+cj) == 0xffffff ){
                 return true;
            }                                 
        }
    } 
    return false; 
}

La función npc::actualiza() cambia, ahora no tiene que controlar el manejo de la imagen de choque.

void npc::actualiza()
{
    // para indicar que se ejecuta dos veces 
    int num = FRAME_RATE / 6; 
 
    if ( tiempo_total % num == 0 )
    {
        if ( estado != 0 )
        { 
           animacion++;
           if ( animacion > 2 ) animacion = 0;
        }   
         
        switch ( estado ) 
        {           
        case 1: // camina horizontal
             ax = x;
             ay = y;        
             if ( direccion == 1 )
             {
                  // camina izquierda
                  x-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 2;
                  }
             }
             if ( direccion == 2 )
             {                  
                  // camina derecha
                  x+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 1;
                  }
             } 
                                                                  
             break;
        case 2: // camina vertical
             ax = x;
             ay = y;        
             if ( direccion == 0 )
             {
                  // camina abajo
                  y+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 3;
                  }
             }
             if ( direccion == 3 )
             {                  
                  // camina arriba
                  y-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 0;
                  }
             } 
 
             break;
        case 3: // camina giro derecha
             ax = x;
             ay = y;  
             if ( direccion == 0 )
             {
                  // camina abajo
                  y+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 1;
                  }
             }
             if ( direccion == 1 )
             {                  
                  // camina izquierda
                  x-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 3;
                  }
             } 
             if ( direccion == 2 )
             {
                  // camina derecha
                  x+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 0;
                  }
             }
             if ( direccion == 3 )
             {                  
                  // camina arriba
                  y-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 2;
                  }
             }  
     
         break;
         case 4: // camina giro izquierda
             ax = x;
             ay = y;  
             if ( direccion == 0 )
             {
                  // camina abajo
                  y+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 2;
                  }
             }
             if ( direccion == 1 )
             {                  
                  // camina izquierda
                  x-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 0;
                  }
             } 
             if ( direccion == 2 )
             {
                  // camina derecha
                  x+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = 3;
                  }
             }
             if ( direccion == 3 )
             {                  
                  // camina arriba
                  y-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = 1;
                  }
             }                              
             break; 
        case 5: // camina libre
             if ( tiempo_total % 200 == 0 )
             {
                  direccion = rand()%4;
             }    
             ax = x;
             ay = y;               
             if ( direccion == 0 )
             {
                      // camina abajo
                      y+=desplazamiento;
                      if ( chocanpc() )
                      {
                           // posicion no valida
                           y = ay;
                           direccion = rand()%4;
                      }
                 }
             if ( direccion == 1 )
             {                  
                  // camina izquierda
                  x-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = rand()%4;
                  }
             } 
             if ( direccion == 2 )
             {
                  // camina derecha
                  x+=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       x = ax;
                       direccion = rand()%4;
                  }
             }
             if ( direccion == 3 )
             {                  
                  // camina arriba
                  y-=desplazamiento;
                  if ( chocanpc() )
                  {
                       // posicion no valida
                       y = ay;
                       direccion = rand()%4;
                  }
                   
             }
            
             break;
        default: // parado
             if ( tiempo_total % 300 == 0 )
             {
                  direccion = rand()%4;
             }              
             break;
        }
     
    }     
}

Al igual que en la clase npc, la clase enemigo se cambia a la hora de crear. No requiere una imagen, sino un id de la imagen. Y se cambia el manejo del choque, se utiliza cbuffer.

class enemigo : public npc {
      int vida;
      int v_actual; 
      bool muerto;     
      int golpeado;      
      int exp;      
     public:
        void crea( int i, int _x, int _y, int dir, int _estado, int _lugar, int v );
        void herida( int d ); 
        void pinta();
        bool ha_muerto() { return muerto; };
        void movimiento();       
        void daexp(int e){ exp = e; };            
        const int getvida()     { return vida; };              
};

void enemigo::crea( int i, int _x, int _y, int dir, int _estado, int _lugar, int v )
{
    x = _x;
    y = _y;
    direccion = dir;
    animacion = 0;
    escena = _lugar;
    
    img=i;
    BITMAP *_img = (BITMAP *)datosjuego[i].dat;    
    imagen = create_bitmap(_img->w, _img->h);
    
    blit( _img, imagen, 0,0, 0,0, _img->w, _img->h);
    
    estado = _estado;
                       
    vida = v;
    v_actual = vida;      
    muerto = false;   
    golpeado=0;  
    exp = 50;              
};

void enemigo::herida( int d )
{
  if ( !muerto )
  {   
     int num = FRAME_RATE / 2;       
     v_actual-=d;
     if ( v_actual <= 0 )
     {          
            muerto = true;
            int vx = x - desplazamiento_map_x;
            int vy = y - desplazamiento_map_y;
            rectfill( cbuffer, vx+2, vy+1, vx+30, vy+31, 0x000000);
            sonido_muere();
            jugador.sube_experiencia(exp); 
           // siempre obtiene un objeto aleatorio
           int q2 = lobj.size();
           int q = lobj[rand()%q2].id;
           jugador.obtiene_objeto( q );            
                       
     }else{
        // daño defensivo del enemigo   
        if ( tiempo_total % num == 0 )
        {
             if ( rand()%2 == 1 )
             {
                 sonido_herido(); 
                 jugador.herido(5+rand()%5); 
             }
        }   
     }
     
  }   
};


void enemigo::pinta()
{ 
     if ( lugar == escena && !muerto )
     {
     
          if ( v_actual == vida )
          {
               actualiza();
          }else{
               movimiento(); 
          } 
          
          int vx = x - desplazamiento_map_x;
          int vy = y - desplazamiento_map_y;
          
          rectfill( cbuffer, vx+2, vy+1, vx+30, vy+31, 0xff0000);  
 
          masked_blit(imagen, buffer, animacion*32, direccion*32, vx, vy, 32,32); 
          
        if ( golpeado == 1 )
        {
            int xn = 2 + rand()%2;
            jugador.no_ataca();
            if ( rand()%10 != 1 )
            {
               sonido_espada_da();            
               herida(xn);              
            }else{
               sonido_espada_choca();   
            }   
            golpeado = 0;
            
        }
        
        if ( golpeado == 0 && jugador.atacando() && posicion_cerca()
             && frente() )
        {
              golpeado = 1;
        }           
 
        if ( !muerto )
        {
            int nm = (v_actual * 30 ) / vida; 
            rectfill( buffer, vx+1, vy, vx+nm, vy+5, 0x00ff00);
            rect( buffer, vx, vy, vx+31, vy+5, 0x000000);
        }                    
     }     
     if ( lugar != escena && v_actual < vida )
     {
        int num = FRAME_RATE / 5; 
        if ( tiempo_total % num == 0 )
        {          
            v_actual++;
        }
     }         
}


void enemigo::movimiento()
{
    ax = x;
    ay = y;  
    int jx = jugador.getx() + desplazamiento_map_x;
    int jy = jugador.gety() + desplazamiento_map_y;  

    // para indicar que se ejecuta dos veces 
    int num = FRAME_RATE / 6; 
    
    int esta = 0; 
    
    // mira hacia donde este el jugador
    if ( jx > x )
    {
         direccion = 2;
    }else{
         direccion = 1; 
    }

    if ( jy > y )
    {
        if ( abs ( jx - x ) < desplazamiento*3 )
        {         
            direccion = 0;
        }
    }else{
        if ( abs ( jx - x ) < desplazamiento*3 )
        {   
            direccion = 3; 
        }    
    }

    // enemigo te persigue

    if ( tiempo_total % num == 0 )
    {
             
        if ( x+32 < jx )
        {
             x+=desplazamiento;
             esta = 1;
        }
        
        if ( x > jx+32 )
        {
             x-=desplazamiento;
             esta = 1;
        }
        if ( y+32 < jy )
        {
             y+=desplazamiento;
             esta = 1;
        }
        
        if ( y > jy+32  )
        {
             y-=desplazamiento;
             esta = 1;
        }    
  
    }
       
     
    if ( ax != x || ay != y )
    {
      // se ha movido en una de las direcciones
      
      if ( chocanpc() )
      {
           x = ax;
           y = ay;
           esta = 0;
      }
      if ( esta != 0 )
      { 
           animacion++;
           if ( animacion > 2 ) animacion = 0;
      }       
 
    }     
    

    if ( posicion_cerca() )
    {
        int num = FRAME_RATE / 3;
        if ( tiempo_total % num == 0 )
        {
             if ( rand()%3 == 1 )
             {             
                 sonido_herido(); 
                 jugador.herido(2+rand()%2);
                 animacion++;
                 if ( animacion > 2 ) animacion = 0;                 
             } 
        }                
    } 
 
}

Ya no se utiliza directamente la imagen choque, para poner el choque del npc y el enemigo. Esto se controla con la nueva imagen cbuffer, que almacena el mapa de choque de lo que se ve por pantalla.

Haz clic aqui para descargar en RAR el archivo npc.h

En el archivo main.cpp, se añade dos archivos nuevos menu.h y partidas.h.

#include < iostream >                            
#include < allegro.h > 
#include "log.h"
#include "datosjuego.h"
#include "botones.h"
#include "global.h"
#include "audio.h"
#include "menu.h"
#include "misobjetos.h"
#include "dialogos.h"
#include "players.h"
#include "tiendas.h"
#include "mijuego.h"
#include "partidas.h"

En la función inicia_allegro(), se añade la inicialización de la nueva variable cbuffer, justo despues de inicializar buffer.

 cbuffer = create_bitmap(PANTALLA_ANCHO, PANTALLA_ALTO); 

El main()  cambia por completo, para añadir el menu.

int main()  
{ 
 
    inicia_allegro();
    
    carga_inicio();
    
    musica_menu();
         
    int op;    
    MIMENU menu;
      
    do{  
             
    blit(menufondo, buffer, 0, 0, 0, 0, PANTALLA_ANCHO, PANTALLA_ALTO);        
 menu.pinta();
 op = menu.teclado();    

    // se a seleccionado una opcion
       if (key[KEY_ENTER] || key[KEY_ENTER_PAD]) 
       {  
          if ( op == 2 )
          {
                // carga partida
                carga_partida();
                sonido_sube_nivel();              
          } 
          if ( op == 1 )
          {
                jugador.inicia();
                lugar = 1;   
                desplazamiento_map_x=-160;
                desplazamiento_map_y=-160; 
                sonido_sube_nivel();      
                
                npersonaje = 10;
                
                personajes[0].crea( diper001, 1300,700, 1,1,3); 
                personajes[1].crea( diper005, 280, 450, 0,2,3);
                personajes[2].crea( diper005, 230, 280, 3,2,3);
                personajes[3].crea( diper003, 960, 310, 2,3,3);
                personajes[4].crea( diper005, 1120, 450, 0,4,3);
                personajes[5].crea( diper004, 900, 650, 1,5,3);
                personajes[6].crea( diper006, 850, 800, 0,0,3);
                personajes[7].crea( diper001, 530, 280, 1,5,3);
                personajes[8].crea( diper007, 334, 170, 0,0,4);
                personajes[9].crea( diper008, 142, 170, 0,0,4);
                
                nmalos = 3;
                malos[0].crea( diene001, 380, 280, 3,5,2,100);
                malos[1].crea( diene001, 400, 720, 0,5,2,100);
                malos[2].crea( diene001, 380, 240, 0,5,2,100);
                malos[3].crea( diper005, 440, 720, 3,5,2,100);                
                                        
          }     
          
          if ( op == 1 || op == 2 )
          {
               carga_juego();               
                
            // juego          
             salir = false;
                     
             while ( !salir )
             {   
                    
                   // tecla de salida
                   if ( key[KEY_ESC] ) salir = true;
                                          
                      if ( contador_tiempo_juego )
                      {
                            while ( contador_tiempo_juego )
                            {
                                actualiza_juego();    
                                contador_tiempo_juego--;
                            }  
                                
                            clear_to_color(buffer, 0x00000);    
                             
                            pinta_juego();                
                            pintar_pantalla();         
                               
                      }else{                                    
                           rest(1);  
                      }   
                }   
                
            if ( lugar == 2 ) para_sonido_ambiente();         
            // fin juego
            guarda_partida();
            musica_menu();
            op=2;
       } 
    }  

  pintar_pantalla();
 
    }while ( !menu.salir() );
                             
     
    destroy_bitmap(fondo);    
    destroy_bitmap(choque);
    destroy_bitmap(cielo); 
    
    destroy_bitmap(menufondo);
    destroy_bitmap(menufondo2); 
    destroy_bitmap(cbuffer);       
    destroy_bitmap(buffer);
 
 return 0;
}
END_OF_MAIN();

Se hace que cuando salgas de la partida, se guarde automáticamente.

Haz clic aqui para descargar en RAR el archivo main.cpp

Y hasta aquí llega este curso, aun falta un próximo curso en el que detalla los cambios realizados en el archivo mijuego.h. Por tanto, aun no se puede compilar pues no se tiene todo.

No hay comentarios:

Publicar un comentario

Related Posts Plugin for WordPress, Blogger...