Pages

Banner

sábado, 9 de junho de 2012

JAVA GAMES 2D::Sons MIDI::07


Olá pessoal!
No tutorial de hoje iremos aprender como tocar arquivos de áudio do tipo MIDI (Musical Instrument Digital Interface)!!! É bem interessante usar esse tipo de arquivo de áudio, facilmente vocês irão encontrar por ai programas para compor melodias e salvar no formato .mid, sugiro que baixem ai algum teclado virtual que dê suporte a este recurso, ou pesquisem e baixe por aí sons já prontos! (são muito pequenos e rápido de baixar!!!), exite formas de tocar formatos diferentes de áudio como .mp3, .au, .wav, mas não será tema desse tutorial!



Então vamos lá!
Para tocar um arquivo de áudio .mid, a primeira coisas que iremos precisar é de um arquivo de áudio do tipo .mid!!!


Depois iremos precisar de um objeto do tipo Sequence para carregar dentro dele o arquivo que iremos tocar, e de um objeto do tipo Sequencer, ele é que irá tocar nossas sequences!
Nosso exercício de hoje será o seguinte: crie um pacote chamado tutoria7 dentro do nosso projeto JAVAGAMES2D, cole dentro do pacote o arquivo Game.java, do pacote tutorial3 que é o nosso template!
Agora nós vamos declarar nosso Sequencer (tocador) e Sequence (música), e em seguida iremos criar um método para tocar a trilha sonora de nossos games!
(Nota: ao declarar o Sequencer e Sequence lembre de importar! use o autoplete que será feito automático! Ctrl+Barra de espaço)
Abaixo segue o código:
(Lembrando que você pode baixar o exemplo clicando no link acima!)




import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.sound.midi.MidiSystem;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.swing.ImageIcon;
import javax.swing.JFrame;

public class Game extends JFrame {

 BufferedImage backBuffer; 
 int FPS = 30;
 int janelaW = 500;
 int janelaH = 500;
 
 Sequencer player; //ESSE É O NOSSO TOCADOR
 String musica1 = "src/tutor7/batalha.mid"; //ISSO É SÓ A URL DA NOSSA MÚSICA
 String musica2 = "src/tutor7/campo.mid"; //ISSO AQUI TAMBÉM É OUTRA URL
 
 public void tocarMusica(String nome, int repetir){
  try{
   player = MidiSystem.getSequencer();  //INICIA O TOCADOR
   Sequence musica = MidiSystem.getSequence(new File(nome));//CARREGA A MÚSICA A SER TOCADA
   player.open(); //ABRE O TOCADOR
   player.setSequence(musica); //PASSA A MÚSICA QUE VAI SER TOCADA PARA O TOCADOR
   player.setLoopCount(repetir); //DEFINE QUANTAS VEZES VAI TOCAR A MÚSICA OBS: 0 = 1 vez; 1 = 2 vezes; 2 = 3 vezes...
   player.start(); //COMEÇA A TOCAR.... CASO QUEIRA PARAR DE TOCAR A MÚSICA BASTA: player.stop();
  }catch(Exception e){
   System.out.println("Erro ao tocar: "+nome);
  }
 }
 
 public void atualizar() {

 }

 public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  //AQUI VAMOS MANDAR DESENHAR ALGUNS IMAGENS NA TELA

  //================================================================================== 
  g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!
 }

 public void inicializar() {
  setTitle("Titulo do Jogo!");
  setSize(janelaW, janelaH);
  setResizable(false);
  setDefaultCloseOperation(EXIT_ON_CLOSE);
  setLayout(null);
  setVisible(true);
  backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);
  
  //===========================================================================
  //========== É AQUI QUE EU TO CHAMANDO O MÉTODO tocarMusica()================
  tocarMusica(musica1, 999); //CHAMAMOS O TOCADOR DENTRO DO MÉTODO inicializar()
  //ENTÃO AO INICAR O GAME, ESSA SERÁ A NOSSA MÚSICA DE FUNDO
  //===========================================================================
 }

 public void run() {
  inicializar();
  while (true) {
   atualizar();
   desenharGraficos();
    try {
     Thread.sleep(1000/FPS);
    } catch (Exception e) {
     System.out.println("Thread interrompida!");
    }
  }
 }
 public static void main(String[] args) {
  Game game = new Game();
  game.run();
 }
}

