Cuestiones de FPS

Dado la pequeña modificación que hice en uno de los proyectos (concretamente en el de minisoccer), me gustaría comentar el tema del control de tiempo en las aplicaciones a tiempo real.

Hasta ahora, siempre había hecho uso de una determinada velocidad constante de juego y FPS. Es decir, el simple bucle que en cada iteración hace un "sleep" si dicha iteración se realiza en muy poco tiempo. Esto nos asegura que el juego se reproduzca a la misma velocidad en cualquier ordenador (no es del todo cierto), pero el renderizado se realiza las mismas veces que la física del juego.

const int FPS = 60;
const int DT = 1000 / FPS;
int lastTime, frameTime;

bool running = true;
while (running) {
    lastTime = getTicks();

    update();
    render();

    frameTime = getTicks() - lastTime;
    if (frameTime < DT)
        sleep(DT - frameTime);
}

Pero de este modo, limitamos las capacidades de un buen hardware cuando seguramente podría ser capaz de ejecutar el juego a una velocidad mayor. Por eso a menudo los programadores usan el tiempo de cada frame (frameTime) para actualizar la física usando lógicas parecidas a esta:

x = x + speed * frameTime

Así se aplica la integración de Euler. Pero no es eso a lo que quiero llegar. Gracias a los excelentes artículos publicados en esta y esta otra página web podemos llegar a implementar un bucle en el que la velocidad del juego es totalmente independente de los FPS. En ese caso la física podríamos calcularla 25 veces por segundo (está estudiado que generalmente es suficiente, incluyendo chequeo de collisones etc.) mientras que el renderizado se realiza en cada frame.

No voy a entrar en la implementación ya que no tiene mucha complicación y las fuentes aportadas tienen suficiente información para entenderlo (en inglés). Cabe destacar que en la renderización se hace uso de un nuevo valor que se usa para interpolar la posición correcta de las instancias y así se consigue una animación realmente suave. Yo mismo he conseguido un excelente resultado asi que animo a hacer uso de este método a todo programador, cualquier duda podeis consultarmelo.

Fuentes:
Koonsolo
Gafferongames

P.D: Las dos páginas usan métodos distintos para calcular el valor usado para la interpolación; personalmente prefiero el método usado por gafferongames que calcula dicho valor mediante el uso del estado anterior y actual de las instancias.

Editor de mapas

Tal y como prometí, he decidido mostrar ahora el editor de mapas que estuve desarrollando. Aunque todavía está muy verde se puede apreciar claramente su buen comportamiento frente a la creación de niveles sencillos. 

Debido a la reciente incorporación, como ya comenté, de la nueva API gráfica en SFML me he obligado a suspender el desarrollo del motor (ergo del editor de mapas) para comenzar a construir a partir de éste otro nuevo motor más específico respecto a las nuevas características de la nueva API.

Pero gracias a las estupendas modificaciones en la creación de formas y polígonos,  me será más fácil desarrollar el sistema de detección de collisiones (que viene siendo lo que básicamente estaba desarrollando en este momento).

Como se me hace dificil explicar exactamente el comportamiento del editor, lo dejo en vuestras manos para cualquier comentario que querais hacer. Notar que aún quedan muchos aspectos por desarrollar, pero ésa es la idea básica.

Los controles son sencillos y son detallados en el panel de ayuda que aparece al pulsar la tecla H. Por mucho que se puedan guardar los niveles en un archivo XML, no recomiendo comenzar ningún proyecto en este prototipo ya que la nueva versión no será compatible con la vieja estructura del XML.

Recientemente he comenzado con la nueva implementación, asi que no dispongo de una compilación para los equipos Linux.

Map Editor: Descargar

P.D: Siento el tamaño de la descarga, que es debido a la cantidad de imagenes de gran calidad sacados de Braid que he incorporado como ejemplo.

Saludos.

Programando un Game Engine

Desde hace tiempo he mantenido la ilusión de crear algún dia un game engine genérico para cualquier juego que tuviera intenciones de comenzar a desarrollar. A lo largo de estos meses he ido desarrollando pequeñas partes del posible motor, como por ejemplo el sistema de partículas que mostré.

Gracias a la librería SFML el proceso del desarrollo de mi motor está siendo satisfactorio, pero todavía queda muchísimo por hacer. Mi intención es prepararlo para a continuación crear un buen proyecto cuyo guión fue terminado hace casi 1 año.

El motor se dividirá en distintos modulos que estarán preparados para manejar el estado del juego, controlar la fisica de los objetos, controlar el renderizado en 2D y proporcionar clases y funciones para la detección de colisiones entre poligonos, manejar sprites con animaciones etc. Por supuesto, incluirá un editor de mapas casi completado que mostraré más adelante.

Estas son algunas de las clases principales que contiene el motor actualmente, sin considerar que existen clases más pequeñas sobretodo relacionados con el módulo de fisica.

Game

    Window

        Camera2D

    Event

    GameStateManager

        GameState

Timer
Error
ResourceManager

    TextureManager

    FontManager

    SoundManager

    MusicManager

CollisionManager

    CollisionShape

    Polygon

Sprite
    AnimatedSprite
Map

    Tile

    CollisionShape

Dado que esta información no aporta mucho conocimiento acerca de este motor, en otra ocasión mostraré su funcionamiento con diversos ejemplos y partiré por enseñar el editor de mapas.

Saludos.

Particle Maker

Como ya prometí en la entrada anterior, os voy a mostrar un pequeño prototipo del motor de particulas básico que programé hace un tiempo. Junto con el sistema de particulas cree un pequeño editor con funcionalidades mínimas para poner en marcha el motor y ver el resultado.

Es el motor de particulas que usé para crear los algunos de los efectos en DBZBX.

La interfaz permite cambiar parametros del tipo de particula para poder darle el aspecto deseado a nuestro efecto. Pero al ser un prototipo, esta interfaz no ofrece todas las funcionalidades que ofrece el motor. Tales como; poder cargar imagenes diferentes para las particulas, aplicar gravedad, interpolación entre 2 colores en lugar de 3, cambiar la región en la que se crean las particulas, modificar la cantidad de particulas, añadir emisores, usar distintos tipos de particulas en un mismo sistema (por ejemplo para poder crear particulas distintas a la muerte de otras) etc.

Por ejemplo, este efecto de fuego no lo podríamos realizar con la interfaz visual, ya que no nos permite cambiar la región en la que se crearan las partículas, ni la cantidad de partículas que se crearán en cada frame.

Para terminar, os dejaré el editor en vuestras manos por si quereis salsear con él. Aquí teneis los controles:

• Flechas derecha/izquierda:  Ver ejemplos (notar que el único sistema de particulas editable es el primero, en un principio el "punto negro").
• Clic y mover ratón: Mover el centro del sistema de partículas.
• Espacio: Cambiar el color de fondo aleatoriamente.

Particles Maker version Windows: Descargar

Dado que se trata de un prototipo antiguo, puede contener errores, asi que como siempre, se aceptan sugerencias o incluso, reclamaciones para la versión de Linux.

Un saludo.