21 - Adicional 1 - Organização de Código

Este capítulo é para quem já possuí experiência em programação.

Recentemente fora levantado um tópico no nosso forum sobre a organização do código.
No capítulo 21 nós aprendemos a melhor forma de se programar um jogo, organizando o código como programação e não como um projeto.

Com este tutorial adicional, pretendo dar mais dicas para tornar a programação de jogos mais organizada.

Fazer um jogo é um projeto que contém várias etapas.
Nem sempre precisamos seguir todas as etapas, mais algumas são indispensáveis para a conclusão sem atrasos ( perda de tempo ) do projeto.

Este tipo de conteúdo é discutido em vários sites e em várias outras áreas, simplesmente por que é um assunto relacionado ao tempo!
Quanto mais tempo gasto, mais caro se torna a sua idéia.

Quanto mais organizada for a sua ideia e o seu projeto, melhor ele será implementado e mais rápido o jogo será concluído.

Eu vou abordar aqui a criação de um jogo no estilo Arkanoid.

1 - A idéia:

Como a idéia é criar um jogo ao estilo do Arkanoid,
precisamos estudar como este jogo funciona e descrever todos os funcionamentos e idéias do jogo.

Se você está criando um jogo que ainda não foi inventado, o processo será o mesmo.

A descrição da idéia é muito importante para sabermos o que realmente queremos fazer e para adotar mudanças no projeto.

Exemplo:

- Um jogo aonde o jogador controla uma raquete ( ou shape ) que vai rebater uma ou várias bolas.
- O objetivo do jogo será destruir todas as peças do cenário, fazendo com que a bola entre em contato com essas peças.
- Cada peça vai fazer com que uma ação seja disparada no jogo, criando novas bolas, aumentando a velocidade, etc.
- Quanto todas as peças forem destruidas, o jogador é enviado diretamente para a proxima fase.
- Quando a bola não for rebatida, o jogador perde uma vida.

Observe que especificamos detalhes do jogo, sua descrição e regras.
A descrição inicia da idéia não deveria ser mudada durante a execução do projeto.

Observe que na minha idéia de Arkanoid, mudei alguns conceitos do jogo original.
Neste ponto também, são definidas algumas historias e cenarios do jogo, não precisam ser completas.

2 - Descrição de Regras

Agora iremos definir as regras do jogo.
Essas regras podem sofrer alterações durante a execução do projeto,
por que as vezes nem sempre conseguimos programar tudo o que queremos.

- O Jogo vai ter uma historia ?

- O jogo vai ter uma animação inicial ?? Como ela vai ser ?

- O Jogo vai ter uma tela inicial ? - Quais serão as opções do menu ?

- Quais serão as telas do jogo ? - Descrever as telas do jogo..

- Descrição das regras para o Jogador - Descrição das regras para o Jogador para cada tela ou cenário

- Descrição das regras do jogo para cada tela ou cenario
- Descrição das regras para upgrades, inimigos, jogabilidade

Quando você for definir as regras, você não precisa levar em consideração tecnologias que serão utilizadas.
Isto por que, as regras poderão ser alteradas mais tarde.

Esta não é a hora de pensar em qual linguagem programar ou qual programa de modelagem utilizar.

3 - Identificando atores e tarefas

Esta aqui é uma das partes mais importantes ao se fazer um projeto pois ela define como será feita a programação.
Você deve identificar atores de ações nas regras e idéias descritas acima.

Nada muito técnico ainda.

Exemplo:

- Bola

A bola pode se mover pelo cenario
A bola pode colidir com uma peça e destrui-la
A bola pode colidir com a raquete do jogador, que vai rebatela para outra direção

- Raquete do jogador

A raquete do jogador pode se mover apenas na horizontal para os lados
A raquete do jogador pode se mover mais rapido ou mais devagar
A raquete do jogador pode ter tamanhos diferentes
A raquete do jogador pode rebater a bola

- Cenario

