Jogo da Memória em Java

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JToolBar;
import javax.swing.border.TitledBorder;

/*
 Este é um programa da Memória com 16 casas distribuídos em 4 linhas por 4 colunas, no qual
 o jogador deverá achar os números iguais. Ao desvirar duas peças aparecerá uma caixa de
 diálogo informando se os números coincidem ou não.
 A cada acerto o jogador ganhará 10 pontos e a cada erro perderá 2 pontos.
*/

public class JogoDaMemoria extends JFrame{
 
    // Autor: João Matheus Santos Assis
    int pontos = 100;  
 
    Random RandomNumber = new Random();
    int Aleatorio[] = new int [16];
    int Posicao_do_vetor_Aleatorio[] = new int [16];
 
    // Barra de Ferramenta
    private JToolBar Barra_Ferramenta = new JToolBar();
    private JButton Button_Novo_Jogo = new JButton("Novo Jogo");
    private JButton Button_Re_Iniciar_Jogo = new JButton("Reiniciar partida");
    private JButton Button_Estatisticas = new JButton("Estatísticas");
    private JButton Sobre_JogoDaMemoria = new JButton("Sobre");
 
    private JPanel Panel = new JPanel();
    private GridLayout Layout_do_Jogo = new GridLayout(4,4);
    private Font Fonte = new Font("Lucida Console", Font.BOLD, 36);
    private JButton Escolha[] = new JButton[16];
 
    private JPanel Barra_de_Status = new JPanel();
    private JLabel Pontuacao_do_Jogador = new JLabel("Pontos: 100");
 
    public JogoDaMemoria() {
        super("Jogo da Memória");
     
        Barra_Ferramenta.add(Button_Novo_Jogo);
        Barra_Ferramenta.add(Button_Re_Iniciar_Jogo);
        Barra_Ferramenta.add(Button_Estatisticas);
        Barra_Ferramenta.add(Sobre_JogoDaMemoria);
        add(Barra_Ferramenta, BorderLayout.NORTH);
     
        for (int i=0; i<16; ++i){
            Escolha[i] = new JButton();
            Panel.add(Escolha[i]);
            Escolha[i].setFont(Fonte);
            Escolha[i].setVisible(true);
        }
     
        Panel.setLayout(Layout_do_Jogo);
        add(Panel, BorderLayout.CENTER);
     
        Barra_de_Status.add(Pontuacao_do_Jogador);
        add(Barra_de_Status, BorderLayout.SOUTH);
     
     
        Eventos_JogoDaMemoria Handler = new Eventos_JogoDaMemoria();
        for (int i=0; i<16; ++i){
            Escolha[i].addActionListener(Handler);
        }
        Button_Novo_Jogo.addActionListener(Handler);
        Button_Re_Iniciar_Jogo.addActionListener(Handler);
        Button_Estatisticas.addActionListener(Handler);
        Sobre_JogoDaMemoria.addActionListener(Handler);

     
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setResizable(false);    
        this.setSize(500,500);
        this.setVisible(true);
        this.setLocationRelativeTo(null);
    }
 
    private class Eventos_JogoDaMemoria implements ActionListener{
     
