Allegro para Iniciantes

Tutorial de Allegro com C++ utilizando o BloodShed DevC++ Por: Thiago "weissengeist" | weissengeist@yahoo.com.br Colaboradores: rodrigozk | rodrigozk@hotmail.com gamemasterbr | andreluizcardona@yahoo.com.br

Objetivo: O objetivo deste tutorial contribuir para que interessados em desenvolvimento de jogos possam iniciar seus estudos de maneira objetiva. Este tutorial apresenta os conceitos bsicos de programao grfica 2D, voltada para jogos. Por sua simplicidade, o Allegro o ponto de partida para iniciao programao de jogos, mas bom ressaltar que jogos comerciais so desenvolvidos com API's mais avanadas que oferecem muitos outros recursos. Para o desenvolvimento de um jogo, por mais simples que seja, necessrio muito estudo e dedicao. Este tutorial no ensina a criar jogos, mas provavelmente vai dar uma boa noo do funcionamento de funes comuns em muitas das bibliotecas grficas recomendadas para o desenvolvimento. Ao final deste estudo, o leitor dever ser capaz de: Instalar corretamente o Allego no DevC++; Entender a sintaxe e utilizao das funes da biblioteca allegro.h; Carregar Bitmaps e Textos na tela; Desenhar e pintar formas geomtricas primitivas; Mover Bitmaps com o Teclado; Detectar Coliso de Bitmaps; Utilizao de Timer, Mouse e Som.

Requerimentos: Compilador BloodShed DevC++ com MinGW/GCC: Link [7,6 MB] (voc pode utilizar outro de sua preferncia, porm estaremos dando nfase ao BloodShed DevC++) Pacote DevPak do Allegro: Link [1,86 MB] (voc pode fazer a instalao manualmente baixando os pacotes seguindo seus procedimentos, porm neste turorial ser abordada a maneira mais fcil) Conhecimento bsico da linguagem C ou C++. Voc pode obter apostilas e Tutoriais de C++ gratuitamente no site da UniDev: Link [N/A] ( importante obter conhecimento razovel programao antes de se aventurar com alguma bibliotca grfica, porm, possvel acomapanhar este tutorial durante o aprendizado da linguagem) Instalao: Iniciando nosso estudo, vamos instalar o DevC++ e o pacote do Allegro. Depois iremos testar um cdigo padro para verificar se a instalao foi feita corretamente. - Clique duas vezes no programa de instalao do BloodShed DevC++ e faa a instalao;

- Clique duas vezes no pacote do Allegro e faa a instalao utilizando o Packman*; (* Packman o gerenciador de pacotes de atualizao do DevC++, apenas um assistente de instalao).

- Se voc preferir, pode instalar o pacote do Allegro pelo prprio DevC++, para isso, clique no menu Ferramentas e escolha Package Manager:

(Essa opo ir abrir um assistente de instalaes de pacotes do DevC++) - Clique no boto Install e selecione o caminho onde voc salvou o pacote de instalao do Allegro:

- Siga todo o processo de instalao:

(DevC++ Package Installation Wizard) - Agora, certifique-se de que o Allegro foi instalado com sucesso. Crie um Novo Projeto no DevC++, Selecione a aba MultiMedia, e clique em Allegro Application(static):

(Selecione o tipo de aplicao na aba MultiMedia, nomeie o Projeto e clique em OK) Aps selecionar o Tipo de projeto e nome-lo, clique em Ok. O programa pedir que voc salve o projeto. Considere criar uma pasta com o nome do projeto onde voc ir salvar todos os arquivos fonte e classas do programa, assim como imagens e sons. Neste projeto no iremos gerar tantos arquivos, pois apenas um projeto teste para verificar se o pacote foi instalado corretamente. Ento escolha um diretrio, salve o projeto e o arquivo main.cpp. Agora pressione F9 ou clique no boto Compilar & Executar. O cdigo padro ser compilado e executado pelo DevC++ e se tudo estiver correto, seu programa no apresentar erros nem warnings, e uma janela vazia ser mostrada:

(Janala vazia gerada pelo cdigo padro da aplicao Allegro) - Utilize a tecla ESC para fechar a janela.

- Apenas a ttulo de conhecimento, veja o cdigo gerado com comentrios:

#include <allegro.h> /* Adiciona as funes do Allegro */ /* As 2 linhas seguintes so chamadas de funes por prototipao */ void init(); void deinit(); int main() { /* Essa linha vai iniciar o programa assim como em C/C++ */ init(); /* Essa linha chama a funo que inicializa as opes de vdeo*/ while (!key[KEY_ESC]) { /* enquanto a tecla pressionada for diferente de ESC a janela continua ativa*/ /* put your code here (adicionaremos nosso cdigo aqui)*/ } deinit(); /* funo para limpar o buffer */ return 0 ; /* Finaliza o Programa sem erros*/ } END_OF_MAIN(); /* Este o comando utilizado para finalizar a funo main() */ void init() { /* declarao da funo*/ int depth, res; /* variveis da funo*/ allegro_init(); /* chama funo do allegro */ depth = desktop_color_depth(); /* Atribuio de valor tirado de funo*/ if (depth == 0 ) depth = 32 ; /* verifica valor, caso ele seja zero, a varivel receve um valor pr-estipulado*/ set_color_depth(depth); /* funo de utilizao de cores, recebe valor pr-estabelecido */ res = set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640 , 480 , 0 , 0 ); /* Detecta placa de vdeo e define resoluo(640x480) */ if (res != 0 ) { /* so res for diferente de zero, por que houve erro */ allegro_message(allegro_error); /* ento exibida uma mensagem de erro gerada pela funo */ exit( -1 ); /* sai do programa informando erro */ } /* as 3 linhas a seguir, so funoes para tempo, utilizao de teclado e mouse */ install_timer(); install_keyboard(); install_mouse(); /* add other initializations here (se for necessrio, tem como adicionar outros tipos) */ } void deinit() { /* a funo que foi prototipada acima */ clear_keybuf(); /* funo para limpar o buffer do teclado */ /* add other initializations here (se for necessrio, tem como adicionar outros tipos) */ }

