Classe DamierGraphique
import java.awt.*;
import java.util.*;
/** <B>Cahier des charges :</B>
*
* <p>Classe de création de damiers incluant l'instanciation des pions et les
règles du jeu.
*
* @author Guillaume BLANC
* @author Cyrille FLAMBART
* @version JDK 1.1.6
* @see Client
* @see Pion
*
*/
//****************************Classe DamierGraphique**********************
public class DamierGraphique extends Panel
{
protected Pion[][] damier;
protected Pion positionDebut, positionFin, pris;
private int aQui;
private Stack historique;
protected static final int France = Pion.France;
protected static final int Bresil = Pion.Bresil;
protected static final int caseBlanche = Pion.caseBlanche;
protected static final int lignesDamier = 10;
protected static final int colonnesDamier = 10;
//***********************Constructeur DamierGraphique**********************
/** Constructeur de la classe <code>DamierGraphique</code> construisant un
panel
* "hébergeant" les pions et les cases.
*/
public DamierGraphique(){
int i, j;
damier = new Pion[colonnesDamier + 2][lignesDamier + 2];
setLayout(new GridLayout(lignesDamier, colonnesDamier));
for(j=0; j <= (lignesDamier + 1); j++)
for(i=0; i <= (colonnesDamier + 1); i++){
damier[i][j] = initialisationPion(i, j);
if(estValide(i,j))
add(damier[i][j]);
}
positionDebut = null;
positionFin = null;
pris = null;
aQui = France;//Honneur au champions du monde
historique = new Stack();
}//Fin du constructeur Damier
//****************************Méthode initialisationPion*********************
/** Méthode de construction du damier proprement dite : case noire, case blanche , pion
* France ou pion Brésil.
*
* @param <code>x</code> Coordonnées en abscisse du pion courant.
* @param <code>y</code> Coordonnées en ordonnée du pion courant.
*/
private Pion initialisationPion(int x, int y){
if(!estValide(x, y))
return new Pion(Pion.caseNoire, x, y);
if((x % 2) != (y % 2))
return new Pion(Pion.caseNoire, x, y);
if(y <= 4)
return new Pion(France, x, y);
if(y >= (lignesDamier - 3))
return new Pion(Bresil, x, y);
return new Pion(caseBlanche, x, y);
}//Fin de la méthode initialiserPion
//*********************************Méthode compterPions****************************
/** Méthode de calcul du nombre de pions présents sur le damier par équipe.
*
*
* @param <code>type</code> Type du pion à compter le nombre.
*/
//Compte le nombre de pions du damier correspondant au type qui lui est passé en
paramètre
public int compterPions(int type){
int score = 20;
for(int i=1; i <= colonnesDamier; i++)
for(int j=1; j <= lignesDamier; j++)
if(damier[i][j].type == -type)
score--;
return score;
}//Fin de la méthode compterPions
//********************************Métode estValide**********************************
/** Méthode de vérification de la validité des coordonnées passées en paramètres.
*
*
* @param <code>x</code> Abscisse à vérifier.
* @param <code>y</code> Ordonnées à vérifier.
*/
//Vérifie la validité des coordonnées passées en paramètres
private boolean estValide(int x, int y){
if( (x >= 1) && (x <= colonnesDamier) && (y >= 1) && (y
<= lignesDamier))
return true;
return false;
}//Fin de la méthode estValide
//*****************************Méthode unsetPositionDebut***************************
/** Méthode de déselection du pion dont on a recliqué dessus.
*
*
*/
//Désélectionne le pion si l'utilisateur re-clique dessus
protected void unsetPositionDebut(){
if(positionDebut != null)
positionDebut.highLight(false);
positionDebut = null;
positionFin = null;
pris = null;
}//Fin de la méthode unsetPositionDebut
//*****************************Méthode setPositionDebut*****************************
/** Méthode de vérification de la validité des coordonnées de l'endroit où le
* joueur à clicker.
*
* @param <code>x</code> Abscisse de l'endroit où le joueur a cliqué.
* @param <code>y</code> Ordonnées de l'endroit où le joueur a cliqué.
*/
//Définie le pion qui a été sélectionné
protected boolean setPositionDebut(int x, int y){
positionDebut = null;
positionFin = null;
pris = null;
//Si les coordonnées du pion ne sont pas valides
if(!estValide(x, y))
return false;
//Affecte la position de début
positionDebut = damier[x][y];
positionDebut.highLight(true);
positionDebut.repaint();
return true;
}//Fin de la méthode setPositionDebut
//*****************************Méthode serPositionFin*****************************
/** Méthode de définition de la case vers laquelle le pion préalablement sélectionné
doit être déplacé
* tout en vérifiant la conformité avec les règles du jeu.
*
* @param <code>x</code> Abscisse de l'endroit où le joueur a cliqué.
* @param <code>y</code> Ordonnées de l'endroit où le joueur a cliqué.
*/
/*Définie la case vers laquelle le pion préalablement sélectionné
doit être déplacé
et vérifie la conformité avec les règles du jeu*/
protected boolean setPositionFin(int x, int y){
positionFin = null;
pris = null;
//Vérifie les coordonnées du pion
if(!estValide(x, y))
return false;
//Calcule les écarts de colonne et de ligne
entre la position de début et celle de fin
int dx = Math.abs(x - positionDebut.x);
int dy = Math.abs(y - positionDebut.y);
//Si la position de fin est égale à la
position de début, on annule le déplacement
if((positionDebut.x == x) && (positionDebut.y == y)){
unsetPositionDebut();
return false;
}
//Si le joueur se déplace d'un nombre de
colonnes <> du nombre de lignes
if(dx != dy)
return false;
/*Si le déplacement n'est pas correct en terme
de nombre de colonnes de déplacement :
soit un déplacement normal, soit un saut de
pion*/
if((!positionDebut.estDame) && (!((dx
== 1) || (dx == 2))))
return false;
/*Si le pion sélectionné n'est pas une dame,
il faut que le joueur2 se déplace en avant
et que le joueur1 se déplace en arrière par
rapport au calcul de la différence des
coordonnées de lignes du pion qui doit être
déplacé*/
//Si le joueur déplace son pion d'une case et que la case est libre
(caseBlanche)
if (damier[x][y].type == caseBlanche){
//Si le pion n'est pas une dame, il faut
imprérativement que le déplacement se fasse en avant (par rapport au coté du joueur)
if((!positionDebut.estDame) &&
(dx==1)){
if(((y-positionDebut.y) > 0) &&
(positionDebut.type == Bresil))
return false;
if(((y-positionDebut.y) < 0) && (positionDebut.type ==
France))
return false;
}
}
else
return false;
//Si le joueur saute un pion en faisant un
déplacement de 2
if(dx == 2){
pris = damier[(positionDebut.x + x) /
2][(positionDebut.y + y) / 2];
if(pris.type != (-positionDebut.type)){
pris = null;
if (!positionDebut.estDame)
return false;
}
else
if (pris.estDame)
Client.musique.Jouer("./son/hahachi.au");
}
else
if ((positionDebut.estDame) && (dx >
2)){
boolean temp = true;
int parcoursX =
positionDebut.x;
int parcoursY =
positionDebut.y;
while ((parcoursX != x)
&& (temp)){
if (positionDebut.x
> x)
parcoursX--;
else
parcoursX++;
if
(positionDebut.y > y)
parcoursY--;
else
parcoursY++;
if
((damier[parcoursX][parcoursY]).type == positionDebut.type)
temp
= false;
else
if
((damier[parcoursX][parcoursY]).type == -positionDebut.type){
if
(pris == null)
pris
= damier[parcoursX][parcoursY];
else
temp
= false;
}
}
if (!temp)
return false;
if (pris.estDame)
Client.musique.Jouer("./son/hahachi.au");
}
else
pris = null;
//Détermine la position de fin
positionFin = damier[x][y];
positionFin.repaint();
return true;
}//Fin de la méthode setPositionFin
//******************************méthode deplacerPion****************************
/** Méthode de déplacement d'un pion.
*
*
*/
public void deplacerPion(){
if((positionDebut == null) || (positionFin == null))
return;
historique.push(new Deplace(positionDebut, positionFin, pris));
// if pris, remove middle piece
if(pris != null){
pris.type = caseBlanche;
pris.estDame = false;
pris.highLight(false);
}
// if at end of Board, make a dame
if(((positionDebut.type == France) && (positionFin.y == lignesDamier)) ||
((positionDebut.type == Bresil) && (positionFin.y == 1))){
if (!positionDebut.estDame)
Client.musique.Jouer("./son/chirac3.au");
positionDebut.estDame = true;
}
// move piece
positionFin.type = positionDebut.type;
positionFin.estDame = positionDebut.estDame;
positionDebut.type = caseBlanche;
positionDebut.estDame = false;
positionDebut.highLight(false);
positionFin.highLight(false);
positionDebut = null;
positionFin = null;
pris = null;
changeAQui();
}//Fin de la méthode deplacerPion
//************************Méthode annulerDéplacement***************************
/** Méthode permettant le drenier déplacement du client courant.
*
*/
public void annulerDeplacement(){
Deplace deplace;
try{
deplace = (Deplace)historique.pop();
}
catch(EmptyStackException e){
return;
}
Pion s = deplace.getPositionDebut();
Pion d = deplace.getPositionFin();
Pion k = deplace.getPris();
if((s==null)||(d==null))
return;
if(positionDebut != null){
positionDebut.highLight(false);
positionDebut = null;
positionFin = null;
pris = null;
}
if(k != null){
damier[k.x][k.y].type = k.type;
damier[k.x][k.y].estDame = k.estDame;
damier[k.x][k.y].highLight(false);
}
damier[s.x][s.y].type = s.type;
damier[s.x][s.y].estDame = s.estDame;
damier[s.x][s.y].highLight(false);
damier[d.x][d.y].type = d.type;
damier[d.x][d.y].estDame = d.estDame;
damier[d.x][d.y].highLight(false);
aQui = s.type;
}//Fin de la méthode annulerDeplacement
//**************************Méthode changeAQui******************************
/** Méthode déterminant le joueur qui doit joueur.
*
*
*/
//Détermine le joueur qui doit joueur
public void changeAQui(){
aQui = (aQui == France) ? Bresil : France;
}//Fin de la méthode changeAQui
//*****************************Méthode getAQui*******************************
/** Méthode retournant le joueur qui doit joué.
*
*
*/
//A qui de jouer
public int getAQui(){
return aQui;
}//Fin de la méthode getAQui
//*************************Méthode dernierDeplacement************************
/** Méthode retournant le le dernier déplacement effectué.
*
*
*/
//retourne le dernier déplacement effectué
public Deplace dernierDeplacement(){
return (Deplace)historique.peek();
}//Fin de la méthode dernierDeplacement
//**************************Méthode setPionJoue******************************
/** Méthode permettant le déplacement du pion.
*@param <code>pionJoue</code> Pion à déplecer.
*
*/
public void setPionJoue(Pion pionJoue){
/*Si aucun pion n'est sélectionné, on sélectionne le pion sur lequel
le joueur vient de cliquer à la condition que ce ne soit pas une case blanche*/
if((positionDebut == null) && (pionJoue.type != caseBlanche)){
setPositionDebut(pionJoue.x, pionJoue.y);
return;
}
if(setPositionFin(pionJoue.x,pionJoue.y))
deplacerPion();
}//Fin de la méthode setPionJoue
}//Fin de la classe Damier