Muito bem.... vamos entender alguns pontos...  o método tocarMusica() que criamos vai receber 2 argumentos o nome da música e o número de vezes que ela se repetirá, só reforçando, se você passar 0 (zero) ele vai tocar 1 vez, se você passar 1(um) ele vai tocar 2... então ele vai tocar (n+1) vezes!!!!
Caso você queira tocar um som de um BIP ao clicar, basta chamar o método tocarMusica() dentro do evento de click (estudaremos sobre eventos mais adiante...), outro exemplo, caso você queira emitir um som de tiro em um jogo de nave, basta chamar o mesmo método quando for disparar o tipo, finalizando.... você pode usar o mesmo método para tocar qualquer parte da trilha sonora dos nossos games!!!
(executem aí para ouvir o som tocando!!!)

Então é isso ai pessoal! finalizamos mais um tutorial, testem esse exemplo ai, lembrando que está disponível para download no link acima!
Até o próximo!!


\_(^_^)_/ Comentários em baixo \_(^_^)_/

JAVA GAMES 2D::Imagens::06


Olá pessoal!
Nesse tutorial, vamos aprender como desenhar imagens (PNG GIF JPG) nas telas de nossos games! é bem legal usar imagens para construir games, eles ficam com um design mais chamativo, e dá menos trabalho que desenhar com usando a Classe geom que vimos nos tutoriais anteriores... recomendo que aprendam a usar alguma ferramenta de desenhos em VETOR (indico o Inkscape ou CorelDraw) e outra ferramente para tratar imagens (indico o Gimp ou Photoshop), mas use o de sua preferência, estarei usando o Inkscape e Gimp em alguns dos exemplos que irei postar ainda... (pegar algumas no google também! \(^_^)/  )...

Muito bem... o primeiro passo para desenhar imagens na tela é ter uma variável do tipo imagem, e carregar uma imagem para essa variável!
(lembrando ao declarar uma variavel do tipo ImageIcon devemos importar essa classe primeir, o Eclipse importa automaticamente para mim, quando uso o autocomplete)

  ImageIcon abelha = new ImageIcon("src/pacote/imagem.png");

Lembre de usar imagens com fundo transparente quando for desenhar a Sprite de algum personagem para seu jogo!

Novamente crie um pacote chamado tutorial6 dentro do projeto JAVAGAMES2D, cole lá a classe Game.java que deixamos como modelo, salve uma imagem de sua preferência nesse mesmo pacote (ah! ou baixe o exemplo pronto no link acima!!!)

Olhe como via ficar o nosso código:
(no inicio declaramos a variável abelha e mandamos desenhar no método desenharGraficos() )



import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;

import javax.swing.ImageIcon;
import javax.swing.JFrame;

public class Game extends JFrame {

 BufferedImage backBuffer; 
 int FPS = 30;
 int janelaW = 500;
 int janelaH = 500;
 
 ImageIcon abelha = new ImageIcon("src/tutor6/bee.png");
 ImageIcon fundo = new ImageIcon("src/tutor6/fundo.png");
 
 public void atualizar() {

 }

 public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  //AQUI VAMOS MANDAR DESENHAR ALGUNS IMAGENS NA TELA
  bbg.drawImage(fundo.getImage(),0,0,this);//QUI DESENHAMOS O FUNDO
  //AS DIMENSÕES ORIGINAIS DO FUNDO SÃO: 500X500 QUE É O TAMANHO DA NOSSA TELA!
  
  //DESENHANDO A ABELHA NAS COORDENADAS X=200 e Y=200
  bbg.drawImage(abelha.getImage(),200,200,this); //aqui fica com as dimensões originais!
  //AQUI DEFINI A LARGURA E ALTURA DA IMAGEM
  bbg.drawImage(abelha.getImage(),100,100,40,40,this); //aqui não fica com as dimensões originais!
  
