Desenvolvimento do Jogo da Velha em Java

Prévia do material em texto

INSTITUTO DE CIÊNCIAS EXATAS E TECNOLOGIA 
 
CURSO: CIÊNCIA DA COMPUTAÇÃO 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
UNIVERSIDADE PAULISTA – UNIP 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Índice 
1.	 OBJETIVO MOTIVAÇÃO DO TRABALHO ................................................. 2	
2.	 INTRODUÇÃO ............................................................................................. 4	
3.	 REGRAS DO JOGO E CONCEITOS .......................................................... 5	
4.	 PLANO DE DESENVOLVIMENTO DO JOGO ............................................ 7	
4.1.	 Elementos e Ferramentas Utilizadas .......................................................... 7	
5.	 PROJETO .................................................................................................... 8	
6.	 RELATÓRIO COM LINHAS DE CÓDIGO ................................................. 11	
7.	 BIBLIOGRÁFIA ......................................................................................... 13	
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1. OBJETIVO MOTIVAÇÃO DO TRABALHO 
 
Ao inicio do semestre, foi proposto junto aos professores e alunos, a elaboração 
de um jogo com a utilização de Interface Gráfica na linguagem Java. 
 
Após reuniões e orientações do corpo doente, ficou decidido entre os integrantes 
do grupo a criação do famoso “Jogo da Velha”, conhecido mundialmente, o Jogo 
da Velha é passatempo divertido entre adultos e crianças. Assim, aplicando 
todos os conceitos teóricos e programáticos adquiridos ao longo do semestre, 
em especial, das seguintes disciplinas: “Estrutura de Dados” e “Aplicação de 
Linguagens de Programação Orientadas a Objetos”. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2. INTRODUÇÃO 
 
Lucas e Rafael, dois jovens alunos do 4˚ semestre do curso de Ciência da 
Computação da Universidade Paulista Unip campus JK, ao receberem a 
proposta de seus docentes em relação a Atividades Praticas Supervisionadas 
do semestre, tiveram a ideia de criar o projeto de Jogo que fosse simples e de 
conhecimento e interesse das pessoas. Logo após várias ideias, chegaram a 
conclusão do desenvolvimento do famoso Jogo da Velha. 
 
Após meses de levantamentos e desenvolvimento, o Jogo foi desenvolvido e 
com isso aprofundado os conteúdos de aula de sala. 
 
Assim, hoje temos a honra de apresentar o nosso trabalho, para poder 
compartilhar um pouco sobre os nossos métodos e desenvolvimento do game. 
 
Agradecemos aos nossos docentes: Cicero, Geraldo e Fabio pelo apoio e auxilio 
em sanar todas as nossas duvidas e dificuldades ao desenvolvimento desse 
projeto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3. REGRAS DO JOGO E CONCEITOS 
 
Em se tratando de jogos e passatempos, preferencialmente onde a criança utiliza 
uma caneta e um papel, tudo é válido para aguçar a perspicácia e inteligência 
da criança. 
 
Há muitas brincadeiras antigas como por exemplo o Jogo da Velha que fez 
sucesso nas gerações passadas e continua a fazer sucesso entre as crianças 
de hoje. 
 
O Jogo da Velha ou Jogo do Galo como é conhecido em Portugal, é um jogo de 
regras extremamente simples, que não traz grandes dificuldades para seus 
jogadores e é facilmente aprendido. 
 
O seu nome Jogo da Velha originou-se na Inglaterra quando mulheres ao fim de 
tarde se reuniam para tomar o chá, bordar e brincar. O Jogo da Velha era jogado 
pelas senhoras de mais idade já que as mesmas não enxergavam bem, e não 
podiam então realizar seus bordados; a opção de diversão então era o Jogo da 
Velha. 
 
Mas muita gente acredita que a origem do jogo seria ainda mais antiga, pois 
foram encontrados tabuleiros escavados em rochas em templos do antigo Egito, 
que provavelmente foram feitos por escravos há mais de 3.500 anos atrás. 
 
O tabuleiro é uma matriz de três linhas por três colunas. Dois jogadores 
escolhem uma marcação cada um, geralmente um círculo (O) e um xis (X). 
 
Os jogadores jogam alternadamente, uma marcação por vez, numa lacuna que 
esteja vazia. 
 
O objetivo é conseguir três círculos ou três xis em linha, quer horizontal, vertical 
ou diagonal, e ao mesmo tempo, quando possível, impedir o adversário de 
ganhar na próxima jogada. 
 
Quando um jogador conquista o objetivo, costuma-se riscar os três símbolos, se 
os dois jogadores jogarem sempre da melhor forma, o jogo terminará sempre em 
empate. A lógica do jogo é muito simples, de modo que não é difícil deduzir ou 
decorar todas as possibilidades para efetuar a melhor jogada – apesar de o 
número total de possibilidades ser muito grande, a maioria delas é simétrica, 
além de que as regras são simples. 
 
