Allegro 5 juego: juego de bucle que se ejecuta a velocidad constante?

Question

¿Cuál es la mejor forma de codificar un bucle de juego en Allegro 5 que siempre se ejecuta a la misma velocidad y que separa correctamente la lógica de dibujo de la lógica de actualización? ¿Debo usar hilos o no? ¿Debo hacer uso del nuevo sistema de eventos Allegro?

Answer 1

Tomado del Allegro wiki:

al_install_timer(1.0/FPS); 

... 

while (1) { 
     al_wait_for_event(queue, &event); 

     /* handle input events */ 

     if (event.type == ALLEGRO_EVENT_TIMER) { 
       handle_game_tick(); 
       need_redraw = true; 
     } 

     if (need_redraw && al_event_queue_is_empty(queue)) { 
       render_last_frame(); 
       need_redraw = false; 
     } 
} 

Si desea saltar marco, omitir el comando render_last_frame() cada vez que se detecta que se está quedando atrás en los marcos (por ejemplo, mediante el uso de la función al_current_time()).

Answer 2

Here es una versión más completa de la respuesta de Allefant (siga el enlace para la explicación detallada, línea por línea):

#include <stdio.h> 
#include <allegro5/allegro.h> 

const float FPS = 60; 

int main(int argc, char **argv) 
{ 
    ALLEGRO_DISPLAY *display = NULL; 
    ALLEGRO_EVENT_QUEUE *event_queue = NULL; 
    ALLEGRO_TIMER *timer = NULL; 
    bool redraw = true; 

    if(!al_init()) { 
     fprintf(stderr, "failed to initialize allegro!\n"); 
     return -1; 
    } 

    timer = al_create_timer(1.0/FPS); 
    if(!timer) { 
     fprintf(stderr, "failed to create timer!\n"); 
     return -1; 
    } 

    display = al_create_display(640, 480); 
    if(!display) { 
     fprintf(stderr, "failed to create display!\n"); 
     al_destroy_timer(timer); 
     return -1; 
    } 

    event_queue = al_create_event_queue(); 
    if(!event_queue) { 
     fprintf(stderr, "failed to create event_queue!\n"); 
     al_destroy_display(display); 
     al_destroy_timer(timer); 
     return -1; 
    } 

    al_register_event_source(event_queue, al_get_display_event_source(display)); 

    al_register_event_source(event_queue, al_get_timer_event_source(timer)); 

    al_clear_to_color(al_map_rgb(0,0,0)); 

    al_flip_display(); 

    al_start_timer(timer); 

    while(1) 
    { 
     ALLEGRO_EVENT ev; 
     al_wait_for_event(event_queue, &ev); 

     if(ev.type == ALLEGRO_EVENT_TIMER) { 
     redraw = true; 
     } 
     else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { 
     break; 
     } 

     if(redraw && al_event_queue_is_empty(event_queue)) { 
     redraw = false; 
     al_clear_to_color(al_map_rgb(0,0,0)); 
     al_flip_display(); 
     } 
    } 

    al_destroy_timer(timer); 
    al_destroy_display(display); 
    al_destroy_event_queue(event_queue); 

    return 0; 
}