Pages

Banner

Easy management

Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right at the coast of the Semantics, a large language ocean.

Read more
image01

Revolution

A small river named Duden flows by their place and supplies it with the necessary regelialia. It is a paradisematic country, in which roasted parts of sentences fly into your mouth.

Read more
image01

Warm welcome

When she reached the first hills of the Italic Mountains, she had a last view back on the skyline of her hometown Bookmarksgrove, the headline of Alphabet Village and the subline of her own road, the Line Lane.

Read more
image01

Quality Control

Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life One day however a small line of blind text by the name of Lorem Ipsum decided to leave for the far World of Grammar.

Read more
image01

quarta-feira, 27 de junho de 2012

JAVA GAMES 2D::Exportando para *.jar::15

Olá pessoal!
Nesse tutorial mostrarei como exportar o nosso game para o formato *.jar Runnable ("Executável"), uma coisa que iremos querer fazer após terminarmos de desenvolver um game é gerar o executável para distribuir para os nossos usuários/clientes!

Muito bem vamos lá!
Estarei aqui usando a IDE Eclipse para exportar o nosso game para *.jar <<download do Eclipse>>
o ideal quando estivermos desenvolvendo um game, é ter um projeto na workspace somente para o jogo que estamos desenvolvendo, quando estudamos o básico de java, aprendemos que o método main() é o método principal, nossa aplicação começará a ser executada a partir do método main(), normalmente em um projeto temos várias classes, ao exportarmos o game, temos que informar em que classe está o método main(), observe a figura abaixo (vamos exportar o game Snake)

Esse é um print de uma workspace minha, observe o projeto snake, dentro dele temos um pacote chamado game, e dentro do pacote game temos a classe Game.java que contem o método main(), então para começar a exportação faremos assim:

1- pressione o botão direto sobre o projeto snake e em seguida clique sobre "Export..." ou "Exportar...".
2- na janela que aparecerá clique em java e em seguida clique sobre Runnable JAR file, agora clique em Next ou Próximo.


3- agora em Launch configuration escolha o item que é [Nome da classe com método main]-[Nome do projeto] nome caso aqui é Game - Snake, em Library Handling (Biblioteca de manipulação), escolha Package required libraries into generated JAR (pacote exigido em bibliotecas JAR gerado.)
Agora em Export destination, escolha a pasta destino para onde você deseja exportar o "executável" do seu game e dê um nome ao arquivo, (eu estou salvando em minha área de trabalho com o nome Snake.jar).

4- para finarlizar clique em finish.


Muito simples não é? está ai o "executável" do nosso game, para que usa Ruindows Windows basta clicar duas vezes sobre o arquivo para executar o game, para quem usa alguma distro do Linux pode ser feito de uma das seguintes formas: clicar com o botão direito sobre o arquivo e escolher "Abrir com Java(TM) Platform SE Binary" ou abrir o terminal entrar no diretório onde o arquivo está salvo e exucutar a seguinte linha de comando: sudo java -jar nome_do_arquivo.jar.

Observe como ficou o meu:



Obrigado por visitar o blog!
Não deixem de comentar ou postar duvidas aqui! Até o nosso próximo tutorial!
Os tutoriais seguintes serão uma série de jogos que iremos construir do começo ao fim, comentado linha por linha!

segunda-feira, 25 de junho de 2012

JAVA GAMES 2D::Menu::14


Olá pessoal!
Nesse tutorial iremos mostrar uma maneira de como construir um menu para os nossos games, além da classe Game.java que iremos criar no nosso pacote tutorial14 dentro do projeto JAVAGAMES2D iremos também criar um uma classe chamada Menu.java.  então é o seguinte, na classe Menu.java, iremos definir como os nossos menus irá se comportar, e iramos criar um menu dentro Game.java.


No exemplo de hoje teremos três cenários, e um menu que nos levará para cada cenário(Jogar, Opções e Ajuda) e um item no menu para sair do game!

Observe com atenção a nossa classe Menu.java (Leia os comentários com atenção!)


import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;

