Como muitos sabem, a Adobe tem o Flex SDK, que são o compilador e as bibliotecas do Flex Builder, só que OpenSource. Com ele você já tem o suficiente para desenvolver qualquer jogo em Flash utilizando ActionScript 3 e as bibliotecas do Flash.

Então resolvi criar um pequeno guia para iniciar na programação de jogos em Flash no Linux. Eu aqui estou usando o Ubuntu Karmic Koala, mas acredito que não vai mudar muita coisa para outras distribuições.

Instalando o Flex SDK

Primeiro de tudo você tem que instalar o Sun JDK. Se você estiver usando qualquer distro debian-based, você pode instalar direto pelo apt-get assim:

$ sudo apt-get install sun-java6-jdk

Caso esteja usando outra distro, você pode baixar a JDK diretamente pelo site do Java. Agora baixe a SDK do Flex no site da Adobe. É um pouquinho grande, tem cerca de 120MB. Agora extraia o conteúdo do arquivo no diretório /opt/flex, que você deve criar. Supondo que você baixou o arquivo flex_sdk_3.5.zip na pasta Downloads:

$ sudo mkdir /opt/flex
$ cd ~/Downloads
$ unzip flex_sdk_3.5.zip -d tmpflex
$ sudo mv tmpflex/* /opt/flex/
$ rm -rf tmpflex

Pronto, você já extraiu a SDK do flex para a pasta /opt/flex, se quiser ter certeza disso, pode dar um:

$ cd /opt/flex
$ ls

Se você ver um monte de arquivos e pastas é porque deu tudo certo. Entretanto, você precisa adicionar a pasta bin ao PATH, para que você possa chamar o compilador pelo shell. Então faça o seguinte:

$ sudo echo "export PATH=/opt/flex/bin:$PATH" >> ~/.bashrc

Isso vai adicionar  a linha export PATH=/opt/flex/bin:$PATH ao arquivo .bashrc, o que dizer que a pasta de binários do Flex SDK vai poder ser acessada pelo shell. Agora feche todas as suas janelas de terminal, abra uma e teste se tudo está ok:

$ mxmlc --version

Se ele mostrar a versão é porque está tudo funcionando perfeitamente.

Instalando o FlashPlayer Standalone

Depois de instalar o SDK do Flex, você já pode programar normalmente e testar seus SWF’s em um navegador. Mas isso não é aconselhável porque dessa forma você não pode ver os erros de runtime que acontecerem no seu jogo. Então vamos instalar o FlashPlayer Standalone. Primeiro de tudo, baixe o pacote com o player normal e o player com debugger aqui no site da Adobe. Mais uma vez vamos extrair e instalar:

$ cd ~/Downloads
$ tar xzvf flash_player_10_linux_dev.tar.gz
$ cd flash_player_10_linux_dev/standalone/debugger
$ tar xzvf flashplayer.tar.gz
$ sudo mv flashplayer /usr/bin/
$ cd ~/Downloads
$ rm -rf flash_player_10_linux_dev

Pronto, teste agora para ver se o flashplayer foi instalado:

$ flashplayer

Onde programar?

Aqui é a parte onde a programação para Flash no Linux me decepciona um pouco. No Windows nós temos o FlashDevelop, que é uma ótima IDE OpenSource. Para Linux eu testei vários plugins para Eclipse e para NetBeans e, infelizmente, não consegui fazer nenhum deles funcionar. São, em sua maioria, muito antigos e sem suporte para as novas versões dessas maravilhosas IDE’s.

Mas há plugins de colorização de código para editores como o VIM, ou o gedit. Para instalar o plugin de colorização ActionScript 3 no gedit, baixe esse arquivo actionscript3.lang e então coloque na pasta /usr/share/gtksourceview-2.0/language-specs/.

Criando um joguinho em ActionScript 3

Depois de tudo isso, vamos criar algo bem básico só para mostrar como é a programação em ActionScript no Linux. Primeiro de tudo, crie uma pasta para o seu projeto:

$ mkdir asgame
$ cd asgame

Agora então crie uma classe bem básica em AS3:

package {

   import flash.display.Sprite;

   // Define algumas características do SWF
   [SWF(width="640", height="480", frameRate="60", backgroundColor="#00CC00")]

   public class Game extends Sprite {
      public function Game()
      {
         trace ("Jogo iniciado!");
      }
   }
}

Essa é a classe mais simples possível, ele apenas vai ter o fundo verde e vai exibir um texto no console. Salve como Game.as. Para compilar, basta chamar o mxmlc:

$ mxmlc Game.as

Depois para testar, você chama o flashplayer passando o Game.swf (que acabou de ser compilado):

$ flashplayer Game.swf

Você também pode testar isso no seu navegador.

Eu costumo criar um script, ou um alias para fazer isso pra mim. Veja como ficaria um script run.sh:

#!/bin/sh

mxmlc Game.as && flashplayer Game.swf

Então fica facinho compilar e testar a cada alteração no código:

$ ./run.sh

Ou simplesmente criar o alias run para compilar de uma vez:

$ alias run="mxmlc Game.as && flashplayer Game.swf"

E chamar usando:

$ run

Frameworks

Não poderia de citar alguns frameworks para o desenvolvimento de jogos em ActionScript 3.0 (com o Flex SDK):

• PushButton Engine
• flixel
• Flash Punk

Não testei a fundo nenhuma das três. Instalei e fiz alguns testes bem básicos com a flixel e com a PushButton, mas nada de interessante que eu possa postar aqui. Por isso vou deixar essa parte para um futuro post.

Conclusão

Eu comecei a criar meu primeiro joguinho em ActionScript 3 com a Flex SDK no Linux há pouco tempo. Já deveria tê-lo terminado, mas não consegui por outros fatores. Entretanto, você pode acessar o código-fonte do BallCanoide em desenvolvimento no GitHub.

No começo eu procurei usar alguns frameworks que eu citei acima, mas percebi que para esse caso eu não precisaria, pois só as bibliotecas do Flash mesmo seriam suficiente. Ainda mais que eu já tinha algum conhecimento delas.

Espero que esse pequeno guia ajude pessoas que não sabem como programar jogos em flash no Linux a começar nessa área. Ainda essa semana eu pretendo escrever um post sobre como utilizar o InkScape para criação de recursos gráficos para jogos em ActionScript com Flex SDK. Já que o Flash trabalha com imagens vetoriais nativamente, nada mais natural que usar SVG. Aguardem. =D

Posts semelhantes:

1. Criando Flash Games no Linux II
2. Flash Games em Dispositivos Móveis
3. Por que eu gosto de jogos em Flash?

Como em todas as outras áreas do conhecimento, há várias formas de aprender sem fazer um curso específico. Aqui vai algumas dicas simples.

Na internet

Minha melhor recomendação é o recente curso gratuito de Game Design dado por Ian Schreiber – profissional da área de games há algum tempo que já escreveu alguns livros que serão citados adiante. O curso foi dado entre Julho e Setembro, com um fórum para tirar dúvidas e uma wiki com dicas e traduções do curso. Infelizmente a tradução para o português parou logo no primeiro capítulo do curso.

O Ian também tem um blog sobre Game Design, que é o Teaching Game Design, além de escrever no blog Applied Game Design.

Não podemos de citar sites como Gamasutra e GameCareerGuide, que têm muito texto sobre desenvolvimento, não só na área de Game Design como em outras áreas também. O Gamasutra é considerado como um dos melhores sites quando o assunto é desenvolvimento de games.

Também temos blogs brasileiros sobre o assunto, o Loodo, por exemplo, é um ótimo blog sobre game design. GameDevBR, Desvaneios Digitais Interativos  e o Blog do Tupinihon são outros que você não pode deixar de dar uma olhada, sempre têm dicas sobre o assunto.

Livros

Livros são indispensáveis, há vários livros sobre o assunto que são ótimos. A maioria é em inglês, então se você não sabe inglês, esse é o primeiro passo.

Em português eu poderia citar o Design de Games e o Design de Jogos. Não li nennhum dos dois ainda, porém assim que eu o fizer, com certeza postarei aqui um review.

Já em inglês há vários. Como pré-requisito do curso do Ian, há dois livros interessantíssimos, que é o A Theory of Fun e o Challanges for Game Designers. E um dos mais falados por aí é o The Art of Game Design: A book of lenses. O livro parece realmente muito bom, e você pode constatar isso em vários reviews desse livro.

Agora basta  você se empenhar. Material não falta.

Fazendo funcionar

Primeiro de tudo, instale o Git com o msys, que é um “emulador” de Bash para Windows, aqui. Na instalação, só tenha certeza que a opção “Use OpenSSH” está ativa.

Pronto, agora nós precisamos criar uma chave SSH, para isso, abra o Git Bash, e digite:

$ cd ~/.ssh/

Caso a pasta .ssh não exista, então crie:

$ mkdir .ssh

Agora então entre nela. Vamos definir os seus dados no Git:

$ git config --global user.name "Bruno Croci"
$ git config --global user.email email@seila.com

Agora criamos a chave SSH:

$ ssh-keygen -t rsa -C "email@seila.com"

É interessante que você use o mesmo email que usou para cadastrar no GitHub. Ele vai fazer uma série de perguntas, como onde você quer salvar, apenas dê enter, vai perguntar também se você quer colocar uma senha de acesso, é bom colocar, mas não necessário.

Agora você vai na sua conta no GitHub, e em account. Na parte de SSH Public Keys, você vai clicar em add another public key, então você vai agora lá na pasta .ssh que você criou na home – se você tiver no Windows XP é C:\Documents and Seetings\Usuario\.ssh\, caso esteja no Windows Vista ou superior, é C:\Users\Usuario\.ssh\ – e vai abrir o arquivo id_rsa.pub, vai copiar o seu conteúdo exatamente igual, sem nenhuma quebra de linha a mais nem a menos e vai colar no campo Key da página, o título você pode colocar qualquer coisa. Então adicione essa chave.

Lembrando que essa chave é criada de acordo com o computador, então em cada computador que você quiser acessar sua conta, vai ter que criar uma chave nova e então adicioná-la à sua conta no site.

Agora volte para o console aberto e teste com:

$ ssh git@github.com

(esse passo provavelmente não vai funcionar no codaset, caso esteja configurando ele, pule este teste)

Caso você tenha setado uma senha na criação da chave, ele irá perguntar, coloque-a e veja o que ele diz. Se você fez tudo exatamente como mostrado, ele vai mostrar uma mensagem dizendo que conseguiu conectar.

E agora?

Se o SSH conseguiu conectar, agora tudo já funcioina perfeitamente, mas e agora? Que tal criarmos um repositório? Primeiro de tudo, vá na pasta do seu projeto e crie o repositório assim:

$ git init

Lembre-se de ter um arquivo README nessa pasta com a descrição do repositório. Agora adicione todos os arquivos dando um:

$ git add .

Comite tudo isso:

$ git commit -m "Primeiro Commit. =D"

Agora vá no GitHub, crie um repositório novo. Precisamos avisar este repositório local, que ele deve sincronizar com o do site, então faça assim:

$ git remote add origin git@github:SeuLogin/NomeDoRepositorio.git

Agora vamos sincronizar este repositório com o remoto:

$ git push origin master

Pronto, você já sincronizou todo o projeto.

Além do GitHub?

Você pode usar outros serviços do tipo, além do GitHub, como por exemplo o Gitorious, ou o Codaset. O Codaset é um serviço que está em Beta ainda, mas achei bem legal. Apesar de não ter muitas coisas diferente dos outros.

Todos os passos que eu dei aqui são iguais para qualquer serviço, basta que você cadastre sua chave ssh no serviço que você for usar.

Se você quiser conferir alguns projetos meus, você pode acessar minhas contas no Codaset e no GitHub.

Não sei NADA de Git…

Sem problemas, eu também só sei comitar, e sincronizar os repositórios. Por isso você pode dar uma lida no livro Magia Git, que é muito bom.

Só para constar, esse pequeno tutorial foi baseado no tutorial do GitHub sobre geração de chaves SSH.

Posts semelhantes:

1. Viva, é OpenSource

Parte1 – Antes de tudo

Primeiro de tudo, é essencial que você possua o tempo necessário, ou seja, que nos dias que você separar (ou nos dias do contest) você esteja livre. Tão importante quanto isso é ter todas as ferramentas que você vai usar previamente instaladas. Já pensou se você vai instalar os programas depois que liberarem as regras?

É muito útil se você tiver uma estrutura do jogo já pronta, facilitando ainda mais o desenvolvimento. Nos meus jogos em Allegro, eu já tenho várias classes prontas, e uma estrutura padrão que eu uso em todos os jogos de contests rápidos. Não é a melhor estrutura, porém é suficiente.

Parte 2 – Desenvolvimento

Logo que sair as regras, você já vai ter tudo preparado para desenvolver o game, mas não caia na tentação, não vá programar na hora. Agora é que vem a parte mais difícil de tudo isso: Fazer o design do jogo. Nessa hora pegue um papel, um lápis e fique lá escrevendo e desenhando tudo o que puder sobre o tema. É claro, dependendo do tema, é interessante que você faça uma pesquisa sobre ele, às vezes isso ajuda muito.

Nós não temos tempo de prototipação, ou seja, você terá que fazer todo o protótipo do jogos na cabeça. Testá-lo várias vezes. Lembre-se de uma regra muito importante do GameDesign, que é prototipar, testar, modificar e começar esse ciclo novamente. Ou seja, assim que tiver uma idéia jogável, “jogue” na sua mente, veja o que precisa ser mudado, jogue-o novamente, e assim por diante. Não pare até ver que seu jogo realmente ficou interessante e implementável – lembre-se que você tem pouco tempo para tornná-lo realidade.

Gostou da idéia que teve? Então documente-a rapidamente num arquivo texto, ou na sua folha de papel mesmo, com todos aqueles desenhos que você fez. Acho que aqui vem uma parte muito importante, definir TODOs. Crie um arquivo e coloque lá, em lista, as tarefas para o desenvolvimento do game. Divida todo o desenvolvimento do jogo em pequenas partes, e em ordem. É muito mais difícil você desenvolver algo sem ter pequenas metas, você vai ver que isso ajuda muito.

Agora então comece a programação. Programe seguindo a lista de tarefas criada anteriormente. Não é necessário comentar muito seu código, mas é aconselhável. Não se preocupe muito com POG, só tome cuidado para que isso não saia do seu controle. O tempo é curto, não dá para ficar refatorando cada testezinho que você faz, isso é verdade, mas não deixe o código muito ilegível também. Além de tudo, tem que tomar cuidado para  não criar algorítimos ineficientes, não precisa usar algorítimos ótimos a todo momento, mas também não queremos o jogo lento por causa de algorítimos mal criados.

Faça os gráficos do seu jogo. Não precisa terminar todo o jogo para criar os gráficos, eu acho ótimo dar uma break na programação para desenhar um pouco. Garanto que isso dá uma relaxada.

Parte 3 – Algumas dicas…

• Durma – é muito importante que você durma. Não ache que vai ficar todo o tempo codando que você não vai aguentar, e depois que você está com sono, começa a fazer algumas coisas meio sem lógica, o que aqui não se encaixa muito bem, precisamos muito de lógica.
• Breaks – faça pausas no desenvolvimento. Não muito demoradas, porque senão você perde a linha de raciocínio. Entretanto, pausas são muito eficientes. Eu aconselharia você a jogar algum joguinho nelas, porém algo bem rápido e divertido. Não gaste mais que dez minutos em cada pausa. Lembre-se também que elas gastam tempo, e você não tem muito.
• Alimentação – faça uma alimentação saudável, pelo menos no tempo de desenvolvimento. Não coma muito, nem coisas muito gordurosas, elas podem te fazer passar mal, e isso não é nada interessante. Mas também aconselho comer chocolate, sem exagero. Chocolate é ótimo porque dá prazer, e te livra um pouco da tensão.
• Beba – essa é uma dica que eu adoro. Beba muito líquido. Nem que seja água. Pode ser café, leite, chá, refrigerante. Só tome cuidado, quando eu digo para beber muito, não é para exagerar. Lembre-se que tudo em exagero pode fazer mal. Eu, por exemplo, adoro chá gelado, ou então coca-cola.

Espero que essas dicas ajudem, pois para mim são muito úteis.

Referências e complementos:

• Ludum Dare Survival Guide
• How to prototype a game in Under 7 Days
• How to design a game when you don’t have time

Posts semelhantes:

1. Meu jogo para o ChristmasHack '08
2. Meu jogo para o Contest de Mobile

Então… são 11 da manhã de primeiro de janeiro e eu não durmi até agora desde ontem, acho que nem vou durmir mesmo, só à noite agora. Eu fiquei passeando pela internet essa noite e encontrei algumas coisas interessantes, que eu tinha que compartilhar com vocês, não é nada muito novo, mas eu não conhecia, então muita gente aí também pode não conhecer também…

No youtube, achei uns canais interessantes sobre GameDev, um deles é o do GyroVorbis, que além de ter alguns vídeos explicando sobre desenvolvimento de jogos em si, tem uma série muito interessante que ele fez com a “equipe” dele. Adventures in Game Development tem 15 capítulos, sendo que alguns capítulos são separados em partes. Eles todos se juntaram para desenvolver uma engine para rodar em PC e Dreamcast, cada vez vão para a casa de alguém, é uma bagunça. Um programa a engine, o outro o MapEditor, o outro os scripts (em lua), e eles zoam muito, é muito legal! Passei a noite inteira vendo os vídeos deles. Vale a pena conferir, veja o primeiro capítulo:

Adventures in Game Development Chapter 1

Depois vai olhando os outros.

É claro, é indispensável um pouco de conhecimento em inglês, mas nem tanto, se você não é muito bom, vai ouvindo com atenção e assistindo os vídeos, são muito bons.

Não deixe de conferir os outros vídeos do mesmo canal, tem uns dando dicas sobre gamedev.

Também tem outro canal muito interessante, que é o da LusikkaMage, ela tem vários tutoriais sobre C/C++, Winsock, Allegro (uma playlist com uns 16 vídeos sobre allegro) e até tutorial de sprites!

A Rachel (dona desse canal) também ajuda os caras lá encima, mas só com sprites.

Fora isso tudo aí, em algum lugar que eu não lembro mais, achei um site com vários vídeo tutoriais de OpenGL. Claro, ele está em inglês também, por isso que eu digo, é melhor você começar a estudar mais inglês se quiser ingressar na área de GameDev! hehehe

Navegando pelos meus Feeds, também encontrei uma Lib para C++ para programação fácil de jogos 2D (e 3D também, vai) acelerados por hardware via Direct3D. É a IndieLib. Na verdade ela foi feita para a implementação de ‘protótipos’ de jogos, por ser fácil de implementar. Não mexi nela ainda, mas me parece ser bem amigável.

Ahh, e não é por que ela foi feita para fazer protótipos de jogos que você não possa criar um jogo sério nela, você pode sim, inclusive acho que ela seja boa para iniciantes ou pessoas que queiram resultados rápidos.

Vale a pena dar uma olhada e uma fuçada! hehehe

Vou deixar um link muito interessante que é essa lista de ferramentas e libs para programação de jogos (tudo free):

Free Game Development Libraries

Tem mais coisa lá que você pode imaginar! hehehe

Ahh, e como o Flausino postou no GamedevBR: “Ano novo, tudo novo”, eu to cheio desse layout aqui, to querendo mudar, mas eu queria mesmo é estrear com novo tema quando eu colocar ele em um servidor e domínio próprio, mas eu to vendo que não vai ser para agora, talvez mês que vem só… então quem sabe eu mude! =D

Posts semelhantes:

1. GameDev com Ruby

Um exemplo bem simples, são aqueles jogos de Orkut, que eu já até citei aqui. A integração com a rede social é feita através da API OpenSocial, porém a jogabilidade, muitos multiplayer e não só dentro da rede social, podendo jogar com guests, é feita, na maioria das vezes com AJAX. Claro, nem sempre, tem muitos jogos lá desenvolvidos com flash.

Flash, seria talvez uma alternativa ao AJAX. Ambos se comunicam com o servidor de formas muito parecidas, via arquivos XML.

Servidor? Sim, tem que ter um servidor rodando, um servidor web. Esse servidor vai receber as informações dos jogos e então repassar aos clientes. O servidor pode ser feito em qualquer linguagem de programação, claro que eu recomendo PHP.

Tudo que ele faz é receber requests processar os dados e elaborar um XML de resposta, que será enviado ao cliente. Então o cliente trata este XML, e exibe as alterações na tela pelo JavaScript.

Claro que para tudo isso, o mais necessário é o domínio no JavaScript, pois ele além de mexer com toda a parte visual (na minha opnião, o mais complicado), ele vai enviar os requests, e quando receber a resposta, vai tratar o XML e exibir ao usuário. Sem contar que tem que tratar muitos erros, e exceções que acontecerão com o ajax, por causa das incompatibilidades.

Para isso existem alguns Frameworks para ajudar no trabalho, dentre elas a MooTools, Prototype e a jQuery. Nunca use a MooTools. A Prototype é legalzinha, mas a que mais gostei mesmo foi a jQuery. Ela é bem completa, e além de tudo isso, aceita plugins, que você pode achar muitos por aí, que façam qualquer coisa.

Com um framework tudo pode ficar mais fácil. Aí então o próximo passo é a segurança. Por ser uma tecnologia Client-Side e em modo texto, todos podem ver os fontes do seus códigos JS, fica muito mais fácil de seu jogo ser hackeado. Então a segurança é um ponto crucial aqui.

Bom, tendo uma boa noção de JS e/ou de algum framework, segurança, só falta uma boa idéia de jogo e um bom design, e então é mão na massa.

Vale a pena investir em jogos via browser sim, principalmente se eles tiverem integrações com redes sociais via OpenSocial, pois é um passatempo que muita gente, hoje, usa.

(Muito obrigado ao Rodrigo pela idéia do post, sei que isso não te ajuda em nada, mas talvez possa ajudar outra pessoa por aí… hehehe)

Java Games: Keyboard and Mouse

Ele explica como fazer a detecção de input tudo pela mesma thread, diferente do método padrão do java, que é por eventos, o que cria threads separadas para cada input, dificultando muitas vezes a programação de jogos.

Se você está aprendendo também, vale a pena dar uma olhadinha.

Posts semelhantes:

1. Matemática aplicada: FPS com Java
2. Conectando a um BD Access com Java
3. Sistema Comercial em Java

Acredito que o jeito mais fácil, seja adicionar estas funções no seu arquivo fonte:

void highcolor_fade_in(BITMAP *bmp_orig, int speed)
{
   BITMAP *bmp_buff;

    if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
    {
        int a;
        if (speed <= 0) speed = 16;

        for (a = 0; a < 256; a+=speed)
        {
            clear(bmp_buff);
            set_trans_blender(0,0,0,a);
            draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
            vsync();
            blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
        }
        destroy_bitmap(bmp_buff);
    }

    blit(bmp_orig, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
}

void highcolor_fade_out(int speed)
{
    BITMAP *bmp_orig, *bmp_buff;

    if ((bmp_orig = create_bitmap(SCREEN_W, SCREEN_H)))
    {
        if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
        {
            int a;
            blit(screen, bmp_orig, 0,0, 0,0, SCREEN_W, SCREEN_H);
            if (speed <= 0) speed = 16;

            for (a = 255-speed; a > 0; a-=speed)
            {
                clear(bmp_buff);
                set_trans_blender(0,0,0,a);
                draw_trans_sprite(bmp_buff, bmp_orig, 0, 0);
                vsync();
                blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
            }
            destroy_bitmap(bmp_buff);
        }
        destroy_bitmap(bmp_orig);
    }

    rectfill(screen, 0,0, SCREEN_W,SCREEN_H, makecol(0,0,0));
}

E depois só chamar as funções, mas você pode criar um arquivo fonte, colocar estas funções e então criar um arquivo header e colocar as respectivas declarações das funções.

Tá, mas como se usa?

Assim… A função fade_in, vai do pretão para uma imagem, então você tem que ter esta imagem que você quer que apareça (tela inteira) em um BITMAP, então você faz isso:

highcolor_fade_in(bitmap, 16);

Lembrando que quanto maior for o valor dado a velocidade (no caso ), mas rápido vai ser, e este valor vai de 1 a 255.

Já a função de fade_out, que transforma da imagem atual para o preto, é assim:

highcolor_fade_out(16);

E a regra para a velocidade é a mesma do fade_in! ^^

Bom, é isso ae pessoal, artigo simples para iniciantes!

Flw

Posts semelhantes:

1. Fade In/Out com fblend no Allegro
2. Entrada de Texto no Allegro
3. Fontes TTF no Allegro

Vamos usar um Banco de Dados Acess com ODBC para conectar com o Java. Tentarei mostrar da forma mais simples possível.

Primeiramente, crie um banco de dados no Access e salve em alguma pasta FIXA do seu projeto (um exemplo, crie uma pasta bf na pasta raiz do seu projeto).

Agora abra o Painel de Controle do Windows, vá em Ferramentas Administrativas -> Fonte de Dados (ODBC). Você pode selecionar a aba Fontes de Dados do Sistema, e então clique em Adicionar. Selecione Driver do Microsoft Access (*.mdb) e clique em Concluir, agora coloque um nome para o Alias do seu banco (esse alias serve para interligar o Java ao Banco), clique em Selecionar e escolha o caminho do banco. Pronto, agora pressione OK e pronto! Vamos então para a melhor parte: Programação! =]

Na sua classe, importe:

import java.sql.*;

Ela é que contém as classes necessárias para se conectar e manipular o banco.

Agora, dentro da classe, você pode definir uns objetos, um Connection, que manipula a conexão em si, e um Statement, que manipula o banco com querys. Assim:

public Connection con;
public Statement stm;

Agora, para facilitar, crie um método chamado Connectar:

public void Conectar()
	{
		//JOptionPane.showMessageDialog(null, "Preparando para iniciar a conexão com o BD;");

		try
		{
			/* Tenta se conectar ao Driver */
			Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
		}
		catch (ClassNotFoundException e)
		{
			JOptionPane.showMessageDialog(null, "Impossível carregar o Driver.");
			System.exit(0);
		}
		try
		{
			/* nomedobanco é o nome que você deu anteriormente ao seu alias */
			con = DriverManager.getConnection("jdbc:odbc:nomedobanco");
			stm = con.createStatement();
		}
		catch (SQLException sqle)
		{
			JOptionPane.showMessageDialog(null, "Problema ao conectar!");
			System.exit(0);
		}

		//JOptionPane.showMessageDialog(null, "Conectado com sucesso!");
	}

