Controle de tempo: importantíssimo

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

#ifndef GLOBAIS_H
#define GLOBAIS_H

/*
====================
variaveis
====================
*/

// variaveis globais utilizadas para serem acessadas pelo timer do Allegro
extern volatile int ticksMS;
extern volatile int ticksFPS;

/*
====================
macros
====================
*/

// conversao entre segundos e milisegundos (calculo facil deixado em macros por comodidade)
#define SEGUNDO_PARA_MILISEGUNDO(s)			((1000)/(s))	// converte para milisegundos o valor dado em segundos
#define MILISEGUNDO_PARA_SEGUNDO(ms)		((ms)/(1000))	// converte para segundos o valor dado em milisegundos

#endif

Jogo.h

#ifndef JOGO_H
#define JOGO_H

#include <allegro.h>
#include "globais.h"

class Jogo {
private:
	// dimensoes do video
	int videoLargura;		// quantidade de pixels de largura do video
	int videoAltura;		// quantidade de pixels de altura do video
	int videoProfundidade;	// quantidade de bits de profundidade (numero de bits que cada pixel tera)

	BITMAP *buffer;	// bitmap que ira guardar tudo o que desenharmos (para depois ser "jogado" na tela")
					// este bitmap eh de suma importancia pois cada funcao de desenho
					// que desenha em um bitmap devera ser apontada
					// para este bitmap, assim fazemos o efeito de "double buffer" ou "buffer duplo"

	bool fimJogo;	// flag que indica se o jogo deve ou nao continuar
	bool telaCheia; // flag que indica se ocuparemos a tela toda ou apenas uma janela

	// variaveis para controle do tempo
	int FPS_DESEJADO;				// quantidade de frames que queremos idealmente que sejam calculados e exibidos em um segundo
	float msDuracaoMaximaFrame;		// calcula a duracao em milisegundos que cada frame deve ter no maximo (idealmente)
	volatile int totalFps;			// contador que guarda o total de frames por segundo (calculado apenas uma vez a cada segundo ou seja quando ja tivermos uma quantidade de frames desenhados na tela)
	volatile int frames;			// contador utilizado para calcular a quantidade de frames
	bool travaFps;					// flag que indica se devemos ou nao limitar o controle de fps
	volatile int msInicioFrame;		// contador de milisegundos que indica quando o frame iniciou
	volatile int msFimFrame;		// contador de milisegundos que indica quando o frame finalizou
	volatile int msDuracaoFrame;	// contador de milisegundos que indica quanto tempo o ultimo frame demorou para ser executado
	int framesPerdidos;				// contador de frames que nao foram processados por falta de tempo (o frame durou mais que a variavel msDuracaoMaximaFrame)

public:
	Jogo();
	void loop(); // executa o game loop
	virtual ~Jogo();
};

void atualizaTickerMS();

#endif

Jogo.cpp

#include "Jogo.h"

Jogo::Jogo() {
	fimJogo = false;
	telaCheia = false;

	// dimensoes do video
	videoLargura		= 640;
	videoAltura			= 480;
	videoProfundidade	= 16;

	int res;
    allegro_init();
    set_color_depth(videoProfundidade);
	res = set_gfx_mode(((telaCheia) ? GFX_AUTODETECT_FULLSCREEN : GFX_AUTODETECT_WINDOWED), videoLargura, videoAltura, 0, 0);

    if (res != 0) {
        allegro_message(allegro_error);
        exit(-1);
    }

    install_timer();
    install_keyboard();
    install_mouse();

	// inicializa as variaveis para controle do tempo
	FPS_DESEJADO			= 30;
	msDuracaoMaximaFrame	= SEGUNDO_PARA_MILISEGUNDO((float)FPS_DESEJADO);
	totalFps				= 0;
	frames					= 0;
	travaFps				= true;
	msInicioFrame			= 0;
	msFimFrame				= 0;
	msDuracaoFrame			= 0;
	framesPerdidos			= 0;

	// abaixo inicializamos o timer para executar a funcao atualizaTickerMS
	// que ira incrementar a variavel ticksMS a cada milisegundo
	LOCK_VARIABLE(ticksMS);
    LOCK_FUNCTION(atualizaTickerMS);
    install_int_ex(atualizaTickerMS, MSEC_TO_TIMER(1));

	// cria um bitmap com uma dimensao grande o suficiente para conter a tela inteira
    buffer = create_bitmap(videoLargura, videoAltura);
    set_window_title("VSoftGames - Teste avancado com timers");

	// inicializa o seed para geracao de numeros pseudo-aleatorios (caso precisemos de numeros aleatorios)
	srand((unsigned)time(0));
}