Por este motivo, é muito comum que o jogo empate (ou “dê velha”). 
 
1. Ganhar: Se você tem duas peças numa linha, ponha a terceira. 
�
2. Bloquear: Se o oponente tiver duas peças em linha, ponha a terceira para 
bloqueá-lo. 
�
3. Triângulo: Crie uma oportunidade em que você poderá ganhar de duas 
maneiras. 
�
4. Bloquear o Triângulo do oponente 
�
5. Centro: Jogue no centro. 
�
6. Canto vazio: jogue num canto vazio. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4. PLANO DE DESENVOLVIMENTO DO JOGO 
 
Para o desenvolvimento deste Jogo, separamos em duas fases: 
 
Fase I Analise de regras do jogo, e pesquisa de métodos e aplicações 
semelhantes já desenvolvidas. 
 
Fase II Desenvolvimento da aplicação colocando em práticas todos os métodos 
pesquisados. 
 
4.1. Elementos e Ferramentas Utilizadas 
 
Interfaces gráficas com Swing 
"Não tenho medo dos computadores. Temo a falta deles." 
 
Interfaces Gráficas em Java são bibliotecas gráficas são bastante simples no 
que diz respeito a conceitos necessários para usá-las. A complexidade no 
aprendizado de interfaces gráficas em Java reside no tamanho das bibliotecas e 
no enorme mundo de possibilidades; isso pode assustar, em um primeiro 
momento. 
 
AWT e Swing são bibliotecas gráficas oficiais inclusas em qualquer JRE ou JDK. 
Além destas, existem algumas outras bibliotecas de terceiros, sendo a mais 
famosa, o SWT - desenvolvida pela IBM e utilizada no Eclipse e em vários outros 
produtos. 
 
Componentes como Swing traz muitos componentes para usarmos: botões, 
entradas de texto, tabelas, janelas, abas, scroll, árvores de arquivos e muitos 
outros. Durante o treinamento, veremos alguns componentes que nos ajudarão 
a fazer as telas do Argentum. 
 
A biblioteca do Swing está no pacote javax.swing (inteira, exceto a parte de 
acessibilidade, que está em javax.accessibility). 
 
JFrame, JPanel e JButton 
 
Os componentes mais comuns já estão frequentemente prontos e presentes na 
API do Swing. Contudo, para montar as telas que são específicas do seu projeto, 
será necessário compor alguns componentes mais básicos, como JFrames, 
JPanels, JButtons, etc. 
 
A tela que vamos para o Argentum terá vários componentes. Para começarmos, 
faremos dois botões importantes: um dispara o carregamento do XML e outro 
permite ao usuário sair da aplicação. 
 
Tratando Eventos 
 
O Swing, como a maioria dos toolkits gráficos, nos traz o conceito de Listeners 
(ouvintes), que são interfaces que implementamos para sobrescrever métodos 
que serão disparados pelas ações sobre um botão, por exemplo. Os eventos do 
usuário são capturados pelo Swing que chama o método que implementamos. 
 
5. PROJETO 
 
A estrutura do projeto consiste basicamente em duas classes: JogoDaVelha.java 
e Jogo.java. 
 
Abaixo a classe JogoDaVelha, onde está contido o método main, que instancia 
um objeto do tipo Jogo, classe que contem toda estrutura e funcionalidadedo 
game. 
 
public class JogoDaVelha extends JFrame{ 
 public static void main(String[] args) { 
 Jogo Tela = new Jogo(); 
 Tela.setDefaultCloseOperation(EXIT_ON_CLOSE); 
 Tela.setResizable(false); 
 } 
} 
Ao iniciar o jogo, a temos a inicial padrão de um jogo da velha, porém com 
botões, que ao serem clicados exibirão o X ou O. 
 
 
Iniciando o jogo, o primeiro botão clicado sempre será o X, alternando para O, 
seguindo as regras básicas do jogo da velha para determinar o vencedor, ou se 
deu velha. 
 
 
 
Quando o jogo termina, aparece uma caixa de texto mostrando qual letra foi 
vencedora, ou se deu velha. 
 
 
 
 
 
Ao clicar ok, será exibida outra caixa de texto, com a opção de jogar novamente, 
que ao clicar sim, será iniciado um novo jogo, e ao clicar não o jogo será fechado. 
 
 
 
 
6. RELATÓRIO COM LINHAS DE CÓDIGO 
 
JogoDaVelha.java: 
package jogodavelha; 
 
import javax.swing.JFrame; 
 
public class JogoDaVelha extends JFrame{ 
 
 public static void main(String[] args) { 
 Jogo Tela = new Jogo(); 
 Tela.setDefaultCloseOperation(EXIT_ON_CLOSE); 
 Tela.setResizable(false); 
 } 
} 
 
