Bom hoje nós vamos desenvolver um game educativo bem simples em Java, desenvolvi esse game para ensinar as pessoas que estão começando a mexer no computador e tem problemas com o mouse, ele consiste em vários quadradinhos na tela e a jogador tem que ir passando o mouse no quadradinho vermelho que vai mudando de lugar.
O game que vamos desenvolver tem essa aparência, são 30 quadradinhos que ao passar o mouse eles vão mudando de cor, mas eles têm que passar o mouse em uma ordem se não, não tem sentido o game né.
Pronto, vamos por a mão no código ehehehh.
Primeiro vamos criar uma classe para fazer os quadradinhos, então crie a classe Quadrado.
O quadrado tem que ter, posição X, Y, largura, altura, e uma cor.
import java.awt.Color;
public class Quadrado {
private int x;
private int y;
private int width;
private int height;
private Color cor;
public Quadrado(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
public Quadrado(){
}
public Color getCor() {
return cor;
}
public void setCor(Color cor) {
this.cor = cor;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
Pronto já temos os quadradinhos precisamos criar agora nossa janela, a janela é mais complicada porque temos que criar um modelo de como vai ser a tela, para depois quando formos criar a tela do game programaremos somente que vamos usar.
A Classe Janela deverá estender a JFrame, pois assim teremos uma janela, precisaremos também implementar duas interfaces a MouseListener e a MouseMotionListener para controlarmos o mouse, deixaremos essa classe abstrata.
Então ficará assim:
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import javax.swing.JFrame;
public abstract class Janela extends JFrame implements MouseListener, MouseMotionListener{
}
Você não precisa, mas é interessante implementar todos os métodos das classes MouseListener, MouseMotionListener, porque depois só sobrescrevemos só aqueles que vamos usar entendeu??? Hehehhe.
Então até agora a classe Janela está assim:
public abstract class Janela extends JFrame implements MouseListener, MouseMotionListener {
public void mouseClicked(MouseEvent e) {
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mouseDragged(MouseEvent e) {
}
public void mouseMoved(MouseEvent e) {
}
}
Continuando a classe janela precisamos de uma variável para guardar em que fase nos estamos e precisamos também criar os quadradinhos.
private int numeroDaFase;
public int getNumeroDaFase() {
return numeroDaFase;
}
public void setNumeroDaFase(int numeroDaFase) {
this.numeroDaFase = numeroDaFase;
}
protected ArrayList<Quadrado> quad = new ArrayList<Quadrado>();
public ArrayList<Quadrado> getQuad() {
return quad;
}
public void setQuad(ArrayList<Quadrado> quad) {
this.quad = quad;
}
Vamos criar inicializar os componentes e fazer um teste?
Para isso precisamos criar mais outro método e depois uma classe, o método é o inicializarComponetes(), assim inicializamos tudo em um único método assim fica mais fácil depois.
public void inicializaComponetes() {
addMouseListener(this);
addMouseMotionListener(this);
setResizable(false);
setSize(740, 640);
setTitle(”:: Elzo Brito – Game ::”);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
}
Agora vamos criar a classe MinhaTela com ela vamos criar a tela, no primeiro momento só para testar a classe Janela depois vamos usar ela para ser nossa tela.
public class MinhaTela extends Janela{
public MinhaTela(){
inicializaComponetes();
}
}
Pronto agora na classe Main crie uma instancia de MinhaTela e veja o que fizemos até agora…
public class Main {
public static void main(String[] args) {
MinhaTela mt = new MinhaTela();
}
}
Pode não parecer, mas 50% do nosso game já está pronto J, vamos dar continuidade e desenhar na tela os quadrados que compõe a tela, para isso vamos criar outra classe para facilitar nosso trabalho, criaremos então a classe Fase é nela que estarão os elementos que vamos usar no jogo.
A classe Fase tem um array com 30 quadrados que formarão a tela, alem dos dos métodos setQ() que servirá para setar a posição dos quadrados na classe e getQ() para recuperar os quadrados depois, o construtor da classe cria os 30 quadradinhos já passando a posição que cada um vai estar na tela.
public class Fase {
private Quadrado[] q = new Quadrado[30];
public Quadrado[] getQ() {
return q;
}
public void setQ(Quadrado[] q) {
this.q = q;
}
public Fase() {
Quadrado[] q = new Quadrado[30];
q[0] = new Quadrado(20, 40, 100, 100);
q[1] = new Quadrado(140, 40, 100, 100);
q[2] = new Quadrado(260, 40, 100, 100);
q[3] = new Quadrado(380, 40, 100, 100);
q[4] = new Quadrado(500, 40, 100, 100);
q[5] = new Quadrado(620, 40, 100, 100);
q[6] = new Quadrado(20, 160, 100, 100);
q[7] = new Quadrado(140, 160, 100, 100);
q[8] = new Quadrado(260, 160, 100, 100);
q[9] = new Quadrado(380, 160, 100, 100);
q[10] = new Quadrado(500, 160, 100, 100);
q[11] = new Quadrado(620, 160, 100, 100);
q[12] = new Quadrado(20, 280, 100, 100);
q[13] = new Quadrado(140, 280, 100, 100);
q[14] = new Quadrado(260, 280, 100, 100);
q[15] = new Quadrado(380, 280, 100, 100);
q[16] = new Quadrado(500, 280, 100, 100);
q[17] = new Quadrado(620, 280, 100, 100);
q[18] = new Quadrado(20, 400, 100, 100);
q[19] = new Quadrado(140, 400, 100, 100);
q[20] = new Quadrado(260, 400, 100, 100);
q[21] = new Quadrado(380, 400, 100, 100);
q[22] = new Quadrado(500, 400, 100, 100);
q[23] = new Quadrado(620, 400, 100, 100);
q[24] = new Quadrado(20, 520, 100, 100);
q[25] = new Quadrado(140, 520, 100, 100);
q[26] = new Quadrado(260, 520, 100, 100);
q[27] = new Quadrado(380, 520, 100, 100);
q[28] = new Quadrado(500, 520, 100, 100);
q[29] = new Quadrado(620, 520, 100, 100);
setQ(q);
}
}
Agora vamos terminar a classe Janela(), nela vamos criar mais um método e sobrescrever outro, o método que vamos criar é o MyTela(), ele servirá para setar a posição dos quadradinhos na classe janela().
public void myTela(){
Fase f = new Fase();
Quadrado[] q = new Quadrado[30];
q = f.getQ();
for(int i=0;i<30;i++){
q[i].setCor(Color.BLACK);
quad.add(q[i]);
}
q[0].setCor(Color.red);
}
Pronto ele cria uma instancia de fase e adiciona no nosso ArrayList a posição de todos os quadradinhos, agora precisamos sobrescrever o método Paint(Graphics g) ele é responsável por desenhar a tela e como queremos desenhar os quadradinhos na tela então precisamos dar uma arrumada nele.
@Override
public void paint(Graphics g) {
g.setColor(Color.WHITE);
g.fillRect(0, 0, 20, 650);
g.fillRect(120, 0, 20, 650);
g.fillRect(240, 0, 20, 650);
g.fillRect(360, 0, 20, 650);
g.fillRect(480, 0, 20, 650);
g.fillRect(600, 0, 20, 650);
g.fillRect(720, 0, 20, 650);
g.fillRect(0, 0, 740, 40);
g.fillRect(0, 140, 740, 20);
g.fillRect(0, 260, 740, 20);
g.fillRect(0, 380, 740, 20);
g.fillRect(0, 500, 740, 20);
g.fillRect(0, 620, 740, 20);
for(int i=0;i<30;i++){
g.setColor(quad.get(i).getCor());
g.fill3DRect(quad.get(i).getX(), quad.get(i).getY(), quad.get(i).getWidth(), quad.get(i).getHeight(), true);
}
}
Quase pronto vamos alterar o método inicializaComponentes() para chamar o MyTela() pois se não, não conseguiremos desenhar a tela sem a posição dos quadradinho correto???
public void inicializaComponetes() {
addMouseListener(this);
addMouseMotionListener(this);
setResizable(false);
setSize(740, 640);
setTitle(”:: Elzo Brito – Game ::”);
setDefaultCloseOperation(EXIT_ON_CLOSE);
myTela();
show();
}
Como será que a tela ficou??
Só falta agora a lógica do game, como havíamos pensando antes, o nosso game é para pessoas que não sabem mexer com o mouse então quando passar o mouse no quadradinho vermelho ele tem que mudar de lugar forçando a pessoa a seguir-lo com o mouse, vamos então para a classe MinhaTela() pois é nela que iremos por um pouco da lógica do nosso game.
public void pintarQuad(int x){
try {
if (quad.get(x – 1).getCor() == Color.ORANGE) {
quad.get(x + 1).setCor(Color.RED);
quad.get(x – 1).setCor(Color.PINK);
quad.get(x).setCor(Color.ORANGE);
}
}
catch(java.lang.ArrayIndexOutOfBoundsException ex){
if(quad.get(0).getCor() == Color.RED){
quad.get(1).setCor(Color.RED);
quad.get(0).setCor(Color.ORANGE);
}
}
catch(java.lang.IndexOutOfBoundsException ex){}
repaint();
}
Adicione esse método pintarQuad(int x), ele serve para pintar o quadrado onde passamos o mouse, se passamos o mouse no 1º quadradinho ele deve ficar amarelo e o 2º quadradinho deve ficar vermelho se passarmos o mouse no 2º quadradinho ele deve ficar amarelo o 3º quadradinho deve ficar vermelho e o 1º quadradinho fica rosinha.
Para finalizar precisamos do movimento do mouse correto? Isso então vamos criar uma classe para trabalharmos só com o movimento do mouse, vamos criar então a classe FaseMouseMove() nela trabalharemos o movimento do mouse sobre os quadradinhos, ela deve importar o MouseEvent, estender a MinhaTela() e sobrescrever o método mouseMoved(MouseEvent e).
import java.awt.event.MouseEvent;
public class FaseMouseMove extends MinhaTela{
@Override
public void mouseMoved(MouseEvent e) {
for(int i=0;i<30;i++){
if(e.getX() > quad.get(i).getX() && e.getX() < (quad.get(i).getWidth() + quad.get(i).getX()) && e.getY() > quad.get(i).getY() && e.getY() < (quad.get(i).getHeight()+quad.get(i).getY())){
pintarQuad(i);
}
}
}
}
Esse IF gigante testa a condição do ponteiro do mouse, se o ponteiro do mouse estiver dentro do quadradinho ele chama então o metodo pintarQua(int i) passando o número do quadradinho que o mouse estar em cima, pronto o game esta criado basta apenas criar uma instancia da classe FaseMouseMove() na classe Main() e pronto é só jogarrrr
public class Main {
public static void main(String[] args) {
FaseMouseMove fmm = new FaseMouseMove();
}
}
Pronto galera espero que tenham gostado do artigo, quem quiser fazer o download do projeto basta clicar no link abaixo, ele foi desenvolvido no NetBeans.
http://elzobrito.com/arquivos/desenvolvimento/gameeducativo/GameEducativo.zip
).
Download: calculadora_android
Homepage: 
Hom Digitalis 