Você está na página 1de 82

Cincia da Computao

DESENVOLVIMENTO DE UM JOGO COM


UTILIZAO DE INTERFACE GRFICA

Karen A de Oliveira Leme RA C221643


Joo Vitor M. Bonachini da Silva RA C272710
Celso Apolinrio Prazeres Junior RA C048151
Higor Henrique Sousa de Oliveira RA B986484
Leocadio Benez Neto RA C152609

Araatuba, SP 2015
LISTA DE FIGURAS

2-1 Movimentao do Peo......................................................................................... 8


2-2 Movimentao do Rei............................................................................................ 9
2-3 Movimentao da Rainha...................................................................................... 9
2-4 Movimentao do Cavalo .................................................................................... 10
2-5 Movimentao da Torre ...................................................................................... 10
2-6 Movimentao do Bispo ...................................................................................... 11
2-7 Modos de Captura no Xadrez ............................................................................. 11
2-8 Movimento Roque ............................................................................................... 12
2-9 Posio antes da captura do peo. ..................................................................... 13
2-10 Posio aps a captura do peo. ...................................................................... 13
2-11 Posio em que o Rei est a ser atacado por uma pea. ................................. 15
2-12 Posio em que o Rei est em xeque ............................................................... 15
2-13 Sem movimentos. Jogo termina com empate. ................................................. 16
4-1 Classe responsvel pelos elementos criados para o jogo. ................................. 21
4-2 Classe responsvel pelos elementos de menu do jogo. ..................................... 22
4-3 Classe responsvel pelo desenho, verificao de rede e regras do jogo. .......... 23
4-4 Classe responsvel pelos jogadores definidos no campo e suas peas ............. 24
4-5 Classe responsvel pelos atributos e mtodos de cada pea. ............................ 25
4-6 Classe responsvel pela criao e consultas no banco de dados do programa. 26
4-7 Estrutura completa do programa ......................................................................... 27
6-1 Menu do programa .............................................................................................. 70
6-2 Tabuleiro ............................................................................................................. 71
6-3 Menu do programa .............................................................................................. 72
6-4 Janela Jogador 1 ................................................................................................. 72
6-5 Representao de um jogo Multiplayer ............................................................... 73
6-6 Peo ............................................................................................................... 74
6-7 Rei ............................................................................................................... 74
6-8 Torre ............................................................................................................... 75
6-9 Cavalo ............................................................................................................... 75
6-10 Bispo ............................................................................................................... 76
6-11 Rainha ............................................................................................................... 77
6-12 Promoo do Peo ........................................................................................... 78
6-13 Xeque-Mate....................................................................................................... 78

SUMRIO

CAPTULO 1 - INTRODUO.................................................................................... 5
1.1 Objetivos ............................................................................................................... 5
1.2 Introduo ............................................................................................................. 5

CAPTULO 2 - REGRAS E FUNCIONAMENTO ........................................................ 8

2.1 Peas .................................................................................................................... 8


2.2 Captura................................................................................................................ 11
2.3 Movimentos Especiais ......................................................................................... 12
2.3.1 Roque ............................................................................................................... 12
2.3.2 Condies para fazer o Roque ......................................................................... 12
2.3.3 En passant ou Ao passar............................................................................. 13
2.3.4 Condies para capturar em passant ............................................................ 14
2.4 Promoo do Peo .............................................................................................. 14
2.5 Xeque ................................................................................................................ 14
2.6 Mate .................................................................................................................... 15
2.6.1 Condies para o Mate .................................................................................... 16
2.7 Empate ................................................................................................................ 16

CAPTULO 3 - PLANO DE DESENVOLVIMENTO .................................................. 17

3.1 Escopo ................................................................................................................ 17


3.2 Analise geral do Projeto ...................................................................................... 17
3.2.1 Objetivos e finalidades do projeto .................................................................... 17
3.2.2 Algumas restries do Projeto .......................................................................... 17
3.2.3 Evoluo do plano de Desenvolvimento .......................................................... 18
3.3 Organizao do Projeto ....................................................................................... 18
3.3.1 Estrutura Organizacional .................................................................................. 18
3.3.2 Funes e Responsabilidades ......................................................................... 18
3.4 Processo de Gerenciamento ............................................................................... 19
3.4.1 Estimativas do Projeto quanto ao tempo e custo ............................................. 19
3.4.2 Recursos Utilizados .......................................................................................... 19
3.4.3 Controle de Cronograma .................................................................................. 20
3.4.4 Anlise de Riscos ............................................................................................. 20

CAPTULO 4 - PROJETO ......................................................................................... 21

4.1 Criao ................................................................................................................ 21


4.2 Classes................................................................................................................ 21
4.2.1 GameMain ........................................................................................................ 21
4.2.2 GameStart ........................................................................................................ 22
4.2.3 ChessBoard...................................................................................................... 22
4.2.4 ChessPlayer ..................................................................................................... 24
4.2.5 ChessPiece ...................................................................................................... 24
4.2.6 GameConnection ............................................................................................. 26

CAPTULO 5 - CDIGO FONTE .............................................................................. 28

5.1 Cdigo Fonte ....................................................................................................... 28


5.1.1 GameMain.java ................................................................................................ 28
5.1.2 GameStart.java ................................................................................................ 31
5.1.3 ChessBoard.java .............................................................................................. 38
5.1.4 ChessPiece.java ............................................................................................... 51
5.1.5 ChessPlayer.java ............................................................................................. 55
5.1.6 GameConnection.java ...................................................................................... 57
5.1.7 Bishop.java ....................................................................................................... 61
5.1.8 King.java........................................................................................................... 62
5.1.9 Knight.java ........................................................................................................ 64
5.1.10 Pawn.java ....................................................................................................... 65
5.1.11 Queen.java ..................................................................................................... 67
5.1.12 Rook.java ....................................................................................................... 68

CAPTULO 6 - PROGRAMA..................................................................................... 70

6.1 Exemplo de execuo do programa .................................................................... 70


6.1.1 Menu ................................................................................................................ 70
6.1.2 Janela nica..................................................................................................... 71
6.1.3 Multiplayer ........................................................................................................ 71
6.2 Movimento das peas ......................................................................................... 73
6.2.1 Peo ................................................................................................................. 73
6.2.2 Rei ...................................................................... Error! Bookmark not defined.
6.2.3 Torre ................................................................................................................. 74
6.2.4 Cavalo .............................................................................................................. 75
6.2.5 Bispo ................................................................................................................ 76
6.2.6 Rainha .............................................................................................................. 76
6.3 Movimentos especiais ......................................................................................... 77
6.3.1 Promoo do Peo ........................................................................................... 77
6.3.2 Xeque Mate ................................................................................................... 78

CAPTULO 7 - BIBLIOGRFIA ................................................................................ 79


Captulo 1
CAPTULO 1 - INTRODUO

1.1 Objetivos

Pesquisar e desenvolver um jogo multiplayer de Xadrez. Esse jogo se


assemelha ao Xadrez tradicional de mesa, com suas caractersticas sendo
retratadas em um ambiente virtual. Este jogo contar com funcionalidades como: a
de mover peas, comer peas do outro jogador, implementao de algumas regras
do Xadrez e conexo entre dois computadores pela rede.

1.2 Introduo

O jogo de xadrez segundo os pesquisadores teve sua origem a partir de


