|
Programando com o Allegro |
A maioria dos programas feitos usando o Allegro segue um certo esquema de montagem. Veremos, a seguir, esse esquema.
Todo programa que usa o Allegro deve ter, antes da chamada de qualquer outra função do Allegro, uma chamada a função allegro_init. Ela inicializa algumas variáveis e reserva memória para algumas operações do Allegro, deixando-o pronto para o uso. Esta função não possui parâmetros, devendo ser chamada da seguinte forma:
allegro_init();
Apás chamada a função allegro_init, são chamadas as funções install_keyboard, install_mouse e install_timer, que inicializam, respectivamente, o teclado, o mouse e os temporizadores. Elas também não possuem parâmetros e são chamadas assim:
install_keyboard();
Normalmente não é necessário checar o valor de retorno dessas funções, uma vez que são raros os casos em que a inicialização de um desses componentes falha. Porém, para projetos maiores, é recomendado que sempre sejam checados os valores de retorno dessas e de outras funções.
install_mouse();
install_timer();
Ao final do programa, utilizamos a função allegro_exit para retirar os domínios do Allegro sobre o computador. A função, que também não possui parâmetros, é chamada da seguinte forma:
allegro_exit();
Existem duas funções para a configuração do modo gráfico: set_color_depth e set_gfx_mode.
A primeira, que deve ser chamada antes da segunda, determina o número de bits de cores a ser usado pelos gráficos. O número de bits pode ser 8 (256 cores), 15 (32768), 16 (65536), 24 (aproximadamente 32 milhões) e 32 (aproximadamente 4 bilhões de cores), sendo este o único parâmetro da função, a ser chamada, por exemplo, da seguinte forma:
set_color_depth(16);
Caso não seja chamada esta função, o padrão para o número de bits é 8.
Já a segunda função, set_gfx_mode, é responsável pela inicialização do modo gráfico. O primeiro parâmetro representa o driver gráfico a ser utilizado pelo Allegro, e que deve ser uma das constantes definidas pelo Allegro. Os segundo e terceiro parâmetros indicam, respectivamente, o tamanho horizontal e vertical da tela, em pixels. Assim, para inicializar o modo gráfico com uma resolução de 640x480, deveríamos chamar a função da seguinte maneira:
set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0);
Os quarto e quinto parâmetros, ignorados no exemplo anterior ao atribuirmos o valor 0 (zero), indicam a resolução de uma possível tela virtual. Isto é utilizado em alguns jogos em que apenas uma parte (tela física) de um mapa (tela virtual), por exemplo, pode ser visualizada. Podemos, então, chamar a função da seguinte maneira:
set_gfx_mode(GFX_VESA1, 640, 480, 3200, 2400);
Com isso, a tela física continuará com uma resolução de 640x480; porém, através de funções de scroll do Allegro, poderemos visualizar uma parte de uma tela virtual de 3200x2400 (armazenada na memória) naquela tela física.
Ao contrário do que acontece com as funções vistas anteriormente, é interessante verificar o valor de retorno desta função, pois é comum os casos em que não é possível inicializar o modo gráfico, pelo não suporte do driver de vídeo ou da resolução pelo hardware. Cabe ao programador tentar "driblar" esses problemas.
Existe apenas uma função de configuração do som no Allegro, que inicializa tanto os dispositivos digitais quanto os dispositivos MIDI. Esta função, install_sound, possui três parâmetros: o primeiro indica o controlador de som digital a ser usado pelo Allegro; o segundo, o controlador de som MIDI; e o terceiro existe apenas por motivos de compatibilidade com versões antigas do Allegro, e deve ser ignorado passando-se o valor NULL. Assim, para inicializarmos o som para ser usado com o Allegro, chamamos a função da seguinte forma:
install_sound(DIGI_SB, MIDI_SB_OUT, NULL);
O exemplo acima inicializa dispositivos de som digital e MIDI do tipo Sound Blaster. Se quisermos que o Allegro escolha automaticamente qual o controlador de som mais apropriado, podemos chamar a função da seguinte maneira:
install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL);
Assim como acontece com a inicialização do modo gráfico, a inicialização do som também está sujeita a falhas, pois o controlador de som escolhido pode não ser compatível com o hardware ou o Allegro pode não ser capaz de escolher automaticamente o controlador correto. Com isso, é interessante checar o valor de retorno desta função, com o intuito de tentar escolher o controlador mais adequado para o hardware existente.
Com as funções vistas anteriormente, podemos criar uma base para montar programas que usem o Allegro. Chamaremos esta base de "esqueleto" de um programa. Abaixo, vemos o código do esqueleto.
#include <stdio.h>
#include <stdlib.h>
#include <allegro.h>
#define MAX_X 800
#define MAX_Y 600
#define V_MAX_X 0
#define V_MAX_Y 0
#define COLOR_BITS 8
#define VIDEO_CARD GFX_VESA1
#define DIGI_CARD DIGI_SB16
#define MIDI_CARD MIDI_SB_OUT
int inicia(void);
void principal(void);
void finaliza(void);
int main (void)
{
if (!inicia())
}
{
finaliza();
}
exit(-1);
principal();
finaliza();
exit(0);
int inicia (void)
{
allegro_init();
}
install_keyboard();
install_mouse();
install_timer();
set_color_depth(COLOR_BITS);
if (set_gfx_mode(VIDEO_CARD, MAX_X, MAX_Y, V_MAX_X, V_MAX_Y) < 0)
{
if (set_gfx_mode(GFX_AUTODETECT, MAX_X, MAX_Y, V_MAX_X, V_MAX_Y) < 0)
}
{
printf("Erro ao inicializar o modo grafico");
}
return (FALSE);
if (install_sound(DIGI_CARD, MIDI_CARD, NULL) < 0)
{
if (install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL) < 0)
}
{
printf("Erro ao inicializar o som");
}
return (FALSE);
return (TRUE);
void principal (void)
{
}
void finaliza (void)
{
allegro_exit();
}
Veremos, agora, as principais funções da biblioteca Allegro, utilizando alguns exemplos para melhor explicá-las. Em alguns casos, apenas a descrição da função e um breve exemplo não serão suficientes; nestes casos, daremos programas completos para exemplificar o uso da função ou de alguma técnica de programação, partindo sempre da função principal do esqueleto de programa.
Tendo em vista que a principal característica do Allegro é o uso da parte gráfica, o Allegro dispõe de diversas funções de desenho. Porém, antes de explicá-las, é necessário entender o modo como o Allegro trata a parte gráfica.
O Allegro trata todo gráfico que pode ser guardado na memória ou desenhado na tela como um bitmap, que nada mais é do que um modo de representar gráficos em formato binário. Para tal, o Allegro define um tipo BITMAP, com o qual o usuário pode manipular facilmente esses bitmaps. Não é necessário, para o programador, conhecer os elementos desta estrutura; basta saber utilizar as funções de bitmaps.
Se quiséssemos, por exemplo, usar um bitmap chamado quadro, poderíamos declará-lo da seguinte forma:
BITMAP *quadro;
Antes de usar um bitmap é necessário criá-lo, pois apenas a declaração do bitmap não é suficiente para o uso do mesmo. Para isso, usamos a função create_bitmap, da seguinte forma:
quadro = create_bitmap(50, 25);
Isto criará um bitmap de largura 50 e altura 25, e que será referenciado pela variável quadro.
Após a criação do bitmap, podemos utilizar as várias funções de bitmaps que o Allegro oferece. Se quiséssemos, por exemplo, desenhar um retângulo no bitmap quadro, poderíamos usar a função rect, como abaixo:
rect(quadro, 10, 5, 40, 20, 0);
Este exemplo desenhará um retângulo desde a coordenada (10, 5) até a coordenada (40, 20), dentro do bitmap quadro, utilizando a cor de código 0.
Porém, tudo o que foi feito até aqui com o bitmap quadro ocorreu na memória. Em nenhum momento o bitmap foi mostrado na tela. Se quiséssemos, agora, colocar o bitmap na tela, poderíamos utilizar a função blit. Ela copia uma parte de um bitmap para dentro de outro bitmap. Além da função blit, utilizamos a variável screen, que também é do tipo BITMAP e é pré-definida pelo Allegro. Assim, a cópia do bitmap quadro para a tela ficaria da seguinte forma:
blit(quadro, screen, 0, 0, 200, 100, 50, 25);
Isto copiará uma parte do bitmap quadro começando na coordenada (0, 0) e de tamanho 50 x 25 (ou seja, todo o bitmap), para o bitmap screen, que nada mais é do que a forma do Allegro representar a tela, através de uma variável do tipo BITMAP.
Poderíamos, neste caso, ter usado a função draw_sprite, que copia um bitmap inteiro para dentro de outro. Assim, a sua chamada ficaria da seguinte forma:
draw_sprite(screen, quadro, 200, 100);
Isto é equivalente à chamada da função blit feita anteriormente, com a diferença de que os pontos do bitmap quadro que possuem código 0 não desenhados, funcionando como pontos transparentes.
Podemos, ainda, utilizar as funções de desenho do Allegro diretamente no bitmap screen. Assim, se quiséssemos, por exemplo, desenhar um círculo preenchido na tela, poderíamos simplesmente escrever
circlefill(screen, 300, 200, 40, 15);
o que desenharia, na tela, um círculo de raio 40, com centro na coordenada (300, 200) e totalmente preenchido com a cor de código 15.
Às vezes, porém, torna-se inviável desenhar, durante a execução do programa, todos os gráficos necessários. Para esses casos, podemos utilizar a função load_bitmap, que carrega um bitmap diretamente de um arquivo, fazendo com que seja possível a confecção de grande parte dos gráficos do jogo antes de sua execução. Assim, se quiséssemos, por exemplo, carregar um bitmap de um arquivo com nome figura.bmp, guardá-lo na memória e referenciá-lo através da variavél quadro, deveríamos utilizar a função da seguinte maneira:
quadro = load_bitmap("figura.bmp", NULL);
Com isso, o bitmap quadro fica disponível para que sejam realizadas todas as operações disponíveis para bitmaps, inclusive o uso das funções blit e draw_sprite, para mostrá-lo na tela.
Quando trabalhamos com bitmaps de 256 cores, temos alguns problemas com a apresentação dos mesmos na tela. Isso se deve ao fato de que, com 8 bits de cores, há uma certa dificuldade em representar um grande número delas. Para contornar tal dificuldade, foram criadas paletas, que nada mais são do que tabelas de cores, com um índice que varia de 0 a 255. Assim, ao invés de cada código de cor representar sempre a mesma cor (o que acontece nos modos de 15, 16, 24 e 32 bits), temos cores que variam de acordo com a paleta em uso. Podemos ter, por exemplo, uma paleta com 256 tons de vermelho diferentes, ou outra com 128 tons de amarelo e 128 tons de azul, dependendo dos números guardados dentro de cada código de cor (três números são guardados dentro de cada código de cor, representando as quantidades de vermelho, verde e azul existentes naquela cor).
Podemos, então, definir uma paleta como sendo um vetor de 256 posições, no qual cada posição corresponde a um código de cor, e em cada uma delas temos três números para representar as quantidades de vermelho, verde e azul existentes na cor correspondente.
Assim como para os bitmaps, existe também, no Allegro, um tipo para paletas. Podemos, então, criar uma paleta usando a seguinte declaração:
PALETTE paleta;
Existem duas maneiras de se modificar uma paleta: a primeira é fazer isso manualmente, utilizando os códigos de cor e as quantidades de vermelho, verde e azul desejadas; a segunda, e, naturalmente, menos trabalhosa, é carregar uma paleta correspondente a determinado bitmap durante a leitura deste.
Na primeira maneira, modificamos os valores da estrutura PALETTE diretamente. Por exemplo:
paleta[15].r = 0;
modificaria o código 15 de paleta para o verde mais claro possível, uma vez que as quantidades de vermelho, verde e azul de cada código variam de 0 a 63 (6 bits). Note que as letras r, g e b correspondem às cores vermelha, verde e azul, respectivamente.
paleta[15].g = 63;
paleta[15].b = 0;
Na segunda maneira, usamos a função load_bitmap para carregar a paleta junto com o bitmap. Assim,
quadro = load_bitmap("figura.bmp", paleta);
carregaria o bitmap do arquivo figura.bmp para quadro e, também, a paleta correspondente a esse bitmap em paleta.
Após definirmos as cores desejadas de uma paleta (seja pelo primeiro ou pelo segundo método), podemos torná-la ativa usando a função set_palette, da seguinte maneira:
set_palette(paleta);
Isto faz com que todas as cores da tela mudem para as cores correspondentes ao código de cor de cada ponto.
Podemos usar isto para fazer algumas animações sem que precisemos redesenhar os gráficos. O exemplo abaixo mostra como fazer isso.
void principal (void)
{
int i;
}
int cor;
PALETTE pal;
/* Limpa a tela (para o codigo de cor 0). */
clear(screen);
/*
Torna ativa a black_palette, paleta pre-definida pelo
*/
Allegro que contem apenas a cor preta, para todos os codigos.
Fazemos isso para que os retangulos feitos a seguir nao sejam
vistos ao serem desenhados.
set_palette(black_palette);
/*
Desenha retangulos preenchidos, cada um com codigos
*/
de cor variando de 0 a 63, em sequencia.
for (i = 0; i < 64; i++)
{
rectfill(screen, i * 12.5, 0, (i + 1) * 12.5, 599, i);
}
/* Gera tons de azuis */
for (i = 0; i < 64; i++)
{
pal[i].r = 0;
}
pal[i].g = 0;
pal[i].b = i;
while (!keypressed())
{
/* Torna ativa a paleta pal */
}
set_palette(pal);
/*
Troca os valores de cada codigo de cor,
*/
causando um efeito de animacao.
cor = pal[63].b;
for (i = 63; i > 0; i--)
{
pal[i].b = pal[i - 1].b;
}
pal[0].b = cor;
Existem outras duas funções que são muito utilizadas pelos programadores Allegro: fade_in e fade_out.
A primeira faz com que, partindo da black_palette, as cores sejam alteradas aos poucos para uma determinada paleta. Isto causa um ótimo efeito visual, pois as cores vão aparecendo gradativamente. Da mesma maneira, a segunda faz o efeito inverso, ou seja, as cores vão desaparecendo gradativamente. Por exemplo:
tela = load_bitmap("figura.bmp", paleta);
O exemplo acima desenha o bitmap tela com cores pretas para que a função fade_in faça-o aparecer gradativamente, até alcançar as cores da paleta paleta. Quando o usuário pressionar alguma tecla, a função fade_out fará o bitmap desaparecer gradativamente. Os valores 4 e 32 utilizados nas funções fade_in e fade_out controlam a velocidade com que as cores são alteradas, podendo ir de 1 (devagar) até 64 (muito rápido).
set_palette(black_palette);
draw_sprite(screen, tela, 20, 30);
fade_in(paleta, 4);
while (!keypressed());
fade_out(32);
Além das funções de desenho vistas anteriormente, o Allegro dispõe de algumas funções para o desenho de textos na tela.
Antes de utilizarmos as funções que desenham os textos, devemos definir o modo como os caracteres serão desenhados. Para tal, usamos a função text_mode. O seu único parâmetro define o código de cor que terá o fundo dos caracteres. Caso o código de cor seja menor do que zero, a fundo será transparente. Assim
text_mode(15);
faria com que o fundo do texto que fosse desenhado posteriormente tivesse o código de cor 15. Porém, se tivéssemos
text_mode(-1);
o fundo seria transparente.
Para desenhar os textos, podemos utilizar quatro funções diferentes: textout, textout_centre, textprinft e textprintf_centre. A primeira, textout, desenha um texto qualquer num determinado bitmap, como a seguir:
textout(screen, font, "O Jogo Acabou", 50, 100, 20);
O exemplo anterior escreve a string "O Jogo Acabou" na coordenada (50, 100) da tela (screen), utilizando o código de cor 20. A função textout_centre teria o mesmo efeito, a não ser pelo fato de que na coordenada (50, 100) seria posicionado o centro da frase "O Jogo Acabou", o que faria o texto ficar centralizado.
Já a função textprintf escreve o texto utilizando um formato (da mesma forma que a função printf da biblioteca stdio). Assim, poderíamos escrever
textprintf(tela, font, 400, 100, 15, "Pontos: %d", pontos);
o que desenharia, na coordenada (400, 100) do bitmap tela, utilizando o código de cor 15, a string "Pontos: %d", utilizando o mesmo formato da função printf. Assim, se a variável pontos do tipo int tivesse o valor 2000, seria desenhada a frase "Pontos: 2000" no bitmap tela. Assim como nas funções textout e textout_centre, a função textprintf_centre faz o mesmo que a função textprintf, apenas centralizando o texto na coordenada pedida.
Apesar de não serem o "forte" do Allegro, as funções desempenham o seu papel de forma satisfatória.
O modo como o Allegro desenha cada caractere, porém, pode ser diferente em alguns jogos. Para tratar esta diferença de desenho, o Allegro possui o tipo FONT. Assim, para definir uma variável com o tipo FONT, escrevemos
FONT *fonte;
É muito difícil, porém, construir fontes manualmente. Para isso, existem alguns programas que podem ser utilizados, por exemplo, para transformar fontes do Windows em fontes utilizáveis pelo Allegro.
Com a fonte já produzida e carregada na memória, podemos utilizar as funções vistas anteriormente normalmente, apenas alterando o parâmetro font (que nada mais é do que uma fonte pré-definida pelo Allegro) para a fonte que queremos. Assim, poderíamos utilizar a fonte fonte da seguinte forma:
textout(screen, fonte, "Exemplo de texto com outra fonte", 200, 200, 50);
Há duas maneiras de ler a entrada usando o Allegro (uma vez que, após o uso da função install_keyboard não é mais possível utilizar as funções de entrada padrões), as duas muito simples, e que devem ser escolhidas de acordo com o que se deseja ler.
A primeira maneira utiliza a função readkey, que é semelhante à função getch da biblioteca conio. O valor retornado pela função possui 16 bits, sendo os menos significativos relativos ao código ASCII e os mais significativos chamados de scancode. Assim, podemos testar diversas teclas (ou combinações delas) das seguintes formas:
/* Pelo codigo ASCII */
if ((readkey() & 0xFF) == 'd')
printf("Voce pressionou a tecla 'd'\n");
/* Pelo scancode */
if ((readkey() >> 8) == KEY_SPACE)
printf("Voce pressionou a tecla Espaço\n");
/* Pressionando CTRL+[letra] */
if ((readkey() & 0xFF) == 3)
printf("Voce pressionou CTRL+C\n");
/* Pressionando ALT+[letra] */
if (readkey() == (KEY_X << 8))
printf("Voce pressionou ALT+X\n");
A segunda maneira utiliza o vetor key, definido pelo Allegro. Assim, podemos testar o pressionamento de teclas de modo mais dinâmico. Por exemplo:
if (key[KEY_D])
printf("Voce pressionou a tecla 'D'\n");
if (key[KEY_SPACE])
printf("Voce pressionou a tecla Espaço\n");
if ((key[KEY_CTRL]) && (key[KEY_C]))
printf("Voce pressionou CTRL+C\n");
if ((key[KEY_ALT] && (key[KEY_X]))
printf("Voce pressionou ALT+X\n");
Naturalmente, devemos escolher a opção que seja mais simples para o que se quer fazer. Se quisermos, por exemplo, ler o nome do jogador, é preferível utilizar a função readkey, que dá a possibilidade de ler vários caracteres diferentes. Porém, se quisermos apenas verificar, por exemplo, se a tecla Enter está pressionada, utilizamos key[KEY_ENTER].
Além desses elementos para o uso do teclado, existem outras duas funções muito úteis para o uso do mesmo: clear_keybuf e keypressed.
A primeira limpa o buffer do teclado, isto é, apaga das possíveis teclas lidas aquelas que foram pressionadas até o momento. Isto é particularmente útil quando, por exemplo, queremos ler teclas apenas a partir de um determinado momento, ignorando as que já foram pressionadas anteriormente e que estão esperando serem lidas. Como a função não possui parâmetros, ela deve ser chamada da seguinte forma:
clear_keybuf();
A segunda verifica se há alguma tecla pressionada no momento, da mesma maneira que a função kbhit da biblioteca conio. Assim, podemos fazer um esquema para o loop principal de um jogo, de maneira que o programa não páre à espera de uma tecla:
while (!key[KEY_ESC])
{
/* alguns comandos */
}
(...)
if (keypressed())
{
tecla = readkey();
}
/* reage a tecla */
(...)
/* outros comandos */
(...)
Além do teclado, talvez o mouse seja um dos módulos do Allegro mais fáceis de utilizar. O Allegro dispõe de algumas funções e variáveis pré-definidas que auxiliam nessa utilização.
As variáveis mouse_x e mouse_y guardam, respectivamente, as atuais posições x e y do ponteiro do mouse.
A variável mouse_b indica qual(is) o(s) botão(ões) do mouse está(ão) sendo pressionado(s). Por exemplo:
if (mouse_b & 1)
printf("Botão esquerdo do mouse pressionado\n");
if (!(mouse_b & 2))
printf("Botão direito do mouse não pressionado\n");
if (mouse_b & 4)
printf("Botão do meio do mouse pressionado\n");
Além dessas variáveis, a principal função para uso do mouse é a show_mouse. Ela faz com que o ponteiro do mouse seja mostrado num determinado bitmap (que pode, inclusive, ser o screen). Assim, se escrevermos
show_mouse(screen);
o ponteiro do mouse será mostrado na tela. Se fizermos
show_mouse(NULL);
o ponteiro do mouse é escondido.
Há, porém, diversos problemas relacionados à função show_mouse. Desenhar o mouse diretamente na tela pode causar manchas devido ao retraço. Se fizéssemos o mouse desaparecer, desenhássemos o que fosse preciso, e reaparecêssemos com o mouse, isto faria o mouse ficar piscando, causando um efeito visual nada interessante. A solução é utilizar a técnica chamada double buffering.
O Allegro aceita uma boa variedade de arquivos de som, cobrindo o necessário para a confecção de qualquer jogo. Há, porém, dois tipos distintos de som: os MIDIs e os Samples.
Os MIDIs são responsáveis pela música de fundo dos jogos. Seguindo o padrão do Allegro, existe um tipo MIDI para guardar arquivos de música. Podemos, então, declarar um MIDI da seguinte forma:
MIDI *musica;
Como não podemos criar MIDIs durante a execução do jogo, temos que carregá-los a partir de arquivos. Para isso, usamos a função load_midi, da seguinte forma:
musica = load_midi("musica.midi");
Isto carregará o arquivo musica.midi para a memória, que será apontada pela variável musica, do tipo MIDI.
Após carregar o arquivo na memória, podemos tocá-lo utilizando a função play_midi. Por exemplo:
play_midi(musica, TRUE);
tocará o MIDI que está guardado na posição de memória apontada por musica. O segundo argumento diz se o MIDI será tocado com loop, ou seja, ao chegar ao final do arquivo, volta a tocá-lo do começo. Neste caso, o argumento é TRUE e, portanto, será tocado em loop. Caso quiséssemos que o arquivo fosse tocado apenas uma vez, o argumento deveria ser FALSE.
Temos duas opção para parar de tocar um MIDI. Uma delas utiliza a função play_midi da seguinte forma:
play_midi(NULL, FALSE);
A outra, utiliza a função stop_midi, que não possui argumentos. Assim, se quisermos fazer um MIDI parar de tocar, escrevemos:
stop_midi();
Da mesma forma que os MIDIs, os samples possuem seu próprio tipo. Assim, se quisermos definir um arquivo sample, podemos fazê-lo da seguinte forma:
SAMPLE *som;
Ainda seguindo o que foi visto anteriormente para os MIDIs, precisamos carregar para a memória um arquivo de sample antes de poder tocá-lo. Para isso, utilizamos a função load_sample, da seguinte forma:
som = load_sample("certo.wav");
A chamada de função acima carregará o arquivo certo.wav na memória e apontará este endereço de memória com a variável som, do tipo SAMPLE.
Para tocar o arquivo carregado na memória pela função load_sample, utilizamos a função play_sample. Ela possui vários argumentos, e pode ser chamada, por exemplo, da seguinte forma:
play_sample(som, 255, 128, 1000, FALSE);
o que fará com que o sample guardado em som seja tocado. O segundo argumento indica o volume com o qual o sample deve ser tocado, e pode variar de 0 a 255. O terceiro argumento indica o balanço das caixas de som, podendo variar, tabmém, de 0 a 255, sendo o 0 para o balanço todo para um lado, e 255 para o outro; neste caso, ao utilizarmos 128, definimos um balanço igualmente distribuído. O quarto argumento indica a frequência com a qual o sample irá ser tocado: 1000 para a frequência normal, 500 para a metade, 2000 para o dobro, e assim por diante. Já o último argumento indica, assim como na função play_midi, se o sample será tocado em loop.
Seguindo o padrão load-play-stop, temos a função stop_sample, que é usada, naturalmente, para fazer um sample parar de tocar. Assim
stop_sample();
faria o sample que está sendo tocado atualmente parar de tocar.
Índice Geral Allegro