chess.h

Go to the documentation of this file.

 
#ifndef CHESS_H // header guard to prevent multiple includes of the classes (results in compilation error)
#define CHESS_H
 
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <windows.h>    // for console text colors
 
using namespace std;
  // to indicate that global variables are defined here (doxygen documentation)
 
#define GREEN 10
 
#define CYAN 11
 
#define RED 12
 
#define PINK 13
 
#define YELLOW 14
 
#define DEFAULT 15
 
enum pieceType 
{
    PAWN,       
    KNIGHT,     
    BISHOP,     
    ROOK,       
    QUEEN,      
    KING,       
    EMPTY       
};
 
enum pieceColor 
{
    BLACK,      
    NEUTRAL,    
    WHITE       
};
 
// forward declaration
class Piece;
 
/*************************************************************************************/
/*                              CHESS CLASS - MEMBER FUNCTIONS                       */
/*************************************************************************************/
class Chess
{
public:
    Chess();
 
    /*********************************** BIG THREE *********************************/
    ~Chess();
 
    Chess(const Chess &chess_object);
 
    Chess & operator =(const Chess &chess_object);
    /************************************* END *************************************/
 
    /************************ MUTATOR & ACCESSOR FUNCTIONS ************************/
    vector<Piece*> getBoard() const {return board;}
 
    void setBoard(const vector<Piece*> &board) {this->board = board;}
 
    vector<Piece*> getCheckPieces() const {return check_pieces;}
 
    void setCheckPieces(const vector<Piece*> &check_pieces) {this->check_pieces = check_pieces;}
 
    bool getCheck() const {return flags[0];}
 
    void setCheck(bool check) {flags[0] = check;}
 
    bool getDoubleCheck() const {return flags[1];}
 
    void setDoubleCheck(bool double_check) {flags[1] = double_check;}
 
    bool getCheckmate() const {return flags[2];}
 
    void setCheckmate(bool checkmate) {flags[2] = checkmate;}
 
    bool getStalemate() const {return flags[3];}
 
    void setStalemate(bool stalemate) {flags[3] = stalemate;}
 
    pieceColor getTurn() const {return turn;}
 
    void setTurn(pieceColor turn) {this->turn = turn;}
 
    int getNumMoves() const { return num_moves;}
 
    void setNumMoves(int num_moves) {this->num_moves = num_moves;}
 
    /*************************************************************************************/
    /*                            CHESSCAMO RESERVOIR FUNCTIONALITY                      */
    /*************************************************************************************/
    vector<pair<int, char>> getReservoir() const {return reservoir;}
 
    void setReservoir(const vector<pair<int, char>> & reservoir) {this->reservoir = reservoir;}
 
    bool useReservoirPiece(int src, int dest);
    /************************************* END *************************************/
 
    void boardInit();
 
    bool makeMove(int src, int dest, istream &in); 
 
    void isCheckmate(string check_type);
              
    bool isStalemate();
    
    friend ostream & operator << (ostream &out, const Chess &chess_object);
 
    friend istream & operator >> (istream &in, Chess &chess_object);
 
private:
    vector<Piece*> board;
 
    vector<Piece*> check_pieces;
 
    vector<bool> flags;
 
    vector<pair<int, char>> reservoir;
 
    pieceColor turn;
 
    int num_moves;          
 
    /*************************************************************************************/
    /*                              PIECE CLASS - HELPER FUNCTIONS                       */
    /*************************************************************************************/
    void makeMoveForType(int src, int dest);
 
    void pieceSwap(int src, int dest, vector<Piece*> &board);
 
    void handleChangeTurn();
 
    void handleCheckmate();
 
    void handleStalemate();
 
    bool singleCheckPieceIterator(Piece *piece, Piece *king); 
    
    bool doubleCheckPieceIterator(Piece *king);
 
    pieceColor switchTurn();
};
 
/*************************************************************************************/
/*                              PIECE CLASS - MEMBER FUNCTIONS                       */
/*************************************************************************************/
class Piece
{
public:
    virtual ~Piece() {}
    Piece() : square{0}, moved{false}, type{EMPTY}, color{NEUTRAL} {}
 
    Piece(int square, pieceType type, pieceColor color) 
        : moved{false}
    {
        this->square = square;
        this->type = type;
        this->color = color;
    }
 
    /************************ MUTATOR & ACCESSOR FUNCTIONS ************************/
    int getPieceSquare() const {return square;}
 
    void setPieceSquare(int square) {this->square = square;}
 
    pieceType getPieceType() const {return type;}
 
    void setPieceType(pieceType type) {this->type = type;}
 
    pieceColor getPieceColor() const {return color;}
 
    void setPieceColor(pieceColor color) {this->color = color;}
 
    bool getPieceMoveInfo() const {return moved;}
 
    void setPieceMoveInfo(bool moved) {this->moved = moved;}    
    
    virtual bool getEnPassantLeft() const {return false;}
 
    virtual void setEnPassantLeft(bool en_passant_left) {}
 
    virtual bool getEnPassantRight() const {return false;}
 
    virtual void setEnPassantRight(bool en_passant_right) {}
    /************************************* END *************************************/
 
    /************************ TYPE DETERMINATION FUNCTIONS *************************/
    bool isEmpty() {return this->getPieceType() == EMPTY;}
 
    bool isPawn() {return this->getPieceType() == PAWN;}
 
    bool isKnight() {return this->getPieceType() == KNIGHT;}
 
    bool isBishop() {return this->getPieceType() == BISHOP;}
 
    bool isRook() {return this->getPieceType() == ROOK;}
 
    bool isQueen() {return this->getPieceType() == QUEEN;}
 
    bool isKing() {return this->getPieceType() == KING;}
    /************************************* END *************************************/
 