        int Cont_Acertos,Primeiro_Click,Segundo_Click;
        int Numero_Click, posi, cont, pontos_Anterior, Maior_Pontuacao_do_Jogador;
        int Partidas_jogadas = 0, Numero_de_Vitorias = 0;
        boolean Novo_Jogo = true;
        boolean Re_Iniciar = false;
        boolean Fim_de_Jogo = false;                      
     
     
        public void actionPerformed(ActionEvent event){                      

         
            if (event.getSource() == Sobre_JogoDaMemoria){
                new Sobre_Sobre_JogoDaMemoria((int)getLocation().getX(), (int)getLocation().getY(),
                        JogoDaMemoria.this, true).setVisible(true);
            }
         
            if (event.getSource() == Button_Novo_Jogo){
                Novo_Jogo = true;
                Re_Iniciar = false;
            }
         
            if (event.getSource() == Button_Re_Iniciar_Jogo){
                Novo_Jogo = true;
                Re_Iniciar = true;
            }
         
            if (event.getSource() == Button_Estatisticas){
                Fim_de_Jogo = true;
            }
         
            if (Novo_Jogo == true){
             
                Cont_Acertos = 0;
                Partidas_jogadas++;
                pontos_Anterior = pontos;
                pontos = 100;
                Numero_Click = 0;
                posi = 0; cont = 16;
                Primeiro_Click = 0;
                Segundo_Click = 0;
             
                for (int i=0; i<16; ++i){
                    Escolha[i].setText("");
                    Escolha[i].setEnabled(true);
                }
             
                if (Re_Iniciar == false){
                 
                    for (int i=0; i<16; ++i){
                        Posicao_do_vetor_Aleatorio[i] = i;
                    }
     
                    for (int i=0; i<8; ++i){
                        for (int j=0; j<2; ++j){
                            posi = RandomNumber.nextInt(cont);
                            Aleatorio[Posicao_do_vetor_Aleatorio[posi]] = i;
                     
                            if (posi < cont){
                                for (int q=(posi+1); q<(cont); ++q){
                                    Posicao_do_vetor_Aleatorio[q-1] = Posicao_do_vetor_Aleatorio[q];
                                }
                            } cont--;
                        }
                    }
                }
                Novo_Jogo = false;
            }
         
         
         
         
            for (int i=0; i<16; ++i){
             
                if (event.getSource() == Escolha[i]){
                                   
                    Escolha[i].setText(String.valueOf(Aleatorio[i]));
                    Escolha[i].setEnabled(false);
                    Escolha[i].setVisible(true);
                    Numero_Click++;
                 
                    if (Numero_Click == 1) Primeiro_Click = i;
                        if (Numero_Click == 2){
                            Segundo_Click = i;
                            if (Aleatorio[Primeiro_Click] != Aleatorio[Segundo_Click]){                                                      
                                pontos-=2;
                                JOptionPane.showMessageDialog(JogoDaMemoria.this, "Errado");
                                Escolha[Primeiro_Click].setText("");
                                Escolha[Segundo_Click].setText("");
                                Escolha[Primeiro_Click].setEnabled(true);
                                Escolha[Segundo_Click].setEnabled(true);                            
                         
                            }  else {
                                Cont_Acertos++;
                                pontos+=10;
                        }
                        Numero_Click = 0;
                    }
                }
            }
         
         
            if (Cont_Acertos == 8){
                Numero_de_Vitorias++;
                Cont_Acertos = 0;
                if (pontos > pontos_Anterior) Maior_Pontuacao_do_Jogador = pontos;
                    Fim_de_Jogo = true;
            }
         
         
            if (pontos < 0) pontos = 0;
            Pontuacao_do_Jogador.setText("Pontos: " + pontos);
         
         
            if (Fim_de_Jogo == true){
                Estatisticas_Jogo(Partidas_jogadas, Numero_de_Vitorias, Maior_Pontuacao_do_Jogador);
                Fim_de_Jogo = false;
            }          
        }
    }
 
 
    void Estatisticas_Jogo(int Partidas_jogadas, int Numero_de_Vitorias, int Maior_Pontuacao_do_Jogador){
     
        JOptionPane.showMessageDialog(JogoDaMemoria.this, "Partidas jogadas: " + Partidas_jogadas +
                        "\nVitórias: " + Numero_de_Vitorias +
                        "\nMaior Pontuação do Jogador: " + Maior_Pontuacao_do_Jogador);
    }
 
 
 
    //Sobre o Jogo da Memória
    class Sobre_Sobre_JogoDaMemoria extends JDialog{
 
        private Font Fonte = new Font("Tahoma", Font.PLAIN, 12);
 
        private JPanel Geral = new JPanel();

 
        private JPanel Informacoes_do_Autor = new JPanel();
            private GridLayout Layout1 = new GridLayout(4,1);
            private JLabel Nome_do_Autor = new JLabel("João Matheus Santos Assis");
            private JLabel Cidade_do_Autor = new JLabel("Valença/Bahia");
            private JLabel Site_do_Codigo = new JLabel("Site do Jogo da Memória:");
            private JLabel Endereco_do_Jogo_da_Memoria = new JLabel("http://programjm.blogspot.com.br/");

        private JPanel Informacoes_Tecnicas = new JPanel();
            private GridLayout Layout2 = new GridLayout(4,1);
            private JLabel Sistema_Operacional = new JLabel("Windows 7");
            private JLabel Plataforma = new JLabel("NetBeans 5.5.1");
            private JLabel Ultima_Atualizacao = new JLabel("Data de Criação:");
            private JLabel Data = new JLabel("8 de setembro de 2012");
         
        private JButton Fechar_Sobre_JogoDaMemoria = new JButton("Fechar");
 
        private int X;
        private int Y;

