Esse jogo, eu fiz em 2008 baseado em outro jogo feito pelo Thiago Negri (hunz). Agora atualizei todo o código para o tutorial.

O jogo funcionará da seguinte maneira:

• O jogador começará numa posição dentro do mapa e usará as setas do teclado para mover-se.
• No mapa, haverá 4 tipos de objetos: paredes, gramado, caminho e ponto final.
• O jogador poderá passar sobre o caminho ou gramado. E não passará sobre as paredes.
• O jogo terminará quando o jogador chegar ao ponto final do mapa.

Baixe as imagens abaixo, elas serão necessárias para o jogo:

Obs.: quando executar o jogo, as imagens devem estar na mesma pasta do executável para funcionar.

Arquivo labirinto.c:


Para compilar, execute:

gcc -o labirinto labirinto.c -lSDL

Controle de FPS

Para o controle do FPS, usei uma função específica, veja o código:


Ela recebe, como parâmetro, o tempo inicial lido no início da iteração do loop principal. SDL_GetTicks() retorna o tempo em milissegundos desde a inicialização do SDL.

Internamente, controla_fps calcula o tempo necessário para "esperar" para voltar a executar o programa. 1000/60 é o FPS convertido para milissegundos, 60 é o valor do FPS (Frames Per Second), quanto maior for o valor do FPS, menor será o tempo de espera.

Basicamente, é isso que ela faz. Espera um pequeno tempo, esse tempo deve variar mais ou menos um pouco. Se não fosse essa função, o programa executaria cada iteração do loop principal em diferentes intervalos de tempo.

Isso quer dizer que, se o programa rodasse numa máquina mais fraca, o loop levaria mais tempo para executar; se fosse numa máquina mais rápida, o programa rodaria muito rápido. Usando um controle de FPS, garantimos que o programa rodará por igual em diferentes máquinas. Essa função pode ser usada, sem muita modificação, em outros programas.

Se você quiser ver como um programa sem controle do FPS roda, compile e execute o código abaixo:

Arquivo demo_fps.c:


Para compilar:

gcc -o demo_fps demo_fps.c -lSDL

Ele mostra um retângulo indo e voltando na horizontal. Olhe atentamente para o retângulo movendo, não tire o olho dele. Em certos momentos, o retângulo move mais rápido e em outros, move mais devagar, isso acontece porque não há um controle de FPS dentro do loop principal.

Se você colocar a função controla_fps() e a variável tempo_inicial no programa, verá que a variação do movimento da imagem diminuirá consideravelmente, o que significa que o programa está rodando numa velocidade quase que constante.

Carregando as imagens:


As SDL_Surface, que são as imagens do jogo, são variáveis globais. Usei uma única função para carregar e verificar se carregou cada imagem. Ela retorna 0, caso alguma imagem não seja carregada e retorna 1, quando todas as imagens foram corretamente carregadas.

Blitagem do mapa

Parte mais complicada é a da blitagem do mapa.

Usei uma função para ficar responsável pela blitagem do mapa. Na blitagem, dependendo do valor da célula atual, cada imagem tem sua própria SDL_Surface. As imagens da parede, por exemplo, são uma, a do ponto final outra, por isso será preciso usar ifs para identificar a imagem para o valor indicado.

Veja abaixo a função desenha_mapa():


A função percorre cada célula da matriz e verifica qual imagem blitar na tela, indicado pelo valor da célula atual. O destino de cada imagem depende do valor das variáveis linha e coluna.

Na tela cada, imagem está localizada de 20 em 20 pixels. Multiplicando o valor da coluna por 20 (tamanho da imagem), conseguimos o destino.x da imagem na tela, o mesmo vale para o destino.y, que é linha vezes 20.

Movimento do jogador

O movimento do jogador é feito pelas setas do teclado. As setas para cima e para baixo ficam responsáveis pelo movimento vertical (no eixo Y), e as setas direita e esquerda pelo movimento horizontal (no eixo X). As variáveis linha_atual e coluna_atual indicam a posição do jogador dentro do mapa (matriz). O movimento é feito como se estivéssemos caminhando entre as linhas e colunas de uma matriz qualquer.

Mover para cima, é o mesmo que mover da linha atual para uma linha anterior (linha_atual menos 1):
O máximo que se pode subir nas linhas é até 0 (primeira linha).

Mover para baixo, é o mesmo que mover da linha atual para uma linha posterior (linha_atual mais 1):




O máximo que se pode descer nas linhas é até 9 (última linha).

Mover para esquerda, é o mesmo que mover uma coluna para esquerda (coluna_atual menos 1):
O máximo que se pode ir para esquerda nas colunas é até 0 (primeira coluna).

Mover para direita, é o mesmo que mover uma coluna para direita (coluna_atual mais 1):
O máximo que se pode ir para direita nas colunas, é até 39 (última coluna).

A colisão é feita verificando se no mapa[linha_atual][coluna_atual] tem uma PAREDE, ou seja, se é igual a 1. Toda vez que mover o jogador, seja no eixo X ou Y, e tiver uma PAREDE no mapa[linha_atual][coluna_atual], deve-se fazer o movimento inverso para retirar o jogador de cima da parede.

Isso depende do movimento feito para chegar lá, por exemplo, se mover para cima (linha_atual menos 1) e tiver uma parede no mapa[linha_atual][coluna_atual] o movimento para desfazer ir para cima é ir para baixo (linha_atual mais 1).

Se mover para direita e tiver uma parede, o movimento de desfazer ir para direita é ir para esquerda. Ou seja, no geral é se tiver uma parede volte para a posição antes de mover.

No loop principal


O destino X e Y da imagem do jogador é feito multiplicando a linha_atual e coluna_atual por 20 (tamanho da imagem).

if (mapa[linha_atual][coluna_atual] == SAIDA) :: Verifica se o jogador chegou ao final da fase. Com isso, poderíamos terminar o game (encerrar o loop) ou carregar uma nova fase. Por enquanto, apenas uma mensagem é mostrada no console.

O que poderia ser colocado no Game

Poderia ler o mapa a partir de um arquivo. O formato poderia ser assim:


Com cada caractere, sendo uma célula da matriz mapa. Obviamente, deve-se converter o caractere lido para o valor inteiro, basta fazer valor_do_caractere - '0'. Poderia ler o mapa de um arquivo assim que o jogador chegasse no ponto final, mas teria de definir outra posição para o jogador dentro do mapa.

Também, poderia colocar outros obstáculos, como portas que abrem ao passar sobre um botão no mapa ou obstáculos móveis, que vai e vem pelo mapa.

Bem, por enquanto, isso fica para você mesmo implementar. :)