Please fix the bug in the code.

May 8th, 2015
SoccerBoss
Category:
Calculus
Price: $20 USD

Question description

Code is complete but there is a bug when it compiles. Please fix the bug and then I will accept your bid. This is very urgent. I only have one hour!!

--------------------------------------------------------------------------------------------------

#ifndef CHESST01_H_INCLUDED
#define CHESST01_H_INCLUDED
 #include<string>
using namespace std;
class Piece
{
  private:
  string itsName;
  int itsVertAddress;
  int itsHorzAddress;

  public:
  void  setItsVertAddress (int address){itsVertAddress = address;}
  void  setItsHorzAddress (int address){itsHorzAddress = address;}
  int  getItsVertAddress()  {return itsVertAddress;}
  int  getItsHorzAddress()  {return itsHorzAddress;}
  void  setItsName  (string name){itsName=name;}
  string getItsName  ()  {return itsName;}
};

class Board
{
  private:
  string itsBoard[26];
  public:
  void setItsBoard(string []);
  void setPcsLoc(string,int,int);
  void DisplayBoard();
  bool emptySpot(int ,int );

};

///////////////////
// bool searchTouch(Piece [],int);
// bool searchMove(Piece [],int,int);
/////////////////////
void Board::setItsBoard(string arr[])
{
  for(int i=0;i<26;i++)
  itsBoard[i]=arr[i];
}
void Board::DisplayBoard()
{
  for(int i=0;i<26;i++)
  cout<<itsBoard[i]<<endl;;

}

void Board::setPcsLoc(string name,int horz,int vert)
{
  itsBoard[vert].replace(horz,2,name);
}

bool Board::emptySpot(int horz,int vert)
{
  cout<<"\n"<<itsBoard[horz][vert]<<endl;
  if(itsBoard[horz][vert]=='.')
  {

  return true;
  }
  return false;
}
/*
 bool searchTouch(Piece pieces[],int address) ////to check if the player is choosing the right Piece
 {
  bool ok_touch = false;
  int Horz = address%10;
  int Vert = address/10;
  for(int i=0;i<32;i++)

  if((pieces[i].getItsHorzAddress()==Horz)&&(pieces[i].getItsVertAddress()==Vert))
  return ok_touch;

  return ok_touch;
 }

 bool searchMove(Piece pieces[],int addtouch,int addmove) ////to check if the player is choosing the right Piece
 {
  bool ok_touch = false;
  int THorz = addtouch%10;
  int TVert = addtouch/10;
  int MHorz = addmove%10;
  int MVert = addmove/10;
  for(int i=0;i<32;i++)

  if((pieces[i].getItsHorzAddress()==THorz)&&(pieces[i].getItsVertAddress()==TVert))
  {
  pieces[i].setPcsLoc(pieces[i].getItsName(),MHorz,MVert);
  return ok_touch;
  }
  return ok_touch;
 }
  */
