Programación de Videojuegos

Por Gorka Suárez

Apartados del curso

• Conceptos teóricos sobre el desarrollo de un videojuego.

• Introducción a la API multiplataforma SDL.

Conceptos teóricos

• Organización de un videojuego.

• El bucle principal.

• La sección de pintado.

• La sección de la lógica.

Organización de un videojuego

Inicializacióndel programa

Finalizacióndel programa

Bucleprincipal

Núcleo de datosdel videojuego

Cargar datos

Libera los datos

Inicialización del programa

• Activar el sistema de video, entrada, sonido, etc...

• Cargar ficheros de configuración.

• Carga de las texturas necesarias durante toda la ejecución del programa.

Bucle principal

• Llamar al pintado de la pantalla.

• Ejecutar un ciclo de la lógica.

Rutina de pintado

Rutina de la lógica

Núcleo dedatos

Leer datos

Leer datos

Modificar datos

Código de ejemplo

void BuclePrincipal (tNucleo * Nucleo){ Uint32 Intervalo = 0; Uint32 TiempoAnt = 0;

do{ //Tomamos el tiempo de inicio TiempoAnt = DarTicks(); //Pintamos la pantalla PintarPantalla(Nucleo); //Calculamos cuanto tiempo ha tardado Intervalo = DarTicks() - TiempoAnt; //Y ejecutamos la lógica en base al tiempo transcurrido EjecutarLogica(Nucleo, Intervalo); }while(Nucleo->Partida.EstadoDelJuego != ESTSAL);}

La sección de pintado

• Pintar el fondo.

• Pintar entidades del juego.

• Pintar interfaz del juego (HUD).

• Actualizar la pantalla.

La sección de la lógica

• Actualizar la entrada del juego (teclado, ratón, etc...)

• Interpretar la entrada del juego.

• Ejecutar la IA de todas las entidades vivas del juego.

Introducción a la SDL

• ¿Qué es la SDL?

• Funciones para la inicialización.

• ¿Qué son las “SDL_Surface”?

• Funciones para manejar imágenes.

• Funciones para la gestión del teclado.

• Como compilar SDL bajo linux.

¿Qué es la SDL?

La SDL es una API multiplataforma, que se puede emplear para el desarrollo de programas que requieran manejo multimedia (gráficos, sonido, entrada, cd-rom, etc...)

Creada por Sam Lantinga, para portar juegos como Civilization Call to Power, de windows a linux. Se puede encontrar en http://www.libsdl.org/

Funciones para la inicialización

• SDL_Init

• SDL_VideoModeOK

• SDL_SetVideoMode

• SDL_Quit

SDL_Init

int SDL_Init (Uint32 flags);

Inicializa la API SDL. Devuelve -1 en caso de que exista algún error. Su argumento flags sirve para indicar los sistemas que deseamos activar (encadenados con el operador | ):

SDL_INIT_VIDEO = Sistema que controla el tema de los gráficos.

SDL_INIT_AUDIO = Sistema que controla el tema del audio.

SDL_INIT_TIMER = Sistema para el control del tiempo.

SDL_INIT_EVERYTHING = Para inicializarlo todo.

SDL_VideoModeOK

int SDL_VideoModeOK (int width, int height, int bpp, Uint32 flags);

Comprueba si está soportado el modo de video indicado por el usuario, en la tarjeta de video del ordenador. Si no está soportado dicho modo de video, nos devolverá 0, en cualquier otro caso nos devolverá la profundidad máxima soportada por el modo de video indicado. Sus parametros son:

width = Ancho de la resolución de la pantalla.

height = Alto de la resolución de la pantalla.

bpp = Numero de bits de profundidad para el color (8, 16, 24, 32).

flags = Propiedades que va a tener el buffer principal de la pantalla.

SDL_SetVideoMode

SDL_Surface * SDL_SetVideoMode (int width, int height, int bpp, Uint32 flags);

Activa el modo de video que le indiquemos. Nos devolverá NULL en caso de error, o la dirección de memoria donde se encuentra el buffer principal de la pantalla. Los flags que podemos usar son:

+ SDL_SWSURFACE: Que use la memoria RAM normal.

+ SDL_HWSURFACE: Que use la memoria RAM de la tarjeta de video.

+ SDL_DOUBLEBUF: Que use doble buffering.

+ SDL_FULLSCREEN: Que la aplicación sea a pantalla completa.

SDL_Quit

void SDL_Quit (void);

Finaliza todos los sistemas que se habían activado de la SDL. Se tiene que llamar siempre que se vaya a salir del programa, para desactivar la SDL.

¿Qué son las “SDL_Surface”?

Son regiones de memoria (buffers), donde se almacenan imágenes. Al cambiar el modo de video, se nos devuelve una región que usará la tarjeta de video, para pintar la pantalla con su información.

¿Qué es el Doble Buffering?

Consiste en una técnica de tener dos buffers para la pantalla, en uno pintamos la escena actual, y del otro la tarjeta de video lee el contenido para pintarlo en la pantalla. Cuando tenemos la escena terminada de pintar, damos el buffer que acabamos de usar a la tarjeta, y tomamos el que acaba de dejar libre, para pintar la nueva escena.

Funciones para manejar imágenes

• SDL_LoadBMP

• SDL_SetColorKey

• SDL_FreeSurface

• SDL_BlitSurface

• SDL_Flip

SDL_LoadBMP

SDL_Surface * SDL_LoadBMP (const char * ruta);

Carga en una surface, un fichero bmp indicado en el parametro ruta.

SDL_SetColorKey

int SDL_SetColorKey (SDL_Surface * surface, Uint32 flag, Uint32 key);

Añade o modifica el color clave para la transparencia de la surface que le pasemos como argumento. “flag” suele valer siempre SDL_SRCCOLORKEY, y “key” es el color que va a actuar como color transparente.

SDL_FreeSurface

void SDL_FreeSurface (SDL_Surface * surface);

Libera el espacio ocupado en memoria por la surface que le indiquemos.

SDL_BlitSurface

int SDL_BlitSurface (SDL_Surface * src, SDL_Rect * srcrect, SDL_Surface * dst, SDL_Rect * dstrect);

Copia en la región “dstrect”, de la surface “dst”, la región “srcrect”, de la surface “src”. En caso de error devuelve -1.

src dst

srcrect

dstrect

SDL_Rect:+ x = Coordenada x.

+ y = Coordenada y.

+ w = Ancho del area.

+ h = Alto del area.

Copiar de src a dst

SDL_Flip

int SDL_Flip (SDL_Surface * buffPantalla);

Intercambia los buffers cuando empleamos la técnica de doble buffering, actualizando así el contenido de la pantalla.

Funciones para la entrada

• SDL_PumpEvents• SDL_GetKeyState• SDL_GetMouseState• SDL_GetRelativeMouseState

SDL_PumpEvents

void SDL_PumpEvents (void);

Actualiza el estado completo de la entrada por teclado y ratón.

SDL_GetKeyState

UInt8 * SDL_GetKeyState (int * numKeys);

Nos da un puntero a la región de memoria, donde SDL tiene almacenado el estado de las teclas del teclado. numKeys normalmente valdrá NULL, para que podamos acceder a todas las teclas. Ejemplo:

UInt8 * teclas = SDL_GetKeyState (NULL);

if(teclas[SDLK_ESCAPE] == 1) printf(“Ha pulsado escape...\n”);

SDL_GetMouseState

UInt8 SDL_GetMouseState (int * x, int * y);

Da las coordenadas (x, y) actuales del ratón. Devolviendo el estado de los botones del ratón. Que se puede comprobar haciendo lo siguiente:

UInt8 Botones = SDL_GetMouseState (&x, &y);

((Botones & SDL_BUTTON(SDL_BUTTON_?)) == 1) -> Indica si está pulsado un botón o no. Los diferentes botones que hay son: SDL_BUTTON_LEFT, SDL_BUTTON_MIDDLE, SDL_BUTTON_RIGHT, SDL_BUTTON_WHEELUP, SDL_BUTTON_WHEELDOWN.

SDL_GetRelativeMouseState

UInt8 SDL_GetRelativeMouseState (int * rx, int * ry);

Da las coordenadas relativas (x, y) actuales del ratón.

Como compilar bajo linux

Para compilar bajo linux no hace falta realmente mucho trabajo. Tan solo hacernos el fichero makefile, y cuando vayamos a llamar al compilador para generar el ejecutable, enlazando todos los ficheros objeto, hemos de añadir lo siguiente:

`sdl-config --cflags --libs`

Como ejemplo, en el caso de que solo tuvieramos un fichero fuente, el comando quedaría tal que:

gcc `sdl-config --cflags --libs` -o prueba prueba.c