terça-feira, 4 de junho de 2013

A era de ouro dos Indie Games


Os Indie Games estão mudando a história dos videogames. A facilidade de entrada no mercado e o enorme retorno financeiro que podem gerar nos mais de 500 mil Androids e iPhones no mercado, fazem com que esse estilo de games experimente um crescimento excepcional. A parte mais atrativa desse crescimento são as possibilidades de enriquecimento e as histórias de sucesso instantâneo que parecem ter criado uma nova “corrida do ouro”, na qual os game designers disputam o mercado no desejo de que sua ideia seja, literalmente, comprada pelas empresas.
Um exemplo de como o mercado dos Indie Games podem transformar uma empresa é o Draw Something, criado pela OMGPOP, que estava à beira da falência quando lançou o jogo, em fevereiro deste ano. O sucesso absurdo do jogo, que é uma espécie de Imagem & Ação para smartphones, chamou a atenção da Zynga, responsável por sucessos como Famville e Cityville. A bilionária produtora se interessou pelo jogo, que tinha alcançado a marca de 50 milhões de usuários, e comprou a OMGPOP por US$ 210 milhões. Dan Porter, dono da empresa, ficou tão feliz com a fortuna instantânea, que recontratou os antigos funcionários, demitidos quando a empresa estava à beira da falência, dando a eles uma parte do lucro.

O mais interessante dessa história é que o jogo é muito simples. Para jogar Draw Something, é necessário baixar o app em seu Android ou iOS e criar uma conta através do seu perfil no Facebook ou seu email. Depois basta convidar seus amigos e desenhar uma das três palavras sorteadas pelo jogo, de uma maneira que seu parceiro consiga respondê-la. A diferença entre o Draw Something e o Imagem & Ação é que ao contrário da versão física do jogo, na versão para smartphone você ganha pontos se seu adversário conseguir adivinhar o desenho. Com essa “disputa cooperativa”, fica mais fácil convidar os amigos para jogar, além é claro, de poder publicar os desenhos nas redes sociais.
Além desse, há diversos exemplos de jogos com conceitos aparentemente muito simples, mas que permitem aos jogadores uma experiência divertida e enriquecedora. Poderíamos citar vários exemplos de indie games que deram certo, como Minecraft, feito por um sueco chamado Markus Persson (o “Notch”), que já vendeu milhões de cópias e surgiu de poucos recursos e uma boa ideia. O jogo tem um conceito parecido com um balde de LEGO, só que com um visual que lembra jogos em 8 bit. O jogo não tem uma história linear, na qual a mão invisível do criador te empurra para um final inevitável. Não há quests ou objetivos, o que possibilita uma liberdade muito grande aos jogadores.

Minecraft: uma ideia simples e poucos recursos que deram certo

O sucesso de jogos como Draw Something e Minecraft mostram que o mercado em constante crescimento, facilitando a vida de quem desenvolve games independentes. Alumas pessoas estão chamando essa de “a Era de Ouro dos Indie Games”, devido aos fenômenos de vendas que cada vez mais saltam aos nossos olhos. Por isso, se você é desenvolvedor de games, programador, ou simplesmente tem uma grande ideia, esse é o momento ideial para concretizá-la.

Última semana para se tornar um testador Beta de Submundo II: Condenados

Esta é a última semana para se tornar um testador Beta de Submundo II Condenados, jogo brasileiro de terror sendo desenvolvido pela empresa independente Sultek Software, o jogo tem previsão de lançamento para o 3º trimestre de 2013 e já possui versões de demonstração.

Para se inscrever basta preencher o formulário encontrado no link: http://sulteksite.blogspot.com.br/2013/05/beta.html

Entendendo a JMonkey Engine

 http://farm3.static.flickr.com/2347/1675386327_64af841db7_o.jpg