#endif // CHESST01_H_INCLUDED



  #include<iostream>
  #include<string>
  #include<cstdlib>
  #include"chess.h"
  bool touchMove(Board*,Piece [],int,int,bool);
  bool checkMove(int);
  bool emptySpot(Piece [],int , int);
  bool pieceMove(Piece [],string ,string ,int ,int );
  int switchNum(int,char);
  void resetBoard(Board *,Piece []);

  using namespace std;
  int main()
  {  /////  2  6  10  14  18  22  26  30
  string arrPcs[26]={"--1---2---3---4---5---6---7---8---",
  "-  ####  ####  ####  ####-",
  "1  ####  ####  ####  ####1",//2
  "-  ####  ####  ####  ####-",
  "-####  ####  ####  ####  -",
  "2####  ####  ####  ####  2",//5
  "-####  ####  ####  ####  -",
  "-  ####  ####  ####  ####-",
  "3  ####  ####  ####  ####3",//8
  "-  ####  ####  ####  ####-",
  "-####  ####  ####  ####  -",
  "4####  ####  ####  ####  4",//11
  "-####  ####  ####  ####  -",
  "-  ####  ####  ####  ####-",
  "5  ####  ####  ####  ####5",//14
  "-  ####  ####  ####  ####-",
  "-####  ####  ####  ####  -",
  "6####  ####  ####  ####  6",//17
  "-####  ####  ####  ####  -",
  "-  ####  ####  ####  ####-",
  "7  ####  ####  ####  ####7",//20
  "-  ####  ####  ####  ####-",
  "-####  ####  ####  ####  -",
  "8####  ####  ####  ####  8",//23
  "-####  ####  ####  ####  -",
  "--1---2---3---4---5---6---7---8---"
  };
  Board gameBoard;
  gameBoard.setItsBoard(arrPcs );

  Piece pcs[64];

  resetBoard(&gameBoard,pcs);

  gameBoard.DisplayBoard();/////display the game board on screen
  cout<<"0 to end the game anytime"<<endl;
  cout<<"entry:2 digits each from 1-8.first: vertical count"<<endl;
  bool exit = false;
  bool white= true; //////the turn is for white
  cout<<"White Turn"<<endl;

while(exit==false)
{
int touch,move;
cout<<"Choose the piece you want to move!"<<endl;
cin>>touch;
if(touch!=0)
{
cout<<"CHoose the target location "<<endl;
cin>>move;
if((checkMove(move))&&(checkMove(touch))&&(touchMove(&gameBoard,pcs,touch,move,white)))
{
  gameBoard.DisplayBoard();/////display the game board on screen
  if(white)
  {
  white=false;/////switch player
  cout<<"Black Turn"<<endl;
  }
  else
  {
  white=true;
  cout<<"White Turn"<<endl;
  }
}
  else cout<<"not accepted"<<endl;
}
else
exit=true;
}

  return 0;
  }


 bool touchMove(Board *aboard,Piece pieces[],int addtouch,int addmove,bool white) ////
 {
  string nameT,nameM;
  bool ok_touch = false;
  int THorz = addtouch%10;
  int TVert = addtouch/10;
  int MHorz = addmove%10;
  int MVert = addmove/10;
  THorz=switchNum(THorz,'h');
  MHorz=switchNum(MHorz,'h');
  TVert=switchNum(TVert,'v');
  MVert=switchNum(MVert,'v');

for(int i=0;i<=64;i++)//searching for the touched piece
  if((pieces[i].getItsHorzAddress()==TVert)&&(pieces[i].getItsVertAddress()==THorz)&&(pieces[i].getItsName()!="  "))
  {
  nameT=pieces[i].getItsName();
  if((white)&&(nameT[0]=='W')) ////white can move white only
  {
  for(int k=0;k<=64;k++)////searching for the target
  if((pieces[k].getItsHorzAddress()==MVert)&&(pieces[k].getItsVertAddress()==MHorz))
  {
  nameM=pieces[k].getItsName();
  if((white)&&(nameM[0]!='W'))
  {
  if(pieceMove(pieces,nameT,nameM,addtouch,addmove))////////////fuction for the rules of each piece movement
  {
  pieces[k].setItsName(pieces[i].getItsName());
  aboard->setPcsLoc(pieces[k].getItsName(),MHorz,MVert);

 pieces[i].setItsName("  ");
 aboard->setPcsLoc(pieces[i].getItsName(),THorz,TVert);
  ok_touch=true;
  }///////////////////////////////////////////////////
  }
  }
  }
  else if
  ((!white)&&(nameT[0]=='B')) ////black can move black only
  {
  for(int k=0;k<=64;k++) ///////searching for the touched piece
  if((pieces[k].getItsHorzAddress()==MVert)&&(pieces[k].getItsVertAddress()==MHorz))
  {
  nameM=pieces[k].getItsName();
  if((!white)&&(nameM[0]!='B'))
  {
  ///////////////////////////////////////////////////
  if(pieceMove(pieces,nameT,nameM,addtouch,addmove))////////////fuction for the rules of each piece movement
  {
  pieces[k].setItsName(pieces[i].getItsName());
  aboard->setPcsLoc(pieces[k].getItsName(),MHorz,MVert);

 pieces[i].setItsName("  ");
 aboard->setPcsLoc(pieces[i].getItsName(),THorz,TVert);
  ok_touch=true;
  }
  //////////////////////////////////////////////////////////
  }
  }
  }
  else ok_touch=false;
  }
  return ok_touch;
 }

  int switchNum(int num,char xChar)
  {
  if(xChar=='h')
  switch(num)
  {
  case 1 : num =2;
  break;
  case 2 : num =6;
  break;
  case 3 : num =10;
  break;
  case 4 : num =14;
  break;
  case 5 : num =18;
  break;
  case 6 : num =22;
  break;
  case 7 : num =26;
  break;
  case 8 : num =30;
  break;
  default :
  break;
  }
  else
  switch(num)
  {
  case 1 : num =2;
  break;
  case 2 : num =5;
  break;
  case 3 : num =8;
  break;
  case 4 : num =11;
  break;
  case 5 : num =14;
  break;
  case 6 : num =17;
  break;
  case 7 : num =20;
  break;
  case 8 : num =23;
  break;
  default :
  break;
  }
  return num;

  }

  void resetBoard(Board *gameBoard,Piece pcs[])
  {

  for(int i=0,j=2;i<8;i++)
  {
  pcs[i].setItsName("WP");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(5);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,5);
  j+=4;
  }

  for(int i=8,j=2;i<16;i++)
  {
  pcs[i].setItsName("BP");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(20);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,20);
  j+=4;
  }
