Criando jogos em Delphi

[~~Surfistinha~~² 0]

- Introdução -

Este é o primeiro de muitos tutoriais sobre desenvolvimento de jogos que eu pretendo postar neste blog. Aqui vamos tratar de desenvolvimento de jogos em Delphi sem usar nenhuma biblioteca externa (como o DirectX ou SDL), apenas a GDI do Windows.

 

Já que o assunto central desse tutorial é usar os conhecimentos em Delphi para criar jogos, é bom que você tenha um conhecimento prévio na linguagem.

- Um jogo simples -

Vamos criar um joguinho bem simples. Nesse joguinho haverá apenas uma bolinha percorrendo todo o cenário.

 

Abra o Delphi e crie um novo projeto. Altere o tamanho do form, coloque 640 de ClientWidth e 480 de ClientHeight. Mude a BorderStyle para bsSingle (assim o usuário não poderá redimensionar o form). E finalmente em BorderIcons deixe apenas biSystemMenu (o botão de fechar) e biMinimize (o botão de minimizar).

 

Vamos algumas variáveis para armazenar a posição e a direção da nossa bolinha. Eu escolhi o tipo single por que ele pode armazenar algumas casas decimais.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

No OnCreate (assim que o form for criado) do form nós vamos inicializar as variáveis de velocidade.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Agora adicione o objeto TTimer no form. Mude a propriedade interval do TTimer para 1. No evento OnTimer deste objeto nós vamos colocar todo o laço principal do jogo (analisar as informações e apresentá-las ao jogador).

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Wow! Funciona! Tem uma bolinha batendo na tela, mas… que falhas são essas??? Fiz alguma coisa errada??

 

Na verdade não, acontece que estamos desenhando diretamente na tela, então todas as etapas do desenho são mostradas para o jogador, por isso essas falhas. Mas se acalmem, existe um modo de contornar isso. Vamos desenhar em outra tela.

 

Esse recurso se chama BackBuffer (ou OffScreen) e consiste em desenhar todos os elementos do jogo em uma tela virtual na memória (aqui nós vamos usar um bitmap) e depois que tiver desenhado tudo enviar para o vídeo (desenhar no form).

 

Vamos criar mais uma variável, chamada BackBuffer, que será do tipo TBitmap.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Antes de iniciar o jogo precisamos criar nosso bitmap (do contrário vamos receber um erro ao tentar desenhar nele). No evento OnCreate do form adicione o seguinte código:

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Quando o jogo terminar nós temos que liberar esse bitmap da memória. Então no evento OnDestroy do form adicione o seguinte código:

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Como não estamos mais desenhando diretamente no Canvas do form, nossa rotina de limpar a tela e desenhar nossa bolinha vai mudar um pouquinho. Abaixo segue o novo código do evento OnTimer.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

 

Download do código fonte deste tutorial:[DOWN]

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

[/DOWN]

 

Nosso primeiro “joguinho” está pronto. A tela continua com algumas falhas porque a rotina de desenho da GDI do Windows não é muito boa, mas vamos usar imagens a partir do próximo tutorial e eliminar um pouco isso.

 

Na próxima parte vamos criar um pequeno clone do “pong”, aquele joguinho de ping pong da Atari, com gráficos e sons. Algo bem oldschool, mas espero que gostem.

 

Parte IV

- Animações -

Quando várias imagens são mostradas em um curto intervalo de tempo, nosso cérebro interpreta isso como movimento. À freqüência de imagens mostradas damos o nome de FPS (Frames per Second, em inglês). Filmes normalmente utilizam 30 quadros (frames) por segundo, enquanto os jogos mais atuais utilizam 60 quadros. Note que 15 é o mínimo de quadros aceitável em uma animação, mas quanto mais quadros por segundo uma animação tiver, mais suave ela será.

 

