package chess2;
public class Game implements ChessConstants{
    int focusX = D;
    int pieceFocusX = D;
    int focusY = _4;
    int pieceFocusY = _4;
    Opponent opponent;
    ChessBoard board;
    ChessGame game;
      Game(ChessGame GAME){
          game = GAME;
          switch (GAME){
              case NORMAL: board = NormalBoard;
                  break;
              case INSECURE: board = InsecureBoard;
                  break;
              case CLAUSTROPHOBIC: board = ClaustrophobicBoard;
                  break;
              case MONKEY: board = MonkeyBoard;
                  break;
              case PEASANT: board = PeasantBoard;
                  break;
              case ADULTERY: board = AdulteryBoard;
                  break;
          }
        if (yourSide==Side.WHITE){
            opponent = new Opponent(GAME, Side.BLACK, board);
            opponentSide = Side.BLACK;
            turn = YOURS;
        }
        else{
            opponent = new Opponent(GAME, Side.WHITE, board);
            opponentSide = Side.WHITE;
            turn = OPPONENTS;
        }


      }
      public int displayYConverter(int YPOS){
          if (yourSide==Side.WHITE){
              return YPOS;
          }
          else{
              if (YPOS==_1){
                  return _8;
              }
              else if (YPOS==_2){
                  return _7;
              }
              else if (YPOS==_3){
                  return _6;
              }
              else if (YPOS==_4){
                  return _5;
              }
              else if (YPOS==_5){
                  return _4;
              }
              else if (YPOS==_6){
                  return _3;
              }
              else if (YPOS==_7){
                  return _2;
              }
              else if (YPOS==_8){
                  return _1;
              }
              else{
                  return YPOS;
              }
          }
      }
      public int displayXConverter(int XPOS){
          if (yourSide==Side.WHITE){
              return XPOS;
          }
          else{
              if (XPOS==A){
                  return H;
              }
              else if (XPOS==B){
                  return G;
              }
              else if (XPOS==C){
                  return F;
              }
              else if (XPOS==D){
                  return E;
              }
              else if (XPOS==E){
                  return D;
              }
              else if (XPOS==F){
                  return C;
              }
              else if (XPOS==G){
                  return B;
              }
              else if (XPOS==H){
                  return A;
              }
              else{
                  return XPOS;
              }
          }
      }
      private void movePiece(){

          if ((opponent.yourVictory||opponent.yourDefeat||opponent.draw)){
              return;
          }
          if (focusX!=pieceFocusX||focusY!=pieceFocusY){

               switch(board.pieceOccupyingSquare(pieceFocusX, displayYConverter(pieceFocusY))){

                   case KING: if (board.getKing(pieceFocusX, displayYConverter(pieceFocusY))!=null&&board.getKing(pieceFocusX, displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getKing(pieceFocusX, displayYConverter(pieceFocusY)).canMoveTo(focusX, displayYConverter(focusY))){
                           ArrayList<Decision> possibleDecisions = board.yourKing(yourSide).possibleDecisions();
                           DeciType moveType = DeciType.MOVES;
                               for (int i=0;i<possibleDecisions.size();i++){
                                   if (possibleDecisions.get(i).xPos==focusX&&possibleDecisions.get(i).yPos==displayYConverter(focusY)){
                                       moveType = possibleDecisions.get(i).type;
                                       break;
                                   }
                               }
                               if (moveType!=DeciType.JUMPS){
                                   board.getKing(pieceFocusX, displayYConverter(pieceFocusY)).move(focusX, displayYConverter(focusY));
                                   turn = OPPONENTS;
                               }
                               else{
                                   if (board.yourKing(yourSide).path==null){
                                       board.yourKing(yourSide).path=board.yourKing(yourSide).makePath(focusX, displayYConverter(focusY));
                                   }

                               }
                           }
                        break;
                    case KNIGHT: if (board.getKnight(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getKnight(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getKnight(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getKnight(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case ROOK: if (board.getRook(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getRook(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&(board.getRook(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))||
                           board.getRook(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canCastle())){
                           board.getRook(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case MYSTERYPIECE: if (board.getMysteryPiece(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getMysteryPiece(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getMysteryPiece(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getMysteryPiece(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case CORPSE: if (board.getCorpse(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getCorpse(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getCorpse(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getCorpse(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           board.getCorpse(displayXConverter(focusX), displayYConverter(focusY)).corpseConverted=false;
                           turn = OPPONENTS;}
                        break;
                    case MONKEY: if (board.getMonkey(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getMonkey(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getMonkey(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getMonkey(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case TANK: if (board.getTank(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getTank(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getTank(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getTank(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case TACOFIEND: if (board.getTacoFiend(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getTacoFiend(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getTacoFiend(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getTacoFiend(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case QUEEN: if (board.getQueen(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getQueen(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getQueen(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getQueen(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case PAWN: if (board.getPawn(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getPawn(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getPawn(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getPawn(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case BISHOP: if (board.getBishop(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getBishop(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                           &&board.getBishop(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                           board.getBishop(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                           turn = OPPONENTS;}
                        break;
                    case WILDCARD: if (board.getWildCard(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY))!=null&&board.getWildCard(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).side==yourSide
                       &&board.getWildCard(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).canMoveTo(displayXConverter(focusX), displayYConverter(focusY))){
                       board.getWildCard(displayXConverter(pieceFocusX), displayYConverter(pieceFocusY)).move(displayXConverter(focusX), displayYConverter(focusY));
                       turn = OPPONENTS;}
                    break;
                   case TOASTER:
                       break;

               }

            pieceFocusX = focusX;
            pieceFocusY = focusY;
            if (turn==OPPONENTS){
                if (yourSide==Side.WHITE&&board.whiteKing.isSuffocated()){
                    board.whiteKing.air--;
                }
                if (yourSide==Side.BLACK&&board.blackKing.isSuffocated()){
                    board.blackKing.air--;
                }
            }

      }
    }
      public void drawBoard(){

          if (game==ChessGame.NORMAL){
              if (yourSide==Side.BLACK){background = flippedNormalBackground;}
              else{background = normalBackground;}
          }
          else if (game==ChessGame.INSECURE||game==ChessGame.CLAUSTROPHOBIC){

                if (yourSide==Side.BLACK){background = flippedInsecureBackground;}
                else{background = insecureBackground;}

          }
//          else if (game==ChessGame.MONKEY){
//              if (board.wellExploded){
//                if (yourSide==Side.BLACK){background = flippedMonkeyBackgroundMinusWell;}
//                else{background = monkeyBackgroundMinusWell;}
//            }
//            else{
//                if (yourSide==Side.BLACK){background = flippedMonkeyBackground;}
//                else{background = monkeyBackground;}
//            }
//          }
//          else if (game==ChessGame.PEASANT){
//            if (board.wellExploded){
//                if (yourSide==Side.BLACK){background = flippedPeasantBackgroundMinusWell;}
//                else{background = peasantBackgroundMinusWell;}
//            }
//            else{
//                if (yourSide==Side.BLACK){background = flippedPeasantBackground;}
//                else{background = peasantBackground;}
//            }
//          }
          else if (game==ChessGame.ADULTERY){
              if (yourSide==Side.BLACK){
                  background = flippedNormalBackground;
              }
              else{
                  background = normalBackground;
              }
          }
          g2d.drawImage(background, 0, 0, resize(800), resize(800), canvas);

            if (board.yourKing(yourSide)!=null&&game!=ChessGame.ADULTERY&&board.yourKing(yourSide).inCheck()){
              g2d.drawImage(kit.getImage(getURL("AttackHere.png")), resize(displayXConverter(board.yourKing(yourSide).xPos)),
                      resize(displayYConverter(board.yourKing(yourSide).yPos)), resize(100), resize(100), canvas);
            }
            if (board.yourKing(opponentSide)!=null&&game!=ChessGame.ADULTERY&&board.yourKing(opponentSide).inCheck()){
              g2d.drawImage(kit.getImage(getURL("AttackHere.png")), resize(displayXConverter(board.yourKing(opponentSide).xPos)),
                      resize(displayYConverter(board.yourKing(opponentSide).yPos)), resize(100), resize(100), canvas);
            }
            if (turn==YOURS&&fire&&board.inToaster(yourSide, focusX, focusY)){
                g2d.drawImage(kit.getImage(getURL("ToastFocus.png")), resize(displayXConverter(board.getToaster(yourSide).projXPos1)),
                        resize(displayYConverter(board.getToaster(yourSide).projYPos1)), resize(200), resize(100), canvas);
            }
          if (turn==YOURS&&fire&&board.inToaster(yourSide, focusX, focusY)){
                g2d.drawImage(kit.getImage(getURL("ToastFocus.png")), resize(displayXConverter(board.getToaster(yourSide).projXPos1)),
                        resize(displayYConverter(board.getToaster(yourSide).projYPos1)), resize(200), resize(100), canvas);
            }
          //These conditionals are REALLY messy -- fix it later
            if ((turn==YOURS&&board.sideOccupyingSquare(displayXConverter(focusX), displayYConverter(focusY))==yourSide||
                  (board.pieceOccupyingSquare(focusX, displayYConverter(focusY))==Piece.CORPSE&&board.getCorpse(focusX, displayYConverter(focusY)).side==yourSide)||
                  board.sideOccupyingSquare(focusX, displayYConverter(focusY))==Side.WALL&&board.inToaster(yourSide, focusX, displayYConverter(focusY)))&&
                  !(opponent.yourVictory||opponent.yourDefeat||opponent.draw)){
                if (!fire&&board.pieceOccupyingSquare(focusX, displayYConverter(focusY))!=Piece.TOASTER){
                    if (board.pieceOccupyingSquare(focusX, displayYConverter(focusY))==Piece.TANK){
                        Tank tank = board.getTank(focusX, displayYConverter(focusY));
                        int xPos1 = tank.projXPos1;
                        int xPos2 = tank.projXPos2;
                        int yPos1 = displayYConverter(tank.projYPos1);
                        int yPos2 = displayYConverter(tank.projYPos2);
                        int width = 100;
                        int height = 100;
                        if (yPos1>yPos2){
                            width = 100;
                            height = 200;
                            yPos1 ^= yPos2;
                            yPos2 ^= yPos1;
                            yPos1 ^= yPos2;
                        }
                        else if (yPos1<yPos2){
                            width = 100;
                            height = 200;
                        }
                        else if (xPos1>xPos2){
                            width = 200;
                            height = 100;
                            xPos1 ^= xPos2;
                            xPos2 ^= xPos1;
                            xPos1 ^= xPos2;
                        }
                        else if (xPos1<xPos2){
                            width = 200;
                            height = 100;
                        }
                        g2d.drawImage(kit.getImage(getURL("ToastFocus.png")), xPos1, yPos1, width, height, canvas);
                    }
                    else{
                        g2d.drawImage(kit.getImage(getURL("Focus.png")), resize(focusX), resize(focusY), resize(100), resize(100), canvas);
                    }
                }

                ArrayList<Decision> possibleDecisions = new ArrayList();
                  switch(board.pieceOccupyingSquare(displayXConverter(focusX), displayYConverter(focusY))){
                    case CORPSE: possibleDecisions=board.getCorpse(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case KING: possibleDecisions=board.getKing(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case KNIGHT: possibleDecisions=board.getKnight(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case ROOK: possibleDecisions=board.getRook(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case MYSTERYPIECE: possibleDecisions=board.getMysteryPiece(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case MONKEY: possibleDecisions=board.getMonkey(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case TANK: possibleDecisions=board.getTank(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case TACOFIEND: possibleDecisions=board.getTacoFiend(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case QUEEN: possibleDecisions=board.getQueen(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case PAWN: possibleDecisions=board.getPawn(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case BISHOP: possibleDecisions=board.getBishop(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case WILDCARD: possibleDecisions=board.getWildCard(displayXConverter(focusX), displayYConverter(focusY)).possibleDecisions();
                        break;
                    case TOASTER: if (fire){possibleDecisions=board.getToaster(yourSide).possibleDecisions();}
                        break;

                }
                for (int i=0;i<possibleDecisions.size();i++){

                    if (possibleDecisions.get(i).type==DeciType.ATTACKS||possibleDecisions.get(i).type==DeciType.SUICIDE
                            ||(possibleDecisions.get(i).type==DeciType.CANNIBALIZES&&cannibalize||(possibleDecisions.get(i).type==DeciType.EXPLODES&&explode))){
                        g2d.drawImage(kit.getImage(getURL("AttackHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (possibleDecisions.get(i).type==DeciType.JUMPS||(possibleDecisions.get(i).type==DeciType.CASTLES&&castle)||(possibleDecisions.get(i).type==DeciType.WEDS&&wed)){
                        g2d.drawImage(kit.getImage(getURL("JumpHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (possibleDecisions.get(i).type==DeciType.TURNS){
                        g2d.drawImage(kit.getImage(getURL("JumpHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (suck&&possibleDecisions.get(i).type==DeciType.SUCKS){
                        g2d.drawImage(kit.getImage(getURL("JumpHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (drop&&possibleDecisions.get(i).type==DeciType.DROPS){
                        g2d.drawImage(kit.getImage(getURL("JumpHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (possibleDecisions.get(i).type==DeciType.ENTERS&&entertank){
                        g2d.drawImage(kit.getImage(getURL("MoveHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                    else if (possibleDecisions.get(i).type==DeciType.MOVES){
                        g2d.drawImage(kit.getImage(getURL("MoveHere.png")), resize(displayXConverter(possibleDecisions.get(i).xPos)), resize(displayYConverter(possibleDecisions.get(i).yPos)), resize(100), resize(100), canvas);
                    }
                }
            }
            for (int i=0;i<board.tanks.size();i++){
                if (board.tanks.get(i).isSuffocated()){
                    board.tanks.remove(i);
                }
                else{
                    int xPos1 = board.tanks.get(i).projXPos1;
                    int xPos2 = board.tanks.get(i).projXPos2;
                    int yPos1 = displayYConverter(board.tanks.get(i).projYPos1);
                    int yPos2 = displayYConverter(board.tanks.get(i).projYPos2);
                    String direction = "Left";
                    int width = 100;
                    int height = 100;
                    if (yPos1>yPos2){
                        direction = "Down";
                        width = 100;
                        height = 200;
                        yPos1 ^= yPos2;
                        yPos2 ^= yPos1;
                        yPos1 ^= yPos2;
                    }
                    else if (yPos1<yPos2){
                        direction = "Up";
                        width = 100;
                        height = 200;
                    }
                    else if (xPos1>xPos2){
                        direction = "Right";
                        width = 200;
                        height = 100;
                        xPos1 ^= xPos2;
                        xPos2 ^= xPos1;
                        xPos1 ^= xPos2;
                    }
                    else if (xPos1<xPos2){
                        direction = "Left";
                        width = 200;
                        height = 100;
                    }
                    g2d.drawImage(kit.getImage(getURL(board.tanks.get(i).getSideInString()+"Tank"+direction+".png")), xPos1, yPos1, resize(width), resize(height), canvas);

                }
            }
            for (int i=0;i<board.walls.size();i++){
              g2d.drawImage(kit.getImage(getURL("wall.png")),
              resize(displayXConverter(board.walls.get(i).xPos)), resize(displayYConverter(board.walls.get(i).yPos)), resize(100), resize(100), canvas);
          }
          for (int i=0;i<board.corpses.size();i++){
              if (!board.corpses.get(i).corpseConverted){
                  if (board.corpses.get(i).yPos>=_4){
                      board.corpses.get(i).side = Side.WHITE;
                      g2d.drawImage(kit.getImage(getURL("WhiteCorpse.png")), resize(displayXConverter(board.corpses.get(i).xPos)), resize(displayYConverter(board.corpses.get(i).yPos)), resize(100), resize(100), canvas);
                      g2d.setPaint(Color.BLACK);
                  }
                  else{
                      board.corpses.get(i).side = Side.BLACK;
                      g2d.drawImage(kit.getImage(getURL("BlackCorpse.png")), resize(displayXConverter(board.corpses.get(i).xPos)), resize(displayYConverter(board.corpses.get(i).yPos)), resize(100), resize(100), canvas);
                      g2d.setPaint(Color.WHITE);
                  }
              }
              if (board.level(board.corpses.get(i).xPos, board.corpses.get(i).yPos)>1){
                  g2d.drawString(""+board.level(board.corpses.get(i).xPos, board.corpses.get(i).yPos), resize(displayXConverter(board.corpses.get(i).xPos))+resize(45),
                          resize(displayYConverter(board.corpses.get(i).yPos))+resize(25));
              }
          }
           for (int i=0;i<board.wildCards.size();i++){
                if (board.wildCards.get(i).isSuffocated()){
                    board.wildCards.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.wildCards.get(i).getSideInString()+"WildCard.png")),
                            resize(displayXConverter(board.wildCards.get(i).getXPos())), resize(displayYConverter(board.wildCards.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }

             for (int i=0;i<board.pawns.size();i++){

                if (board.pawns.get(i).isSuffocated()){
                    board.pawns.get(i).suffocate=true;
                    if (i==board.pawns.size()){
                        break;
                    }
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.pawns.get(i).getSideInString()+"Pawn.png")),
                            resize(displayXConverter(board.pawns.get(i).getXPos())), resize(displayYConverter(board.pawns.get(i).getYPos())), resize(100), resize(100), canvas);
                }
                if (board.pawns.get(i).side==yourSide&&(board.pawns.get(i).side==Side.WHITE&&(board.pawns.get(i).yPos==_7^(board.pawns.get(i).yPos==_6&&!board.pawns.get(i).hasMoved)))
                        ^(board.pawns.get(i).side==Side.BLACK&&(board.pawns.get(i).yPos==_2^(board.pawns.get(i).yPos==_6&&!board.pawns.get(i).hasMoved)))){
                    int xPos = -1;
                    int yPos;
                    if (board.pawns.get(i).side==Side.WHITE){
                        yPos = displayYConverter(_8);
                    }
                    else{
                        yPos = displayYConverter(_1);
                    }
                    if (board.pawns.get(i).canMoveTo(board.pawns.get(i).xPos, yPos)){
                        xPos = board.pawns.get(i).xPos;
                    }
                    else if (board.pawns.get(i).canMoveTo(board.pawns.get(i).xPos-100, yPos)){
                        xPos = board.pawns.get(i).xPos-100;
                    }
                    else if (board.pawns.get(i).canMoveTo(board.pawns.get(i).xPos+100, yPos)){
                        xPos = board.pawns.get(i).xPos+100;
                    }
                    if (xPos != -1&&game!=ChessGame.ADULTERY){
                        switch(promotionPiece){
                            case QUEEN: g2d.drawImage(kit.getImage(getURL("Semi"+board.pawns.get(i).getSideInString()+"Queen.png")), resize(xPos), resize(yPos), resize(100), resize(100), canvas);
                                break;
                            case BISHOP: g2d.drawImage(kit.getImage(getURL("Semi"+board.pawns.get(i).getSideInString()+"Bishop.png")), resize(xPos), resize(yPos), resize(100), resize(100), canvas);
                                break;
                            case ROOK: g2d.drawImage(kit.getImage(getURL("Semi"+board.pawns.get(i).getSideInString()+"Rook.png")), resize(xPos), resize(yPos), resize(100), resize(100), canvas);
                                break;
                            case PAWN: g2d.drawImage(kit.getImage(getURL("Semi"+board.pawns.get(i).getSideInString()+"Pawn.png")), resize(xPos), resize(yPos), resize(100), resize(100), canvas);
                                break;
                            case KNIGHT: g2d.drawImage(kit.getImage(getURL("Semi"+board.pawns.get(i).getSideInString()+"Knight.png")), resize(xPos), resize(yPos), resize(100), resize(100), canvas);
                                break;
                        }
                    }
                }
                board.pawns.get(i).changeCheck();
            }
           for (int i=0;i<board.monkeys.size();i++){
                if (board.monkeys.get(i).isSuffocated()){
                    board.monkeys.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.monkeys.get(i).getSideInString()+"Monkey.png")),
                            resize(displayXConverter(board.monkeys.get(i).getXPos())), resize(displayYConverter(board.monkeys.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }
            for (int i=0;i<board.rooks.size();i++){
                if (board.rooks.get(i).isSuffocated()){
                    board.rooks.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.rooks.get(i).getSideInString()+"Rook.png")),
                            resize(displayXConverter(board.rooks.get(i).getXPos())), resize(displayYConverter(board.rooks.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }

          for (int i=0;i<board.tacoFiends.size();i++){
                if (board.tacoFiends.get(i).isSuffocated()){
                    board.tacoFiends.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.tacoFiends.get(i).getSideInString()+"TacoFiend.png")),
                            resize(displayXConverter(board.tacoFiends.get(i).getXPos())), resize(displayYConverter(board.tacoFiends.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }



             for (int i=0;i<board.knights.size();i++){
                if (board.knights.get(i).isSuffocated()){
                    board.knights.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.knights.get(i).getSideInString()+"Knight.png")),
                            resize(displayXConverter(board.knights.get(i).getXPos())), resize(displayYConverter(board.knights.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }
            for (int i=0;i<board.queens.size();i++){
                if (board.queens.get(i).isSuffocated()){
                    board.queens.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.queens.get(i).getSideInString()+"Queen.png")),
                            resize(displayXConverter(board.queens.get(i).getXPos())), resize(displayYConverter(board.queens.get(i).getYPos())), resize(100), resize(100), canvas);

                }
            }
            for (int i=0;i<board.mysteryPieces.size();i++){
                if (board.mysteryPieces.get(i).isSuffocated()){
                    board.mysteryPieces.get(i).suffocate=true;
                }
                else{
                    g2d.drawImage(kit.getImage(getURL(board.mysteryPieces.get(i).getSideInString()+"mysteryPiece.png")),
                            resize(displayXConverter(board.mysteryPieces.get(i).getXPos())), resize(displayYConverter(board.mysteryPieces.get(i).getYPos())), resize(100), resize(100), canvas);
                }
            }
           for (int i=0;i<board.bishops.size();i++){

                if (board.bishops.get(i).isSuffocated()){
                    board.bishops.get(i).suffocate=true;
                }
                else{

                    g2d.drawImage(kit.getImage(getURL(board.bishops.get(i).getSideInString()+"Bishop.png")),
                            resize(displayXConverter(board.bishops.get(i).getXPos())), resize(displayYConverter(board.bishops.get(i).getYPos())), resize(100), resize(100), canvas);
                }
           }

            if (board.whiteKing!=null){
                g2d.drawImage(kit.getImage(getURL("WhiteKing.png")), resize(displayXConverter(board.whiteKing.getXPos())), resize(displayYConverter(board.whiteKing.getYPos())), resize(100), resize(100), canvas);

                if (board.whiteKing.air<0){
                    if (yourSide==Side.WHITE){
                        opponent.yourDefeat = true;
                    }
                    else{
                        opponent.yourVictory=true;
                    }
                }
                if (board.whiteKing.air>0){
                    g2d.setPaint(Color.BLACK);
                    g2d.drawString(""+board.whiteKing.air, resize(displayXConverter(board.whiteKing.getXPos()))+resize(50), resize(displayYConverter(board.whiteKing.getYPos()))+resize(50));
                }
                else{
                    g2d.drawString("", resize(displayXConverter(board.whiteKing.getXPos()))+resize(50), displayYConverter(board.whiteKing.getYPos())+resize(50));
                }
            }
            if (board.blackKing!=null){
                g2d.drawImage(kit.getImage(getURL("BlackKing.png")), resize(displayXConverter(board.blackKing.getXPos())), resize(displayYConverter(board.blackKing.getYPos())), resize(100), resize(100), canvas);

                if (board.blackKing.air<0){
                   if (yourSide==Side.WHITE){
                        opponent.yourVictory = true;
                   }
                   else{
                       opponent.yourDefeat=true;
                   }
                }
                if (board.blackKing.air>0){
                    g2d.setPaint(Color.WHITE);
                    g2d.drawString(""+board.blackKing.air, displayXConverter(board.blackKing.getXPos())+resize(50), displayYConverter(board.blackKing.getYPos())+resize(50));
                }
                else{
                    g2d.drawString("", displayXConverter(board.blackKing.getXPos())+resize(50), displayYConverter(board.blackKing.getYPos())+resize(50));
                }
            }
          if (board.whiteKing.air<0&&board.blackKing.air<0){
                    opponent.draw=true;
                    opponent.yourDefeat=false;
                    opponent.yourVictory=false;
           }
            if ((opponent.yourVictory||opponent.yourDefeat||opponent.draw)&&!view){

               if (opponent.yourVictory){

                   g2d.drawImage(kit.getImage(getURL("victory"+yourSide+".png")), 0, 0, resize(800), resize(800), canvas);
               }
               else if (opponent.yourDefeat){

                   g2d.drawImage(kit.getImage(getURL("defeat"+yourSide+".png")), 0, 0, resize(800), resize(800), canvas);
               }
               else if (opponent.draw){
                   g2d.drawImage(kit.getImage(getURL("draw.png")), 0, 0, resize(800), resize(800), canvas);
               }
               g2d.setPaint(Color.BLACK);
               newGame.isActive = true;
               returnButton.isActive = true;

               switch (board.game){
                   case NORMAL: NormalBoard = new ChessBoard(ChessGame.NORMAL);
                       break;
                   case INSECURE: InsecureBoard = new ChessBoard(ChessGame.INSECURE);
                       break;
                   case CLAUSTROPHOBIC: ClaustrophobicBoard = new ChessBoard(ChessGame.CLAUSTROPHOBIC);
                       break;
                   case MONKEY: MonkeyBoard = new ChessBoard(ChessGame.MONKEY);
                       break;
                   case PEASANT: PeasantBoard = new ChessBoard(ChessGame.PEASANT);
                       break;
                   case ADULTERY: AdulteryBoard = new ChessBoard(ChessGame.ADULTERY);
                       break;
               }

          }
           for (int i=0;i<board.queens.size();i++){
               if (board.queens.get(i).suffocate){
                   board.queens.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.bishops.size();i++){
               if (board.bishops.get(i).suffocate){
                   board.bishops.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.rooks.size();i++){
               if (board.rooks.get(i).suffocate){
                   board.rooks.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.knights.size();i++){
               if (board.knights.get(i).suffocate){
                   board.knights.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.pawns.size();i++){
               if (board.pawns.get(i).suffocate){
                   board.pawns.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.mysteryPieces.size();i++){
               if (board.mysteryPieces.get(i).suffocate){
                   board.mysteryPieces.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.monkeys.size();i++){
               if (board.monkeys.get(i).suffocate){
                   board.monkeys.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.corpses.size();i++){
               if (board.corpses.get(i).suffocate){
                   board.corpses.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.wildCards.size();i++){
               if (board.wildCards.get(i).suffocate){
                   board.wildCards.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.tanks.size();i++){
               if (board.tanks.get(i).suffocate){
                   board.tanks.remove(i);
                   i--;
               }
           }
         for (int i=0;i<board.tacoFiends.size();i++){
               if (board.tacoFiends.get(i).suffocate){
                   board.tacoFiends.remove(i);
                   i--;
               }
           }
       repaint();
      }
      public void work(){


            if (turn==OPPONENTS){

            opponent.move();
            turn=YOURS;
                if (yourSide!=Side.WHITE){
                   board.countWhiteKills();
               }
               else{
                   board.countBlackKills();
               }

              drawBoard();
            }

            else if (turn==YOURS){
              board.controlMinds(yourSide);
              board.controlMinds(opponentSide);
              if (opponent.noPossibleReactionMoves(board)){
                  if (board.yourKing(yourSide).inCheck()){
                      opponent.yourDefeat = true;
                  }
                  else{
                      opponent.draw = true;
                  }
              }
               movePiece();
               if (turn!=YOURS){
                    if (yourSide==Side.WHITE){
                        board.countWhiteKills();
                    }
                    else{
                        board.countBlackKills();
                    }

               }

               if (!computerOpponent&&turn!=YOURS){
                   turn = YOURS;
                   if (yourSide==Side.WHITE){yourSide=Side.BLACK;opponentSide=Side.WHITE;onSide=opponentSide;}
                   else{yourSide=Side.WHITE;opponentSide=Side.BLACK;onSide=opponentSide;}
               }
               board.controlMinds(yourSide);
            board.controlMinds(opponentSide);
               drawBoard();
           }

      }
  }