void Jogo::loop() {
	// neste caso o game loop continua executando enquanto nao pressionarmos
    // a tecla esc, mas voce pode verificar por uma outra variavel ou condicao
    while (!fimJogo) {

		// registra quando acabamos este frame
		msFimFrame = msInicioFrame;

		// guarda a quantidade de milisegundos que haviam passado antes do inicio deste frame
		msInicioFrame = ticksMS;

		// ================
		// ENTRADA E PROCESSAMENTO
		// ================

        if (key[KEY_ESC]) fimJogo = true; // se pressionou a tecla esc entao finaliza o jogo

		// ================
		// SAIDA
		// ================

		// para exibir o resultado na tela, toda a saida deve ser desenhada
        // no bitmap buffer declarado anteriormente

		// limpa o buffer com a cor preta
		clear_to_color(buffer, makecol(0, 0, 0));

		// exibe as informacoes do timer
		textprintf(buffer, font, 0, 0, -1, " FPS desejado: %i " , FPS_DESEJADO);
		textprintf(buffer, font, 0, 12, -1, " FPS calculado: %i " , totalFps);
		textprintf(buffer, font, 0, 24, -1, " Milisegundos passados: %i " , ticksMS);
		textprintf(buffer, font, 0, 36, -1, " Para %i fps, cada frame deve durar no maximo %f milisegundos ", FPS_DESEJADO , msDuracaoMaximaFrame);
		textprintf(buffer, font, 0, 48, -1, " Duracao do frame anterior: %3i milisegundos" , msDuracaoFrame);
		textprintf(buffer, font, 0, 60, -1, " Quantidade de frames perdidos: %i" , framesPerdidos);

		// copia todo o conteudo desenhado no buffer para a tela (exibindo assim o resultado do processamento)
        blit(buffer, screen, 0, 0, 0, 0, videoLargura, videoAltura);

        // apos a saida concluida, incrementamos o contador de frames, pois
		// temos mais um frame executado
		frames++;

		// agora que finalizamos o frame, guarda o quanto tempo ele demorou para ser executado
		msDuracaoFrame = ticksMS - msInicioFrame;

		// se a duracao dele foi maior do que o previsto, entao ele provavelmente nao foi exibido
		if (msDuracaoFrame > msDuracaoMaximaFrame)
			framesPerdidos++;

		// se quisermos travar o fps
		// e este frame durou pelo menos 1 milisegundo ou menos do que o maximo permitido
		if (travaFps && msDuracaoFrame && (msDuracaoFrame <= msDuracaoMaximaFrame)) {
			// dorme o restante do tempo que temos
			int dormir = msDuracaoMaximaFrame - msDuracaoFrame;
			rest(dormir);
		} else {
			// problemas, estamos durando mais do que o previsto...
		}

		// calcula o fps:
		// se passou um segundo desde a contagem do ultimo fps
		if (ticksFPS > 1000) {
			totalFps = frames / MILISEGUNDO_PARA_SEGUNDO(ticksFPS);	// pega a quantidade de frames que foram exibidos neste segundo
																	// e divide pela quantidade do tempo que passou (em segundos)
			ticksFPS = 0; // reinicia o nosso timer de fps
			frames = 0; // reinicia o contador de frames
		}
    }

}

