Allegro is a C++ game programming package, open source, and easy to use.

1. Biblioteca Allegro
Monitoria de Introdução à computação – if669ec
Thais Alves de Souza Melo - tasm
2011.2

2. Instalação
• Code::Blocks do site da disciplina já o possui instalado
• Guia para instalação manual:
http://wiki.allegro.cc/index.php?title=Code::Blocks
• Instalação facilitada:
http://www.unidev.com.br/phpbb3/viewtopic.php?f=11&t=45
265

3. Criação do Projeto

4. Hello World

5. Init( )
• int allegro_init();
• Inicializa o Allegro, devendo ser chamada antes de qualquer outra
função da biblioteca.
• int install_timer();
• int install_keyboard();
• int install_mouse();
• Funções que instalam, respectivamente, o temporizador, teclado e
mouse.
• int install_sound(int digi_card, int midi_card, char *cfg_path);
• Não vem por padrão no init() ;. Ativa o som no Allegro.
• Digi_card e midi_card referem-se aos controladores de som digital e
MIDI, respectivamente. Passá-los como DIGI_AUTODETECT e
MIDI_AUTODETECT para que o allegro selecione o driver.
• O parâmetro cfg_path refere-se à compatibilidade com versões
anteriores, e pode ser ignorado passando-se NULL.

6. Init( )
• void set_color_depth(int depth);
• Determina a quantidade de bits a serem utilizados pelos gráficos
(depth). Posem ser:
•
•
•
•
•
8 (256 cores)
15 (32768 cores)
16 (65536 cores)
24 (aproximadamente 32 milhões de cores)
32 (aproximadamente 4 bilhões de cores)
• int set_gfx_mode(int card, int w, int h, int v_w, int v_h);
• Inicializa o modo gráfico. Card representa o driver gráfico a ser
utilizado (ex.: GFX_AUTODETECT, para que o Allegro detecte
automaticamente a placa de video), w e h representam o
tamanho horizontal e vertical em pixels da tela. v_w e v_h
indicam a resolução de uma possível tela virtual.

7. Deinit( )
• void allegro_exit();
• Utilizada ao final do programa para finalizar o Allegro. Não
precisa ser necessariamente chamada, pois allegro_init
determina que ela seja chamada automaticamente quando o
programa é encerrado.

8. Alguns Tipos Definidos
• BITMAP
• Tipo definido pelo Allegro para manipular facilmente bitmaps,
que seriam matrizes de pixels, em que cada elemento indica uma
cor.
• Declaração: BITMAP *nome ;
• O allegro define automaticamente um BITMAP screen, referente
à tela.
• PALLETE
• Vetor de 256 posições em que cada uma representa um código
de cor.
• Declaração: PALLETE nome ;

9. Alguns Tipos Definidos
• FONT
• Contém a descrição das fontes que podem ser utilizadas na tela
• Declaração: FONT *nome ;
• MIDI
• Declaração: MIDI *nome ;
• SAMPLE
• Declaração: SAMPLE *nome ;
• Os tipos FONT e PALLETE não serão utilizados.

10. Teclado
• O Allegro trabalha com um vetor key[] de 127 posições, cujos
elementos representam as teclas. Para facilitar, são definidas
constantes que facilitam a busca de um elemento no vetor:
• Exemplo: key[KEY_ESC]
Tecla
A, B ... Z
Código na Array
KEY_A, KEY_B...KEY_Z
KEY_0_PAD
Teclado Numérico 0 a 9 ...
KEY_9_PAD
Teclado Normal 0 a 9 KEY_0 ... KEY_9
Esc
KEY_ESC
Enter
KEY_ENTER
Seta para a Direita
KEY_RIGHT
Seta para a Esquerda KEY_LEFT
Seta para Cima
KEY_UP
Seta para Baixo
KEY_DOWN
Tecla
Pause
Código na Array
KEY_PAUSE
Barra de Espaço
KEY_SPACE
Print Screen
Shitf Esquerdo
Shift Direito
Control Esquerdo
Control Direito
Alt esquerdo
Alt Direito
KEY_PRTSCR
KEY_LSHIFT
KEY_RSHIFT
KEY_LCONTROL
KEY_RCONTROL
KEY_ALT
KEY_ALTGR

11. Exemplos
• while(!key[KEY_ESC])
{
...
}
• if(key[KEY_ENTER])
{
...
}
Executará o código enquanto ESC
Não estiver pressionado.
Entrará no if apenas se ENTER estiver
Pressionado