public class Menu {
 int cenario = -1;   //ESSA VARIAVEL INDICA EM QUE CENÁRIO ESTAMOS, -1(NENHUM CENÁRIO) (0,1,2,3...N) OUTROS CENÁRIOS
 int itemSelecionado = 0; //ESSA VARIAVEL SERVIRÁ PARA INDICAR QUAL ITEM QUE ESTÁ SELECIONADO (o atual é zero que é o primeiro item do menu)
 String itens[];    //aqui vamos guardar os itens do nosso menu (jogar, opções, sair...etc)
 Graphics bbg;    //como nos outros métodos da classe game.java usamos essa varialvel para desenhar elementos na tela
 boolean ativo;    //indica se o menu está ativo ou não (ao inicar o jogo desativamos o menu, para o controlemos durante o jogo)
 int x;      //coordenada x do menu
 int y;      //coordenada y do menu
 int tamanhoDaFonte = 20; //nem precisa explicar não é ?
 int distanciaEntreItens = 15;//distância entre cada item do menu!
 Font fonte = new Font("Arial", Font.BOLD, tamanhoDaFonte);//a fonte do nosso menu
 Color corSelecionado = new Color(255, 0, 0); // COR VERMELHA para o item selecionado
 Color corNaoSelecionado = new Color(0, 0, 0); // COR PRETA para o item que não está selecionado
 //isso é o construtor ao criarmos o objeto do tipo Menu, teremos que informar o número de itens as coordenadas e se ele estará ativo ou não!
 public Menu(int numeroDeItens, int x, int y, boolean ativo) {
  itens = new String[numeroDeItens];
  this.x = x;
  this.y = y;
  this.ativo = ativo;
 }
 //esse metodo só chamará o método controlaMenu se ele estiver ativo!
 public void controlar(KeyEvent e) {
  if (ativo) {
   controlarMenu(e);
  }
 }
 //esse método nos fará retornar ao menu ao pressinarmos "Esc"
 public void voltarAoMenu(KeyEvent e){
  //se tecla pressionada for igual a "Esc"
  if(e.getKeyCode() == e.VK_ESCAPE){
   cenario = -1;  //com isso sai dos cenários em que estivermos...
   ativo = true;  //e reativa o menu para que o possamos controlar novamente...
  }
 }
 //esse método controlará o nosso menu através do teclado
 //ele é chamando dentro do método controla()
 private void controlarMenu(KeyEvent e) {
  //se pressionar a tecla "cima" diminui 1 em itemSelecionado
  if (e.getKeyCode() == e.VK_UP) {
   itemSelecionado -= 1;
  }
  //se pressionar a tecla "baixo" aumenta 1 em itemSelecionado
  if (e.getKeyCode() == e.VK_DOWN) {
   itemSelecionado += 1;
  }
  //isso aqui é para controlar os limites extrmos do menu
  //caso eu esteja com 1º item selecionado e pressione para cima, ele vai para a ultima opção
  //caso eu esteja com o ultimo item selecionado e pressione para baixo, ele vai para primeira opção
  if (itemSelecionado >= itens.length) {
   itemSelecionado = 0;
  }
  if (itemSelecionado < 0) {
   itemSelecionado = itens.length - 1;
  }
  //se pressionar a tecla Enter ele muda o valor de cenario para o item que está selecionado
  //isso fará mudar de cenário e desativará o menu para que ele não seja mais controlado!
  if(e.getKeyCode() == e.VK_ENTER){
   cenario = itemSelecionado;
   ativo = false;
  }
 }
 //esse método irá desenhar o nosso menu na tela!
 //a um loop (for) que irá listar todos os itens que está guardado em itens[]
 //um calculo é feito para a coordenada y de cada intem do nosso menu, para que eles fiquem
 //um distante do outro, então caso y = 10, o item 0 será: 10+(0*(20+15)) = 10
 //para o item 1 será: 10+(1*(20+15)) = 45
 //para o item 2 será: 10+(2*(20+15)) = 80
 //para o item 3 será: 10+(3*(20+15)) = 115, e assim por diante...
 public void desenharMenu() {
  bbg.setFont(fonte);//seta a fonte que definimos bem acima na declaração de variáveis
  for (int i = 0; i < itens.length; i++) {// aqui é o inicio do nosso loop
   if(itemSelecionado == i){//se ele estiver selecionado muda a cor para vermelho e desenha o item na tela
    bbg.setColor(corSelecionado);
    bbg.drawString(itens[i], x, y+(i*(tamanhoDaFonte+distanciaEntreItens)));
   }else{//se não estiver selecionado muda a cor para preto e desenha o item na tela
    bbg.setColor(corNaoSelecionado);
    bbg.drawString(itens[i], x, y+(i*(tamanhoDaFonte+distanciaEntreItens)));
   }
  }
 }

}

