board.hpp

#ifndef _TARTAN_HPP_
#define _TARTAN_HPP_
 
#include <array>
#include <forward_list>
#include <list>
#include <ostream>
#include <typeindex>
#include <functional>
#include <initializer_list>
 
namespace tt {
 
class Board;
 
class Piece {
public:
    enum class Color {
        Black = 0, White = 1,
    };
    class Position {
    public:
        enum class Mode {
            Normal = 1, 
            Reverse = -1, 
        };
    private:
        short p_x = 1;
        short p_y = 1;
        Mode p_mode = Mode::Normal;
    public:
        Position() = default; 
        Position(int x, int y);
        Position(char l, int d);
        Position(const std::string& str);
        Position(const char* str) : Position(std::string(str)) {};
    public:
        Position(const Position&);
        Position& operator=(const Position&);
    public:
        int x() const { return p_x; };
        int y() const { return p_y; };
        char letter() const { return p_x + 'a' - 1; };
        int digit() const { return p_y; };
        int setX(int x);
        int setY(int y);
        char setLetter(char x) { return setX(x-'a'+1) + 'a'-1; };
        int setDigit(short y) { return setY(y); };
        Position offset(int dx, int dy) const;
        Position offset(char dc, int dd) const;
        bool atLeft() const;
        bool atRight() const;
        bool atTop() const;
        bool atBottom() const;
        Mode mode() const { return p_mode; };
        Mode setMode (Mode m);
    public:
        std::string str() const;
        Position operator+(const Position&) const;
        Position operator-(const Position&) const;
        Position operator+=(const Position&);
        Position operator-=(const Position&);
        Position operator()(int dx, int dy) const;
        Position operator()(char dc, int dd) const;
        friend bool operator==(const Position&, const Position&);
        friend std::ostream& operator<<(
            std::ostream&, const Position&);
    };
    class Turn {
    public:
        Turn(const Piece* tpiece, 
             const Position& to, 
             const Piece* cap = nullptr, 
             bool possible = true);
        Position to() const { return t_to; };
        Position from() const { return t_from; };
        const Piece* piece() const { return t_piece; };
        Piece* piece() { return t_piece; };
        const Piece* capture() const { return t_capture; };
        Piece* capture() { return t_capture; };
        bool possible() const { return t_possible; };
        bool setPossible(bool c) { return !(t_possible = c); };
        virtual std::string str() const;
        virtual void apply(int mode = 0);
        virtual void undo();
        virtual bool isEqual(const Turn& rhs) const;
        friend bool operator==(const Turn& lhs, const Turn& rhs);
        friend bool operator!=(const Turn&, const Turn&);
        friend std::ostream& operator<<(std::ostream& os, const Turn& t);
        virtual auto clone() const -> std::decay<decltype(*this)>::type*;
        virtual ~Turn() = default;
    protected:
        Position t_from;
        Position t_to;
        Piece* t_piece;
        Piece* t_capture;
        bool t_possible;
    };
    class TurnMap : public std::list<Turn*> {
    public:
        using std::list<Turn*>::list;
        TurnMap(const TurnMap&);
        TurnMap(TurnMap&&);
        TurnMap& operator=(const TurnMap& other);
        TurnMap& operator=(TurnMap&& other);
        bool possible() const;
        ~TurnMap();
        friend bool operator==(const TurnMap& lhs, const TurnMap& rhs);
        friend bool operator!=(const TurnMap& lhs, const TurnMap& rhs);
    };
protected:
    Color p_color;
    Position p_position;
    Board* p_board = nullptr;
    std::size_t p_movesMade = 0;
    std::size_t p_turnIndex = 0;
public:
    Color color() const { return p_color; };
    Color setColor(Color col);
    const Position& position() const { return p_position; };
    Position& position() { return p_position; };
    Position setPosition(const Position&);
    virtual Position move(const Position& to);
    virtual TurnMap moveMap(int mode = 0) const = 0;
    const Board* board() const { return p_board; };
    Board* board() { return p_board; };
    Board* setBoard(Board* b);
    std::size_t movesMade() const { return p_movesMade; }
    std::size_t turnIndex() const { return p_turnIndex; }
public:
    static TurnMap diagonalMoves(const Piece* p);
    static TurnMap straightMoves(const Piece* p);
public:
    Piece(const Position& pos = {1,1}, Color col = Color::White);
    virtual ~Piece() = default;
};
 
using BoardT = std::array<std::array<Piece*, 8>, 8>;
class Board : private BoardT {
    friend class Piece::Turn;
public:
    using CapturedT = std::forward_list<const Piece*>;
    using HistoryT = std::list<const Piece::Turn*>;
    using TurnsT = std::list<std::pair<Piece::Position, Piece::Position>>;
    using PieceSetT = std::list<Piece*>;
    using PieceTypesArgT = std::list<std::type_index>;
    using PieceTypesRetT = std::type_index;
    using PieceGetterT = std::function<PieceTypesRetT(PieceTypesArgT)>;
public:
    Board();
    Board(PieceSetT& set);
 