JMonkey Engine (jME) é um framework Open Source de alta performance para desenvolvimento de aplicações Java que utilzem recursos 3D. A primeira versão do framework foi criada por Mark Powell em 2003, enquanto pesquisava sobre o processo renderização utilizado em OpenGL.
A arquitetura do framework é baseada em grafos de cenas, ou seja, os dados do ambiente estão organizados em uma estrutura de árvore, onde um nodo origem pode ter um conjunto de nodos filhos. Estes nodos filhos, por sua vez, têm uma referência única de seu nodo de origem (também chamado nodo pai). Toda essa estrutura tem o objetivo de tornar o processo de renderização mais ágil.
Por exemplo, se construírmos um grafo de cena que representa um conjunto de móveis, que estão relacionados através de seu nodo pai, que é a sala, que por sua vez compartilham um andar, que estão localizados em um determinado edifício.
Se neste ambiente hierárquico bem definido, estivermos interessados em mostrar apenas um determinado andar, podemos facilmente descartar do processo de renderização todos os ramos do grafo que representam os outros andares, e por consequência, suas salas e seus móveis mostrando apenas o que realmente deve ser mostrado.
O segredo para poupar recursos preciosos do sistema tornando esse sistema de renderização realmente eficiente está em um bom algoritmo para o sistema de câmeras. A câmera é o objeto que aponta, em um determinado ambiente 3D, para onde estamos focalizando (olhando) num determinado momento. Ela que decide quem deverá ser desenhado ou não, num determinado instante de tempo.

Knights of Pen & Paper será lançado no Steam

Knights-of-pen-and-paper-behold-the-target

Nas paredes da Behold Studios, fundada em 2009 na cidade de Brasília, está impressa a frase:
Criamos os games que gostaríamos de jogar.
E ao contrário do que você pode estar imaginando, não é um daqueles games educativos chatos que sempre vemos ganharem ‘fama’ no território nacional. ”Knights of Pen & Paper” é a melhor prova de que o slogan funciona, afinal, após 500 mil downloads nas plataformas iOS e Android, o agora famoso RPG está a caminho do PC (via Steam), Mac e Linux, chancelado pela publisher européia Paradox Interactive.

Como tudo começou

Behold-Studios-The-Target
Como todo bom nerd, os integrantes da empresa, durante uma sessão de RPG de mesa, se deram conta de que, nenhum jogo digital lançado até o momento, se equiparava a “Dungeons & Dragons”, segundo os critérios deles. Foi aí quando tiveram sua epifania:
Somos desenvolvedores de jogos. Vamos criar nosso próprio game,
Behold-Knights-of-pen-and-paper-pizza-guy-the-target
O visual pixelado e a música chip tune, foi uma idéia deles, visto que, RPGs tradicionas ‘de mesa’ estão relacionados as decadas de 80 e 90.

GAME DE TABULEIRO

“Knights of Pen & Paper” é um RPG clássico com influências de jogos de tabuleiro e do próprio RPG de mesa, jogado com dados, fichas de personagem de papel e um narrador que conduz o enredo.
Knights-of-pen-and-paper-behold-tabuleiro-the-target

O jogo combina as tradicionais classes de RPG, como mago, paladino e ladrão, com personagens inusitados, como motoboy, nerd e hipster. O humor é presença constante nos diálogos do game, cujo enredo passa por vilas, cavernas e masmorras, em que as mais variadas missões podem ser cumpridas.
A começar pelo nome, “Knights of Pen & Paper”, é voltado para o mercado internacional. A originalidade, mesmo sob um gênero conhecido, fez o jogo obter sucesso lá fora e aparecer em muitos veículos especializados estrangeiros.
EUA, Canadá e Inglaterra são os responsáveis por mais de 60% dos downloads do game. O Brasil aparece em sexto lugar, atrás também de Austrália e Alemanha.
O foco está no mercado internacional. O público brasileiro, em geral, não consome muitos jogos independentes nacionais. O brasileiro compra muitos jogos, sim, mesmo com a pirataria, mas tende a optar pelos games ‘blockbusters‘,

Mudanças no PC

O lançamento da nova edição, intitulada Knights of Pen & Paper +1, ainda não tem data definida, mas chega em 2013.

O game põe os jogadores no controle do dungeon master e de todos os outros personagens em aventuras tradicionais e bem humoradas. A versão atualizada inclui o game original com novas dungeons, monstros e itens. O Behold Studios também adicionou uma taverna que permite a troca de personagens, o que facilita a vida de quem não quer iniciar uma partida nova sempre que abrir um novo tipo de personagem.

O game já concorreu ao prêmio de Melhor Game Estudantil no Independent Games Festival, ao lado de Back to Bed, ATUM e Pulse.

Screen Shot 2013-03-25 at 8.07.52 PM


Com lançamento programado para entre junho e setembro, “Knights” ainda não tem preço definido, mas uma coisa é certa: vai manter as microtransações, tal qual nas plataformas móveis.