/////set rook locations
  for(int i=16,j=2;i<18;i++)
  {
  //////set location for white rook
  pcs[i].setItsName("WR");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);


  ////set location for black rook
  pcs[i+2].setItsName("BR");
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=30;


  }

  /////set Knight locations
  for(int i=20,j=6;i<22;i++)
  {
  //////set location for white knight
  pcs[i].setItsName("WN");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);


  ////set location for black knight
  pcs[i+2].setItsName("BN");
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=26;
  }

  /////set Bishops locations
  for(int i=24,j=10;i<26;i++)
  {
  //////set location for white bishop
  pcs[i].setItsName("WB");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,2);


  ////set location for black bishop
  pcs[i+2].setItsName("BB");
  pcs[i+2].setItsVertAddress(j);
  pcs[i+2].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[i+2].getItsName(),j,23);
  j=22;
  }

  /////set Queens locations
  //////set location for white queen
  pcs[28].setItsName("WQ");
  pcs[28].setItsVertAddress(14);
  pcs[28].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[28].getItsName(),14,2);

  ////set location for black queen
  pcs[29].setItsName("BQ");
  pcs[29].setItsVertAddress(14);
  pcs[29].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[29].getItsName(),14,23);

 /////set kings locations
  //////set location for white king
  pcs[30].setItsName("WK");
  pcs[30].setItsVertAddress(18);
  pcs[30].setItsHorzAddress(2);
  gameBoard->setPcsLoc(pcs[30].getItsName(),18,2);

  ////set location for black king
  pcs[31].setItsName("BK");
  pcs[31].setItsVertAddress(18);
  pcs[31].setItsHorzAddress(23);
  gameBoard->setPcsLoc(pcs[31].getItsName(),18,23);

/////////////set the other spots
int k=8;
  for(int i=32,j=2;i<64;i++)
  {
  //////set location for white knight
  pcs[i].setItsName("  ");
  pcs[i].setItsVertAddress(j);
  pcs[i].setItsHorzAddress(k);
  gameBoard->setPcsLoc(pcs[i].getItsName(),j,k);
if(j<30)
j+=4;
else
{
j=2;
k+=3;
}
  }
  }

bool checkMove(int move)
{
  int first  = move/10;
  int second = move%10;
  if((first<1)||(first>8)||(second<1)||(second>8))
  return false;
  return true;
}