  //AQUI VAMOS ROTACIONAR A IMAGEM EM 45º
  //PARA ISSO VAMOS USAR OUTRA VARIAVEL DO TIPO Graphics2D
  //SE NÃO usarmos outra variável tudo que tá no buffer será rotacionado também!
  Graphics2D bbg2d = (Graphics2D) backBuffer.getGraphics();//AQIU É NOSSA OUTRA VÁRIAVEL!
  //para rotacionar primeiro define o eixo (isso desloca a imagem, então depois temos que desfazer)
  //vou por o exito no meio, então é só dividir a altura e largura da imagem por 2
  bbg2d.translate((abelha.getIconWidth()/2)+300, (abelha.getIconHeight()/2)+300); //tem que desfazer isso depois que a imagem será deslocada!
  bbg2d.rotate(45*(Math.PI/180)); //vamos calcular 45º
  bbg2d.translate(-((abelha.getIconWidth()/2)+300), -((abelha.getIconHeight()/2)+300));// agora desfaz o négocio do exito!!!
  //veja que eu passei os mesmos valores só que negativos, ovserve o sinal de "-" menos
  bbg2d.drawImage(abelha.getImage(),300,300,this); //desenha a imagem
  
  
  //================================================================================== 
  g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!
 }

 public void inicializar() {
  setTitle("Titulo do Jogo!");
  setSize(janelaW, janelaH);
  setResizable(false);
  setDefaultCloseOperation(EXIT_ON_CLOSE);
  setLayout(null);
  setVisible(true);
  backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);
 }

 public void run() {
  inicializar();
  while (true) {
   atualizar();
   desenharGraficos();
    try {
     Thread.sleep(1000/FPS);
    } catch (Exception e) {
     System.out.println("Thread interrompida!");
    }
  }
 }
 public static void main(String[] args) {
  Game game = new Game();
  game.run();
 }
}

Muito bem... tudo okay!!! agora vamos entender alguns pequenos detalhes...
muito bem... sabemos que PI = 3.14; que é = a 180°, como é que calculamos 1°?
dividimos PI/180  = 0,017444444, muito bem isso é igual a 1° e como é que calculamos 45º é só multiplicar (PI/180)*45 !!!

no método translate(x,y) definimos as coordenadas dos eixos onde a imagem girará em torno!
pra rotacionar a imagem em torno dela mesma, fizemos o seguinte:
vamos supor que a imagem esteja nas coordenadas x=0 e y=0 e suas dimensões são w=100 e h=100
sabemos que o centro da imagem é a coordenada x=50 e y=50, como é que calculamos isso ?
bem e só dividir w e h (width e Height = largura e altura) da imagem por 2!
e se posicionarmos a imagem na coordenada x=25 e y=50 o centro da imagem será =
(w/2)+25 e (h/2)+50, aaaaaaaaaaaaah! intendi, é por isso que somamos 300 no translate(x+300,y+300) no nosso exemplo acima! \(^_^)/ !!!
continuando..... quando mudamos o centro de rotação da imagem, a mesma é deslocada em função disso! por isso que ao definirmos o exito, depois mandar rotacionar, temos que voltar o que foi feito ao normal! então se eu deslocar (x+300) terei depois que deslocar -(x+300) okay ?!

O meu ficou assim:


Muito bem pessoal! até o próximo tutorial!

\_(^_^)_/ Comentários em baixo \_(^_^)_/

JAVA GAMES 2D::Textos::05


Olá pessoal!
Nesse tutorial vamos aprender como exibir textos em nossos jogos usando os métodos drawString() e setFont(), criem outro pacote chamado tutorial5 dentro do nosso projeto JAVAGAMES2D, copie o arquivo Game.java do pacote tutorial3 e cole dentro do pacote tutorial5, lembrando esse Gama.java é a estrutura básica do nosso game, deixamos no pacote tutorial3 como modelo para os futuros games que iremos desenvolver....

Muito bem.... agora adicione o seguinte código dentro do método desenharGraficos(), e vamos testar para ver como fica!


public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  //AQUI VAMOS MANDAR DESENHAR ALGUNS TEXTOS NA TELA
   bbg.setColor(new Color(100,200,100)); //muda a cor!
   bbg.setFont(new Font("Comic Sans MS",Font.BOLD,20));// definimos a fonte, o estilo negrito(bold) e o tamanho
   bbg.drawString("JAVA GAMES 2D", 100, 200); // aqui desenhamos o texto "JAVA GAMES 2D" nas coordenadas X=100 e Y=200
   //OUTROS TESTES...
   bbg.setColor(Color.RED);
   bbg.setFont(new Font("Comic Sans MS",Font.ITALIC,20));
   bbg.drawString("JAVA GAMES 2D", 150, 225);
   
   bbg.setColor(Color.YELLOW);
   bbg.setFont(new Font("Comic Sans MS",Font.PLAIN,20));
   bbg.drawString("JAVA GAMES 2D", 100, 250);
   
  //==================================================================================
  g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!
 }