(Cdigo de main.cpp do projeto de exemplo com comentrios) Pronto, agora podemos comear com exemplos de utilizao do Allegro. A Sintaxe da Biblioteca: Vamos agora entender os principais comandos do Allegro. Estudaremos as funes de inicializao da biblioteca, da placa de vdeo e do teclado. Veremos tambm a funo END_OF_MAIN(), que a funo necessria para indicar o fim de main. Para um estudo deste assunto iremos escrever um cdigo totalmente novo. Ento apague todo o contedo do arquivo main.cpp, do projeto que voc acabou de criar, e siga as instrues a seguir. - Vamos carregar prottipos e as difinies do Allegro, carregando o arquivo allegro.h: #include <allegro.h>

- Como sabemos, ao declarar o arquivo de cabealho, teremos acesso s funes pr programadas que facilitam o desenvolvimento do cdigo. O arquivo includo foi allegro.h, que a biblioteca grfica a qual estamos estudando. - Vamos agora declarar a funo principal do nosso programa, a main(): #include <allegro.h> int main() { } - Agora vamos fazer as definies e chamadas de funes importantes para a utilizao do Allegro. A primeira funo que devemos chamar allegro_init(), que inicializar as funes da biblioteca. Logo aps esta funo, devemos chamar uma funo para interpretar os comandos dos dispositivos de entrada, no nosso caso, a funo install_keyboard(), referente ao teclado, e se for necessrio, outros dispositivos de entrada, como por exemplo o mouse. A funo install_keyboard() interpreta os valores do teclado de forma diferente das funes de input padro de outras bibliotecas, como por exemplo, stdio.h entre outras. Mais definies da funo, sero abordadas no tpico referente a movimentao de bitmaps com o teclado. Vejamos agora a utilizao das funes:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); }

- O prximo passo, est relacionado s definies de video. Vamos definir atravz da utilizao da funo set_color_depth(), qual ser a profundidade de cores utilizada. Essa funo pode receber valores pr estabelecidos de 8, 15, 16, 24 e 32 cores. Este nmero, regido por RGB, ou seja, variao de tonalidade de 3 cores primrias que possibilitam a utilizao de outras cores. O significado de RGB na verdade Vermelho(Red), Verde(Green) e Azul(Blue), e utilizado como padro para preenchimento de cores em Bitmaps. Exemplo:

(A cr vermelha formada atravez da RGB [255,0,0] como mostra a imagem) - Na imagem acima, vemos o princpio da utilizao de RGB. Ao Vermelho foi atribuido o nmero mximo de tonalidade, enquanto ao Verde e Azul, no foi atribuido nenhum nmero. Como a tonalidade do Verde e Azul nula, o Vermelho no se mistura com nenhuma outra cor, permanacendo nesta tonalidade. - Voltando ao Allegro, o que temos que fazer, informar funo set_color_depth(), quantos bits de cores sero utilizados:

set_color_depth(32);

- A funo set_color_depth() deve ser utilizada sempre antes da funo set_gfx_mode(). Caso contrrio, as cores de algum Bitmap, no sero exibidas corretamente. - A prxima definio de vdeo a ser feita, a definio da placa de vdeo e de sua resoluo. Para isso utilizaremos a funo set_gfx_mode(), que tem como parmetro inicial a deteco do modo de vdeo, a definio da resoluo em que a aplicao ser exibida: set_gfx_mode(GFX_AUTODETECT, 640 , 480 , 0 , 0 );

- Na linha acima, vemos a funo sendo utilizada, com o parmetro de deteco automtica da placa de vdeo com uma resoluo 640x480. Os proximos campos, onde vemos dois zeros, so respectivamente a altura e largura virtuais da tela, ou seja, partes do mapa de um jogo que no aparecem no display. Estas reas virtuais so acessadas por meio de uma funo de scrowling, ou seja, rolamento de tela. Neste exemplo no utilizaremos a rea virtual, por isso no daremos importncia para ela agora. - Veremos agora alguns dos modos de vdeo possveis e suas descries: GFX_TEXT GFX_AUTODETECT GFX_VGA GFX_MODEX GFX_VESA1 GFX_VESA2B GFX_VESA2L GFX_VESA3 GFX_VBEAF GFX_XTENDED retorna para o modo texto faz com que o Allegro escolha o driver grfico mais apropriado (normalmente tem problemas com placas de vdeo mais recentes) modo VGA (320x200, 320x100, 160x120, 80x80) uma verso planar do modo VGA (tweaked) usa o driver VESA 1.x usa o driver VBE 2.0 em modo banked usa o driver VBE 2.0 com framebuffer linear usa o driver VBE 3.0 usa o acelerador de hardware API VBE/AF usa o driver 640x480 unchained

- Como podemos perceber, os modos de video acima so definies divididas em duas partes, GFX, que se refere ao modo grfico, e os modos propriamente ditos, como por exemplo AUTODETECT. Porm, existe outro subparmetro pode ser utilizado; caso voc queira deixar seu jogo em modo fullscreen(tela cheia), voc deve declarar o modo, e no final acrescentar o sub-parmetro FULLSCREEN. Caso no o faa, a funo ir assumir default, executando seu jogos em uma janela. Voc pode especificar que quer seu programa especificamente em uma janela acrescentando WINDOWED. Veja exemplos: set_gfx_mode(GFX_AUTODETECT, 640 , 480 , 0 , 0 ); /* default */ set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640 , 480 , 0 , 0 ); /* fora janela */ set_gfx_mode(GFX_AUTODETECT_FULLSCREEN, 640 , 480 , 0 , 0 ); /* fora fullscreen */

- Uma vez definidos estes parmetros, podemos iniciar uma rotina para inserir os grficos. Como estamos utilizando a biblioteca allegro.h, no podemos exibir texto da mesma forma que fazemos com cout ou printf(), pois no fazem parte desta biblioteca. Para imprimir texto utilizaremos o seguinte comando: textout(screen, font, "texto", 1,1, makecol(255,0,0 ) );

- Vamos analizar a funo textout() e seus parmetros: textout: Chamada da funo. Indica que o bitmap a ser impresso ser do tipo texto. screen: Ponteiro tipo BITMAP definido pelo Allegro e utilizado pela funo set_gfx_mode(). Pode ser

