Revista EGW #107

Capa - Revista EGW #107
Capa - Revista EGW #107
Capa - Revista EGW #107

Está nas bancas a revista EGW número 107. Citamos a revista pois, além de ser uma revista legal, nós da XUTI fomos matéria de 2 páginas na revista, na matéria “Game como inclusão social“, que fala sobre nossas atividades de desenvolvimento de jogos nas unidades do SESC no Rio de Janeiro, em parceria com o amigo Fabiano Sampaio.

Para comprar a revista, vocês podem ir a uma banca ou clicar AQUI.

Se conseguir autorização, coloco a matéria online depois que a revista sair das bancas.

Game Zone Especial

Revista Game Zone
Revista Game Zone
Revista Game Zone

Está nas bancas a revista GAME ZONE ESPECIAL. Citamos a revista pois, além de ser uma revista legal e acessível aos mais leigos em programação, nós da XUTI auxiliamos na revista com textos e tutoriais. Espero que gostem.

Para comprar a revista, vocês podem ir a uma banca ou clicar AQUI.

Como instalar o MingW com o Allegro no Windows ?

O propósito deste texto é descrever detalhadamente a instalação do MinGW (http://www.mingw.org/) conjuntamente com a biblioteca para desenvolvimento de jogos Allegro (http://www.talula.demon.co.uk/allegro/ ou http://alleg.sourceforge.net/).

O MinGW é, grosseiramente, uma versão do compilador C da GNU (GCC – http://gcc.gnu.org/) para Windows, permitindo então compilar programas C/C++ neste ambiente de forma muito eficiente.

O Allegro é uma biblioteca multiplataforma que inclui muitas funções úteis no desenvolvimento de jogos, como funções gráficas (2D e 3D), áudio, controle de teclado/mouse/joystick e timer. Funciona de forma muito simples e permite a geração de códigos praticamente idênticos em todas as plataformas em que está disponível, dentre as quais Windows, Linux e DOS.

Conjuntamente com um editor de textos (nossa preferência pessoal é pelo XEmacs – http://www.xemacs.org/ pois tem uma funcionalidade única para escrever o código, mas outra forte indicação é o Dev-C++ – http://www.bloodshed.net/ que é um ambiente integrado que funciona com o MinGW; mas qualquer outro editor de sua preferência serve) temos um ambiente de desenvolvimento de jogos básico completo.

Parte I – O que devo pegar?

Para instalar o MinGW e o Allegro, você deverá baixar os seguintes pacotes:

i) A distribuição completa do MinGW, atualmente em um único arquivo de instalação, que se encontrava na época deste texto em http://prdownloads.sourceforge.net/mingw/MinGW-1.1.tar.gz

ii) Os seguintes utilitários adicionais portados para MinGW:

  • fileutils: consiste em utilitários para lidar com arquivos muito úteis, principalmente na linha de comando ou makefiles. Pegue a versão disponível em ftp://ftp.franken.de/pub/win32/develop/gnuwin32/mingw32/porters/Mikey/fileutils316-ming.tar.bz2
  • sed: é necessário pra compilar o Allegro. Pegue em ftp://agnes.dida.physik.uni-essen.de/home/janjaap/mingw32/binaries/sed-2.05.zip
  • bzip2: você vai precisar pra abrir o fileutils acima. Pegue em http://prdownloads.sourceforge.net/mingwrep/bzip2-1.0.1-20011028.zip

iii) O Allegro propriamente dito com o arquivo para fazer interface com o DirectX no Windows. Vá à página de download da última versão estável do Allegro (4.2) – http://alleg.sourceforge.net/wip.html – e baixe os seguintes arquivos com source para windows:

  • all400.zip (http://prdownloads.sourceforge.net/alleg/all420.zip?download)

E APENAS UM dos arquivos abaixo, dependendo da versão do DirectX que você deseja dar suporte:

  • dx70_mgw.zip (não confunda com dx70_min.zip!) – http://alleg.sourceforge.net/files/dx70_mgw.zip
  • dx80_mgw.zip – http://alleg.sourceforge.net/files/dx80_mgw.zip

Parte II – Configurando o MingW e preparando para instalar o Allegro

Comece pela instalação do pacote do MinGW, descompactando o arquivo no diretório que deseja que ele fique instalado. O usual é algo como c:mingw32 (pessoalmente prefiro c:mingw pois mingw32 é um nome ultrapassado do projeto). Este arquivo pode ser descompactado com o Winzip. De agora em diante, vamos assumir que a instalação foi feita em c:mingw.

O diretório c:mingwbin deve ser incluído no início do seu path (caso você use DJGPP também: antes da inclusão do diretório dele!), sendo que isso pode ser feito de várias formas, sendo as mais comuns:

  • Windows 9x: editando seu arquivo c:autoexec.bat alterando a linha do path ou simplesmente incluindo no final deste arquivo a linha “path c:mingwbin;%PATH%”
  • Windows NT (inclui 2000,XP e Me): abra o Painel de Controle, vá em “Sistema” e então na aba “Avançado” e finalmente no botão “Ambiente”. Selecione PATH= e adicione “c:mingwbin”.
  • Da mesma forma, a seguinte linha deve ser inserida no c:autoexec.bat : “set MINGDIR=c:mingw”. (Caso você utilize Windows XP ou NT, no mesmo menu descrito no ítem anterior, crie uma variavel denominada MINGDIR e atribua a ela o valor c:mingw. Não utilize autoexec.bat).

Após estas alterações nos arquivos de inicialização será necessário que você reinicie o computador. Vá então em uma janela DOS/CONSOLE e digite a seguinte linha para testar a instalação: “gcc -v”. O resultado deve ser algo como:”Reading specs from C:MINGWBIN..libgcc-libi386-mingw32msvc2.95.3specs gcc version 2.95.3 20010726 (release)”.

Instale agora o pacote sed e bzip2, descompactando-os para o diretório do MinGW (aponte o winzip para c:mingw portanto). Em seguida, na janela DOS, vá ao diretório onde está o arquivo do fileutils e rode o comando “bunzip2 fileutils316-ming.tar.bz2” (este comando deverá funcionar se você descompactou direito o arquivo bzip2 e incluiu c:mingw no seu PATH adequadamente e irá descompactar o arquivo fileutils316-ming.tar.bz2 para fileutils316-ming.tar o qual o Winzip pode lidar). Então descompacte com o Winzip o arquivo fileutils316-ming.tar gerado por este último comando para o diretório do MinGW como acima.

Descompacte da mesma forma os arquivos do Allegro para o diretório do MinGW (c:mingw), e quando for descompactar o arquivo dx70_mgw.zip (ou o dx80_mgw.zip – depende de qual arquivo você pegou) e sobrescreva todos os arquivos existentes.

Pronto! Basta agora configurar o Allegro e então compilá-lo!

Parte III – Compilando o Allegro

Se você chegou até aqui, não deverá ter mais problemas (estamos considerando apenas a instalação padrão. Se você quer algo mais sofisticado, certamente sabe do que está falando e não precisa deste tutorial!).

Os comandos a seguir devem ser executados em uma janela DOS/CONSOLE. Para compilar o Allegro devemos preparar os arquivos de configuração para avisar de que a compilação será com o MinGW e então mandar compilar o mesmo. Para isso, basta seguir os seguintes passos, digitando os comandos entre aspas na linha de comando:

1. Vá ao diretório do Allegro: “cd c:mingwallegro”
2. Rode o arquivo de configuração do allegro: “fix.bat mingw32”
3. Finalmente vamos compilar o Allegro: “make”
4. Tome um café…(dependendo da sua máquina, considere jogar uma partida de xadrez)
5. Basta então mandar instalar a biblioteca: “make install”

Pronto! O Allegro está instalado! Você poderá ver vários exemplos no diretório c:mingwallegroexamples e uma demo muito interessante em c:mingwallegrodemo . A documentação básica do Allegro está no diretório c:mingwallegrodocs e é muito indicado que você veja o link de tutoriais na página da biblioteca, principalmente o Vivace se você for iniciante.

Caso você deseje informações mais detalhadas, este texto foi feito com base no processo que usei para instalar no meu computador, mas foi fortemente influenciado pela documentação nos sites citados e na documentação da configuração e instalação do Allegro,constantes do diretório de documentação que acompanha a biblioteca.

Bom código!

Timming no Allegro

Por Daniel Loureiro

Uma das primeiras dúvidas que surge com a programação de jogos é com a temporização (“timming”). Coisas do tipo: “gostaria que o lutador gordo fosse um pouco mais lento que o oponente”, “quero uma contagem regressiva numa velocidade, meu jogador em outra, e o boomerangue dele em outra”, entre outras.

De fato, quando o jogo começa a ficar complexo, é comum termos elementos que executam em velocidades diferentes. Em programação isto é obtido executando trechos de código em velocidades diferentes: o código responsável por atualizar a contagem regressiva deve ser executado em uma velocidade (1 segundo, por exemplo), o código que modifica a animação do personagem em outra, e assim por diante.

O Allegro provê rotinas que facilitam esta tarefa. A primeira coisa que o programador deve fazer, é colocar cada um dos trechos de código em uma função diferente. Desta forma, temos uma função para atualizar a contagem regressiva, outra para movimentar o personagem, outra para animá-lo, etc.

Depois, deve-se chamar uma função específica do Allegro e passar 2 parâmetros: um é a função que desejamos que seja executada em determinada velocidade, o outro é o período entre uma execução e outra (em milésimos de segundo). Assim, passar a função “Mova_Personagem” e o valor 50, fará que “Mova_Personagem” seja executada a cada 50 ms, ou a 20 vezes por segundo (1000/50).

Você pode querer usar as macros do Allegro que convertem segundos para ms, execuções por segundo para ms, execuções por minuto para ms, e até mesmo (para os que gostam de padronizar) ms para ms (!!!). Entre as funções básicas de timing, existem mais 2: uma para a execução automática de uma função e a outra inicializa as funções de timing do Allegro.

Existem também outras funções relacionadas com o timing: algumas inúteis, que são idênticas às tradicionais, porém com outros nomes; outras para sincronização vertical (para melhorar a qualidade gráfica); e outras de uso geral (como uma nova versão para o famoso “delay”).

Abaixo, veremos as 3 funções mais básicas:

  • “int install_int(void (*proc)(), int speed)”. Esta é a função principal, e serve para criar um “timer” (função que será executada automaticamente). Ela põe a função passada pelo 1o parâmetro na lista de funções a serem executadas automaticamente pelo Allegro. Note que “speed” é o período em que a função será executada automaticamente. Se a função já estiver na lista, ela apenas modifica o período dado por “speed”. Obs.: A função passada por parâmetro não pode retornar algo, nem ter parâmetros, isto é, tem que ser algo como: “void Funcao(void)”.
  • “void remove_int(void (*proc)())”. Retira a função da lista (somente se ela existir), parando a execução automática dela.
  • “int install_timer(void)”. Inicializa as funções de timing do Allegro. Já que a função “install_int” chama ela se o programador ainda não o fez, seu uso não é obrigatório, mas recomendado por motivos de padronização.

Para converter para os milésimos usados por “speed”, você pode usar as seguintes macros:

MACRO CONVERTE O MESMO QUE
SECS_TO_TIMER(msegs) Segundos para ms 1000 * msegs
MSEC_TO_TIMER(mseg) Ms para ms mseg
BPS_TO_TIMER (bps) Execuções por segundos para ms 1000/bps
BPM_TO_TIMER (bpm) Execuções por minutos para ms 60000/bpm

Devido à forma com que o Allegro gerencia os “timers”, devemos tomar uma série de medidas em nosso programa:

  1. As variáveis globais que serão alteradas dentro de um “timer” devem ser declaradas com a palavra reservada “volatile”. Volatile, se você não se lembra, faz com que o compilador saiba que determinada variavel “volatile” pode ser alterada por “algo” que não seja exatamente algum código no programa principal.
  2. Após a declaração de um “timer”, devemos usar a macro END_OF_FUNCTION(Nome_da_Funcao_Timer)”.
  3. Todas variáveis globais acessadas (lidas e/ou escritas) nos “timers” devem ser trancadas com a macro “LOCK_VARIABLE(Nome_De_Uma_Variavel)”.
  4. Todas as funções de “timer” devem ser trancadas com “LOCK_FUNCTION(Nome_da_Funcao_Timer)”.
  5. Os “timers” não devem acessar o disco nem outras funções do sistema.
  6. Deve-se fazer os “timers” o mais simples possível.

Exemplo básico:

[c]

volatile int x=0; //Variável glogal modificada em um timer

void Anda(void) { //Timer
x++;
}

END_OF FUNCTION(Anda); //Necessário após a declaração de um timer

int main(void) { //Nosso programa

install_timer(); //Opcional, porém mais legível
LOCK_FUNCTION(Anda); //Obrigatório trancar os timers usados
LOCK_VARIABLE(x); //Obrigatório trancar as variáveis globais usadas nos timers
install_int(Anda, BPS_TO_TIMER(10)); //"Anda" deve ser executado 10 vezes por segundos
while(!Fim_Jogo) {} //Lógica do jogo
return(1);
}
[/c]

Para finalizar, devo destacar que o Allegro permite apenas 16 “timers”. Como as funções de animações FLI, mouse, interface GUI, e música MIDI necessitam de “timers”, se utilizarmos alguns destes recursos, a quantidade de “timers” do usuário fica ainda menor.

Senha

Jogo Senha
Jogo Senha

O jogo SENHA foi desenvolvido originalmente pela PROINFO Software, em 1995. O programa foi feito para o ambiente DOS/Turbo C, mas funciona sem problema sob o ambiente WINDOWS. Foi desenvolvido basicamente com a finalidade de aprender a utilizar strings em C.

O arquivo senha.rar, disponível na seção download, contém 3 versões do programa:

senha01.c Código fonte original do programa
senha01.exe Primeira versão do programa, com vários erros de planejamento do jogo
senha02.exe Segunda versão do programa, levemente modificada para resolver alguns problemas lógicos no jogo e de verificação de strings
senha03.exe Primeira versão oficial do jogo, com menus. Bem simples, mas apresentáve

Para fazer o download do jogo, vá na seção DOWNLOADS do site ou clique aqui: [Download não encontrado.]