12. Texto
• void textout_ex(BITMAP *bmp, const FONT *f, const char *s, int x, int y, int
color, int bg);
• Imprime uma string na tela na posição x, y. Color refere-se a cor do texto e bg a
cor do fundo do texto.
• void textprintf_ex(BITMAP *bmp, const FONT *f, int x, int y, int color, int bg,
const char *fmt, ...);
• Imprime uma string na tela de forma parecida à printf(), permitindo a passagem
de parâmetros como %d, %c etc..
• int makecol(int r, int g, int b);
• Converte cores do formato RGB para o formato aceito pelas funções.
• Obs1.: 0 equivale a cor preta e -1 ou makecol(255, 0, 255) à transparente.
• Obs2.: Passar o parâmetro FONT como “font” (sem aspas) para utilizar a fonte
própria do sistema.
• Obs3.: Ambas possuem variantes que imprimem o texto centralizado,
justificado ou alinhado à direita.

13. Primitivas de Imagem
• int getpixel(BITMAP *bmp, int x, int y);
• Lê um o pixel da coordenada (x, y) de um BITMAP.
• int getr(int c);
• int getg(int c);
• int getb(int c);
• Retornam respectivamente os valores de R, G e B de um
determinado pixel (pego pelo getpixel()).
•
•
•
•
•
void putpixel(BITMAP *bmp, int x, int y, int color);
void line(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);
void triangle(BITMAP *bmp, int x1, y1, x2, y2, x3, y3, int color);
void rect(BITMAP *bmp, int x1, int y1, int x2, int y2, int color);
void circle(BITMAP *bmp, int x, int y, int radius, int color);

14. Carregando imagens
• BITMAP *create_bitmap(int width, int height);
• Cria um bitmap de memória do tamanho especificado.
• BITMAP *load_bitmap(const char *filename, RGB *pal);
• Carrega um arquivo bitmap do disco. RGB* pal refere-se à paleta de cores,
aplicada apenas a imagens de 8 bits. Passar como NULL.
• void destroy_bitmap (BITMAP *bitmap);
• Libera a memória utilizada por um bitmap.
• void clear_bitmap(BITMAP *bitmap);
• Limpa um bitmap para a cor preta.
• void clear_to_color(BITMAP *bitmap, int color);
• Análoga àcima, porém com a escolha da cor para a qual será limpo o bitmap.
• Obs.: Não é necessário utilizar a função create_bitmap antes da load_bitmap!

15. Blitting e Sprites
• void blit(BITMAP *source, BITMAP *dest, int source_x,
int source_y, int dest_x, int dest_y, int width, int height);
• Copia uma área retangular (width x height) do bitmap de fonte (source)
em um bitmap de destino (dest). Não aceita o rosa puro como
transparante.
• void draw_sprite(BITMAP *bmp, BITMAP *sprite, int x, int y);
• Copia o bitmap de origem (sprite) diretamente no bitmap de
destino (bmp). Aceita o rosa puro como transparente.
• Obs.: Ambas as funções acima possuem variantes que
espelham, aumentam ou rotacionam as imagens.

16. Exemplo
•
•
•
•
•
•
•
•
•
•
•
...
BITMAP* buffer, *imagem ;
buffer = create_bitmap(60, 60) ;
imagem = load_bitmap(“imagem.bmp”, NULL) ;
...
blit(imagem, buffer, 100, 100, 0, 0, 60, 60) ;
draw_sprite(screen, buffer, 400, 300) ;
...
Podemos usar o clear_bitmap()
destroy_bitmap(imagem) ;
aqui, caso ainda precisemos usar
destroy_bitmap(buffer) ;
os BITMAPs.
...

17. Double Buffering
• Desenhar os bitmaps diretamente no screen faz e depois
limpá-lo faz com que a tela “pisque” a cada troca de frame,
gerando um efeito visualmente desconfortável. Para evitar
esse problema, é utilizada a técnica de double buffering:
• Cria-se um BITMAP* buffer de memória, em geral do tamanho da
tela e nele são desenhados todos os elementos desejados.
• O buffer é desenhado então na tela e é depois limpado, e assim
sucessivamente para os outros frames. Não usar clear_bitmap na
screen!