Entendendo um pouco do que foi feito...
o método setFont() recebe como argumento(parâmetro) um objeto do tipo font, para criar um objeto do tipo font usamos o new Font("Nome da Font",Font.estilo,tamanho), em seguida mandamos desenhar a font com o drawString("texto",x,y)....
então quer dizer que é só isso (¬¬´) ? isso mesmo! bem simples não? \(^_^)/ !!!
O meu ficou assim:


Então é só isso pessoal! até o próximo tutorial!

\_(^_^)_/ Comentários em baixo \_(^_^)_/

sexta-feira, 8 de junho de 2012

JAVA GAMES 2D::Formas Geométricas::04


Olá pessoal!
Nesse tutorial vamos aprender como desenhar algumas formas geométricas usando a Classe Geom (java.awt.geom) bem... então ai segue alguns exemplos é super fácil de entender!

ah! crie um projeto dentro de sua workspace chamado JAVAGAMES2D dentro dela crie um pacote chamado tutorial3 e crie uma Classe chamada Game.java com o código do tutorial anterior!!! deixe isso guardado de exemplo, agora crie um pacote chamado tutorial4 e copie e cole a classe Game.java do pacote tutorial3 no pacote tutorial4, e nessa Classe acrescente o seguinte código dentro do método desenharGraficos()  :



public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  //AQUI VAMOS MANDAR DESENHAR COISAS NA TELA
   bbg.setColor(new Color(100,90,200)); //muda a cor!
   bbg.drawRect(50, 75, 100, 100);   //desenha um retângulo sem preenchimento
   
   bbg.setColor(new Color(200,0,200));  //muda a cor
   bbg.drawOval(50, 200, 100, 100);   //desenha uma elipse sem preenchimento
             //x=50 y=200 largura=100 altura=100
   bbg.drawLine(250, 250, 300, 300);  //desenha uma linha reta
             //xPont1 = 250 yPonto1 = 250 || xPonto2 = 300 yPonto2 = 300
   bbg.setColor(new Color(100,200,100)); //
   bbg.fillRect(50, 350, 100, 100);  //Desenhando um retângulo preenchido!
   bbg.setColor(new Color(255,255,0));  //
   bbg.fillOval(200, 350, 100, 100);  //Desenhando um Elipse preenchido!
  //==================================================================================
  g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!
 }

bem... existem várias formas geométricas que é possível desenhar! com a Classe geom!, recomendo que façam alguns testes, existem outras formas geométricas como roundRect (retângulo com pontas arredondadas),  drawPolygon() e etc...
como vcs viram também o método setColor() recebe um objeto do tipo Color como parâmetro, e ao criarmos esse objeto, ele possui um construtor que recebe três parâmetros do tipo inteiro new Color(1,2,4);  esses três parâmetros são respectivamente os valores dos tons RGB (red, green, blue), então você pode usar o paint ou qualquer ferramente de desenho para fazer cores, vale lembra que cada número inteiro que você passar como parâmetro pode variar de 0 até 255!


ah! execute a app para ver como ficou, Ctrl+F11(Eclipse) / Shift + F6 (netBeans)
no meu ficou assim:



bem... então é isso ai pessoal!!!, até o próximo tutorial!
\_(^_^)_/ Comentários em baixo \_(^_^)_/

quinta-feira, 7 de junho de 2012

JAVA GAMES 2D::Estrutura Básica do Game::03



Nesse III tutorial vamos aprender a criar a estrutura básica para os nossos jogos, definir o tamanho da janela(Frame), criar um Image Buffering e o gameLoop e etc...
Explicando algumas coisas:
Ao criarmos um código que por exemplo: movimente uma nave inimiga em um jogo como Space invader, para que a nave mova-se constantemente, o código que faz esse controle precisa ser executado constantemente, um outro exemplo: ao pressionar uma tecla para mover um personagem, os valores das variáveis que guardam sua posição X e Y seriam modificados, a imagem que aparece na tela precisa ser atualizada, para exibir o personagem em sua nova posição, então para que isso aconteça precisamo criar uma coisa chamamos de game loop, que seria nada mais do que um loop infinito!

while(true){
  //COMANDO!
}

Outro detalhe importante do game loop, precisamos controlar a frequência com que a tela será atualizada e os métodos de controle interno do jogo! para isso usaremos o seguinte código:

int FPS = 30; //TAXA DE ATUALIZAÇÃO DA TELA
while(true){
  Thread.sleep(1000/FPS);
}