varias civilizaes, apesar de que a maioria aponta a ndia como sendo o verdadeiro
local da origem do jogo, em meados do sculo VI D.C. Acredita-se que o xadrez
tenha surgido com regras diferentes das definidas atualmente, mas com o nome de
Chaturanga, em snscrito, linguagem da ndia. Depois, recebeu o nome persa de
Shatranj, no sculo VII, e acredita-se que as regras tenham sido diferentes do
xadrez indiano.
Em 1913, foi escrito o livro Uma Histria do Xadrez, por Harold James
Ruthven Murray. A obra atribua a origem do xadrez ndia e durante anos, essa
teoria permaneceu como certa.
Mas com o tempo, novas descobertas acerca da origem do xadrez passaram
a surgir, a ponto de fazerem as pessoas refletirem se o chaturanga era realmente a
nica possibilidade.
Para Yuri Averbakh, um grande mestre do xadrez, outros jogos deveriam ser
levados em questo quanto influncia, tendo, por exemplo, os gregos e egpcios
que tinham jogos de tabuleiro que simulavam corridas.
De acordo com Jean-Louis Cazaux, quatro hipteses podem ser levadas em
conta:
O xadrez surgiu na Prsia.
O xadrez surgiu na China.
O xadrez persa e chins tem o mesmo ancestral.
O xadrez chins e o persa tiveram o poder de influenciar um ao outro quanto
sua formao.
As peas evoluram ao longo do tempo, tanto na estrutura quanto aos
movimentos. Antigamente, o bispo era o elefante e podia se movimentar pelas
diagonais, mas andando apenas duas casas por vez. A dama era o vizir, e andava
apenas uma casa nas diagonais; os pees no tinham o privilgio de poder andar
duas casas no movimento inicial e no existia o roque.
As regras passaram a sofrer essas alteraes em meados de 1200 e
aproximadamente em 1475, nasceu o xadrez com as regras como so at os dias de
hoje. O local onde passaram a definir as regras como so atualmente tem duas
verses: uns acreditam que foi na Itlia, enquanto outros acreditam ter sido na
Espanha.
Com o passar do tempo, as peas comearam a adquirir seus novos
movimentos e a dama passou a ser a pea mais poderosa do jogo.
A Frana passou a conquistar o espao enxadrstico no sculo XVIII, tendo o
msico Andr Philidor como mestre e Louis de la Bourdonnais como vencedor de
uma famosa srie de matches contra Alexander McDonnell, mais forte jogador de
xadrez da poca.
Os coffee houses (cafeterias) eram os locais mais frequentados pelos
enxadristas nas cidades europeias. Em 1843, foi publicada a primeira edio de uma
obra completa sobre a teoria do xadrez. Paul Rudolf von Bilguer e Tassilo von
Heydebrand foram os mestres germnicos que publicaram-na.
No Brasil Os registros de campeonatos de xadrez datam de 1927,
quando Joo de Souza Mendes Junior sagrou-se campeo em uma disputa no Rio
de Janeiro. Joo de Souza considerado um expoente da histria do xadrez
nacional. Em 1960 ocorreu o primeiro campeonato brasileiro de xadrez feminino, na
cidade de Brusque, Santa Catarina, e Dora Rbio foi a primeira campe. J no ano
de 1977, o Brasil tem como destaque Henrique Mecking, considerado o mais
importante enxadrista brasileiro.
Existem tambm diversos registros na literatura enxadrstica brasileira, de
obras que nortearam geraes como os livros Xadrez Bsico, Manual de Xadrez,
Xadrez de A a Z, Importncia do Xadrez, dentre outras.
Vimos como o xadrez evoluiu ao longo do tempo, mas apenas como prtica e
diverso para as pessoas. O esporte passou a se tornar profissional em 1851,
quando teve o primeiro torneio moderno, em Londres. Na disputa, o alemo Adolf
Anderssen foi o campeo.
Com a profissionalizao do xadrez, passou a ser feito um estudo mais
profundo sobre o esporte, e os nomes que mais se destacaram na poca foram Paul
Morphy e Wilhelm Steinitz. Entre os anos de 1857 e 1863, Morphy consagrou-se
campeo, vencendo o antigo campeo Adolf Anderssen.
Mas o primeiro campeo mundial de xadrez foi Steinitz, em 1886. Conquistou
o ttulo ao derrotar o mestre alemo Johannes Zukertort. Perdeu a conquista apenas
em 1894, ao ser derrotado pelo matemtico alemo Emanuel Lasker. O cubano Jos
Ral Capablanca, consagrado campeo durante os anos de 1921 a 1927, foi quem
acabou com o imprio germnico no xadrez.
Captulo 2
CAPTULO 2 - REGRAS E FUNCIONAMENTO

2.1 Peas

O Peo s se movimenta para frente, sendo a nica pea que no se


move para trs. No primeiro lance de cada peo ele pode avanar 1 ou 2
casas. partir do segundo lance de cada peo ele ir movimenta-se
apenas 1.

2-1 Movimentao do Peo

O Rei movimenta-se apenas 1 casa em qualquer direo. O Rei nunca


pode se movimentar para uma casa que esteja sob ataque ou capturar
uma pea que esteja defendida por uma pea adversria. No diagrama o
rei preto s pode ir para cima, pois indo para a esquerda ou em diagonal
estar sob ataque da torre branca. Quando estudarmos os movimentos
especiais veremos que existe uma situao em que o rei pode andar 2
casas.

2-2 Movimentao do Rei

Rainha, tambm conhecida como Dama, a pea mais poderosa do


xadrez, ela pode ir para frente ou para trs, para direita ou para a
esquerda, ou na diagonal, quantas casas quiser, mas no pode pular
nenhuma outra pea.

2-3 Movimentao da Rainha


O cavalo tem um movimento especial que parece a letra L. O cavalo se
movimenta 2 casas para frente ou para trs e em seguida 1 casa para a
direita ou para a esquerda, ou 2 casas para a direita ou para a esquerda
e em seguida 1 casa para frente ou para trs. O cavalo a nica pea
do xadrez que pode pular outras peas.

2-4 Movimentao do Cavalo

A torre se movimenta para frente e para trs, para a direita e para a


esquerda, quantas casas quiser, mas no pode pular nenhuma outra
pea.

2-5 Movimentao da Torre


O bispo se movimenta na diagonal mantendo-se sempre nas casas de
mesma cor que se encontrava no incio do jogo, podendo ir para frente e
para trs, quantas casas quiser, mas no pode pular nenhuma outra
pea.

2-6 Movimentao do Bispo

2.2 Captura

Capturar uma pea tom-la do adversrio. Com exceo do peo


todas as peas efetuam uma captura fazendo seu movimento prprio e
ocupando a casa que era ocupada por uma pea adversria. O peo efetua a
captura em diagonal ocupando a prxima casa direita ou esquerda.

2-7 Modos de Captura no Xadrez


2.3 Movimentos Especiais

Roque

um movimento que envolve a torre e o rei. o nico movimento do


xadrez em que voc mexe duas peas ao mesmo tempo e que o rei anda duas
casas. O objetivo do roque tirar o rei do centro do tabuleiro e deix-lo num
canto que mais protegido, ao mesmo tempo colocar a torre no centro do
tabuleiro para facilitar seus ataques.
No roque o rei anda duas casas em direo torre e a torre pula o rei
ficando ao seu lado.
O roque grande aquele que o rei anda em direo torre mais
distante.
O roque pequeno aquele em que o rei anda em direo torre mais
prxima.

2-8 Movimento Roque

Condies para fazer o Roque

O rei no pode ter se movimentado nenhuma vez;


A torre com quem se quer rocar no pode ter feito nenhum
movimento;
No pode haver peas entre o rei e a torre;
O rei no pode estar em xeque;
O rei no pode passar, nem terminar em casa que esteja sob o
ataque de pea adversria.

En passant ou Ao passar

uma forma especial de captura que o peo faz quando esse est na 5
fila (em relao ao jogador) e um peo adversrio avana duas casas
passando do seu lado.
Na posio do desenho o peo branco est na 5 fila e o peo preto avana
duas casas passando ao seu lado.

Para capturar o peo preto, o peo branco deve ocupar a casa por onde
passou o peo preto.

2-9 Posio antes da 2-10 Posio aps a


captura do peo. captura do peo.
Condies para capturar em passant

