package chess2;
import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.net.*;
public class ChessApplet extends JApplet implements ChessConstants{
 Toolkit kit = Toolkit.getDefaultToolkit();
 Image background;
 Image normalBackground = kit.getImage(getURL("NormalBoard.png"));
 Image flippedNormalBackground = kit.getImage(getURL("FlippedNormalBoard.png"));
 Image insecureBackground = kit.getImage(getURL("InsecureBoard.png"));
 Image flippedInsecureBackground = kit.getImage(getURL("FlippedInsecureBoard.png"));
// Image monkeyBackground = kit.getImage(getURL("MonkeyBoard.png"));
// Image flippedMonkeyBackground = kit.getImage(getURL("FlippedMonkeyBoard.png"));
// Image monkeyBackgroundMinusWell = kit.getImage(getURL("MonkeyBoardMinusWell.png"));
// Image flippedMonkeyBackgroundMinusWell = kit.getImage(getURL("FlippedMonkeyBoardMinusWell.png"));
// Image peasantBackground = kit.getImage(getURL("PeasantBoard.png"));
// Image flippedPeasantBackground = kit.getImage(getURL("FlippedPeasantBoard.png"));
// Image peasantBackgroundMinusWell = kit.getImage(getURL("PeasantBoardMinusWell.png"));
// Image flippedPeasantBackgroundMinusWell = kit.getImage(getURL("FlippedPeasantBoardMinusWell.png"));
 static Difficulty difficulty = Difficulty.MEDIUM;
Graphics2D g2d;
static Side yourSide = Side.WHITE;
Side comp2side;
Side onSide = Side.WHITE;
Side opponentSide;
Turn turn = Turn.YOURS;
static Piece promotionPiece = Piece.QUEEN;
ChessButton menuButton = new ChessButton("Menu", resize(0), resize(640));
ChessButton normalButton = new ChessButton("Play Normal Chess", resize(0), resize(280));
//ChessButton insecureButton = new ChessButton("Play Insecure Chess", 0, 350);
ChessButton insecureButton = new ChessButton("Play Insecure Chess", resize(0), resize(330));
ChessButton claustrophobicButton = new ChessButton("Play Claustrophobic Chess", resize(0), resize(380));
//ChessButton monkeyButton = new ChessButton("Play Monkey Chess", 0, resize(430));
//ChessButton peasantButton = new ChessButton("Play Peasant Chess", 0, resize(480));
ChessButton adulteryButton = new ChessButton("Play Adultery Chess", 0, resize(430));
ChessButton rulesButton = new ChessButton("Rules", resize(0), resize(500));
ChessButton settingsButton = new ChessButton("Settings", resize(0), resize(550));
ChessButton creditsButton = new ChessButton("Credits", resize(0), resize(600));
ChessButton hotKeysButton = new ChessButton("Hot Keys", resize(0), resize(650));

//ChessButton rulesButton = new ChessButton("Rules", 0, 570);
//ChessButton settingsButton = new ChessButton("Settings", 0, 620);
//ChessButton creditsButton = new ChessButton("Credits", 0, 670);
//ChessButton hotKeysButton = new ChessButton("Hot Keys", 0, 720);
ChessButton newGame = new ChessButton("New Game", resize(200), resize(700));
ChessButton returnButton = new ChessButton("Menu", resize(410), resize(700));
ChessButton whiteButton = new ChessButton("White", resize(240), resize(400));
ChessButton blackButton = new ChessButton("Black", resize(240), resize(400));
ChessButton veryeasyButton = new ChessButton("Very Easy", resize(470), resize(400));
ChessButton easyButton = new ChessButton("Easy", resize(470), resize(400));
ChessButton mediumButton = new ChessButton("Medium", resize(470), resize(400));
ChessButton hardButton = new ChessButton("Hard", resize(470), resize(400));
ChessButton veryhardButton = new ChessButton("Very Hard", resize(470), resize(400));
ChessButton onePlayer = new ChessButton("Computer Opponent", resize(240), resize(500));
ChessButton twoPlayer = new ChessButton("Two Players", resize(240), resize(500));
ChessButton noPlayer = new ChessButton("Computer Players Only", resize(240), resize(500));
ScrollButton upButton = new ScrollButton(true, resize(770), resize(310));
ScrollButton downButton = new ScrollButton(false, resize(770), resize(650));
ScrollBall scrollball = new ScrollBall();
ScrollBar scrollbar = new ScrollBar();
TextField rulesField = new TextField(RulesPrinter.dividedAdulteryRules());
TextField creditsField = new TextField(RulesPrinter.dividedCredits());
TextField hotKeysField = new TextField(RulesPrinter.dividedInsecureHotKeys());
int player_setting = 0;
final int ONE_P = 0;
final int TWO_P = 1;
final int NO_P = 2;
//boolean computerOpponent = true;
int mouseX, mouseY;
int clickX, clickY;
Game Normal;
Menu Menu;
Game Insecure;
Game Claustrophobic;
Game Monkey;
Game Peasant;
Game ActiveGame;
Game Adultery;
ChessBoard NormalBoard = new ChessBoard(ChessGame.NORMAL);
//ChessBoard NormalBoard = TestBoards.BlackEnPassantBoard();
ChessBoard InsecureBoard = new ChessBoard(ChessGame.INSECURE);
ChessBoard ClaustrophobicBoard = new ChessBoard(ChessGame.CLAUSTROPHOBIC);
//ChessBoard ClaustrophobicBoard = TestBoards.castleTestBoard();
ChessBoard MonkeyBoard = new ChessBoard(ChessGame.MONKEY);
//ChessBoard MonkeyBoard = TestBoards.corpseJumpBoard();
ChessBoard PeasantBoard = new ChessBoard(ChessGame.PEASANT);
ChessBoard AdulteryBoard = new ChessBoard(ChessGame.ADULTERY);
int clickcount = 0;
int scrollState = 0;

boolean cannibalize = false;
static boolean explode = false;
static boolean castle = false;
boolean view = false;
static boolean fire = false;
static boolean drop = false;
static boolean wed = false;
static boolean entertank = false;
static boolean suck = false;
int state = 0;
final int _Menu = 0;
final int _Normal = 1;
final int _Insecure = 2;
final int _Claustrophobic = 3;
final int _Monkey = 4;
final int _Peasant = 5;
final int _Adultery = 6;
final int showMenu = 0;
final int playNormal = 1;
final int playInsecure = 2;
final int playClaustrophobic = 3;
final int playMonkey = 4;
final int playPeasant = 5;
final int playAdultery = 6;
final int showRules = 7;
final int showSettings = 8;
final int showCredits = 9;
final int displaySize = 10;
boolean[] displayType = {true, false, false, false, false, false, false, false, false, false};
boolean canScroll = true;
  private PaintSurface canvas;
  private int resize(int org){
      return (int) (org*3/4);
  }
  private URL getURL(String filename){
      URL url = null;
      try{
          url = this.getClass().getResource(filename);
      }
      catch (Exception e){}
      return url;
  }
  private class ClickListener implements MouseListener{
    public void mouseClicked(MouseEvent e){


    }

