please fix the bug in the code

/in /by

We're the ideal place for homework help. If you are looking for affordable, custom-written, high-quality and non-plagiarized papers, your student life just became easier with us. Click either of the buttons below to place your order.


Order a Similar Paper Order a Different Paper

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;
}

Writerbay.net

Do you need academic writing help? Our quality writers are here 24/7, every day of the year, ready to support you! Instantly chat with a customer support representative in the chat on the bottom right corner, send us a WhatsApp message or click either of the buttons below to submit your paper instructions to the writing team.


Order a Similar Paper Order a Different Paper
Writerbay.net