Algo muy útil para los proyectos y que los IDE (programas que ayudan a programar) hacen de forma automática, son los makefiles. Make es una orden que se aplica a cualquier tarea donde algunos ficheros deben ser actualizados a partir de otros cuando éstos cambian.

Se basa un un fichero makefile donde se describen las relaciones entre los ficheros que componen el programa y las órdenes necesarias para cada uno de ellos. De forma automática actualiza sólo lo necesario, lo que haya cambiado y no todo.

Joystick
SDL le dedica un subsistema sólo para ello, pero no es le más completo debido a que hay muchos y no siguen un estándar.

Gestión mediante eventos
Los ejes de movimiento del joystick producen el evento de tipo SDL_JoyAxisEvent:

typedef struct{
Uint8 type; // al mover el eje produce SDL_JOYAXISMOTION
Uint8 which; //que joystick
Uint8 axis; //que eje
Sint16 value; //valor del movimiento
} SDL_JoyAxisEvent;

Llegados hasta aquí, me gustaría recordar que nada de esto es mi autoría y viene del Tutorial de libSDL para la programación de videojuegos. Tampoco está escrito a modo de divulgación, sino a modo de constancia de lo aprendido en mi viaje y, por tanto, hasta para mi opinión, es un poco desastre las entradas escritas hasta ahora.

Ratón
Tiene dos tipos de eventos
De movimiento: contiene la posición del puntero, posición relativa respecto al anterior movimiento y si hay botón pulsado y cuál.
De pulsación: muy similar al de teclado.

Y nos vamos a los eventos en SDL, de Tutorial de libSDL para la programación de videojuegos.

La estructura principal es

typedef union{
Uint8 type;
SDL_ActiveEvent active; //tipo de evento
SDL_KeyboardEvent key;
SDL_MouseMotionEvent motion;
SDL_MouseButtonEvent button;
SDL_JoyAxisEvent jaxis;
SDL_JoyBallEvent jball;
SDL_JoyHatEvent jhat;
SDL_JoyButtonEvent jbutton;
SDL_ResizeEvent resize;
SDL_QuitEvent quit;
SDL_UserEvent user;
SDL_SysWMEvent syswm;
} SDL_Event;

Continuamos con el pdf Tutorial de libSDL para la programación de videojuegos y sacándole mucho jugo, ¡cada vez más animado para hacer un juego! ¿Es posible que al terminar el pdf tenga ya uno?

Mapas de bits
Con SDL_Rect definimos el tamaño del cuadrado a copiar y la posición

Cargamos una imagen con el siguiente método, el cual devuelve NULL ante problemas.

SDL_Surface *SDL_LoadBMP(const char *file);

Código!!

Para el que haya echado un vistazo al pdf que sigo, notará que he hecho un copy-paste impresionante, y para colmo de males, no funciona CORREGIDO. Tengo que revisar mejor el código, pero algo hace que se cuelgue y tenga que cerrar por las malas la terminal.

Y seguimos con el tutorial de SDL de Antonio García Alba, las partes I y II por si os lo habéis saltado.

Manejo overlay
Crea un overlay. En caso de error devuelve NULL.

SDL_Overlay *SDL_CreateYUVOverlay(int width, int height, Uint32 format, SDL_Surface *display);

Libera el overlay

void SDL_FreeYUVOverlay(SDL_Overlay *overlay);

Antes de acceder a los datos del pixel, hay que bloquear y después desbloquear.

int SDL_LockYUVOverlay(SDL_Overlay *overlay); //cero si correcto, -1 al contrario void SDL_UnlockYUVOverlay(SDL_Overlay *overlay);

Continuando la entrada anterior sobre el tutorial de Antonio García Alba

Inicialización de librerías adicionales

• SDL_image

#include &ltSDL/SDL_image.h&gt

compilar con -lSDL_image

Otro de los pdf que encontré y hasta ahora el que mejor pinta tiene para ayudarme a arrancar con algún jueguecito y estrenar mi portfolio.

Se titula Tutorial de libSDL para la programación de videojuegos y empieza con mucha teoría sobre SDL acompañado de bastante código de ejemplo para ir practicando. Algo ya había puesto en esta entrada, pero volveré a postearlo para dejar una serie de entradas juntas sobre dicho tutorial.

Intentando programar algo gráfico, me encuentro con este pdf de tutorial sobre SDL que parece muy bueno y estoy siguiendo conjuntamente con el de Nacho Cabanes de un pdf encontrado en la librería de Open Libra y tras mucho buscar, encontré una versión más actualizada en su página web.

No voy a pararme en los pdf porque no he terminado de leerlos y tengo intención de profundizar en ellos más adelante, aquí dejo lo que me he enterado del SDL.

