Timer encapsulaton

Aniconic

Hey there everyone,

I've been working on encapsulating some allegro functions. Though I do have some experience with programming, I'm not as confident as I'd like to be. that being said I'm looking for some opinions on what I have for my timer class. I wrote the member function definitions in the class's header file because it's functions are pretty short and sweet, and I don't plan on changing them much. I'd like to keep all of the smaller components as concise as possible.

#SelectExpand
  1#ifndef _TIMER_H
  2#define _TIMER_H
  3
  4#include <allegro5/allegro5.h>
  5
  6class timer {
  private:
          ALLEGRO_TIMER *t;
          int lastTime;
          
  public:
         /*default constructor*/
         timer() {
             t = al_create_timer(1); 
             lastTime = 0;
         }
         
         /*re-installer function*/
         void init(double ticksPerSecond) {
              al_destroy_timer(t);
              t = al_create_timer(1.0/ticksPerSecond);
         }
         
         /*interface functions*/
         void start() {al_start_timer(t); }
         void stop() {al_stop_timer(t); }
         bool running() {return al_get_timer_started(t); }
         int count() {al_get_timer_count(t);}
         bool tick() {
              int curTime = timer::count();
              if (curTime > lastTime) lastTime = curTime;
              else return false;
              return true;
         }
         
         /*default destructor*/
         ~timer() {al_destroy_timer(t);}
 38};
 39
 40#endif

Essentially, I plan to glue instances of this class together with other components to create new objects with a common "entity" interface, with the "tick" function being called in it's parent object's update function.

I was just going to add the ticker to an event queue, but I wanted to keep it as independent as possible.

Here's an example of how I was planning on using it as a countdown timer:

#SelectExpand
  1#include <stdio.h>
  2#include <allegro5/allegro.h>
  3#include "timer.h"


  6int main(int argc, char **argv)
  7{
 ALLEGRO_DISPLAY *display = NULL;

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

 display = al_create_display(640, 480);
 if(!display) {
    fprintf(stderr, "failed to create display!\n");
    return -1;
 }
 timer ticker; //default constructor creates timer defaulting to 1 second
 int counter = 1000; //countdown time

 al_clear_to_color(al_map_rgb(0,0,0));
 
 ticker.init(1000); //reinitialize to tick every millisecond

 al_flip_display();
 
 ticker.start();
 while (counter != 0) {
     if (ticker.tick()) counter--;
 }

 al_destroy_display(display);
 
 //ticker automatically stopped and destroyed.

 return 0;
 39}

I personally think it will work quite well, but then again this is my first attempt with the Allegro library, and I am using it to sort of expand my horizons. I suppose my primary concern is any leaks I may have missed, as well as any performance related issues I didn't consider. I was also wondering if there was a way to allow an instance of this class to be created and then added to a specified event queue without giving it an event queue argument? I doubt it, but I would appreciate any suggestions for possible solutions.

Also, I'd like to take a second to thank Schyfis and furinkan for their feedback on my previous thread. Although I didn't have time to post it earlier before the topic was locked, I really appreciate your feedback. The suggestions you guys offered gave me a lot of ideas for approaches to solving the aforementioned problems.

Edgar Reynaldo

That's not the best way to use an ALLEGRO_TIMER. You're polling it constantly, which will use 100% cpu every time you do so. Use an event queue and wait for a timer event. That way the cpu can sleep, and your prog won't do anything until it gets a timer event.

Aniconic

What if instances of this class were only used within an entity's update function, which is only called after a global FPS timer event?

Then would it be appropriate to use?

My problem is that entities might not always have a reference to the event queue. Unless its beneficial to somehow have more then one?

Edgar Reynaldo

Entities in your program shouldn't have any idea what an event queue is nor have access to one. Pipe the events from the queue to your entities in a HandleEvent function or similar or use an Update function that you call when you receive a timer event. Register your timer with an outside event queue and then monitor that queue for events, dispatching them to your engine / entities from there.

Thread #613910. Printed from Allegro.cc