Go4Expert

Go4Expert (http://www.go4expert.com/)
-   C++ (http://www.go4expert.com/forums/cpp/)
-   -   Need a help on C++ (http://www.go4expert.com/forums/help-cpp-t27432/)

retroshell 25Dec2011 08:24

Need a help on C++
 
Hello

This source code is for chess game in C++
But I can't move it's pieces, Please help me.

Code:

#include <iostream>
#include <string>
#include <vector>

using namespace std;


class Piece {

    private:
        //private members
        //private methods       

    public:
        //public members
        string label;                //the name of the piece ("Kn", "Bi", etc.)
        int currentRow;            //keeps up with row position
        int currentColumn;    //keeps up with column position
        string color;                //keeps up with which color the piece is
        bool canHop;                //determines whether piece can jump over other pieces

        //public methods
        Piece(string, int, int, string);            //constructor
        virtual bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece       

};

Piece::Piece(string lab, int row, int col, string c) {
    color = c;
    //appends a B or W at the end of a piece's name
    if (color == "black") {    label = lab + "-B"; }
    else {    label = lab + "-W"; }
    currentRow = row;
    currentColumn = col;
    //since only the knight can jump over other pieces, the default value is false
    canHop = false;
} //end of constructor

bool Piece::isMoveLegal(int destRow, int destColumn) {
    //rook rules.  this method could also simply return true,
    //since it is going to be overriden by any subclass based on it
    if (currentRow == destRow || currentColumn == destColumn) {
        return true;
    }
    else return false;
} //end of isMoveLegal







class Pawn: public Piece {

    private:
        bool isFirstMove;    //this variable is only necessary for the pawn
    public:
        Pawn(int, int, string);        //constructor
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece               

};

Pawn::Pawn (int row, int col, string c) : Piece ("Pn", row, col, c) {
    //nice and simple
    isFirstMove = true;        //this variable is only a member of Paw
} //end of constructor

bool Pawn::isMoveLegal(int newRow, int newColumn) {
    //pawn movement rules
    if (isFirstMove && currentColumn == newColumn && abs(newRow - currentRow) == 2) {       
        isFirstMove = false;
        return true;
    }
    else if (currentColumn == newColumn && abs(newRow - currentRow) == 1) {
        isFirstMove = false;
        return true;
    }
    return false;
} //end of isMoveLegal


class King: public Piece {

    private:
    public:
        King(int, int, string);
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece               
};

King::King (int row, int col, string c) : Piece ("K", row, col, c) {
    //nice and simple
} //end of constructor

bool King::isMoveLegal(int newRow, int newColumn) {
    return false;
}


class Knight: public Piece {

    private:
    public:
        Knight(int, int, string);
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece   
};

Knight::Knight(int row, int col, string c) : Piece ("KN", row, col, c) {
    //nice and simple
} //end of constructor

bool Knight::isMoveLegal(int newRow, int newColumn) {
    return false;
}

class Queen: public Piece {

    private:
        //private members
        //private methods

    public:
        Queen(int, int, string);
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece               

};

Queen::Queen(int row, int col, string c) : Piece ("Q", row, col, c) {
    //nice and simple
} //end of constructor

bool Queen::isMoveLegal(int newRow, int newColumn) {
    return false;
}


class Rook: public Piece {

    private:
        //private members
        //private methods

    public:
        Rook(int, int, string);
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece               

};

Rook::Rook(int row, int col, string c) : Piece ("RK", row, col, c) {
    //nice and simple
} //end of constructor

bool Rook::isMoveLegal(int newRow, int newColumn) {
    return false;
}

class Bishop: public Piece {

    private:
        //private members
        //private methods

    public:
        Bishop(int, int, string);
        bool isMoveLegal(int, int);    //validates that the move the player chose can be performed by this piece               

};

Bishop::Bishop(int row, int col, string c) : Piece ("BI", row, col, c) {
    //nice and simple
} //end of constructor

bool Bishop::isMoveLegal(int newRow, int newColumn) {
    return false;
}

class Board {

    private:
        string theBoard [8][8];        //an array of strings which represents the board
        void eraseBoard();            //this clears the board

    public:
        Board();                    //constructor
        void drawBoard();        //draws the board
        void setPiece(string, int, int);    //this "sets" a piece on the board the first time
        void setPiece(int, int, int, int);    //this version of the method moves a piece
};

Board::Board()  {
    eraseBoard();
} //end of constructor

void Board::eraseBoard() {
    for (int r=0; r<8; r++) {
        for (int c=0; c<8; c++) {
            theBoard[r][c] = " + ";
        } //end of columns
    } //end of rows
} //end of initializeBoard

void Board::setPiece(string pieceName, int destRow, int destCol) {
    theBoard[destRow][destCol]= pieceName;
} //end of setPiece

void Board::setPiece(int sourceRow, int sourceCol, int destRow, int destCol) {
    //implement this
} //end of setPiece

void Board::drawBoard() {
    cout<<"\t A \t B \t C \t D \t E \t F \t G \t H \t";
    for (int r=0; r<8; r++) {
        cout << " \n";
        cout << endl;
        cout << r+1;
        for (int c=0; c<8; c++) {   
            cout << "\t";
            cout << theBoard [r] [c];
        } //end of columns
    } //end of rows
    cout << endl;
    cout << "\n";
} //end of drawBoard


class Game {

    private:
        Board theBoard;
        vector <Piece*> allThePieces;        //a vector of Piece pointers
        string whoseTurn;                            //holds either "black" or "white"
        //this method converts the user's input into a form the board can understand.
        //for instance, it changes the user's input "B" to 2.  it also does the same for
        //the input "3", which is changed to a 3.
        int convertStringToNum(char); //implement this
        //this method constructs all the pieces and places them on the board
        void createPieces();//implement part of this; do one or two pieces
        Piece * findPiece(int, int);        //locates a particular piece using row and column coordinates
        bool intersectsOtherPieces(int, int, int, int); //checks whether path moves through other pieces
        //checks for a piece at a location, then removes it from the board
        void capturePiece(int, int);

    public:
        //public methods
        Game();        //constructor
        ~Game();        //destructor
        void takeTurns();        //swaps whose turn it is and ask for moves
        //tries to move a piece.  if there are no problems, it returns true. 
        //if it is unsuccesful (for instance, if the move is illegal), it returns false.
        bool movePiece(int, int, int, int);
        //checks whether each team still has their king, if one is missing, the other
        //team is declared the winner
        bool isGameOver();
       

};

Game::Game() {
    createPieces();
    whoseTurn = "white";
    cout <<"Let the games begin! \n";
} // end of createPieces

void Game::createPieces() {
    for (int i=1; i<=8; i++) {       
        allThePieces.push_back(new Pawn (2, i, "black"));
        allThePieces.push_back(new Pawn (7, i, "white"));
        allThePieces.push_back(new King (1, 5, "black"));
        allThePieces.push_back(new King (8, 5, "white"));
        allThePieces.push_back(new Queen (1, 4, "black"));
        allThePieces.push_back(new Queen (8, 4, "white"));
        allThePieces.push_back(new Knight (1, 2, "black"));
        allThePieces.push_back(new Knight (8, 2, "white"));
        allThePieces.push_back(new Knight (1, 7, "black"));
        allThePieces.push_back(new Knight (8, 7, "white"));
        allThePieces.push_back(new Rook (1, i, "black"));
        allThePieces.push_back(new Rook (8, i, "white"));
        allThePieces.push_back(new Rook (1, i, "black"));
        allThePieces.push_back(new Rook (8, i, "white"));
        allThePieces.push_back(new Bishop (1, 8, "black"));
        allThePieces.push_back(new Bishop (8, 1, "white"));
        allThePieces.push_back(new Bishop (1, 1, "black"));
        allThePieces.push_back(new Bishop (8, 8, "white"));
    }

    for (int i=0; i<allThePieces.size(); i++) {
        theBoard.setPiece(allThePieces.at(i)->label, allThePieces.at(i)->currentRow-1, allThePieces.at(i)->currentColumn-1);
    }
} //end of createPieces

bool Game::movePiece(int pieceRow, int pieceCol, int destRow, int destCol) {

    Piece * tempPiece;
    tempPiece = findPiece(pieceRow, pieceCol);
    //first, make sure there's a piece where they selected
    if (tempPiece->currentRow == -1) {
        cout<<"no piece exists at "<<pieceRow<<", "<<pieceCol<<"\n"; 
        return false;
    }
    //next, make sure they are moving one of their own pieces
    else if (whoseTurn != tempPiece->color) {
        cout<<"that is not your piece\n";
        return false;
    }
    //next, check that the destination is not the same as the current location
    else if (pieceRow == destRow && pieceCol == destCol) {
        cout<<"your piece is already at that location\n";
        return false;
    }
    //next, check to make sure i'm not moving onto a piece of my own color
    else if (findPiece(destRow, destCol)->color == tempPiece->color) {
        cout<<"can't move on top of a piece of your own color\n";
        return false;
    }
    //next, make sure the path is clear to my goal spot
    else if (intersectsOtherPieces(pieceRow, pieceCol, destRow, destCol) &&
        !tempPiece->canHop ) {
        cout<<"there is a piece in your way.  only knights can jump over other pieces.\n";
        return false;
    }
    //next, check to see if the move is legal for that piece
    else if (!tempPiece->isMoveLegal(destRow, destCol)) {
        cout<<"sorry, that move is not legal!\n";
        return false;
    }

    //if we've made it this far, we're okay.  place the piece
    cout<<"moving piece "<<tempPiece->label<<" to "<<destRow<<", "<<destCol<<"\n";
    //capture any piece that's there
    capturePiece(destRow, destCol);
    //inform the board
    theBoard.setPiece(tempPiece->currentRow-1, tempPiece->currentColumn-1, destRow-1, destCol-1);
    //change the piece's location
    tempPiece->currentRow = destRow;
    tempPiece->currentColumn = destCol;
   
} //end of movePiece


Piece * Game::findPiece(int row, int col) {
    bool foundPiece = false;
    Piece * currPiece;

    for (int i=0; i<allThePieces.size(); i++) {  //iterate through all the pieces
        currPiece = allThePieces.at(i);   

        if (currPiece->currentRow == row && currPiece->currentColumn == col) {
            return currPiece;
            foundPiece = true;
        } //end of searching for piece
    }

    if (!foundPiece) {   
        return &Piece("no piece", -1, -1, "no color");
    }
} //end of findPiece


bool Game::intersectsOtherPieces(int sourceRow, int sourceColumn, int destRow, int destColumn) {
    int tempRow = sourceRow;
    int tempColumn = sourceColumn;
   
    while(tempRow != destRow || tempColumn != destColumn) {
        if(tempRow < destRow) { tempRow++; }
        else if (tempRow > destRow) { tempRow--; }

        if(tempColumn < destColumn) { tempColumn++; }
        else if (tempColumn > destColumn) { tempColumn--; }

        if (findPiece(tempRow, tempColumn)->currentRow != -1) {
            //cout<<"found piece in your way at "<<tempRow<<", "<<tempColumn;
            return true;
        }
        return false;

    } //end of while

} //end of intersectsOtherPieces

int Game::convertStringToNum(char letter) {
    //implement this, it does not work
    return -1;
} //end of convertLetterToNum

void Game::takeTurns() {
    if (whoseTurn == "white") { whoseTurn = "black";  }
    else { whoseTurn = "white";  }
    char source1, source2, dest1, dest2;
    int sRow, sCol, dRow, dCol;
    bool moveSuccessful = false;

    while (!moveSuccessful) {
        theBoard.drawBoard();
        //prompt for move
        cout<<whoseTurn<<", which piece would you like to move? > ";
        cin>>source1>>source2;
        cout<<"where would you like to move? > ";
        cin>>dest1>>dest2;
        system("cls");

        //convert the letter to a number
        if (isalpha(source1)) {
            sCol = convertStringToNum(source1);
            sRow = convertStringToNum(source2);
        }
        else {
            sRow = convertStringToNum(source1);
            sCol = convertStringToNum(source2);
        }
        if (isalpha(dest1)) {
            dCol = convertStringToNum(dest1);
            dRow = convertStringToNum(dest2);
        }
        else {
            dRow = convertStringToNum(dest1);
            dCol = convertStringToNum(dest2);
        }
        moveSuccessful = movePiece(sRow, sCol, dRow, dCol);
    } //end of while move is not successful
} //end of takeTurns

void Game::capturePiece(int row, int col) {
    Piece * currPiece;
    int targetIndex = -1;

    for (int i=0; i<allThePieces.size(); i++) {  //iterate through all the pieces
        currPiece = allThePieces.at(i);   

        if (currPiece->currentRow == row && currPiece->currentColumn == col) {
            targetIndex = i;
            cout<<"you captured the "<<currPiece->label<<"\n";
        } //end of searching for piece
    }
    if (targetIndex != -1) {
        allThePieces.erase(allThePieces.begin() + targetIndex);
    }
} //end of capturePiece

bool Game::isGameOver() {
    bool foundWhiteKing = false;
    bool foundBlackKing = false;
    Piece * currPiece;

    for (int i=0; i<allThePieces.size(); i++) {  //iterate through all the pieces
        currPiece = allThePieces.at(i);   
        if (currPiece->label == "K-W") { foundWhiteKing = true; }
        else if (currPiece->label == "K-B") { foundBlackKing = true; }
    }

    if (!foundWhiteKing) {   
        cout<<"Black team wins! Congratulations!"; 
        return true;
    }
    else if (!foundBlackKing) {   
        cout<<"White team wins! Congratulations!"; 
        return true;
    }
    else {  return false;  }
} //end of isGameOver

Game::~Game() {
    for (int i=0; i<allThePieces.size(); i++) {  //iterate through all the pieces
        delete allThePieces.at(i);
    }
} //end of destructor









int main() {
    int kludge;
    Game theGame;
    //Board gameboard;
    //gameboard.drawBoard();
   
    //while (!theGame.isGameOver()) {           
        theGame.takeTurns();
    //} //end of while game is not over

    cin>>kludge;
    return 0;
} //end of main


Scripting 26Dec2011 03:51

Re: Need a help on C++
 
Hmm, I would indeed want to help you, but I don't have 2 hours for reading through this huge code, sorry.

xpi0t0s 29Dec2011 14:20

Re: Need a help on C++
 
>> I can't move it's pieces

What happens if you try?

Does your code compile? If not, what errors do you get?
I suspect you'll get an error here:
Code:

bool Game::intersectsOtherPieces(int sourceRow, int sourceColumn, int destRow, int destColumn) {
...
if (findPiece(tempRow, tempColumn)->currentRow != -1) {

because findPiece returns a Piece*, not an int.

But anyway, I need to know what happens if you try to move a piece, because I can't tell from looking at the code why you can't move one.


All times are GMT +5.5. The time now is 07:58.