PDJBlog

Na terceira parte da série nós finalmente vamos começar a programar, infelizmente ainda não vai ser uma programação "pesada", só vamos preparar o programa para que ele possa "suportar" o jogo em si. Ou seja, vamos criar um esqueleto para ele.

Módulo da Lib

Primeiro, vamos criar um programa que inicie a Allegro, entre num loop(que não faz nada) até que se aperte Esc, e depois feche. O importante aqui é ir programando e compilando a medida que se faz o código. Muitas pessoas quando começam a programar tendem a programar várias linhas de código e só depois compilar, mas isso é ruim porquê depois de muitas linhas de código se tiver um erro no seu programa(e provavelmente vai ter) fica díficil saber de one ele veio já que você programou muitas coisas de uma só vez.

Então agora nós só vamos fazer um programa que chama a Allegro e pronto. Mas é importante lembrar que nós vamos separar a Allegro em um outro módulo como eu havia dito. O porquê disso é devido ao fato de organização no código e também pra aumentar a facilidade de portabilidade. Se você depois quiser fazer esse programa em SDL ou outra lib, o jogo vai estar mais isolado da lib utilizando essa organização no código.

Na primeira parte da série eu falei que seria necessário um conhecimento de programação de jogos e como usar a Allegro, então pra quem não conhece existem bons tutoriais por aí sobre ela, mas se quiser continuar lendo sinta-se a vontade

Vamos criar então três arquivos:

• main.c
• libAllegro.h
• libAllegro.c

A main.c é o programa em si, que tera nossa função main() e que controlará todo o resto do jogo. O libAllegro.h e libAllegro.c são os arquivos que vão constituir o módulo da lib da Allegro.

Dentro do libAllegro.h, teremos o seguinte código:

Nesse arquivo não temos nada de muito especial, somente incluimos a allegro, e declaramos duas funções que serão programas no libAllegro.c, pelo nome das funções(inicia_allegro e finaliza_allegro) podemos supor que elas vão servir para iniciar e fechar a Allegro.
Agora vamos para o libAllegro.c programar cada função. Primeiro vamos programar a initAllegro, que será a função que irá inicializar a Allegro. Para inicializar a Allegro nós vamos utilizar o mesmo código que o Dev-C++ cria caso você use o devkpak da Allegro , segue o código comentado:

Bom, explicando por alto cada parte da função(já que o foco aqui não é Allegro) primeiro nós declaramos duas variáveis que serão utilizadas para armazenar os bits das cores(depth) e outra para verificar se podemos inicializar o programar com a resolução e o modo gráfico definido(res). Depois chamamos a allegro_init() para que a allegro se inicie e para podermos usar todas as outras funções da allegro.

Mais abaixo usamos a variável depth para receber quantas cores utilizamos no desktop, depois disso é feita uma verificação de erro e chamamos a set_color_depth(depth); Mais embaixo inicializamos o modo gráfico com janela na resolução de 640 por 480, mais adiante fazemos uma verificação de erro. E depois chamamos install_timer() e install_keyboard() para podermos usá-los mais tarde. Desculpem não explicar detalhadamente mas como disse acima, o foco não é a Allegro

A função finaliza_allegro() será uma função vazia, já que por hora não tem o que botar nela mesmo. Ela vai servir mais tarde para finalizarmos timers e outras coisas da Allegro.

O arquivo libAllegro.c ficará assim:

Bom, falta só chamar essas funções no nosso arquivo main. A estrutura do main vai ser bem simples, ele precisa chamar nosso módulo da Allegro, chamar a função de inicializar, entrar num loop(essa parte do loop na verdade não precisa, mas eu deixei ela aqui para que a gente possa ver a tela preta), depois chamar a função deinitAllegro, e fim

Se vocês compilarem o programa agora(é bom fazê-lo), ele irá rodar uma tela preta e quando você apertar Esc ele irá sair do programa.

Módulo Jogo

