Allegro: Biblioteca de Programação para Jogos

Juliano da Costa Medeiros e Rodrigo Machado Hahn

Universidade do Vale do Rio dos Sinos
jcm.voy@terra.com.br - dormento@ig.com.br

Resumo 3. Funções

Na área da informática, a área de jogos é muito 3.1. Funções Gráficas:

importante, pois o desenvolvimento dos jogos exige
muito conhecimento na qual é visto no curso de Ciência
da Computação. Incrivelmente essa área é pouco
difundida nas universidades, mesmo sendo evidente a
sua importância acadêmica e por ser uma fonte
inesgotável de pesquisa.
1. Introdução
Uma importante área da computação é o
desenvolvimento de jogos. Esta área é de grande
importância durante o desenvolvimento dos jogos, pois
são utilizados diversos recursos computacionais, de baixo
a alto nível, nos processos de desenvolvimento.
Conseqüentemente, este ramo da computação é
abrangente e muito explorado.
2. A Biblioteca Allegro
Allegro Low Level Game Routines (Allegro) é uma
biblioteca de programação de jogos para programadores
C/C++. Originalmente foi desenvolvida por Shawn
Hargreaves e atualmente mantida por muitos
programadores.
Allegro é uma biblioteca Open Source, podendo ser
modificada por qualquer programador e distribuída
gratuitamente. Esta biblioteca oferece muitas funções
para gráficos, sons, dispositivos de entrada (teclado,
mouse e joystick), funções matemáticas de ponto fixo e
flutuante, funções 3D, além de funções de gerenciamento
de arquivo, arquivo compactado, uma GUI e
temporizadores.
2.1. Plataformas suportadas:
• DOS (DJGPP, Watcom);
• UNIX (Linux, FreeBSD, Irix, Solaris, Darvin);
• Windows (MSVC, MinGW, Cygwin, Borland);
• BeOS, QNX;
• MacOSX [1].
• Desenhos vetoriais: pixels, linhas, retângulos,
círculos, elipses, arcos, splines Bezier
preenchimento de shape, com ou sem padrão
polígonos: planos, Gouraud, com textura com
translúcido;
• Sprites: máscara, compactada e cópias, rotação,
redimensionamento, canal alfa, suporte para
arquivos: BMP, LBM, PCX e TGA (outros
suportados com plugins);
• Paletas de Cores: manipulação da paleta de
cores (lendo, escrevendo, convertendo)
conversão de formato de cores RGB para HSV e
vice-versa;
• Textos: saída de texto em formato (mascarado,
colorido, alinhado);
• Outras: desenho diretamente na tela em um
bitmap de memória de algum tamanho crolling e
funções de animação par ao formato FLI/FLC.
[1]
3.1.2. Drivers Gráficos:
• Dos: modo VGA, SVGA em 8, 15, 16,24 e
32 bits por pixel;
• Unix: X Windows, DGA, fbcon, SVGAlib,
VBE/AF, mode-X, VGA;
• Windows: DirectX (normal ou full-screen)
GDI;
• BeOS: BwindowsScreen Bdirect Window.[1]
4. Funções de Som
• Midi: suporte nativo de música no formato
MIDI (com 64 efeitos simultâneos)
controle/resposta dinâmico para música como
ligar, desligar, volume principal, pitch bend, e

1
 escolha de programa. Pode ler diretamente