            public Sobre_Sobre_JogoDaMemoria(int X, int Y, Frame parent, boolean modal) {
                super(parent, modal);
     
                this.X = X;
                this.Y = Y;
         
                // Adicionando os elementos ao Dialog      
                Nome_do_Autor.setFont(Fonte);
                Cidade_do_Autor.setFont(Fonte);
                Site_do_Codigo.setFont(Fonte);
                Endereco_do_Jogo_da_Memoria.setFont(Fonte);
     
                Sistema_Operacional.setFont(Fonte);
                Plataforma.setFont(Fonte);
                Ultima_Atualizacao.setFont(Fonte);
                Data.setFont(Fonte);
     
     
                Informacoes_do_Autor.setLayout(Layout1);
                Informacoes_Tecnicas.setLayout(Layout2);
     
     
                Informacoes_do_Autor.add(Nome_do_Autor);
                Informacoes_do_Autor.add(Cidade_do_Autor);
                Informacoes_do_Autor.add(Site_do_Codigo);
                Informacoes_do_Autor.add(Endereco_do_Jogo_da_Memoria);
     
     
                Informacoes_do_Autor.setPreferredSize(new Dimension (230,140));
                Informacoes_do_Autor.setBackground(Color.WHITE);
                Informacoes_do_Autor.setBorder(BorderFactory.createTitledBorder(null, "Programador",
                    TitledBorder.DEFAULT_JUSTIFICATION,
                    TitledBorder.DEFAULT_POSITION, new Font("Tahoma", 1, 14)));
     
                Informacoes_Tecnicas.add(Sistema_Operacional);
                Informacoes_Tecnicas.add(Plataforma);
                Informacoes_Tecnicas.add(Ultima_Atualizacao);
                Informacoes_Tecnicas.add(Data);
     
                Informacoes_Tecnicas.setPreferredSize(new Dimension (200,140));
                Informacoes_Tecnicas.setBackground(Color.WHITE);
                Informacoes_Tecnicas.setBorder(BorderFactory.createTitledBorder(null, "Sistema",
                    TitledBorder.DEFAULT_JUSTIFICATION,
                    TitledBorder.DEFAULT_POSITION, new Font("Tahoma", 1, 14)));
     
                Geral.add(Informacoes_do_Autor);
                Geral.add(Informacoes_Tecnicas);
                Geral.add(Fechar_Sobre_JogoDaMemoria);
     
                Geral.setFont(Fonte);
                add(Geral);
     
                getRootPane().setDefaultButton(Fechar_Sobre_JogoDaMemoria);
                Fechar_Sobre_JogoDaMemoria.setSelected(true);
                Geral.setBackground(Color.WHITE);
     
     
                this.setTitle("Sobre o Jogo da Memória");
                this.setSize(500,210);
                this.setResizable(false);
                this.setLocation(X+20,Y+40);
             
                Fechar_Sobre_JogoDaMemoria.addActionListener(new ActionListener(){
                 
                    public void actionPerformed(ActionEvent event){
                     
                        setVisible(false);
                        dispose();
                     
                    }
                });
        }  
    }


    public static void main(String [] args){
     
        new JogoDaMemoria();
     
    }  
}




Palavras-Chaves: Random, Novo Jogo, Reiniciar, Estatística, Sobre,  Pontuação, Java.



Artigos relacionados em Java:

• Criando um JFrame em Java
• Calculadora simples em Java
• Barra de Carregamento em Java
• IMC em Java
• Eventos com JButton (mudando a cor do JPanel) em Java
• Jogo da Forca em Java
• Calculadora Completa em Java
• Desenhando figuras com o mouse em Java

Feito no NetBeans-5.5.1 | Executável

Feito no NetBeans-5.5.1 | Executável

Feito no NetBeans-5.5.1 | Executável

Feito no NetBeans-5.5.1 | Executável

Desenhando figuras com o mouse em Java

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JToolBar;

// Esta é uma ferramenta gráfica de desenho básica no qual se podem criar figuras simples.

public class Desenhando{
       
    public static void main(String args[]){
       
        JanelaComandos JanelaComandos = new JanelaComandos();
       
        JanelaComandos.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JanelaComandos.setSize(1000,500);
        JanelaComandos.setVisible(true);
        JanelaComandos.setLocationRelativeTo(null);
   
    } 
}

// Autor: João Matheus Santos Assis

class JanelaComandos extends JFrame{
       
    // Barra de Ferramenta com os botões necessários
    private JToolBar Barra_De_Ferramenta = new JToolBar();
    private JButton Retangulo = new JButton("Retângulo");
    private JButton Circulo = new JButton("Circulo");
    private JButton Reta = new JButton("Reta");
    private JButton Editar_Cor = new JButton("Editar Cor");
   
   
    private Gerador_Desenho Panel_Desenho = new Gerador_Desenho();
   