18. Exemplos
Sem Double Buffering:
int main(){
init();
while (!key[KEY_ESC]){
textout_centre_ex(screen, font, "Sem Double Buffering", 320, 240, makecol(255, 255, 255), 0);
clear_bitmap(screen) ;
}
deinit();
return 0;
}
END_OF_MAIN()
Com Double Buffering:
int main(){
init();
BITMAP* buffer = create_bitmap(640, 480) ;
while (!key[KEY_ESC]){
textout_centre_ex(buffer, font, "Com Double Buffering", 320, 240, makecol(255, 255, 255), 0);
draw_sprite(screen, buffer, 0, 0) ;
clear_bitmap(buffer) ;
}
deinit();
return 0;
}
END_OF_MAIN()

19. Som – MIDI
• MIDI *load_midi(const char *filename);
• Carrega um arquivo MIDI.
• void destroy_midi(MIDI *midi);
• Libera a memória do arquivo carregado.
• int play_midi(MIDI *midi, int loop);
• Toca o arquivo MIDI indicado, parando a execução de qualquer
outro MIDI. Se loop receber qualquer valor diferente de 0, tocará
até ser parado ou substituído.
• void stop_midi();
• Pára qualquer MIDI que esteja sendo executada (funciona de
maneira semelhante à play_midi(NULL, false) ;)

20. Som – Sample
• SAMPLE *load_sample(const char *filename);
• Carrega um SAMPLE.
• void destroy_sample(SAMPLE *spl);
• Libera a memória ocupada por um SAMPLE.
• int play_sample(const SAMPLE *spl, int vol, int pan, int freq, int loop);
• Toca um sample. Vol e pan variam de 0(min/esquerda) à 255(máx/direita).
Freq indica a velocidade com que o som é executado, sendo 1000 a
velocidade normal. Loop indica a quantidade de vezes para repetir um som.
• void stop_sample(const SAMPLE *spl);
• Pára a execução de um sample.
• Obs.: Diferente dos MIDI, podem ser executados vários SAMPLEs ao
mesmo tempo.

21. Mouse
• O mouse em allegro se comporta como um objeto, possuindo as
variáveis mouse_x e mouse_y que indicam sua posição.
• A variável mouse_b indica qual botão do mouse está sendo
pressionado, sendo o bit 0 o botão esquerdo, o bit 1 o botão direito e o
bit 2 o botão do meio.
• Sintática da comparação:
• If(mouse_b & 1) printf(“Botao esquerdo apertado”) ;
• If(!(mouse_b & 1)) printf(“Botao esquerdo não apertado”) ;
• Atenção: comparação bit a bit! (apenas um ‘&’)
• void position_mouse(int x, int y);
• Coloca o mouse na posição x e y indicada
• void show_mouse(BITMAP *bmp);
• Desenha o mouse no bitmap apontado. Para não exibir mouse, passar NULL
como argumento. Obs.: Funciona apenas com o timer instalado

22. Temporizador
• A priori, para o controle da velocidade do jogo, temos a
função void rest(unsigned int time); que faz com que o
computador aguarde “time” milissegundos para executar o
próximo comando.
• Porém, em computadores mais lentos, isso pode prejudicar o
andamento do jogo, pois os comandos seriam executados
mais lentamente, o que levaria a necessidade de um rest
menor ou até sua ausência para que a velocidade se
mantivesse.
• O uso de temporizadores resolve este problema.

23. Temporizador - Exemplo
volatile long int contador = 0 ;
void timer_game () ;
…
void timer_game ()
{
contador++ ;
}
END_OF_FUNCTION(timer_game) ;
...
int main()
{
Variável global!
...
LOCK_VARIABLE(contador) ;
LOCK_FUNCTION(timer_game) ;
install_int (timer_game, TBF) ;
...
}
TBF = Time Between Frames

24. Exercício
• Implementar um space invaders simplificado em Allegro. Deve
possuir um menu com duas opções:
• Selecionando a primeira, deverá aparecer uma nave que se move
na horizontal controlada pelo usuário.
• Ao pressionar ESPAÇO, a nave deve atirar um projétil (velocidade
constante) na direção em que está olhando.
• Ao pressionar a tecla P, deve voltar ao menu inicial.
• A segunda opção é a de sair do programa.

25. Referências
• http://www.allegro.cc/
• http://www.allegro.cc/manual/ - Manual com funções das
versões 4 e 5 do Allegro.
• http://alleg.sourceforge.net/

26. Tutoriais
• http://www.dcc.ufrj.br/~abdalla/allegro.html
• http://www.glost.eclipse.co.uk/gfoot/vivace/ (Em Inglês)
• http://equipe.nce.ufrj.br/adriano/c/apostila/allegro/docs/alle
gro.html