chessboard.java

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

     */
    public void GrandRoqueThrows() throws CoupException{
        if (promote){
            throw new CoupException("vous devez jouer une promotion");
        }
        if (!canGrandRoque(colorToPlay))
            throw new CoupException("Tu ne peux plus roquer de ce cote !");
        int y=getYroque();
        if (!isEmpty(1, y) || !isEmpty(2, y) || !isEmpty(3, y))
            throw new CoupException("les cases entre le roi et la tour ne sont pas vides");
        if (inChess(colorToPlay)){
            throw new CoupException("Vous etes en echec !");
        }
        try{
            if (CasesMenaced(colorToPlay, new Position(0, y), new Position(4, y))){
                throw new CoupException("vous traversez une position d'echec");
            }
        }catch (PosException e){
            e.printStackTrace();
            System.out.println("erreur grave");
            System.exit(0);
        }
    }
    /**
     * @brief renvoie l'ordonnee du roque en cours, selon la couleur qui doit jouer
     * @return 0 ou 7
     */
    protected int getYroque(){
        if (colorToPlay.equals(Color.white)){
            return 0;
        }else{
            return 7;
        }
    }
    /**
     * @brief effectue un grand roque
     * aucune verification n'est effectuee
     */
    protected void GrandRoqueNoCheck(){
        cantRoque(colorToPlay);
        int y=getYroque();
        colorToPlay=colorToPlay.oltherColor();
        PieceGoTo(4, y, 2, y);
        PieceGoTo(0, y, 3, y);
    }
    /**
     * @brief fait un grand roque
     * @throws bouffe.CoupException si on ne peut pas le faire
     */
    public void GrandRoque() throws CoupException{
        GrandRoqueThrows();
        GrandRoqueNoCheck();
    }
    /**
     * @brief fait un petit roque
     * @throws bouffe.CoupException si on ne peut pas le faire
     */
    public void PetitRoque() throws CoupException {
        PetitRoqueThrows();
        PetitRoqueNoCheck();
    }
    /**
     * @brief tente de faire un petit roque
     * @throws bouffe.CoupException si on ne peut pas le faire
     */
    public void PetitRoqueThrows() throws CoupException {
        if (promote){
            throw new CoupException("vous devez jouer une promotion");
        }
        if (!canPetitRoque(colorToPlay))
            throw new CoupException("Tu ne peux plus roquer de ce cote !");
        int y=getYroque();
        if (!isEmpty(5, y) || !isEmpty(6, y))
            throw new CoupException("les cases entre le roi et la tour ne sont pas vides");
        if (inChess(colorToPlay)){
            throw new CoupException("Vous etes en echec !");
        }
        try{
            if (CasesMenaced(colorToPlay, new Position(7, y), new Position(4, y))){
                throw new CoupException("vous traversez une position d'echec");
            }
        }catch (PosException e){
            System.out.println("erreur grave");
            System.exit(0);
        }
    }
    /**
     * @brief fait un petit roque sans effectuer de verifications
     */
    protected void PetitRoqueNoCheck(){
        int y=getYroque();
        cantRoque(colorToPlay);
        colorToPlay=colorToPlay.oltherColor();
        PieceGoTo(4, y, 6, y);
        PieceGoTo(7, y, 5, y);
    }
    /**
     * @brief dit si une case est vide ou pas
     * @param pos la position de la case
     * @return boolean
     */
    public boolean isEmpty(Position pos){
        return pieces[pos.x][pos.y].isEmpty();
    }
    /**
     * @brief dit si une case est vide ou pas
     * @param x la colone
     * @param y la ligne
     * @return boolean
     */
    public boolean isEmpty(int x, int y){
        return pieces[x][y].isEmpty();
    }
    /**
     * @brief dit si il n'y a pas de piece entre start et end
     * @param start la position de depart
     * @param end la position d'arrivee
     * @return boolean
     */
    public boolean nobodybetween(Position start, Position end){
        int i, j;
        try{
            Position p=new Position(start);
            p.marcherVers(end);
            while(!p.equals(end)){
                if (!pieces[p.x][p.y].isEmpty())
                    return false;
                p.marcherVers(end);
            }
        }catch(Exception e){
            System.out.println(e);
            e.printStackTrace();
            System.exit(0);
        }
        return true;
    }
    /**
     * @brief dit si une piece est un roi
     * @param p la position de la piece
     * @return boolean
     */
    public boolean isKing(Position p){
        return this.getPiece(p).getRule() instanceof Roi;
    }
    /**
     * @brief renvoie la piece qui est a la position p
     * @param p la position
     * @return la piece
     */
    protected Piece getPiece(Position p){ return pieces[p.x][p.y]; }
    /**
     * @brief renvoie la piece qui est a la position (x, y)
     * @param x la colone
     * @param y la ligne
     * @return la piece
     */
    protected Piece getPiece(int x, int y){ return pieces[x][y]; }
    /**
     * @brief dit si il reste des coups a jouer ou pas
     * @return
     */
    protected boolean HCoup(){
        CoupIterator c=new CoupIterator(this);
        return c.hasNext();
    }
    /**
     * @brief dit si la partie est finnie ou pas
     * met la couleur du gagnant dans la varible winner
     * @return true si la partie est finnie, false sinon
     */
    public boolean isEnded(){
        if (!HCoup()){
            if (inChess(colorToPlay)){
                winner=colorToPlay.oltherColor();
            }else{
                winner=Color.undef;
            }
            return true;
        }
        return false;
    }
    /**
     * @brief dit si un joueur est en echec
     * @param color la couleur du joueur qui est en echec
     * @return boolean
     */
    public boolean inChess(Color color){
        return CaseMenaced(color, getKingPosition(color));
    }
    /**
     * renvoie le nombre sur 2 bits qui caracterise les roques d'une couleur
     * @param c la couleur
     * @return int dans [0, 3]
     */
    protected int getRoques(Color c){
        if (c.equals(Color.white)){
            return roques & 0x3;
        }else{
            return (roques & 0xC ) >> 2;
        }
    }
    /**
     * @brief definit le nombre sur 2 bits qui caracterise les roques d'une couleur
     * @param c la couleur
     * @param r les roques (entre 0 et 3)
     */
    protected void setRoques(Color c, int r){
        if (c.equals(Color.white)){
            roques = roques & 0xC + r;
        }else{
            roques = roques & 0x3 + (r << 2); 
        }
    }
    /**
     * @brief dit qu'on ne pourra plus petit roquer
     * @param color la couleur de celui qui roque
     */
    protected void cantPetitRoque(Color color){
        setRoques(color, getRoques(color) & 1);
    }
    /**
     * @brief dit qu'on ne pourra plus grand roquer
     * @param color la couleur de celui qui roque
     */
    protected void cantGrandRoque(Color color){
        setRoques(color, getRoques(color) & 2);
    }
    /**
     * @brief dit qu'on ne pourra plus roquer du tout
     * @param color la couleur de celui qui roque
     */
    protected void cantRoque(Color color){
        //System.out.println("Les "+color+" ne peuvent plus roquer");
        setRoques(color, 0 );
    }
    /**
     * @brief dit si le joueur peut petit-roquer ou pas
     * @param color la couleur du joueur
     * @return true si il peut roquer, false sinon
     */
    public boolean canPetitRoque(Color color){
        return (getRoques(color)&2)!=0;
    }
    /**
     * @brief dit si le joueur peut grand-roquer ou pas
     * @param color la couleur du joueur
     * @return true si il peut roquer, false sinon
     */
    public boolean canGrandRoque(Color color){
        return (getRoques(color)&1)!=0;
    }
    /**
     * @brief donne la position du roi
     * @param c la couleur du roi dont on cherche la position
     * @return la position du roi de couleur c
     */
    public Position getKingPosition(Color c){
        int i, j;
        try{
            for (i=0;i<8;i++){
                for (j=0;j<8;j++){
                    if (pieces[i][j].getColor().equals(c)){
                        if (pieces[i][j].getRule() instanceof Roi)
                            return new Position(i, j);
                    }
                }
            }
        } catch(Exception e){
            System.out.println(e);
            e.printStackTrace();
            System.exit(0);
        }
        return null;    // cette ligne est debile, mais java l'impose pour pouvoir compiler
    }
    /**
     * @brief dit si les cases entre start et end sont menaces par une piece qui n'est pas de la couleur color
     * @param color la couleur des autres pieces
     * @param start la position de depart de la recherche
     * @param end la position de fin de la recherche
     * @return boolean
     */
    public boolean CasesMenaced(Color color, Position start, Position end){
        int i, j;
        try{
            Position p=new Position(start);
            p.marcherVers(end);
            while(!p.equals(end)){
                if (CaseMenaced(color, p))
                    return true;
                p.marcherVers(end);
            }
        }catch(Exception e){
            System.out.println(e);
            e.printStackTrace();
            System.exit(0);
        }
        return false;
    }
    /**
     * @brief dit si une case est menacee par une piece qui n'est pas de la couleur color
     * @param color couleur des pieces qui ne peuvent pas menacer les cases
     * @param p la position de la case a verifier
     * @return boolean
     */
    public boolean CaseMenaced(Color color, Position p){
        int i,j;
        Color olther=color.oltherColor();
        for (i=0;i<8;i++){
            for (j=0;j<8;j++){
                if (pieces[i][j].getColor().equals(olther)){
                    if (pieces[i][j].getRule().CanGoTo(p, this))
                        return true;
                }
            }
        }
        return false;
    }
    /**
     * @brief dessine une piece de l'echiquier
     * @param a l'url de l'image de la piece
     * @return une image d'une piece
     */
    public javax.swing.JLabel getImage(String a){
        java.net.URL url=getClass().getClassLoader().getResource(a);
        //System.out.println("loading "+url);
        javax.swing.ImageIcon icon = new javax.swing.ImageIcon(url);
        javax.swing.JLabel label = new javax.swing.JLabel(icon);
        label.setBounds(0,0, icon.getIconWidth(), icon.getIconHeight());
        return label;
    }
    
    /**
     * @brief affiche l'echiquer sur un JLayeredPane
     * @param layeredPane le conteneur de l'echiquier
     */
    public void showOn(javax.swing.JLayeredPane layeredPane){
        //String path=System.getenv("PWD")+"/";
        javax.swing.JLabel a;
        int i, j;
        layeredPane.removeAll();
        for (i = 0; i < 8; i++) {
            for (j = 0; j < 8; j++) {
                a = getImage("images/" + pieces[i][j].GetRepresentation() + ".gif");
                layeredPane.add(a);
                a.setLocation(30 + i * 40, 30 + 40 * 7 - j * 40);
            }
        }
        a = getImage("images/grille.gif");
        layeredPane.add(a);
        a.setLocation(30, 30);
        if (isEnded()){
            if (this.winner.equals(Color.white)){
                System.out.println("WHITE WINS");
            }else if (this.winner.equals(Color.black)){
                System.out.println("BLACK WINS");
            }else{
                System.out.println("PAT");
            }
        }
    }
    protected Color winner;
    protected boolean promote;
    /**
     * the Pieces array
     */
    protected Piece[][] pieces;
    /**
     * la couleur qui doit jouer le prochain coup
     */
    protected Color colorToPlay;
    /**
     * @brief le champ de bits sur lequel on stoque les possibilites de roques
     * on utilise en fait seulement les 4 derniers bits...
     * 1 dit que les blancs peuvent grand-roquer
     * 2 dit qu'ils peuvent petit-roquer
     * 4 dit que les noirs peuvent grand-roquer
     * 8 dit que les noirs peuvent petit roquer
     * ainsi, roques & 0xC code les roques possibles des noirs et roques & 0x3 celle des blancs
     * on peut meme pousser pour dire que roques & 0x3 est aux blancs ce que (roques & 0xC) >> 2 est aux noirs
     */
    protected int roques;
}