    private Color Cor_da_Figura = Color.RED;
    private Color Ultima_Cor = Color.RED;


    private JLabel Status = new JLabel("  Forma ativa: Retângulo");
   
   
   
    public JanelaComandos() {
        super("Desenvolvedor Gráfico");
       
        // Adicionando os componentes
        Barra_De_Ferramenta.add(Retangulo);
        Barra_De_Ferramenta.add(Circulo);
        Barra_De_Ferramenta.add(Reta);
        Barra_De_Ferramenta.add(Editar_Cor);
       
        // Cor de fundo da Barra de Status
        Status.setBackground(Color.WHITE);
       
        add(Barra_De_Ferramenta, BorderLayout.NORTH);               
        add(Panel_Desenho, BorderLayout.CENTER);               
        add(Status, BorderLayout.SOUTH);
       
        Eventos_Desenhando Eventos = new Eventos_Desenhando();
        Retangulo.addActionListener(Eventos);
        Circulo.addActionListener(Eventos);
        Reta.addActionListener(Eventos);
        Editar_Cor.addActionListener(Eventos);
        
    }
   
   
   
    private class Eventos_Desenhando implements ActionListener{
       
        /* A variável Forma determinará qual figura deverá ser desenhada,
         se seu valor for 0 será desenhado um Retângulo, caso for 1
         um Círculo, 2 será uma reta*/
        int Forma = 0;
       
        public void actionPerformed(ActionEvent event) {           
           
           
            if (event.getSource()== Retangulo){
                Forma=0;
                Status.setText("  Forma ativa: Retângulo");
                repaint();
            }           
           
            if (event.getSource() == Circulo){
                Forma=1;
                Status.setText("  Forma ativa: Circulo");
                repaint();
            }
           
            if (event.getSource() == Reta){
                Forma=2;
                Status.setText("  Forma ativa: Reta");
                repaint();
            }
           
            // Criando uma Caixa de Cor para mudar a cor da linha
            if (event.getSource() == Editar_Cor){
                Cor_da_Figura = JColorChooser.showDialog(JanelaComandos.this,
                        "Editando Cor da Figura", Cor_da_Figura);
                if (Cor_da_Figura != null){
                    Ultima_Cor = Cor_da_Figura;
                }
            }
            // Enviando a Forma a ser desenhada e a cor da linha
            Panel_Desenho.setForma( Forma, Ultima_Cor );
           
        }
    }
}



class Gerador_Desenho extends JPanel implements MouseListener, MouseMotionListener{
 
        Dimension Dimensao = Toolkit.getDefaultToolkit().getScreenSize();  
 
        // Criando local onde ficará armazenadas as imagens.
       
        private BufferedImage Buffered_da_Imagem = new BufferedImage((int)Dimensao.getWidth(),
                (int)Dimensao.getHeight(), BufferedImage.TYPE_INT_RGB);
       
        private BufferedImage Buffered_da_Reta = new BufferedImage((int)Dimensao.getWidth(),
                (int)Dimensao.getHeight(), BufferedImage.TYPE_INT_RGB);
       
        private int valor;
        private Color Ultima_Cor;
        private int x;
        private int y;  
       
       
        public Gerador_Desenho(){
           
            Graphics g_Imagem = Buffered_da_Imagem.createGraphics();
            g_Imagem.setColor(Color.WHITE);
            g_Imagem.fillRect(0, 0, Buffered_da_Imagem.getWidth(), Buffered_da_Imagem.getHeight());
            g_Imagem.dispose();
           
            Graphics g_Reta = Buffered_da_Reta.createGraphics();  
            g_Reta.setColor(Color.WHITE);  
            g_Reta.fillRect(0, 0, Buffered_da_Reta.getWidth(), Buffered_da_Reta.getHeight());
            g_Reta.dispose();
           
            if (Ultima_Cor == null)
                Ultima_Cor = Color.RED;
       
            this.addMouseListener(this);
            this.addMouseMotionListener(this);
        }  
       
           
           
        public void paintComponent(Graphics g) {  
            super.paintComponent(g);  
           
            g.setColor(Color.WHITE);
            g.fillRect(0, 0, Buffered_da_Imagem.getWidth(), Buffered_da_Imagem.getHeight());
            g.drawImage(Buffered_da_Reta, 0, 0, null);
          
            g.dispose();  
        }
       
                       
             
        public void setForma(int newValor, Color newCor){
            valor = newValor;
            Ultima_Cor = newCor;
        }
       
       
       
