chessboard.java

利用JAVA编译的国际象棋中各棋子的步法。

/*
 * (Copyleft) coucou747
 * Code sous licence GPL,
 * pour toute degradation de votre honneur,
 * je ne saurais en aucun cas etre tennu responsable
 * 
 * Si l'une des proprietes suivante vennait a etre verifiee :
 *  -Si vous avez des idees d'ameliorations possibles,
 *  -Si vous avez developpe des ameliorations
 *  -Si mon projet vous plait
 *  -Si mon code vous plait
 *  -Si vous vous servez de mon code
 *  -Si vous aimez les chips
 *  -Si vous avez trouve des bugs
 *  -Si vous avez fixe des bugs (c'est gentil :) )
 *  -Si vous avez fait un projet base sur celui-ci
 *  -Si vous voullez me faire des bisous
 * faites le moi savoir
 *  -par mail a l'adresse [e-mail]
 *  -par irc sur uni-irc.net salon #programmation
 *  -par msn a l'adresse [e-mail]
 * 
 * Remerciements a mon ex-petite amie,
 * c'est probablement grace a elle que j'ai trouve le temps de coder ca...
 */

package echec;

/**
 * @brief Une class qui decrit un plateau d'echec,
 * avec les coups possibles d'echec.
 * @author max
 */