Jogo::~Jogo() {
    clear_keybuf();
	destroy_bitmap(buffer);
}

/*
=======
atualizaTickerMS

Incrementa o contador de ticks a cada 1 milisegundo
=======
*/
void atualizaTickerMS() {
    ticksMS++;
	ticksFPS++;
}END_OF_FUNCTION(atualizaTickerMS);

main.cpp

/*
======================================
Exemplo de utilizacao de diversas tecnicas com timers atraves da biblioteca Allegro.

por Vitor Almeida da Silva

06/2009

======================================
*/

// inclui o header da biblioteca Allegro
#include <allegro.h>
#include "Jogo.h"

volatile int ticksMS		= 0;	// contador atual de milisegundos passados desde o inicio do jogo
volatile int ticksFPS		= 0;	// contador atual de milisegundos executados desde o calculo do ultimo fps

/*
=======
main

Funcao principal
Aqui temos o ponto de entrada da aplicacao onde o Game Loop sera executado
=======
*/
int main(int argc, char *argv[]) {
    Jogo *jogo = new Jogo();
	jogo->loop();
	delete jogo;

	return 0; // retorna um codigo de OK para o sistema operacional

}END_OF_MAIN();

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:

/*
======================================
Exemplo de calculo de resolucao do timer no allegro

por Vitor Almeida da Silva

06/2009

======================================
*/

// inclui o header da biblioteca Allegro
#include <allegro.h>

/*
====================
variaveis globais
====================
*/

volatile int ticksMS = 0; // contagem total de milisegundos passados desde o inicio do jogo (incrementado a cada milisegundo)

/*
====================
prototipos das funcoes
====================
*/
void atualizaTickerMS();

/*
=======
main

Funcao principal
=======
*/
int main(int argc, char *argv[]) {
	// inicializa o allegro
	allegro_init();
    set_window_title("VSoftGames - Resolucao (granularidade) do timer do allegro");

    // aqui inicializamos o nosso timer de ticks
    // trancando o espaco de memoria da variavel ticks e da funcao timer
    // assim elas nao sofrem alteracoes externas
	install_timer();
    LOCK_VARIABLE(ticksMS);
    LOCK_FUNCTION(atualizaTickerMS);
    install_int_ex(atualizaTickerMS, MSEC_TO_TIMER(1)); // timer chamado a cada milisegundo

	const int contador = 5; // quantidade de valores que queremos apurar
	int valores[contador]; // cria um espaco onde iremos guardar os resultados
	int i = 0; // indice para guardar a quantidade de valores medidos
	volatile int long atual = 0, ultimo = ticksMS; // valores iniciais

	while (i < contador) { // enquanto nao medimos todos os valores que queremos
		atual = ticksMS; // pega a quantidade atual de milisegundos
		if (atual != ultimo) { // verifica se houve uma diferenca com o ultimo valor medido
			//allegro_message("%d ms", atual - ultimo); // se houve, guarda no nosso array de resultados
			valores[i] = atual - ultimo; // se houve, guarda no nosso array de resultados
			ultimo = atual; // o valor que acabamos de medir eh o ultimo
			i++; // incrementa o nosso contador de valores medidos
		}
	}

	// agora que medidos os valores, podemos exibi-los
	allegro_message("Exibindo %d resultado(s).", contador);
	for (i = 0; i < contador; i++) {
		allegro_message("%d - %d ms", i + 1, valores[i]);
	}

	// finaliza
	allegro_exit();

    return 0; // retorna um codigo de OK para o sistema operacional

}END_OF_MAIN();

/*
=======
atualizaTickerMS

Incrementa o contador de ticks a cada 1 milisegundo
=======
*/
void atualizaTickerMS() {
    ticksMS++;
}END_OF_FUNCTION(atualizaTickerMS);

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.

Uma das resoluções do timer na minha máquina

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

