#include "ChessSimulation.h"

ChessPiece__MODEL__::ChessPiece__MODEL__()
{
  piece = 0;
  square = "";
  toSquare = "";
  firstTick = true;
  moving = false;
  jump = false;
  goingToSky = false;
  speed = (real)20;
  numSteps = 0;
  step = 0;
  countDown = 0;
  dx = 0;
  dy = 0;
  dz = 0;
}

void ChessPiece__MODEL__::Tick()
{
if(firstTick){firstTick=false;
  ChessVideoScene.addObject(piece);
  return;
  }if(goingToSky){piece->translate(0,0,(real)8.0/(real)frames_per_second);
  }if(piece){if(moving){if(countDown>0){countDown--;
  return;
  }if(jump){real halfd=(real)numSteps/(real)2;
  real st=-((real)step-halfd);
  real st1=-((real)(step+1)-halfd);
  real divider=(numSteps*numSteps)/(real)32;
  dz=(st*st-st1*st1)/divider;
  }piece->translate(dx,dy,dz);
  step++;
  if(step==numSteps){moving=false;
  square=toSquare;
  string msg="Yes";
   messageBoardNew_->postMessage("NEXTMOVE", msg) ;
  }return;
  }string fromSquare= messageBoard_->getMessage("FROM") ;
  toSquare= messageBoard_->getMessage("TO") ;
  if(fromSquare==square){real fx,fy,fz;
  real tx,ty,tz;
  squareLocation(fromSquare,fx,fy,fz);
  squareLocation(toSquare,tx,ty,tz);
  real distance=(real)sqrt((tx-fx)*(tx-fx)+(ty-fy)*(ty-fy));
  numSteps=(int)((distance*frames_per_second)/speed);
  step=0;
  dx=(tx-fx)/(real)numSteps;
  dy=(ty-fy)/(real)numSteps;
  dz=(tz-fz)/(real)numSteps;
  string empty="";
   messageBoardNew_->postMessage("FROM", empty) ;
   messageBoardNew_->postMessage("TO", empty) ;
  moving=true;
  countDown=(int)frames_per_second/2;
  }else if(toSquare==square){goingToSky=true;
  square="sky";
  }};
  
}

whitePawn1__AGENT__::whitePawn1__AGENT__()
{
  piece = Pawns[1];
  square = "h2";
}

void whitePawn1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn2__AGENT__::whitePawn2__AGENT__()
{
  piece = Pawns[3];
  square = "g2";
}

void whitePawn2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn3__AGENT__::whitePawn3__AGENT__()
{
  piece = Pawns[5];
  square = "f2";
}

void whitePawn3__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn4__AGENT__::whitePawn4__AGENT__()
{
  piece = Pawns[7];
  square = "e2";
}

void whitePawn4__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn5__AGENT__::whitePawn5__AGENT__()
{
  piece = Pawns[9];
  square = "d2";
}

void whitePawn5__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn6__AGENT__::whitePawn6__AGENT__()
{
  piece = Pawns[11];
  square = "c2";
}

void whitePawn6__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn7__AGENT__::whitePawn7__AGENT__()
{
  piece = Pawns[13];
  square = "b2";
}

void whitePawn7__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whitePawn8__AGENT__::whitePawn8__AGENT__()
{
  piece = Pawns[15];
  square = "a2";
}

void whitePawn8__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn1__AGENT__::blackPawn1__AGENT__()
{
  piece = Pawns[0];
  square = "h7";
}

void blackPawn1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn2__AGENT__::blackPawn2__AGENT__()
{
  piece = Pawns[2];
  square = "g7";
}

void blackPawn2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn3__AGENT__::blackPawn3__AGENT__()
{
  piece = Pawns[4];
  square = "f7";
}

void blackPawn3__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn4__AGENT__::blackPawn4__AGENT__()
{
  piece = Pawns[6];
  square = "e7";
}

void blackPawn4__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn5__AGENT__::blackPawn5__AGENT__()
{
  piece = Pawns[8];
  square = "d7";
}

void blackPawn5__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn6__AGENT__::blackPawn6__AGENT__()
{
  piece = Pawns[10];
  square = "c7";
}

void blackPawn6__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn7__AGENT__::blackPawn7__AGENT__()
{
  piece = Pawns[12];
  square = "b7";
}

void blackPawn7__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackPawn8__AGENT__::blackPawn8__AGENT__()
{
  piece = Pawns[14];
  square = "a7";
}