Teoria básica apresentada, vamos ao que interessa. Para montarmos uma animação no Delphi, tudo o que precisaremos é mostrar uma seqüência de imagens na tela. Mas como mostrar essa seqüência? Simples. Vamos usar variáveis para recordar qual quadro devemos mostrar na tela, e por quanto tempo ele ainda deve ser mostrado na tela.[/u

- A classe TAnimation-

Para controlar a animação vamos criar uma classe, nesse caso a TAnimation, que derivará apenas de TObject (como todas as classes em Delphi derivam de TObject, nós podemos deixar essa herança implícita). Essa classe precisa guardar uma matriz contendo as imagens de cada quadro, o quadro que está sendo mostrado atualmente e o tempo de espera entre um quadro e outro. Além disso, ela precisa de uma rotina que atualize a animação. Essa rotina recebe o tempo decorrido e atualiza a variável que guarda o tempo que o quadro atual foi exibido. Se esse tempo for maior do que o tempo de espera, alteramos o quadro da animação. Por fim, precisamos de uma rotina para desenhar o quadro atual na tela. Sabendo disso, podemos criar a nossa classe.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Nossa classe agora está criada. É uma classe que pode controlar qualquer animação usando imagens (quadros) no formato bitmap. Para esse tutorial, vamos criar um pequeno programa que mostra várias animações de explosão em lugares aleatórios da tela.

 

Antes de continuar, faça o download do código fonte e imagens da animação aqui.

 

Agora que você já tem as imagens, vai perceber que elas estão no formato jpeg (aliás, um formato que não deve ser usado para animações/sprites), que eu usei aqui só pra reduzir o tamanho do arquivo. =D Mas, enfim, como as imagens estão em jpeg, temos três alternativas: A primeira é converter cada imagem manualmente para bitmap, já que nossa classe só aceita esse formato. A segunda, é alterar nossa classe para funcionar com imagems em jpeg ao invés de bitmap, mas como eu disse, jpeg deve ser evitado em animações e sprites. A terceira, é criar uma função para converter as imagens de jpeg para bitmap. Vamos usar a terceira, já que eu sou um programador garoto preguiçoso demais para converter as imagens manualmente ^.-

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Agora nós temos imagens que servem como quadros em nossa classe de animação, podemos começar a criar nosso programa. Primeiro, vamos precisar de algumas variáveis para controlar as animações e, claro, nosso backbuffer.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

 

AnimFrames é uma variável útil, já que ela vai permitir carregar as imagens do HD no formato jpeg e guardá-las no formato bitmap, assim nós só precisamos convertê-las uma vez. Já RunningAnims é uma lista com ponteiros para instâncias das animações mostradas na tela. Enfim, nós carregamos as imagens e inicializamos essas variáveis quando o form é criado, e liberamos os recursos quando ele é destruído.

 

Além disso, precisaremos de 2 objetos TTimer. Um com o intervalo de 1 milisegundo, que vai controlar a atualização das explosões, e o outro com intervalo de 100 milisegundos, que vai criar animações aleatoriamente na tela.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

O modo de cópia cmSrcPaint em conjunto com o fundo preto, faz com que a cor preta das imagens desenhadas no backbuffer fique transparente.

 

Agora que inicializamos tudo, falta criar as animações. Então no evento OnTimer do Timer2 vamos colocar um pequeno código que cria animações aleatórias pela tela.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

Por fim, precisamos escrever o código do evento OnTimer do Timer1, que irá controlar todas as animações ativas na tela. Isso é possível pois temos uma lista de todas as animações ativas guardadas em RunningAnims, então basta percorrer esta lista e atualizar as animações nela.

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

 

end;

 

Para ver o efeito das animações basta rodar o programa e voílà! Você deve ver várias animações sendo criadas aleatóriamente pela tela em intervalos regulares.

- Conclusão -

Esse foi um pequeno tutorial para desenvolvimento de jogos em Delphi, utilizando apenas a GDI do Windows. Claro, você não deve utilizar a GDI do Windows para desenvolver jogos, mas o conceito aqui se aplica a qualquer outra framework. Eu pretendo escrever mais tutoriais de GameDev em Delphi, utilizando frameworks como Asphyre e SDL (apesar de estar um pouco mais ocupado agora i.i). Até lá o(^-^)/”

 

creditos: Desconhecido