O cenario pode ter tamanhos diferentes
O cenario pode ter várias peças
O cenario pode ter uma imagem de fundo
O cenario pode ter apenas um jogador
O cenario pode ter várias bolas
O cenario deve controlar para que as bolas não saiam de seus limites

Eu identifiquei alguns atores e tarefas deles acima.
Nem sempre se consegue identificar todos os atores, por isso talvez você vá precisar alterar este parte mais tarde.

4 - Criando Classes e métodos

Este método de desenvolvimento não é igual ao UML, Por favor, não confunda!
Os atores no UML são usuários e/ou outros meios externos que desenvolvem algum papel em relação ao sistema.

Você pode usar a UML para ajudar no seu projeto também.
Além de definir os atores e possíveis tarefas, você vai definir diagramas que irão ajudar você a identificar quem serão as classes.

Estude UML também!
http://pt.wikipedia.org/wiki/UML

Após identificar os atores do passo 3, podemos procurar quais deles serão classes, e quais funções cada classe vai executar.

Pense da seguinte maneira!
Você vai criar uma classe para alguma coisa que irá ter várias variáveis e que irá desempenhar várias tarefas no seu jogo.

Bola, Jogador e Cenário desempenham várias tarefas, como vimos acima, então ficou fácil de saber quem serão nossas classes.

Com as tarefas de cada um, também podemos conhecer de antemão quais serão os metodos que cada um vai fazer.

Exemplo:

Classe Bola

metodo mover
metodo desenhar no cenario
metodo colisao com peças
metodo colisao com jogador

Neste ponto, nem sempre vamos descobrir todos os métodos e todas as classes.
Porém, neste ponto já podemos descidir como vamos fazer as coisas e se conseguimos fazer tais coisas.

Agora é hora de descidir a linguagem de programação e como será programado o jogo.
Agora também é hora de decidir quais classes se comunicarão com outras classes.

Por exemplo:

A classe bola vai ter o método que verifica a colisão? ou a classe cenario ?
Quem vai controlar as vidas ? O cenário ou o jogador ?

Exemplo de código:

#ifndef BOLAS_H
#define BOLAS_H

#include <allegro.h>

class Bolas {

private:

   // contadores auxiliares
   int i;
   int c;


public:

   int posicao_x;
   int posicao_y;

   int tamanho;
   int cor;

   // controlam a velocidade da bola em x e em y
   // desta forma ela pode ir para lugares diferentes na tela
   int velocidade_x;
   int velocidade_y;

   // informam a direção de movimentação da bola
   // pelo cenario

   // para esquerda bola->direcao_x = -1;
   // para cima bola->direcao_y = -1;
   int direcao_x;
   int direcao_y;

   Bolas(); // função construtor
   ~Bolas(); // função destrutor

   void iniciar( int pos_x, int pos_y ); // inicia objeto
   void destrutor(); // reinicia variáveis do objeto

   void mostrar( BITMAP * fundo ); // imprime a bola no vetor fundo
   void refresh(); // atualiza posição da bola

   void adiciona_velocidade_x();
   void remove_velocidade_x();

};

#endif

5 - Programação

Agora você vai criar as classes que encontrou e tentar juntar todas as classes de forma que o jogo rode no final.
Bom.. essa minha explicação foi bem superficial, já que isto é bem complicado.

Então vou mostrar como isto é feito na prática!

- Para programar um jogo você deve ter noção de Orientação a Objeto básica para criar as classes.
- Para programar um jogo você precisa ter alguma noção de UML para identificar eventos e classes.

http://pt.wikipedia.org/wiki/Orienta%C3%A7%C3%A3o_a_objetos
http://pt.wikipedia.org/wiki/UML
http://bdjogos.com/adrw/c/classes.htm

Eu criei um jogo no estilo do Arkanoid para você baixar.
O código fonte está incluído e você poderá alterar como quiser.

Neste código fonte existem todos os comentários que você vai precisar para entender como ler o código e como organizar o projeto.

Esta forma de programar jogos com certeza não é a melhor forma que existe.
Eu apenas abordei um modo prático de programar jogos, procure pesquisar mais sobre isto.