arquivos MIDI;
• Wave: Suporte nativo para arquivos .wav e .voc,
com opções de volume, pitch, etc, durante a
execução. [1]
4.1. Drivers de Som
• Dos: Adlib, SB Pro, SB16, AWE32 MPU-401
ESS AudioDrive Ensoniq Soundscape Windows
Sound System;
• Unix: OSS ESD ALSA;
• Windows: DirectSound WaveOut drivers de
sistema MIDI. [1]
5. Outras utilidades
• Funções matemáticas;
• Teclado, mouse e joystick;
• Manipulação de arquivos compactados no
formato LZSS;
• Ferramenta para criação de arquivo de dados
(grabber);
• GUI simples para diálogos e seleção de arquivo.
[1]
6. Instalação
6.1. Utilizando o MinGw
Para instalar o compilador MinGw é necessário trazer
a biblioteca Allegro. Há uma versão compactada em
binário para o compilador MinGw disponível no site
http://www.allegro.cc. Basta descompactar o arquivo no
diretório aonde foi instalado o compilador MinGw e os
arquivos DLLs(all* /dll) da biblioteca devem ser copiados
para o diretório apropriado do Windows.
Os arquivos dll estarão armazenados no diretório
principal do MinGw.
6.2. Utilizando o DJGPP
Para instalar o compilador DJGPP é necessário trazer
a biblioteca Allegro. Caso exista algum arquivo de nome
allxyz.zip entre os arquivos de instalação do
DJGPP/GCC, não é necessário baixa-lo novamente. Em
seguida deve-se criar um diretório do DJGPP/GCC e
extrair os arquivos do arquivo.zip para o diretório.
O segundo passo é compilar os arquivos fonte, para
isto abra o Pront do MS-DOS, mude para o diretório do
Allegro e digite make. No término digite make install
para que o Allegro seja instalado, isto fará com que o
2
DJGPP/GCC possa utiliza-lo. Após o make deve-se
verificar se os arquivos allegro.h e liballeg.a estão nos
respectivos diretórios: c:\DJGPP\Include e C:\DJGPP\Lin.
Caso não esteja deve-se copiar manualmente.
7. Principais Rotinas
7.1. Rotinas básicas
As rotinas básicas são as de inicialização do Allegro:
• int allegro_init(); responsável pela inicialização
da biblioteca Allegro e das variáveis globais e
pela reserva de memória;
• void allegro_exit(); esta função encerra o
Allegro. Quando chamada o programa retorna
para o modo texto, remove qualquer rotina de
mouse, teclado ou temporização que tenha sido
instalada;
7.2. Rotinas de vídeo
• void set_color_depth (int depth); Função
responsável pela configuração do número de bit
de cores que é determinado pelo parâmetro de
depth. Os valores que podem ser passados pelo
parâmetro depth são 8,15,16,24 e 32. Esta
função deve ser chamada antes da função
set_gfx_mode.
• Int set_gfx_mode (int card, int w,int h,int
v_w,int v_h); Esta função faz o Allegro mudar
para o modo gráfico. O parâmetro card deve ser
um dos seguintes parâmetros: GFX_TEXT,
GFX_AUTO DETECT, GFX_VGA,
GFX_MODEX, GFX_VESA1, GFX_VESA2B,
GFX_VESA2L, GFX_VESA3, GFX_VBEAF
ou GFX_XTENDED.
7.3. Rotinas de Bitmaps
Todos os gráficos carregados na tela ou na memória
são tratados pelo Allegro como Bitmaps. Os Bitmaps são
matrizes de pixels em que cada valor indica uma cor.
Estes estão definidos no arquivo Allegro.h como screen.
Para a declaração de um bitmap usa-se:
BITMAP*nome_do_bitmap;
Extern BITMAP *screen;
• BITMAP *create_bitmap (int width, int height);
Cria um bitmap na memória com largura width
 e altura height. O retorno do valor é o endereço