Knights-of-pen-and-paper-behold-pc-the-target
No PC as novidades começam com ajustes finos que incluem a possibilidade de se locomover diretamente para onde se deseja ir (antes era preciso passar lugar por lugar até o destino final), e o recurso para trocar de personagens na Taverna, sem que seja preciso iniciar uma nova partida.
Porém, a maior boa nova fica mesmo por conta da adição de “dungeons“. Nessas masmorras há vários ambientes, nos quais é preciso circular para encontrar a chave que leva ao chefão. Cada sala funciona como um teste e costuma guardar itens valiosos para a jornada.

sexta-feira, 31 de maio de 2013

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!

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!)

1:  import java.awt.Color;  
2:  import java.awt.Font;  
3:  import java.awt.Graphics;  
4:  import java.awt.event.KeyEvent;  
5:  import java.awt.image.BufferedImage;  
6:  public class Menu {  
7:   int cenario = -1;  //ESSA VARIAVEL INDICA EM QUE CENÁRIO ESTAMOS, -1(NENHUM CENÁRIO) (0,1,2,3...N) OUTROS CENÁRIOS  
8:   int itemSelecionado = 0; //ESSA VARIAVEL SERVIRÁ PARA INDICAR QUAL ITEM QUE ESTÁ SELECIONADO (o atual é zero que é o primeiro item do menu)  
9:   String itens[];  //aqui vamos guardar os itens do nosso menu (jogar, opções, sair...etc)  
10:   Graphics bbg;  //como nos outros métodos da classe game.java usamos essa varialvel para desenhar elementos na tela  
11:   boolean ativo;  //indica se o menu está ativo ou não (ao inicar o jogo desativamos o menu, para o controlemos durante o jogo)  
12:   int x;   //coordenada x do menu  
13:   int y;   //coordenada y do menu  
14:   int tamanhoDaFonte = 20; //nem precisa explicar não é ?  
15:   int distanciaEntreItens = 15;//distância entre cada item do menu!  
16:   Font fonte = new Font("Arial", Font.BOLD, tamanhoDaFonte);//a fonte do nosso menu  
17:   Color corSelecionado = new Color(255, 0, 0); // COR VERMELHA para o item selecionado  
18:   Color corNaoSelecionado = new Color(0, 0, 0); // COR PRETA para o item que não está selecionado  
19:   //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!  
20:   public Menu(int numeroDeItens, int x, int y, boolean ativo) {  
21:   itens = new String[numeroDeItens];  
22:   this.x = x;  
23:   this.y = y;  
24:   this.ativo = ativo;  
25:   }  
26:   //esse metodo só chamará o método controlaMenu se ele estiver ativo!  
27:   public void controlar(KeyEvent e) {  
28:   if (ativo) {  
29:    controlarMenu(e);  
30:   }  
31:   }  
32:   //esse método nos fará retornar ao menu ao pressinarmos "Esc"  
33:   public void voltarAoMenu(KeyEvent e){  
34:   //se tecla pressionada for igual a "Esc"  
35:   if(e.getKeyCode() == e.VK_ESCAPE){  
36:    cenario = -1; //com isso sai dos cenários em que estivermos...  
37:    ativo = true; //e reativa o menu para que o possamos controlar novamente...  
38:   }  
39:   }  
40:   //esse método controlará o nosso menu através do teclado  
41:   //ele é chamando dentro do método controla()  
42:   private void controlarMenu(KeyEvent e) {  
43:   //se pressionar a tecla "cima" diminui 1 em itemSelecionado  
44:   if (e.getKeyCode() == e.VK_UP) {  
45:    itemSelecionado -= 1;  
46:   }  
47:   //se pressionar a tecla "baixo" aumenta 1 em itemSelecionado  
48:   if (e.getKeyCode() == e.VK_DOWN) {  
49:    itemSelecionado += 1;  
50:   }  
51:   //isso aqui é para controlar os limites extrmos do menu  
52:   //caso eu esteja com 1º item selecionado e pressione para cima, ele vai para a ultima opção  
53:   //caso eu esteja com o ultimo item selecionado e pressione para baixo, ele vai para primeira opção  
54:   if (itemSelecionado >= itens.length) {  
55:    itemSelecionado = 0;  
56:   }  
57:   if (itemSelecionado < 0) {  
58:    itemSelecionado = itens.length - 1;  
59:   }  
60:   //se pressionar a tecla Enter ele muda o valor de cenario para o item que está selecionado  
61:   //isso fará mudar de cenário e desativará o menu para que ele não seja mais controlado!  
62:   if(e.getKeyCode() == e.VK_ENTER){  
63:    cenario = itemSelecionado;  
64:    ativo = false;  
65:   }  
66:   }  
67:   //esse método irá desenhar o nosso menu na tela!  
68:   //a um loop (for) que irá listar todos os itens que está guardado em itens[]  
69:   //um calculo é feito para a coordenada y de cada intem do nosso menu, para que eles fiquem  
70:   //um distante do outro, então caso y = 10, o item 0 será: 10+(0*(20+15)) = 10  
71:   //para o item 1 será: 10+(1*(20+15)) = 45  
72:   //para o item 2 será: 10+(2*(20+15)) = 80  
73:   //para o item 3 será: 10+(3*(20+15)) = 115, e assim por diante...  
74:   public void desenharMenu() {  
75:   bbg.setFont(fonte);//seta a fonte que definimos bem acima na declaração de variáveis  
76:   for (int i = 0; i < itens.length; i++) {// aqui é o inicio do nosso loop  
77:    if(itemSelecionado == i){//se ele estiver selecionado muda a cor para vermelho e desenha o item na tela  
78:    bbg.setColor(corSelecionado);  
79:    bbg.drawString(itens[i], x, y+(i*(tamanhoDaFonte+distanciaEntreItens)));  
80:    }else{//se não estiver selecionado muda a cor para preto e desenha o item na tela  
81:    bbg.setColor(corNaoSelecionado);  
82:    bbg.drawString(itens[i], x, y+(i*(tamanhoDaFonte+distanciaEntreItens)));  
83:    }  
84:   }  
85:   }  
86:  }  

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