void blackPawn8__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteKnight1__AGENT__::whiteKnight1__AGENT__()
{
  piece = &wknight01;
  square = "b1";
  jump = true;
}

void whiteKnight1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteKnight2__AGENT__::whiteKnight2__AGENT__()
{
  piece = &wknight02;
  square = "g1";
  jump = true;
}

void whiteKnight2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackKnight1__AGENT__::blackKnight1__AGENT__()
{
  piece = &bknight01;
  square = "b8";
  jump = true;
}

void blackKnight1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackKnight2__AGENT__::blackKnight2__AGENT__()
{
  piece = &bknight02;
  square = "g8";
  jump = true;
}

void blackKnight2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteBishop1__AGENT__::whiteBishop1__AGENT__()
{
  piece = &wbishop01;
  square = "c1";
}

void whiteBishop1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteBishop2__AGENT__::whiteBishop2__AGENT__()
{
  piece = &wbishop02;
  square = "f1";
}

void whiteBishop2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackBishop1__AGENT__::blackBishop1__AGENT__()
{
  piece = &bbishop01;
  square = "c8";
}

void blackBishop1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackBishop2__AGENT__::blackBishop2__AGENT__()
{
  piece = &bbishop02;
  square = "f8";
}

void blackBishop2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteRook1__AGENT__::whiteRook1__AGENT__()
{
  piece = &wrook01;
  square = "a1";
}

void whiteRook1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteRook2__AGENT__::whiteRook2__AGENT__()
{
  piece = &wrook02;
  square = "h1";
}

void whiteRook2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackRook1__AGENT__::blackRook1__AGENT__()
{
  piece = &brook01;
  square = "a8";
}

void blackRook1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackRook2__AGENT__::blackRook2__AGENT__()
{
  piece = &brook02;
  square = "h8";
}

void blackRook2__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteQueen1__AGENT__::whiteQueen1__AGENT__()
{
  piece = &wqueen01;
  square = "d1";
}

void whiteQueen1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackQueen1__AGENT__::blackQueen1__AGENT__()
{
  piece = &bqueen01;
  square = "d8";
}

void blackQueen1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

whiteKing1__AGENT__::whiteKing1__AGENT__()
{
  piece = &wking01;
  square = "e1";
}

void whiteKing1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

blackKing1__AGENT__::blackKing1__AGENT__()
{
  piece = &bking01;
  square = "e8";
}

void blackKing1__AGENT__::Tick()
{
ChessPiece__MODEL__::Tick();

  
}

chessPlayer__AGENT__::chessPlayer__AGENT__()
{
  firstTick = true;
  move = 0;
}

void chessPlayer__AGENT__::Tick()
{
if(firstTick){firstTick=false;
  string msg="Yes";
   messageBoardNew_->postMessage("NEXTMOVE", msg) ;
  return;
  }string nextMove= messageBoard_->getMessage("NEXTMOVE") ;
  if(nextMove=="Yes"){string msg="No";
   messageBoardNew_->postMessage("NEXTMOVE", msg) ;
  if((2*move+1)>=moves.size()){string endGame="Yes";
   messageBoardNew_->postMessage("ENDGAME", endGame) ;
  return;
  }string fromSquare=moves[2*move];
  string toSquare=moves[2*move+1];
   messageBoardNew_->postMessage("FROM", fromSquare) ;
   messageBoardNew_->postMessage("TO", toSquare) ;
  move++;
  };
  
}

chessBoard__AGENT__::chessBoard__AGENT__()
{
  firstTick = true;
}

void chessBoard__AGENT__::Tick()
{
if(firstTick){firstTick=false;
  ChessVideoScene.addObject(&board);
  return;
  };
  
}

Camera01__AGENT__::Camera01__AGENT__()
{
  camera = &camera01;
  count = 0;
}