Você pode descomentar as linhas que mostram uma mensagem antes de se conectar e depois, só para ver como que é! ^^

Crie também uma função para desconectar, e se possível, chame-a antes de sair do seu programa:

public void Desconectar()
	{
		try
		{
			con.close();
		}
		catch (SQLException sqle)
		{
			JOptionPane.showMessageDialog(null, "Problema ao desconectar!");
			System.exit(0);
		}
	}

Basicamente, agora você já pode se conectar e desconectar ao banco de dados! Excelente não?

Tá, imagino agora que você se perguntou: “Mas como vou manipulá-lo agora?”! Hmm, Boa pergunta!

Para manipular o Banco de Dados em si, como fazer consultas, inserções, remoções, é necessário a utilização de SQL, portanto se você não sabe, é melhor estudar um pouco! hehehe

Então, voltando para o Java…

Lembra-se do objeto Statement que criamos? Então, ele é o ponto chave agora! Para executar uma query, você usa o método execute dele, assim:

stm.execute("INSERT INTO tabela(nome, idade) VALUES('Bruno', 17)");

Porém ele NÃO traz retorno algum, ou seja, se você quiser fazer uma consulta, por exemplo, tem que usar o método executeQuery, que retorna um objeto ResultSet, que contém todo o resgistro retornado do banco de dados, a partir da consulta.