O seu peo deve estar na 5 fila;


O peo adversrio deve avanar duas casas passando ao seu
lado;
Somente no lance imediatamente aps o avano do peo
adversrio.

2.4 Promoo do Peo

Quando o peo chega do outro lado do tabuleiro ele promovido e deve


escolher tornar-se uma rainha ou torre ou bispo ou cavalo, sendo que
normalmente ele escolhe tornar-se uma rainha, por ser a pea mais poderosa.
Na teoria podemos ter at 9 rainhas da mesma cor em um jogo.

2.5 Xeque

Quando o Rei est a ser atacado por uma pea inimiga diz-se que este
est em xeque.
No final da jogada o Rei no pode ficar em cheque, se o jogador se
enganar e deixar o Rei nessa situao este ter de refazer o lance, neste caso
a regra piece tuche piece joue se possvel tem de ser respeitada.
Caso no seja possvel deixar o Rei sem estar em xeque a posio
passa a ser de mate e o jogo termina com derrota para o lado que se move.
2-11 Posio em que o Rei est a ser
atacado por uma pea.

2.6 Mate

O jogador que est em xeque no pode evitar que o seu Rei deixe de est-lo
no final do seu lance. Esta situao designada mate e implica a derrota para
o lado do Rei que est em xeque vitria para o outro.

2-12 Posio em que o Rei est em


xeque
Condies para o Mate

O rei no pode se movimentar para nenhuma casa sem ataque;


A pea que est atacando no pode ser capturada;
Nenhuma pea pode se colocar na frente da pea que est
atacando.

2.7 Empate

Quando o lado a mover no tem nenhuma jogada legal que possa realizar e
no est em xeque o jogo termina com empate.

2-13 Sem movimentos. Jogo


termina com empate.
Captulo 3
CAPTULO 3 - PLANO DE DESENVOLVIMENTO

3.1 Escopo

Este plano de desenvolvimento tem a finalidade de ser usado no projeto de


Xadrez, tal projeto faz parte da nossa APS semestral.

3.2 Analise geral do Projeto

Objetivos e finalidades do projeto

O projeto tem como seu objetivo aprimorar nossos conhecimentos com a


linguagem Java, assim como, a manipulao das suas interfaces grficas. Alm
disso, o projeto ir por a prova nossos conhecimentos adquiridos em sala de aula
sobre SQL e banco de dados.

Algumas restries do Projeto

O projeto deve ser feito em Java


Somente podero ser utilizados elementos grficos na linguagem Java
O projeto deve contar com recursos multiplayer
Evoluo do plano de Desenvolvimento

Devido no ser vivel o encontro do grupo para o desenvolvimento, os testes


e adaptaes sero realizados nas aulas.

3.3 Organizao do Projeto

Estrutura Organizacional

Para a facilitao no desenvolvimento, o projeto ser desenvolvido


unicamente pelo nosso colega, Joo Vitor M. Bonachini da Silva, o qual j possui
certa experincia na criao de jogos. A parte de testes ser feita pelo restante
grupo, que ir fazer a sua documentao.

Funes e Responsabilidades

Joo Vitor M. Bonachini da Silva. Desenvolvedor


Celso Apolinrio Prazeres Junior Responsvel pela elaborao e
gerenciamento de cronograma
(Testador)
Karen A. de Oliveira Leme Responsvel pela elaborao do
documento
(Testador)
Higor Henrique Sousa de Oliveira Responsvel pela elaborao do
documento
(Testador)
Leocdio Benez Neto Revisor
(Testador)
3.4 Processo de Gerenciamento

Estimativas do Projeto quanto ao tempo e custo

A estimativa para o desenvolvimento do projeto ser de cerca de um ms


(Outubro), essa estimativa se deve ao fato da limitao de delegaes de tarefas,
tornando o processo de desenvolvimento mais rpido, mas com maior
complexidade. Dentre essa estimativa j esto includo os testes e possveis
modificaes no cdigo.

Recursos Utilizados

Como o desenvolvimento ser feito na casa dos integrantes, o hardware ir


se alterar, pois cada integrante possui um computador diferente, mas seu
desenvolvimento e testes sero feitos basicamente em computadores e notebooks.
Para o desenvolvimento do jogo ser utilizado a linguagem Java, uma
linguagem de programao orientada a objetos que possui diversos elementos que
podem auxiliar no desenvolvimento, sua API Java2D facilita na criao e
modificao dos elementos grficos.
Ir ser utilizado a IDE Netbeans, nela temos certas facilidades na criao,
edio e manuteno de aplicaes criadas na linguagem Java. Com isso o tempo
para o desenvolvimento do projeto pode ser melhor aproveitado para as
implementaes importantes, no precisando nos preocupar com certas
particularidades do Java.
Por se tratar de um jogo com o fator de multiplayer local pela rede, ir ser
utilizado um banco de dados onde sero armazenadas as informaes de ambos os
jogadores. Para a parte de conexo foi criado um banco de dados MySql, por se
tratar de um banco de dados fcil de mexer, gratuito e bastante robusto, alm do
que, o banco em que estamos mais acostumados a utilizar nas aulas.
Para a documentao ser utilizado o Word, sua verso depende do
integrante do grupo, j que ser editado em seu prprio computador.
Controle de Cronograma

O controle do cronograma ficar a cargo de Celso A. Prazeres, ele verificar


se os prazos esto sendo atendidos. Alm disso, realizaremos reunies em sala de
aula para olharmos o andamento do trabalho e estipularmos datas para a entrega da
parte de cada um dos integrantes. Em caso de atraso em alguma das partes, ser
feito mudanas no cronograma afim de melhorias referente ao trabalho.

Anlise de Riscos

Sero realizadas reunies semanais para a verificao de algum risco no


prazo de entrega, caso positivo, modificaes sero discutidas entre o grupo.
Captulo 4
CAPTULO 4 - PROJETO

4.1 Criao

Para a criao do jogo sero necessrias diversas classes, cada uma com a
sua respectiva funo.

4.2 Classes

GameMain

Responsvel pela inicializao do frame que ir comportar os elementos


criados para o jogo.

4-1 Classe responsvel pelos


elementos criados para o jogo.
GameStart

Esta classe inicia um frame que ir comportar os elementos de menu, nele


podero ser escolhidos entre uma partida com multiplayer na mesma mquina ou
em rede, os campos contidos nesse frame serviro para a criao de uma conexo
com um banco de dados.

4-2 Classe responsvel pelos elementos de menu do jogo.

ChessBoard

Responsvel por desenhar o tabuleiro, fazer verificaes de rede, em caso de


multiplayer pela rede, e verificaes de regra de jogo.
4-3 Classe responsvel pelo desenho, verificao de rede e regras do jogo.
ChessPlayer

Como todo jogo de Xadrez, est classe representa os jogadores do jogo,


definindo o lado do campo e suas peas.

4-4 Classe responsvel pelos jogadores definidos no


campo e suas peas

ChessPiece

Essa classe funciona como uma genrica de pea onde ficam definido os
atributos e mtodos compartilhados por todas as peas. As classes Pawn, Queen,
Rook, Bishop, King e Knight, so classes que herdam os atributos e mtodos da
classe ChessPiece, cada classe faz a sobrescrita dos mtodos da classe
ChessPiece dependendo da necessidade de cada pea.
4-5 Classe responsvel pelos atributos e mtodos de cada pea.
GameConnection

Esta classe responsvel pela criao e consultas no banco de dados.

4-6 Classe responsvel pela criao e consultas no banco de


dados do programa.
Aqui podemos ver como ficou a estrutura completa do programa com suas
ligaes, relacionamentos e heranas.

4-7 Estrutura completa do programa


Captulo 5
CAPTULO 5 - CDIGO FONTE

5.1 Cdigo Fonte

GameMain.java

package aegis;

import java.awt.Dimension;

