Instalando a Allegro 5 no Mac OS (OSX Mavericks)

Olá pessoal!

Essa semana precisei instalar a Allegro 5 no Mac devido a um treinamento que estou ministrando e, putz, suei um pouco para fazer tudo funcionar da forma correta! Então vou aqui passar o caminho das pedras pro pessoal que precisa ou quer fazer o mesmo 🙂

O primeiro passo é instalar algum gerenciador de pacotes, como o Homebrew ou o MacPorts. Após instalados, vamos baixar as dependências para a compilação da biblioteca.

sudo port install cmake zlib freetype jpeg libogg physfs libpng flac libtheora +universal

ou

brew install cmake zlib freetype jpeg libogg physfs libpng flac libtheora

Após a obtenção dos pacotes, entra um ajustezinho para que, durante a compilação, o cmake encontre corretamente a biblioteca FreeType (que, por algum motivo é instalada em um local não-padrão). Precisei rodar um comando para criar um link no diretório padrão para ela:

sudo ln -s /usr/local/opt/freetype/include/freetype2 /usr/local/include/freetype

Depois disso, é só baixarmos o código-fonte da Allegro (pode ser a versão 5.0 ou 5.1) e descompactar. Abra o terminal, navegue até a pasta onde ele foi descompactado e digite os seguintes comandos:

mkdir build

cd build

cmake ..

make

sudo make install

E pronto! Ah, uma dica a mais é que, no Mac, precisei sempre adicionar a opção de linker -lallegro_main. Caso contrário, ocorre um erro parecido com o seguinte:

Undefined symbols for architecture x86_64:
  "_main", referenced from:
     implicit entry/start for main executable
ld: symbol(s) not found for architecture x86_64

Valeu pessoal, até a próxima 🙂

Captura de tela 2014-08-21 23.51.09

Allegro 5.0.7, MinGW 4.6 e Eclipse Juno

Olá pessoal! Apesar da irregularidade de posts ultimamente, o blog não morreu não! Estou com sérios problemas de conexão com a Internet em casa, por isso não tenho conseguido postar por aqui. Além disso, estou aguardando sair o novo Visual Studio para Windows Phone 8 pra continuar com a série de posts.

Nas últimas semanas estive ministrando um curso sobre a biblioteca Allegro. Qual não foi a minha surpresa, que a última versão (5.0.7) não traz uma versão já compilada para Windows que suporte a versão 4.4 do MinGW, que por sinal acompanha a instalação “padrão” do Code::Blocks. Percebendo isso, resolvi fazer esse tutorial para instalação da nova versão da biblioteca com o MinGW 4.6, este sim compatível. E aproveitando, já vou mostrar como utilizar o Eclipse como IDE. Apesar de originalmente voltado para Java, é uma ótima IDE para desenvolvimento em praticamente qualquer linguagem, já que é orientado a plugins.

Continuar lendo

Tutorial Allegro 5 #16 – Fadein e Fadeout (Alpha Blending)

Olá leitores! Este depois de vários posts, chegamos ao fim da série sobre Allegro 5. Como devem ter percebido 0u não, não sou um profundo conhecedor da biblioteca. Apenas criei a série para compartilhar com vocês os assuntos que eu fui estudando, quase a partir do zero. Isso mostra que, sim, com um pouco de persistência, é possível se aventurar por novas ferramentas, mesmo que a documentação seja um pouco escassa. No final das contas, consegui, pelo menos, montar um pequeno guia em português pra quem quer começar a mexer com Allegro 5.

E pra encerrar, vou mostrar um uso dos conhecidos efeitos de transição fadein e fadeout. Procurei deixar as duas funções o mais genéricas possível, para que vocês possam reutilizá-las em outros projetos que vocês porventura vierem a fazer.

Como das outras vezes, vamos ver o código e em seguida comentamos seus detalhes:

Acredito que o que realmente nos interessa nesse aplicativo é o conteúdo das funções fadeout() e fadein().

