1. We have moved from vBulletin to XenForo and you are viewing the site in the middle of the move. Though the functional aspect of everything is working fine, we are still working on other changes including the new design on Xenforo.
    Dismiss Notice

Need a help on C++

Discussion in 'C++' started by retroshell, Dec 25, 2011.

  1. retroshell

    retroshell New Member

    Joined:
    Dec 25, 2011
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    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
     
  2. Scripting

    Scripting John Hoder

    Joined:
    Jun 29, 2010
    Messages:
    421
    Likes Received:
    57
    Trophy Points:
    0
    Occupation:
    School for life
    Location:
    /root
    Hmm, I would indeed want to help you, but I don't have 2 hours for reading through this huge code, sorry.
     
  3. xpi0t0s

    xpi0t0s Mentor

    Joined:
    Aug 6, 2004
    Messages:
    3,012
    Likes Received:
    203
    Trophy Points:
    0
    Occupation:
    Senior Support Engineer
    Location:
    England
    >> 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.
     

Share This Page