Agora veja como criaremos o nosso menu dentro de Game.java, (leita os comentários com atenção!)


import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.File;

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

public class Game extends JFrame implements KeyListener{

 BufferedImage backBuffer; 
 int FPS = 30;
 int janelaW = 500;
 int janelaH = 500;
 //AQUI DECLARAMOS O NOSSO MENU COM:
 //4 itens, coordenadas x e y = 100, a ativo = true
 //agora olhe esse método abaixo cenarios()
 Menu menuPrincipal = new Menu(4, 100, 100, true);
 
 //esse método vai desenhar na tela alguns possíveis cenários do nosso game
 //lá em Menu.java cenario foi definido como -1
 //se cenario == 0 muda a cor do fundo e mostra um texto
 //se cenario == 1 muda a cor do fundo e mostra um texto
 //se cenario == n muda a cor do fundo e mostra um texto...
 
 //agora obser o nosso método desenharGraficos()
 public void cenarios(){
  Graphics bbg = backBuffer.getGraphics();
  bbg.setFont(new Font("Arial",Font.BOLD,20));
  if(menuPrincipal.cenario == 0){
   bbg.setColor(new Color(255,100,100));
   bbg.fillRect(0, 0, janelaW, janelaH);
   bbg.setColor(Color.BLACK);
   bbg.drawString("Você escolheu Jogar", 100, 200);
   //aqui você pode escolher o que irá aparecer caso o usuario escolha essa item do menu!
  }
  if(menuPrincipal.cenario == 1){
   bbg.setColor(new Color(100,255,100));
   bbg.fillRect(0, 0, janelaW, janelaH);
   bbg.setColor(Color.BLACK);
   bbg.drawString("Você escolheu Opções", 100, 200);
  }
  if(menuPrincipal.cenario == 2){
   bbg.setColor(new Color(100,100,255));
   bbg.fillRect(0, 0, janelaW, janelaH);
   bbg.setColor(Color.BLACK);
   bbg.drawString("Você escolheu Ajuda", 100, 200);
  }
  if(menuPrincipal.cenario == 3){
   System.exit(0);//esse comando fecha o nosso game!
  }
 }
 
 public void atualizar() {

 }

 public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  bbg.setColor(Color.WHITE);
  bbg.fillRect(0, 0, janelaW, janelaH); //PINTA O FUNDO COM UM QUADRADO BRANCO
  
  menuPrincipal.desenharMenu();//isso desenhará nosso menu
  cenarios();//isso irá desenhar os cenários que escolhermos no menu
  //agora observe o método inicializar()
  
  //================================================================================== 
  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 ESTAMOS ADICIONANDO UM ESCUTADOR DE TECLAS
  addKeyListener(this);
  
  //aqui definimos o texto de cada item do nosso menu
  menuPrincipal.itens[0] = "Jogar";
  menuPrincipal.itens[1] = "Opções";
  menuPrincipal.itens[2] = "Ajuda";
  menuPrincipal.itens[3] = "Sair";
  //aqui fazemos o método desenhaMenu() que fica lá em Menu.java
  //desenhar no nosso buffer
  //.. agora para finalizar observe o método de evento keyPressed() mais abaixo...
  menuPrincipal.bbg = backBuffer.getGraphics();
 }

 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();
 }

 public void keyPressed(KeyEvent e) {
  //aqui, chamamos os métodos que irá controlar o menu pelo teclado
  menuPrincipal.controlar(e);//esse controla o menu
  menuPrincipal.voltarAoMenu(e);//esse faz voltar para o menu quando pressionarmos "Esc"
 }
 
 public void keyReleased(KeyEvent e) {
  
 }
 public void keyTyped(KeyEvent e) {
  
 }
}

