===== Allegro — Timers =====

Dans cet article nous étudions les Timers, et comment les utiliser pour réguler notre boucle d'affichage.

==== Que sont les Timers? ====

Ce sont des sources d'events qui déclenche un event sur un intervalle de temps régulier.

==== Pourquoi en ai-je besoin ====

Ils peuvent être utilisés pour mettre à jour la boucle principale de votre jeu, ce qui vous permet de tourner à un certain FPS, ou ils peuvent être utilisés pour savoir quand une animation à besoin d'être mise à jour, etc. 

==== Exemple basique ====

Construit à partir de l'[[allegro:events#Basic_Example|exemple précédent]] afin d'avoir une fréquence d'update stable.

<file c main.c>
#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;
   ALLEGRO_EVENT ev;
   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)
   {
      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_is_event_queue_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;
}
</file>

==== Détails ====

Cette fois-ci nous avons quelques nouveautés et quelques modifications.

<code c>const float FPS = 60;</code>
C'est le ratio pour limiter la fréquence d'update.

<code c>   timer = al_create_timer(1.0 / FPS);</code>
On initialise notre timer à **1.0 / FPS** seconde par tick.

<code c>   al_register_event_source(event_queue, al_get_timer_event_source(timer));</code>
On dirige la source d'events du timer vers notre queue de manière à les récupérer plus tard.

<code c>   al_start_timer(timer);</code>
évident? cette instruction démarre notre timer sans laquelle nous aurions aucun events.

<code c>      al_wait_for_event(event_queue, &ev);</code>
Nous modifions un peu. Maintenant que nous avons régulièrement des events, nous n'avons plus besoin de nous inquiéter d'être bloqué par cette fonction. **al_wait_for_event** attendra un event pour toujours.

<code c>      if(event.type == ALLEGRO_EVENT_TIMER) {
         redraw = true;
      }</code>
Ici nous vérifions que nous avons bien affaire à un event de type Timer, si c'est le cas, nous demandons de redessiner. Si nous devons mettre à jour la logique du jeu, nous devons aussi le faire ici.

<code c>      if(redraw && al_is_event_queue_empty(event_queue)) {
         redraw = false;
         al_clear_to_color(al_map_rgb(0,0,0));
         al_flip_display();
      }</code>
Pourquoi mettre un AND logique ici? Nous devons être sûr que notre queue d'events est vide avant de redessiner à l'écran. Bien sur, ça n'a aucun intérêt maintenant, mais ça en aura pas la suite.

Donc on vérifie si **redraw** est **true**, et si la queue est vide, si les deux sont true, alors peint le display, on échange les buffers, on met redraw à **false**, et le boucle recommence.

Comme dans l'exemple précédent, celui-ci se termine quand vous cliquez sur le bouton //quitter// de la fenêtre.

<code c>   al_destroy_timer(timer);</code>
Désinstalle notre Timer .

Ce qui conclut notre article sur les Timers d'Allegro 5.

[[allegro:events|Précédent]] << [[allegro:start#articles|Sommaire]] >> [[allegro:bitmaps|Suivant]]