Com timers é possível utilizar truques, basta passar o tempo em que a função começou a ser executada (ou foi chamada) e baseado neste tempo e em variáveis de estado podemos fazer truques de visualização na variável ou qualquer outro tipo de controle de tempo desejado.

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:

	int demoraTecla = 250;	// intervalo em ms (250 ms ou seja, um quarto de segundo) que queremos entre cada comando do teclado
	volatile int msUltimaEntrada = 0; // guarda quando ocorreu a ultima entrada do teclado (em ms)

Agora onde você verifica a sua entrada, inserimos o seguinte código por volta da linha 69:

		// aqui esta o segredo para a "entrada pausada":
		// se o tempo que levamos desde a ultima entrada ate agora (ticksMS - msUltimaEntrada) for maior
		// do que o intervalo que estipulamos anteriormente (demoraTecla), significa que ja podemos
		// considerar uma nova entrada
		if ((ticksMS - msUltimaEntrada >= demoraTecla)){
			msUltimaEntrada = ticksMS; // registra quando apertamos a tecla
			// execute aqui todo o codigo e verificacao de entrada
			// aqui podemos por exemplo incrementar um contador
		}

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)

As coisas estão indo muito bem por aqui, tenho aprendido e aplicado uma quantida massiva de informações que abriu muito minha cabeça (coisas boas devem vir…), dentre elas: OpenGL ES, C++, ARM (a arquitetura e um pouco do assembly), trigonometria, Objective-C, iPhone (se alguma empresa estiver interessada em desenvolver algo para iPhone e quiser entrar em contato fique a vontade), etc…

Resumindo algumas outras coisas que também aconteceram:

• perdi todo o conteúdo da minha hd antiga (sniff^2) (incluindo TODOS os artigos que eu havia escrito, fiquei muito f*dido, perdi coisa demais);
• comprei um Zeebo (sim, aquele video-game da TecToy), mais detalhes abaixo;
• passei de faixa no kung-fu (vem faixa preta…).

Voltando aos artigos: tenho três artigos prontos para serem publicados: um ensina a fazer a movimentação de um carro de corrida (movimentação angular) e é bem interessante para o pessoal que quer ver trignonometria e como isso se aplica no Allegro. Outro que eu gostei bastante é um artigo avançado sobre timers, ensinando como medir a resolução do timer do Allegro, pegar entrada apenas algumas vezes por segundo (ao invés de ficar acumulando por frame) e outras coisas mais. E o terceiro é uma adaptação de um outro tutorial (surpresa).

O bom de trabalhar na indústria é que muitas das dicas que eu passei anteriormente puderam ser testadas e aprovadas, inclusive eu anoto todo o meu aprendizado e posso fazer um novo artigo para a “Dicas para aprender a programar jogos” (parte 3 ou 4) com dicas relevantes direto das trincheiras.

Semana que vem (após o feriado) irei publicar o artigo sobre timers, fiquem atentos.

Falando sobre o Zeebo: comprei ele faz alguns dias com a intenção de tentar “hackear” (no bom sentido claro, não quero fazer pirataria com ele e sim tentar desenvolver para a plataforma como uma espécie de hobby inicialmente (como eu já fazia com o meu celular)). A minha idéia inicial era portar o Doom para o Zeebo.

Doom para o Zeebo: será que vai?

Pegando o SDK no site da Tectoy e lendo algumas informações adicionais eu consegui compilar uns exemplos que vieram juntos com o SDK do Zeebo mas ao que tudo indica enquanto eu não pagar uma licença para a Qualcomm não poderei passar os programas para o Zeebo (que precisa sofrer uma alteração para receber programas adicionais).

iPhone: uma excelente plataforma para desenvolvimento

Andou acontecendo bastante coisa na indústria também: recentemente a ZeniMax comprou a id Software (fiquei um pouco chateado com a notícia pois sou fã de carteirinha da id desde pequeno), lançamento do novo iPhone (no Brasil não faz tanto sucesso por causa do preço mas lá fora a coisa é um pouco diferente, é uma plataforma excelente).