void Camera01__AGENT__::Tick()
{
count++;
  real sx=(real)25*(real)cos((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sy=(real)25*(real)sin((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sz=(real)20+(real)5*(real)sin((2.0*3.1416*count)/(real)(3*frames_per_second));
  Vector3DW eaux(0,0,0);
  eaux.setX(sx);
  eaux.setY(sy);
  eaux.setZ(sz);
  camera->setEye(eaux);
  string fromSquare= messageBoard_->getMessage("FROM") ;
  string toSquare= messageBoard_->getMessage("TO") ;
  if((fromSquare!="")&&(toSquare!="")){real fx,fy,fz;
  real tx,ty,tz;
  squareLocation(fromSquare,fx,fy,fz);
  squareLocation(toSquare,tx,ty,tz);
  real distance=(fx*fx+fy*fy+fz*fz);
  distance+=(tx*tx+ty*ty+tz*tz);
  real grade=(real)1500/distance;
  if(grade<0)grade=0;
  if(grade>10)grade=10;
  gradeCamera01=grade;
  };
  
}

Camera02__AGENT__::Camera02__AGENT__()
{
  camera = &camera02;
  count = 0;
}

void Camera02__AGENT__::Tick()
{
count++;
  real sx=(real)10*(real)cos((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sy=(real)10*(real)sin((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sz=(real)5+(real)2*(real)sin((2.0*3.1416*count)/(real)(3*frames_per_second));
  Vector3DW ataux(0,0,0);
  ataux.setX(sx);
  ataux.setY(sy);
  ataux.setZ(sz);
  camera->setAt(ataux);
  string fromSquare= messageBoard_->getMessage("FROM") ;
  string toSquare= messageBoard_->getMessage("TO") ;
  if((fromSquare!="")&&(toSquare!="")){real fx,fy,fz;
  real tx,ty,tz;
  squareLocation(fromSquare,fx,fy,fz);
  squareLocation(toSquare,tx,ty,tz);
  real distance=((sx-fx)*(sx-fx)+(sy-fy)*(sy-fy)+(sz-fz)*(sz-fz));
  distance+=((sx-tx)*(sx-tx)+(sy-ty)*(sy-ty)+(sz-tz)*(sz-tz));
  real grade=(real)1500/distance;
  if(grade<0)grade=0;
  if(grade>10)grade=10;
  gradeCamera02=grade;
  };
  
}

Camera03__AGENT__::Camera03__AGENT__()
{
  camera = &camera03;
  count = 0;
}

void Camera03__AGENT__::Tick()
{
count++;
  real sx=(real)10*(real)cos((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sy=(real)10*(real)sin((2.0*3.1416*count)/(real)(8*frames_per_second));
  real sz=(real)40+(real)10*(real)sin((2.0*3.1416*count)/(real)(3*frames_per_second));
  Vector3DW eaux(0,0,0);
  eaux.setX(sx);
  eaux.setY(sy);
  eaux.setZ(sz);
  camera->setEye(eaux);
  gradeCamera03=(real)5;
  
}

ChessSimulation::ChessSimulation()
{
  whitePawn1.setMessageBoard(&messageBoard_);
  whitePawn1.setMessageBoardNew(&messageBoardNew_);
  whitePawn2.setMessageBoard(&messageBoard_);
  whitePawn2.setMessageBoardNew(&messageBoardNew_);
  whitePawn3.setMessageBoard(&messageBoard_);
  whitePawn3.setMessageBoardNew(&messageBoardNew_);
  whitePawn4.setMessageBoard(&messageBoard_);
  whitePawn4.setMessageBoardNew(&messageBoardNew_);
  whitePawn5.setMessageBoard(&messageBoard_);
  whitePawn5.setMessageBoardNew(&messageBoardNew_);
  whitePawn6.setMessageBoard(&messageBoard_);
  whitePawn6.setMessageBoardNew(&messageBoardNew_);
  whitePawn7.setMessageBoard(&messageBoard_);
  whitePawn7.setMessageBoardNew(&messageBoardNew_);
  whitePawn8.setMessageBoard(&messageBoard_);
  whitePawn8.setMessageBoardNew(&messageBoardNew_);
  blackPawn1.setMessageBoard(&messageBoard_);
  blackPawn1.setMessageBoardNew(&messageBoardNew_);
  blackPawn2.setMessageBoard(&messageBoard_);
  blackPawn2.setMessageBoardNew(&messageBoardNew_);
  blackPawn3.setMessageBoard(&messageBoard_);
  blackPawn3.setMessageBoardNew(&messageBoardNew_);
  blackPawn4.setMessageBoard(&messageBoard_);
  blackPawn4.setMessageBoardNew(&messageBoardNew_);
  blackPawn5.setMessageBoard(&messageBoard_);
  blackPawn5.setMessageBoardNew(&messageBoardNew_);
  blackPawn6.setMessageBoard(&messageBoard_);
  blackPawn6.setMessageBoardNew(&messageBoardNew_);
  blackPawn7.setMessageBoard(&messageBoard_);
  blackPawn7.setMessageBoardNew(&messageBoardNew_);
  blackPawn8.setMessageBoard(&messageBoard_);
  blackPawn8.setMessageBoardNew(&messageBoardNew_);
  whiteKnight1.setMessageBoard(&messageBoard_);
  whiteKnight1.setMessageBoardNew(&messageBoardNew_);
  whiteKnight2.setMessageBoard(&messageBoard_);
  whiteKnight2.setMessageBoardNew(&messageBoardNew_);
  blackKnight1.setMessageBoard(&messageBoard_);
  blackKnight1.setMessageBoardNew(&messageBoardNew_);
  blackKnight2.setMessageBoard(&messageBoard_);
  blackKnight2.setMessageBoardNew(&messageBoardNew_);
  whiteBishop1.setMessageBoard(&messageBoard_);
  whiteBishop1.setMessageBoardNew(&messageBoardNew_);
  whiteBishop2.setMessageBoard(&messageBoard_);
  whiteBishop2.setMessageBoardNew(&messageBoardNew_);
  blackBishop1.setMessageBoard(&messageBoard_);
  blackBishop1.setMessageBoardNew(&messageBoardNew_);
  blackBishop2.setMessageBoard(&messageBoard_);
  blackBishop2.setMessageBoardNew(&messageBoardNew_);
  whiteRook1.setMessageBoard(&messageBoard_);
  whiteRook1.setMessageBoardNew(&messageBoardNew_);
  whiteRook2.setMessageBoard(&messageBoard_);
  whiteRook2.setMessageBoardNew(&messageBoardNew_);
  blackRook1.setMessageBoard(&messageBoard_);
  blackRook1.setMessageBoardNew(&messageBoardNew_);
  blackRook2.setMessageBoard(&messageBoard_);
  blackRook2.setMessageBoardNew(&messageBoardNew_);
  whiteQueen1.setMessageBoard(&messageBoard_);
  whiteQueen1.setMessageBoardNew(&messageBoardNew_);
  blackQueen1.setMessageBoard(&messageBoard_);
  blackQueen1.setMessageBoardNew(&messageBoardNew_);
  whiteKing1.setMessageBoard(&messageBoard_);
  whiteKing1.setMessageBoardNew(&messageBoardNew_);
  blackKing1.setMessageBoard(&messageBoard_);
  blackKing1.setMessageBoardNew(&messageBoardNew_);
  chessPlayer.setMessageBoard(&messageBoard_);
  chessPlayer.setMessageBoardNew(&messageBoardNew_);
  chessBoard.setMessageBoard(&messageBoard_);
  chessBoard.setMessageBoardNew(&messageBoardNew_);
  Camera01.setMessageBoard(&messageBoard_);
  Camera01.setMessageBoardNew(&messageBoardNew_);
  Camera02.setMessageBoard(&messageBoard_);
  Camera02.setMessageBoardNew(&messageBoardNew_);
  Camera03.setMessageBoard(&messageBoard_);
  Camera03.setMessageBoardNew(&messageBoardNew_);
}

void ChessSimulation::clear()
{
  messageBoard_.clear();
  messageBoardNew_.clear();
}

ChessSimulation__MESSAGEBOARD__& ChessSimulation::getMessageBoard()
{
  return messageBoard_;
}

void ChessSimulation::Tick()
{
  whitePawn1.Tick();
  whitePawn2.Tick();
  whitePawn3.Tick();
  whitePawn4.Tick();
  whitePawn5.Tick();
  whitePawn6.Tick();
  whitePawn7.Tick();
  whitePawn8.Tick();
  blackPawn1.Tick();
  blackPawn2.Tick();
  blackPawn3.Tick();
  blackPawn4.Tick();
  blackPawn5.Tick();
  blackPawn6.Tick();
  blackPawn7.Tick();
  blackPawn8.Tick();
  whiteKnight1.Tick();
  whiteKnight2.Tick();
  blackKnight1.Tick();
  blackKnight2.Tick();
  whiteBishop1.Tick();
  whiteBishop2.Tick();
  blackBishop1.Tick();
  blackBishop2.Tick();
  whiteRook1.Tick();
  whiteRook2.Tick();
  blackRook1.Tick();
  blackRook2.Tick();
  whiteQueen1.Tick();
  blackQueen1.Tick();
  whiteKing1.Tick();
  blackKing1.Tick();
  chessPlayer.Tick();
  chessBoard.Tick();
  Camera01.Tick();
  Camera02.Tick();
  Camera03.Tick();
  messageBoard_ = messageBoardNew_;
}