
	Conheça a iniciativa da Biblioteca dos Desenvolvedores


	Índice da Biblioteca


	Área dos Usuários


	Fórum de Discussão

Controle de Tempo

Todas as linguagens de programação tem acesso a algum componente ou controle de tempo.
No windows, desde que a janela é aberta, o sistema operacional começa a contar o tempo que ela esta aberta em clocks de máquina.

Poder usar esses componentes de tempo é muito importante em qualquer jogo. Eles servem para fazer animações, controlar o tempo de jogabilidade ou mesmo o tempo de alguma fase.

VOCÊ PRECISA SABER...

Para usar o controle de tempo do allegro, precisamos conhecer como funciona um ponteiro para função.

http://www.bdjogos.com/adrw/c/ponteirofuncoes.htm

DICA...

As rotinas de tempo são utilizadas para substituir as paradas de código "comando rest()" ou os gotos do basic.
Por isso não é muito aconselhável utilizar o comando rest() em seu jogos.

install_timer

Esta função precisa ser chamada no ínicio do programa para que seja habilitado a utilização de timers do allegro.
Funciona assim como o install_keyboard().

remove_timer

Remove todo e qualquer controle de tempo. Esta função é chamada automaticamente no final do programa pelo comando allegro_exit();

install_int

Esta é a nossa função chave, esta função serve para instalar um timer handler.
Ela possuí dois parâmetros:

int install_int(void (*proc)(), int speed);

O primeiro é um ponteiro para uma função.
No primeiro parametros você precisa informar o nome de uma função que é uma função que retorna um void sem parametros que será executada várias vezes no tempo determinado pelo segundo parametro.

E o segundo é a velocidade do contador de tempo em milisegundos, onde 1 segundo é igual a 1000 milisegundos.

VOCÊ PRECISA SABER...

O que é um handler ?

Imagine um Handler como um ponteiro, só que ele não aponta para um endereço de memória e sim para um serviço ( que pode ser um serviço de seu programa, de outro programa ou do sistema operacional ).

VOCÊ PRECISA SABER...

Chamar novamente a função com o primeiro parametro igual faz com que o handler timer seje recriado ( havendo modificação do segundo parametro ), substituindo assim o controlador de tempo anterior.

Desta forma, não podemos ter dois handlers de tempo para uma mesma função.

Exemplo:

No exemplo abaixo.. fazemos com que uma variável seja incrementada apos 5 segundos.

Como esta função é controlada pelo hardware, ela pode funcionar contando o tempo mais rapido em alguns computadores ou o tempo mais lento em outros. Veremos como usar macros para controlar isto.

CÓDIGO...

#include <allegro.h>

int vcontador;

// prototipo
void contador();

int main()
{
   allegro_init();
   set_color_depth(16);
   install_keyboard();
   set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 640, 480, 0, 0);

   install_timer();
   install_int( contador, 5000 );


   int vcontador = 0;

   // Laço principal
   while( !key[KEY_ESC] )
   {

      vcontador = ::vcontador;
      clear( screen );

      textprintf_ex( screen, font, 10, 10, makecol(255,0,0), -1, "Variavel Contador: %d", vcontador );

      vsync();
   }


   allegro_exit();
   return 0;
}
END_OF_MAIN();

void contador()
{
   ::vcontador++;
}

FIM DO CÓDIGO

install_int_ex

Esta é uma função modificadora da função original.
Ela aceita parametros personalizados e também tem sua velocidade controlada pelo hardware( clock ticks ).

VOCÊ PRECISA SABER...

Clock Tick é a menor unidade reconhecida por um dispositivo computacional.

Geralmente um clock tick se refere ao sistema de clock principal, que pode rodar a 66MHz ou,
66 Milhões de clock ticks ( ciclos do processador ) por segundo.

Computadores modernos rodam muito mais rápido que 66MHz mais todo PC pode executar apenas 1 instrução em 1 clock tick ( ciclo ).

O Allegro nos deixa converter o formato de hardware com a ajuda dos seguintes macros, que podem ser utilizadas como o segundo parametro:

SECS_TO_TIMER(secs) - Pega o número em segundos entre cada clock tick

MSEC_TO_TIMER(msec) - Pega o número em milisegundos entre cada clock tick.
Usar este parametro deixa a função install_int_ex igual a função install_int.

BPS_TO_TIMER(bps) - Pega o número de clock tick a cada segundo

BPM_TO_TIMER(bpm) - Pega o número de clock tick a cada minuto

Exemplo:

// a cada 10 segundos
install_int_ex( funcao1, SECS_TO_TIMER(10) );

// a cada 10 segundos ( 10000 milisegundos )
install_int_ex( funcao1, MSEC_TO_TIMER(10000) );

// a cada 1000 clock tick por segundo
install_int_ex( funcao1, BPS_TO_TIMER(1000) );

// a cada 100000 clock tick por minuto
install_int_ex( funcao1, BPM_TO_TIMER(100000) );

VOCÊ PRECISA SABER...

Se você usa um compilador que roda em DOS modo protegido como o DJGPP, as variáveis e funções utilizados pelos install_int devem ser bloqueadas com as macros LOCK_VARIABLE.

Caso seu programa não esteje contando corretamente, leia sobre isto em:

http://www.allegro.cc/manual/api/timer-routines/install_int_ex

remove_int

Esta função remove um handler regitrado para a função enviada por parametro.

Exemplo :

install_int_ex( funcao1, SECS_TO_TIMER(10) ); // cria contador
remove_int( funcao1 ); // remove o contador que executava a funcao1

install_param_int e install_param_int_ex

O prototipo da função assusta:

int install_param_int(void (*proc)(void *), void *param, int speed);

É a mesma coisa que o install_int porém, com uma grande diferença de que você pode passar um parametro para essa função. ( E usar os modificadores no install_param_int_ex ).

Como esse parametro é um void, você poderá passar qualquer tipo, fazendo a conversão antes e depois para poder usar os tipos. Essa função é um pouco complexa, por isso vou dar um exemplo completo da utilização.

Exemplo :

No exemplo abaixo, instalamos um timer que incrementa um contador a cada 5 segundos.
Quando este contador chegar a 5, fizemos com que o timer seja desligado.

CÓDIGO...

#include <allegro.h>
#include <iostream>

int vcontador;

// prototipo
void contador( void * );

int main()
{
   allegro_init();
   set_color_depth(16);
   install_keyboard();
   set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 640, 480, 0, 0);

   install_timer();
   int total = 5;
   install_param_int( contador, (void *)&total, 5000 );


   int vcontador = 0;

   // Laço principal
   while( !key[KEY_ESC] )
   {

      vcontador = ::vcontador;
      clear( screen );

      textprintf_ex( screen, font, 10, 10, makecol(255,0,0), -1, "Variavel Contador: %d", vcontador );

      vsync();
   }


   allegro_exit();
   return 0;
}
END_OF_MAIN();

void contador( void *b)
{
   ::vcontador++;

   int *c = (int *)b;
   int a = (*c);

   if ( ::vcontador == a )
   {
      remove_param_int( contador, (void *)b );
   }
}

FIM DO CÓDIGO

remove_param_int

Esta função remove um handler regitrado para a função enviada por parametro.

Exemplo :

install_param_int( contador, (void *)&total, 5000 ); // cria contador
remove_param_int( contador, (void *)b ); // remove o contador que executava a contador

rest

Esta função faz com que o programa espere pelo tempo especificado no parametro.

void rest(unsigned int time);

Exemplo :

rest( 5000 ); // espera 5 segundos

rest_callback

Esta função faz com que o programa espere pelo tempo especificado no parametro, durante a espera, ela executa a função enviada no segundo parametro.

void rest_callback(long time, void (*callback)())

A função enviada tem que ser void e nao pode ter parametros.

Exemplo :

rest_callback( 10000, pause ); // espera 10 segundos e enquanto isso executa a função pause

Contribuidor
Adriano Waltrick
14/08/2007

Voltar

01/06/2007 (C) Copyright. Todos os Direitos Reservados. Leia a política de privacidade do portal. É proibida a cópia de conteúdo deste site de acordo com a Lei Brasileira de Direitos Autorais.