/**
*
* @author JV Master
*/
public class GameMain extends javax.swing.JFrame {

/**
* Creates new form GameMain
*/
public GameMain() {
initComponents();

this.setResizable(false);
this.pack();
this.setPreferredSize(new Dimension(400, 400));
}
/**
* This method is called from within the constructor to initialize the
form. WARNING: Do NOT modify this code. The content of this method is always
regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

chessBoard1 = new aegis.ChessBoard();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Chess Game");
setResizable(false);
addWindowListener(new java.awt.event.WindowAdapter() {
public void windowClosing(java.awt.event.WindowEvent evt) {
formWindowClosing(evt);
}
});

javax.swing.GroupLayout chessBoard1Layout = new


javax.swing.GroupLayout(chessBoard1);
chessBoard1.setLayout(chessBoard1Layout);
chessBoard1Layout.setHorizontalGroup(

chessBoard1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
);
chessBoard1Layout.setVerticalGroup(

chessBoard1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
);

javax.swing.GroupLayout layout = new


javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(chessBoard1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(chessBoard1, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
);

pack();
setLocationRelativeTo(null);
}// </editor-fold>

private void formWindowClosing(java.awt.event.WindowEvent evt) {


// TODO add your handling code here:
this.getBoard().stopConnection();
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting
code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the
default look and feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(GameMain.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(GameMain.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(GameMain.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(GameMain.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */


java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new GameMain().setVisible(true);
}
});
}

public ChessBoard getBoard() {


return this.chessBoard1;
}

// Variables declaration - do not modify


private aegis.ChessBoard chessBoard1;
// End of variables declaration
}

GameStart.java

package aegis;

/**
*
* @author JV Master
*/
public class GameStart extends javax.swing.JFrame {
/**
* Creates new form GameStart
*/
public GameStart() {
initComponents();
}

/**
* This method is called from within the constructor to initialize the
form. WARNING: Do NOT modify this code. The content of this method is always
regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jSeparator1 = new javax.swing.JSeparator();


jRadioButton1 = new javax.swing.JRadioButton();
jRadioButton2 = new javax.swing.JRadioButton();
jButton1 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();
jLabel2 = new javax.swing.JLabel();
jTextField2 = new javax.swing.JTextField();
jLabel3 = new javax.swing.JLabel();
jTextField3 = new javax.swing.JTextField();
jCheckBox1 = new javax.swing.JCheckBox();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("Chess Game");
setResizable(false);

jRadioButton1.setSelected(true);
jRadioButton1.setText("Network");
jRadioButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jRadioButton1ActionPerformed(evt);
}
});

jRadioButton2.setText("Janela nica");
jRadioButton2.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jRadioButton2ActionPerformed(evt);
}
});

jButton1.setText("Iniciar Jogo");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});

jLabel1.setLabelFor(jTextField1);
jLabel1.setText("Host:");

jTextField1.setText("localhost");

jLabel2.setLabelFor(jTextField2);
jLabel2.setText("Usurio:");

jTextField2.setText("root");

jLabel3.setLabelFor(jTextField3);
jLabel3.setText("Senha:");

jCheckBox1.setSelected(true);
jCheckBox1.setText("Sempre Alinhar Abaixo");

javax.swing.GroupLayout layout = new


javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jSeparator1)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(35, 35, 35)
.addComponent(jLabel1))
.addGroup(layout.createSequentialGroup()
.addGap(27, 27, 27)
.addComponent(jLabel3))
.addComponent(jLabel2,
javax.swing.GroupLayout.Alignment.TRAILING))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jTextField3)
.addComponent(jTextField1)
.addComponent(jTextField2)))
.addGroup(javax.swing.GroupLayout.Alignment.LEADING,
layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(jRadioButton1)
.addComponent(jRadioButton2))
.addGap(0, 0, Short.MAX_VALUE))
.addGroup(layout.createSequentialGroup()
.addGap(0, 173, Short.MAX_VALUE)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(jButton1,
javax.swing.GroupLayout.PREFERRED_SIZE, 125, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(jCheckBox1))))
.addContainerGap())
);
layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jRadioButton1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel1)
.addComponent(jTextField1,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel2)
.addComponent(jTextField2,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel3)
.addComponent(jTextField3,
javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 11,
Short.MAX_VALUE)
.addComponent(jCheckBox1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jSeparator1,
javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(jRadioButton2)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jButton1)
.addContainerGap())
);

pack();
setLocationRelativeTo(null);
}// </editor-fold>
private void jRadioButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
jRadioButton2.setSelected(false);
changeNetworkChecked(true);
}

private void jRadioButton2ActionPerformed(java.awt.event.ActionEvent evt) {


// TODO add your handling code here:
jRadioButton1.setSelected(false);
changeNetworkChecked(false);
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {


// TODO add your handling code here:
GameMain frame = new GameMain();

if (jRadioButton1.isSelected()) {
GameConnection conn = new GameConnection();
conn.start(jTextField1.getText(), jTextField2.getText(),
jTextField3.getText());
frame.getBoard().setConnection(conn);
}
if (jCheckBox1.isSelected())
frame.getBoard().setInvertSecondPlayer(true);

frame.setVisible(true);
this.setVisible(false);
this.dispose();
}

private void changeNetworkChecked(boolean value) {


jLabel1.setEnabled(value);
jTextField1.setEnabled(value);
jLabel2.setEnabled(value);
jTextField2.setEnabled(value);
jLabel3.setEnabled(value);
jTextField3.setEnabled(value);
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting
code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the
default look and feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(GameStart.class.getName()).log(java.util.logging.Le
vel.SEVERE, null, ex);
} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(GameStart.class.getName()).log(java.util.logging.Le
vel.SEVERE, null, ex);
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(GameStart.class.getName()).log(java.util.logging.Le
vel.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(GameStart.class.getName()).log(java.util.logging.Le
vel.SEVERE, null, ex);
}
//</editor-fold>

/* Create and display the form */


java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new GameStart().setVisible(true);
}
});
}

// Variables declaration - do not modify


private javax.swing.JButton jButton1;
private javax.swing.JCheckBox jCheckBox1;
private javax.swing.JLabel jLabel1;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JRadioButton jRadioButton1;
private javax.swing.JRadioButton jRadioButton2;
private javax.swing.JSeparator jSeparator1;
private javax.swing.JTextField jTextField1;
private javax.swing.JTextField jTextField2;
private javax.swing.JTextField jTextField3;
// End of variables declaration
}

ChessBoard.java

package aegis;

import aegis.pieces.*;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import javax.swing.JPanel;
import javax.swing.Timer;

/**
* Chess Board
* @author JV Master
*/
public class ChessBoard extends JPanel implements MouseListener {

protected ChessPlayer[] players;

protected int current;


protected int pieceIndex;
protected ArrayList<Point> pieceMoves;
protected ArrayList<Point> pieceEats;

// -----------------
protected boolean networking = false;
protected GameConnection conn = null;
protected int status = 0; // 0: waiting second player
protected Timer timer;

protected boolean invertSecondPlayer = false;

public ChessBoard() {
// Inicia o listener do mouse
this.addMouseListener(this);

// Inicia o timer (listener que verifica periodicamente o database em


caso de networking)
this.setTimer(new Timer(500, new ActionListener() {
@Override
public void actionPerformed(ActionEvent evt) {
updateConnection();
}
}));
this.getTimer().setRepeats(true);

// Inicia o jogo
this.start();
}

// Inicia o jogo
public void start() {
// Inicia os jogadores
this.setPlayers(new ChessPlayer[2]);
players[0] = new ChessPlayer(1);
players[1] = new ChessPlayer(0);

this.setCurrent(0);
this.setPieceIndex(-1);
}

// ---------------------------------------------------------------
// DRAWING
// ---------------------------------------------------------------