try
{
	ResultSet rs = stm.executeQuery("SELECT * FROM tabela");
	while (rs.next())
	{
		JOptionPane.showMessageDialog(null, "Nome: " + rs.getString("nome") + " - Idade: " + rs.getInt("idade"));
	}
}
catch (SQLException e)
{
	JOptionPane.showMessageDialog(null,"" + e.getMessage(),"Erro",0);
}
finally
{
	rs.close();
}

O Objeto ResultSet, tem um método para pegar cada tipo do banco de dados. Dentro dele vai o parâmetro que é o nome do campo a ser pego!

Fácil? Não exatamente! Isso é muito básico, não inútil, mas básico. Portanto, você concerteza vai precisar de mais material, então acesse este magnífico site que você vai achar de tudo lá! =D

(Muito Obrigado ao ViniGodoy pela ajuda aqui! =D)

Valeu, até a próximaaa!

Posts semelhantes:

1. Sistema Comercial em Java
2. Input de Mouse e Teclado no Java
3. Matemática aplicada: FPS com Java

Se você estiver utilizando ela no seu projeto e desejar usar fade in/out, você pode utilizar estas funções aqui:

void fade_in(BITMAP *bmp_orig, int speed)
{
   BITMAP *bmp_buff;

    if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
    {
        int a;
        if (speed <= 0) speed = 16;

        for (a = 0; a < 256; a+=speed)
        {
            clear(bmp_buff);
            fblend_trans(bmp_orig, bmp_buff, 0, 0, a);
            blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
        }
        destroy_bitmap(bmp_buff);
    }

    blit(bmp_orig, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
}

void fade_out(int speed)
{
    BITMAP *bmp_orig, *bmp_buff;

    if ((bmp_orig = create_bitmap(SCREEN_W, SCREEN_H)))
    {
        if ((bmp_buff = create_bitmap(SCREEN_W, SCREEN_H)))
        {
            int a;
            blit(screen, bmp_orig, 0,0, 0,0, SCREEN_W, SCREEN_H);
            if (speed <= 0) speed = 16;

            for (a = 255-speed; a > 0; a-=speed)
            {
                clear(bmp_buff);
                fblend_trans(bmp_orig, bmp_buff, 0, 0, a);
                blit(bmp_buff, screen, 0,0, 0,0, SCREEN_W, SCREEN_H);
            }
            destroy_bitmap(bmp_buff);
        }
        destroy_bitmap(bmp_orig);
    }

    rectfill(screen, 0,0, SCREEN_W,SCREEN_H, makecol(0,0,0));
}

Que nada mais são do que aquelas funções que tem no site da A.cc, só que com o fblend, não com o blend do Allegro.

Se você não sabe o que é a fblend, aguarde mais um pouco que logo eu pretendo fazer um tutorialzinho básico de como instalá-la e usá-la! =D

Bom uso!

Posts semelhantes:

1. Fade In/Out com Allegro
2. Entrada de Texto no Allegro
3. MotionBlur com Allegro