utilizado para outras funes envolvendo BITMAPS. font: a definio do tipo de fonte utlizada para o texto, essa definio, assim como a anterior so declaradas na funo set_gfx_mode(), porm so um pouco mais complexas, e vamos deix-las de lado por no serem essenciais para o aprendizado inicial. "texto" : O texto que ser exibido. Assim como no comando printf(), o texto que ser exibido fica entra aspas("). O campo texto do tipo char, ento, possvel adicionar uma varivel do tipo string ou char no lugar do texto puro como no exemplo acima. 1,1: Esses nmeros representam respectivamente coluna e linha. So dois valores do tipo int, e pode-se usar variveis para represent-los, tornando o programa mais dinmico. O texto ser inserido na coluna e linha definidas por estes parmetros. Esses nmeros esto relacionados com a resoluo definida na funo de vdeo set_gfx_mode(), desta forma, se estes valores forem maiores que os valores da resoluo, no ser possvel visualizar o texto corretamente. makecol(255,0,0): Esta funo utilizada para determinar cor. Seu valore de sada do tipo int, o que significa que o valor da funo pode ser armazenado em uma varivel para tornar o programa mais dinmico. Os valores de entrada desta funo, esto no padro de RGB, ou seja, intensidade de 3 cores primrias: red(vermelho), green(verde) e blue(azul).

- Existem outras funes para exibio de texto, porm, no sero exploradas neste tuturial introdutrio. Mais informaes sobre exibio de texto podem ser encontradas nos links relacionados no final desta pgina. - Vamos ver como fazer para inserir estes cdigos em nosso programa utilizando a diretiva de condio while():
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_SAFE, 800 , 600 , 0 , 0 ); while(!key[KEY_ESC]) { textout(screen, font, "texto", 1,1, makecol(255,0,0 ) ); }; return 0; }

(O cdigo acima no pode ser executado ainda pois falta a funo END_OF_MAIN()) - Agora vamos ver como fazer para inserir uma imagem na janela. O procedimento um pouco mais complexo, porm, muito simples de se fazer. O primeiro passo para se exibir uma imagem, ter uma imagem, ento, vamos criar uma para nosso exemplo:

(Imagem a ser utilizada no exemplo, formato bmp de 24 bits) O procedimento para adicionar a imagem so: 1 PALETTE pal; /* declarao uma varivel tipo PALETTE */

BITMAP *img = load_bitmap("c:\\teste.bmp",pal);/* Ponteiro BITMAP carrega imagem */ 2 draw_sprite(screen, img, 30,80 ); /* funo para imprimir imagem */ 3 1: Aqui temos a declarao da varivel pal, tipo PALETTE, que utilizada na linha seguinte tambm. Variveis do tipo PALETTE, so utilizadas para definir as cores que o BITMAP est utilizando. O Allegro oferece algumas variveis PALETTE padro que podem facilitar o trabalho dos programadores de diversas formas; Neste caso, a utilizao de pal torna-se desnecessria pois estamos utilizando 32 bits e poseriamos utilizar o argumento NULL. A utilizao de uma varivel tipo PALLETE no est errada neste caso, porm no h necessidade. Quando a profundidade de cores de 8 bits(256 cores), torna-se necessrio utilizar uma varivel tipo PALETTE, para definir as cores que sero utilizadas. Existem formas de manipular a Paleta de Cores, porm no as abordaremos neste tutorial. No nosso exemplo vamos utilizar a paleta mesmo sem a sua necessidade. 2: Nesta linha temos a declarao de um ponteiro do tipo BITMAP, que nomeamos *img. Esta varivel recebe, atravz da funo load_bitmap(), o arquivo de imagem que iremos carregar, teste.bmp, seguido do parmetro pal, descrito acima. 3: A funo draw_sprite() a funo que carrega a imagem na tela. Seus parmetros so similares s da funo textout(), porm no utiliza os parmetros font e makecol(r,g,b). Mas em contrapartida, utiliza as declaraes feitas nas duas linhas anteriores. Nesta linha, o parmetro img a imagem propriamente dita, e os nmeros a seguir so coluna e linha respectivamente. - Agora vamos inserir estas linhas em nossso cdigo; tambm vamos reduzir consideravelmente o tamanho do cdigo se comparar-mos com o cdigo gerado pelo automaticamente pelo Allegro. Vejamos como fica o novo cdigo:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); PALETTE pal; BITMAP *img = load_bitmap("c:\\teste.bmp",pal); while(!key[KEY_ESC]) { clear_bitmap(img); textout(screen, font, "Exemplo", 30,20, makecol(255,0,0 ) ); draw_sprite(screen, img, 30,30 ); }; return 0; }

(Cdigo alterado para exibir imagem e texto) No cdigo acima, pode-se notar a diferena do cdigo padro do Allegro mostrado anteriormente, isto por que vrias outras funes que no utilizaremos foram retiradas, assim como install_mouse(), clear_keybuf() entre outras; ou seja, o cdigo que voc est vendo acima o mais enxuto possvel para imprimir uma imagem e um texto numa janela. A definio da janela est em 640x480, mas poderia ser mudada para qualquer resoluo desejada, contanto que a placa de vdeo seja capaz de executar na resoluo desejada. - Um ultimo comando deve ser incluso ao cdigo para para que o programa execute corretamente. A funo END_OF_MAIN() faz com que o Allegro entenda que o fim da funo main(), ou seja, o fim do programa. A no incluso da funo END_OF_MAIN() far com que o DevC++ apresente uma mensagem de erro. Observe o cdigo completo com comentrios:
#include <allegro.h> /* Adiciona as funes do Allegro */ int main() { allegro_init(); /* funo de inicializao do allegro */ install_keyboard(); /* funo de inicializao de teclado, agora dentro da main() */ set_color_depth(32); /* funo de profundidade de cores, definio em 32 cores */ set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); /* seleciona o tipo da placa e resoluo do vdeo */

PALETTE pal; /* declarao uma varivel tipo PALETTE */ BITMAP *img = load_bitmap("c:\\teste.bmp",pal);/* Ponteiro BITMAP img e atribui seu valor */ while(!key[KEY_ESC]) { /* Enquanto tecla diferente de ESC */ clear_bitmap(img); /* Limpa o ponteiro */ textout(screen, font, "Exemplo", 30,20, makecol(255,0,0 ) ); /* funo para imprimir texto */ draw_sprite(screen, img, 30,30 ); /* funo para imprimir imagem */ }; /* fim do while() */ return 0; /* Sai da funo main() sem erros fazendo com que o programa finalize */ } END_OF_MAIN() /* Finaliza a execuo do Allegro neste programa */

