package chess2;
import java.util.ArrayList;
public class ChessBoard implements ChessConstants{
    
    int blackMoveXPos;
    int blackMoveYPos;
    Piece blackMovePiece;
    int whiteMoveXPos;
    int whiteMoveYPos;
    Piece whiteMovePiece;
    public ArrayList<Bishop> bishops = new ArrayList(4);
    public  ArrayList<Pawn> pawns = new ArrayList(16);
    public  ArrayList<Rook> rooks = new ArrayList(4);
    public  ArrayList<Knight> knights = new ArrayList(4);
    public  ArrayList<Queen> queens = new ArrayList(2);
    public ArrayList<MysteryPiece> mysteryPieces = new ArrayList();
    public ArrayList<Monkey> monkeys = new ArrayList();
    public ArrayList<Tank> tanks = new ArrayList();
    public ArrayList<Wall> walls = new ArrayList();
    public ArrayList<Corpse> corpses = new ArrayList();
    public ArrayList<TacoFiend> tacoFiends = new ArrayList();
    public ArrayList<WildCard> wildCards = new ArrayList();
    public  King whiteKing;
    public  King blackKing;
    public King secondWhiteKing;
    public King secondBlackKing;
    public Toaster whiteToaster;
    public Toaster blackToaster;
    public boolean wellExploded = false;
    boolean whiteHasKilled = false;
    int whiteKillCount;
    int whiteKillXPOS;
    int whiteKillYPOS;
    boolean blackHasKilled = false;
    int blackKillXPOS;
    int blackKillYPOS;
    int blackKillCount;
    ChessGame game;
    public ChessBoard (){
        ChessGame GAME = ChessGame.NORMAL;
        game = GAME;
        walls.add(new Wall(A, _2));
        walls.add(new Wall(B, _2));
        walls.add(new Wall(C, _2));
        walls.add(new Wall(D, _2));
        walls.add(new Wall(E, _2));
        walls.add(new Wall(F, _2));
        walls.add(new Wall(G, _2));
        walls.add(new Wall(H, _2));
        walls.add(new Wall(A, _7));
        walls.add(new Wall(B, _7));
        walls.add(new Wall(C, _7));
        walls.add(new Wall(D, _7));
        walls.add(new Wall(E, _7));
        walls.add(new Wall(F, _7));
        walls.add(new Wall(G, _7));
        walls.add(new Wall(H, _7));
        walls.add(new Wall(E, _1));
        walls.add(new Wall(C, _1));
        walls.add(new Wall(E, _8));
        walls.add(new Wall(C, _8));
        pawns.add(new Pawn(Side.WHITE, C, _3, this, GAME));
        pawns.add(new Pawn(Side.BLACK, F, _6, this, GAME));
        whiteKing = new King(Side.WHITE, D, _1, this, GAME);
        whiteKing.air=3;
        blackKing = new King(Side.BLACK, D, _8, this, GAME);
        blackKing.air=3;
    }
    public ChessBoard(ChessGame GAME){
        game = GAME;
      if (GAME==ChessGame.NORMAL){
        bishops.add(new Bishop(Side.WHITE, C, _1, this, GAME));
        bishops.add(new Bishop(Side.WHITE, F, _1, this, GAME));
        bishops.add(new Bishop(Side.BLACK, C, _8, this, GAME));
        bishops.add(new Bishop(Side.BLACK, F, _8, this, GAME));
        pawns.add(new Pawn(Side.WHITE, A, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, B, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, C, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, D, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, E, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, F, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, G, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, H, _2, this, GAME));
        pawns.add(new Pawn(Side.BLACK, A, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, B, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, C, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, D, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, E, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, F, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, G, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, H, _7, this, GAME));
        rooks.add(new Rook(Side.WHITE, A,  _1, this, GAME));
        rooks.add(new Rook(Side.WHITE, H, _1, this, GAME));
        rooks.add(new Rook(Side.BLACK, A, _8, this, GAME));
        rooks.add(new Rook(Side.BLACK, H, _8, this, GAME));
        knights.add(new Knight(Side.WHITE, B, _1, this, GAME));
        knights.add(new Knight(Side.WHITE, G, _1, this, GAME));
        knights.add(new Knight(Side.BLACK, B, _8, this, GAME));
        knights.add(new Knight(Side.BLACK, G, _8, this, GAME));
        queens.add(new Queen(Side.WHITE, D, _1, this, GAME));
        queens.add(new Queen(Side.BLACK, D, _8, this, GAME));
        whiteKing = new King(Side.WHITE, E, _1, this, GAME);
        blackKing = new King(Side.BLACK, E, _8, this, GAME);
      }
      else if (GAME==ChessGame.ADULTERY){
        bishops.add(new Bishop(Side.WHITE, C, _1, this, GAME));
        bishops.add(new Bishop(Side.BLACK, F, _1, this, GAME));
        bishops.add(new Bishop(Side.WHITE, C, _8, this, GAME));
        bishops.add(new Bishop(Side.BLACK, F, _8, this, GAME));
        pawns.add(new Pawn(Side.WHITE, A, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, B, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, C, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, D, _2, this, GAME));
        pawns.add(new Pawn(Side.BLACK, E, _2, this, GAME));
        pawns.add(new Pawn(Side.BLACK, F, _2, this, GAME));
        pawns.add(new Pawn(Side.BLACK, G, _2, this, GAME));
        pawns.add(new Pawn(Side.BLACK, H, _2, this, GAME));
        pawns.add(new Pawn(Side.WHITE, A, _7, this, GAME));
        pawns.add(new Pawn(Side.WHITE, B, _7, this, GAME));
        pawns.add(new Pawn(Side.WHITE, C, _7, this, GAME));
        pawns.add(new Pawn(Side.WHITE, D, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, E, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, F, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, G, _7, this, GAME));
        pawns.add(new Pawn(Side.BLACK, H, _7, this, GAME));
        rooks.add(new Rook(Side.WHITE, A,  _1, this, GAME));
        rooks.add(new Rook(Side.BLACK, H, _1, this, GAME));
        rooks.add(new Rook(Side.WHITE, A, _8, this, GAME));
        rooks.add(new Rook(Side.BLACK, H, _8, this, GAME));
        knights.add(new Knight(Side.WHITE, B, _1, this, GAME));
        knights.add(new Knight(Side.BLACK, G, _1, this, GAME));
        knights.add(new Knight(Side.WHITE, B, _8, this, GAME));
        knights.add(new Knight(Side.BLACK, G, _8, this, GAME));
        queens.add(new Queen(Side.WHITE, D, _1, this, GAME));
        queens.add(new Queen(Side.BLACK, E, _8, this, GAME));
        whiteKing = new King(Side.WHITE, D, _8, this, GAME);
        blackKing = new King(Side.BLACK, E, _1, this, GAME);
      }
      else{
        wellExploded = true;
        bishops.add(new Bishop(Side.WHITE, C, _2, this, GAME));
        bishops.add(new Bishop(Side.WHITE, F, _2, this, GAME));
        bishops.add(new Bishop(Side.BLACK, C, _7, this, GAME));
        bishops.add(new Bishop(Side.BLACK, F, _7, this, GAME));
        pawns.add(new Pawn(Side.WHITE, A, _1, this, GAME));
        pawns.add(new Pawn(Side.WHITE, B, _1, this, GAME));
        pawns.add(new Pawn(Side.WHITE, C, _1, this, GAME));
        pawns.add(new Pawn(Side.WHITE, D, _3, this, GAME));
        pawns.add(new Pawn(Side.WHITE, E, _3, this, GAME));
        pawns.add(new Pawn(Side.WHITE, F, _1, this, GAME));
        pawns.add(new Pawn(Side.WHITE, G, _1, this, GAME));
        pawns.add(new Pawn(Side.WHITE, H, _1, this, GAME));
        pawns.add(new Pawn(Side.BLACK, A, _8, this, GAME));
        pawns.add(new Pawn(Side.BLACK, B, _8, this, GAME));
        pawns.add(new Pawn(Side.BLACK, C, _8, this, GAME));
        pawns.add(new Pawn(Side.BLACK, D, _6, this, GAME));
        pawns.add(new Pawn(Side.BLACK, E, _6, this, GAME));
        pawns.add(new Pawn(Side.BLACK, F, _8, this, GAME));
        pawns.add(new Pawn(Side.BLACK, G, _8, this, GAME));
        pawns.add(new Pawn(Side.BLACK, H, _8, this, GAME));
        rooks.add(new Rook(Side.WHITE, A,  _2, this, GAME));
        rooks.add(new Rook(Side.WHITE, H, _2, this, GAME));
        rooks.add(new Rook(Side.BLACK, A, _7, this, GAME));
        rooks.add(new Rook(Side.BLACK, H, _7, this, GAME));
        knights.add(new Knight(Side.WHITE, B, _2, this, GAME));
        knights.add(new Knight(Side.WHITE, G, _2, this, GAME));
        knights.add(new Knight(Side.BLACK, B, _7, this, GAME));
        knights.add(new Knight(Side.BLACK, G, _7, this, GAME));
        queens.add(new Queen(Side.WHITE, E, _2, this, GAME));
        queens.add(new Queen(Side.BLACK, E, _7, this, GAME));
        whiteKing = new King(Side.WHITE, D, _2, this, GAME);
        blackKing = new King(Side.BLACK, D, _7, this, GAME);
        if (GAME==ChessGame.PEASANT||GAME==ChessGame.MONKEY){
            whiteToaster = new Toaster(Side.WHITE, D, _2, E, _2, this, GAME);
            blackToaster = new Toaster(Side.BLACK, D, _7, E, _7, this, GAME);
        }
      }
    }
    public ChessBoard(ChessBoard cloneBoard){
        game = cloneBoard.game;
        for (int i=0;i<cloneBoard.bishops.size();i++){
           bishops.add(new Bishop(cloneBoard.bishops.get(i).side, cloneBoard.bishops.get(i).xPos, cloneBoard.bishops.get(i).yPos, this, cloneBoard.game));
            this.bishops.get(i).inTank = cloneBoard.bishops.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.pawns.size();i++){
            pawns.add(new Pawn(cloneBoard.pawns.get(i).side, cloneBoard.pawns.get(i).xPos, cloneBoard.pawns.get(i).yPos, cloneBoard.pawns.get(i).hasMoved, this, cloneBoard.game));
            this.pawns.get(i).inTank = cloneBoard.pawns.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.rooks.size();i++){
            rooks.add(new Rook(cloneBoard.rooks.get(i).side, cloneBoard.rooks.get(i).xPos, cloneBoard.rooks.get(i).yPos, this, cloneBoard.game));
            this.rooks.get(i).inTank = cloneBoard.rooks.get(i).inTank;
            this.rooks.get(i).hasMoved = cloneBoard.rooks.get(i).hasMoved;
        }
        for (int i=0;i<cloneBoard.knights.size();i++){
            knights.add(new Knight(cloneBoard.knights.get(i).side, cloneBoard.knights.get(i).xPos, cloneBoard.knights.get(i).yPos, this, cloneBoard.game));
            this.knights.get(i).inTank = cloneBoard.knights.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.queens.size();i++){
            queens.add(new Queen(cloneBoard.queens.get(i).side, cloneBoard.queens.get(i).xPos, cloneBoard.queens.get(i).yPos, this, cloneBoard.game));
            this.queens.get(i).inTank = cloneBoard.queens.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.corpses.size();i++){
            corpses.add(new Corpse(cloneBoard.corpses.get(i).side, cloneBoard.corpses.get(i).xPos, cloneBoard.corpses.get(i).yPos, this, cloneBoard.game));
            this.corpses.get(i).inTank = cloneBoard.corpses.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.walls.size();i++){
            walls.add(new Wall(cloneBoard.walls.get(i).xPos, cloneBoard.walls.get(i).yPos));
            this.walls.get(i).inTank = cloneBoard.walls.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.mysteryPieces.size();i++){
            mysteryPieces.add(new MysteryPiece(cloneBoard.mysteryPieces.get(i).side, cloneBoard.mysteryPieces.get(i).xPos, cloneBoard.mysteryPieces.get(i).yPos, this, cloneBoard.game));
            this.mysteryPieces.get(i).inTank = cloneBoard.mysteryPieces.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.monkeys.size();i++){
            monkeys.add(new Monkey(cloneBoard.monkeys.get(i).side, cloneBoard.monkeys.get(i).xPos, cloneBoard.monkeys.get(i).yPos, this, cloneBoard.game));
            this.monkeys.get(i).inTank = cloneBoard.monkeys.get(i).inTank;
        }
        for (int i=0;i<cloneBoard.tanks.size();i++){
            tanks.add(new Tank(cloneBoard.tanks.get(i).side, cloneBoard.tanks.get(i).projXPos1, cloneBoard.tanks.get(i).projYPos1,
                    cloneBoard.tanks.get(i).projXPos2, cloneBoard.tanks.get(i).projYPos2, this, cloneBoard.game));
        }
        for (int i=0;i<cloneBoard.tacoFiends.size();i++){
            tacoFiends.add(new TacoFiend(cloneBoard.tacoFiends.get(i).side, cloneBoard.tacoFiends.get(i).xPos, cloneBoard.tacoFiends.get(i).yPos, this, cloneBoard.game));
            this.tacoFiends.get(i).inTank = cloneBoard.tacoFiends.get(i).inTank;
        }

        if (cloneBoard.whiteKing!=null){
                whiteKing = new King(Side.WHITE, cloneBoard.whiteKing.xPos, cloneBoard.whiteKing.yPos, this, cloneBoard.game);
                whiteKing.air = cloneBoard.whiteKing.air;
                whiteKing.hasMoved = cloneBoard.whiteKing.hasMoved;

        }
        if (cloneBoard.blackKing!=null){
                blackKing = new King(Side.BLACK, cloneBoard.blackKing.xPos, cloneBoard.blackKing.yPos, this, cloneBoard.game);
                blackKing.air = cloneBoard.blackKing.air;
                blackKing.hasMoved = cloneBoard.blackKing.hasMoved;
        }
        blackKillCount = cloneBoard.blackKillCount;
        whiteKillCount = cloneBoard.whiteKillCount;
        whiteToaster = cloneBoard.whiteToaster;
        blackToaster = cloneBoard.blackToaster;
        whiteMovePiece = cloneBoard.whiteMovePiece;
        whiteMoveXPos = cloneBoard.whiteMoveXPos;
        whiteMoveYPos = cloneBoard.whiteMoveYPos;
        blackMovePiece = cloneBoard.blackMovePiece;
        blackMoveXPos = cloneBoard.blackMoveXPos;
        blackMoveYPos = cloneBoard.blackMoveYPos;
       
    }
     public boolean inRangeOfBoard(int XPOS, int YPOS){
        if (YPOS<=_1&&YPOS>=_8&&XPOS>=A&&XPOS<=H){
            return true;
        }
        return false;
    }
    public boolean inCheckMate(Side side){
        if (yourKing(side)!=null&&yourKing(side).inCheckMate()){
            return true;
      }
      else if (yourKing(side)==null){
          boolean isDefeated = true;
          for (int i=0;i<wildCards.size();i++){
              if (!wildCards.get(i).inCheck()){
                  isDefeated = false;
              }
          }
          if (isDefeated){
              return true;
          }
      }
        return false;
    }
    public boolean squareAdjacentToSquare(int xPos1, int yPos1, int xPos2, int yPos2){
        if (Math.abs(xPos1-xPos2)<=100&&Math.abs(yPos1-yPos2)<=100){
            return true;
        }
        return false;
    }
    public boolean squareAdjacentToEmpty(int xPos, int yPos){
        if (sideOccupyingSquare(xPos, yPos)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos+100, yPos)&&sideOccupyingSquare(xPos+100, yPos)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos-100, yPos)&&sideOccupyingSquare(xPos-100, yPos)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos, yPos+100)&&sideOccupyingSquare(xPos, yPos+100)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos, yPos-100)&&sideOccupyingSquare(xPos, yPos-100)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos+100, yPos+100)&&sideOccupyingSquare(xPos+100, yPos+100)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos+100, yPos-100)&&sideOccupyingSquare(xPos+100, yPos-100)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos-100, yPos+100)&&sideOccupyingSquare(xPos-100, yPos+100)==Side.NONE){return true;}
        if (inRangeOfBoard(xPos-100, yPos-100)&&sideOccupyingSquare(xPos-100, yPos-100)==Side.NONE){return true;}
        return false;
    }
    public void clearSquare(int XPOS, int YPOS){
        for (int i=0;i<queens.size();i++){
            if (queens.get(i).xPos==XPOS&&queens.get(i).yPos==YPOS){
                queens.remove(i);
            }
        }
        
        for (int i=0;i<pawns.size();i++){
            if (pawns.get(i).xPos==XPOS&&pawns.get(i).yPos==YPOS){
                pawns.remove(i);
            }
        }
        for (int i=0;i<rooks.size();i++){
            if (rooks.get(i).xPos==XPOS&&rooks.get(i).yPos==YPOS){
                rooks.remove(i);
            }
        }
        for (int i=0;i<knights.size();i++){
            if (knights.get(i).xPos==XPOS&&knights.get(i).yPos==YPOS){
                knights.remove(i);
            }
        }
        for (int i=0;i<bishops.size();i++){
            if (bishops.get(i).xPos==XPOS&&bishops.get(i).yPos==YPOS){
                bishops.remove(i);
            }
        }
        
        for (int i=0;i<mysteryPieces.size();i++){
            if (mysteryPieces.get(i).xPos==XPOS&&mysteryPieces.get(i).yPos==YPOS){
                mysteryPieces.remove(i);
            }
        }
        for (int i=0;i<walls.size();i++){
            if (walls.get(i).xPos==XPOS&&walls.get(i).yPos==YPOS){
                walls.remove(i);
            }
        }
        for (int i=0;i<corpses.size();i++){
            if (corpses.get(i).xPos==XPOS&&corpses.get(i).yPos==YPOS){
                corpses.remove(i);
            }
        }

        for (int i=0;i<tacoFiends.size();i++){
            if (tacoFiends.get(i).xPos==XPOS&&tacoFiends.get(i).yPos==YPOS){
                tacoFiends.remove(i);
            }
        }
        for (int i=0;i<monkeys.size();i++){
            if (monkeys.get(i).xPos==XPOS&&monkeys.get(i).yPos==YPOS){
                monkeys.remove(i);
            }
        }
        for (int i=0;i<wildCards.size();i++){
            if (wildCards.get(i).xPos==XPOS&&wildCards.get(i).yPos==YPOS){
                wildCards.remove(i);
            }
        }
        if (whiteKing!=null&&whiteKing.xPos==XPOS&&whiteKing.yPos==YPOS){
            whiteKing=null;
        }
        if (blackKing!=null&&blackKing.xPos==XPOS&&blackKing.yPos==YPOS){
            blackKing=null;
        }
        if (game==ChessGame.ADULTERY){
            if (whiteKing==null){
                whiteKing = new King(Side.WHITE, D, _8, this, game);
            }
            if (blackKing==null){
                blackKing = new King(Side.BLACK, E, _1, this, game);
            }
        }
    }
    public void clearToaster(Side SIDE){
        if (SIDE==Side.WHITE){
            clearSquare(D, _2);
            clearSquare(E, _2);
        }
        else{
            clearSquare(D, _7);
            clearSquare(E, _7);
        }
    }
    public void clearTankCompartment(int XPOS, int YPOS){
        switch(pieceOccupyingSquareLite(XPOS, YPOS)){
            case NONE: return;
            case KING:
                if (whiteKing!=null&&whiteKing.xPos==XPOS&&whiteKing.yPos==YPOS){
                    whiteKing=null;
                }
                if (blackKing!=null&&blackKing.xPos==XPOS&&blackKing.yPos==YPOS){
                    blackKing=null;
                }
                break;
            case QUEEN: queens.remove(getQueen(XPOS, YPOS));
                break;
            case BISHOP: bishops.remove(getBishop(XPOS, YPOS));
                break;
            case KNIGHT: knights.remove(getKnight(XPOS, YPOS));
                break;
            case ROOK: rooks.remove(getRook(XPOS, YPOS));
                break;
            case PAWN: pawns.remove(getPawn(XPOS, YPOS));
                break;
            case MONKEY: monkeys.remove(getMonkey(XPOS, YPOS));
                break;
            case MYSTERYPIECE: mysteryPieces.remove(getMysteryPiece(XPOS, YPOS));
                break;
            case TACOFIEND: tacoFiends.remove(getTacoFiend(XPOS, YPOS));
                break;
        }
    }
    public void clearTank(Tank TANK){
        clearTankCompartment(TANK.projXPos1, TANK.projYPos1);
        clearTankCompartment(TANK.projXPos2, TANK.projYPos2);
    }
    public boolean inBarrel(int XPOS, int YPOS){
        if (game==ChessGame.NORMAL||game==ChessGame.ADULTERY){
            return false;
        }
        if (wellExploded){
            return false;
        }
        if (XPOS==D||XPOS==E){
            if (YPOS==_4||YPOS==_5){
                return true;
            }
        }
        return false;
    }
    public boolean inChapel(int XPOS, int YPOS){
        if (game!=ChessGame.PEASANT){
            return false;
        }
        if (XPOS==C||XPOS==F){
            if (YPOS==_4||YPOS==_5){
                return true;
            }
        }
        return false;
    }
    public boolean onPermWall(int XPOS, int YPOS){
        if (game!=ChessGame.PEASANT){
            return false;
        }
        if (XPOS==B||XPOS==G){
            if (YPOS==_4||YPOS==_5){
                return true;
            }
        }
        return false;
    }
    public boolean inDisco(int XPOS, int YPOS){
        if (game!=ChessGame.PEASANT){
            return false;
        }
        if (XPOS==B||XPOS==G){
            if (YPOS==_4||YPOS==_5){
                return true;
            }
        }
        return false;
    }
    public boolean toasterLoaded(Side SIDE){
        if (SIDE==Side.WHITE){
            return whiteToasterLoaded();
        }
        else{
            return blackToasterLoaded();
        }
    }
    public boolean whiteToasterLoaded(){
        if (sideOccupyingSquare(D, _2)!=Side.NONE){return true;}
        if (sideOccupyingSquare(E, _2)!=Side.NONE){return true;}
        return false;
    }
    public boolean blackToasterLoaded(){
        if (sideOccupyingSquare(D, _7)!=Side.NONE){return true;}
        if (sideOccupyingSquare(E, _7)!=Side.NONE){return true;}
        return false;
    }
    public boolean inToaster(Side SIDE, int XPOS, int YPOS){
        if (SIDE==Side.WHITE){
            return inWhiteToaster(XPOS, YPOS);
        }
        else{
            return inBlackToaster(XPOS, YPOS);
        }
    }
    public boolean inWhiteToaster(int XPOS, int YPOS){
        if (!(game==ChessGame.PEASANT||game==ChessGame.MONKEY)){
            return false;
        }
        if (XPOS==D||XPOS==E){
            if (YPOS==_2){
                return true;
            }
        }
        return false;
    }
    public boolean inBlackToaster(int XPOS, int YPOS){
        if (!(game==ChessGame.PEASANT||game==ChessGame.MONKEY)){
            return false;
        }
        if (XPOS==D||XPOS==E){
            if (YPOS==_7){
                return true;
            }
        }
        return false;
    }
    public boolean equals(ChessBoard BOARD){
        if (BOARD==null){
            return false;
        }
        else if(BOARD==this){
            return true;
        }
        else{
            if (this.bishops.size()!=BOARD.bishops.size()){
                return false;
            }
            if (this.pawns.size()!=BOARD.pawns.size()){
                return false;
            }
            if (this.knights.size()!=BOARD.knights.size()){
                return false;
            }
            if (this.rooks.size()!=BOARD.rooks.size()){
                return false;
            }
            if (this.queens.size()!=BOARD.queens.size()){
                return false;
            }
            for (int i=0;i<this.bishops.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.bishops.size();n++){
                    if (this.bishops.get(i).xPos==BOARD.bishops.get(n).xPos&&this.bishops.get(i).yPos==BOARD.bishops.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.pawns.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.pawns.size();n++){
                    if (this.pawns.get(i).xPos==BOARD.pawns.get(n).xPos&&this.pawns.get(i).yPos==BOARD.pawns.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.rooks.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.rooks.size();n++){
                    if (this.rooks.get(i).xPos==BOARD.rooks.get(n).xPos&&this.rooks.get(i).yPos==BOARD.rooks.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.knights.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.knights.size();n++){
                    if (this.knights.get(i).xPos==BOARD.knights.get(n).xPos&&this.knights.get(i).yPos==BOARD.knights.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.queens.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.queens.size();n++){
                    if (this.queens.get(i).xPos==BOARD.queens.get(n).xPos&&this.queens.get(i).yPos==BOARD.queens.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.walls.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.walls.size();n++){
                    if (this.walls.get(i).xPos==BOARD.walls.get(n).xPos&&this.walls.get(i).yPos==BOARD.walls.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.corpses.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.corpses.size();n++){
                    if (this.corpses.get(i).xPos==BOARD.corpses.get(n).xPos&&this.corpses.get(i).yPos==BOARD.corpses.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.monkeys.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.monkeys.size();n++){
                    if (this.monkeys.get(i).xPos==BOARD.monkeys.get(n).xPos&&this.monkeys.get(i).yPos==BOARD.monkeys.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.wildCards.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.wildCards.size();n++){
                    if (this.wildCards.get(i).xPos==BOARD.wildCards.get(n).xPos&&this.wildCards.get(i).yPos==BOARD.wildCards.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.tanks.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.tanks.size();n++){
                    if (this.tanks.get(i).projXPos1==BOARD.tanks.get(n).projXPos1&&this.queens.get(i).projYPos1==BOARD.queens.get(n).projYPos1
                            &&this.tanks.get(i).projXPos2==BOARD.tanks.get(i).projXPos2&&this.tanks.get(i).projYPos2==BOARD.tanks.get(i).projYPos2){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            for (int i=0;i<this.tacoFiends.size();i++){
                boolean match = false;
                for (int n=0;n<BOARD.tacoFiends.size();n++){
                    if (this.tacoFiends.get(i).xPos==BOARD.tacoFiends.get(n).xPos&&this.tacoFiends.get(i).yPos==BOARD.tacoFiends.get(n).yPos){
                        match = true;
                    }
                }
                if (!match){
                    return false;
                }
            }
            if (whiteKing!=null&&!(this.whiteKing.xPos==BOARD.whiteKing.xPos&&this.whiteKing.yPos==BOARD.whiteKing.yPos)){
                return false;
            }
            if (whiteKing!=null&&BOARD.whiteKing!=null&&whiteKing!=null&&whiteKing.air!=BOARD.whiteKing.air){
                return false;
            }
            if (whiteKing!=null&&BOARD.whiteKing!=null&&whiteKing.hasMoved!=BOARD.whiteKing.hasMoved){
                return false;
            }
            if (blackKing!=null&&BOARD.blackKing!=null&&!(this.blackKing.xPos==BOARD.blackKing.xPos&&this.blackKing.yPos==BOARD.blackKing.yPos)){
                return false;
            }
            if (blackKing!=null&&BOARD.blackKing!=null&&blackKing.air!=BOARD.blackKing.air){
                return false;
            }
            if (blackKing!=null&&blackKing.hasMoved!=BOARD.blackKing.hasMoved){
                return false;
            }
        }
        return true;
    }
    public Side sideOccupyingSquare(int XPOS, int YPOS){
     if (!inRangeOfBoard(XPOS, YPOS))
     {
         return Side.NULL;
     }
     for (int i=0;i<pawns.size();i++){
           if (pawns.get(i).getXPos()==XPOS && pawns.get(i).getYPos()==YPOS){
               if (pawns.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }

       for (int i=0;i<knights.size();i++){
           if (knights.get(i).getXPos()==XPOS && knights.get(i).getYPos()==YPOS){
               if (knights.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
     for (int i=0;i<wildCards.size();i++){
           if (wildCards.get(i).getXPos()==XPOS && wildCards.get(i).getYPos()==YPOS){
               if (wildCards.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
            for (int i=0;i<rooks.size();i++){
           if (rooks.get(i).getXPos()==XPOS && rooks.get(i).getYPos()==YPOS){
               if (rooks.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
            for (int i=0;i<bishops.size();i++){
           if (bishops.get(i).getXPos()==XPOS && bishops.get(i).getYPos()==YPOS){
               if (bishops.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       for (int i=0;i<queens.size();i++){
           if (queens.get(i).getXPos()==XPOS && queens.get(i).getYPos()==YPOS){
               if (queens.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       for (int i=0;i<mysteryPieces.size();i++){
           if (mysteryPieces.get(i).getXPos()==XPOS && mysteryPieces.get(i).getYPos()==YPOS){
               if (mysteryPieces.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       for (int i=0;i<tanks.size();i++){
           if ((tanks.get(i).projXPos1==XPOS&&tanks.get(i).projYPos1==YPOS)||(tanks.get(i).projXPos2==XPOS&&tanks.get(i).projYPos2==YPOS)){
               if (tanks.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       for (int i=0;i<monkeys.size();i++){
           if (monkeys.get(i).getXPos()==XPOS && monkeys.get(i).getYPos()==YPOS){
               if (monkeys.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       for (int i=0;i<tacoFiends.size();i++){
           if (tacoFiends.get(i).getXPos()==XPOS && tacoFiends.get(i).getYPos()==YPOS){
               if (tacoFiends.get(i).getSide()==Side.BLACK){
                   return Side.BLACK;
               }
               else {
                   return Side.WHITE;
               }
           }
       }
       if (blackKing!=null&&blackKing.getXPos()==XPOS&&blackKing.getYPos()==YPOS){
           return Side.BLACK;
       }
       if (whiteKing!=null&&whiteKing.getXPos()==XPOS&&whiteKing.getYPos()==YPOS){
           return Side.WHITE;
       }
     if (onPermWall(XPOS, YPOS)){
         return Side.PERMWALL;
     }
     for (int i=0;i<walls.size();i++){
           if (walls.get(i).getXPos()==XPOS && walls.get(i).getYPos()==YPOS){
               return Side.WALL;
           }
        }
        for (int i=0;i<corpses.size();i++){
           if (corpses.get(i).getXPos()==XPOS && corpses.get(i).getYPos()==YPOS){

               return Side.CORPSE;
           }
       }

       return Side.NONE;
   }

    public void kill(ChessPiece KILLER, int XPOS, int YPOS){

        if (KILLER.game==ChessGame.MONKEY||KILLER.game==ChessGame.PEASANT){
            if (pieceOccupyingSquare(XPOS, YPOS)!=Piece.TANK){corpses.add(new Corpse(KILLER.side, XPOS, YPOS, KILLER.yourBoard, KILLER.game));}
            else{
               for (int i=0;i<tanks.size();i++){
          if ((tanks.get(i).projXPos1==XPOS&&tanks.get(i).projYPos1==YPOS)||(tanks.get(i).projXPos2==XPOS&&tanks.get(i).projYPos2==YPOS)){
            if (tanks.get(i).side==Side.WHITE){
                blackHasKilled = true;
            }
            else{
                whiteHasKilled = true;
            }
            tanks.remove(i);
            return;
          }
      }
            }
        }
        kill(KILLER.xPos, KILLER.yPos, XPOS, YPOS);
    }
    public void kill(int lastXPOS, int lastYPOS, int XPOS, int YPOS){
        for (int i=0;i<queens.size();i++){
          if (queens.get(i).xPos==XPOS&&queens.get(i).yPos==YPOS){
            if (queens.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            if (game==ChessGame.ADULTERY){
                if (queens.get(i).side==Side.WHITE){
                    queens.remove(i);
                    clearSquare(D, _1);
                    queens.add(new Queen(Side.WHITE, D, _1, this, ChessGame.ADULTERY));

                }
                else if (queens.get(i).side==Side.BLACK){
                    queens.remove(i);
                    clearSquare(E, _8);
                    queens.add(new Queen(Side.BLACK, E, _8, this, ChessGame.ADULTERY));
                }
            }
            else{
                queens.remove(i);
            }
            return;
          }
      }
    for (int i=0;i<pawns.size();i++){

          if (pawns.get(i).xPos==XPOS&&pawns.get(i).yPos==YPOS){
            if (pawns.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            pawns.remove(i);
            return;
          }
      }

      for (int i=0;i<rooks.size();i++){
          if (rooks.get(i).xPos==XPOS&&rooks.get(i).yPos==YPOS){
            if (rooks.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            rooks.remove(i);
            return;
          }
      }
      for (int i=0;i<bishops.size();i++){
          if (bishops.get(i).xPos==XPOS&&bishops.get(i).yPos==YPOS){
            if (bishops.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            bishops.remove(i);
            return;
          }
      }
      for (int i=0;i<knights.size();i++){
          if (knights.get(i).xPos==XPOS&&knights.get(i).yPos==YPOS){
            if (knights.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            knights.remove(i);
            return;
          }
      }
      
    for (int i=0;i<mysteryPieces.size();i++){
          if (mysteryPieces.get(i).xPos==XPOS&&mysteryPieces.get(i).yPos==YPOS){
            if (mysteryPieces.get(i).side==Side.WHITE){
                blackHasKilled = true;
                blackKillXPOS = lastXPOS;
                blackKillYPOS = lastYPOS;
            }
            else{
                whiteHasKilled = true;
                whiteKillXPOS = lastXPOS;
                whiteKillYPOS = lastYPOS;
            }
            mysteryPieces.remove(i);
            return;
          }
      }
     
     for (int i=0;i<walls.size();i++){
          if (walls.get(i).xPos==XPOS&&walls.get(i).yPos==YPOS){
            walls.remove(i);
          }
      }
      
     if (blackKing!=null&&blackKing.xPos==XPOS&&blackKing.yPos==YPOS){
         if (game==ChessGame.ADULTERY){
            blackKing = null;
            if (whiteKing!=null&&whiteKing.xPos==E&&whiteKing.yPos==_1){
                kill(E, _7, D, _8);
                whiteKing.xPos = D;
                whiteKing.yPos = _1;
            }
            for (int i=0;i<queens.size();i++){
//                if (whiteKing!=null&&queens.get(i).side==Side.WHITE&&queens.get(i).xPos==D&&queens.get(i).yPos==_8){
//                    kill(E, _7, D, _1);
//                    queens.get(i).xPos = D;
//                    queens.get(i).yPos = _1;
//                }
//                if (queens.get(i).side==Side.BLACK&&queens.get(i).xPos==D&&queens.get(i).yPos==_8){
//                    kill(E, _7, E, _8);
//                    queens.get(i).xPos = E;
//                    queens.get(i).yPos = _8;
//                }
            }
            clearSquare(E, _1);
            blackKing = new King(Side.BLACK, E, _1, this, ChessGame.ADULTERY);
         }
         else{
             blackKing = null;
         }
     }
    if (whiteKing!=null&&whiteKing.xPos==XPOS&&whiteKing.yPos==YPOS){
         whiteKing = null;
         if (game==ChessGame.ADULTERY){
            if (blackKing!=null&&blackKing.xPos==E&&blackKing.yPos==_1){
                kill(E, _7, E, _1);
                blackKing.xPos = E;
                blackKing.yPos = _1;
            }
            for (int i=0;i<queens.size();i++){
//                if (blackKing!=null&&queens.get(i).side==Side.WHITE&&queens.get(i).xPos==E&&queens.get(i).yPos==_1){
//                    kill(E, _7, D, _1);
//                    queens.add(new Queen(Side.WHITE));
//                }
//                if (queens.get(i).side==Side.BLACK&&queens.get(i).xPos==E&&queens.get(i).yPos==_1){
//                    kill(E, _7, E, _8);
//                    queens.get(i).xPos = E;
//                    queens.get(i).yPos = _8;
//                }
            }
            clearSquare(D, _8);
            whiteKing = new King(Side.WALL, D, _8, this, ChessGame.ADULTERY);
         }
         else{
            whiteKing = null;
         }
     }
    if (secondBlackKing!=null&&secondBlackKing.xPos==XPOS&&secondBlackKing.yPos==YPOS){
         secondBlackKing = null;
     }
    if (secondWhiteKing!=null&&secondWhiteKing.xPos==XPOS&&secondWhiteKing.yPos==YPOS){
         secondWhiteKing = null;
     }
    if (game==ChessGame.ADULTERY){
        boolean haswhite = false;
        boolean hasblack = false;
        for (int i=0;i<queens.size();i++){
            if (queens.get(i).side==Side.WHITE){
                haswhite = true;
            }
            if (queens.get(i).side==Side.BLACK){
                hasblack = true;
            }
        }
        if (!haswhite){
            queens.add(new Queen(Side.WHITE, D, _1, this, game));
        }
        if (!hasblack){
            queens.add(new Queen(Side.BLACK, E, _8, this, game));
        }

    }
  }
    public Piece pieceOccupyingSquareLite(int XPOS, int YPOS){

     for (int i=0;i<pawns.size();i++){
         if (pawns.get(i).getXPos()==XPOS&&pawns.get(i).getYPos()==YPOS){
             return Piece.PAWN;
         }
     }

     for (int i=0;i<wildCards.size();i++){
         if (wildCards.get(i).getXPos()==XPOS&&wildCards.get(i).getYPos()==YPOS){
             return Piece.WILDCARD;
         }
     }
     for (int i=0;i<mysteryPieces.size();i++){
         if (mysteryPieces.get(i).getXPos()==XPOS&&mysteryPieces.get(i).getYPos()==YPOS){
             return Piece.MYSTERYPIECE;
         }
     }
     for (int i=0;i<monkeys.size();i++){
         if (monkeys.get(i).getXPos()==XPOS&&monkeys.get(i).getYPos()==YPOS){
             return Piece.MONKEY;
         }
     }
     for (int i=0;i<tacoFiends.size();i++){
         if (tacoFiends.get(i).getXPos()==XPOS&&tacoFiends.get(i).getYPos()==YPOS){
             return Piece.TACOFIEND;
         }
     }
       for (int i=0;i<rooks.size();i++){
           if (rooks.get(i).getXPos()==XPOS && rooks.get(i).getYPos()==YPOS){
               return Piece.ROOK;
           }
       }
       for (int i=0;i<knights.size();i++){
           if (knights.get(i).getXPos()==XPOS && knights.get(i).getYPos()==YPOS){
               return Piece.KNIGHT;
           }
       }
            for (int i=0;i<bishops.size();i++){
           if (bishops.get(i).getXPos()==XPOS && bishops.get(i).getYPos()==YPOS){
                return Piece.BISHOP;
           }
       }
       for (int i=0;i<queens.size();i++){
           if (queens.get(i).getXPos()==XPOS && queens.get(i).getYPos()==YPOS){
              return Piece.QUEEN;
           }
       }
       if (blackKing!=null&&blackKing.getXPos()==XPOS&&blackKing.getYPos()==YPOS){
           return Piece.KING;
       }
       if (whiteKing!=null&&whiteKing.getXPos()==XPOS&&whiteKing.getYPos()==YPOS){
           return Piece.KING;
       }

      for (int i=0;i<walls.size();i++){
         if (walls.get(i).getXPos()==XPOS&&walls.get(i).getYPos()==YPOS){
             return Piece.WALL;
         }
     }
     for (int i=0;i<corpses.size();i++){
         if (corpses.get(i).getXPos()==XPOS&&corpses.get(i).getYPos()==YPOS){
             return Piece.CORPSE;
         }
     }


       return Piece.NONE;
   }
    public Piece pieceOccupyingSquare(int XPOS, int YPOS){
    if (!ChessApplet.entertank){
         for (int i=0;i<tanks.size();i++){
             if ((tanks.get(i).projXPos1==XPOS&&tanks.get(i).projYPos1==YPOS)||(tanks.get(i).projXPos2==XPOS&&tanks.get(i).projYPos2==YPOS)){
                 return Piece.TANK;
             }
         }
     }
     if (ChessApplet.fire){
         if (inWhiteToaster(XPOS, YPOS)||inBlackToaster(XPOS, YPOS)){
             return Piece.TOASTER;
         }
     }

     for (int i=0;i<pawns.size();i++){
         if (pawns.get(i).getXPos()==XPOS&&pawns.get(i).getYPos()==YPOS){
             return Piece.PAWN;
         }
     }

     for (int i=0;i<wildCards.size();i++){
         if (wildCards.get(i).getXPos()==XPOS&&wildCards.get(i).getYPos()==YPOS){
             return Piece.WILDCARD;
         }
     }


     for (int i=0;i<mysteryPieces.size();i++){
         if (mysteryPieces.get(i).getXPos()==XPOS&&mysteryPieces.get(i).getYPos()==YPOS){
             return Piece.MYSTERYPIECE;
         }
     }
     for (int i=0;i<monkeys.size();i++){
         if (monkeys.get(i).getXPos()==XPOS&&monkeys.get(i).getYPos()==YPOS){
             return Piece.MONKEY;
         }
     }
     for (int i=0;i<tacoFiends.size();i++){
         if (tacoFiends.get(i).getXPos()==XPOS&&tacoFiends.get(i).getYPos()==YPOS){
             return Piece.TACOFIEND;
         }
     }
       for (int i=0;i<rooks.size();i++){
           if (rooks.get(i).getXPos()==XPOS && rooks.get(i).getYPos()==YPOS){
               return Piece.ROOK;
           }
       }
       for (int i=0;i<knights.size();i++){
           if (knights.get(i).getXPos()==XPOS && knights.get(i).getYPos()==YPOS){
               return Piece.KNIGHT;
           }
       }
            for (int i=0;i<bishops.size();i++){
           if (bishops.get(i).getXPos()==XPOS && bishops.get(i).getYPos()==YPOS){
                return Piece.BISHOP;
           }
       }
       for (int i=0;i<queens.size();i++){
           if (queens.get(i).getXPos()==XPOS && queens.get(i).getYPos()==YPOS){
              return Piece.QUEEN;
           }
       }
       if (blackKing!=null&&blackKing.getXPos()==XPOS&&blackKing.getYPos()==YPOS){
           return Piece.KING;
       }
       if (whiteKing!=null&&whiteKing.getXPos()==XPOS&&whiteKing.getYPos()==YPOS){
           return Piece.KING;
       }
       if (inWhiteToaster(XPOS, YPOS)){
           return Piece.TOASTER;
       }
       if (inBlackToaster(XPOS, YPOS)){
           return Piece.TOASTER;
       }
      for (int i=0;i<walls.size();i++){
         if (walls.get(i).getXPos()==XPOS&&walls.get(i).getYPos()==YPOS){
             return Piece.WALL;
         }
     }
     for (int i=0;i<corpses.size();i++){
         if (corpses.get(i).getXPos()==XPOS&&corpses.get(i).getYPos()==YPOS){
             return Piece.CORPSE;
         }
     }
     for (int i=0;i<tanks.size();i++){
         if ((tanks.get(i).projXPos1==XPOS&&tanks.get(i).projYPos1==YPOS)||(tanks.get(i).projXPos2==XPOS&&tanks.get(i).projYPos2==YPOS)){
             return Piece.TANK;
         }
     }
     if (inToaster(Side.WHITE, XPOS, YPOS)||inToaster(Side.BLACK, XPOS, YPOS)){
         return Piece.TOASTER;
     }

       return Piece.NONE;
   }

  public boolean sideAccesses(Side SIDE, int XPOS, int YPOS){
      for (int i=0;i<pawns.size();i++){
          if (pawns.get(i).side==SIDE&&(pawns.get(i).canMoveTo(XPOS, YPOS)||pawns.get(i).occupies(XPOS, YPOS))){
              return true;
          }
      }
      for (int i=0;i<knights.size();i++){
          if (knights.get(i).side==SIDE&&(knights.get(i).canMoveTo(XPOS, YPOS)||knights.get(i).occupies(XPOS, YPOS))){
              return true;
          }
      }
      for (int i=0;i<bishops.size();i++){
          if (bishops.get(i).side==SIDE&&(pawns.get(i).canMoveTo(XPOS, YPOS)||pawns.get(i).occupies(XPOS, YPOS))){
              return true;
          }
      }
      for (int i=0;i<rooks.size();i++){
          if (rooks.get(i).side==SIDE&&(rooks.get(i).canMoveTo(XPOS, YPOS)||rooks.get(i).occupies(XPOS, YPOS))){
              return true;
          }
      }
      for (int i=0;i<queens.size();i++){
          if (queens.get(i).side==SIDE&&(queens.get(i).canMoveTo(XPOS, YPOS)||queens.get(i).occupies(XPOS, YPOS))){
              return true;
          }
      }
      if (yourKing(SIDE).occupies(XPOS, YPOS)||yourKing(SIDE).canMoveTo(XPOS, YPOS)){
          return true;
      }
      return false;
  }
   public void addWall(int XPOS, int YPOS){
       if (game!=ChessGame.NORMAL&&game!=ChessGame.INSECURE&&game!=ChessGame.ADULTERY&&level(XPOS, YPOS)==0){
                walls.add(new Wall(XPOS, YPOS));
       }
   }
   public void controlMinds(Side SIDE){
    if (game==ChessGame.NORMAL||game==ChessGame.ADULTERY){
        return;
    }

      for (int i=0;knights.size()>0&&i<knights.size();i++){

          if (knights.get(i).side==SIDE&&knights.get(i).numberOfChecks()>=3){

              if (knights.get(i).side==Side.WHITE){
                  knights.get(i).side = Side.BLACK;
                  knights.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  knights.get(i).side = Side.WHITE;
                  knights.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (knights.get(i).numberOfChecks()>=3){
                  knights.remove(i);
              }
          }



      }
    for (int i=0;queens.size()>0&&i<queens.size();i++){

          if (queens.get(i).side==SIDE&&queens.get(i).numberOfChecks()>=3){

              if (queens.get(i).side==Side.WHITE){
                  queens.get(i).side = Side.BLACK;
                  queens.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  queens.get(i).side = Side.WHITE;
                  queens.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (queens.get(i).numberOfChecks()>=3){
                  queens.remove(i);
              }
          }



      }
      for (int i=0;rooks.size()>0&&i<rooks.size();i++){

          if (rooks.get(i).side==SIDE&&rooks.get(i).numberOfChecks()>=3){

              if (rooks.get(i).side==Side.WHITE){
                  rooks.get(i).side = Side.BLACK;
                  rooks.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  rooks.get(i).side = Side.WHITE;
                  rooks.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
                  }
              if (rooks.get(i).numberOfChecks()>=3){
                  rooks.remove(i);
              }
          }



      }
      for (int i=0;mysteryPieces.size()>0&&i<mysteryPieces.size();i++){

          if (mysteryPieces.get(i).side==SIDE&&mysteryPieces.get(i).numberOfChecks()>=3){

              if (mysteryPieces.get(i).side==Side.WHITE){
                  mysteryPieces.get(i).side = Side.BLACK;
                  mysteryPieces.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  mysteryPieces.get(i).side = Side.WHITE;
                  mysteryPieces.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (mysteryPieces.get(i).numberOfChecks()>=3){
                  mysteryPieces.remove(i);
              }
          }



      }
    for (int i=0;pawns.size()>0&&i<pawns.size();i++){
          if (pawns.get(i).side==SIDE&&pawns.get(i).numberOfChecks()>=3){
              if (pawns.get(i).side==Side.WHITE){
                  pawns.get(i).side = Side.BLACK;
                  pawns.get(i).opponentSide = Side.WHITE;
                  pawns.get(i).hasMoved=false;
                  if (pawns.get(i).numberOfChecks()>=3){
                      pawns.remove(i);
                  }
                  if (pawns.get(i).yPos==_1){
                      promotePawn(Side.BLACK, pawns.get(i).xPos, pawns.get(i).yPos);
                  }
                  if (pawns.get(i).numberOfChecks()>=3){
                      pawns.remove(i);
                  }
              }
              else{
                  pawns.get(i).side = Side.WHITE;
                  pawns.get(i).opponentSide = Side.BLACK;
                  pawns.get(i).hasMoved=false;
                  if (pawns.get(i).numberOfChecks()>=3){
                      pawns.remove(i);
                  }
                  if (pawns.get(i).yPos==_8){
                      promotePawn(Side.WHITE, pawns.get(i).xPos, pawns.get(i).yPos);
                  }
              }

          }



      }

      for (int i=0;bishops.size()>0&&i<bishops.size();i++){

          if (bishops.get(i).side==SIDE&&bishops.get(i).numberOfChecks()>=3){

              if (bishops.get(i).side==Side.WHITE){
                  bishops.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  bishops.get(i).side = Side.WHITE;
                  bishops.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (bishops.get(i).numberOfChecks()>=3){
                  bishops.remove(i);
              }

          }
      }
    for (int i=0;monkeys.size()>0&&i<monkeys.size();i++){

          if (monkeys.get(i).side==SIDE&&monkeys.get(i).numberOfChecks()>=3){

              if (monkeys.get(i).side==Side.WHITE){
                  monkeys.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  monkeys.get(i).side = Side.WHITE;
                  monkeys.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (monkeys.get(i).numberOfChecks()>=3){
                  bishops.remove(i);
              }

          }
      }
    for (int i=0;tacoFiends.size()>0&&i<tacoFiends.size();i++){

          if (tacoFiends.get(i).side==SIDE&&tacoFiends.get(i).numberOfChecks()>=3){

              if (tacoFiends.get(i).side==Side.WHITE){
                  tacoFiends.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  tacoFiends.get(i).side = Side.WHITE;
                  tacoFiends.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (tacoFiends.get(i).numberOfChecks()>=3){
                  tacoFiends.remove(i);
              }

          }
      }
    for (int i=0;wildCards.size()>0&&i<wildCards.size();i++){

          if (wildCards.get(i).side==SIDE&&wildCards.get(i).numberOfChecks()>=3){

              if (wildCards.get(i).side==Side.WHITE){
                  wildCards.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  wildCards.get(i).side = Side.WHITE;
                  wildCards.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (wildCards.get(i).numberOfChecks()>=3){
                  wildCards.remove(i);
              }

          }
      }
    for (int i=0;tanks.size()>0&&i<tanks.size();i++){

          if (tanks.get(i).side==SIDE&&tanks.get(i).numberOfChecks()>=3){

              if (tanks.get(i).side==Side.WHITE){
                  tanks.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  tanks.get(i).side = Side.WHITE;
                  tanks.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (tanks.get(i).numberOfChecks()>=3){
                  tanks.remove(i);
              }

          }
      }

  }
   public void controlMindsMinusKingChecking(Side SIDE){
    if (game==ChessGame.NORMAL){
        return;
    }

      for (int i=0;knights.size()>0&&i<knights.size();i++){

          if (knights.get(i).side==SIDE&&knights.get(i).numberOfChecksMinusKingChecking()>=3){

              if (knights.get(i).side==Side.WHITE){
                  knights.get(i).side = Side.BLACK;
                  knights.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  knights.get(i).side = Side.WHITE;
                  knights.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (knights.get(i).numberOfChecksMinusKingChecking()>=3){
                  knights.remove(i);
              }
          }
      }
    for (int i=0;queens.size()>0&&i<queens.size();i++){

          if (queens.get(i).side==SIDE&&queens.get(i).numberOfChecksMinusKingChecking()>=3){

              if (queens.get(i).side==Side.WHITE){
                  queens.get(i).side = Side.BLACK;
                  queens.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  queens.get(i).side = Side.WHITE;
                  queens.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (queens.get(i).numberOfChecksMinusKingChecking()>=3){
                  queens.remove(i);
              }
          }
      }
      for (int i=0;rooks.size()>0&&i<rooks.size();i++){

          if (rooks.get(i).side==SIDE&&rooks.get(i).numberOfChecksMinusKingChecking()>=3){

              if (rooks.get(i).side==Side.WHITE){
                  rooks.get(i).side = Side.BLACK;
                  rooks.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  rooks.get(i).side = Side.WHITE;
                  rooks.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (rooks.get(i).numberOfChecksMinusKingChecking()>=3){
                  rooks.remove(i);
              }
          }
      }
      for (int i=0;mysteryPieces.size()>0&&i<mysteryPieces.size();i++){

          if (mysteryPieces.get(i).side==SIDE&&mysteryPieces.get(i).numberOfChecksMinusKingChecking()>=3){

              if (mysteryPieces.get(i).side==Side.WHITE){
                  mysteryPieces.get(i).side = Side.BLACK;
                  mysteryPieces.get(i).opponentSide = Side.WHITE;
                  blackHasKilled = true;
              }
              else{
                  mysteryPieces.get(i).side = Side.WHITE;
                  mysteryPieces.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (mysteryPieces.get(i).numberOfChecksMinusKingChecking()>=3){
                  mysteryPieces.remove(i);
              }
          }
      }
    for (int i=0;pawns.size()>0&&i<pawns.size();i++){
          if (pawns.get(i).side==SIDE&&pawns.get(i).numberOfChecksMinusKingChecking()>=3){
              if (pawns.get(i).side==Side.WHITE){
                  pawns.get(i).side = Side.BLACK;
                  pawns.get(i).opponentSide = Side.WHITE;
                  pawns.get(i).hasMoved=false;
                  if (pawns.get(i).numberOfChecksMinusKingChecking()>=3){
                      pawns.remove(i);
                  }
                  if (pawns.get(i).yPos==_1){
                      promotePawn(Side.BLACK, pawns.get(i).xPos, pawns.get(i).yPos);
                  }
                  if (pawns.get(i).numberOfChecksMinusKingChecking()>=3){
                      pawns.remove(i);
                  }
              }
              else{
                  pawns.get(i).side = Side.WHITE;
                  pawns.get(i).opponentSide = Side.BLACK;
                  pawns.get(i).hasMoved=false;
                  if (pawns.get(i).numberOfChecksMinusKingChecking()>=3){
                      pawns.remove(i);
                  }
                  if (pawns.get(i).yPos==_8){
                      promotePawn(Side.WHITE, pawns.get(i).xPos, pawns.get(i).yPos);
                  }
              }
              if (pawns.get(i).numberOfChecksMinusKingChecking()>=3){
                  pawns.remove(i);
              }
          }
      }

      for (int i=0;bishops.size()>0&&i<bishops.size();i++){

          if (bishops.get(i).side==SIDE&&bishops.get(i).numberOfChecksMinusKingChecking()>=3){

              if (bishops.get(i).side==Side.WHITE){
                  bishops.get(i).side = Side.BLACK;
                  blackHasKilled = true;
              }
              else{
                  bishops.get(i).side = Side.WHITE;
                  bishops.get(i).opponentSide = Side.BLACK;
                  whiteHasKilled = true;
              }
              if (bishops.get(i).numberOfChecksMinusKingChecking()>=3){
                  bishops.remove(i);
              }
          }
      }
  }
   public void marry(int XPOS, int YPOS, Side SIDE){
       Side opponentSide;
       if (SIDE==Side.WHITE){opponentSide=Side.BLACK;}
       else {opponentSide=Side.WHITE;}
       switch(pieceOccupyingSquare(XPOS, YPOS)){
           case KING: yourKing(opponentSide).setSide(SIDE);
               break;
           case QUEEN: getQueen(XPOS, YPOS).setSide(SIDE);
               break;
           case BISHOP: getBishop(XPOS, YPOS).setSide(SIDE);
               break;
           case CORPSE: getCorpse(XPOS, YPOS).setSide(SIDE);
               break;
           case ROOK: getRook(XPOS, YPOS).setSide(SIDE);
               break;
           case KNIGHT: getKnight(XPOS, YPOS).setSide(SIDE);
               break;
           case PAWN: getPawn(XPOS, YPOS).setSide(SIDE);
               break;
           case MYSTERYPIECE: getMysteryPiece(XPOS, YPOS).setSide(SIDE);
               break;
           case TACOFIEND: getTacoFiend(XPOS, YPOS).setSide(SIDE);
               break;
           case TANK: getTank(XPOS, YPOS).setSide(SIDE);
               break;

       }
   }
   public void countBlackKills(){
       if (game==ChessGame.NORMAL||game==ChessGame.ADULTERY){
           return;
       }
       if (blackHasKilled){
            blackKillCount++;
            if (blackKillCount==3){
                 for (int i=0;i<walls.size();i++){
                    if (walls.get(i).xPos==blackKillXPOS&&walls.get(i).yPos==blackKillYPOS){
                        walls.remove(i);
                    }
                }
                mysteryPieces.add(new MysteryPiece(Side.BLACK, blackKillXPOS, blackKillYPOS, this, game));
                blackKillCount=0;
            }
        }
        else{
           blackKillCount = 0;
        }
       blackHasKilled = false;
   }
   public void countWhiteKills(){
       if (game==ChessGame.NORMAL||game==ChessGame.ADULTERY){
           return;
       }
       if (whiteHasKilled){
            whiteKillCount++;
            if (whiteKillCount==3){
                for (int i=0;i<walls.size();i++){
                    if (walls.get(i).xPos==whiteKillXPOS&&walls.get(i).yPos==whiteKillYPOS){
                        walls.remove(i);
                    }
                }
                mysteryPieces.add(new MysteryPiece(Side.WHITE, whiteKillXPOS, whiteKillYPOS, this, game));
                whiteKillCount=0;
            }
        }
        else{
            whiteKillCount = 0;
        }
      whiteHasKilled = false;
   }
  public int level(int XPOS, int YPOS){
       int level = 0;
       for (int i=0;i<corpses.size();i++){
           if (corpses.get(i).xPos==XPOS&&corpses.get(i).yPos==YPOS){
               level++;
           }
       }
       for (int i=0;i<walls.size();i++){
           if (walls.get(i).xPos==XPOS&&walls.get(i).yPos==YPOS&&!walls.get(i).inTank){
               level++;
               break;
           }
       }
       if (onPermWall(XPOS, YPOS)){
           level++;
       }
       return level;
   }
  public void explode(int XPOS, int YPOS){
      int[] xPosits = {XPOS, XPOS, XPOS, XPOS+100, XPOS+100, XPOS+100, XPOS-100, XPOS-100, XPOS-100};
      int[] yPosits = {YPOS, YPOS+100, YPOS-100, YPOS, YPOS+100, YPOS-100, YPOS, YPOS+100, YPOS-100};
      for (int n=0;n<9;n++){
          for (int i=0;i<pawns.size();i++){
              if (pawns.get(i).xPos==xPosits[n]&&pawns.get(i).yPos==yPosits[n]){
                  pawns.remove(i);
                  break;
              }
          }
          for (int i=0;i<bishops.size();i++){
              if (bishops.get(i).xPos==xPosits[n]&&bishops.get(i).yPos==yPosits[n]){
                  bishops.remove(i);
                  break;
              }
          }
          for (int i=0;i<knights.size();i++){
              if (knights.get(i).xPos==xPosits[n]&&knights.get(i).yPos==yPosits[n]){
                  knights.remove(i);
                  break;
              }
          }
          for (int i=0;i<rooks.size();i++){
              if (rooks.get(i).xPos==xPosits[n]&&rooks.get(i).yPos==yPosits[n]){
                  rooks.remove(i);
                  break;
              }
          }
          for (int i=0;i<queens.size();i++){
              if (queens.get(i).xPos==xPosits[n]&&queens.get(i).yPos==yPosits[n]){
                  queens.remove(i);
                  break;
              }
          }
          for (int i=0;i<mysteryPieces.size();i++){
              if (mysteryPieces.get(i).xPos==xPosits[n]&&mysteryPieces.get(i).yPos==yPosits[n]){
                  mysteryPieces.remove(i);
                  break;
              }
          }
          for (int i=0;i<tanks.size();i++){
              if ((tanks.get(i).projXPos1==xPosits[n]&&tanks.get(i).projYPos1==yPosits[n])||(tanks.get(i).projXPos2==xPosits[n]&&tanks.get(i).projYPos2==yPosits[n])){
                  tanks.remove(i);
                  break;
              }
          }
          for (int i=0;i<wildCards.size();i++){
              if (wildCards.get(i).xPos==xPosits[n]&&wildCards.get(i).yPos==yPosits[n]){
                  wildCards.remove(i);
                  break;
              }
          }
          for (int i=0;i<walls.size();i++){
              if (walls.get(i).xPos==xPosits[n]&&walls.get(i).yPos==yPosits[n]){
                  walls.remove(i);
                  break;
              }
          }
          for (int i=0;i<corpses.size();i++){
              if (corpses.get(i).xPos==xPosits[n]&&corpses.get(i).yPos==yPosits[n]){
                  corpses.remove(i);
                  i--;

              }
          }
          for (int i=0;i<monkeys.size();i++){
              if (monkeys.get(i).xPos==xPosits[n]&&monkeys.get(i).yPos==yPosits[n]){
                  monkeys.remove(i);
                  break;
              }
          }
          for (int i=0;i<tacoFiends.size();i++){
              if (tacoFiends.get(i).xPos==xPosits[n]&&tacoFiends.get(i).yPos==yPosits[n]){
                  tacoFiends.remove(i);
                  break;
              }
          }
      }
  }
  public ChessPiece getPiece(int XPOS, int YPOS){
      switch(pieceOccupyingSquareLite(XPOS, YPOS)){
          case KING: return getKing(XPOS, YPOS);
          case QUEEN: return getQueen(XPOS, YPOS);
          case BISHOP: return getBishop(XPOS, YPOS);
          case KNIGHT: return getKnight(XPOS, YPOS);
          case ROOK: return getRook(XPOS, YPOS);
          case PAWN: return getPawn(XPOS, YPOS);
          case MYSTERYPIECE: return getMysteryPiece(XPOS, YPOS);
          case MONKEY: return getMonkey(XPOS, YPOS);
          case TACOFIEND: return getTacoFiend(XPOS, YPOS);
          case WILDCARD: return getWildCard(XPOS, YPOS);
          case WALL: return getWall(XPOS, YPOS);
          case CORPSE: return getCorpse(XPOS, YPOS);
      }
      return null;
  }
  public Bishop getBishop(int XPOS, int YPOS){
       for(int i=0;i<bishops.size();i++){
           if (bishops.get(i).xPos==XPOS&&bishops.get(i).yPos==YPOS){
               return bishops.get(i);
           }
       }
       return null;
   }
      public King getKing(int XPOS, int YPOS){
       if (blackKing!=null&&blackKing.xPos==XPOS&&blackKing.yPos==YPOS){
           return blackKing;
       }
       if (whiteKing!=null&&whiteKing.xPos==XPOS&&whiteKing.yPos==YPOS){
           return whiteKing;
       }
       return null;
   }
      public Knight getKnight(int XPOS, int YPOS){
       for(int i=0;i<knights.size();i++){
           if (knights.get(i).xPos==XPOS&&knights.get(i).yPos==YPOS){
               return knights.get(i);
           }
       }
       return null;
   }
      public Pawn getPawn(int XPOS, int YPOS){
       for(int i=0;i<pawns.size();i++){
           if (pawns.get(i).xPos==XPOS&&pawns.get(i).yPos==YPOS){
               return pawns.get(i);
           }
       }
       return null;
    }
    public Wall getWall(int XPOS, int YPOS){
       for(int i=0;i<walls.size();i++){
           if (walls.get(i).xPos==XPOS&&walls.get(i).yPos==YPOS){
               return walls.get(i);
           }
       }
       return null;
    }
    public MysteryPiece getMysteryPiece(int XPOS, int YPOS){
       for(int i=0;i<mysteryPieces.size();i++){
           if (mysteryPieces.get(i).xPos==XPOS&&mysteryPieces.get(i).yPos==YPOS){
               return mysteryPieces.get(i);
           }
       }
       return null;
    }
    public Corpse getCorpse(int XPOS, int YPOS){
       for(int i=0;i<corpses.size();i++){
           if (corpses.get(i).xPos==XPOS&&corpses.get(i).yPos==YPOS){
               return corpses.get(i);
           }
       }
       return null;
    }
    public Monkey getMonkey(int XPOS, int YPOS){
       for(int i=0;i<monkeys.size();i++){
           if (monkeys.get(i).xPos==XPOS&&monkeys.get(i).yPos==YPOS){
               return monkeys.get(i);
           }
       }
       return null;
    }
    public WildCard getWildCard(int XPOS, int YPOS){
       for(int i=0;i<wildCards.size();i++){
           if (wildCards.get(i).xPos==XPOS&&wildCards.get(i).yPos==YPOS){
               return wildCards.get(i);
           }
       }
       return null;
    }
    public Tank getTank(int XPOS, int YPOS){
       for(int i=0;i<tanks.size();i++){
           if ((tanks.get(i).projXPos1==XPOS&&tanks.get(i).projYPos1==YPOS)||(tanks.get(i).projXPos2==XPOS&&tanks.get(i).projYPos2==YPOS)){
               return tanks.get(i);
           }
       }
       return null;
    }
    public TacoFiend getTacoFiend(int XPOS, int YPOS){
       for(int i=0;i<tacoFiends.size();i++){
           if (tacoFiends.get(i).xPos==XPOS&&tacoFiends.get(i).yPos==YPOS){
               return tacoFiends.get(i);
           }
       }
       return null;
    }
   public Queen getQueen(int XPOS, int YPOS){
       for(int i=0;i<queens.size();i++){
           if (queens.get(i).xPos==XPOS&&queens.get(i).yPos==YPOS){
               return queens.get(i);
           }
       }
       return null;
   }
   public Rook getRook(int XPOS, int YPOS){
       for(int i=0;i<rooks.size();i++){
           if (rooks.get(i).xPos==XPOS&&rooks.get(i).yPos==YPOS){
               return rooks.get(i);
           }
       }
       return null;
   }


   public Toaster getToaster(Side SIDE){
       if (SIDE == Side.BLACK){
           return blackToaster;
       }
       else{
           return whiteToaster;
       }
   }
  public ArrayList<Decision> squaresControlled(Side SIDE){
      ArrayList<Decision> squaresControlled = new ArrayList();
      for (int i=_8;i<=_1;i+=100){
          for (int n=A;n<=H;n+=100){
              if (sideAccesses(SIDE, n, i)){
                  squaresControlled.add(new Decision(n, i));
              }
          }
      }
      return squaresControlled;
  }
   public King yourKing(Side SIDE){
      if (SIDE==Side.WHITE){
          return whiteKing;
      }
      else{
          return blackKing;
      }
  }
  public int numCorpses(int XPOS, int YPOS){
      int numCorpses = 0;
      for (int i=0;i<corpses.size();i++){
          if (corpses.get(i).xPos==XPOS&&corpses.get(i).yPos==YPOS){
              numCorpses++;
          }
      }
      return numCorpses;
  }

  public void promotePawn(Side SIDE, int XPOS, int YPOS){
      if (game==ChessGame.ADULTERY){
          return;
      }
      for (int i=0;i<pawns.size();i++){
          if (pawns.get(i).side==SIDE&&pawns.get(i).occupies(XPOS, YPOS)){
              pawns.remove(i);
              if (SIDE==ChessApplet.yourSide){
                  switch (ChessApplet.promotionPiece){
                      case QUEEN: queens.add(new Queen(SIDE, XPOS, YPOS, this, game));
                          break;
                      case BISHOP: bishops.add(new Bishop(SIDE, XPOS, YPOS, this, game));
                          break;
                      case ROOK: rooks.add(new Rook(SIDE, XPOS, YPOS, this, game));
                          break;
                      case PAWN: pawns.add(new Pawn(SIDE, XPOS, YPOS, this, game));
                          break;
                      case KNIGHT: knights.add(new Knight(SIDE, XPOS, YPOS, this, game));
                          break;
                  }
              }
              else{
                  queens.add(new Queen(SIDE, XPOS, YPOS, this, game));
              }
          }
      }
  }
}