@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);

Graphics2D g2d = (Graphics2D)g;

// Altera a fonte padro caso no tenha sido alterada, e adiciona AA na


fonte
if (g2d.getFont().getSize() != 24) {
g2d.setFont(new Font("Arial", Font.PLAIN, 24));
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
}

// Desenha o tabuleiro
for (int x = 0; x < 8; x++)
for (int y = 0; y < 8; y++) {
g2d.setColor(((x + y) % 2 == 0) ? Color.LIGHT_GRAY :
Color.GRAY);
g2d.fillRect(x * 50, y * 50, 50, 50);
}

// Desenha as marcaes
if (this.getPieceIndex() != -1) {
ChessPiece piece = this.getPlayerPiece(this.getPieceIndex());

// alpha

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.4f));

g2d.setColor(Color.MAGENTA);
g2d.fillRect(xy(piece.getX()) * 50, xy(piece.getY()) * 50, 50, 50);
g2d.setColor(Color.CYAN);
for (Point move : this.getPieceMoves())
g2d.fillRect(xy((int)move.getX()) * 50, xy((int)move.getY()) *
50, 50, 50);

g2d.setColor(Color.RED);
for (Point eat : this.getPieceEats())
g2d.fillRect(xy((int)eat.getX()) * 50, xy((int)eat.getY()) *
50, 50, 50);

// reset alpha

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f));
}

// Desenha as peas
for (int i = 0; i < 2; i++)
this.getPlayer(i).draw(g, (xy(0) == 7));

// Desenha as mensagens de tela


if (isNetworking()) {
if (this.status == 0)
drawMessage(g2d, "AGUARDANDO JOGADOR 2");

if (this.current != this.getConnection().getPlayerIndex())
drawMessage(g2d, "VEZ DO OPONENTE");
}
}

// Desenha uma mensagem na tela


// Utilizado nas mensagens de networking
protected void drawMessage(Graphics2D g2d, String text) {
FontMetrics fm = getFontMetrics(g2d.getFont());

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
0.8f));
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, 400, 400);
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,
1f));
g2d.setColor(Color.WHITE);
g2d.drawString(text, (this.getWidth() - fm.stringWidth(text)) / 2,
this.getHeight() / 2);
}

// ---------------------------------------------------------------
// INPUT
// ---------------------------------------------------------------

@Override
public void mouseClicked(MouseEvent e) {
// Calcula a clula do tabuleiro relativa a posio do mouse
int x = xy(e.getX() / 50);
int y = xy(e.getY() / 50);

// Verifica se o input no est bloqueado no sistema de networking


if (!isNetworking() || isNetworking() && this.getCurrent() ==
this.getConnection().getPlayerIndex() && this.getStatus() == 1) {

if (this.getPieceIndex() == -1 || (this.getPieceMoves().isEmpty()
&& this.getPieceEats().isEmpty())) {
// -- Faz a seleo da pea que ser movida
this.setPieceIndex(this.indexOfPiece(this.getPlayerPieces(), x,
y));
if (this.getPieceIndex() != -1) {
// Calcula a lista de movimentos possveis da pea
selecionada
this.setPieceMoves(this.getCurrentPiece().getMoves(this));
this.setPieceEats(this.getCurrentPiece().getEats(this));

// Atualiza o desenho
this.repaint();
}

} else {
// -- Move a pea selecionada

// Verifica se a posio clicada est dentro das possibilidades


de movimento
int move = this.indexOfPoint(this.getPieceMoves(), x, y);
int eat = this.indexOfPoint(this.getPieceEats(), x, y);
if (move != -1) {
// Executa a ao da pea
Point p = this.getPieceMoves().get(move);
move(this.getCurrentPiece(), (int)p.getX(), (int)p.getY());

// Atualiza o desenho
this.repaint();

} else if (eat != -1) {

// Executa a ao da pea
Point p = this.getPieceEats().get(eat);
eat(this.getCurrentPiece(), (int)p.getX(), (int)p.getY());

// Atualiza o desenho
this.repaint();
}
}
}
}

// Move a pea e remove a pea inimiga "comida", enviando uma mensagem caso
esteja utilizando networking
protected void eat(ChessPiece piece, int x, int y) {
eat(piece, x, y, "eat");
}

// Move a pea e remove a pea inimiga "comida", enviando a mensagem com a


ao escolhida caso esteja utilizando networking
protected void eat(ChessPiece piece, int x, int y, String action) {
// Procura o inimigo na posio {x, y}
ChessPiece enemy =
this.getEnemyPiece(this.indexOfPiece(this.getEnemyPieces(), x, y));

// Desabilita o inimigo
enemy.setEnabled(false);

// Realiza o movimento da pea


move(piece, x, y, action);

// Verifica se houve vitria de jogo


checkWin(enemy);
}

// Move a pea, enviando uma mensagem caso esteja utilizando networking


protected void move(ChessPiece piece, int x, int y) {
move(piece, x, y, "move");
}

// Move a pea, enviando a mensagem com a ao escolhida caso esteja


utilizando networking
protected void move(ChessPiece piece, int x, int y, String action) {
// Salva a posio anterior da pea
int oX = piece.getX();
int oY = piece.getY();

// Move a pea
piece.setX(x);
piece.setY(y);

// Verifica a promoo
checkPromotion(piece);

// Realiza a troca de turno para o prximo jogador


togglePlayer();

// Networking
if (isNetworking() && !action.equals("")) {
this.getConnection().send(action, "" + oX + oY + piece.getX() +
piece.getY());
}
}

// Verifica se h promoo da pea


protected void checkPromotion(ChessPiece piece) {
if (piece != null && piece instanceof Pawn)
if (piece.getY() == 0 || piece.getY() == 7) {
piece.setEnabled(false);
this.getPlayerPieces().add(
new Queen(piece.getX(), piece.getY(), piece.getSide())
);
}
}
// Verifica se h vitria do jogo
protected void checkWin(ChessPiece piece) {
if (piece != null && piece instanceof King) {
if (isNetworking() && this.getCurrent() ==
this.getConnection().getPlayerIndex())
this.getConnection().send("win", "" + (1 - this.getCurrent()));
this.start();
}
}

// Inverte o jogador atual


protected void togglePlayer() {
this.setPieceIndex(-1);
this.setCurrent(1 - this.getCurrent());
}

// ---------------------------------------------------------------

@Override
public void mousePressed(MouseEvent e) { }

@Override
public void mouseReleased(MouseEvent e) { }

@Override
public void mouseEntered(MouseEvent e) { }

@Override
public void mouseExited(MouseEvent e) { }

// ---------------------------------------------------------------
// CUSTOM GETTERS & SETTERS
// ---------------------------------------------------------------

public ChessPlayer getPlayer(int index) {


return this.getPlayers()[index];
}

public ChessPlayer getPlayer() {


return this.getPlayers()[this.getCurrent()];
}
public ChessPlayer getEnemy() {
return this.getPlayers()[1 - this.getCurrent()];
}

public ArrayList<ChessPiece> getPlayerPieces() {


return this.getPlayer().getPieces();
}

public ArrayList<ChessPiece> getEnemyPieces() {


return this.getEnemy().getPieces();
}

public ChessPiece getPlayerPiece(int index) {


return this.getPlayerPieces().get(index);
}

public ChessPiece getEnemyPiece(int index) {


return this.getEnemyPieces().get(index);
}

public ChessPiece getCurrentPiece() {


return this.getPlayerPiece(this.getPieceIndex());
}

// Retorna a posio dentro da coleo especificada de uma determinada pea


na posio {x, y}
public int indexOfPiece(ArrayList<ChessPiece> collection, int x, int y) {
for (int i = 0; i < collection.size(); i++) {
ChessPiece piece = collection.get(i);
if (piece.isEnabled() && piece.getX() == x && piece.getY() == y)
return i;
}

return -1;
}

