Gioco Allegro 5: loop di gioco che funziona a velocità costante?

Question

Qual è il modo migliore per codificare un ciclo di gioco in Allegro 5 che funziona sempre alla stessa velocità e che separa correttamente la logica di disegno dalla logica di aggiornamento? Dovrei usare discussioni o no? Dovrei utilizzare il nuovo sistema di eventi Allegro?

Answer 1

tratto dal wiki allegro:

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; 
     } 
} 

Se volete cornice saltare, saltare il comando render_last_frame() ogni volta che si rileva che sono in ritardo nei telai (ad esempio utilizzando la funzione al_current_time()).

Answer 2

Here è una versione più completa della risposta di Allefant (seguire il link per la dettagliata spiegazione riga per riga):

#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; 
}