Super simples! não é?
Observem como ficou o meu:



Até o nosso próximo tutorial!
Abraços e não deixem de comentar...

quarta-feira, 20 de junho de 2012

Ruby Básico :: Ruby Interativo :: Parte 3

 Olá pessoal!!!

Vamos agora começar a embarcar no Ruby e dar nossos primeiros passos rumo ao infinito do mundo da programação.

Mas, contudo, entretanto, porém, antes disso vamos fazer um pequeno passeio rápido sobre o que está por vir nesta série Ruby Básico.

Nós iremos estudar sobre:
  • Variáveis e tipos
  • Constantes
  • Módulos
  • Operadores condicionais
  • Loops
  • Blocos e Procs
  • Orientação a objeto
  • Objetos
  • Classes
  • Métodos
  • Sobrecarga de métodos
  • Arquivos
  • Visão geral do Ruby no mercado atual
  • ... e o que vier em pauta.

Beleza, agora vamos ao que interessa!!!

Ruby Interativo - IRB 


A linguagem Ruby, ao instalarmos no nosso ambiente, ela nos oferece um console interativo na qual podemos digitar comandos e já obtermos as saídas na tela. É um ótimo lugar para se começar a aprender Ruby e a testar várias coisas legais lá. Então vamos seguir.

Agora abra o terminal do sistema operacional, e então digite irb e tecle Enter.

 
Bom, como podemos ver já estamos dentro do irb (Interactive Ruby) e agora já podemos começar a brincar (rs).

Vamos começar por testarmos algumas operações matemáticas:



Como podem ver fizemos algumas operações matemáticas básicas no irb, como adição, multiplicação e divisão, e logo abaixo de cada setença o console já nos mostra o resultado de cada operação.

Passemos para algo mais interessante:


Agora podemos ver nessas expressões matemáticas um pouco sobre a precedência. Na linha 005 do irb temos a expressão (6+0)*3 cujo resultado é 18. No Ruby temos as operçaões de multiplicação e divisão com maior precedência do que as de soma e de subtração. Também as operações são testadas no sentido da esquerda para a direita. Aqui nessa linha a precedência é mudada devido aos parênteses, forçando que a primeira expressão a ser resolvida seja a que estiver dentro dos parênteses e mais à esquerda.

Reparem nas duas linhas seguintes: 8/2*5 resultou na resolução primeiro da divisão 8 por 2, na qual obteve-se o resultado 4 e só depois multiplicou-se esse resultado por 5, resultando em 20.

Na linha 007 os valores envolvidos e as operações são as mesmas, só que dessa vez com a posição mudada. A diferença do resultado se dá por causa do valor de precedência: a multiplicação e a divisão têm o mesmo valor de precedência, então resolve-se o que estiver mais a esquerda. Também podemos perceber que o resultado da multiplicação entre 2 e 5 foi 10, e sua posterior divisão por 8 resulta no valor final da expressão em 1. O por quê disso se dá pelo fato de que 10/8 no Ruby resultará em um valor inteiro. Como nessa divisão estão participando dois números inteiros, então o resultado será um inteiro.

Atente nisso: 


Viu?

Dessa vez na divisão estão envolvidos dois números decimais e o resultado é devolvido, naturalmente, na forma de um decimal. Esse valor com certeza é um valor muito mais aproximado do que o resultado anterior entre 10 e 8 que resultou em 1.

Essa é só uma forma mais inteligente do Ruby para usar o operador de divisão.

Toda divisão que envolva algum número decimal, o resultado dessa divisão será um número decimal.