(Cdigo comentado e pronto para execuo) - Ao executarmos este cdigo, a seguinte janela ser exibida:

(Janela de aplicao Allegro exibindo a palavra 'Exemplo' e o desenho de um Aviozinho) Desenhando Bitmaps: Agora vamos ver algumas das funes de desenho geomtrico primitivo do Allegro. Estas funes so utilizadas para desenhar retas, circulos, retangulos e diversas outras formas atravez de pixels. O que se deve saber a respeito deste tipo de desenho, a forma com que ele exibido. - Vamos apagar uma parte de nosso cdigo, deixando apenas a inicializao das funes do Allegro e a diretiva while():
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); while(!key[KEY_ESC]) {

}; return 0; } END_OF_MAIN();

- Para desenhar uma imagem, necessrio criar um ponteiro do tipo BITMAP, que ser utilizado como um buffer para a execuo da funo. Neste ponteiro, ser definido o tamanho mximo da imagem que ser desenhada. A definio e feita atravz da funo create_bitmap(), que recebe como parmetro dois nmeros inteiros referente resoluo utilizada na janela. Iremos ento criar um BITMAP:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); BITMAP *img = create_bitmap(640,480); /* Cria o BITMAP while(!key[KEY_ESC]) { }; return 0; } END_OF_MAIN();

*/

- O prximo passo ser definir a dimenso e a cor de nossa linha. Para isto, iremos utilizar a funo padro de criao de linha do Allegro, line(), que recebe como parmetro o ponteiro que criamos(BITMAP), os pontos de incio e fim da linha(int), e a funo de cr da linha(makecol()). Desta forma a sintaxe da funo seria esta: line(BITMAP *img, int x_inicial, int y_inicial ,int x_final,int y_final, makecol(int,int,int )); - E esta seria sua utilizao: line(img, 10,10, 100,100, makecol(255,0,0 ) );

- Agora vamos entender como so desenhados os Bitmaps, comparando o plano de Bitmaps(se que podemos chamar assim), e o plano Cartesiano:

(Comparao entre plano cartesiano e Plano de Pixels utilizado por Bitmaps)

- Como podemos perceber, os vetores X e Y, esto posicionados da maneira diferente quando comparamos os planos, desta forma, quando desenharmos a linha, devemos ter em mente a direo do trao. Vamos adicionar a funo ao nosso cdigo:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); BITMAP *img = create_bitmap(640,480); /* Cria o BITMAP */ while(!key[KEY_ESC]) { clear_bitmap(img); line(img, 10,10, 100,100, makecol(255,0,0 ) ); /* Define dimenso e cor da linha }; return 0; } END_OF_MAIN();

*/

- Aps feita a definio das dimenses de nossa linha, devemos chamar a funo blit(), que responsvel pela impresso da linha. Esta funo recebe como parmetros o BITMAP que criamos, que na verdade a imgem propriamente dita; em seguida, um outro ponteiro, que definido pela funo set_gfx_mode(), o ponteiro screen, seguido de quatro campos inteiros, e por ltimo, a largura mxima e altura mxima da janela, ou seja, a resoluo. Esta a sintaxe da funo blit(): blit(BITMAP *bitmap, BITMAP *bitmap,int,int,int,largura,altura);

- E utilizada assim: blit(img, screen,0,0,0,0,640,480);

- Estes quatro campos inteiros que foram declarados com zero, so na verdade informaes das posies de X e Y que so passados biblioteca draw.h, utilizada pelo Allegro, porm neste exemplo estas definies no so aplicveis, pois a definio feita na funo line() j suficiente para nosso exemplo. Agora vamos incluir esta funo ao nosso cdigo:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); BITMAP *img = create_bitmap(640,480); /* Cria o BITMAP */ while(!key[KEY_ESC]) { clear_bitmap(img); line(img, 10,10, 100,100, makecol(255,0,0 ) ); /* Define dimenso e cor da linha blit(img, screen,0,0,0,0,640,480); /* Imprime a linha */ }; return 0; } END_OF_MAIN();

*/

(Cdigo comentado para gerao de uma linha em diagonal utilizando Allegro) - Executando este cdigo, teremos o seguinte resultado:

(Janela de aplicao Allegro exibindo uma linha diagonal com base nos valores de X e Y iniciais e finais da funo) - Como mencionado anteriormente, existem outras funes grficas especficas para construo de figuras geomtricas. Estas funes funcionam da mesma forma que funes matemticas e so relativamente simples de se executar, basta que o programador tenha conhecimento de matemtica, especificamente de geometria. Vamos ver alguns exemplos das funes: - Crculo: O circulo, feito atravz da funo circle(), que tem como parmetro o ponteiro BITMAP, sua posio X e Y, seu raio e finalmente sua cr: circle(img, 15,150,100, makecol(255,0,0 ) ); - Retngulo: O retngulo, construido com a funo rect(), e recebe como parmetros um ponteiro de tipo BITMAP, as posies de X e Y do seu incio que no lado superior esquerdo, a posio de terminao, que o lado inferior direito, e sua cr: rect(img, 10,10, 100,100, makecol(255,0,0 ) );

- Preenchimento: Figuras como o retngulo e crculo, no tem preenchimento, sendo desenhadas apenas suas bordas, desta forma o programador ter que utilizar a funo de preenchimento referente a figura para que a mesma tenha seu interior preenchido com alguma cr, caso contrrio ser apenas uma borda. Vejamos um exemplo:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); BITMAP *img = create_bitmap(640,480); /* Cria o BITMAP */ while(!key[KEY_ESC]) { clear_bitmap(img); rect(img, 10,10, 100,100, makecol(255,0,0 ) ); /* Define dimenso e cor da retngulo

*/

blit(img, screen,0,0,0,0,640,480); /* Imprime o retngulo }; return 0;

*/

} END_OF_MAIN();

(cdigo para gerar o retngulo) - Executando este cdigo, temos a seguinte janela:

(Janela de aplicao Allegro exibindo um retngulo) - Para inserir uma cor de preenchimento, devemos utilizar a seguinte funo: rectfill(img, 11,11,99,99, makecol(0,0,255 ) );

