9 Ene

Arrancando SDL

Ahora que ya hemos instalado el compilador MinGW y hemos aprendido un poco de C++ estaremos preparados para empezar a tontear con formas más gráficas de salida por pantalla. Este tipo de salidas dependen del sistema operativo en el que nos encontremos. De ahí el problema de la portabilidad de aplicaciones gráficas, ya que aunque el resultado sea muy similar, la forma de mostrarse que subyacente puede ser muy distinta. SDL soluciona estos problemas de portabilidad dando acceso de más bajo nivel al hardware, así nuestras creaciones serán portables a bastantes plataformas haciendo algunos cambios al software.

Bien, para instalar las librerías SDL bajo MinGW lo primero que haremos es entrar enla pagina oficial de SDL y descargarnos las librerías de desarrollo para MinGW y descomprimirlos en una carpeta temporal. De esta carpeta copiaremos la carpeta SDL que está en “temporal/include” en “/mingw/include”, los archivos que hay en “/temporal/lib” en “/mingw/lib” y el archivo “/temporal/bin/sdl-config” en “msys/bin”.

Una vez copiados todos los archivos, y suponiendo que vamos a utilizar siempre la misma versión de SDL, copiaremos el archivo SDL.dll en la carpeta “/system32″ de windows. La alternativa es copiarlo en la carpeta donde ejecutaremos el programa que creemos.

Con todo esto ya podremos crear nuestra primera aplicación gráfica, sería muy duro llamar al resultado juego. Pero al menos tendréis cierto contacto con la forma de programar en SDL antes de que entremos al grueso del asunto, pienso que os animará bastante hacer algo que funcione aunque sea muy simple. Finalmente, para compilar un programa con SDL escribimos el siguiente comando en msys.

gcc nombre_del_archivo.cpp `sdl-config –cflags –libs`

Fijaos que no son apóstrofes sino tildes invertidas. Ya listos todos los previos, vamos a crear una nueva carpeta en el directorio de trabajo de msys, y en ella el archivo que será el código fuente siguiendo el mismo procedimiento que en la anterior entrega.

La aplicación va a consistir en una ventana que se cierra dando a escape o al botón de cerrar en la que se moverá un cuadro verde a través de los cursores. Coged vuestro nuevo código fuente en blanco y marcad su estructura usando comentarios. Como podréis observar ya seguimos grosso modo la estructura básica de un juego.

Para empezar a usar SDL hay que inicializarlo, esto lo hacemos con SDL_Init(Uint32 flags). Esta función devuelve -1 cuando se da algún tipo de error, y 0 cuando tiene éxito. En el próximo artículo veremos como aprovechar esto para gestionar los errores y ver que ha fallado exactamente. El parámetro es del tipo Uint32 que significa exactamente lo que parece, es un entero sin signo de 32 bits. Aunque para crear una variable de este tipo no hay que definir un tipo propio SDL define sus propios tipos de variables para evitar posibles problemas de portabilidad.

El parámetro que le pasaremos en esta aplicación será SDL_INIT_VIDEO. Una explicación más extendida de los parámetros que se le pueden introducir la tenéis aquí, que por cierto es una muy buena guía de referencia sobre SDL, merecedora de un lugar en vuestros favoritos. Cuando hayamos acabado de usar SDL deberíamos liberar los recursos que toma, esto lo hacemos con la función SDL_Quit(void), por supuesto en la parte de finalización del programa.

Sigamos creando la ventana, para esto primero tenemos que inicializar el modo de vídeo y crear una superficie que actuará como la pantalla. Esta declaración es SDL_Surface *nombre, ya que aunque lo que queremos la superficie en sí, la función que inicializa el modo de vídeo no devuelve la superficie sino un puntero a esta. La creación de la superficie pantalla, se hará con SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags), sus parámetros son el ancho, el alto, la profundidad de color, y los parámetros de entrada. Esta vez usaremos, 640, 480, 32, SDL_HWSURFACE|SDL_DOUBLEBUFF; sí, los parámetros los estamos concatenando con un solo operador or ” | “. El primer parámetro indica que la superficie se crea por hardware, el segundo habilita el double buffer que sería como una capa oculta en la que se opera para luego mostrarlo en la visible. El puntero que devuelve la función lo almacenaremos en el que creamos antes.