1:  import java.awt.*;  
2:  import java.awt.event.KeyEvent;  
3:  import java.awt.event.KeyListener;  
4:  import java.awt.image.BufferedImage;  
5:  import java.io.File;  
6:  import javax.swing.ImageIcon;  
7:  import javax.swing.JFrame;  
8:  public class Game extends JFrame implements KeyListener{  
9:   BufferedImage backBuffer;  
10:   int FPS = 30;  
11:   int janelaW = 500;  
12:   int janelaH = 500;  
13:   //AQUI DECLARAMOS O NOSSO MENU COM:  
14:   //4 itens, coordenadas x e y = 100, a ativo = true  
15:   //agora olhe esse método abaixo cenarios()  
16:   Menu menuPrincipal = new Menu(4, 100, 100, true);  
17:   //esse método vai desenhar na tela alguns possíveis cenários do nosso game  
18:   //lá em Menu.java cenario foi definido como -1  
19:   //se cenario == 0 muda a cor do fundo e mostra um texto  
20:   //se cenario == 1 muda a cor do fundo e mostra um texto  
21:   //se cenario == n muda a cor do fundo e mostra um texto...  
22:   //agora obser o nosso método desenharGraficos()  
23:   public void cenarios(){  
24:   Graphics bbg = backBuffer.getGraphics();  
25:   bbg.setFont(new Font("Arial",Font.BOLD,20));  
26:   if(menuPrincipal.cenario == 0){  
27:    bbg.setColor(new Color(255,100,100));  
28:    bbg.fillRect(0, 0, janelaW, janelaH);  
29:    bbg.setColor(Color.BLACK);  
30:    bbg.drawString("Você escolheu Jogar", 100, 200);  
31:    //aqui você pode escolher o que irá aparecer caso o usuario escolha essa item do menu!  
32:   }  
33:   if(menuPrincipal.cenario == 1){  
34:    bbg.setColor(new Color(100,255,100));  
35:    bbg.fillRect(0, 0, janelaW, janelaH);  
36:    bbg.setColor(Color.BLACK);  
37:    bbg.drawString("Você escolheu Opções", 100, 200);  
38:   }  
39:   if(menuPrincipal.cenario == 2){  
40:    bbg.setColor(new Color(100,100,255));  
41:    bbg.fillRect(0, 0, janelaW, janelaH);  
42:    bbg.setColor(Color.BLACK);  
43:    bbg.drawString("Você escolheu Ajuda", 100, 200);  
44:   }  
45:   if(menuPrincipal.cenario == 3){  
46:    System.exit(0);//esse comando fecha o nosso game!  
47:   }  
48:   }  
49:   public void atualizar() {  
50:   }  
51:   public void desenharGraficos() {  
52:   Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI  
53:   Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...  
54:   bbg.setColor(Color.WHITE);  
55:   bbg.fillRect(0, 0, janelaW, janelaH); //PINTA O FUNDO COM UM QUADRADO BRANCO  
56:   menuPrincipal.desenharMenu();//isso desenhará nosso menu  
57:   cenarios();//isso irá desenhar os cenários que escolhermos no menu  
58:   //agora observe o método inicializar()  
59:   //==================================================================================  
60:   g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!  
61:   }  
62:   public void inicializar() {  
63:   setTitle("Titulo do Jogo!");  
64:   setSize(janelaW, janelaH);  
65:   setResizable(false);  
66:   setDefaultCloseOperation(EXIT_ON_CLOSE);  
67:   setLayout(null);  
68:   setVisible(true);  
69:   backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);  
70:   //AQUI ESTAMOS ADICIONANDO UM ESCUTADOR DE TECLAS  
71:   addKeyListener(this);  
72:   //aqui definimos o texto de cada item do nosso menu  
73:   menuPrincipal.itens[0] = "Jogar";  
74:   menuPrincipal.itens[1] = "Opções";  
75:   menuPrincipal.itens[2] = "Ajuda";  
76:   menuPrincipal.itens[3] = "Sair";  
77:   //aqui fazemos o método desenhaMenu() que fica lá em Menu.java  
78:   //desenhar no nosso buffer  
79:   //.. agora para finalizar observe o método de evento keyPressed() mais abaixo...  
80:   menuPrincipal.bbg = backBuffer.getGraphics();  
81:   }  
82:   public void run() {  
83:   inicializar();  
84:   while (true) {  
85:    atualizar();  
86:    desenharGraficos();  
87:    try {  
88:     Thread.sleep(1000/FPS);  
89:    } catch (Exception e) {  
90:     System.out.println("Thread interrompida!");  
91:    }  
92:   }  
93:   }  
94:   public static void main(String[] args) {  
95:   Game game = new Game();  
96:   game.run();  
97:   }  
98:   public void keyPressed(KeyEvent e) {  
99:   //aqui, chamamos os métodos que irá controlar o menu pelo teclado  
100:   menuPrincipal.controlar(e);//esse controla o menu  
101:   menuPrincipal.voltarAoMenu(e);//esse faz voltar para o menu quando pressionarmos "Esc"  
102:   }  
103:   public void keyReleased(KeyEvent e) {  
104:   }  
105:   public void keyTyped(KeyEvent e) {  
106:   }  
107:  }  

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




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

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
1:  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:

1:  @Override  
2:   public void mouseClicked(MouseEvent e) {  
3:   // TODO Auto-generated method stub  
4:   }  
5:   @Override  
6:   public void mouseEntered(MouseEvent e) {  
7:   // TODO Auto-generated method stub  
8:   }  
9:   @Override  
10:   public void mouseExited(MouseEvent e) {  
11:   // TODO Auto-generated method stub  
12:   }  
13:   @Override  
14:   public void mousePressed(MouseEvent e) {  
15:   // TODO Auto-generated method stub  
16:   }  
17:   @Override  
18:   public void mouseReleased(MouseEvent e) {  
19:   // TODO Auto-generated method stub  
20:   }  
21:   @Override  
22:   public void mouseDragged(MouseEvent e) {  
23:   // TODO Auto-generated method stub  
24:   }  
25:   @Override  
26:   public void mouseMoved(MouseEvent e) {  
27:   // TODO Auto-generated method stub  
28:   }  

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:

1:  public void inicializar() {  
2:   setTitle("Titulo do Jogo!");  
3:   setSize(janelaW, janelaH);  
4:   setResizable(false);  
5:   setDefaultCloseOperation(EXIT_ON_CLOSE);  
6:   setLayout(null);  
7:   setVisible(true);  
8:   backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);  
9:   //AQUI ESTAMOS ADICIONANDO OS ESCUTADORES DE EVENTOS DO MOUSE  
10:   addMouseListener(this);  
11:   addMouseMotionListener(this);  
12:   }  

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)