da área de memória aonde foi alocado;
• BITMAP *load_bitmap (char *filename,
PALLETE pal); Destrói o bitmap apontado por
bitmap, liberando a memória ocupada;
• Int save_bitmap (char *filename, BITMAP
*bmp, PALETTE pal); Salva o bitmap apontado
por bmp, com a paleta apontada por pal no
arquivo de nome filename. A função retorna um
número diferente de zero caso ocorra algum
erro;
• Void putpixel (BITMAP *bmp, int x, int y, int
color); Desenha um ponto na coordenada
especificada e de cor especificada.;
• Void line (BITMAP *bmp, int x1, int y1, intx2,
int y2, int color); Desenha uma linha na
coordenada especificada, de (x1,y1) até (x2,y2);
• Void hline (BITMAP *bmp, int x1, int y, int x2,
int color); Desenha uma linha horizontal;
• Void vline (BITMAP *bmp, int x, int y1, int y2,
int color); Desenha uma linha vertical;
• Void triangle (BITMAP *bmp, int x1, int y1, int
x2, int y2, int x3, int y3, int color); Desenha um
triângulo;
• Void rect (BITMAP *bmp, int x1, int y1, int x2,
int y2, int color); Desenha um retângulo;
• Void rectfill (BITMAP *bmp, int x1, inty1, int
x2, in y2, int color); Desenha um retângulo;
• Void polygon (BITMAP *bmp, int vertices, int
*points, int color); Desenha um polígono com
vertices especificados pelo vetor points. O vetor
é um par de coordenadas (x,y);
• Void circle (BITMAP *bmp, int x, int y, int
radius, int color); Desenha uma circunferência
de centro (x, y);
• Void circlefill (BITMAP *bmp (BITMAP *bmp,
int x, int y, int radius, int color); Desenha um
círculo);
• Void blit (BITMAP *source, BITMAP *dest, int
source_x, int source_y, int dest_x, int dest_y, int
width, int height); Copia uma area retangular
para a coordenada (dest_x, dest_y) do bitmap
apontado por dest;
• Void draw_sprite (BITMAP *bmp, BITMAP
*sprite, int x, int y); Copia o bitmap inteiro,
apontado por sprite, do bitmap apontado por
bmp.
7.4. Rotinas de Paletas
No Allegro todas as funções de desenho utilizam
parâmetros inteiros para representar as cores. No modo
256 cores, por exemplo, esses valores representam os
3
índices de um vetor onde cada elemento representa as
intensidades de uma certa cor. Este vetor chama-se
paleta.
Funções:
• PALETTE nome_da_paleta; Inicializa a função;
• Extern PALETTE desktop_pallete; Paleta
default;
• Void set_palette (PALETTE p); Função que
seleciona a paleta especificada por p para ser
utilizada;
• Void set_palette_range (PALETTE p; int from,
int to, int vsync); Esta função fornece o mesmo
resultado que a set_palette, diferenciando-as
pelo fato de que apenas um trecho da paleta é
selecionado para o uso;
• Void get_palette (PALETTE p); Função
responsável pelo armazenamento da paleta
utilizada em p;
• Void get_palette_range (PALETTE p; int from,
int to); Armazena uma parte da paleta;
• Void fade_in (PALETTE p, int speed); Função
que altera gradualmente as cores da paleta,
desde a black_palette até a paleta p. Speed
controla a velocidade da alteração;
• Void fade_out (int speed); Função que altera
gradualmente as cores da paleta até atingir a
black_palette com velocidade speed;
• Void fade_in_range (PALETTE p, int speed, int
from, int to); Função que altera gradualmente as
cores da paleta, desde a black_palette até a
paleta p, com velocidade speed;
• Void fade_from (PALETTE source, PALETTE
dest, int speed); Função que altera
gradualmente as cores da paleta, desde a paleta
source até a paleta dest, com velocidade speed.
7.5. Rotinas de Fontes
O Allegro define um tipo Font, que contém as
descrições das fontes que podem vir a ser desenhadas na
tela.
Declaração da função: FONT *nome_da_fonte;
Funções:
• Extern FONT *font; Fonte padrão para algumas
tarefas do Allegro. Esta pode ser alterada para
que o Allegro utilize na fonte;
• Extern FONT *font; fonte padrão para algumas
tarefas do Allegro. Pode ser alterada;
• Void text_mode (int mode); Altera o modo de
desenho do texto. Caso mode for zero ou
positivo, o fundo dos caracteres terá a cor do
 código mode.Caso seja negativo, o fundo será
