User Tag List

Resultados 1 al 2 de 2

Tema: Programación de un juego en C++ (1/11)

  1. #1

    Fecha de ingreso
    Jun 2004
    Ubicación
    Pinto (MADRID)
    Mensajes
    987
    Mencionado
    11 Post(s)
    Tagged
    0 Tema(s)
    Agradecer Thanks Given 
    3
    Agradecer Thanks Received 
    93
    Thanked in
    Agradecido 65 veces en [ARG:2 UNDEFINED] posts

    Programación de un juego en C++ (1/11)

    1. PLANTILLA BASE

    Para hacer la cosa más fácil, vamos a crear un sólo archivo para el juego (main.cpp). Como el juego es relativamente corto no habrá problema, aunque en proyectos largos tendrás que buscar la forma de dividir las funciones.

    También he incluido el proyecto en CodeBlocks para los que lo quieren todo hecho. Por cierto, lo he linkado con estos parámetros: -lSDL_mixer -lSDL_ttf -lfreetype -lsmpeg -lvorbisidec -lz -lSDL -lpthread. El archivo completo lo tienes en: Tutorial de programación c++ (1/11)

    Empezamos. Si miramos el archivo main.cpp encontramos lo siguiente:

    Código:
    ///////////////////////////////////
    /*  Librerías a utilizar         */
    ///////////////////////////////////
    #include <fstream>
    #include <SDL/SDL.h>
    Estas son las librerías externas que vamos a utilizar de momento. Por un lado tenemos SDL.h, que contiene las funciones gráficas de Wiz. Y por otro lado fstream, que contiene algunas funciones del sistema, entre ellas hay una que nos permitirá volver al menú de la consola una vez que salgamos del juego.

    Código:
    ///////////////////////////////////
    /*  Codigos de joystick          */
    ///////////////////////////////////
    
    #define GP2X_BUTTON_UP              (0)
    #define GP2X_BUTTON_DOWN            (4)
    #define GP2X_BUTTON_LEFT            (2)
    #define GP2X_BUTTON_RIGHT           (6)
    #define GP2X_BUTTON_UPLEFT          (1)
    #define GP2X_BUTTON_UPRIGHT         (7)
    #define GP2X_BUTTON_DOWNLEFT        (3)
    #define GP2X_BUTTON_DOWNRIGHT       (5)
    #define GP2X_BUTTON_CLICK           (18)
    #define GP2X_BUTTON_A               (12)
    #define GP2X_BUTTON_B               (13)
    #define GP2X_BUTTON_X               (14)
    #define GP2X_BUTTON_Y               (15)
    #define GP2X_BUTTON_L               (10)
    #define GP2X_BUTTON_R               (11)
    #define GP2X_BUTTON_START           (8)
    #define GP2X_BUTTON_SELECT          (9)
    #define GP2X_BUTTON_VOLUP           (16)
    #define GP2X_BUTTON_VOLDOWN         (17)
    Estas definiciones son los códigos de los botones de Wiz y GP2X. He visto que en algunos sdk ya están definidas (en el mío no). Si el compilador te da un error por duplicación de constantes, las puedes quitar. Esto nos servirá para comprobar qué botones hemos pulsado.

    Código:
    ///////////////////////////////////
    /*  Variables globales           */
    ///////////////////////////////////
    SDL_Surface *screen;   		    // superficie de la pantalla
    SDL_Joystick *joystick;         // joystick usado
    int done=0;
    Las variables globales son valores que necesitamos consultar en cualquier parte del programa. Hay que intentar usar el menor número de variables globales siempre que sea posible, pero aquí no tendremos muchas.

    SDL_Surface *screen; es la pantalla de la Wiz, donde dibujaremos los gráficos y los textos.
    SDL_Joystick *joystick; es el pad de la Wiz, para controlar los movimientos y botones.
    int done=0; esto nos indicará cuándo saldremos del juego. Cuando queramos salir, pondremos done=1.

    Código:
    ///////////////////////////////////
    /*  Inicio del programa          */
    ///////////////////////////////////
    int main(int argc, char *argv[])
    {
      SDL_Event event;
    
      if(SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO | SDL_INIT_AUDIO)<0)
        return 0;
    
      screen = SDL_SetVideoMode(320, 240, 16, SDL_SWSURFACE);
        if(screen==NULL)
          return 0;
    
      joystick=SDL_JoystickOpen(0);
        SDL_ShowCursor(0);
    En la función main definiremos una variable SDL_Event event; que recogerá todas las pulsaciones de los botones.

    A continuación iniciamos el sistema SDL, y activamos el joystick, el video y el audio. Esto lo hacemos con la función SDL_Init(SDL_INIT_JOYSTICK | SDL_INIT_VIDEO | SDL_INIT_AUDIO).

    En la variable global screen metemos la pantalla de la Wiz, que debe ser de 320x240 de resolución y 16 bits de profundidad. En Wiz no puedes ejecutar juegos en 24 bits, cosa que sí es posible en GP2X.

    Lo siguiente es guardar en la variable joystick el pad de control de Wiz, y ocultar el cursor con SDL_ShowCursor(0).

    Código:
      while(!done)
      {
        // Comprueba los eventos de botones
        while(SDL_PollEvent(&event))
        {
          switch(event.jbutton.button)
          {
            case GP2X_BUTTON_START:
              done=1;
              break;
          }
        }
    
        SDL_FillRect(screen, NULL, 0x000000);
        SDL_Flip(screen);
      }
    Este será el bucle principal del juego. Mientras la variable done sea 0, se ejecutará sin fin. Lo primero que debemos hacer es comprobar la pila de pulsaciones de los botones. Si no hacemos esto, el programa se colgará, así que debemos meterlo obligatoriamente.

    La línea while(SDL_PollEvent(&event)) irá sacando de esa pila todos los eventos del joystick. Cada botón pulsado tendrá un efecto en nuestro programa, aunque por ahora sólo comprobaremos si se pulsa el botón MENU. Si es así, pondremos done=1 y el programa acabará. El código de botón pulsado en cada evento lo tendremos que comprobar en la variable event.jbutton.button.

    Bueno, dentro del bucle principal por un lado debemos comprobar las pulsaciones de los botones y por otro dibujar la pantalla. En nuestro caso la dibujaremos completamente de negro con SDL_FillRect(screen, NULL, 0x000000). Y la mostraremos con SDL_Flip(screen). La función SDL_Flip() siempre es obligatoria y hay que meterla para que muestre lo que dibujamos en pantalla.

    Código:
      // Ponemos la pantalla en negro y salimos
      SDL_FillRect(screen, NULL, 0x000000);
      SDL_Flip(screen);
    
      if(SDL_JoystickOpened(0))
        SDL_JoystickClose(joystick);
    
      // Volvemos al menu de WIZ antes de cerrar
      chdir("/usr/gp2x");
      execl("/usr/gp2x/gp2xmenu", "/usr/gp2x/gp2xmenu", NULL);
    
      return 1;
    }
    Para finalizar el programa una vez que le damos a salir, veis que he vuelto a dibujar la pantalla de negro y la he vuelto a mostrar. Esto lo hago porque en ocasiones, al salir de un juego aparece basura en la pantalla y se llena de colores, pero al dejarla en negro no ocurre. Así que es más bonito para cerrar el juego.

    También cerramos el joystick, aunque seguramente no haga falta, pero nos curamos en salud haciendo las cosas bien.

    A continuación vemos las líneas que nos devuelven la menú de Wiz. Si no las añadimos, al salir de un juego el sistema se quedará en la consola de linux, y como no lo vemos nos dará la impresión de que se ha colgado. Así que debemos arrancar el menú antes de salir con la función execl().

    Este programa es lo mínimo que funciona en Wiz. Si lo compilas y ejecutas, verás que la pantalla se queda en negro hasta que pulsas el botón MENU. Parece que la consola responde a nuestras órdenes, así que es el momento de preparar alguna cosa más compleja.

  2. #2

    Fecha de ingreso
    May 2008
    Ubicación
    A tu lado, en tus sueños
    Mensajes
    22,478
    Mencionado
    145 Post(s)
    Tagged
    1 Tema(s)
    Agradecer Thanks Given 
    319
    Agradecer Thanks Received 
    552
    Thanked in
    Agradecido 424 veces en [ARG:2 UNDEFINED] posts
    Entradas de blog
    3

Permisos de publicación

  • No puedes crear nuevos temas
  • No puedes responder temas
  • No puedes subir archivos adjuntos
  • No puedes editar tus mensajes
  •