O módulo do jogo vai ser um dos mais importantes porque ele é um módulo central que controla todo o resto do jogo(por isso o nome dele :)). Vai ser um dos módulos onde nós mais vamos voltar e ficar adicionando/mudando código já que ele é o controlador de tudo, então a medida que formos criando as coisas, quem vai botar elas "no palco" vai ser esse módulo.

Primeiro vamos criar o jogo.h:

Ou seja, esse módulo agora não vai ter muita coisa. Só precisamos de uma variável fimJogo que vamos usar na main mais tarde, e duas funções, uma pra inicializar as variáveis relacionadas ao jogo, e a outra é o processamento do jogo em si. Vamos ver elas no jogo.c:

Por enquanto esse módulo não tem nada de especial também, só atribuimos zero a variável fimJogo. Pode parecer inútil programar esses módulos sem nada só pra ter um programa que aparece uma tela preta, mas construir programas grandes é como se fosse qualquer projeto grande como por exemplo uma casa, primeiro se constroem os alicerces para depois ir "moldando" o resto em cima disso. E é assim que um programa grande funciona, embora no nosso caso o Space Invaders não seja necessariamente grande como os jogos de hoje em dia, ele já apresenta características de um jogo que precisa ser programado dessa maneira.

Se nós não programarmos o jogo projetando e tendo em vista o final dele, mais adiante muito do código terá que ser reescrito e isso além de ser trabalhoso faz com que o jogo fique com muitos bugs porque você quase sempre não se lembra algo que você programou no começo do jogo. Então se você está se perguntando o porquê de tudo isso, relaxe que mais adiante você vai entender

Agora o que nos falta é inserir isso na nossa main, o que eu basicamente vou fazer é chamar a função de inicializar as variáveis, mudar o while e inserir o processamento do jogo:

Bom, percebam que eu chamei a inicia_variaveis() logo após a inicia_allegro(), essa ordem é importante porque algumas vezes nós vamos precisar iniciar variáveis que são dependentes da lib que estamos usando, então essa função tem que vir depois da inicialização da lib.

Depois eu mudei o while de "while (!key[KEY_ESC])" pra "while (!fimJogo)". Eu fiz isso devido ao fato de que o jogo nem sempre vai fechar quando apertamos ESC, por enquanto ele só vai fechar nessa condição, mas mais adiante ele vai fechar no menu principal, quando apertamos esc, quando der algum erro, etc. Então por isso o loop principal do jogo depende da variável fimJogo.

Adicionei a linha de "if (key[KEY_ESC]) fimJogo = 1 para podermos fechar o jogo, mais adiante nós vamos deletar essa linha já que no lugar dela vai ser chamada uma função para controlar o input de todo o jogo, mas como nós ainda não criamos o módulo de input essa linha de código vai ficar aí temporiariamente para podermos fechar o jogo.

Logo após o nosso falso input eu chamo a função de processamento do jogo, embora não tenha nada, é essa função que vai mexer os objetos do jogo, detectar colisões, verificar quando a fase acabou, processar a IA dos inimigos, ou seja, tudo relativo ao jogo em si. Por enquanto vamos deixar ela vazia mesmo.

Finalizando

Bom, até agora você tem uma bela de uma tela preta! Mas isso é importante já que existem milhares de maneiras de fazer um programa que imprima uma tela preta, e principalmente milhares de maneiras de começar a programar um jogo. Mas eu estou fazendo isso pra que vocês vejam que é importante preparar tudo antes mesmo que o programa não faça nada. E não é só porque o programa não está fazendo nada, que o código por debaixo dele tem que ser ruim. O jogo tem que ser bom tanto para o usuário quanto para o programador.

Por enquanto vamos ficar só com esses dois módulos, no próximo será explicado o módulo de output o de objeto e canhão e input! Então se prepare!

Mas como vocês viram, montar um jogo é saber se preparar, entender os requerimentos dele e saber como programar isso efetivamente. Por isso eu frizei bastante nas 2 primeiras partes da série o planejamento, e como eu disse, é prática! Até a próxima