    /************************ COLOR DETERMINATION FUNCTIONS ************************/
    bool isPieceWhite() {return this->getPieceColor() == WHITE;}
 
    bool isPieceBlack() {return this->getPieceColor() == BLACK;}
    /************************************* END *************************************/
    bool isSameColor(int dest, const Chess &chess);
    
    bool isPinned(int dest, const Chess &chess);
 
    bool isPathFree(int dest, const Chess &chess);
 
    bool isLegalMove(int dest, Chess &chess);
 
    bool causeCheck(int dest, Chess &chess);
 
    bool causeDoubleCheck(int dest, Chess &chess);
    
    virtual bool isPossibleMove(int dest, const Chess &chess) {return false;}
 
    virtual void enPassantHandling(int src, Chess &chess) {return;}
 
    virtual void promotePawn(Chess &chess, istream &in) {return;}
 
    virtual bool canCastle(int dest, const Chess &chess) {return false;}
 
    virtual bool movedIntoCheck(int dest, Chess &chess) {return false;}
 
private:
    int square;
 
    bool moved; 
 
    pieceType type;
 
    pieceColor color;   
};
 
/*************************************************************************************/
/*                              PAWN CLASS - MEMBER FUNCTIONS                        */
/*************************************************************************************/
class Pawn : public Piece
{
public:
    ~Pawn() {}
 
    Pawn() : Piece(), en_passant_left{false}, en_passant_right{false} {}
 
    // constructor with valid piece information initialization
    
    Pawn(int square, pieceType type, pieceColor color)
     : Piece(square, type, color), en_passant_left{false}, en_passant_right{false} {}
 
    /************************ MUTATOR & ACCESSOR FUNCTIONS ************************/
    // En-passant ability information (LEFT)
    bool getEnPassantLeft() const override {return en_passant_left;}
    void setEnPassantLeft(bool en_passant_left) override {this->en_passant_left = en_passant_left;}
 
    // En-passant ability information (RIGHT)
    bool getEnPassantRight() const override {return en_passant_right;}
    void setEnPassantRight(bool en_passant_right) override {this->en_passant_right = en_passant_right;}
    /************************************* END *************************************/
 
    bool isPossibleMove(int dest, const Chess &chess) override;
 
    void enPassantHandling(int src, Chess &chess) override;
 
    void promotePawn(Chess &chess, istream &in) override;
 
private:
    bool en_passant_left;
 
    bool en_passant_right;
};  
 
/*************************************************************************************/
/*                              KNIGHT CLASS - MEMBER FUNCTIONS                      */
/*************************************************************************************/
class Knight : public Piece
{
public:
    ~Knight() {}
 
    Knight() : Piece() {}
 
    Knight(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
 
    bool isPossibleMove(int dest, const Chess &chess) override;
};
 
/*************************************************************************************/
/*                              BISHOP CLASS - MEMBER FUNCTIONS                      */
/*************************************************************************************/
class Bishop : public Piece
{
public:
    ~Bishop() {}
 
    Bishop() : Piece() {}
 
    Bishop(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
 
    bool isPossibleMove(int dest, const Chess &chess) override;
};
 
/*************************************************************************************/
/*                              ROOK CLASS - MEMBER FUNCTIONS                        */
/*************************************************************************************/
class Rook : public Piece
{
public:
    ~Rook() {}
 
    Rook() : Piece() {}
 
    Rook(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
 
    bool isPossibleMove(int dest, const Chess &chess) override;
};
 
/*************************************************************************************/
/*                              QUEEN CLASS - MEMBER FUNCTIONS                       */
/*************************************************************************************/
class Queen : public Piece
{
public:
    ~Queen() {}
 
    Queen() : Piece() {}
 
    Queen(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
 
    bool isPossibleMove(int dest, const Chess &chess) override;
};
 
/*************************************************************************************/
/*                              KING CLASS - MEMBER FUNCTIONS                        */
/*************************************************************************************/
class King : public Piece
{
public:
    ~King() {}
 
    King() : Piece() {}
 
    King(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
 
    bool isPossibleMove(int dest, const Chess &chess) override;
 
    bool canCastle(int dest, const Chess &chess) override;
 
    bool movedIntoCheck(int dest, Chess &chess) override;
};
 
/*************************************************************************************/
/*                              EMPTY CLASS - MEMBER FUNCTIONS                       */
/*************************************************************************************/
class Empty : public Piece
{
public:
    ~Empty() {}
 
    Empty() : Piece() {}
 
    Empty(int square, pieceType type, pieceColor color) : Piece(square, type, color) {}
};
 
/*************************************************************************************/
/*                              GLOBAL FUNCTIONS / OBJECTS                           */
/*************************************************************************************/
namespace chessCAMO
{
    template<class T>
    int preProcessInput(T input)
    {
        if(std::isalpha(input[0]) && input.length() > 1)
        {
            int ascii_val = std::islower(input[0]) ? 97 : 65;
            return (int(input[0]) - ascii_val) + (8 - (int(input[1]) - 48))*8; // file + rank
        }
 
        // piece from reservoir?
        else if(std::isalpha(input[0]))
            return (unsigned char) std::tolower(input[0]);
 
        else { return std::stoi(input); }
    }
 
    void printBoard(const vector<Piece*> &board, const vector<pair<int, char>> &reservoir);
 
    void printFooterMessage(string input_message, const Chess &chess);
 
    void drawOrResign(bool clear_screen, Chess &chess, istream &in);
 
    void printMessage(string text, int color);
 
    void clearScreen(bool apply);
 
    void saveObject(const Chess &chess_object);
 
    void restoreObject(Chess &chess_object);
} // end namespace chessCAMO
 
#endif // CHESS_H
 
// main page of doxygen documentation file