ZeniMax compra a id: nãããããoooooo

Teve também o Rio Game Show (que eu não fui) que é um evento muito interessante e eu pretendo com certeza ir no ano que vem.

Acho que por enquanto é só.

Abraços e até breve.

Hoje venho dar algumas dicas de como conseguir um trabalho com programação de jogos.

Vejo muita gente discutindo assuntos do tipo que linguagem utilizar, que biblioteca usar e por aí vai. Claro isto é importante mas não é o fim. Ponha-se no lugar do entrevistador: se você fosse contratar alguém para trabalhar fazendo um jogo como você iria medir as habilidades desta pessoa para saber se ela realmente sabe o que diz? Simples: PORTFOLIO.

O portfolio

O seu portfolio não precisa mostrar projetos excessivamente grandes (esqueça aquela sua idéia brilhante de MMORPG) mas sim mostrar sua habilidade para fazer um jogo completo, funcional e polido.

Não importa se será o milésimo clone de um pong, breakout, pacman, mario, não importa se você está usando javascript, c++, c#, programação orientada a objetos (desejável), linux, windows, mac,  etc etc. O que importa é você ter o projeto pronto e disponível (facilmente acessível e testável, seja através de um executável, uma página especial com vídeos, etc). Você não precisa nem se preocupar se a estrutura do seu código estará perfeita ou não (embora seja recomendável dar uma atenção nesta parte). O simples fato de mostrar o jogo pronto é um atestado de que você entende os conceitos.

Hoje em dia você tem tudo disponível: com uma boa conexão de internet você pode pegar diversos tutoriais, recursos, artigos, livros, técnicas, tirar dúvidas em chats, todos os recursos necessários para aprender (todos os jogos “clássicos” possuem exemplos prontos para download de código fonte em diversas linguagens, é só dar uma pesquisada na internet).

O mais importante mesmo é ter disciplina, objetivo, foco e fazer cada pequeno passo para chegar no seu objetivo (tá parecendo até blog de autoajuda).

Faça o que eu digo, não faça o que eu faço…

O leitor pode estar pensando: tá tudo bem, dica interessante mas você trabalha na indústria?

Bom, agora posso dizer que sim….

Recentemente consegui uma vaga como programador em uma empresa chamada MyPlay Mobile para desenvolver jogos para iPhone. É uma empresa pequena em início de carreira mas temos grandes planos (como qualquer empresa) e know-how para fazer o barco andar. No meu caso o que realmente ajudou foi o blog que serviu como um “atestado de conhecimento”.

Até a próxima.

PS: se você trabalha na indústria e quer compartilhar a sua história conosco fique à vontade para comentar.

Continuando a série sobre o game loop, este artigo irá demonstrar uma versão “revisada” sobre os outros dois anteriores.

Basicamente revisei o código, e expliquei melhor algumas coisas. Também simplifiquei e melhorei um pouco o estilo.

No geral gameloops se resumem em um conceito: controle de tempo. O gameloop exibido abaixo é uma versão bem simples, mas podemos fazer uma versão bem mais complicada onde temos um timer diferente para a lógica e outro para a renderização, podemos calcular quanto tempo cada frame deve levar e deixar o frame apenas ser exibido se ainda houver tempo (descartando quando não der).

Tem também uma técnica para fazer gameloops que não depende da limitação por frames e sim de quanto tempo resta baseado em cálculos por “delta”, ou “tempo decorrido por frame”.

Para aprender bem isso, recomendo um estudo aprofundado das funções de timer do allegro.

Abaixo segue o código revisado:

/*
======================================
Exemplo da implementacao de um Game Loop em Allegro
com algumas explicacoes

por Vitor Almeida da Silva

03/2009

======================================
*/

// inclui o header da biblioteca Allegro
#include <allegro.h>

/*
====================
variaveis globais
====================
*/

bool fimJogo = false;	// flag que indica se o jogo deve ou nao continuar