Es decir, esos juegos "amateur", que hacen aficionados y sin un duro, véase, yo mismo. Asi que vamos por lo que creo que ya es lo último que puedo sangrar a Advertainmen, los juegos indie. La serie de entradas la verdad es que me decepciona, simple teoría que se parece a la ya vista, y que se ajusta a cualquier proyecto de videojuego, no solo indie.

Lo primero es tener claro que vamos a estar limitados, asi que nada de pensar ¿y esto cómo podría hacerlo? Tenemos que hacer que nuestro universo sea fácil de hacer y que esté integrado en nuestra historia.

¡Si! ¡Un poco más de movimiento! En Advertainmen tienen una serie de post para realizar juegos en móvil con java, concretamente en 2D. Java es un lenguaje que domino, y móvil tengo uno a mano para pruebas... ¡Todo listo!

Bueno, quizás no me ponga a programar ya mismo, en primer lugar porque habrá que planificar un poco, y en segundo lugar porque sigo sin tener el ordenador, el cual está más grave de lo que pensaba, pobrico. También tengo que indicar que los post son de 2009, es decir, unos cuantos años ya y casi seguro ya no se aplica hoy en día lo que nos cuente. Intentaré contrastar con la actualidad lo que aprenda.

Continuando con la inteligencia artificial de parte de Advertainmen, pasamos a algo interesante, el comportamiento del jefe final, el cual es un enemigo, pero normalmente de poderes y morfología impresionantes.

Definir el entorno del jefe final
Para derrotar a un jefe final suele ser interesante interactuar con el entorno, aunque el jefe se empeñe en destrozarlo y tirarnos trozos de ello. Suelen aparecer en sitios muy acotados y definidos, pero no se podrá salir de la zona. Por eso es fundamental que tanto en el diseño de mapa como en el argumento pase algo para poder estar bien encerrados.

Inteligencia Artificial, materia que dí en mi carrera y la verdad... si estáis pensando en androides o máquinas con código la mar de interesante, ya podéis olvidarlo porque no es lo que parece y encima me pareció un aburrimiento. Pero en videojuegos se ve más interesante y os pongo en un par de entradas la serie de Advertainmen sobre el tema.

Cuando hablamos de IA hay 2 personas que se ponen a temblar, el programador que tiene que programarla y el diseñador que tiene que definir el comportamiento de los npcs.

Y ya, con esta entrada terminamos la saga (I, II, III) hablando de los juegos en línea. ¡Mañana más material interesante y menos tocho!

Diseño de juego en linea persistentes
Son juegos completamente en línea y están pensados para permitir jugar a un gran número de jugadores (millones), y es por ello que usan suscripciones mensuales para el mantenimiento de los servidores.

Tercera parte...

Videojuego a Videojuego
Se produce entre consolas/ordenadores por la red. Se presupone conocimientos de redes, TCP/IP, TCP y UDP entre otros, asi que me salto la parte de arquitectura de internet y otros conceptos.

Programación de la red
Necesitamos crear las conexiones y definir la comunicación entre aplicaciones. Opciones:

Continuamos con el "resumen"... Todavía queda al menos otra entrada y ¡pensad que estoy resumiendo 114 páginas!

Videojuego a Usuario

Pantalla
El juego se ha de diseñar pensando en el público objetivo. Podemos usar el esquema de la Asociación para la Interacción Persona Ordenador (AIPO).

De esta entrada, había quedado pendiente una segunda parte. Bueno, pues he terminado releyendo el libro y mandando a la mierda el asco de resumen que me estaba saliendo, asi que repito de nuevo la primera parte y pongo el resto en sucesivas entradas, esperando que esta vez el resumen esté bastante decente.

Algunas partes, como la historia, lo he quitado. Y como no deja de ser un resumen, si os parece un contenido interesante, dadle un vistazo al libro. y aviso, tanto en esta entrada como en las otras, puede ser un tochazo aburrido. ;)

Si mal no recuerdo, habíamos visto por algún lado qué era esa palabra. Pero por si acaso, es la interfaz de comunicación con el jugador durante el juego. Quedan menos cosas por ver en Advertainmen, y ahora toca La creación de un HUD y como suele ser habitual, yo dejo aquí una especie de resumen y os aconsejo que vayáis al post original.

Denominamos HUD a todo lo que se “pinta” por encima del render del juego y que le da información al jugador, es decir, todo lo que vemos en pantalla de información: la vida, la energía, la munición que me queda, el mini mapa, la vida de los enemigos, etc..

Esta entrada es un complemento a la teoría del diseño de niveles de un videojuego.

Sacado de Advertainmen en su par de entradas, con otro punto de vista, lo explica con una analogía y menos tecnicismos, con algunos detalles y consejos más, para tener un poco más claro qué es lo que hay que hacer.

Imaginaos que sois un Master de un juego de Rol, imaginad un escenario (unas mazmorras repletas de esqueletos asesinos y de bestias inmundas) y empezamos a crear jugabilidad.