    public void mouseEntered(MouseEvent e){

    }

    public void mouseExited(MouseEvent e){

    }

   public void mousePressed(MouseEvent e){
        
        clickX = e.getX();
        clickY = e.getY();
        mouseX = e.getX();
        mouseY = e.getY();
        if (state==_Menu){
           if (menuButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showMenu] = true;
           }
           else if(normalButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[playNormal] = true;
           }
           else if(insecureButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[playInsecure] = true;
           }
           else if(claustrophobicButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[playClaustrophobic] = true;
           }
//           else if(monkeyButton.isClicked(e.getX(), e.getY())){
//               for (int i=0;i<displaySize;i++){
//                   displayType[i] = false;
//               }
//               displayType[playMonkey] = true;
//           }
//           else if(peasantButton.isClicked(e.getX(), e.getY())){
//               for (int i=0;i<displaySize;i++){
//                   displayType[i] = false;
//               }
//               displayType[playPeasant] = true;
//           }
           else if(adulteryButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[playAdultery] = true;
           }
           else if(rulesButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showRules] = true;
           }
           else if(settingsButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showSettings] = true;
           }
           else if(creditsButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showCredits] = true;
           }
           else if(hotKeysButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showMenu] = true;
           }

           else if(whiteButton.isClicked(e.getX(), e.getY())){
               if (player_setting == ONE_P){
                   yourSide = Side.BLACK;
                   if (ActiveGame!=null){ActiveGame.opponent.side = Side.WHITE;}
                   turn=Turn.OPPONENTS;
               }

           }
           else if(blackButton.isClicked(e.getX(), e.getY())){
               if (player_setting == ONE_P){
                   yourSide = Side.WHITE;
                   if (ActiveGame!=null){ActiveGame.opponent.side = Side.BLACK;}
                   turn=Turn.OPPONENTS;
               }

           }

           else if(veryeasyButton.isClicked(e.getX(), e.getY())){
               difficulty = Difficulty.EASY;
           }
           else if(easyButton.isClicked(e.getX(), e.getY())){
               difficulty = Difficulty.MEDIUM;
           }
           else if(mediumButton.isClicked(e.getX(), e.getY())){
               difficulty = Difficulty.HARD;
           }
           else if(hardButton.isClicked(e.getX(), e.getY())){
               difficulty = Difficulty.VERY_HARD;
           }
           else if(veryhardButton.isClicked(e.getX(), e.getY())){
               difficulty = Difficulty.VERY_EASY;
           }
           else if(onePlayer.isClicked(e.getX(), e.getY())){
               player_setting = TWO_P;
               opponentSide = onSide;
           }
           else if(twoPlayer.isClicked(e.getX(), e.getY())){
               player_setting = NO_P;
               opponentSide = onSide;
           } 
           else if(noPlayer.isClicked(e.getX(), e.getY()))
           {
                player_setting = ONE_P;
                yourSide = onSide;
           }
           repaint();
        }
       else if (state!=_Menu){
           clickcount++;
          if (e.getX() >= resize(A) && e.getX() < resize(B)){
               ActiveGame.focusX = A;
           }
           else if (e.getX() >= resize(B) && e.getX() < resize(C)){
               ActiveGame.focusX = B;
           }
           else if (e.getX() >= resize(C) && e.getX() < resize(D)){
               ActiveGame.focusX = C;
           }
           else if (e.getX() >= resize(D) && e.getX() < resize(E)){
               ActiveGame.focusX = D;
           }
           else if (e.getX() >= resize(E) && e.getX() < resize(F)){
               ActiveGame.focusX = E;
           }
           else if (e.getX() >= resize(F) && e.getX() < resize(G)){
               ActiveGame.focusX = F;
           }
           else if (e.getX() >= resize(G) && e.getX() < resize(H)){
               ActiveGame.focusX = G;
           }
           else if (e.getX() >= resize(H)){
               ActiveGame.focusX = H;
           }

           if (e.getY() >= resize(_1)){
               ActiveGame.focusY = _1;
           }
           else if (e.getY()>= resize(_2)){
               ActiveGame.focusY = _2;
           }
           else if (e.getY()>=resize(_3)){
               ActiveGame.focusY = _3;
           }
           else if (e.getY()>=resize(_4)){
               ActiveGame.focusY = _4;
           }
           else if (e.getY()>=resize(_5)){
               ActiveGame.focusY = _5;
           }
           else if (e.getY()>=resize(_6)){
               ActiveGame.focusY = _6;
           }
           else if (e.getY()>=resize(_7)){
               ActiveGame.focusY = _7;
           }
           else if (e.getY()>=resize(_8)){
               ActiveGame.focusY = _8;
           }

          //I'd really like to get rid of this part and make all these special moves in movePiece()
           if (ActiveGame!=null){
               if (ActiveGame.board.pieceOccupyingSquare(ActiveGame.pieceFocusX, ActiveGame.pieceFocusY)==Piece.MONKEY){
                   if (ActiveGame.pieceFocusX==ActiveGame.focusX&&ActiveGame.pieceFocusY==ActiveGame.focusY){
                      Monkey stationaryMonkey = ActiveGame.board.getMonkey(ActiveGame.focusX, ActiveGame.focusY);
                      if (stationaryMonkey.canMoveTo(ActiveGame.focusX, ActiveGame.focusY)){
                          stationaryMonkey.move(ActiveGame.focusX, ActiveGame.focusY);
                           if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                           else{
                               if (yourSide==Side.WHITE){yourSide=Side.BLACK;}
                               else if (yourSide==Side.BLACK){yourSide=Side.WHITE;}
                           }
                      }
                   }
               }
                    if (fire&&ActiveGame.board.pieceOccupyingSquare(ActiveGame.pieceFocusX, ActiveGame.displayYConverter(ActiveGame.pieceFocusY))==Piece.TOASTER){
                       if (ActiveGame.board.getToaster(yourSide).canMoveTo(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY))){
                           ActiveGame.board.getToaster(yourSide).move(ActiveGame.pieceFocusX, ActiveGame.displayYConverter(ActiveGame.pieceFocusY));
                           if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                           else{
                               if (yourSide==Side.WHITE){yourSide=Side.BLACK;}
                               else if (yourSide==Side.BLACK){yourSide=Side.WHITE;}
                           }
                       }

                   }
                   //Doesn't this code mean that you can have entertank up or wed and then cannibalize someone?
                   if (ActiveGame.board.sideOccupyingSquare(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY))==yourSide){
                       if (ActiveGame.board.pieceOccupyingSquare(ActiveGame.pieceFocusX, ActiveGame.displayYConverter(ActiveGame.pieceFocusY))==Piece.KING){
                               if (cannibalize&&!(ActiveGame.game==ChessGame.NORMAL||ActiveGame.game==ChessGame.INSECURE)){

                                   if (ActiveGame.board.yourKing(yourSide).canMoveTo(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY))){
                                       ActiveGame.board.yourKing(yourSide).move(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY));
                                       if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                                       else{
                                           if (yourSide==Side.WHITE){yourSide=Side.BLACK;}
                                           else if (yourSide==Side.BLACK){yourSide=Side.WHITE;}
                                       }
                                   }
                               }

                            if(ActiveGame.board.yourKing(yourSide).canBreathInPlace()
                                       &&ActiveGame.displayYConverter(ActiveGame.focusX)==ActiveGame.board.yourKing(yourSide).xPos&&ActiveGame.displayYConverter(ActiveGame.focusY)==ActiveGame.board.yourKing(yourSide).yPos){
                                turn=Turn.OPPONENTS;
                                //ActiveGame.board.yourKing(yourSide).air--;
                              //  ActiveGame.board.yourKing(opponentSide).air++;
                               }

                       }


                       if (explode&&(ActiveGame.game==ChessGame.MONKEY||ActiveGame.game==ChessGame.PEASANT)){
                           for (int i=0;i<ActiveGame.board.pawns.size();i++){
                              if (ActiveGame.focusX==ActiveGame.board.pawns.get(i).xPos&&ActiveGame.focusY==ActiveGame.board.pawns.get(i).yPos){
                                  if (ActiveGame.board.pawns.get(i).canMoveTo(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY))){
                                      ActiveGame.board.pawns.get(i).move(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY));
                                      if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                                      else{yourSide=ActiveGame.board.pawns.get(i).opponentSide;}
                                  }
                                  break;
                              }
                            }
                       }
                      if (suck&&ActiveGame.board.pieceOccupyingSquare(ActiveGame.pieceFocusX, ActiveGame.displayYConverter(ActiveGame.pieceFocusY))==Piece.TANK){
                          ActiveGame.board.getTank(ActiveGame.pieceFocusX, ActiveGame.displayYConverter(ActiveGame.pieceFocusY))
                                  .move(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY));
                               if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                               else{
                                   if (yourSide==Side.WHITE){yourSide=Side.BLACK;}
                                   else if (yourSide==Side.BLACK){yourSide=Side.WHITE;}
                               }
                      }

                      if (entertank&&(ActiveGame.game==ChessGame.MONKEY||ActiveGame.game==ChessGame.PEASANT)){

                           if (ActiveGame.board.yourKing(yourSide).canMoveTo(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY))){
                               ActiveGame.board.yourKing(yourSide).move(ActiveGame.focusX, ActiveGame.displayYConverter(ActiveGame.focusY));
                               if (player_setting==ONE_P){turn=Turn.OPPONENTS;}
                               else{
                                   if (yourSide==Side.WHITE){yourSide=Side.BLACK;}
                                   else if (yourSide==Side.BLACK){yourSide=Side.WHITE;}
                               }
                           }
                       }
                   ActiveGame.pieceFocusX = ActiveGame.focusX;
                   ActiveGame.pieceFocusY = ActiveGame.focusY;
               }
               else if (ActiveGame.board.pieceOccupyingSquare(ActiveGame.focusX, ActiveGame.focusY)==Piece.CORPSE){
                    if (ActiveGame.board.getCorpse(ActiveGame.focusX, ActiveGame.focusY).side==yourSide){
                        ActiveGame.pieceFocusX = ActiveGame.focusX;
                        ActiveGame.pieceFocusY = ActiveGame.focusY;
                    }
               }


           }
           if(newGame.isClicked(e.getX(), e.getY())){
               switch(state){
                   case _Normal:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playNormal] = true;
                       Normal = null;
                      break;
                   case _Insecure:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playInsecure] = true;
                       Insecure = null;
                      break;
                   case _Claustrophobic:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playClaustrophobic] = true;
                       Claustrophobic = null;
                      break;
                   case _Monkey:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playMonkey] = true;
                       Monkey = null;
                      break;
                   case _Peasant:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playPeasant] = true;
                       Peasant = null;
                      break;
                   case _Adultery:
                       for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                       }
                       displayType[playAdultery] = true;
                       Peasant = null;
                      break;
               }
           }
           if(returnButton.isClicked(e.getX(), e.getY())){
               for (int i=0;i<displaySize;i++){
                   displayType[i] = false;
               }
               displayType[showMenu] = true;
               state = _Menu;
               Insecure = null;
               Claustrophobic = null;
               Monkey = null;
               Peasant = null;
           }
           repaint();
       }
  }
   public void mouseReleased(MouseEvent e){
        clickX = 0;
        clickY = 0;
    }
  }
  private class KeyBoardListener implements KeyListener{
        public void keyPressed(KeyEvent e){
            int keyCode = e.getKeyCode();
           switch (keyCode){
               case KeyEvent.VK_B: promotionPiece = Piece.BISHOP;
                   break;
               case KeyEvent.VK_Q: promotionPiece = Piece.QUEEN;
                    break;
               case KeyEvent.VK_R: promotionPiece = Piece.ROOK;
                    break;
               case KeyEvent.VK_P: promotionPiece = Piece.PAWN;
                    break;
               case KeyEvent.VK_K: promotionPiece = Piece.KNIGHT;
                    break;
               case KeyEvent.VK_C: cannibalize = true;
                   break;
               case KeyEvent.VK_S: suck = true;
                   break;
               case KeyEvent.VK_X: castle = true;
                   break;
               case KeyEvent.VK_D: drop = true;
                   break;
               case KeyEvent.VK_E: explode = true;
                   break;
               case KeyEvent.VK_T: entertank = true;
                   break;
               case KeyEvent.VK_V: view = true;
                   break;
               case KeyEvent.VK_W: wed = true;
                   break;
               case KeyEvent.VK_M:
                   view = false;
                     for (int i=0;i<displaySize;i++){
                           displayType[i] = false;
                     }
                       displayType[showMenu] = true;
                    state=_Menu;
                   break;
               case KeyEvent.VK_F: fire = true;
                   break;
               case KeyEvent.VK_N:
                   switch(ActiveGame.game){
                       case NORMAL: NormalBoard = new ChessBoard(ChessGame.NORMAL); Normal = new Game(ChessGame.NORMAL);
                           break;
                       case INSECURE: InsecureBoard = new ChessBoard(ChessGame.INSECURE); Insecure = new Game(ChessGame.INSECURE);
                           break;
                       case CLAUSTROPHOBIC: ClaustrophobicBoard = new ChessBoard(ChessGame.CLAUSTROPHOBIC); Claustrophobic = new Game(ChessGame.CLAUSTROPHOBIC);
                           break;
                       case MONKEY: MonkeyBoard = new ChessBoard(ChessGame.MONKEY); Monkey = new Game(ChessGame.MONKEY);
                           break;
                       case PEASANT: PeasantBoard = new ChessBoard(ChessGame.PEASANT); Peasant = new Game(ChessGame.PEASANT);
                           break;
                       case ADULTERY: AdulteryBoard = new ChessBoard(ChessGame.ADULTERY); Adultery = new Game(ChessGame.ADULTERY);
                           break;
                   }
                   break;

           }
       }


        public void keyTyped(KeyEvent e){

        }
        public void keyReleased(KeyEvent e){
            int keyCode = e.getKeyCode();
            if (state!=_Menu){
                switch (keyCode){
                    case KeyEvent.VK_C: cannibalize = false;
                        break;
                    case KeyEvent.VK_E: explode = false;
                        break;
                    case KeyEvent.VK_T: entertank = false;
                        break;
                    case KeyEvent.VK_V: view = false;
                        break;
                    case KeyEvent.VK_D: drop = false;
                        break;
                    case KeyEvent.VK_S: suck = false;
                        break;
                    case KeyEvent.VK_F: fire = false;
                        break;
                    case KeyEvent.VK_X: castle = false;
                        break;
                    case KeyEvent.VK_W: wed = false;
                        break;

                }
                promotionPiece = Piece.QUEEN;
           }
        }
  }
  class TextField{
   ArrayList<String> textLines;
   TextField(ArrayList<String> textLines){
       this.textLines = textLines;
   }
   int top = resize(0);
   int bottom = resize(20);
  }
  class ScrollBall{
     private double xPos;
     private double yPos;
      boolean isActive = false;
      private int width = 15;
      private int height = resize(15);
      private Image img = kit.getImage(getURL("ScrollBall.png"));
      ScrollBall(){
          xPos = resize(770);
          yPos = resize(335);
      }
      public void draw(){
          if (!isActive){return;}
          yPos = resize(335)+(rulesField.top*1.80);
          g2d.drawImage(img, (int) this.xPos, (int) this.yPos, width, height, canvas);
      }
      public boolean isClicked(int mouseX, int mouseY){
        if (!isActive){
            return false;
        }
        if (new Rectangle2D.Float((int)xPos, (int)yPos, width, height).contains(mouseX, mouseY)){
            return true;
        }
        return false;
    }
  }
  class ScrollBar{
      private int xPos = resize(770);
      private int yPos = resize(325);
      private Image img = kit.getImage(getURL("ScrollBar.png"));
      boolean isActive = false;
      private int width = 15;
      private int height = resize(325);
      public void draw(){
          if (!isActive){return;}
          if (!isClicked(clickX, clickY)){
            g2d.drawImage(img, (int) this.xPos, (int) this.yPos, width, height, canvas);
          }
          else{
              g2d.drawImage(kit.getImage(getURL("ScrollBar2.png")), (int) this.xPos, (int) this.yPos, width, height, canvas);
          }
      }
      public boolean isClicked(int mouseX, int mouseY){
        if (!isActive){
            return false;
        }
        if (new Rectangle2D.Float(xPos, yPos, width, height).contains(mouseX, mouseY)){
            return true;
        }
        return false;
    }
  }
  class ScrollButton{
      boolean isActive = false;
     private int xPos;
     private int yPos;
     private int width = 15;
     private int height = 15;
     private Image img;
     boolean up;
      ScrollButton(boolean up, int xPos, int yPos){
            this.up = up;
            this.xPos = xPos;
            this.yPos = yPos;
            if (up){
                img = kit.getImage(getURL("upButton.png"));
            }
            else{
                img = kit.getImage(getURL("downButton.png"));
            }
      }
      public void draw(){
          if (!isActive){return;}
          g2d.drawImage(img, this.xPos, this.yPos, width, height, canvas);
      }
      public boolean isClicked(int mouseX, int mouseY){
        if (!isActive){
            return false;
        }
        if (new Rectangle2D.Float(xPos, yPos, width, height).contains(mouseX, mouseY)){
            return true;
        }
        return false;
    }
  }

  class ChessButton {
    private int x, y, height, width;
   boolean isActive = false;
   private String title;
    Toolkit kit = Toolkit.getDefaultToolkit();
      private  Image background = kit.getImage(getURL("button.png"));
    public ChessButton(String TITLE, int X, int Y){
        x = X;
        y = Y;
        height = resize(50);
        width = resize(200);
        title = TITLE;
    }
    public String String(){
       return title;
    }
    public int stringX(){
        return x+resize(10);
    }
    public int stringY(){
        return y+resize(20);
    }
    public int x(){
        return x;
    }
    public int y(){
        return y;
    }
    public int width(){
        return width;
    }
    public int height(){
        return height;
    }
    public Image Img(){
        return background;
    }
    public void draw(){
        if (this.isActive){
        g2d.drawImage(this.Img(), this.x(), this.y(), resize(215), resize(50), canvas);
            g2d.drawString(this.String(), this.stringX(), this.stringY());
        }
    }
    public boolean isClicked(int mouseX, int mouseY){
        if (!isActive){
            return false;
        }
        if (new Rectangle2D.Float(x, y, width, height).contains(mouseX, mouseY)){
            return true;
        }
        return false;
    }
}
    @Override
    public void init() {
    this.setSize(resize(800), resize(800));
    canvas = new PaintSurface();
    this.add(canvas, BorderLayout.CENTER);
    this.addMouseListener(new ClickListener());
    this.addKeyListener(new KeyBoardListener());
   }
  class Menu{

      public void work(){

            g2d.drawImage(kit.getImage(getURL("background.png")), 0, 0, resize(800), resize(800), canvas);

            normalButton.isActive = true;
            insecureButton.isActive = true;
            claustrophobicButton.isActive = true;
//            monkeyButton.isActive = true;
//            peasantButton.isActive = true;
            adulteryButton.isActive = true;
            rulesButton.isActive = true;
            settingsButton.isActive = true;
            creditsButton.isActive = true;
            hotKeysButton.isActive = true;

            if (displayType[showMenu]){
               g2d.drawImage(kit.getImage(getURL("ChessPanel.png")), resize(210), resize(260), 500, resize(450), canvas);

               for (int i=0;i<hotKeysField.textLines.size();i++){
                    g2d.drawString(hotKeysField.textLines.get(i), resize(220), resize(290+(i*20)));
                }
            }
            else if (displayType[playNormal]){
                state = _Normal;
                repaint();
            }
            else if (displayType[playInsecure]){
                state = _Insecure;
                repaint();
            }
            else if (displayType[playClaustrophobic]){
                state = _Claustrophobic;
                repaint();
            }
            else if (displayType[playMonkey]){
                state = _Monkey;
                repaint();
            }
            else if (displayType[playPeasant]){
                state = _Peasant;
                repaint();
            }
            else if (displayType[playAdultery]){
                state = _Adultery;
                repaint();
            }
            else if (displayType[showRules]){
                upButton.isActive = true;
                downButton.isActive = true;
                int init = 0;
                scrollball.isActive=true;
                scrollbar.isActive=true;
                g2d.drawImage(kit.getImage(getURL("chesspanel.png")), resize(210), resize(260), 500, resize(450), canvas);
                for (int i=rulesField.top;init<rulesField.bottom-rulesField.top;i++){
                    g2d.drawString(rulesField.textLines.get(i), resize(220), resize(290)+(init*20));
                    init++;
                    if (i==rulesField.textLines.size()-1){
                        break;
                    }
                }
                repaint();
            }
            else if (displayType[showSettings]){
                g2d.drawImage(kit.getImage(getURL("chesspanel.png")), resize(210), resize(260), 500, resize(450), canvas);
                g2d.drawString("Settings", resize(450), resize(300));
                if (yourSide==Side.WHITE){
                    whiteButton.isActive=true;
                }
                else{
                    blackButton.isActive=true;
                }
                if (player_setting!=TWO_P){
                    if (difficulty==Difficulty.VERY_EASY){veryeasyButton.isActive=true;}
                    if (difficulty==Difficulty.EASY){easyButton.isActive=true;}
                    if (difficulty==Difficulty.MEDIUM){mediumButton.isActive=true;}
                    if (difficulty==Difficulty.HARD){hardButton.isActive=true;}
                    if (difficulty==Difficulty.VERY_HARD){veryhardButton.isActive=true;}
                }
                if (player_setting==ONE_P){onePlayer.isActive=true;}
                else if(player_setting==TWO_P){twoPlayer.isActive=true;}
                else if(player_setting==NO_P){noPlayer.isActive=true;}
                repaint();
            }
            else if (displayType[showCredits]){
                g2d.drawImage(kit.getImage(getURL("chesspanel.png")), resize(210), resize(260), 500, resize(450), canvas);
                for (int i=0;i<creditsField.textLines.size();i++){
                    g2d.drawString(creditsField.textLines.get(i), resize(220), resize(290+(i*20)));
                }

            }
      }
  }

  class Pause extends Thread{
        public void For(int seconds){
            try{
            Thread.sleep(seconds*1000);
            }
            catch(InterruptedException e){

            }
        }
    }

  class Game{
    int focusX = D;
    int pieceFocusX = D;
    int focusY = _4;
    int pieceFocusY = _4;
    int registerX;
    int registerY;
    Opponent opponent;
    Opponent comp2;
    ChessBoard board;
    ChessGame game;
    ArrayList<Decision> possibleDecisions;
      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 = Turn.YOURS;
        }
        else{
            opponent = new Opponent(GAME, Side.WHITE, board);
            opponentSide = Side.WHITE;
            turn = Turn.OPPONENTS;
        }
        if(opponentSide==Side.WHITE)
        {
            comp2 = new Opponent(GAME, Side.BLACK, board);
            comp2side = Side.BLACK;
            turn = Turn.OPPONENTS;
        }
        else
        {
              comp2 = new Opponent(GAME, Side.WHITE, board);
              comp2side = Side.WHITE;
              if (player_setting==NO_P)
              {
                turn = Turn.COMP2;
              }
        }
        


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

                   }
                  registerX = XPOS;
                  registerY = YPOS;
                  return possibleDecisions;
      }
       private void movePiece()
       {

            clickcount = 0;
            int pieceXPos = displayXConverter(registerX);
            int pieceYPos = displayYConverter(registerY);
            
            int focusXPos = displayXConverter(focusX);
            int focusYPos = displayYConverter(focusY);
            
            if ((opponent.yourVictory||opponent.yourDefeat||opponent.draw))
            {
              return;
            }
            if (possibleDecisions==null)
            {
                return;
            }
            if (possibleDecisions.size()==0)
            {
                return;
            }
            boolean legalMove = false;
            for (int i=0;i<possibleDecisions.size();i++)
            {
                if (focusXPos==possibleDecisions.get(i).xPos&&focusYPos==possibleDecisions.get(i).yPos)
                {
                    legalMove = true;
                }
            }
            if (!legalMove)
            {
                return;
            }
            switch(board.pieceOccupyingSquare(pieceXPos, pieceYPos))
            {
                case KING: board.getKing(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case KNIGHT: board.getKnight(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case ROOK: board.getRook(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case MYSTERYPIECE: board.getMysteryPiece(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case QUEEN: board.getQueen(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case PAWN: board.getPawn(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
                case BISHOP: board.getBishop(pieceXPos, pieceYPos).move(focusXPos, focusYPos);
                    break;
            }
            turn = Turn.OPPONENTS;
            
       }
      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==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==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==Turn.YOURS&&board.sideOccupyingSquare(displayXConverter(focusX), displayYConverter(focusY))==yourSide||
                  (board.pieceOccupyingSquare(displayXConverter(focusX), displayYConverter(focusY))==Piece.CORPSE&&board.getCorpse(displayXConverter(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);
                    }
                }

                possibleDecisions = this.possibleDecisions(focusX, focusY);
                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.get(i).suffocated=true;
                }
                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).suffocated=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).suffocated=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).suffocated=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).suffocated=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).suffocated=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).suffocated=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).suffocated=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).suffocated=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).suffocated=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, resize(displayXConverter(board.blackKing.getXPos()))+resize(50), resize(displayYConverter(board.blackKing.getYPos()))+resize(50));
                }
                else{
                    g2d.drawString("", resize(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(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).suffocated){
                   board.queens.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.bishops.size();i++){
               if (board.bishops.get(i).suffocated){
                   board.bishops.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.rooks.size();i++){
               if (board.rooks.get(i).suffocated){
                   board.rooks.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.knights.size();i++){
               if (board.knights.get(i).suffocated){
                   board.knights.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.pawns.size();i++){
               if (board.pawns.get(i).suffocated){
                   board.pawns.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.mysteryPieces.size();i++){
               if (board.mysteryPieces.get(i).suffocated){
                   board.mysteryPieces.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.monkeys.size();i++){
               if (board.monkeys.get(i).suffocated){
                   board.monkeys.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.corpses.size();i++){
               if (board.corpses.get(i).suffocated){
                   board.corpses.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.wildCards.size();i++){
               if (board.wildCards.get(i).suffocated){
                   board.wildCards.remove(i);
                   i--;
               }
           }
          for (int i=0;i<board.tanks.size();i++){
               if (board.tanks.get(i).suffocated){
                   board.tanks.remove(i);
                   i--;
               }
           }
         for (int i=0;i<board.tacoFiends.size();i++){
               if (board.tacoFiends.get(i).suffocated){
                   board.tacoFiends.remove(i);
                   i--;
               }
           }
       repaint();
      }
      public void work(){

            if (player_setting==TWO_P)
            {
                turn=Turn.YOURS;
            }
            if (turn==Turn.OPPONENTS){
                
                    opponent.move();
                
                if (player_setting==ONE_P)
                {
                    turn=Turn.YOURS;
                }
                else if (player_setting==TWO_P)
                {
                    turn=Turn.YOURS;
                }
                else if (player_setting==NO_P)
                {
                turn=Turn.COMP2;
                }

                if (opponentSide==Side.WHITE){
                    board.countWhiteKills();
                }
                else{
                    board.countBlackKills();
                }
                drawBoard();
            }
            else if(turn==Turn.COMP2)
            {

                comp2.move();

                turn=Turn.OPPONENTS;
                if (comp2side==Side.WHITE)
                {
                    board.countWhiteKills();
                }
                else
                {
                    board.countBlackKills();
                }
                drawBoard();
            }
            else if (turn==Turn.YOURS){
              board.controlMinds(yourSide);
              board.controlMinds(opponentSide);
              if (Reply.replies(board, opponentSide).size()==0){
                  if (board.yourKing(yourSide).inCheck()){
                      opponent.yourDefeat = true;
                  }
                  else{
                      opponent.draw = true;
                  }
              }
              if (clickcount==1)
              {
               movePiece();
               if (board.yourKing(yourSide).isSuffocated()&&board.yourKing(yourSide).didBreathInPlace==false)
               {
                    board.yourKing(yourSide).air--;
               }
               if (board.yourKing(opponentSide).isSuffocated()&&board.yourKing(yourSide).didBreathInPlace==false)
               {
                   board.yourKing(opponentSide).air--;
               }
              }
             
               if (turn!=Turn.YOURS){
                    if (yourSide==Side.WHITE){
                        board.countWhiteKills();
                    }
                    else{
                        board.countBlackKills();
                    }

               }

               if (player_setting==TWO_P&&turn!=Turn.YOURS){
                   turn = 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();
           }

      }
  }

  class PaintSurface extends JComponent{

        @Override
        public void paint(Graphics g){
        g2d = (Graphics2D)g;
        g2d.setPaint(Color.BLACK);

        normalButton.isActive = false;
        insecureButton.isActive = false;
        claustrophobicButton.isActive = false;
//       monkeyButton.isActive = false;
//        peasantButton.isActive = false;
        adulteryButton.isActive = false;
        rulesButton.isActive = false;
        creditsButton.isActive = false;
        newGame.isActive = false;
        returnButton.isActive = false;
        settingsButton.isActive = false;
        whiteButton.isActive = false;
        blackButton.isActive = false;
        veryeasyButton.isActive = false;
        easyButton.isActive = false;
        mediumButton.isActive = false;
        hardButton.isActive = false;
        veryhardButton.isActive = false;
        onePlayer.isActive = false;
        twoPlayer.isActive = false;
        noPlayer.isActive = false;
        upButton.isActive = false;
        downButton.isActive = false;
        hotKeysButton.isActive = false;
        scrollball.isActive = false;
        scrollbar.isActive = false;

        if (state==_Menu){
            if (Menu==null){Menu = new Menu(); }
             Menu.work();
        }
        else if (state == _Normal){
            ActiveGame = Normal;
            if ((Normal==null)||((Normal.opponent.yourVictory||Normal.opponent.yourDefeat||Normal.opponent.draw)&&state!=_Normal)){
                Normal = new Game(ChessGame.NORMAL);
                Insecure = null;
                Claustrophobic = null;
                Monkey = null;
                Peasant = null;
                Adultery = null;

            }
            Normal.work();
        }
        else if (state==_Insecure){
            ActiveGame = Insecure;
            if ((Insecure==null)||((Insecure.opponent.yourVictory||Insecure.opponent.yourDefeat||Insecure.opponent.draw)&&state!=_Insecure)){
                Insecure = new Game(ChessGame.INSECURE);
                Normal = null;
                Claustrophobic = null;
                Monkey = null;
                Peasant = null;
                Adultery = null;
            }
             Insecure.work();
        }
        else if (state==_Claustrophobic){
            ActiveGame = Claustrophobic;
            if ((Claustrophobic==null)||((Claustrophobic.opponent.yourVictory||Claustrophobic.opponent.yourDefeat||Claustrophobic.opponent.draw)&&state!=_Claustrophobic)){
                Claustrophobic = new Game(ChessGame.CLAUSTROPHOBIC);
                Normal = null;
                Insecure = null;
                Monkey = null;
                Peasant = null;
                Adultery = null;
            }
             Claustrophobic.work();

        }
        else if (state==_Monkey){
            ActiveGame = Monkey;
            if ((Monkey==null)||((Monkey.opponent.yourVictory||Monkey.opponent.yourDefeat||Monkey.opponent.draw)&&state!=_Monkey)){
                Monkey = new Game(ChessGame.MONKEY);
                Normal = null;
                Insecure = null;
                Claustrophobic = null;
                Peasant = null;
                Adultery = null;
            }
             Monkey.work();
        }
        else if (state==_Peasant){
            ActiveGame = Peasant;
            if ((Peasant==null)||((Peasant.opponent.yourVictory||Peasant.opponent.yourDefeat||Peasant.opponent.draw)&&state!=_Peasant)){
                Peasant = new Game(ChessGame.PEASANT);
                Normal = null;
                Insecure = null;
                Claustrophobic = null;
                Monkey = null;
                Adultery = null;
            }
             Peasant.work();
        }
        else if (state==_Adultery){
            ActiveGame = Adultery;
            if ((Adultery==null)||((Adultery.opponent.yourVictory||Adultery.opponent.yourDefeat||Adultery.opponent.draw)&&state!=_Adultery)){
                Adultery = new Game(ChessGame.ADULTERY);
                Normal = null;
                Insecure = null;
                Claustrophobic = null;
                Monkey = null;
                Peasant = null;
            }
             Adultery.work();
        }
        menuButton.draw();
       normalButton.draw();
        insecureButton.draw();
        claustrophobicButton.draw();
//       monkeyButton.draw();
//        peasantButton.draw();
        adulteryButton.draw();
        whiteButton.draw();
        blackButton.draw();
        settingsButton.draw();
        creditsButton.draw();
        rulesButton.draw();
        newGame.draw();
        returnButton.draw();
        veryeasyButton.draw();
        easyButton.draw();
        mediumButton.draw();
        hardButton.draw();
        veryhardButton.draw();
        onePlayer.draw();
        twoPlayer.draw();
        noPlayer.draw();
        scrollbar.draw();
        scrollball.draw();
        upButton.draw();
        downButton.draw();
        hotKeysButton.draw();

           if (scrollbar.isClicked(clickX, clickY)){
               if (!scrollball.isClicked(clickX, clickY)){
                   if (clickY>scrollball.yPos){
                       if (rulesField.bottom<rulesField.textLines.size()){
                          rulesField.top++;
                          rulesField.bottom++;
                       }
                   }
                   else{
                       if (rulesField.top>0){
                          rulesField.top--;
                          rulesField.bottom--;
                       }
                   }
               }

           }
           if (upButton.isClicked(clickX, clickY)||downButton.isClicked(clickX, clickY)){
               scrollState++;
           }
           if (scrollState==7){
              if(upButton.isClicked(clickX, clickY)){
                   if (rulesField.top>0){
                       rulesField.top--;
                       rulesField.bottom--;
                       scrollState=0;
                   }
               }
               else if(downButton.isClicked(clickX, clickY)){
                   if (rulesField.bottom<rulesField.textLines.size()&&scrollState==7){
                        scrollState = 0;
                        rulesField.top++;
                        rulesField.bottom++;
                   }
               }
              scrollState = 0;
           }
        }
  }
}