volatile int ticks = 0;	// esta variavel ira ser um contador de ticks do clock principal
						// do jogo
						// cada tick a mais significa que um ciclo de logica do jogo
						// foi processado
						// esta variavel eh incrementada a cada tick de logica do jogo

// dimensoes do video
int videoLargura		= 640;	// quantidade de pixels de largura do video
int videoAltura			= 480;	// quantidade de pixels de altura do video
int videoProfundidade	= 32;	// quantidade de bits de profundidade (numero de bits que cada pixel tera)

BITMAP *buffer;	// bitmap que ira guardar tudo o que desenharmos (para depois ser "jogado" na tela")
				// este bitmap eh de suma importancia pois cada funcao de desenho
				// que desenha em um bitmap provavelmente devera ser apontada
				// para este bitmap

const int FPS_DESEJADO	= 60;	// quantidade de frames que queremos idealmente que sejam calculados e exibidos em um segundo
volatile int totalFps	= 0;	// contador que guarda o total de frames por segundo (calculado apenas uma vez a cada segundo)
volatile int frames		= 0;	// contador utilizado para calcular a quantidade de frames por segundo (incrementado a cada tick do clock)

/*
====================
prototipos das funcoes
====================
*/

void inicializa();
void finaliza();
void atualizaTicker();
void contaSegundos();

/*
=======
main

Funcao principal
Aqui temos o ponto de entrada da aplicacao onde o Game Loop sera executado
=======
*/
int main(int argc, char *argv[]) {
    // realiza todas as inicializacoes necessarias
    inicializa();    // a partir deste ponto temos a aplicacao pronta para iniciar o game loop

    // inicio do game loop

	// neste caso o game loop continua executando enquanto nao pressionarmos
    // a tecla esc, mas voce pode verificar por uma outra variavel ou condicao
    while (!fimJogo) {        // inicio do processamento da logica do jogo
        while (ticks > 0) {            // aqui iniciamos o processamento da logica do jogo
            // neste ponto, voce devera inserir o codigo responsavel
            // processamento da logica do seu jogo, isto inclui: deteccao de colisao
            // inteligencia artificial, calculos diversos, etc

			// aqui esta o segredo:

			// a variavel abaixo "ticks" eh decrementada, mas lembre-se que ela
            // tambem eh incrementada pela funcao de timer, entao qual eh a logica?
            // Lembre-se que o timer do ticks eh executado em um intervalo fixo
            // entao o decremento tambem devera ocorrer pelo menos N vezes (ver variavel FPS_DESEJADO), isto garante
            // que a logica do jogo sera executada pelo menos N vezes

            if (key[KEY_ESC]) fimJogo = true; // se pressionou a tecla esc entao finaliza o jogo

            ticks--; // decrementa o contador de ticks

	        // apos a saida concluida, incrementamos o contador de frames, pois
			// temos mais um frame executado
			frames++;
		}
		// fim do processamento da logica do jogo

		// quando chegarmos ateh aqui significa que a variavel ticks esta com valor
        // zerado, entao ja executamos toda a logica do jogo, agora eh hora
        // de exibir o resultado na tela

		// para exibir o resultado na tela, toda a saida deve ser desenhada
        // no bitmap buffer declarado anteriormente

		// limpa o buffer com a cor preta
		clear_to_color(buffer, makecol(0, 0, 0));

		// exibe um contador de frames por segundo
		// descomente se quiser exibir o contador
		// textprintf(buffer, font, 0, 0, -1, " FPS: %i " , totalFps);

		// copia todo o conteudo desenhado no buffer para a tela (exibindo assim o resultado do processamento)
        blit(buffer, screen, 0, 0, 0, 0, videoLargura, videoAltura);

		rest(1); // evita que a aplicacao monopolize o processador
    }

    // executa todas as finalizacoes necessarias
    finaliza();

    return 0; // retorna um codigo de OK para o sistema operacional

}END_OF_MAIN();