Jogo.java: 
package jogodavelha; 
 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
import javax.swing.border.EmptyBorder; 
 
public class Jogo extends JFrame { 
 JButton cor; 
 JButton [] botao; 
 JPanel painelJogo; 
 int vezJogador; 
 String simbolo; 
 
 public Jogo() {//Construtor 
 super("Jogo da Velha"); //Titulo da janela 
 ((JComponent)getContentPane()).setBorder(new EmptyBorder(5, 5, 5,5)); 
 
 painelJogo = new JPanel(); 
 painelJogo.setLayout(new GridLayout(3,3,10,10)); 
 cor = new JButton(); 
 botao = new JButton[9]; 
 
 for (int i =0; i < 9; i++) { 
 botao[i] = new JButton(); 
 } 
 
 //Formatação dos botões do painel 
 for (int i=0;i<9;i++) { 
 int j=i; 
 botao[i].setFont(new Font("Calibri", Font.BOLD, 70)); 
 botao[i].addActionListener(new ActionListener(){ 
 @Override 
 public void actionPerformed(ActionEvent e) { 
 Jogada(j); 
 Vencedor(); 
 Velha(); 
 } 
 }); 
 painelJogo.add(botao[i]); 
 } 
 
 add(painelJogo); 
 setLocation(470, 200); 
 setSize(400,400); 
 setVisible(true); 
 } 
 //Método que verifica de quem é a vez e seu simbolo 
 public void Jogada(int simbol) { 
 if (vezJogador == 0) { 
 simbolo = "X"; 
 vezJogador = 1; 
 } else { 
 simbolo = "O"; 
 vezJogador = 0; 
 } 
 botao[simbol].setText(simbolo); 
 botao[simbol].setEnabled(false); 
 } 
 public void Vencedor() { 
 //Vencedor com base nas linhas 
 for (int i=0; i< 7; i+=3) { 
 if ( botao[i].getText() == botao[i+1].getText() && botao[i+1].getText() == 
botao[i+2].getText() && botao[i].getText() != "") { 
 JOptionPane.showMessageDialog(null, "O vencedor foi: 
"+botao[i].getText(), "Vencedor", WIDTH); 
 Restart(); 
 } 
 } 
 //Vencedor com base nas colunas 
 for (int i = 0; i<3; i++) { 
 if (botao[i].getText() == botao[i+3].getText() && botao[i].getText() == 
botao[i+6].getText() && botao[i].getText() != "") { 
 JOptionPane.showMessageDialog(null, "O vencedor foi: 
"+botao[i].getText(), "Vencedor", WIDTH); 
 Restart(); 
 } 
 } 
 //Vencedor com base nas diagonais 
 if ((botao[0].getText() == botao[4].getText() && botao[4].getText() == 
botao[8].getText() && botao[4].getText() != "") || 
 (botao[2].getText() == botao[4].getText() && botao[4].getText() == 
botao[6].getText() && botao[4].getText() != "")){ 
 JOptionPane.showMessageDialog(null, "O vencedor foi: 
"+botao[4].getText(), "Vencedor", WIDTH); 
 Restart(); 
 } 
 } 
 //Caso dar velha 
 public void Velha(){ 
 int velha = 0; 
 for (int i=0; i<9; i++) { 
 if (botao[i].getText() != "") 
 velha++; 
 } 
 if (velha == 9) { 
 JOptionPane.showMessageDialog(null, "Deu velha !!"); 
 Restart(); 
 } 
 } 
 //Iniciar um novo jogo ou fechar janela 
 public void Restart() { 
 int dialogButton = JOptionPane.YES_NO_OPTION; 
 int dialogResult = JOptionPane.showConfirmDialog(this, "Deseja jogar 
novamente", "Restart", dialogButton); 
 if(dialogResult == 0) { 
 for (int i=0; i<9; i++) { 
 botao[i].setText(""); 
 botao[i].setEnabled(true); 
 } 
 } else { 
 System.exit(0); 
 } 
 } 
} 
 
7. BIBLIOGRÁFIA 
 
https://www.bigmae.com/regras-jogo-da-velha/ 
Acesso em: 24/10/2018 
 
 
https://www.portugal-a-programar.pt/forums/topic/61964-como-fazer-a-
interface-gr%C3%A1fica-de-um-pequeno-jogo/ 
Acesso em: 02/11/2018 
 
https://www.youtube.com/watch?v=5UPKApqVN-A 
Acesso em: 15/11/2018 
 
http://clubedosgeeks.com.br/programacao/java/fazendo-um-jogo-da-velha-em-
java-no-netbeans-parte-1-projeto-tela-do-jogo-e-inicio-do-codigo 
Acesso em: 19/11/2018