    Board(Board&&) = default;
    Board& operator=(Board&&) = default;
    Board(const Board&) = delete;
    Board& operator=(const Board&) = delete;
public:
    Piece::Color currentTurn() const {
        return b_currentTurnColor; 
    };
    virtual Piece::Color setCurrentTurn(Piece::Color col);
    virtual Piece::TurnMap possibleMoves(const Piece* p) const;
    Piece::TurnMap possibleMoves(const Piece::Position& pos) const;
    virtual const Piece::Turn* makeTurn(const Piece::Position& from, 
                                                         const Piece::Position& to) = 0;
protected:
    virtual Piece* placePiece(Piece* p);
    Piece::TurnMap produceTurn(const Piece::Position& from,
                                                    const Piece::Position& to, Piece::Turn** turn);
    virtual const Piece::Turn* applyTurn(Piece::Turn* turn);
public:
    const BoardT& board() const { return static_cast<const BoardT&>(*this); };
    BoardT& board() { return static_cast<BoardT&>(*this); };
    HistoryT& history() { return b_history; };
    const HistoryT& history() const { return b_history; };
    std::size_t movesMade() const { return b_history.size(); }
    std::size_t turnIndex() const { return b_turnIndex; };
 
    virtual Piece* canInsert(Piece* p) const;
    virtual Piece* insertPiece(Piece* p);
    virtual void clear();
 
    void fill();
    void fill(PieceSetT& set);
    void fill(const std::string& str);
    template<class Iterator>
    void fill(Iterator begin, Iterator end);
    void fill(std::initializer_list<const std::string> list);
    void refill() { clear(); fill(); };
 
    virtual PieceSetT defaultPieceSet() const = 0;
 
    virtual bool isEqual(const Board& other) const = 0;
    friend bool operator==(const Board& lhs, const Board& rhs);
    friend bool operator!=(const Board&, const Board&);
    Piece*& operator[](const Piece::Position& pos);
    const Piece* operator[](const Piece::Position& pos) const;
    Piece*& at(const Piece::Position& pos);
    const Piece* at(const Piece::Position& pos) const;
    using BoardT::iterator;
    using BoardT::const_iterator;
    using BoardT::begin;
    using BoardT::end;
    void setPieceGetter(PieceGetterT g) { b_pieceGetter = g; };
    PieceGetterT& pieceGetter() { return b_pieceGetter; };
    const PieceGetterT& pieceGetter() const  { return b_pieceGetter; };
    PieceTypesRetT getPieceType(PieceTypesArgT possible);
    virtual std::string str() const = 0;
    friend std::ostream& operator<<(std::ostream& os, const Board& b);
    ~Board();
public:
    PieceSetT set(const std::string& str) const;
    template<class Iterator>
    PieceSetT set(Iterator begin, Iterator end) const;
    virtual Piece* piece(const std::string& spec) const = 0;
private:
    void fillBoardWithNullptrs();
protected:
    Piece::Color b_currentTurnColor = Piece::Color::White;
    CapturedT b_capturedPieces;
    HistoryT b_history;
    PieceGetterT b_pieceGetter;
    std::size_t b_turnIndex = 0;
};
 
}
 
#endif // !_TARTAN_HPP_