/*
=======
inicializa

Realiza qualquer procedimento necessario para iniciar o jogo
Isto inclui iniciar a janela e deixa-la preparada para ser desenhada, iniciar
o estado do jogo, posicoes iniciais, nivel inicial e tudo o que for necessario
=======
*/
void inicializa() {
    int res;
    allegro_init();
    set_color_depth(videoProfundidade);
    res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, videoLargura, videoAltura, 0, 0);

    if (res != 0) {
        allegro_message(allegro_error);
        exit(-1);
    }

    install_timer();
    install_keyboard();
    install_mouse();

    // aqui inicializamos o nosso timer de ticks
    // trancando o espaco de memoria da variavel ticks e da funcao timer
    // assim elas nao sofrem alteracoes externas
    // note que a funcao ticker sera chamada FPS_DESEJADO vezes por segundo, isto eh,
    // a logica do nosso jogo sera executada FPS_DESEJADO vezes em um segundo
    LOCK_VARIABLE(ticks);
    LOCK_FUNCTION(atualizaTicker);
    install_int_ex(atualizaTicker, BPS_TO_TIMER(FPS_DESEJADO));

    // aqui ocorre o mesmo processo para o timer dos segundos
    // note que o timer sera chamado apenas uma vez por segundo
    LOCK_FUNCTION(contaSegundos);
    install_int_ex(contaSegundos, BPS_TO_TIMER(1));

    // cria um bitmap com uma dimensao grande o suficiente para caber na tela
    buffer = create_bitmap(videoLargura, videoAltura);
    set_window_title("VSoftGames - Teste do Game Loop");
}

/*
=======
finaliza

Realiza qualquer procedimento de limpeza para finalizar o jogo
=======
*/
void finaliza() {
    clear_keybuf();
    destroy_bitmap(buffer); // desaloca o buffer que utilizamos para o double buffer

    // neste ponto voce devera adicionar qualquer tipo de finalizacao que for
    // necessario, limpeza, etc.
}

/*
=======
atualizaTicker

Incrementa o contador de ticks de logica
=======
*/
void atualizaTicker() {
    ticks++;
}END_OF_FUNCTION(atualizaTicker);

/*
=======
contaSegundos

Funcao executada uma vez por segundo para atualizar o contador de frames por segundo
=======
*/
void contaSegundos() {
	totalFps = frames;
	frames = 0;
} END_OF_FUNCTION(contaSegundos);

Valeu pessoal, até a próxima.

Utilizando o programa abaixo, é possível conferir na máquina em que ele será compilado o tamanho de cada tipo de dado do C (bem como seus valores mínimos e máximos).

#include <stdio.h> // biblioteca de entrada e saida padrao
#include <limits.h> // biblioteca que contem os macros (definidos pelo fabricante do compilador) com os valores maximos e minimos suportados pelo mesmo

int main(int argc, char *argv[])
{
    // total de bits do processador em que o programa foi compilado
    char totalBits = sizeof(int) * 8; // geralmente o tamanho do tipo inteiro eh igual a quantidade de bits de processamento do processador
    printf("\n\nMaquina de %d bits\n\n", totalBits);

    printf("Tipo em C\t\tTamanho\t\t\tValores\n");
    printf("=======================================================\n");

    // caracteres
    printf("char\t\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a %d)\n", sizeof(char),  sizeof(char) * 8, SCHAR_MIN, SCHAR_MAX, UCHAR_MAX);

    // valores inteiros
    printf("int\t\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a 0x%X)\n", sizeof(int), sizeof(int) * 8, INT_MIN, INT_MAX, UINT_MAX);
    printf("short int\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a %d)\n", sizeof(short int),  sizeof(short int) * 8, SHRT_MIN, SHRT_MAX, USHRT_MAX);
    printf("long int\t\t%d bytes (%d bits)\tsigned (%d a %d) unsigned (0 a 0x%X)\n", sizeof(long int),  sizeof(long int) * 8, LONG_MIN, LONG_MAX, ULONG_MAX);

    // numeros em ponto flutuante
    printf("float\t\t\t%d bytes (%d bits)\n", sizeof(float), sizeof(float) * 8);
    printf("double\t\t\t%d bytes (%d bits)\n", sizeof(double), sizeof(double) * 8);

    system("PAUSE");

    return 0;
}