public class Chessboard {
    /**
     * @brief Constructeur
     */
    public Chessboard(){
        promote=false;
        roques=0x0F;
        colorToPlay=Color.white;
        try{
            pieces=new Piece[8][];
            for (int i=0;i<8;i++){
                pieces[i]=new Piece[8];
                for (int j=0;j<8;j++){
                    pieces[i][j]=new Piece(new Position(i, j));
                }
            }
            for (int i=0;i<8;i++){
                pieces[i][0].setColor(Color.white);
                pieces[i][1].setColor(Color.white);
                pieces[i][6].setColor(Color.black);
                pieces[i][7].setColor(Color.black);
                pieces[i][6].setPieceType(new Pion());
                pieces[i][1].setPieceType(new Pion());
            }
            pieces[1][0].setPieceType(new Cavalier());
            pieces[6][0].setPieceType(new Cavalier());
            pieces[1][7].setPieceType(new Cavalier());
            pieces[6][7].setPieceType(new Cavalier());
            
            pieces[0][0].setPieceType(new Tour());
            pieces[7][0].setPieceType(new Tour());
            pieces[0][7].setPieceType(new Tour());
            pieces[7][7].setPieceType(new Tour());
            
            pieces[2][0].setPieceType(new Fou());
            pieces[5][0].setPieceType(new Fou());
            pieces[2][7].setPieceType(new Fou());
            pieces[5][7].setPieceType(new Fou());
            
            pieces[3][7].setPieceType(new Dame());
            pieces[4][7].setPieceType(new Roi());
            
            pieces[3][0].setPieceType(new Dame());
            pieces[4][0].setPieceType(new Roi());
        }catch (PosException e){
            System.out.println(e);
            e.printStackTrace();
            System.exit(0);
        }
    }
    /**
     * @brief affiche une ligne entre deux lignes de pieces
     * permet l'affichage mode console
     */
    protected void nl(){
        for (int i=0;i<9;i++)
            System.out.print("----");
        System.out.println();
    }
    /**
     * @brief affiche l'echiquier
     */
    public void print(){
        for (int i=0;i<8;i++){
            System.out.print((char)('a'+i));
            for (int j=0;j<8;j++){
                System.out.print(" | ");
                System.out.print(pieces[i][j].GetRepresentation());
            }
            System.out.println(" |");
            nl();
        }
        System.out.print(" ");
        for(int i=0;i<8;i++){
            System.out.print(" | "+(i+1));
        }
        System.out.println();
    }
    /**
     * @brief tente de faire une prise en passant
     * @param start la position de depart
     * @param end la position d'arrivee
     * @throws bouffe.CoupException l'exception levee si on ne peut pas prendre en passant
     */
    public void TakeInPassThrows(Position start, Position end) throws CoupException{
        Color colorPlay=pieces[start.x][start.y].getColor();
        if (promote){
            throw new CoupException("vous devez jouer une promotion");
        }
        if (!colorPlay.equals(colorToPlay)){
            throw new CoupException("c'est pas a toi de jouer !");
        }
        if (! (pieces[end.x][end.y].isEmpty())){
            throw new CoupException("Destination "+end+" non vide !");
        }
        if (! (pieces[start.x][start.y].getRule() instanceof Pion)){
            throw new CoupException("ce n'est pas un pion qui prend en passant !");
        }
        PieceRule r=pieces[end.x][start.y].getRule();
        if (r instanceof Pion){
            Pion p=(Pion)r;
            if ( end.dx(start)==1 && (
                    (end.y==start.y+1 && colorPlay.equals(Color.white) ) ||
                    (end.y==start.y-1 && colorPlay.equals(Color.black) )
                    ))
            {
                if (!p.enpassant()){
                    throw new CoupException("le pion ne peut pas etre pris en passant !");
                }
                
                Piece save=pieces[end.x][start.y];
                this.PieceGoTo(start, end);
                pieces[end.x][start.y]=new Piece(start);
                boolean b=this.inChess(colorPlay);
                this.PieceGoTo(end, start);
                pieces[end.x][start.y]=save;
                if (b){
                    throw new CoupException("vous seriez en echec apres avoir joue");
                }
            }else{
                throw new CoupException("vous ne vous deplacez pas dans le bon sens");
            }
        }else{
            throw new CoupException("vous tentez de prendre autre chose qu'un pion ! "+r);
        }
    }
    /**
     * @brief dit si on peut jouer de start en end.
     * @param start la position de depart
     * @param end la position d'arrivee
     * @return boolean (true si on peut se deplacer, false sinon)
     */
    public boolean CanPlay(Position start, Position end){
        return CanTakeInPass(start, end) || canMove(start, end);
    }
    /**
     * dit si on peut prendre en passant ou non
     * @param start la position de depart
     * @param end la position d'arrivee
     * @return boolean (true si on peut prendre en passant, false sinon)
     */
    public boolean CanTakeInPass(Position start, Position end){
        try{
            TakeInPassThrows(start, end);
            return true;
        }catch(CoupException e){
            //System.out.println(e);
            return false;
        }
    }
    /**
     * @brief prend en passant
     * @param start la position de depart
     * @param end la position d'arrivee
     * @throws bouffe.CoupException si on ne peut pas se deplacer
     */
    public void TakeInPass(Position start, Position end) throws CoupException{
        TakeInPassThrows(start, end);
        TakeInPassNoCheck(start, end);
    }
    /**
     * @brief prend en passant sans effectuer de verifications
     * @param start la position de depart
     * @param end la position d'arrivee
     */
    protected void TakeInPassNoCheck(Position start, Position end){
        moveNoCheck(start, end);                    // on bouge
        pieces[end.x][start.y]=new Piece(start);    // on prend l'autre piece
    }
    /**
     * @brief dit si on peut bouger ou pas
     * @param start la case de depart
     * @param end la case d'arrivee
     * @return boolean
     */
    public boolean canMove(Position start, Position end){
        try{
            canMoveThrows(start, end);
            return true;
        }catch(CoupException e){
            //System.out.println(e);
            return false;
        }
    }
    /**
     * @brief permet de savoir si on peut prometre ou pas
     * @return renvoie true si il y a une promotion possible
     */
    public boolean canPromote(){
        return promote;
    }
    /**
     * @brief effectue une promotion
     * @param rule la piece
     * @throws bouffe.CoupException si on ne peut pas faire la promotion
     */
    public void promote(PieceRule rule) throws CoupException{
        if (!promote){
            throw new CoupException("vous ne pouvez pas promouvoir");
        }
        if (
                rule instanceof Dame ||
                rule instanceof Tour ||
                rule instanceof Cavalier ||
                rule instanceof Fou){
            for (int i=0;i<8;i++){
                if (pieces[i][0].getRule() instanceof Pion){
                    pieces[i][0].setPieceType(rule);
                    promote=false;
                    colorToPlay=colorToPlay.oltherColor();
                    return;
                }
                if (pieces[i][7].getRule() instanceof Pion){
                    pieces[i][7].setPieceType(rule);
                    promote=false;
                    colorToPlay=colorToPlay.oltherColor();
                    return;
                }
            }
        }else{
            throw new CoupException("la promotion ne peut pas se faire vers ce type de piece");
        }
    }
    /**
     * @brief ceci detecte les pions a prometre
     * @return true si on doit faire une promotion, false sinon
     */
    protected boolean havePionPromote(){
        for (int i=0;i<8;i++){
            if (pieces[i][0].getRule() instanceof Pion){
                return true;
            }
            if (pieces[i][7].getRule() instanceof Pion){
                return true;
            }
        }
        return false;
    }
    /**
     * @brief bouge une piece
     * @param start depart
     * @param end arrivee
     * @throws bouffe.CoupException la raison de l'impossibilite du deplacement
     */
    public void move(Position start, Position end) throws CoupException{
        //System.out.println(roques);
        canMoveThrows(start, end);
        moveNoCheck(start, end);
        if (havePionPromote()){
            promote=true;
            colorToPlay=colorToPlay.oltherColor();
        }
    }
    /**
     * @brief dit si on peut bouger une piece
     * @param start la case de depart
     * @param end la case d'arrivee
     * @throws bouffe.CoupException c'est leve si on ne peut pas bouger
     */
    protected void canMoveThrows(Position start, Position end) throws CoupException{
        boolean prise=!isEmpty(end);
        Color colorPlay=pieces[start.x][start.y].getColor();
        if (promote){
            throw new CoupException("vous devez jouer une promotion");
        }
        if (!colorPlay.equals(colorToPlay)){
            throw new CoupException("c'est pas a toi de jouer !");
        }else if (prise && colorPlay.equals(pieces[end.x][end.y].getColor())){
            throw new CoupException("vous cherchez a vous prendre vous meme...");
        }else if (pieces[start.x][start.y].isEmpty()){
            throw new CoupException("Case vide");
        }else if (!pieces[start.x][start.y].getRule().CanGoTo(end, this)){
            throw new CoupException("Coup invalide ("+pieces[start.x][start.y].GetRepresentation()+")");
        }else{
            Piece oldP=pieces[end.x][end.y];

            pieces[end.x][end.y]=pieces[start.x][start.y];
            pieces[start.x][start.y].setPosition(end, false);
            pieces[start.x][start.y]=new Piece(start);
            
            colorToPlay=colorToPlay.oltherColor();
            boolean a=inChess(colorPlay);
            colorToPlay=colorToPlay.oltherColor();
            
            pieces[start.x][start.y]=pieces[end.x][end.y];
            pieces[start.x][start.y].setPosition(start, false);
            pieces[end.x][end.y]=oldP;
            
            if (a){
                throw new CoupException("vous vous metteriez echec !");
            }
        }
    }
    /**
     * @bief on bouge une piece sans effectuer aucune verification
     * @param start la case de depart
     * @param end la case d'arrivee
     */
    protected void moveNoCheck(Position start, Position end){
        
        if (pieces[start.x][start.y].getRule() instanceof Roi){
            cantRoque(colorToPlay);
        }
        int y=getYroque();
        if (start.y==y && pieces[start.x][start.y].getRule() instanceof Tour){
            if (start.x==0){
                cantGrandRoque(colorToPlay);
            }else if (start.x==7){
                cantPetitRoque(colorToPlay);
            }
        }
        colorToPlay=colorToPlay.oltherColor();
        
        System.out.println("On bouge un "+pieces[start.x][start.y].GetRepresentation());
        System.out.println("c'est aux "+colorToPlay+"s de jouer");
        //System.out.println("roques : "+roques);
        PieceGoTo(start, end, true);
    }
    protected void PieceGoTo(Position start, Position end, boolean b){
        pieces[end.x][end.y]=pieces[start.x][start.y];
        pieces[start.x][start.y].setPosition(end, b);
        pieces[start.x][start.y]=new Piece(start);
    }
    /**
     * @brief deplace une piece sans aucune verification, sans changer la couleur du joueur qui doit jouer
     * @param start la position de depart
     * @param end la position d'arrivee
     */
    protected void PieceGoTo(Position start, Position end){
        PieceGoTo(start, end, false);
    }
    /**
     * @brief deplace une piece sans aucune verification, sans changer la couleur du joueur qui doit jouer
     * @param startx la colone de depart
     * @param starty la ligne de depart
     * @param endx la colone d'arrivee
     * @param endy la ligne d'arrivee
     */
    protected void PieceGoTo(int startx, int starty, int endx, int endy){
        try{
            PieceGoTo(new Position(startx, starty), new Position(endx, endy));
        }catch(Exception e){
            System.out.println("erreur grave : "+e);
            e.printStackTrace();
            System.exit(1);
        }
    }
    /**
     * @brief tente de faire un grand roque
     * @throws bouffe.CoupException si on ne peut pas faire de grand roque