Por fim, antes de terminarmos essa brincadeira com operações matemáticas, vamos ver as operações de exponenciação e o operador módulo, que devolve o resto de uma divisão.


O operador de exponenciação é o ** . Como podemos ver na linha 014 temos 2 elevado a potência de 10, cujo resultado é 1024. Mais embaixo temos o uso do operador módulo que retorna o primeiro resto da divisão entre 10 e 8.

Bom pessoal, por aqui vou encerrar essa introdução ao irb trabalhando somente com operações matemáticas. Nos próximos tutoriais estaremos em contato com mais princípios da linguagem só que dessa vez através de scripts escritos em ruby e executados no terminal.

Até mais, vejo vocês lá !!!

JAVA GAMES 2D::Aviso::

Olá pessoal!
Devido a alguns imprevistos, os próximos tutoriais dessa série serão lançados a partir do dia 25 deste mesmo mês!


Agradeço a todos por visitarem o blog!



domingo, 17 de junho de 2012

JAVA GAMES 2D::Eventos do Mouse::13


Olá pessoal!
Nesse tutorial iremos aprender uma das maneiras de como usar os Eventos  do Mouse, é muito semelhante ao tutorial anterior de Eventos do Teclado, para o nosso tutorial de hoje utilizaremos duas Interfaces: MouseListener e MouseMotionListener
(Criem um pacote tutorial13 no nosso projeto JAVAGAMES2D com o arquivo Game.java)

Muito bem....Vamos lá!
A primeira coisa a ser feita é implementar as interfaces na nossa Classe Game.java