transparente. O padrão é zero;
• Void textout (BITMAP *bmp,FONT *f,unsigned
char *s, int x,int y,int color ); Esta função
escreve a string s, na coordenada (x,y) apontado
por bmp, utilizando a fonte de f e a cor color. Se
o valor de color for -1 a cor utilizada será a cor
original do bitmap da fonte;
• Void textout_center (BITMAP *bmp, FONT *f,
unsigned char *s,int x,int y,int color); Imprime
a string s centralizada na coordenada (x,y);
• Void textprintf (BITMAP *bmp, FONT *f,int x,
int y,int color,char *fmt ... ); Escreve um texto
formatado no bitmap;
• Void textprintf_center (BITMAP *bmp, FONT
*f,int x,int y,int color,char *fmt,... ); Imprime o
texto centralizado na coordenada especificada.
7.6. Rotinas de Teclado
Funções:
• Int install_keyboard (); Inicializa a função;
• Void remove_exit(); Libera o teclado para a
BIOS; Geralmente usada quando deseja-se
encerrar a função install_keyboard;
• Void clear_keyboard (); Limpa o buffer do
teclado. Esta limpeza garante que qualquer
tecla que tenha sido pressionada e não lida
pela função readkey seja apagada;
• Int keypressed (); Retorna verdadeiro caso
alguma tecla tenha sido pressionada e que
esteja no buffer a espera da leitura;
• Int readkey(); Retorna o próximo buffer do
teclado. Caso o buffer esteja vazio, a função
aguarda até que alguma tecla seja
pressionada;
• Extern volatile char key [Key_Max];
Verifica se alguma tecla está sendo
pressionada.
7.7. Rotinas de Som
A configuração do som exige apenas o uso de uma
função. Esta função inicializa os dispositivos digitais e os
do tipo MIDI.
Funções:
• Install_sound (int digi_card, int midi_card, char
*cfg_path); Inicializa a função;
• Void remove_soud(); Remove a função de som;
4
• Midi *.Load_midi (char *filename); Carrega um
arquivo midi retornando um ponteiro para uma
estrutura midi;
• Int play_midi (MIDI *midi, int loop); Executa o
arquivo midi especificado por midi;
• Void stop_midi(); Interrompe qualquer midi que
esteja sendo tocado;
• SAMPLE *load_sample (char *filename); Um
arquivo sample é carregado, retornando um
ponteiro para uma estrutura sample;
• Int play_sample (SAMPLE *spl, int vol, int
pam, int freq, int loop); Inicializa o sample
especificado por spl utilizando os argumentos
vol, pan, freq e loop;
• Void stop_sample (Sample *sql); Faz parar de
tocar o sample especificado por spl.
7.8. Rotinas de Mouse
• Int install_mouse(); Inicializa o mouse para ser
usado pelo Allegro;
• Void remove_mouse(); Interrompe o controle do
Allegro sobre o mouse;
• Extern volatile int mouse_x; extern volatile int
mouse_y; Estas duas funções guardam a posição
x e y do cursor do mouse;
• Extern volatile int mouse_b; Guarda o estado
atual do pressionamento dos botões do mouse;
• Void set_mouse_range (int x1, int y1, int x2, int
y2); Esta função define qual a dimensão de
deslocamento que o ponteiro do mouse pode ter
na tela.
7.9. Rotinas de Timer
Funções:
• Int install_timer; Esta função é a mais
importante, pois deve ser chamada antes de se
usar qualquer função de timer, antes de mostrar
o ponteiro do mouse e tocar uma midi;
• Void remove_timer(); Remove o temporizador
do Allegro;
• Int install_int (void (*proc)(),int speed);
Inicializa um temporizador para ser utilizado a
cada intervalo de speed;
• Void remove_int (void (*proc)()); Remove o
temporizador usado pela função proc;
• Lock_variable(variavel); lock_function(função);
End_of_function(funcao); Quando utiliza-se
temporizadores, são necessários utilizar esses
três macros;
 • Void rest(long time); O programa é get_config_float(const char *section, const char
interrompido (pause) por time milisegundos.
7.10. Rotinas de DataFile
DataFile: É um arquivo com extensão .dat. Este
arquivo é capaz de armazenar diversos arquivos, de
extensões diferentes, que podem ser carregados durante a
execução do programa.
Para gerar um arquivo DataFile pode-se utilizar um
utilitário chamado Grabber, que está armazenado no
diretório tools do Allegro.
Para acessar um arquivo DataFile:
DATAFILE *dat + a função load datafile;
DATAFILE *load_datafile(const char *filename);
Um arquivo chamado filename é aberto como um
arquivo datafile. Se algum erro ocorrer, a função retorna
Null.
7.11. Rotinas de Arquivos de Configuração
Funções:
• Void set_config_file (const char *filename);
Esta função faz o Allegro utilizar o arquivo
filename para futuras chamadas a outras funções
de arquivos de configuração;
• Void set_config_string (const char *section,
const char *name, const char *val); Uma string
é escrita no arquivo de configuração na chave
name da seção section;
• Void set_config_id (const char *section, const
char *name, int val); Escreve um ID no arquivo
ao invés de uma string;
• Void set_config_int (const char *section, const
char *name, int val ); void set_config_hex(const
char *section, const char *name, int val ); void
set_config_float(const char *section, const char
*name, float val ); As três funções escrevem
respectivamente: números inteiros,
hexadecimais e de ponto flutuante;
• Const char *get_config_string (const char
*section, const char *name, const char *def);
Função que lê um arquivo de configuração atual
da chave name da seção section;
• Int get_config_id (const char *section, const
char *name, int def); Esta função lê uma ID do
arquivo de configuração;
• Int get_config_int (const char *section, const
char *name, int def); int get_config_hex (const
char *section, const char *name, int def ); int
5
*name, float def ); Estas três funções lêem
respectivamente: um inteiro, um hexadecimal e
um ponto flutuante do arquivo de configuração.
8. Técnicas de Programação
8.1. Double Buffering
Quando uma animação é feita usando o Allegro,
surgem alguns problemas relacionados aos vários
métodos que podem ser utilizados.
A forma mais simples de animação é aquela em que a
tela é limpa. Em seguida desenham-se os objetos, limpa-
se novamente, e desenham-se os objetos novamente, mas
em posições diferentes formando uma seqüência
animada. Este método não funciona corretamente, pois a
tela pisca a cada limpeza. Para corrigir este problema
usa-se a técnica chamada Double Buffering.
8.2. Scrolling
Uma das principais técnicas utilizadas em jogos é o
scrolling. O scrolling consiste em movimentar o fundo do
cenário e, normalmente, deixar o personagem controlado
parado, o que causa uma sensação de movimento. O
scrolling pode ser horizontal, vertical ou em ambas as
direções.
Um tipo especial de scrolling que é muito utilizado é o
parallax scrolling. Ele consiste num scrolling em que
vários fundos se movimentam em velocidades diferentes,
causando uma sensação de profundidade.
8.3. Sprites
Sprite é o conjunto de dados que definem determinado
objeto ou personagem num jogo.
Para uma pessoa, por exemplo, pode-se ter um sprite
que contenha as posições vertical e horizontal dela no
mundo, a direção para onde ela está virada e os bitmaps
que podem representa-la durante o jogo.
8.4. Detecção de Colisões
Em inúmeras ocasiões é necessário verificar se dois
sprites estão sobrepostos ou não. Para isso, existem vários
métodos de detecção de possíveis colisões. A mais
simples envolve apenas alguns testes lógicos e
matemáticos, as complexas envolvem vários testes e
cálculos.
As rotinas de colisões são muito usadas nos jogos além
de serem fundamentais, pois praticamente todo jogo que
envolva ações possui essas rotinas.
8.4.1. Detecção baseada em retângulos: A detecção
baseada em retângulos é comum em jogos 2D, pois
muitas vezes são utilizados os próprios sprites do jogo
para fazer os testes. O teste consiste basicamente em
efetuar quatro testes que referem aos lados dos
retângulos.
8.4.2. Detecção baseada em círculos: A detecção
baseada em círculos é menos comum do que a colisões
em retângulos. Porém a de círculos é mais simples e
basicamente efetua cálculos matemáticos.
9. Jogos
9.1. Estrutura de um Jogo
Um jogo pode ser estruturado desta forma:
1. Inicialização: um jogo é configurado de uma
forma que comece num estado padrão, com suas
variáveis devidamente inicializadas e os drivers
de vídeo e som funcionando; [2]
2. Loop principal: O jogo em si, onde será feito
todo o processamento até que o jogador termine
o jogo de alguma forma, morrendo, terminando
ou desistindo. Durante esse loop, três partes são
distintas:
- Entrada: os valores são lidos do teclado,
mouse ou joystick;
- Processamento: mover os objetos, de
acordo com a entrada;
- Visualização: mostrar ao jogador o que
ocorreu de acordo com seus comandos. [2]
3. Finalização: Devem ser fornecidas ao jogador,
informações do que aconteceu, atualizar alguma
tabela de escores, mostrar alguma animação de
encerramento. [2]
Para fazer com que o jogo execute mais de uma vez,
sem haver a necessidade de retornar ao sistema
operacional, muitos jogos possuem o loop principal
contido em um outro loop.
10. Exemplo comentado
Este exemplo cria um labirinto e uma lua. Este
labirinto aparenta ser 3D, mas não é.
1. include <stdio.h>
2. include <conio.h>
3. include <allegro.h>
4. #define MAXX 640
5. #define MAXY 480
6
6. BITMAP *plano[2];
7. int main(void); //Função principal
8. void draw_lab(void); //desenha labirinto
9. void draw_bkd(void); //desenha fundo
10. int main(void)
11. {
12. //Imprime menu
13. printf("\nEste programa desenhara o básico de um
labirinto 3D e um fundo");
14. printf("\nNada Será' implementado por enquanto,
alem dos gráficos.\n");
15. getch(); //Aguarda uma tecla ser pressionada
16. allegro_init();
17. install_keyboard();
18. set_color_depth(8);
19. if
(set_gfx_mode(GFX_AUTODETECT_FULLSCREEN,
MAXX, MAXY, 0, 0) < 0) {
20. printf("%s\n", allegro_error);
21. exit(1);
22. }
23. plano[0] = create_bitmap_ex(8,MAXX,MAXY);
24. plano[1] = create_bitmap_ex(8,MAXX,MAXY);
25. draw_lab();
26. draw_bkd();
27. blit(plano[1], screen, 0, 0, 0, 0, MAXX, MAXY);
28. masked_blit(plano[0], screen, 0, 0, 0, 0, MAXX,
MAXY);
29. readkey();
30. allegro_exit();
31. return 0;
32. }
33. END_OF_MAIN()
34. void draw_lab(void)
35. {
36. clear_to_color(plano[0],0);
37. line(plano[0], 0, 0, 639, 479, 2);
38. line(plano[0], 639, 0, 0, 479, 2);
39. line(plano[0], 0, 0, 639, 0, 2);
40. line(plano[0], 639, 0, 639, 479, 2);
41. line(plano[0], 639, 479, 0, 479, 2);
42. line(plano[0], 0, 479, 0, 0, 2);
43. line(plano[0], 0, 68, 90, 68, 2);
44. line(plano[0], 90, 105, 140,105, 2);
45. line(plano[0], 140, 135, 180,135, 2);
46. line(plano[0], 180, 158, 210,158, 2);
47. line(plano[0], 210, 180, 240,180, 2);
48. line(plano[0], 240, 195, 260,195, 2);
49. line(plano[0], 260, 210, 280,210, 2);
50. line(plano[0], 280, 218, 290,218, 2);
51. line(plano[0], 90, 68, 90, 412, 2);
52. line(plano[0], 140, 105, 140, 375, 2);
53. line(plano[0], 180, 135, 180, 345, 2);
54. line(plano[0], 210, 158, 210, 322, 2);
 55. line(plano[0], 240, 180, 240, 300, 2);
56. line(plano[0], 260, 195, 260, 285, 2);
57. line(plano[0], 280, 210, 280, 270, 2);
58. line(plano[0], 290, 218, 290, 262, 2);
59. line(plano[0], 300, 225, 300, 255, 2);
60. hline(plano[0], 0, 412, 90, 2);
61. hline(plano[0], 90, 375, 140, 2);
62. hline(plano[0], 140, 345, 180, 2);
63. hline(plano[0], 180, 322, 210, 2);
64. hline(plano[0], 210, 300, 240, 2);
65. hline(plano[0], 240, 285, 260, 2);
66. hline(plano[0], 260, 270, 280, 2);
67. hline(plano[0], 280, 262, 290, 2);
68. hline(plano[0],550 ,68 ,639, 2);
69. hline(plano[0],500 ,105 ,550, 2);
70. hline(plano[0],460 ,135 ,500, 2);
71. hline(plano[0],430 ,158 ,460, 2);
72. hline(plano[0],400 ,180 ,430, 2);
73. hline(plano[0],380 ,195 ,400, 2);
74. hline(plano[0],360 ,210 ,380, 2);
75. hline(plano[0],350 ,218 ,360, 2);
76. vline(plano[0], 550, 68, 412, 2);
77. vline(plano[0], 500, 105, 375, 2);
78. vline(plano[0], 460, 135, 345, 2);
79. vline(plano[0], 430, 158, 322, 2);
80. vline(plano[0], 400, 180, 300, 2);
81. vline(plano[0], 380, 195, 285, 2);
82. vline(plano[0], 360, 210, 270, 2);
83. vline(plano[0], 350, 218, 262, 2);
84. vline(plano[0], 340, 225, 255, 2);
85. line(plano[0], 550 ,412 ,639, 412,2);
86. line(plano[0], 500 ,375 ,550, 375,2);
87. line(plano[0], 460 ,345 ,500, 345,2);
88. line(plano[0], 430 ,322 ,460, 322,2);
89. line(plano[0], 400 ,300 ,430, 300,2);
90. line(plano[0], 380 ,285 ,400, 285,2);
91. line(plano[0], 360 ,270 ,380, 270,2);
92. line(plano[0], 350 ,262 ,360, 262,2);
93. hline(plano[0], 290, 225, 350, 2);
94. hline(plano[0], 290, 255, 350, 2);
95. }
96. void draw_bkd(void)
97. {
98. floodfill(plano[1], 10, 10, 16);
99. circlefill(plano[1], 200, 100, 50, 15);
100.circle(plano[1], 200, 100, 50, 16);
101.arc (plano[1], 250, 100, itofix (96), itofix (160), 70,
7);
102. floodfill(plano[1], 170,100,7);
103. }
Linhas 1,2 e 3: Declarações das bibliotecas utilizadas;
Linhas 4 e 5: São definições;
Linha 6: Variável Global;
7
Linhas 7, 8 e 9: Protótipos;
Linhas 13, 14 e 15: Imprime o menu;
Linha 16: Inicia o Allegro;
Linha 17: Inicia o teclado;
Linha 18: Inicializa modo gráfico com profundidade
de cor em 8 bits;
Linhas 19..22: Inicia modo gráfico. Se não for
possível, mostra uma mensagem de erro e sai do
programa;
Linhas 23 e 24: Cria os planos na mesma resolução da
tela;
Linhas 25 e 26: Chamam as funções e desenham as
imagens;
Linhas 27 e 28: Mostram a tela com transparência;
Linha 29: Espera uma tecla ser pressionada;
Linha 30: Finaliza o Allegro;
Linha 31,32 e 33: Sai do programa;
Linha 34: Funcao que desenha o labirinto;
Linha 36: Pinta o BITMAP para a cor
zero(transparente);
Linhas 37 e 38: Desenham figuras no primeiro plano.
Linhas diagonais;
Linhas 39.. 42: Desenham um quadrado em volta da
tela;
Linhas 43.. 50: Desenha as linhas horizontais de
corredores a esquerda;
Linhas 51.. 59: Desenham as linhas verticais da
esquerda;
Linhas 60.. 67: Desenham as linhas horizontais de
corredores a esquerda - parte de baixo;
Linhas 68..75: Desenham as linhas horizontais de
corredores a direita;
Linhas 76..84: Desenham as linhas verticais da direita;
Linhas 85..92: Desenham as linhas horizontais de
corredores a direita - parte de baixo;
Linhas 93 e94: Desenham a linha do corredor do
fundo;
Linha 96: Desenha o fundo;
Linha 98: Pinta o fundo do plano 2. Plano 2 = plano[1]
Linha 99: Desenha um circulo cheio, na cor branca;
Linha 100: Faz um contorno preto na Lua;
Linha 101: Desenha a linha que separa a parte
iluminada da parte escura da lua;
Linha 102: Pinta a parte escura da lua; [3]
11. Licença
"Allegro is gift-ware. It was created by a number of
people working in cooperation, and is given to you freely
as a gift. You may use, modify, redistribute, and
generally hack it about in any way you like, and you do
not have to give us anything in return.
 However, if you like this product you are encouraged [3] XuTi Game Development.
to thank us by making a return gift to the Allegro http://www.xuti.net/
community. This could be by writing an add-on package,
providing a useful bug report, making an improvement to
the library, or perhaps just releasing the sources of your
program so that other people can learn from them. If you
redistribute parts of this code or make a game using it, it
would be nice if you mentioned Allegro somewhere in
the credits, but you are not required to do this. We trust
you not to abuse our generosity." [1]
Cabeçalho exigido no código fonte do programa, caso
algum programador utilize a biblioteca gráfica Allegro:

Há outras restrições que devem ser consultadas na

documentação do Allegro.

12. Conclusões

Concluímos ao término deste artigo que a

programação de jogos e a utilização da biblioteca gráfica
Allegro são ferramentas indispensáveis no meio
acadêmico, pois exercita a lógica e a programação do
estudante. O Allegro é uma biblioteca extremamente
simples e fácil de se entender, tornando-se uma
ferramenta muito utilizada por estudantes iniciantes na
área de programação de jogos. Assim como a linguagem
Pascal que é utilizada por muitas universidades como
uma ferramenta didática para os iniciantes em
programação, a biblioteca Allegro deve ser utilizada
também didaticamente.

13. Referências

[1] Allegro, a game programming library.

http://www.talula.demon.co.uk/allegro
[2] Allegro: Biblioteca de programação para Jogos.
http://www.inf.unisinos.br/~barbosa/linguagens/consipro
2/allegro/allegro.pdf