bool pieceMove(Piece pieces[],string nameT,string nameM,int touch ,int move )
{
  int moving=touch;
  int THorz = touch%10;
  int TVert = touch/10;
  int MHorz = move%10;
  int MVert = move/10;
  int movingH=THorz;
  int movingV=TVert;
  int diff=abs(touch-move);
  int signedDiff=touch-move;



  if(nameT[1]=='P') ////if its  pawn
  {
  if(nameT[0]=='W')//////white pawn
  {
  if(nameM[0]==' ')//////////////piece not attacking
  {
  if(move==touch+10)////one step forward ?
  return true;//yes? go
  return false;//no ? not accepted
  }
  else if(nameM[0]!=' ')////attacking abviously black piece
  if((move==touch+11)||(move==touch+9)) //moving diagonal down?
  return true; /////diagonal
  return false;/////not diagonal
  }
  if(nameT[0]=='B')//////black pawn
  {
  if(nameM[0]==' ')//////////////piece not attacking
  {
  if(move==touch-10)////one step up
  return true;/////up ok
  return false;/////not up not accepted
  }
  if(nameM[0]!='.')////attacking abviously white piece
  if((move==touch-11)||(move==touch-9)) ////diagonal up
  return true;/////ok move
  return false;////not accepted
  }
  return false;////any unexpected mistake will return a non accepted move
  }///////////////////////////////////////////////////////////////////end of pawn statment
  ////////////knight
  if(nameT[1]=='N')
  {
  int Hdiff=abs(THorz-MHorz);
  int Vdiff=abs(TVert-MVert);
  cout<<"Hdiff  and Vdiff are "<<Hdiff<<"  "<<Vdiff<<endl;
  if(((Hdiff==1)&&(Vdiff==2))||((Hdiff==2)&&(Vdiff==1)))
  return true;
  return false;
  }
  ////////////////////////////////////////////////////////////////////end night statement
  if(nameT[1]=='K')
  {
  if((diff==1)||(diff==11)||(diff==9)||(diff==10))////one step any direction
  return true; /////good move
  return false;////not accepted
  //////king
  }

  else if(nameT[1]=='R')
  {
  if((movingH==MHorz)||(movingV==MVert)) ////if its vertical or horizontal moving rook or queen
  {
  ////while loop to the check that there are no objects to block the moving objects's way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if(movingH>MHorz)//theobjects is moving to the left
  movingH--;
  if(movingH<MHorz)////right direction
  movingH++;
  if(movingV>MVert)//theobjects is moving Down
  movingV--;
  if(movingV<MVert)////Up direction
  movingV++;
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,'h'),switchNum(movingV,'v')))
  return false; ////if an object is found the movement cant be done



  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  else return false;
  }

  /////////different selection
  if(nameT[1]=='B')
  {
  if((diff%9==0)||(diff%11==0)) ////if its diagonal moving bishop or queen
  {
  ////while loop to the check that there are no objects to block the moving objects's way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if((MHorz>THorz)&&(MVert>TVert))//theobjects is moving to the left
  {
  movingH++;
  movingV++;
  }
  if((MHorz<THorz)&&(MVert<TVert))////right direction
  {
  movingH--;
  movingV--;
  }
  if((MHorz>THorz)&&(MVert<TVert))////right direction
  {
  movingH++;
  movingV--;
  }
  if((MHorz<THorz)&&(MVert>TVert))////right direction
  {
  movingH--;
  movingV++;
  }
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,'h'),switchNum(movingV,'v')))
  return false; ////if an object is found the movement cant be done
  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  else return false;
  }
  if(nameT[1]=='Q')
  {
  if((movingH==MHorz)||(movingV==MVert)) ////if its vertical or horizontal moving rook or queen
  {
  ////while loop to the check that there are no objects to block the moving objects's way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if(movingH>MHorz)//theobjects is moving to the left
  movingH--;
  if(movingH<MHorz)////right direction
  movingH++;
  if(movingV>MVert)//theobjects is moving Down
  movingV--;
  if(movingV<MVert)////Up direction
  movingV++;
  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object
  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,'h'),switchNum(movingV,'v')))
  return false; ////if an object is found the movement cant be done
  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  if((diff%9==0)||(diff%11==0)) ////if its diagonal moving bishop or queen
  {
  ////while loop to the check that there are no objects to block the moving objects's way
  while(moving!=move) ////the while loop ends if we reach the target
  {
  if((MHorz>THorz)&&(MVert>TVert))//theobjects is moving to the left
  {
  movingH++;
  movingV++;
  }
  if((MHorz<THorz)&&(MVert<TVert))////right direction
  {
  movingH--;
  movingV--;
  }
  if((MHorz>THorz)&&(MVert<TVert))////right direction
  {
  movingH++;
  movingV--;
  }
  if((MHorz<THorz)&&(MVert>TVert))////right direction
  {
  movingH--;
  movingV++;
  }

  ////after we move and before we accept the movement we need to check if
  ////there is no object is  blocking the way of our moving object

  moving=movingV*10+movingH;
  if(moving!=move)
  if(!emptySpot(pieces,switchNum(movingH,'h'),switchNum(movingV,'v')))
  return false; ////if an object is found the movement cant be done


  }
  ////if the while loop ends  it means the path is clear and its ok to move
  return true;
  }
  }
return false;
}

bool emptySpot(Piece pieces[],int h, int v)
{
  for(int i=0;i<=64;i++)
  if((pieces[i].getItsHorzAddress()==v)&&(pieces[i].getItsVertAddress()==h)&&(pieces[i].getItsName()=="  "))
  return true;
  return false;
}


Tutor Answer

(Top Tutor) Daniel C.
(997)
School: Cornell University
PREMIUM TUTOR

Studypool has helped 1,244,100 students

Summary
Quality
Communication
On Time
Value
tinytim47
Feb 21st, 2017
" Wow this is really good.... didn't expect it. Sweet!!!! "
Ask your homework questions. Receive quality answers!

Type your question here (or upload an image)

1824 tutors are online

Brown University





1271 Tutors

California Institute of Technology




2131 Tutors

Carnegie Mellon University




982 Tutors

Columbia University





1256 Tutors

Dartmouth University





2113 Tutors

Emory University





2279 Tutors

Harvard University





599 Tutors

Massachusetts Institute of Technology



2319 Tutors

New York University





1645 Tutors

Notre Dam University





1911 Tutors

Oklahoma University





2122 Tutors

Pennsylvania State University





932 Tutors

Princeton University





1211 Tutors

Stanford University





983 Tutors

University of California





1282 Tutors

Oxford University





123 Tutors

Yale University





2325 Tutors