O método sleep() receberá como parâmetro, um valor inteiro que será o tempo em milissegundos de uma PAUSA que ocorrerá! porem esse é um código perigoso que estamos mando nossa aplicação executar, teremos então que tratar as exceções que poderão ocorrer, ficando assim:


int FPS = 30; //TAXA DE ATUALIZAÇÃO DA TELA
while(true){
  try{
    Thread.sleep(1000/FPS);
  }catch(){
    System.out.println("Erro na Thread!"); 
    //MENSAGEM A SER EXIBIDA NO CONSOLE CASO OCORRA ALGUM ERRO
  }
}


Outro detalhe importante na construção de games é, ao mandarmos desenhar algum objeto na tela, como um texto, imagem, forma geométrica, etc, devido ao game loop ficar atualizando a tela o tempo inteiro, dará uma sensação de leg, porque será desenhado na tela elemento a elemento, então qual seria uma solução para esse probleminha?
O Image Buffering, iremos criar um BufferedImage (buffer de imagem)!!!, como é que isso funciona?
Bem é o seguinte... não iremos mais desenhar elementos na tela, ao invés disso iremos desenhar os elementos no buffer, e por fim desenhar o que está no buffer na tela de uma vez só!

então ai segue o corpo do nosso game totalmente comentado:


import java.awt.*;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
//A CLASSE GAME HERDA AS FUNCIONALIDADES DE JFRAME
public class Game extends JFrame {

 BufferedImage backBuffer; //ESSE É O NOSSO BUFFER
 int FPS = 30;    //ESSA É A TAXA DE ATUALIZAÇÃO DA TELA
 int janelaW = 500;   //LARGURA DA TELA
 int janelaH = 500;   //ALTURA DA TELA

 //NO NOSSO METODO ATUALIZAR VAMOS CHAMAR OS METODOS
 //QUE SERÃO EXECUTADOS O TEMPO INTEIRO...
 public void atualizar() {

 }

 //NESSE MÉTODO VAMOS DESENHAR
 //FORMAS GEOMETRICAS, IMAGENS E TEXTOS NA TELA E ETC...
 public void desenharGraficos() {
  Graphics g = getGraphics();//COM g IREMOS DESENHAR O QUE ESTÁ NO BUFFER NA TELA
  Graphics bbg = backBuffer.getGraphics();//COM bbg IREMOS DESENHAR NO NOSSO BUFFER
  
  //AQUI ESTAMOS DESENHANDO O BUFFER NA TELA,
  //NAS COORDENADAS X:0 e Y:0
  g.drawImage(backBuffer, 0, 0, this);
 }
 //ESSE É O NOSSO MÉTODO INICIALIZAR
 //AQUI VAMOS INICIALIZAR ALGUMAS CONFIGURAÇÃO DO frame E OUTRAS CONFIGURAÇÕES
 public void inicializar() {
  setTitle("Titulo do Jogo!");//SETANDO O TITULO DA JANELA
  setSize(janelaW, janelaH);//DEFINIDO AS DIMENSÕES DA JANELA
  setResizable(false);//TIRANDO A PERMISSÃO DO USUÁRIO REDIMENSIONAR A JANELA
  setDefaultCloseOperation(EXIT_ON_CLOSE);//QUANDO FECHARMOS O frame A APLICAÇÃO PARA DE EXECUTAR
  setLayout(null);//COM ISSO PODEREMOS DEFINIAR COORDENADA E DIMESÕES DE ELMENTOS DE FORMULARIO NO NOSSO FRAME
  setVisible(true);//MUDANDO A VISIBILIDADE DO frame PARA TRUE, ASSIM ELE APARECERÁ
  backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);//CRIANDO O NOSSO BUFFER DE IMAGEM
 }
 //AQUI É O NOSSO MÉTODO RUN()
 //NELE TEMOS O NOSSO GAME LOOP (UM LOOP INFINITO)
 public void run() {
  inicializar();//AQUI CHAMAMOS O METODO INICIALIZAR SOMENTE UMA VEZ, POIS ELE ESTÁ FORA DO NOSSO LOOP
  while (true) {//AQUI É O NOSSO LOOP INFINITO
   atualizar();//CHAMAMOS O METODO ATUALIZAR O TEMPO INTEIRO
   desenharGraficos();//ATUALIZAREMOS O GRÁFICO QUE APARECE NA TELA O TEMPO INTEIRO
    try {
     Thread.sleep(1000/FPS); //TAXA DE ATUALIZAÇÃO NA TELA, FUNCIONA COMO UM DELAY
    } catch (Exception e) {
     System.out.println("Thread interrompida!");
    }
  }
 }
 //AQUI É O NOSSO MÉTODO PRINCIPAL
 public static void main(String[] args) {
  Game game = new Game();//CRIAMOS UM OBJETO A PARTIR DESSA PROPRIA CLASSE
  game.run();//CHAMAMOS O METODO RUN(), O MÉTODO RUN() EXECUTA O INICIALIZAR(), ATUALIZAR() E DESENHARGRAFICOS()
 }
 //-----------------------------------------------------------------------------
}// FIM DO CÓDIGO FONTE