1:  import java.awt.*;  
2:  import java.awt.event.KeyEvent;  
3:  import java.awt.event.KeyListener;  
4:  import java.awt.event.MouseEvent;  
5:  import java.awt.event.MouseListener;  
6:  import java.awt.event.MouseMotionListener;  
7:  import java.awt.image.BufferedImage;  
8:  import java.io.File;  
9:  import javax.swing.ImageIcon;  
10:  import javax.swing.JFrame;  
11:  import javax.swing.JOptionPane;  
12:  public class Game extends JFrame implements MouseListener, MouseMotionListener{  
13:   BufferedImage backBuffer;  
14:   int FPS = 30;  
15:   int janelaW = 500;  
16:   int janelaH = 500;  
17:   //VARIAVEIS QUE VAMOS UTILIZAR  
18:   //UMA IMAGEM PARA REPRESENTAR A MIRA  
19:   //E AS SUAS COORDENADAS X e Y  
20:   //NÃO SE ESQUEÇA DE OLHAR O MÉTODO desenharGraficos()  
21:   //e os métodos de eventos que é onde iremos tratar algumas coisas  
22:   ImageIcon mira = new ImageIcon("src/tutor13/mira.png");  
23:   int xMira;  
24:   int yMira;  
25:   public void atualizar() {  
26:   }  
27:   public void desenharGraficos() {  
28:   Graphics g = getGraphics(); //ISSO JÁ ESTAVA AQUI  
29:   Graphics bbg = backBuffer.getGraphics();//ISSO TAMBÉM JÁ ESTAVA AQUI...  
30:   bbg.setColor(Color.WHITE);  
31:   bbg.fillRect(0, 0, janelaW, janelaH); //PINTA O FUNDO COM UM QUADRADO BRANCO  
32:   bbg.setColor(Color.RED);  
33:   bbg.setFont(new Font("helvica",Font.BOLD,20));  
34:   bbg.drawString("X=: "+xMira+" Y="+yMira, 50, 100); //EXIBE UM TEXTO + O VALOR DA TECLA PRESSIONADA  
35:   //QUE ESTÁ NA VARIÁVEL teclaPressionada  
36:   //AQUI DESENHAMOS A MIRA, O -25 É PARA FICAR CENTRALIZADA COM O CURSOR  
37:   bbg.drawImage(mira.getImage(), xMira-25, yMira-25, this);  
38:   //==================================================================================  
39:   g.drawImage(backBuffer, 0, 0, this);//OBS: ISSO DEVE FICAR SEMPRE NO FINAL!  
40:   }  
41:   public void inicializar() {  
42:   setTitle("Titulo do Jogo!");  
43:   setSize(janelaW, janelaH);  
44:   setResizable(false);  
45:   setDefaultCloseOperation(EXIT_ON_CLOSE);  
46:   setLayout(null);  
47:   setVisible(true);  
48:   backBuffer = new BufferedImage(janelaW, janelaH, BufferedImage.TYPE_INT_RGB);  
49:   //AQUI ESTAMOS ADICIONANDO OS ESCUTADORES DE EVENTOS DO MOUSE  
50:   addMouseListener(this);  
51:   addMouseMotionListener(this);  
52:   }  
53:   public void run() {  
54:   inicializar();  
55:   while (true) {  
56:    atualizar();  
57:    desenharGraficos();  
58:    try {  
59:     Thread.sleep(1000/FPS);  
60:    } catch (Exception e) {  
61:     System.out.println("Thread interrompida!");  
62:    }  
63:   }  
64:   }  
65:   public static void main(String[] args) {  
66:   Game game = new Game();  
67:   game.run();  
68:   }  
69:   public void mouseClicked(MouseEvent e) {  
70:   JOptionPane.showMessageDialog(null, "Você clicou!!!!");  
71:   }  
72:   public void mouseEntered(MouseEvent e) {  
73:   }  
74:   public void mouseExited(MouseEvent e) {  
75:   }  
76:   public void mousePressed(MouseEvent e) {  
77:   }  
78:   public void mouseReleased(MouseEvent e) {  
79:   }  
80:   public void mouseDragged(MouseEvent e) {  
81:   }  
82:   public void mouseMoved(MouseEvent e) {  
83:   //AQUI X e Y DA MIRA RECEBE AS COORDENADAS DO CURSOR  
84:   xMira = e.getX();  
85:   yMira = e.getY();  
86:   }  
87:  }  

Veja como ficou:




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