Ruby Básico :: Tutorial :: Parte 1

Olá galera, tudo bem?

Acho que todo mundo já ouviu falar sobre linguagens de programação, como Java, C, C++, Pascal, Basic, entre outras, não é mesmo? Se por acaso nunca ouviu falar não tem problema. O importante é que está aqui para aprender a programar e ouviu falar em Ruby, ou então não (rsrs)... mas quer mesmo é aprender e começar nesse mundo dos algoritmos.

Se essa hipótese está correta, então está no lugar certo, e, emitindo uma opinião bem pessoal, escolheu a linguagem correta para estudar: Ruby !!! 

Ruby: o melhor amigo do programador

Caso vocês não saibam, Ruby é uma linguagem muito popular. Alguns a definem como uma linguagem repleta de arte e beleza, tal como elegância. Talvez prática e conveniente, produtiva e fácil de entender. 

Podemos concordar e dizer que sim. No entanto ninguém melhor do que o próprio criador da linguagem para definí-la, Yukihiro “matz” Matsumoto.

Eis então uma definição da linguagem Ruby dita pelo Matsumoto: 

"O Ruby é simples na aparência, mas muito complexo no interior, tal como o corpo humano"

Matsumoto uniu coisas das linguagens que ele mais gostava (Smalltalk, Perl, Eiffel, Ada, e Lisp) e as misturou para criar a linguagem Ruby, equilibrando programação funcional com programação imperativa.

Bom, com essa pequena descrição, quero chamar a atenção de vocês, caros leitores, para o que nós podemos interpretar de uma "linguagem de programação".

Segundo o wikipedia:

"Uma linguagem de programação é um método padronizado para comunicar instruções para um computador. É um conjunto de regras sintáticas e semânticas usadas para definir um programa de computador"

Tomando esta afirmação, então podemos resumir "linguagem de programação" como sendo linguagem do computador, linguagem que deve ser entendida pelo computador para que ele então possa executar as ações que são inseridas através da linguagem. A linguagem é então, primordialmente, projetada para acomodar as necessidades do computador. Nós, programadores que somos, estamos em condição de estrangeiros para o mundo do computador e sua(s) linguagem(s). Somos estrangeiros em busca de parceria "no mundo do computador" e tradutores dessa tal "linguagem de programação" para nosso mundo humano.

Pensemos então, como nosso cérebro age quando nós pensamos em linguagem? Linguagem são as palavras do idioma que usamos para nos expressar no mundo. O computador que conhecemos não pode fazer isso. Então a questão é: como pode o computador ter uma linguagem? A linguagem deve ser nossa, pois se nós a falamos nativamente, por que deveria ser diferente?

Podemos por fim quebrar no meio, triturar, jogar fora essa afirmação de que linguagem de programação é uma linguagem de computador e passar a chamá-la de linguagem do programador, uma linguagem de nossos pensamentos.

Por isso, a linguagem Ruby foi concebida para ser bem mais do que isso. Ruby é mais do que uma linguagem de computador, é uma linguagem feita para o programador.

Leia isso para si mesmo em voz alta:

Obs: traduza mentalmente na hora da leitura as palavras em inglês para o português.

  5.times { print "Olá pessoal!" }

 Nas sentenças em inglês, a pontuação, assim como exclamações, parenteses e períodos, são ignorados na hora da leitura. A pontuação dá sentido às palavras, dando pistas sobre o que o autor pretendia na sentença. A leitura então fica assim: Cinco vezes escreva "Olá pessoal!".


Leia isso para si mesmo em voz alta:

      exit unless "abcde".include? "bcd"

Esta sentença é uma checagem bem simples. Aqui o nosso programa sairá ao menos que a palavra "abcde" contenha, ou tenha incluso, a palavra "bcd". A leitura então fica assim: Saia ao menos que a palavra "abcde" inclua a palavra " bcd".


Muito simples não? Esses exemplos são código Ruby e por eles podemos ver como Matsumoto teve a preocupação de tornar a linguagem Ruby uma linguagem simples e fácil de ser lida, de forma tão natural como nossa própria linguagem do dia a dia.

Viram como Ruby preocupa-se com a verbosidade de suas sentenças? Repararam também de como a linguagem utiliza-se de símbolos naturais para tornar a leitura de código mais natural, mais rápida para nosso cérebro processar e entender, mais perto do que estamos acostumados a ler, mais natural, como disse Matsumoto.

No exemplo acima Ruby fez uso do símbolo de marcação de questão: ? . Agora faço a pergunta: você já viu alguma linguagem utilizar marcação de questão tão efetivamente ?

Vamos a mais um exemplo: 

Leia isso para si mesmo em voz alta:

           ['torta', 'queijo', 'vinho'].each { |comida| print comida.capitalize }

Apesar desse código agora ser menos legível e mais parecer com uma sentença, continuem lendo ou então releiam em voz alta.

Quero que reparem que em Ruby muitas vezes lê-se como leríamos naturalmente em inglês uma frase, entretanto, o Ruby também faz uso de uma leitura mais abreviada do inglês. Portanto, traduzindo do inglês esta sentença, a leitura fica assim: Com cada palavra 'torta', 'queijo', e 'vinho': pegue cada comida e escreva-a capitalizada.

Com isso acho que deu para vocês perceberem de como é interessante e extremamente elegante escrever código em Ruby. 

Agora sejam Bem Vindos ao nosso mundo Rubysta e vamos aos estudos!!!

Até a próxima parte deste tutorial pessoal. 

Vejo vocês lá!

JAVA GAMES 2D::Sons MIDI::07

DOWNLOAD DOS EXEMPLOS AQUI

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

DOWNLOAD DOS EXEMPLOS AQUI

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

DOWNLOAD DOS EXEMPLOS AQUI

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 \_(^_^)_/

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

DOWNLOAD DOS EXEMPLOS AQUI

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 \_(^_^)_/

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

DOWNLOAD DOS EXEMPLOS AQUI

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:

• JFrame
• Applet
• Middlet

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 \_(^_^)_/