Outro pequeno detalhe importante...
Como vamos desenvolver Games 2D, estaremos trabalhando dentro de um plano cartesiano... pra quem não sabe o plano cartesiano foi criado por René Descartes e consiste em em dois eixos perpendiculares um X e outro Y....

porem ....... aqui vai funcionar de uma maneira um pouquinho diferente....


É assim que vamos nos locomover dentro desse plano bidimensional !!!
Então é isso pessoal! continuem no próximo Tutor...

\_(^_^)_/ Comentários em baixo \_(^_^)_/

JAVA GAMES 2D::JFrame, Applet, Middlet::02

Olá pessoal!
Irei falar muito rapidamente sobre JFrame, Applet e Middlet!
Basicamente você vai querer portar o jogo que você desenvolveu para uma dessas plataformas: Desktop, WEB ou Dispositivos portáteis!
Bem... então se você quiser desenvolver o jogo para Desktop, poderá usar a classe JFrame da API do JAVA!
Caso seja para WEB, poderá usar a classe Applet da API do JAVA!
E caso seja para dispositivos portáteis, poderá usar a classe Middlet da API do JAVA!
Basicamente (mais bem basicamente mesmo!) é isso..... caso queira mais detalhes, recomendo ler a documentação dessas bibliotecas!

Links da documentação:


O método que utilizaremos para desenvolver os jogos será igual, caso você queira desenvolver os jogos para uma dessas plataformas! No decorrer desses tutoriais vamos utilizar a Classe JFrame!

(Eu disse que seria rapidamente!)



\_(^_^)_/ Comentários em baixo \_(^_^)_/

JAVA GAMES 2D::Introdução::01


Olá pessoal!
Bem essa é uma série de tutorias que pretendo postar aqui sobre desenvolvimento de jogos 2D com JAVA, esse foi o tema de um dos mini-cursos que ministrei no V EDIFPI (Encontro de Informática Piauiense). Ao longo desta série de tutoriais pretendo mostrar como desenvolver 3 Jogos (Snake, Space Invader, plataforma) jogos 2D utilizando java da maneira mais simples e descomplicada possível.

(postarei o link para download de alguns dos exemplos)


Sumário:

  • JFrame, Applet, Middlet
  • Estrutura básica do game (Janela, ImageBuffering, gameLoop)
  • Formas geométricas
  • Textos
  • Imagens
  • Sons MIDI
  • Animando Sprites
  • Movimentando objetos
  • Colisão (Simples)
  • Colisão (Não tão simples!)
  • Eventos do Teclado
  • Eventos do Mouse
  • Menu
  • Gerando *.JAR Runnable "executável"
  • Jogo Snake passo a passo e comentário para cada linha.
  • Jogo Space Invader passo a passo e comentário para cada linha.
  • Jogo Plataforma(ainda não decidi qual, algum parecido com Super Mário)  passo a passo e comentado linha a linha.
Bem... pessoal... essa será a nossa programação nessa série de Tutoriais, vamos conhecer algumas técnicas interessantes de como desenvolver jogos 2D utilizando Java!

Pré-requisitos:
  • uma JRE e JDK instalada (<<Donwload>>)
  • IDE (estarei utilizando Eclipse <<Download>>, sinta-se livre para usar a de sua preferência)
  • Saber o básico de algoritmo e lógica de programação, básico de java (se souber Orientação a Objetos esses tutoriais ficarão ridiculamente simples)
  • Vontade de aprender!
Caso você queira iniciar em JAVA ai segue o link de ótimas vídeo aulas disponibilizadas pelo instituto XTI no youtube: http://www.youtube.com/user/ricardolopescosta/videos?query=JAVA
um total de 116 vídeo aulas!

 \_(^_^)_/ Comentários em baixo \_(^_^)_/