// Retorna a posio dentro da coleo especificada de um determinado Point


na posio {x, y}
public int indexOfPoint(ArrayList<Point> collection, int x, int y) {
for (int i = 0; i < collection.size(); i++) {
Point p = collection.get(i);
if (p.getX() == x && p.getY() == y)
return i;
}

return -1;
}

// ---------------------------------------------------------------
// GETTERS & SETTERS
// ---------------------------------------------------------------

public ChessPlayer[] getPlayers() {


return players;
}

public void setPlayers(ChessPlayer[] players) {


this.players = players;
}

public int getCurrent() {


return current;
}

public void setCurrent(int current) {


this.current = current;
}

public int getPieceIndex() {


return pieceIndex;
}

public void setPieceIndex(int pieceIndex) {


this.pieceIndex = pieceIndex;
}

public ArrayList<Point> getPieceMoves() {


return pieceMoves;
}

public void setPieceMoves(ArrayList<Point> pieceMoves) {


this.pieceMoves = pieceMoves;
}
public ArrayList<Point> getPieceEats() {
return pieceEats;
}

public void setPieceEats(ArrayList<Point> pieceEats) {


this.pieceEats = pieceEats;
}

// ---------------------------------------------------------------
// NETWORKING
// ---------------------------------------------------------------

public GameConnection getConnection() {


return conn;
}

// Caso seja enviada uma conexo, ento ativa o networking


public void setConnection(GameConnection conn) {
this.conn = conn;

this.setNetworking(true);
this.getConnection().getPlayerIndex();
this.getConnection().send("start", "" +
this.getConnection().getPlayerIndex());

this.getConnection().setLastIndex(Integer.parseInt(this.getConnection().receive()[0]))
;
this.getTimer().start();

if (this.getConnection().getPlayerIndex() == 1)
this.setStatus(1);
}

// Para o networking
public void stopConnection() {
if (isNetworking()) {
this.getTimer().stop();
this.getConnection().send("stop", "" +
this.getConnection().getPlayerIndex());
this.getConnection().stop();
this.setNetworking(false);
}
}

// Networking: Verifica se h novas atualizaes de dados


public void updateConnection() {
String[] data = this.getConnection().receive();

if (Integer.parseInt(data[0]) > this.getConnection().getLastIndex()) {


this.getConnection().setLastIndex(Integer.parseInt(data[0]));

ChessPiece piece;

switch(data[1]) {
case "start":
// Caso seja o jogador 1 e receba a mensagem que um jogador
entrou
if (this.getConnection().getPlayerIndex() == 0) {
this.setStatus(1);

// Atualiza o desenho
this.repaint();
}
break;
case "move":
// Seleciona a pea movida
piece =
this.getPlayerPiece(this.indexOfPiece(this.getPlayerPieces(), getIntAt(data[2], 0),
getIntAt(data[2], 1)));

// Executa a ao da pea
move(piece, getIntAt(data[2], 2), getIntAt(data[2], 3),
"");

// Atualiza o desenho
this.repaint();
break;
case "eat":
// Seleciona a pea movida
piece =
this.getPlayerPiece(this.indexOfPiece(this.getPlayerPieces(), getIntAt(data[2], 0),
getIntAt(data[2], 1)));

// Executa a ao da pea
eat(piece, getIntAt(data[2], 2), getIntAt(data[2], 3), "");

// Atualiza o desenho
this.repaint();
break;
case "stop":
// Fecha o jogo caso o outro cliente tenha sido finalizado
stopConnection();
System.exit(0);
break;
default:
break;
}
}
}

// Retorna o valor inteiro relativo ao char na posio especificada de uma


string
protected int getIntAt(String data, int index) {
return Integer.parseInt(data.substring(index, index + 1));
}

// Alinha abaixo o jogaodor 2


protected int xy(int value) {
if (isNetworking() && isInvertSecondPlayer() &&
this.getConnection().getPlayerIndex() == 1)
return (7 - value);

return value;
}

public boolean isNetworking() {


return networking;
}

public void setNetworking(boolean networking) {


this.networking = networking;
}

public int getStatus() {


return status;
}
public void setStatus(int status) {
this.status = status;
}

public Timer getTimer() {


return timer;
}

public void setTimer(Timer timer) {


this.timer = timer;
}

public boolean isInvertSecondPlayer() {


return invertSecondPlayer;
}

public void setInvertSecondPlayer(boolean invertSecondPlayer) {


this.invertSecondPlayer = invertSecondPlayer;
}
}

ChessPiece.java

package aegis;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.util.ArrayList;
import javax.swing.ImageIcon;

/**
* Chess Piece
* @author JV Master
*/
public class ChessPiece {

protected int x;
protected int y;
protected int side;

protected Image image;

protected boolean enabled;

public ChessPiece() {
this(0, 0, 0);
}

public ChessPiece(int x, int y, int side) {


this.setEnabled(true);
this.setX(x);
this.setY(y);
this.setSide(side);
}

public void draw(Graphics g) {


if (this.getImage() != null && this.isEnabled())
g.drawImage(this.getImage(), this.getX() * 50, this.getY() * 50, null);
}

public void draw(Graphics g, boolean xy) {


if (this.getImage() != null && this.isEnabled() && xy)
g.drawImage(this.getImage(), (7 - this.getX()) * 50, (7 - this.getY()) * 50,
null);
else
draw(g);
}

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

public int getSide() {


return side;
}

public void setSide(int side) {


this.side = side;
}

public Image getImage() {


return image;
}

public void setImage(Image image) {


this.image = image;
}

public boolean isEnabled() {


return enabled;
}

public void setEnabled(boolean enabled) {


this.enabled = enabled;
}

public ArrayList<Point> getMoves(ChessBoard board) {


return new ArrayList<>();
}

public ArrayList<Point> getEats(ChessBoard board) {


return new ArrayList<>();
}

// -------------------------------------------------
// move mapping
// 0: continue search
// 1: stop search
public int addCellEmpty(ArrayList<Point> list, ChessBoard board, int x, int y)
{
x += this.getX(); y+= this.getY();
if (this.isCell(x, y) &&
board.indexOfPiece(board.getPlayerPieces(), x, y) == -1 &&
board.indexOfPiece(board.getEnemyPieces(), x, y) == -1) {
list.add(new Point(x, y));
return 0;
}

return 1;
}

public int addCellEnemy(ArrayList<Point> list, ChessBoard board, int x, int y)


{
x += this.getX(); y+= this.getY();
if (this.isCell(x, y)) {
if (board.indexOfPiece(board.getEnemyPieces(), x, y) != -1)
list.add(new Point(x, y));
else
if (board.indexOfPiece(board.getPlayerPieces(), x, y) == -1)
return 0;
}

return 1;
}

public void loopCellEmpty(ArrayList<Point> list, ChessBoard board, int x, int


y) {
int result = 0, i = 1;
while (result == 0) {
result = this.addCellEmpty(list, board, i * x, i * y);
i++;
}
}

public void loopCellEnemy(ArrayList<Point> list, ChessBoard board, int x, int


y) {
int result = 0, i = 1;
while (result == 0) {
result = this.addCellEnemy(list, board, i * x, i * y);
i++;
}
}

public boolean isCell(int x, int y) {


return (x >= 0 && x <= 7 && y >= 0 && y <= 7);
}

// -------------------------------------------------

public Image loadPieceImage(String name) {


return new ImageIcon(getClass().getClassLoader().getResource(
name + "_" + ((this.getSide() == 0) ? "b" : "w") + ".png"
)).getImage();
}
}

ChessPlayer.java

package aegis;

import aegis.pieces.*;
import java.awt.Graphics;
import java.util.ArrayList;