        public void paint_retangulo(int x2, int y2){
           
            Graphics2D g_retangulo = Buffered_da_Reta.createGraphics();  
            g_retangulo.drawImage(Buffered_da_Imagem, 0, 0, null);
            g_retangulo.setColor(Ultima_Cor);
           
            g_retangulo.setStroke(new BasicStroke(2.0f));
           
            if (x2>x && y2>y)
                g_retangulo.drawRect(x,y,x2-x,y2-y);
            if (x2>x && y>y2)
                g_retangulo.drawRect(x,y2,x2-x,y-y2);
            if (x>x2 && y>y2)
                g_retangulo.drawRect(x2,y2,x-x2,y-y2);
            if (x>x2 && y2>y)
                g_retangulo.drawRect(x2,y,x-x2,y2-y);  
               
            g_retangulo.dispose();
        }
               
               
               
               
        public void paint_Circulo(int x2, int y2){
           
            Graphics2D g_Circulo = Buffered_da_Reta.createGraphics();  
            g_Circulo.drawImage(Buffered_da_Imagem, 0, 0, null);   
            g_Circulo.setColor(Ultima_Cor);
           
            g_Circulo.setStroke(new BasicStroke(2.0f));
           
            if (x2>x && y2>y)
                g_Circulo.drawOval(x,y,x2-x,y2-y);
            if (x2>x && y>y2)
                g_Circulo.drawOval(x,y2,x2-x,y-y2);
            if (x>x2 && y>y2)
                g_Circulo.drawOval(x2,y2,x-x2,y-y2);
            if (x>x2 && y2>y)
                g_Circulo.drawOval(x2,y,x-x2,y2-y);
               
            g_Circulo.dispose();    
        }
               
               
               
        public void paint_Reta(int x2, int y2){
           
            Graphics2D g_Reta = Buffered_da_Reta.createGraphics();  
            g_Reta.drawImage(Buffered_da_Imagem, 0, 0, null);
            // Definindo a Cor da linha
            g_Reta.setColor(Ultima_Cor);
           
            // Definindo a espessura da linha
            g_Reta.setStroke(new BasicStroke(2.0f));
           
            // Desenhando a linha
            g_Reta.drawLine(x, y, x2, y2);
           
            // Atualizando a tela
            g_Reta.dispose();
        }
       
         
       
       
       
        // Capturando os Eventos com o mouse
        public void mousePressed(MouseEvent e) { 
      
            // Obtendo as coordenadas do mouse
            x = e.getX();  
            y = e.getY();  
      
            // Chamando o método Forma
            Forma(e.getX(), e.getY());
      
            repaint(); 
        }    
       
       
        public void mouseReleased(MouseEvent e) {
       
            Forma(e.getX(), e.getY());
           
            Graphics g_Imagem = Buffered_da_Imagem.createGraphics();
            g_Imagem.drawImage(Buffered_da_Reta, 0, 0, null);
            g_Imagem.dispose();  
 
            repaint(); 
        }          
       
       
        public void mouseClicked(MouseEvent e) {
            x = e.getX();  
            y = e.getY();
           
            Forma(e.getX(), e.getY());
           
            repaint(); // Atualiza a imagem do Jpanel  
        }
       
       
        public void mouseEntered(MouseEvent e) {
        }
       
       
        public void mouseExited(MouseEvent e) {
        }
       
       
        public void mouseDragged(MouseEvent e) {

            Forma(e.getX(), e.getY()); 
           
            repaint();
        }
       
       
        public void mouseMoved(MouseEvent e) {
        }
       
       
        public void Forma(int x, int y){
           
            if (valor==0)
                paint_retangulo(x, y);
            if (valor==1)
                paint_Circulo(x, y);
            if (valor==2)
                paint_Reta(x, y);
           
        }
}



Palavras-Chaves: Retângulo, Círculo, Reta, Editar Cor, Desenhando com o mouse,
espessura da linha, Cor de fundo, Forma, JToolBar, JButton, JLabel, Barra de Status, BorderLayout, JColorChooser, Java.


Artigos relacionados em Java:

• Desenhando Espiral Quadrático em Java
• Desenhando Circulos côncentricos no meio da tela em Java
• Reproduzindo a palheta RGB em Java
• Criando um JFrame em Java
• Desenhando linhas a partir do canto superior esquerdo em Java
• Calculadora simples em Java
• Eventos com JButton (mudando a cor do JPanel) em Java
• Jogo da Forca em Java
• Calculadora Completa em Java

Feito no NetBeans-5.5.1 | Executável



Feito no NetBeans-5.5.1 | Executável