Saber os tipos de dados e tamanhos pode servir por exemplo para se descobrir qual o menor tipo de dados na máquina utilizada  ou a diferença entre dois tipos facilitando assim a escrita de um código mais otimizado.

Possui alguma dica interessante? Não deixe de compartilhar.

O blog  Game tutorials made easy recentemente postou um tutorial sobre como desenvolver um tetris utilizando C++ e a biblioteca SDL.

O tutorial é bem completo, explicando passo-a-passo a lógica utilizada e muito bem ilustrado.

Apesar de não ser desenvolvido com a biblioteca Allegro ele pode ser facilmente adaptado para outras tecnologias pois o tutorial é bem focado na lógica.

Conhece mais algum tutorial interessante?

Em especial o programador de jogos enfrenta problemas em uma base diária.

Segue abaixo uma lista com algumas dicas úteis que ajudam na resolução de problemas:

1. Tente entender o problema a fundo: pegue a maior quantidade possível de informações, livros, artigos, sites, amigos, qualquer material que possa servir de referência para consulta;
2. Reflita cuidadosamente sobre o que você está tentando resolver, este passo é super importante pois ajuda a ter uma idéia clara do que você realmente está se dispondo a fazer e não do que você acha que está tentando fazer;
3. Quando o excesso de pensamento não der em nada, tente pensar de uma maneira diferente com um outro ponto de vista, algo totalmente diferente que talvez não faça sentido inicialmente mas que pode trazer resultados;
4. Algums problemas fazem parte de uma categoria maior, encontre problemas parecidos e use-os como base para resolver o problema em mãos;
5. Não conseguiu resolver o problema? Existe alguma outra alternativa em que você não precise resolvê-lo ou precise resolver um problema menor e mais fácil?
6. Muitos problemas mais complicados são resolvidos com muita determinação e dedicação, existem problemas que não são resolvidos rapidamente e requerem um esforço grande para serem resolvidos, se este for o seu caso, calma e concentração;
7. Quanto mais problemas você resolver mais estará apto a resolver problemas parecidos ou problemas de mesma categoria. Conhecimento se constrói em cima de conhecimento.

Estas são algumas das dicas que eu utilizo quando enfrento algum problema complicado.

E você? Possui mais algumas dicas? Não deixe de comentar.

O foco do novo tutorial está nos exemplos e passou por uma reescrita total (para corrigir todos os erros anteriores e explicar melhor alguns temas).

Ele será dividido em partes para ser mais fácil a leitura e impressão.

Até breve.

Capa do livro

Escrito por Martin J. Wells, o livro é bem completo e explica em detalhes como programar celulares utilizando Java. Além disso, é uma excelente fonte de técnicas para programar jogos 2d (incluindo trigonometria, cenários, raycasting, isometria e uma infinidade de temas interessantes que podem ser aplicados para outros ambientes…).

O livro pode ser adquirido através da Amazon (apenas em inglês).

Apesar de ser um bom livro, possui algumas desvantagens tais como revisão mal finalizada e humor excessivo em alguns pontos, mas que não alteram o valor do conteúdo do livro.

Atualmente ele possui duas edições: a segunda edição é a mais atual (voltada para o MIDP 2.0 e a primeira para o 1.0.

Bons estudos.

VSoftGames no celular

Agora o VSoftGames está disponível também para quem possui celular - é só acessar o endereço http://vsoftgames.mofuse.mobi/ e navegar.

Há um serviço chamado MoFuse, que permite facilmente essa conversão. Agora vocês podem acessar utilizando o seu celular, smartphone ou iPhone.

Até.