/**
* Chess Player
* @author JV Master
*/
public class ChessPlayer {

protected ArrayList<ChessPiece> pieces;


protected int side;

public ChessPlayer(int side) {


if (side != 0) side = 1;
this.side = side;

this.start();
}
public void start() {
int offset = side * 7;

pieces = new ArrayList<>();

pieces.add(new Rook(0, offset, side));


pieces.add(new Rook(7, offset, side));
pieces.add(new Knight(1, offset, side));
pieces.add(new Knight(6, offset, side));
pieces.add(new Bishop(2, offset, side));
pieces.add(new Bishop(5, offset, side));
pieces.add(new Queen(3, offset, side));
pieces.add(new King(4, offset, side));

for(int i = 0; i < 8; i++)


pieces.add(new Pawn(i, 1 + side * 5, side));
}

public void draw(Graphics g) {


for (ChessPiece piece : pieces)
piece.draw(g);
}

public void draw(Graphics g, boolean xy) {


for (ChessPiece piece : pieces)
piece.draw(g, xy);
}

public ArrayList<ChessPiece> getPieces() {


return pieces;
}

public void setPieces(ArrayList<ChessPiece> pieces) {


this.pieces = pieces;
}

public int getSide() {


return side;
}

public void setSide(int side) {


this.side = side;
}
}

GameConnection.java

package aegis;

import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* Game Connection
* @author JV Master
*/
public class GameConnection {

protected Connection conn = null;


protected final String dbName = "db_chess";
protected final String tableName = "actions";

protected int gameIndex = 0;


protected int playerIndex = -1;
protected int lastIndex = 0;

public void start(String host, String user, String pass) {


String connURL = "jdbc:mysql://" +host+ ":3306/";

try {
Class.forName("com.mysql.jdbc.Driver");

setupDB(connURL, user, pass);

conn = DriverManager.getConnection(connURL + dbName, user, pass);

createGameTable();

} catch (SQLException | ClassNotFoundException ex) {


Logger.getLogger(GameConnection.class.getName()).log(Level.SEVERE,
null, ex);
}
}

public void stop() {


if (conn != null) {
try {
conn.close();
} catch (SQLException ex) {

Logger.getLogger(GameConnection.class.getName()).log(Level.SEVERE, null, ex);


}
}
}

protected void setupDB(String connURL, String user, String pass) throws


SQLException {
conn = DriverManager.getConnection(connURL, user, pass);

ResultSet rs = conn.getMetaData().getCatalogs();
boolean found = false;

while (rs.next()) {
String databaseName = rs.getString(1);
if(databaseName.equals(dbName))
found = true;
}

rs.close();

// -----------

if (!found) {
Statement st = conn.createStatement();
st.executeUpdate("CREATE DATABASE " + dbName);
st.close();
}

conn.close();
}

protected void createGameTable() throws SQLException {


Statement st = conn.createStatement();
st.executeUpdate("CREATE TABLE IF NOT EXISTS " + tableName + "("
+ "id INTEGER NOT NULL AUTO_INCREMENT,"
+ "game_id INTEGER NOT NULL,"
+ "action VARCHAR(10) NOT NULL,"
+ "params VARCHAR(10) NOT NULL DEFAULT '',"
+ "time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,"
+ "PRIMARY KEY(id)"
+ ");");
st.close();
}

public int getPlayerIndex() {


if (this.playerIndex == -1) {
try {
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(
"SELECT game_id gid, COUNT(*) AS players, "
+ "(SELECT COUNT(*) FROM actions WHERE gid = game_id
AND action = 'stop') AS stopped "
+ "FROM " + tableName + " "
+ "WHERE action = 'start' "
+ "GROUP BY game_id "
+ "ORDER BY game_id DESC;"
);

if (rs.next()) {
if (rs.getString("players").equals("2") ||
rs.getInt("stopped") > 0) {
this.gameIndex = rs.getInt("gid") + 1;
this.playerIndex = 0;
} else {
this.gameIndex = rs.getInt("gid");
this.playerIndex = 1;
}
} else {
this.gameIndex = 0;
this.playerIndex = 0;
}

st.close();
} catch (SQLException ex) {
Logger.getLogger(GameConnection.class.getName()).log(Level.SEVERE, null, ex);
}

return this.playerIndex;
} else {
return this.playerIndex;
}
}

public String[] receive() {


try {
String sql = "SELECT * FROM " +tableName+ " WHERE game_id = ? ORDER
BY id DESC LIMIT 1";
PreparedStatement st = conn.prepareStatement(sql);
st.setInt(1, this.gameIndex);
//Statement st = conn.createStatement();
//ResultSet rs = st.executeQuery("SELECT * FROM " +tableName+ "
ORDER BY id DESC LIMIT 1");
ResultSet rs = st.executeQuery();
if (rs.next()) {
String[] result = new String[4];
result[0] = rs.getString("id");
result[1] = rs.getString("action");
result[2] = rs.getString("params");
result[3] = rs.getString("time");
return result;
}
System.out.println(this.gameIndex + " " + rs.getString("game_id"));
st.close();
} catch (SQLException ex) {
Logger.getLogger(GameConnection.class.getName()).log(Level.SEVERE,
null, ex);
}

return null;
}

public void send(String action, String params) {


try {
String sql = "INSERT INTO " +tableName+ " (game_id, action, params)
VALUES (?,?,?);";
PreparedStatement st = conn.prepareStatement(sql,
Statement.RETURN_GENERATED_KEYS);
st.setInt(1, this.gameIndex);
st.setString(2, action);
st.setString(3, params);
st.executeUpdate();

ResultSet rs = st.getGeneratedKeys();
if (rs.next())
this.setLastIndex(rs.getInt(1));

st.close();
} catch (SQLException ex) {
Logger.getLogger(GameConnection.class.getName()).log(Level.SEVERE,
null, ex);
}
}

public int getLastIndex() {


return lastIndex;
}

public void setLastIndex(int lastIndex) {


this.lastIndex = lastIndex;
}
}

Bishop.java

package aegis.pieces;

import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;

