PDJBlog

Desculpem o atraso pessoal, é que estamos tendo problema com o sistema do WordPress e o post que era pra ter sido postado (do Bruno Schifer) teve que ser adiado, então esse imprevisto com o sistema acabou me pegando de surpresa pra escrever esse texto(ainda faltava preparar umas coisas!). Mas aqui está:

Parte 2

Bom, nessa segunda parte do artigo vamos fazer as preparações para podermos começar a programar baseado com a descrição do jogo que foi feita na primeira parte da série.

Módulos

A maneira que irei usar para programar aqui vai ser dividir em módulos o que tinhamos definido na primeira parte da série e algumas coisas especiais que vamos usar pra programar. Na primeira parte nós definimos que iriamos ter os seguintes atores no jogo:

- Canhão
- Naves
- Base(barreira)
- Tiros

Definimos também as variáveis que eles irão usar, se vocês prestaram atenção eles dividem variáveis em comum, como x e y, flag de vivo ou morto, e frame atual de animação. No caso o único que é diferente é a barreira. Então nós iremos criar uma estrutura comum para o Canhão, Naves e Tiros. Vamos chamar ela de estrutura objeto. Nós iremos definir as variáveis dela na próxima parte da série.

Vejam que mesmo definindo que iremos criar uma estrutura em comum para eles, cada um tem um movimento diferente, tem uma imagem diferente, atira de maneira diferente e é representado com uma estrutura de dados diferente(o Canhão é uma estrutura normal, as naves são uma matriz de uma estrutura, e os tiros uma lista, ou vetor de uma estrutura de tiros). Então apesar de cada um dos três dividir a estrutura de objeto, cada um tem uma peculiaridade, ou seja, vamos precisar de um módulo para cada um também.

Quando eu falo a palavra módulo, eu me refiro nada mais que um .h e um .c que contém somente coisas relacionadas ao ator que estamos programando. É quase igual a um objeto de POO(só que sem as vantagens de POO). Com o que definimos até agora vamos precisar de um módulo para o Canhão, outro para as Naves outro para a Barreira outro para os Tiros e mais um para a estrutura de objeto. A idéia desses módulos é que (como objetos de POO) eles são “isolados” o máximo possível para que qualquer alteração no jogo, não precise alterar muitos módulos, mas sim o módulo em questão. Ou seja, vamos tentar fazer com que eles sejam independentes um do outro o máximo possível. Não é 100% possível de fazer isso porque geralmente um utiliza variáveis e estruturas dos outros e alguns vão ser por natureza totalmente dependentes de um outro, como por exemplo a estrutura objeto que é uma estrutura “mãe” da estrutura de canhão nave e tiros. Se vocês não estão entendendo muito bem isso tudo, fiquem mais calmos que quando vocês começarem a programar (na próxima parte da série) vai tudo ficar mais claro.

Outros módulos que vamos precisar vão ser os módulos de output, input, o módulo jogo e mais um módulo para a lib que vamos usar. Esse módulo da lib vai servir pra que possamos tentar separar algumas funções da lib que vamos usar no jogo, pra ficar mais fácil pra quem usa SDL ao invés de Allegro.

Resumindo nós temos os seguintes módulos:

Lib, módulo que terá funções para inicializar/finalizar a lib utilizada.

Objeto, módulo que irá conter estrutura variáveis e funções para manipular objetos(qualquer coisa que se mova) no jogo.(É nesse módulo que vamos criar a função da colisão)

Tiros, módulo que será dependente do módulo objeto e ira conter estruturas de dados, variavéis e funções para manipular os tiros das naves inimigas e do jogador.

Nave, módulo que será dependente do módulo objeto e do modulo tiro e irá conter estrutura variáveis e funções para manipular as naves inimigas do jogo(com base no que tinhamos planejado na série passada, é aqui que vai ter o algoritmo de movimento das naves e o algoritmo de “IA” para atirar)

Canhao, módulo que será dependente do módulo objeto e módulo de tiros, irá conter estrutura variáveis e funções para manipular o canhão do jogo

Barreira, módulo que irá conter estruturas e variáveis para manipular a barreira.

Input, módulo que irá controlar as reações do teclado.

Output, módulo que irá conter funções para controlar audio e video.

Jogo, módulo chave que irá utilizar todos os outros módulos para fazer o jogo funcionar.

Ordem de desenvolvimento

Bom, com base nisso iremos criar a ordem de como iremos programar tudo. De acordo com o que eu tinha dito na parte passada da série, a ordem com que vamos programar tudo depende das dependências(!). Mas nesse caso não são necessariamente as dependências dos módulos. Vejam que o módulo de tiro depende do de objeto, mas ele vai ser um dos ultimos a ser programado já que (como eu tinha dito) se criarmos ele primeiro não iria adiantar muito já que pra um tiro ser disparado precisa de algo que o dispare!

Então a ordem vai ser algo mais ou menos assim:

1º Criar o módulo da Lib
2º Criar o módulo do Jogo
3º Criar o módulo de Output
4º Criar o módulo Objeto e Canhao
5º Criar o módulo de Input
6º Criar o módulo das Naves
7º Criar o módulo dos Tiros
8º Criar o módulo da Barreira

Acredito que a ordem será essa, mas notem que criar um módulo não significa necessariamente que vamos criar ele e nunca mais iremos programar algo nele de novo. Muito pelo contrário, todo módulo que vamos criar vai ser um “esqueleto”, ou seja, no começo não vai ter muita coisa, só o suficiente pra criar as dependências e não precisar ficar reprogramando tudo utilizando Ctrl+C e Ctrl+V ou algo que o valha.

Finalizando

Com isso concluímos essa segunda parte da série. A partir da próxima se preparem que vamos começar a programar