public class Game extends JFrame implements MouseListener, MouseMotionListener{

Lembrem de adicionar a implementação dos métodos dessas interfaces, observem que podemos implementar quantas interfaces quisermos, bastando apenas separar por virgula, então é possível usar eventos de teclado e mouse num mesmo jogo...
Agora veja os método que serão implementados no final da Classe Game.java:


@Override
 public void mouseClicked(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mouseEntered(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mouseExited(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mousePressed(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mouseReleased(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mouseDragged(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void mouseMoved(MouseEvent e) {
  // TODO Auto-generated method stub
  
 }

Recomendo apagar esses comentários gerados (caso você tenha mandado gerar automaticamente), Muito bem... vamos lá....
Os métodos mouseMoved() e mouseDragged() são da interface MouseMotionsListener, e os outros métodos são de MouseListener,  bem... vejamos para quê serve cada um desses eventos:

mouseMoved(): é acionado todo vez que você mover o mouse.
mouseDragged(): é acionado toda vez que você clica segura e arrasta.

mouseReleased(): é acionado quando você libera o clique.
mousePressed(): é acionado no momento em quê o clique é pressionado e mantamos pressionado.
mouseExited(): é acionado quando o cursor é retirado de cima de um elemento.
mouseEntered(): é acionado quando o cursor ficar sobre um elemento.
mouseClicked(): é acionando quando clicamos com o mouse.

Agora a próxima etapa é adicionar um escutador para esses eventos no nosso JFrame dentro do método inicializar(),  se não adicionarmos esses escutadores nenhum desses métodos serão executados quando os eventos forem acionados (lembrando, o escutador é que manda executar esses métodos quando o evento for acionado).
Observe o código abaixo:


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 ESTAMOS ADICIONANDO OS ESCUTADORES DE EVENTOS DO MOUSE
  addMouseListener(this);
  addMouseMotionListener(this);
 }

Muito simples! não é?
Agora vamos ver um exemplo de uso de eventos do mouse, no nosso exemplo iremos mover uma mira,  exibir as coordenadas do cursor no JFrame e quando clicarmos exibir uma mensagem!
(LEIAM OS COMENTÁRIOS DO CÓDIGO COM ATENÇÃO)


import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.File;

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

public class Game extends JFrame implements MouseListener, MouseMotionListener{

 BufferedImage backBuffer; 
 int FPS = 30;
 int janelaW = 500;
 int janelaH = 500;
 
 //VARIAVEIS QUE VAMOS UTILIZAR
 //UMA IMAGEM PARA REPRESENTAR A MIRA
 //E AS SUAS COORDENADAS X e Y
 //NÃO SE ESQUEÇA DE OLHAR O MÉTODO desenharGraficos()
 //e os métodos de eventos que é onde iremos tratar algumas coisas
 ImageIcon mira = new ImageIcon("src/tutor13/mira.png");
 int xMira;
 int yMira;
 
 public void atualizar() {

 }

 public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  bbg.setColor(Color.WHITE);
  bbg.fillRect(0, 0, janelaW, janelaH); //PINTA O FUNDO COM UM QUADRADO BRANCO
  
  bbg.setColor(Color.RED);
  bbg.setFont(new Font("helvica",Font.BOLD,20));
  bbg.drawString("X=: "+xMira+"  Y="+yMira, 50, 100); //EXIBE UM TEXTO + O VALOR DA TECLA PRESSIONADA
  //QUE ESTÁ NA VARIÁVEL teclaPressionada
  
  //AQUI DESENHAMOS A MIRA, O -25 É PARA FICAR CENTRALIZADA COM O CURSOR
  bbg.drawImage(mira.getImage(), xMira-25, yMira-25, this);
  
  //================================================================================== 
  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 ESTAMOS ADICIONANDO OS ESCUTADORES DE EVENTOS DO MOUSE
  addMouseListener(this);
  addMouseMotionListener(this);
 }

 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();
 }
 public void mouseClicked(MouseEvent e) {
  JOptionPane.showMessageDialog(null, "Você clicou!!!!");
 }
 public void mouseEntered(MouseEvent e) {

 }
 public void mouseExited(MouseEvent e) {
 
 }
 public void mousePressed(MouseEvent e) {
 
 }
 public void mouseReleased(MouseEvent e) {
 
 }
 public void mouseDragged(MouseEvent e) {
  
 }
 public void mouseMoved(MouseEvent e) {
  //AQUI X e Y DA MIRA RECEBE AS COORDENADAS DO CURSOR
  xMira = e.getX();
  yMira = e.getY();
 }
}

Veja como ficou:



Muito simples não é ?
Até o próximo tutorial!!! não deixem de comentar ou tirar duvidas! (assim que dé, respondo!!!)

sábado, 16 de junho de 2012

JAVA GAMES 2D::Eventos do Teclado::12


Olá pessoal!
Nesse tutorial vamos mostrar uma maneira de como usar eventos do teclado para controlar algumas ações nos nossos jogos. é realmente muito simples fazer isso! tudo que iremos fazer é implementar uma Interface na nossa classe, reescrever os métodos abstratos dessa interface, e adicionar um escutador de teclas no nosso JFrame!
(Criem um pacote tutorial12 no nosso projeto JAVAGAMES2D com o arquivo Game.java)

Vamos lá!
1º passo implemente na Classe Game.java a seguinte Interface: KeyListiner

public class Game extends JFrame implements KeyListener{

Quando fizer isso salve as alterações, como eu uso o Eclipse ele vai acusar um erro, informando que eu preciso adicionar a implementação dos métodos da interface Keylistner, observe a figura abaixo:

agora vamos usar um truque do Eclipse, observe o x vermelho antes de public class, dê um clique sobre esse ícone, que irá aparecer o seguinte:

Agora basta dar um duplo clique  em Add unimplmented methods, para que o Eclipse adicione automaticamente essas linhas de código no final da classe Game.java


@Override
 public void keyPressed(KeyEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void keyReleased(KeyEvent e) {
  // TODO Auto-generated method stub
  
 }

 @Override
 public void keyTyped(KeyEvent e) {
  // TODO Auto-generated method stub
  
 }

... O que temos ai é o seguinte: três métodos sem retorno (void), que recebe um parâmetro do tipo KeyEvent, (caso queiram apaguem esses comentários gerado pelo Eclipse)
//TODO Auto-generated method stub
@Override


Agora para finalizar vamos adicionar no nosso método inicializar() o escutador de teclas que é que vai acionar esses três métodos que foram criados toda vez que um evento de teclado for acionado!


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 ESTAMOS ADICIONANDO UM ESCUTADOR DE TECLAS
  addKeyListener(this);
 }

Falando brevemente sobre os três métodos criados:
O keyPressed é acionado no momento em que você pressiona a tecla e enquanto ela estiver pressionada
O keyReleased é acionado no momento em que você libera a tecla pressionada
O keyTyped é acionado toda vez que o usuário digitar um caractere em algum elemento que está com o foco!

Muito bem.... agora vamos ver um um bom exemplo, vamos exibir a tecla que o usuário pressionou e mover uma bola com as teclas direcionais....
(Leia os comentários com atenção!)


import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.File;

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

public class Game extends JFrame implements KeyListener{

 BufferedImage backBuffer; 
 int FPS = 30;
 int janelaW = 500;
 int janelaH = 500;
 
 //VAMOS EXIBIR A TECLA PRESSIONADA
 //E MOVER UMA BOLA COM AS DIRECIONAIS
 //OBSER ISSO LÁ NO MÉTODO desenaharGraficos()
 char teclaPressionada;
 int xBola = 200;
 int yBola = 200;
 
 public void atualizar() {

 }

 public void desenharGraficos() {
  Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI
  Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...
  bbg.setColor(Color.WHITE);
  bbg.fillRect(0, 0, janelaW, janelaH); //PINTA O FUNDO COM UM QUADRADO BRANCO
  
  bbg.setColor(Color.RED);
  bbg.setFont(new Font("helvica",Font.BOLD,20));
  bbg.drawString("Você pressionou: "+teclaPressionada, 50, 100); //EXIBE UM TEXTO + O VALOR DA TECLA PRESSIONADA
  //QUE ESTÁ NA VARIÁVEL teclaPressionada
  
  //DESENHA UMA BOLA VERMELHA NA TELA
  bbg.fillOval(xBola, yBola, 50, 50);
  //AGORA VEJA O CÓDIGO DO MÉTODO keyPressed()
  //LÁ VAMOS DIZER O QUE VAI ACONTECER QUANDO UM TECLA FOR PRESSIONADA!!!
  
  //================================================================================== 
  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 ESTAMOS ADICIONANDO UM ESCUTADOR DE TECLAS
  addKeyListener(this);
 }

 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();
 }

 //ESSES SÃO OS MÉTODOS DE EVENTOS DO TECLADO
 public void keyPressed(KeyEvent e) {
  
  //AQUI A VARIAVEL VAI RECEBER O VALOR UNICODE DA TECLA QUE O USUÁRIO PRESSIONAR!!!
  teclaPressionada = e.getKeyChar();
  
  //OBS: e.VK_  depois pressione ctrl+espaço para autocompletar!
  //ai tem todas as teclas do teclado!!!
  
  //SE A TECLA PRESSIONADA FOR LEFT = ESQUERDA xBola diminue 10
  if(e.getKeyCode() == e.VK_LEFT){
   xBola -= 10;
  }
  //SE A TECLA PRESSIONADA FOR RIGHT = DIREITA xBola aumenta 10
  if(e.getKeyCode() == e.VK_RIGHT){
   xBola += 10;
  }
  //SE A TECLA PRESSIONADA FOR UP = CIMA yBola diminue 10
  if(e.getKeyCode() == e.VK_UP){
   yBola -= 10;
  }
  //SE A TECLA PRESSIONADA FOR DOWN = BAIXO yBola aumenta 10
  if(e.getKeyCode() == e.VK_DOWN){
   yBola += 10;
  }
  
 }//FIM DO MÉTODO keyPressed()
 
 public void keyReleased(KeyEvent e) {
  
 }
 public void keyTyped(KeyEvent e) {
  
 }
}

Muito bem.... vejam como ficou o meu:


Então é isso.... até o próximo tutorial, não deixem de comentar ou postar suas dúvidas aqui....


\_(^_^)_/ Comentários e Dúvidas \_(^_^)_/

quinta-feira, 14 de junho de 2012

Ruby Básico :: Tutorial :: Parte 2

Olá galera, bem vindos a segunda parte do tutorial Ruby Básico !!!


Nessa parte vamos falar da instalação do Ruby no ambiente Windows. No mac não será  necessário, pois já vem instalado por padrão no sistema. E no Linux eu já ensinei como se instala e vocês podem conferir aqui nesse post.

Instalando o Ruby no Windows


Bom, como muita coisa nesse sistema operacional funciona com executáveis prontos, então basta-nos baixarmos o RubyInstaller da versão do Ruby que queremos instalar na nossa máquina.

Aqui eu escolhi a versão 1.9.2-p290, que é a qual estaremos trabalhando dentro do novo curso que lançaremos mais a frente no blog sobre Ruby On Rails. Mas se preferirem podem baixar a versão 1.9.3 que é a versão atual do Ruby.

Agora deixo-lhes aqui uma dica: para instalações de programas vamos começar a criar o hábito de nomearmos os nomes das pastas de destino sem espaços, pois pastas com espaços ou caracteres como acentuação podem causar vários problemas.

Pronto, com a instalação feita o que nos resta a fazer para que o Ruby funcione na nossa máquina é adicionarmos à variável de ambiente PATH do sistema o local onde acabamos de instalar o Ruby. Então vamos até o painel de controle do sistema, na opção de propriedades do sistema:


E logo em seguida no botão Variáveis de Ambiente...


E no bloco "Variáveis do sistema" procure a variável "Path" e então digite o seguinte no fim do campo de valor: ;C:\nome-da-pasta-que-voce-criou\bin 

Fique atento ao ponto-e-vírgula no início que é o que separa cada caminho contido na variável Path.

Após isso é só irmos ao prompt de comando (cmd) e digitarmos ruby -v. Se tudo der certo na tela aparecerá a versão do Ruby que você acabou de instalar no sistema.

Tudo pronto agora teremos que atualizar as gems.

Para fazer isso vamos ao console novamente (cmd) e então digitamos gem update --system

Isso irá atualizar o Rubygems

Uma alternativa ao RVM: Instalando o PIK.


Bom meus amigos, como nós queremos trabalhar futuramente com projetos em Ruby, e é por isso que estamos aqui aprendendo Ruby não é mesmo, às vezes sentimos a necessidade de instalarmos versões mais novas ou mais antigas do Ruby ou então do Rails ou de alguma gem, e para isso precisamos ter um controle de versões para essas instalações e aqui eu vos apresento o PIK, uma alternativa ao RVM, o qual funciona somente no Linux e Mac. 

O PIK, assim como o RVM, é uma ferramenta para controle de versões do ruby e outras gems. O Pik está disponível como gem, então para instalarmos basta o seguinte comando: gem install pik

No entanto, a instalação do PIK ainda não está completa, precisamos rodar o comando pik_install e indicarmos o local onde a instalação copiará os arquivos do PIK. Mas antes de fazermos isso, vamos novamente criar uma pasta para a instalação do PIK. Aqui eu criei no caminho C:\PIK. 

Após isso ainda temos que adicionar esse caminho para a variável de sistema PATH, aquela mesma que anteriormente adicionamos o Ruby. 

Vamos seguir o mesmo procedimento de antes de adicionarmos o PIK para o PATH com a seguinte linha:

;C:\PIK

Seguindo em frente, se vocês estiverem com o console (cmd) aberto, o fechem para e o abram novamente para que o console carregue as novas informações do Path. Logo em seguida instalamos o pik com o seguinte comando:

pik_install C:\PIK

Pronto, instalação do PIK feita com sucesso. Já é possível instalarmos quantas versões do Ruby ou até do Rails nós quisermos, mas com cuidado para não reescrevemos o Path e nem o diretório de instalação.

Na página do github do PIK possui uma referência completa dos comandos que ele possui.

Então pessoal, encerro por aqui essa parte e vejo vocês no próximo tutorial e não deixem de postar nos comentários quaisquer dúvidas ou questionamentos referentes ao assunto.

Até a próxima pessoal!!!