Igual que antes, debemos liberar la memoria ocupada por la superficie creada. Lo haremos con la función SDL_FreeSurface(SDL_Surface *surface ) al finalizar el programa, pasándole como parámetro el nombre que le hayáis dado a vuestro puntero. Ahora vamos a crear el rectángulo que se moverá por pantalla. Lo declaramos en su correspondiente lugar usando SDL_Rect nombre, estos objetos tienen 4 características , x, y w y h. Podréis adivinar fácilmente a cual corresponde cada una, aunque tened una cosa clara, la referencia está en la esquina superior derecha del rectángulo, para que lo tengáis en cuenta a la hora de gestionar su posición.

Podéis inicializar los valores del rectángulo como os plazca, yo lo he establecido como un rectángulo de 10×10 píxeles situado en la posición (100, 100) de la pantalla. En este punto ya tenemos todo lo necesario para meternos de lleno en el game loop, y lo primero antes de entrar en un bucle es controlar la salida del mismo. Crearemos una variable booleana para tal fin. Usaremos un bucle del tipo while cuya condición sea cierta al menos la primera vez.

Ahora lo que tenemos que hacer es empezar a gestionar la entrada y decidir que ocurrirá para cada diferente entrada. Las condiciones de salida de nuestro programa serán que se pulse la tecla escape o el botón de cerrar la ventana.

Quizás os parezca extraño que empiece con un while. Lo que pasa es que SDL_PollEvent(SDL_Event *) devuelve 1 mientras haya elementos en cola y los almacena en la variable evento, que por cierto ya debería estar declarada en su lugar correspondiente. El tipo de evento SDL_QUIT es la pulsación del botón de la ventana. La otra condición es que una tecla sea pulsada y que ésta sea la de escape. Ya que el soltar una tecla también es un evento la aclaración de que es solo al pulsar no es gratuita.

Ahora mismo ya es funcional el programa, aunque no está acabado aun. Si lo compiláis y ejecutáis os debería salir una ventana en negro de la resolución que hayáis elegido, que se cerrará como hemos dicho. Pero aún falta el punto que se mueve. Para saber que teclas están pulsadas usaremos un puntero a Uint8, en realidad un array, que almacenará el estado actual del teclado. En este array se sustituye la etiqueta de SDL correspondiente a esa tecla y devuelve el valor 1 si está pulsada y 0 en caso contrario. Sabiendo esto no os será complicado hacer una estructura condicional que modifique la x e y del punto, aunque aún no se verá nada y la bola se saldrá por los bordes. Lo de los bordes tiene fácil solución, para lo otro tendremos que pasar a la sección de salida del game loop.

Cabe destacar que en el momento que se detecta movimiento pintamos con negro la región en la que se encontraba el punto con anterioridad, a no ser que lo que queráis sea una estela. Este trabajo es desempeñado por la función SDL_FillRect(SDL_Surface *, SDL_Rect *, Uint32 color), el primer valor es un puntero a la superficie de destino, el segundo la dirección al área rectangular a colorear y el tercero el color deseado, para definir el color usamos la función SDL_MapRGB(SDL_PixelFormat *, Uint8 r, Uint8 g, Uint8 b). Los últimos 3 parámetros nos son familiares, el primero es el formato de píxel, que lo tomaremos de la superficie que creamos como pantalla.

Si habéis conseguido mover el punto os daréis cuenta que se mueve endiabladamente rápido, esto es porque no hemos establecido un retardo entre ciclos. Esto se soluciona con SDL_Delay( Uint32 ms), que retrasa los ciclos el número de milisegundos indicados por el parámetro. No pongáis menos de 10 porque es posible que no lo haga bien.

Voy a colgar el programa finalizado para que podáis seguir más fácilmente este capítulo, esta aplicación pese a ser de gran simplicidad ayuda mucho a fijar conceptos y podéis jugar mucho con ella para crear efectos diversos. En el próximo capítulo empezaremos el desarrollo de un juego en toda regla, sin IA por ahora para facilitar las cosas, aun no está decidido cual será pero posíblemente sea un clon del buscaminas.

Aquí tenéis el código fuente y el ejecutable ya compilado. El ejecutable no funcionará si no habéis copiado SDL.dll a la carpeta system32 o la misma en la que se ejecute.