Classe de Timer para Allegro

Como eu disse no artigo de Timer no Allegro, eu vou postar uma classe que eu fiz para auxiliar o trabalho com timers.

Para utilizar, basta fazer assim:

CTimer *timer1 = new CTimer(SECS_TO_TIMER(1)); // Timer para 1 segundo

Eu criei o timer, porém ele ainda não está contando, para iniciar ele, faça assim:

timer1->Start();

Para pausar:

timer1->Pause();

Para pegar a contagem:

timer1->getCount();

Para resetar o contador:

timer1->Reset();

Vou citar também o método getStatus, que retorna o status atual do Timer, TIMER_PAUSED, se ele estiver pausado e TIMER_STARTED se ele estiver funcionando.

Está bem simples, porém é bem útil! =D

Aqui está o código:
CTimer.h

/***************************************************\
**            Desenvolvido por CrociDB             **
**                                                 **
** Voce pode usar a vontade este codigo, desde que **
**  coloque os devidos creditos ao autor original. **
**                                                 **
**   Nao me resposabilizo por seus atos com este   **
**                      codigo.                    **
**                                                 **
\***************************************************/

#include <allegro.h>

#define TIMER_PAUSED                0
#define TIMER_STARTED               1

class CTimer
{
private:
    int         iCount;
    int         velocidade;
    int         status;

    static void update(void *param);

public:
                CTimer(int vel);
                ~CTimer();

    void        Start();
    void        Pause();
    int         getCount();
    void        Reset();
    int         getStatus();
    void        desc();
};

CTimer.cpp

/***************************************************\
**            Desenvolvido por CrociDB             **
**                                                 **
** Voce pode usar a vontade este codigo, desde que **
**  coloque os devidos creditos ao autor original. **
**                                                 **
**   Nao me resposabilizo por seus atos com este   **
**                      codigo.                    **
**                                                 **
\***************************************************/

#include "CTimer.h"

CTimer::CTimer(int vel)
{
    this->velocidade = vel;

    iCount = 0;
    status = TIMER_PAUSED;

    LOCK_VARIABLE(iCount);
    LOCK_FUNCTION(update);
}

void CTimer::update(void *param)
{
    CTimer *pthis = (CTimer*)param;
    ++(pthis->iCount);
} END_OF_FUNCTION(update)

void CTimer::Start()
{
    install_param_int(CTimer::update, this, velocidade);
    status = TIMER_STARTED;
}

void CTimer::Pause()
{
    remove_param_int(CTimer::update, this);
    status = TIMER_PAUSED;
}

int CTimer::getCount()
{
    return this->iCount;
}

void CTimer::Reset()
{
    this->iCount = 0;
}

int CTimer::getStatus()
{
    return status;
}

void CTimer::desc()
{
    this->iCount--;
}

CTimer::~CTimer()
{
    remove_param_int(CTimer::update, this);
}

Eu uso ele em quase todos os meus projetos, e você pode usar a vontade! hihihi

Valeu, qualquer dúvida posta aeeew! =D

7 Respostas

  1. A minha é bem parecida, mas eu na interrupção instalada, em vez de incrementar uma unidade a variável que “conta” o tempo, eu somo ao valor dela velocidade. Desse jeito iCount, armazena o valor “real” do tempo passado. Não sei se me expliquei bem.

  2. Ah Tá! Entendi!

    Dessa forma também é bem interessante!

    O que eu esqueci de colocar nessa classe, são métodos para mudar e pegar a velocidade… hehehe

    Vlw

  3. Bacana a classe, mas eu tenho uma dica. Ao invés de um #define para TIMER_PAUSED/STARTED, seria mais interessante criar um tipo enum. Dessa forma o código se encaixaria melhor no padrão C++. Ficaria algo mais ou menos assim:

    typedef enum TimerStatus
    {
    TIMER_PAUSED,
    TIMER_STARTED
    };

    Bem, é só uma dica e você, obviamente, não tem que mudar nada. Espero que não me ache intrometido demais pra ficar palpitando no teu código😛

  4. Pow Diego, valeu mesmo pela dica! Eu tinha pensado mesmo nisso quando postei aqui (por que faz um tempo que eu fiz essa classe), mas me deu preguiça de mudar! hehehe

    A dica está aí, quem quiser, sinta-se a vontade em mudar! =D

    Valeu mesmo cara!

  5. O iCount não conta! Fica sempre no zero…
    Eu criei um objeto CTimer e usei o Start()
    mas quando fui pegar o iCount retorna
    sempre ZERO! =/

  6. Hmm… você deve estar fazendo algo errado.

    Verifique o intervalo que está colocando no timer, talvez seja muito grande.

    E para pegar o resultado, utilize o getCount().

    Qualquer dúvida, só postar.

  7. Hmm, talvez eu esteja colocando o objeto
    em algum lugar errado?
    O intervalo é SECS_TO_TIMER(1), o objeto
    é instanciado e inicializado (Start()) dentro
    do main após o install_timer()…

    Se você pudesse me enviar uma utilização
    da classe, tenho 99% de certeza que eu
    que to errando hehe.. vlw

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: