ALLEGRO

Controle de tempo é importantíssimo em jogos eletrônicos: seja para realizar cálculos de física, tempo, alterar a velocidade de objetos, saber quanto tempo a aplicação está rodando, calcular quantos ms o frame pode durar baseado no fps, etc. As aplicações são grandes.

Por isso saber trabalhar com timers é fundamental para o programador de jogos. A biblioteca Allegro nos fornece alguns recursos interessantes (um bom tutorial sobre a utilização dos mesmos pode ser visto aqui no site bdjogos).

Existem alguns truques comuns utilizados na programação de jogos 2d (e 3d) e alguns conceitos que devem ser entendidos para a utilização plena de timers. Hoje vamos ver esses conceitos na teoria e prática para alavancar seus conhecimentos sobre timers. Apertem os cintos e acertem os relógios, é hora de contar o tempo…

Começando

Para todos os exemplos deste tutorial utilizaremos um timer configurado pelo Allegro que incrementa uma variável (chamada ticksMS) a cada 1 milisegundo. A partir desta configuração veremos a resolução do mesmo e algumas técnicas.

Utilizar um timer desta maneira nos traz alguns benefícios interessantes:

• podemos calcular quanto tempo o frame pode durar (em ms) baseado no fps desejado;
• em qualquer momento do frame podemos calcular quanto tempo estamos executando o frame atual e tomar medidas de acordo;
• podemos saber se o frame atual executou dentro do tempo desejado;
• muitas outras aplicações.

Para realizar os exemplos deste artigo, crie um projeto com os seguintes arquivos:

globais.h
Jogo.h
Jogo.cpp
main.cpp

Conceitos

Primeiro vamos começar com alguns conceitos iniciais necessários para se trabalhar com timers.

Resolução do timer (ou granularidade): é a quantidade de tempo que precisa haver entre duas chamadas ao timer (ou seja, quando pegamos o valor atual do timer) para termos valores diferentes retornados.

A resolução é muito importante para termos uma idéia de quanto tempo temos entre as chamadas. Para medir a granularidade das funções de timer do Allegro utilize o programa abaixo:
Este programa inicia um timer no Allegro que a cada 1 milisegundo incrementa uma variável (ticksMS). Realizando um pequeno loop “contador” vezes e calculando a diferença entre o tickMS podemos saber a granularidade do timer.



Note que o valor pode variar. Na minha máquina o menor valor que consegui foi 1 ms (para ver as unidades de medida, veja a última seção deste artigo), sendo que o valor variou até 15 ms (ver figura acima).

Bom, com uma resolução de 1ms conseguimos um FPS máximo de 100 (1000/1) (ou seja, se tivéssemos por exemplo uma resolução de 15ms teríamos um FPS máximo de 66.6 (1000/15)), o que é muito bom e suficiente para nosso caso.
Se você quiser uma resolução maior (na casa dos microsegundos), utilize as funções do seu sistema operacional ao invés do timer do Allegro (consulte os links no final do artigo).

Técnicas

A seguir vamos ver algumas das técnicas possíveis utilizando-se timers.

Técnica “entrada pausada”:

Em muitos casos queremos que ocorra uma ação (baseado em um comando do jogador), mas não queremos que esta ação se “acumule” para o próximo frame. O ideal é termos uma pequena pausa antes do jogo considerar outra ação se continuarmos com o mesmo botão pressionado.

Com o nosso timer executando a cada milisegundo, podemos calcular a qualquer momento: em que tempo entramos no frame atual e qual a duração de ms que estamos neste frame. Tendo estas informações em mãos fica fácil fazermos um pequeno delay para considerar a próxima ação. Exemplo:

No arquivo Jogo.cpp vá para a função loop e declare as variáveis abaixo logo no início da função:

Agora onde você verifica a sua entrada, inserimos o seguinte código por volta da linha 69:
Com esse código podemos limitar a quantidade de entradas que temos em um frame (isto pode ser feito também criando-se um outro timer no próprio Allegro, mas a solução que temos aqui apesar de ser mais complicada inicialmente compensa pois o Allegro possui um limite de 16 timers e no nosso caso estamos utilizando apenas um timer). Agora você já pode pressionar uma tecla e ter resultados que não ficam se acumulando entre os frames.

Conclusões

Espero com este artigo ter demonstrado um pouco melhor o funcionamento dos timers e algumas técnicas aplicáveis (qualquer problema no código ou algum erro por favor avisem para que eu possa corrigir).

Na parte 2 veremos algumas outras técnicas (em especial movimentação relativa ao tempo restante do frame).

Timers em geral são um assunto bem complicado pois cada implementação pode ter seus “problemas”. Cada sistema operacional ou dispositivo possuem suas particularidades, características e devem ser observadas com atenção.

Para se utilizar timers deve-se saber os conceitos envolvidos e se realizar todas as medições necessárias para garantir um funcionamento seguro.

Vale a pena dar uma boa olhada no código fonte do Allegro para verificar como as funções de timers são implementadas no seu sistema operacional.

Lições

Agora que você já sabe um pouco mais sobre timers, pode tentar fazer as seguintes experiências:

• altere a quantidade de fps desejado e veja o quanto a sua máquina aguenta
• realize outros tipos de processamento e veja quanto tempo os frames demoram
• ao invés de utilizar os timers do Allegro, implemente um wrapper utilizando funções de timer do seu sistema operacional e faça os mesmos testes (altamente recomendado)

Referências

• código fonte da biblioteca Allegro
• Timing in Win32
• Chapter 2. An Animation Framework
• QPC, GTOD, RDTSC
• theWitters Game Loop Tutorial

Unidades de medidas e abreviações

ms: milisegundos, ou (1/1.000) de um segundo (um milésimo de segundo)
us: microsegundos, ou 1/1.000.000 de um segundo (um milionésimo de segundo)