/**
* Chess Bishop
* @author JV Master
*/
public class Bishop extends ChessPiece {

public Bishop() {
super();
}

public Bishop(int x, int y, int side) {


super(x, y, side);

this.setImage(this.loadPieceImage("bishop"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEmpty(list, board, 1, 1);


this.loopCellEmpty(list, board, -1, -1);
this.loopCellEmpty(list, board, 1, -1);
this.loopCellEmpty(list, board, -1, 1);

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEnemy(list, board, 1, 1);


this.loopCellEnemy(list, board, -1, -1);
this.loopCellEnemy(list, board, 1, -1);
this.loopCellEnemy(list, board, -1, 1);

return list;
}
}

King.java

package aegis.pieces;
import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;

/**
* Chess King
* @author JV Master
*/
public class King extends ChessPiece {

public King() {
super();
}

public King(int x, int y, int side) {


super(x, y, side);

this.setImage(this.loadPieceImage("king"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.addCellEmpty(list, board, 1, 0);


this.addCellEmpty(list, board, -1, 0);
this.addCellEmpty(list, board, 0, 1);
this.addCellEmpty(list, board, 0, -1);
this.addCellEmpty(list, board, 1, 1);
this.addCellEmpty(list, board, -1, -1);
this.addCellEmpty(list, board, 1, -1);
this.addCellEmpty(list, board, -1, 1);

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();
this.addCellEnemy(list, board, 1, 0);
this.addCellEnemy(list, board, -1, 0);
this.addCellEnemy(list, board, 0, 1);
this.addCellEnemy(list, board, 0, -1);
this.addCellEnemy(list, board, 1, 1);
this.addCellEnemy(list, board, -1, -1);
this.addCellEnemy(list, board, 1, -1);
this.addCellEnemy(list, board, -1, 1);

return list;
}
}

Knight.java

package aegis.pieces;

import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;

/**
* Chess Knight
* @author JV Master
*/
public class Knight extends ChessPiece {

public Knight() {
super();
}

public Knight(int x, int y, int side) {


super(x, y, side);

this.setImage(this.loadPieceImage("knight"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.addCellEmpty(list, board, -2, -1);


this.addCellEmpty(list, board, -1, -2);
this.addCellEmpty(list, board, -2, 1);
this.addCellEmpty(list, board, -1, 2);
this.addCellEmpty(list, board, 2, -1);
this.addCellEmpty(list, board, 1, -2);
this.addCellEmpty(list, board, 2, 1);
this.addCellEmpty(list, board, 1, 2);

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.addCellEnemy(list, board, -2, -1);


this.addCellEnemy(list, board, -1, -2);
this.addCellEnemy(list, board, -2, 1);
this.addCellEnemy(list, board, -1, 2);
this.addCellEnemy(list, board, 2, -1);
this.addCellEnemy(list, board, 1, -2);
this.addCellEnemy(list, board, 2, 1);
this.addCellEnemy(list, board, 1, 2);

return list;
}
}

Pawn.java

package aegis.pieces;

import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;
/**
* Chess Pawn
* @author JV Master
*/
public class Pawn extends ChessPiece {

public Pawn() {
super();
}

public Pawn(int x, int y, int side) {


super(x, y, side);

this.setImage(this.loadPieceImage("pawn"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

if (this.getSide() == 0) {
this.addCellEmpty(list, board, 0, 1);
if (this.getY() == 1) this.addCellEmpty(list, board, 0, 2);
} else {
this.addCellEmpty(list, board, 0, -1);
if (this.getY() == 6) this.addCellEmpty(list, board, 0, -2);
}

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

if (this.getSide() == 0) {
this.addCellEnemy(list, board, -1, 1);
this.addCellEnemy(list, board, 1, 1);
} else {
this.addCellEnemy(list, board, -1, -1);
this.addCellEnemy(list, board, 1, -1);
}
return list;
}
}

Queen.java

package aegis.pieces;

import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;

/**
* Chess Queen
* @author JV Master
*/
public class Queen extends ChessPiece {

public Queen() {
super();
}

public Queen(int x, int y, int side) {


super(x, y, side);

this.setImage(this.loadPieceImage("queen"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEmpty(list, board, 1, 0);


this.loopCellEmpty(list, board, -1, 0);
this.loopCellEmpty(list, board, 0, 1);
this.loopCellEmpty(list, board, 0, -1);
this.loopCellEmpty(list, board, 1, 1);
this.loopCellEmpty(list, board, -1, -1);
this.loopCellEmpty(list, board, 1, -1);
this.loopCellEmpty(list, board, -1, 1);

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEnemy(list, board, 1, 0);


this.loopCellEnemy(list, board, -1, 0);
this.loopCellEnemy(list, board, 0, 1);
this.loopCellEnemy(list, board, 0, -1);
this.loopCellEnemy(list, board, 1, 1);
this.loopCellEnemy(list, board, -1, -1);
this.loopCellEnemy(list, board, 1, -1);
this.loopCellEnemy(list, board, -1, 1);

return list;
}
}

Rook.java

package aegis.pieces;

import aegis.ChessBoard;
import aegis.ChessPiece;
import java.awt.Point;
import java.util.ArrayList;

/**
* Chess Rook
* @author JV Master
*/
public class Rook extends ChessPiece {

public Rook() {
super();
}
public Rook(int x, int y, int side) {
super(x, y, side);

this.setImage(this.loadPieceImage("rook"));
}

@Override
public ArrayList<Point> getMoves(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEmpty(list, board, 1, 0);


this.loopCellEmpty(list, board, -1, 0);
this.loopCellEmpty(list, board, 0, 1);
this.loopCellEmpty(list, board, 0, -1);

return list;
}

@Override
public ArrayList<Point> getEats(ChessBoard board) {
ArrayList<Point> list = new ArrayList<>();

this.loopCellEnemy(list, board, 1, 0);


this.loopCellEnemy(list, board, -1, 0);
this.loopCellEnemy(list, board, 0, 1);
this.loopCellEnemy(list, board, 0, -1);

return list;
}
}
Captulo 6
CAPTULO 6 - PROGRAMA

6.1 Exemplo de execuo do programa

Menu

Na figura abaixo, apresenta o menu, permitindo que o usurio escolha a opo


desejada.

6-1 Menu do programa


Janela nica

Ao escolher a opo Janela nica e depois clicar em Iniciar Jogo, ser gerado
uma janela com o tabuleiro.

6-2 Tabuleiro

Multiplayer

Para o modo Multiplayer, escolha a opo Network no Menu. Depois de


selecionado, insira os dados correspondentes, ou seja, o host (endereo da rede),
um nome de usurio e uma senha que ser utilizado por ambos os jogadores em
rede.
6-3 Menu do programa

Depois da insero dos dados e clicar em Iniciar Jogo aparecer uma janela
com o tabuleiro para o jogador que inciou o jogo.

6-4 Janela Jogador 1


Na imagem abaixo, temos uma represantao de como um jogo multiplayer. So
duas janelas, uma para cada jogador, conforme o jogo se desenvolve, aparece
mensagem vez do oponente, sempre que acabar de fazer uma jogada.

6-5 Representao de um jogo Multiplayer

6.2 Movimento das peas

Peo

O Peo s se movimenta para frente, sendo a nica pea que no se move


para trs.
6-6 Peo

Rei

O Rei movimenta-se apenas uma casa em qualquer direo.

6-7 Rei
Torre

A torre se movimenta para frente e para trs, para a direita e para a esquerda,
quantas casas quiser, mas no pode pular nenhuma outra pea.
6-8 Torre

Cavalo

O cavalo a nica pea do xadrez que pode pular outras peas. Ele tem um
movimento especial que parece a letra L, movendo-se 2 casas para frente ou para trs
e em seguida 1 casa para a direita ou para a esquerda ou vice-versa.

6-9 Cavalo
Bispo

O bispo se movimenta na diagonal mantendo-se sempre nas casas de mesma


cor, podendo ir para frente e para trs, quantas casas quiser, mas no pode pular
nenhuma outra pea.

6-10 Bispo

Rainha

a pea mais poderosa do xadrez, ela pode ir para frente ou para trs, para
direita ou para a esquerda, ou na diagonal, quantas casas quiser, mas no pode pular
nenhuma outra pea.
6-11 Rainha

6.3 Movimentos especiais

Promoo do Peo

Se o peo chegar do outro lado do tabuleiro ele promovido e tornar-se uma


rainha por ser a pea mais poderosa.
Na figura abaixo, podemos ver uma segunda rainha branca do outro lado do
tabuleiro. Isso ocorre porque o peo chegou do outro lado, sendo assim,
automaticamente se torna uma rainha.
6-12 Promoo do Peo

Xeque Mate

Quando o Rei est a ser atacado por uma pea inimiga diz-se que este est
em xeque. Esta situao implica a derrota para o lado do Rei que est em xeque
vitria para o outro.
Na figura abaixo, podemos ver que ocorrer um xeque-mate, assim que o
fizer, o jogo termina e reinicializado.

6-13 Xeque-Mate
CAPTULO 7 - BIBLIOGRAFIA

Movimento das peas. Disponvel em:


<http://baquara.com/xadrez/movimentos.htm>. Acesso em 4 de setembro de 2015.

Movimento especiais. Disponvel em:


<http://baquara.com/xadrez/especiais.htm>. Acesso em 4 de setembro de 2015.

SIERRA, Kathy; BATES, Bert Use a Cabea Java Editora Alta Books, Rio
de Janeiro, 2010.

MILANI, Andre MYSQL - Guia do programador Editora Novatec, So


Paulo, 2006.

Regras do Xadrez. Disponvel em: <http://regras-do-xadrez.info/como-jogar-


xadrez.html>. Acesso em 3 de setembro de 2015.