- Note que na funo rectfill(), os valores das posies de X e Y esto diferentes da funo anterior. As coordenadas do preechimento devem ser calculadas para que desenho no sobreponha sua borda. O preenchimento ser um pixel menor em todos os lados. O retngulo est sendo desenhado um pixel abaixo no eixo Y e um pixel a frente no eixo X; e sua terminao est um pixel acima no eixo Y e um pixel antes no eixo X. Desta forma temos a seguinte imagem:

(Janela de aplicao Allegro exibindo um retngulo de bordas vermelhas e preenchimento azul) - Tringulo: O tringulo uma figura geomtrica com 3 pontas, isto significa que para desenharmos um tringulo, alm de chamar o ponteiro BITMAP para a construo da imagem, deveremos declarar 3 vrtices, de posies X e Y, e por ltimo a cr do tringulo. Esta figura geomtrica no formada por linhas, e sim uma imagem slida, no podendo ser utilizada a funo de preenchimento como nos desenhos anteriores. A funo do tringulo triangle(), e sua sintaxe : triangle(img,150,150,350,350,10,350, makecol(255,0,0 ) ); - Retas: Alm da linha desenhada no primeiro exemplo, com a funo line(), existem dois outros tipos de linhas que podem ser utilizados no Allegro; linhas verticais, vline(), e linhas horizontais, hline(), que tem como parmetro o ponteiro que far a contruo da imagem, o ponto onde ser iniciada a reta, de acrdo com o tipo escolhido, os pontos X e Y que definiro a extenso da reta, e por ltimo, a cor da linha: // sintaxe void vline(BITMAP *bitmap, int x1, int y1, int x2, makecol(int,int,int ) ); void hline(BITMAP *bitmap, int y1, int y2, int x1, makecol(int,int,int ) ); // utilizao vline(img, 10,10,100, makecol(255,0,0 ) ); hline(img, 10,10,100, makecol(255,0,0 ) ); - Exisitem outras funes para grficos geomtricos no Allegro, porm neste Tutorial, apenas estas sero abordadas. Se quiser aprender mais sobre estas e outras funes, visite um dos links relacionados no final desta pgina. Mover Bitmaps com o Teclado: Agora chegamos numa parte um pouco mais complexa, e para obter resultados com a leitura e necessrio que tenha lido os tpicos anteriores. Vamos falar do input pelo teclado, especificamente da forma com que os valores das teclas so obtidos. Vamos aprender como movimentar bitmaps atravez do teclado. Antes de comear, importante seber de alguns conceitos de utilizao do teclado. - A biblioteca Allegro no possui uma funo que armazena o valor digitado pelo usurio em uma varivel, como

por exemplo a funo scanf(). O Allegro tem uma forma diferente de representar os valores das teclas, e para ler as mesmas, necessrio a utilzao de uma estrutura alternativa. - Primeiramente, vamos observar uma forma de utilizao da array key, que uma espcie de ndice de caracteres do Allegro. Cada tecla tem um valor constante correspondente a ela. Para exemplificar, vamos utilizar uma parte do cdigo que fizemos anteriormente, porm, vamos nos concentrar nos parmetros da funo while():
while(!key[KEY_ESC]) { /* Enquanto a tecla no for Esc faa o que est no bloco */ };

- O parmetro desta funo uma array, key, que est na posio [KEY_ESC], que corresponde a tecla ESC de seu teclado. Esta array utilizada dentro de uma funo da biblioteca Allegro, para detectar, por meio de scancode, se uma certa tecla est pressionada ou no(0 ou 1). Atravz de valores do ponteiro key, pode-se utilizar teclas especficas para certas interaes entre o programa e o usurio. Para isso, o programador dever saber quais so os valores correspondentes as teclas. Vejamos ento o contedo da array nesta tabela: Tecla A, B ... Z Cdigo na Array KEY_A, KEY_B...KEY_Z

Teclado Numrico 0 a 9 KEY_0_PAD ... 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 Pause KEY_PAUSE Barra de Espao KEY_SPACE Print Screen KEY_PRTSCR Shitf Esquerdo KEY_LSHIFT Shift Direito KEY_RSHIFT Control Esquerdo KEY_LCONTROL Control Direito KEY_RCONTROL Alt esquerdo KEY_ALT Alt Direito KEY_ALTGR (Codificao das teclas mais importantes contidas na array key) - Existem outras teclas que no so mencionadas neste tutorial, pois no sero usadas; mas acredito que esta explicao superficial a respeito da array key, suficiente por enaquanto. - Vamos escrever um cdigo que use algumas das teclas mencionadas acima. Mas para isso, vamos entender como fazer para movimentar um Bitmap da forma mais simples. - Para se desenhar um Bitmap, necessrio informar certos parmetros sua funo. O principal parmetro para se movimentar um Bitmap, a sua posio na tela, ou seja, suas coordenadas X e Y, que diro onde o Bitmap ser desenhado. Ento, podemos escrever uma estrutura que vai modificar o valor de X e Y, caso seja pressionada uma tecla de movimentao, definida pelo programador. Vamos exemplificar:
if(key[KEY_RIGHT]) { x++; clear_bitmap(img); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480);

- O cdigo acima, verifica se a seta para direita foi pressionada; como vimos na tabela de valores da array key, a tecla para direita representada por KEY_RIGHT. A funo circlefill() utiliza variveis no lugar de valores para X e Y. Caso a seta para direita seja pressionada, o valor de X, ser acrecido em 1(um), a circunferncia ser apagada e redesenhada de acordo com o novo valor de X. Essa estrutura a estrutura bsica para movimento de Bitmaps ou sprites, porm pode ser amplamente melhorada. Vamos criar um cdigo que mostre a leitura das quatro setas direcionais do teclado:
#include <allegro.h> #include <stdio.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); int x=300, y=190; BITMAP *img = create_bitmap(640,480); char txt[40]; sprintf(txt,"X: %d Y: %d", x, y); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480); textout(screen,font,txt,5,5,makecol(255,0,0)); while(!key[KEY_ESC]) { clear_bitmap(img); if(key[KEY_RIGHT]) { x++; clear_bitmap(img); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480); sprintf(txt,"X: %d Y: %d", x, y); textout(screen,font,txt,5,5,makecol(255,0,0)); } if(key[KEY_LEFT]) { x--; clear_bitmap(img); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480); sprintf(txt,"X: %d Y: %d", x, y); textout(screen,font,txt,5,5,makecol(255,0,0)); } if(key[KEY_UP]) { y--; clear_bitmap(img); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480); sprintf(txt,"X: %d Y: %d", x, y); textout(screen,font,txt,5,5,makecol(255,0,0)); } if(key[KEY_DOWN]) { y++; clear_bitmap(img); circlefill(img,x,y,30,makecol(255,255,255)); blit(img,screen,0,0,0,0,640,480); sprintf(txt,"X: %d Y: %d", x, y); textout(screen,font,txt,5,5,makecol(255,0,0)); } }; return 0; } END_OF_MAIN();