A função fadeout() recebe como parâmetro um valor inteiro, indicando a velocidade do processo de transição (quanto menor o valor, mais lento). No primeiro bloco de código da função, fazemos uma cópia do conteúdo atual da tela e o colocamos na variável buffer (que utilizaremos para fazer a transparência gradual). Em seguida, validamos a velocidade (para que fique sempre entre 1 e 15). Por fim, temos um looping que faz a transição. Basicamente, limpamos a tela (fundo preto), desenhamos a cópia da tela aplicando a transparência (através da função al_draw_tinted_bitmap(), semelhante a já conhecida al_draw_bitmap(), com a diferença de alterar o valor das camadas rgba do bitmap (red, green, blue e alpha – essa última, o nosso canal de transparência). Após isso, atualizamos a tela e fazemos uma breve pausa entre um looping e outro – que não é necessário se você estiver controlando a taxa de FPS.

Já a função fadein(), recebe como parâmetros a imagem que será exibida na tela após a conclusão e a velocidade da transição. Nesta função, temos apenas a verificação da velocidade, e já fazemos a transição, aplicando a transparência gradativa na própria imagem recebida como argumento.

Na função main(), fazemos a chamada a função fadein() seguida de uma pausa de 3 segundos e finalizamos com a chamada a fadeout().

Pra compilar:

  • Windows: -lallegro-5.0.5-mt -lallegro_image-5.0.5-mt
  • Linux: -lallegro -lallegro_image

Bom pessoal, é isso aí. Espero que a série tenha sido útil, e que sirva como um primeiro passo para quem quiser começar a mexer com Gamedev. Continuem acompanhando o blog, pois tem muita coisa boa vindo por aí!

Tutorial Allegro 5 #15 – Utilizando Caixas de Diálogo Nativas

Olá pessoal! Hoje vamos ter um tutorial bastante simples, mas bem legal, mostrando como utilizar caixas de diálogo nativas do sistema operacional em seu aplicativo usando a Allegro 5.

Para o uso de tal recurso, utilizamos a extensão allegro_dialog, que é quem se encarrega de adaptar a chamada à função de exibição ao estilo de janela do seu sistema operacional (Windows, Linux ou MacOS).

Vamos observar o código e já comentamos sobre ele:

No código acima, criamos uma sequência de janelas, procurando demonstrar as várias opções que a Allegro nos oferece. Basicamente, todo o processo gira em torno da chamada a função al_show_native_message_box(). Seus parâmetros são: (1) a janela a qual ela pertence. No nosso caso, passei como argumento NULL, pois não há uma janela (ALLEGRO_DISPLAY). No caso, você pode passar nesse argumento a função al_get_current_display(), que retorna a janela ativa; (2) título da caixa de diálogo; (3) título do texto; (4) botões – não encontrei documentação clara sobre a utilização deste parâmetro, mas aparentemente serve para a utilização de botões personalizados – e; (5) tipo de caixa de diálogo. No nosso exemplo, utilizei todos os tipos disponíveis na biblioteca Allegro.

Basicamente, a função al_show_native_message_box() retorna um valor verdadeiro quando clica-se em um botão afirmativo (sim ou OK) e falso ao clicar em um botão negativo (Não, Cancelar ou mesmo fechar a caixinha). Através disso, criei o fluxo do programa.

Para compilar, precisamos lembrar de linkar com o add-on allegro_dialog.

  • Windows: -lallegro-5.0.5-mt -lallegro_dialog-5.0.5-mt
  • Linux: -lallegro -lallegro_dialog

Até a próxima! 🙂

Tutorial Allegro 5 #14 – Entrada de Texto

Olá pessoal! Depois de algum tempo sem os posts da série sobre Allegro, estamos de volta! No exemplo de hoje, vamos ver como obter uma entrada de texto do usuário, já que nativamente não temos uma forma de obter um texto (como um scanf ou cin).

Neste exemplo, vamos simular que você terminou um jogo e fez a melhor pontuação e então precisará digitar seu nome para ir para o ranking. No aplicativo, em vez de utilizarmos o evento ALLEGRO_EVENT_KEY_DOWN, usaremos ALLEGRO_EVENT_KEY_CHAR para obtermos os caracteres relativos a cada uma das teclas. Vamos olhar o código e em seguida comentamos seus detalhes. Lembrando que este exemplo foi baseado do lazyfoo.net, com a diferença de que aqui estamos utilizando Allegro 5 em vez de SDL, e adaptei-o

No nosso exemplo, os itens chave são a string str e a função manipular_entrada(). A string, de 17 posições (16 caracteres + caratere indicando fim de string), é inicializada na linha 37, dentro da função main(). Ainda na função main(), temos uma flag chamada concluido, que indicará quando o usuário pressionar a tecla Enter, encerrando a digitação do nome.

Dentro do trecho de tratamento de eventos, temos a chamada à função manipular_entrada(), que passando o evento como parâmetro. Internamente, nessa função, verificamos o campo keyboard.unichar do evento, caso ele seja do tipo ALLEGRO_EVENT_KEY_CHAR. Este campo contém o caractere correspondente a tecla pressionada. Primeiramente, montamos uma string temporária na linha 175 que, caso possua um valor dentro do esperado (números ou caracteres (maiúsculos ou minúsculos)), será concatenada a string str por meio da função strcat(). Como em C o tipo char pode ser tratado como int, utilizamos os comparadores >= e <= para validar a faixa dos valores. Caso estejam, eles são adicionados à string principal str. Ainda na função manipular_entrada(), verificamos se a tecla pressionada foi a backspace, para então remover o último caractere da string str na linha 199.

Voltando à função main(), temos uma verificação da flag concluido para escolher entre qual mensagem será exibida ao usuário: “Melhor Pontuação! Nome:” ou “1º Lugar”. No final do looping temos a chamada a função exibir_texto_centralizado(), mas não temos nenhuma novidade em sua implementação.

O aplicativo rodando deve parecer com isso:

A imagem e a fonte, você pode usar qualquer uma a seu gosto, bastando alterar na função carregar_arquivos(). Para compilar, utilizamos os add-ons allegro_image, allegro_font e allegro_ttf.

  • Windows: -lallegro-5.0.5-mt -lallegro_image-5.0.5-mt -lallegro_font-5.0.5-mt -lallegro_ttf-5.0.5-mt
  • Linux: -lallegro -lallegro_image -lallegro_font -lallegro_ttf

Bom, é isso pessoal! Espero que o tutorial seja útil! Acredito que no ponto que estamos, já seja possível começar a fazer alguns jogos. Criatividade pessoal! 🙂

Tutorial Allegro 5 #13 – Utilizando Joystick

Olá pessoal! Hoje temos mais um post da série sobre Allegro 5, dessa vez tratando sobre como programar uma aplicação para utilizar o joystick como dispositivo de entrada.

A biblioteca Allegro possui suporte nativo a esse tipo de dispositivo. Teoricamente, qualquer joystick USB reconhecido por seu sistema operacional deve funcionar corretamente junto com a biblioteca (pra dizer a verdade, nunca tive a oportunidade de testar um joystick com qualquer outro tipo de conexão).

Na versão 5, temos ainda uma nova funcionalidade: os joysticks podem ser conectados e desconectados mesmo durante a execução do seu aplicativo, bastando apenas realizar uma nova chamada à função al_reconfigure_joysticks(). Além disso, você pode utilizar, também, mais de um joystick ao mesmo tempo (infelizmente ainda não tenho 2 joysticks pra testar e fazer um tutorial… mas quem sabe num futuro próximo?).

Para esse tutorial, testei em um joystick bem mais ou menos que eu tenho aqui (é um Foston, modelo imitação do Dual Shock do Playstation), mas, como disse, deve funcionar com qualquer joystick USB que você tiver por aí.

O nosso exemplo consiste em mover um círculo pela tela utilizando os direcionais do joystick. Ao pressionar as teclas 1, 2, 3 ou 4, o círculo muda de cor, alternando entre branco, verde, azul e vermelho. Vamos dar uma olhada no código e já comentamos o que temos de novo nele:

Na inicialização, temos algumas funções novas sendo chamadas. A primeira delas é a função al_install_joystick(), necessária para utilizarmos esse dispositivo (assim como temos funções de inicialização específicas para mouse e teclado). Logo após, temos uma chamada à função al_reconfigure_joysticks(), necessária para o correto funcionamento dos joysticks dentro da aplicação. Em seguida, verificamos se algum dispositivo foi encontrado, através da função al_get_num_joysticks() que retorna o número de joysticks encontrados. A partir desta funções, obtemos o joystick através da função al_get_joystick() que retorna um ponteiro para o tipo ALLEGRO_JOYSTICK. Neste exemplo em questão, não utilizaremos tal estrutura (mostrei apenas como obtê-la). Ela é útil para diferenciar eventos quando temos mais de um joystick conectado. Por fim, adicionamos a nossa fila de eventos os eventos originados no joystick, passando para a função al_register_event_source() a função al_get_joystick_event_source().

Na parte de tratamento de eventos é onde realizamos a manipulação dos dados do joystick. No caso do nosso aplicativo, temos o tratamento dos eventos ALLEGRO_EVENT_JOYSTICK_AXIS (eventos originados pelos botões direcionais) e ALLEGRO_EVENT_JOYSTICK_BUTTON_DOWN (eventos originados ao pressionar-se algum dos botões numerados).

No tratamento dos eventos ALLEGRO_EVENT_JOYSTICK_AXIS, temos o campos joystick.axis dentro do evento. Caso seu valor seja 0, o movimento foi horizontal e caso seja 1 o movimento foi vertical. Através do seu valor, ajustamos o incremento da posição x e y do círculo, controlado pelas variáveis inc_x e inc_y. Com isso, conseguiremos mover o círculo pela tela, incrementando com o valor do campo joystick.pos, que é um valor float oscilando entre -1 e 1. No caso, como o meu joystick não possui direcionais analógicos, ele só retornará -1, 0 e 1 (caso seu joystick possua direcionais analógicos, esses valores podem ser fracionários, de forma que você pode controlar a intensidade do movimento em seu jogo).

No caso dos botões, tratados pelo evento ALLEGRO_EVENT_JOYSTICK_BUTTON_DOWN (também há o evento ALLEGRO_EVENT_JOYSTICK_BUTTON_UP), verificamos qual botão foi pressionado, conferindo o valor do campo joystick.button. No caso do Windows, você pode conferir o mapeamento dos botões através do utilitário do próprio sistema (disponível em Painel de Controle -> Dispositivos e Impressoras). No caso do meu joystick, ele possui 12 botões, então terei números dos botões reconhecidos pela Allegro com números de 0 a 11.

Para testar, basta ir pressionando os botões e eles serão destacados no utilitário.

Voltando ao nosso aplicativo, mapeei 4 botões, colocando uma opção padrão (default) para o caso de algum outro botão seja pressionado. Com isso, temos a variável cor do tipo ALLEGRO_COLOR que recebe uma cor de acordo com o botão que foi pressionado.

Ao final, limpamos a tela, e desenhamos o círculo na posição indicada e com a cor selecionada. Fazemos também um mapeamento das coordenadas para que o círculo não saia da tela. O nosso aplicativo deve ficar semelhante a isso:

Para compilar:

  • Windows: -lallegro-5.0.5-mt -lallegro_primitives-5.0.5-mt
  • Linux: -lallegro -lallegro_primitives

Bom pessoal, é isso! Até a próxima!

Tutorial Allegro 5 #12 – Ajustando Frames por Segundo FPS

Olá pessoal! Voltando com a série sobre programação de jogos usando Allegro 5, hoje vamos falar sobre como ajustar a taxa de FPS (Frames Por Segundo). Geralmente, utilizamos essa técnica para evitar que um jogo seja executado em velocidades diferentes em máquinas com configurações diferentes. Por exemplo, um jogo pode rodar na velocidade “normal” em um PC mais antigo, e rodar extremamente rápido em um PC mais novo, de forma que seja impossível jogá-lo neste PC. Dessa forma, a limitação da taxa de frames é um requisito praticamente indispensável ao criar qualquer jogo.

Para mostrar como isso funciona, e a diferença entre limitarmos ou não a taxa de frames, vamos fazer um aplicativo que exibirá um texto descendo a tela. Ao pressionar a tecla Enter, limitaremos ou não a taxa de frames. Com isso vocês perceberão a diferença do movimento. Este tutorial foi adaptado do site Lazyfoo.net (lá ele utiliza SDL e C++).

Então, vamos dar uma olhada no código e em seguida comentar os pontos mais importantes dele.

Analisando o código acima, temos lá no começo a declaração da constante FRAMES_POR_SEGUNDO, definida como 60. Este é o número geralmente utilizado para jogos. Em seguida, após as declarações comuns da janela, fundo, fonte e fila de eventos, temos uma variável do tipo double chamada tempoInicial. Ela será utilizada no cálculo do tempo para a atualização da tela. Nas inicializações, nenhuma novidade (inicializamos as bibliotecas e criamos a janela e a fila de eventos). Em seguida, temos a função carregarArquivos() que carrega a imagem de fundo e a fonte, além da função finalizar(). Após isso, tempos duas funções de controle de tempo: a função inicializar() que obtém o tempo atual através da função al_get_time(). A função al_get_time() retorna um valor double correspondente a quantidade de segundos desde que a biblioteca Allegro foi inicializada. Logo após, temos a função obterTempo() que retorna a diferença entre o tempo atual (al_get_time() novamente) e o início, quando o contador foi disparado.

Na nossa função main(), temos uma variável chamada frame que será responsável pelo deslocamento do texto na tela (animação) e uma flag booleana chamada limitado, que indicará se a limitação de 60 frames por segundo deverá ser aplicada ou não.

No looping principal, temos a verificação de eventos para fechar a janela, além da verificação da tecla Enter, que inverterá o conteúdo da flag limitado. Após isso, temos a parte em que desenhamos o fundo e o texto. No caso do texto, o que é modificado é a posição y, representada pelo 4º parâmetro da função al_draw_text. Basicamente, o deslocamento é feito pelo resultado do trecho (frame % FRAMES_POR_SEGUNDO), que representará a posição que o texto será desenhado. Como a nossa taxa de frames por segundo é de 60, o resultado desse resto de divisão será um valor entre 0 e 59, de forma que o texto terá 60 valores progressivos para o parâmetro y, sendo também ajustado pela divisão pelos frames por segundo da posição do texto centralizado na tela. Ficou meio complicado de entender, né? Mas não se preocupe, com o tempo você aprende a bolar umas lógicas mirabolantes também 😀

Por fim, incrementamos o valor de frame, atualizamos a tela e, se houver a limitação e ainda não decorreu-se 1/60 de segundo, faremos uma pausa através da função al_rest() esperando que este tempo passe.

O resultado deverá ser algo mais ou menos assim:

Faça o teste por você mesmo. O texto deverá estar passando pela tela a uma velocidade razoável. Experimente agora apertar a tecla Enter para ver o quanto o seu processador aguenta: a diferença deverá ser muito grande (pelo menos aqui o negócio ficou extremamente rápido, em um i5). Imagine em um jogo isso… ficaria “injogável” numa velocidade tão alta.

Assim, dá pra perceber a importância da limitação de frames por segundo!

Para compilar:

  • Windows: -lallegro-5.0.5-mt -lallegro_image-5.0.5-mt -lallegro_font-5.0.5-mt -lallegro_ttf-5.0.5-mt
  • Linux: -lallegro -lallegro_image -lallegro_font -lallegro_ttf

Os arquivos que utilizei podem ser baixados daqui.

Então é isso pessoal! Até a próxima!