(Estrutura simples para movimento de uma circunferncia utilizando o teclado) - O cdigo utiliza sprintf(), uma funo da biblioteca stdio.h que guada texto e valores de variveis em uma string. Essa string foi usada para que a funo textout() pudesse imprimir as posies de X e Y dinamicamente.

Colizao entre Bitmaps: Agora estudaremos a Colizao entre Bitmaps; para isso, vamos entender o que vem a ser o termo coliso de bitmaps antes de criarmos nosso cdigo de simples coliso. - O que ns entendemos por coliso no mundo real, o encontro fsico de dois ou mais objetos ou superficies; pode ser considerado coliso, o momento que um veculo se choca com um poste, ou quando uma pessoa pisa no cho ao caminhar. A coliso no mundo real pode ser explicada por uma das leis da fsica que diz que dois corpos no poderm ocupar o mesmo espao ao mesmo tempo. Da mesma forma que a coliso fsica; a coliso de bitmaps acontece quando dois ou mais objetos ou superfcies se tocam, ou seja, quando existem pixels de diferentes bitmaps sendo desenhados em uma mesma coordenada. Na coliso virtual, as leis da fsica tem que ser ensinadas ao computador para que os bitmaps no se sobreponho. - Como forma de ilustrao rstica e superficial, vamos considerar um retngulo que foi definido com quatro pontos no plano de Bitmaps: 260,190(x e y superiores),360 e 290(x e y inferiores). Para esse retngulo, as coordenadas no sero alteradas. Criaremos ento outro retngulo, que ser movido pelo teclado, sendo baseado no cdigo utilizado para movimentao do circulo visto anteriormente. Neste cdigo, o crculo ser substituido por um retngulo. Este retngulo ter coordenadas que sero armazenadas nas variveis tipo x, y, x2 e y2. - O que iremos fazer, definir uma rea na tela que o retngulo manipulvel reconhecer como barreira. Para fazer este tipo de definio, vamos comparar o valor de X e Y do nosso retngulo com as posies do retngulo esttico, e se o nosso retngulo invadir esta barreira, ele ser empurrado para fora de acordo com a direo que ele tentou entrar. Vamos ver o cdigo completo para depois analizarmos:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); int x=275, y=75, x2=340, y2=140; PALETTE pal; BITMAP *img = create_bitmap(640,480); rectfill(img,x,y,x2,y2,makecol(0,0,255)); /* Retngulo Manupulvel Azul */ rectfill(img,260,190,360,290,makecol(255,0,0)); /* Retngulo Esttico Vermelho */ blit(img,screen,0,0,0,0,640,480); while(!key[KEY_ESC]) { /* Movimentao por setas do teclado: Incio */ if(key[KEY_RIGHT]) { clear_bitmap(img); x++;x2++; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); } if(key[KEY_LEFT]) { clear_bitmap(img); x--;x2--; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); } if(key[KEY_UP]) { clear_bitmap(img); y--;y2--; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); } if(key[KEY_DOWN]) { clear_bitmap(img); y++;y2++; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); } /* Fim da movimentao com Teclado e incio das verificaes de posicionamento */ if((x >= 259) && (x <= 360)) {

if((y2 >= 190) && (y2 <= 354)) { clear_bitmap(img); x++;x2++; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); textout(screen,font,"colisao detectada",250,1,makecol(255,255,0)); } } if((x2 >= 259) && (x2 <= 360)) { if((y >= 125) && (y <= 285)) { clear_bitmap(img); x--;x2--; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); textout(screen,font,"colisao detectada",250,1,makecol(255,255,0)); } } if((y >= 190) && (y <= 290)) { if((x >= 194) && (x <= 359)) { clear_bitmap(img); y++;y2++; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); textout(screen,font,"colisao detectada",250,1,makecol(255,255,0)); } } if((y2 >= 190) && (y2 <= 290)) { if((x >= 196) && (x <= 359)) { clear_bitmap(img); y--;y2--; rectfill(img,x,y,x2,y2,makecol(0,0,255)); rectfill(img,260,190,360,290,makecol(255,0,0)); blit(img,screen,0,0,0,0,640,480); textout(screen,font,"colisao detectada",250,1,makecol(255,255,0)); } }

} END_OF_MAIN()

}; return 0;

(cdigo de coliso simples no aprefeioado) - Depois de executar o cdigo pudemos perceber que o retngulo menor, de cor azul, pode ser movido pelas cetas do teclado, porm no entra na rea do retngulo vermelho. Como podemos observar no cdigo, existe uma sequencia de diretivas condicionais que comparam os valores das coordenadas dos dois retngulos, em todos os lados, fazendo com que eles sejam afastados para dar uma ideia de coliso fsica. - O que fizemos foi uma simples comparao das posies, e definimos um procedimento que ser executado no caso de um retngulo invadir o outro. - Claro que este no o melhor exemplo de uma deteco de coliso, porm, d uma ideia superficial de como as colizes funcionam. Neste exemplo, foram utilizados retngulos por serem mais fceis de se trabalhar, e evitam clculos matemticos mais complxos, porm existem algortimos especficos para certos tipos de colizao, os quais so mais trabalhosos e complexos para um tutorial destinado a iniciantes, que por sua vez foi escrito por um iniciante. Utilizao de Timer, Mouse e Som: Nesta ultima parte de nosso tutorial, vamos entrar em um contedo ainda mias complexo. Por isso, necessrio que os conceitos dos tpicos apresentados acima tenham sido compreendidos, e claro, ateno. - Neste tpico, vamos estudar o funcionamento das funes install_mouse() e install_sound(), que dependem da funo install_timer() para funcionar. Ento, vamos ver uma a uma:

Timer: O Timer, basicamente a funo contadora de tempo no Allegro. Os eventos de tempo podem ter diversas utilizaes, como por exemplo, contar o tempo que o jogador levou para passar um level de um jogo, ou coisas do tipo, porm, outras funes podem utilizar recursos do Timer. - Os eventos de tempo, simulam um relgio, ou seja, contam o tempo atravz de interrupo e retomada constante de uma determinada ao. O intervalo entre execuo, parada e retomada de execuo, pr-estabelecido pelo programador. Num relgioa, os ponteiros so analgicamente programados, para executarem um movimento que ser interrompido e logo em seguida executado novamente e assim por diante. - Vamos ver os principais comandos de utilizao do Timer e sua sintaxe correta, para isso, vamos utilizar nosso primeiro cdigo, de criao de janela vazia e vamos alter-lo:
#include <allegro.h> int main() { allegro_init(); install_keyboard(); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); while(!key[KEY_ESC]) { }; return 0; } END_OF_MAIN();

- Logo abaixo da inicializao do Allegro, vamos inserir a chamada do Timer:

install_timer();

- Agora vamos inserir uma funo que utilizaremos como um callback. Esta funo no ter retorno, por que o mesmo no relevante para a execuo do programa; uma funo utilizada apenas constar na sintaxe, neste caso recomendado que se utilize o modificador volatile como vemos na funo. Exitem casos, onde a funo callback utilizada pelo Timer tem utilidade real.
volatile int a = 0; /* varivel global */ void func() { a++; }

- O programa no tem como definir por si s, qual a funo a ser utilizada pelo Timer, ento, prximo passo informar ao qual ser a funo e a varivel a ser utilizada. Estas declaraes so feitas dentro da funo main():
LOCK_VARIABLE(a); /* varivel */ LOCK_FUNCTION(func); /* funo */

- Aps definir a funo e a varivel, iremos inserir a seguinte linha de comando:

install_int();

- A funo acima recebe dois parmetros. Primeiro a funo callback mostrada acima, seguida do intervalo de tempo em milisegundos. Ento a funo fica assim:
install_int(func(),100);

- Vejamos agora como fica o cdigo acima com as funes de Timer inclusas:
#include <allegro.h> volatile int a = 0; /* varivel global */ void func() { a++; } int main() { allegro_init(); install_timer(); install_keyboard(); LOCK_VARIABLE(a); LOCK_FUNCTION(func); install_int(func(),100); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); while(!key[KEY_ESC]) { }; return 0; } END_OF_MAIN();

- Aps este procedimento, a execuo deste programa ser uma janela vazia, assim como a janela padro gerada pela Allegro, a diferena que as funes que utilizam eventos de tempo podem ser utilizadas agora. Mouse: Agora que o Timer foi executado, vamos ver o procedimento para iniciar o mouse. O mouse nunca funciona sem o Timer. - Aps ter certeza de que o Timer est funcionando, podemos iniciar o Mouse. A funo a seguir, serve para carregar os procedimentos do inicializao do Mouse
install_mouse();

- O prximo passo criar um ponteiro do tipo Bitmap onde o cursor do mouse ser desenhado, da mesma forma que as figuras geomtricas primitivas. O comando utilizado para isso :
BITMAP *img = create_bitmap(640,480);

- Para exibir o cursor utilizaremos uma funo que recebe como parmetro o ponteiro que criamos acima:
show_mouse(img);

- Vamos ver o cdigo completo para que tenhamos uma idia.

#include <allegro.h> volatile int a = 0; /* varivel global */ void func() { a++; } int main() { allegro_init(); install_timer(); install_mouse(); install_keyboard(); install_int(func(),100); LOCK_VARIABLE(a); LOCK_FUNCTION(func); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); BITMAP *img = create_bitmap(640,480); while(!key[KEY_ESC]) { clear_bitmap(img); show_mouse(img); }; return 0;

} END_OF_MAIN();

- O Allegro tem procedimentos prprio para detectar qual boto foi pressionado, para isso, a funo vai atribuir valores aos botes; que so 1 para o boto esquerdo e 2 para o boto direito. Para detectar o boto, o Allegro faz uma verificao do valor de mouse_b; a estrutura if() a mais indicada para este tipo de verificao por questes de praticidade:
if(mouse_b & 1) { textout(screen,font,"botao direito",1,1,makecol(255,255,255)); }

- Num jogo, as posies X e Y do cursor do mouse so extremamente importantes em quase 100% dos casos. Por isso, a funo do Mouse no Allegro, j tem essas posies dinamicamente armazenadas nas vairveis mouse_x e mouse_y. Vejamos a utilizao:
int main() { //cdigo... int x,y,x1,y1; BITMAP *img = create_bitmap(640,480); if(mouse_b & 1) { x = mouse_x; y = mouse_y; if(mouse_b & 2) { x1 = mouse_x; y1 = mouse_y; rect(img,x,y,x1,y1,makecol(0,0,255)); } } //cdigo... }

- Ao executar este programa, as posies X e Y do cursor sero guardadas toda vez que o boto esquerdo for pressionado, e novamente armazenadas quando o direito for pressionado, e por fim desenhar um retngulo. - Estas so as formas mais bsicas de utilizao do Mouse. Sound: Agora veremos o procedimento de utilizao do som. A funo de som necessita do Timer para funcionar. Existem duas finalidades primrias para utilizao de som; a msica de fundo e os efeitos sonoros relacionados com aes do jogador. Para msica de fundo o Allegro utiliza sons no formato Midi, e para os outros sons decorrentes de aes, podem ser utilizados outros tipos de arquivos, porm, formato Wave o mais comum. Vamos agora ver como o procedimento de inicializao do som e execuo de arquivos de som. - Assim como os outros dispositivos de entrada, temos que inicializar o som. Para isto vamos utilizar a funo install_sound(), porm com alguns parmetros:
install_sound(digi_card,midi_card,cfg_path);

- Como parmetros desta funo temos digi_card, que detecta driver de som digital que a placa est usando, em seguida temos midi_card, que detecta o driver de MIDI a ser utilizado. Por ltimo temos cfg_path, que utilizado para manter compatibilidade de verses mais antigas do Allegro; vamos deixar seu valor em NULL, pois no o utilizaremos. - Assim como o vdeo, a configurao de som tem alguns valores pr-estabelecidos para entrar como parmentros desta funo. Vejamos alguns dos possveis valores para digi_card e midi_card: digi_card: DIGI_AUTODETECT DIGI_NONE DIGI_SB DIGI_SB10 instrui o Allegro a escolher o driver de som sem som digital auto-detecco de placas Sound Blaster Sound Blaster 1.0 (8 bit mono)

DIGI_SB15 DIGI_SB20 DIGI_SBPRO DIGI_SB16 DIGI_AUDIODRIVE DIGI_SOUNDSCAPE midi_card: MIDI_AUTODETECT MIDI_NONE MIDI_ADLIB MIDI_OPL2 MIDI_2XOPL2 MIDI_OPL3 MIDI_SB_OUT MIDI_MPU MIDI_DIGMID MIDI_AWE32

Sound Blaster 1.5 (8 bit mono) Sound Blaster 2.0 (8 bit mono) Sound Blaster Pro (8 bit stereo) Sound Blaster 16 (16 bit stereo) ESS AudioDrive Ensoniq Soundscape

instrui o Allegro a escolher o driver de MIDI sem som MIDI auto-deteco de sintetizadores Adlib ou Sound Blaster FM sintetizador OPL2 (mono, usado em Adlib e Sound Blaster) sintetizador OPL2 dual (stereo, usado em Sound Blaster Pro-I) sintetizador OPL3 (stereo, usado em Sound Blaster Pro-II e acima) interface MIDI Sound Blaster interface MIDI MPU-401 sample-based software wavetable player AWE32 (EMU8000 chip)

- Vejamos como fica nossa funo com um dos valores contidos nas tabelas:
install_sound(DIGI_AUTODETEC,MIDI_AUTODETECT,NULL);

- Vamos ver como carregar e executar arquivos do tipo Wave com o Allegro. Primeiramente, devemos ter um arquivo de som compatvel com o Allegro. Os arquivos Wave podem ter at 16 bits, e devem ser carregados em ponteiros do tipo Sample. - Vamos criar um ponteiro do tipo SAMPLE onde ser carregado o nosso arquivo de som. Este ponteiro recebe uma funo que indica o caminho do arquivo, load_wav().
SAMPLE *som = load_wav("c:\\som.wav");

- Para executar este som, vamos utilizar a funo play_sample(), que recebe como parmetro o ponteiro criado acima, o volume(0 255), o balano(0 a 255), a frequncia(que tem vrias configuraes, por exemplo 1000 que utiliza a mesma frequncia que o arquivo foi gravado) e loop(0:sem loop, 1: loop infinito).
play_sample(som,255,90,1000,0);

- Para parar de tocar um sample, utiliza-se a funo:

stop_sample(som);

- Onde som o ponteiro carregado com o som. - Vamos agora carregar e executar um arquivo no formato Midi. A execuo de Midi mais simples que a de um Sample, pois tem uma outra finalidade que consistem apenas em executar o arquivo com loop infinito, ou executlo apenas uma vez at que chegue ao fim do arquivo. - Primeiramente, vamos criar o ponteiro onde ser carregado o contedo do nosso arquivo de som; esse ponteiro ser do tipo MIDI, vamos cham-lo de mid. Para carregar o arquivo de som, utilizaremos a funo load_midi(), que

tem como parmetro a localizao do arquivo:

MIDI *mid = load_midi("c:\\fundo.mid");

- Como vimos, o carregamento similiar ao de um Sample. A execuo tambm similar, porm no requer a mesma quantidade de parmetros; apenas o ponteiro do Midi, e se ele vai ter loop ou no:
play_midi(mid,1);

- Na linha acima vemos a funo que executar o Midi at que o programa seja encerrado. Caso o segundo parmetro fosse zero, o arquivo seria executado apenas uma vez. - Para parar a execuo de um Midi, utiliza-se a funo: stop_midi(); - Como o Allegro s executa um Midi de cada vez, no necessrio parmetro para esta funo. Este comando far com que qualquer arquivo Midi em execuo pre imediatamente. - Vejamos agora um exemplo de utilizao de um arquivo de som:
#include <allegro.h> volatile int i=0; void imaismais() { i++; } int main() { allegro_init(); install_timer(); install_keyboard(); install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,NULL); install_int(imaismais,100); LOCK_VARIABLE(i); LOCK_FUNCTION(imaismais); set_color_depth(32); set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0); SAMPLE *som_w = load_wav("c:\\up.wav"), *som_s = load_wav("c:\\down.wav"), *som_a = load_wav("c:\\left.wav"), *som_f = load_wav("c:\\right.wav"); MIDI *mid = load_midi("c:\\fundo.midi"); while(!key[KEY_ESC]) { play_midi(mid,1); if(key[KEY_W]) { play_sample (som_w, 255, 128, 1000, 0); } if(key[KEY_A]) { play_sample (som_a, 255, 128, 1000, 0); } if(key[KEY_S]) { play_sample (som_s, 255, 128, 1000, 0); } if(key[KEY_D]) { play_sample (som_d, 255, 128, 1000, 0); } }; return 0; } END_OF_MAIN();

- A partir de agora, voc pode comear a escrever seus prprios cdigos. Sobretudo, recomendo um estudo mais aprofundado da biblioteca, pois ela ainda oferece muitos recursos no explorados neste tutorial. Recomendo ainda um estudo aprofundado na linguagem C++, pois essencial para a programao de jogos profissionais. Daqui para frente com voc; boa sorte e bons estudos.

 Agradecimentos: Agradeo imensamente a rodrigozk, que pacientemente me ajudou a escrever este tutorial, mostrando-se interessado em melhorar a qualidade do material de referncia na lingua portuguesa. Agradeo tambm a gamemasterbr, e outros usurios do frum da UniDev, pois alguns dos temas abordados neste tutorial foram complementados com definies discutidas no frum relacionado a Allegro. Links Relacionados: - Allegro Oficial [ingls] - Allegro.cc [ingls] - Manual Allegro Vivace [ingls] - As Funes do Allegro da UFRJ [portugus] - UniDev.Com.Br [portugus]

Powered by Geocities.ws