board.h

/*
    This file is part of Cute Chess.
    Copyright (C) 2008-2018 Cute Chess authors

    Cute Chess is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Cute Chess is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef BOARD_H
#define BOARD_H

#include <QString>
#include <QVector>
#include <QVarLengthArray>
#include <QSharedPointer>
#include <QDebug>
#include <QCoreApplication>
#include "square.h"
#include "piece.h"
#include "move.h"
#include "genericmove.h"
#include "zobrist.h"
#include "result.h"
class QStringList;


namespace Chess {

class BoardTransition;

class LIB_EXPORT Board
{
    Q_DECLARE_TR_FUNCTIONS(Board)

    public:
        enum CoordinateSystem
        {
            NormalCoordinates,
            InvertedCoordinates
        };
        enum MoveNotation
        {
            StandardAlgebraic,  
            LongAlgebraic       
        };
        enum FenNotation
        {
            XFen,
            ShredderFen
        };

        Board(Zobrist* zobrist);
        virtual ~Board();
        virtual Board* copy() const = 0;

        virtual QString variant() const = 0;
        virtual bool isRandomVariant() const;
        virtual bool variantHasDrops() const;
        virtual bool variantHasOptionalPromotions() const;
        virtual bool variantHasWallSquares() const;
        virtual QList<Piece> reservePieceTypes() const;
        virtual CoordinateSystem coordinateSystem() const;
        virtual int width() const = 0;
        virtual int height() const = 0;
        virtual QString defaultFenString() const = 0;
        quint64 key() const;
        void initialize();
        
        bool isValidSquare(const Square& square) const;

        QStringList pieceList(Side side) const;
        QString fenString(FenNotation notation = XFen) const;
        QString startingFenString() const;
        bool setFenString(const QString& fen);
        void reset();

        virtual Side upperCaseSide() const;
        Side sideToMove() const;
        Side startingSide() const;
        Piece pieceAt(const Square& square) const;
        int plyCount() const;
        int repeatCount() const;
        virtual int reversibleMoveCount() const;
        int reserveCount(Piece piece) const;
        QString pieceSymbol(Piece piece) const;
        Piece pieceFromSymbol(const QString& pieceSymbol) const;
        QString pieceString(int pieceType) const;
        QString representation(Piece piece) const;

        void makeMove(const Move& move, BoardTransition* transition = nullptr);
        void undoMove();

        QString moveString(const Move& move, MoveNotation notation);
        Move moveFromString(const QString& str);
        Move moveFromGenericMove(const GenericMove& move) const;
        GenericMove genericMove(const Move& move) const;

        bool isLegalMove(const Move& move);
        bool isRepetition(const Move& move);
        QVector<Move> legalMoves();
        virtual Result result() = 0;
        virtual Result tablebaseResult(unsigned int* dtm = nullptr) const;

    protected:
        virtual void vInitialize() = 0;

        void setPieceType(int type,
                  const QString& name,
                  const QString& symbol,
                  unsigned movement = 0,
                  const QString & gsymbol = QString());
        bool pieceHasMovement(int pieceType, unsigned movement) const;

        virtual void vMakeMove(const Move& move,
                       BoardTransition* transition) = 0;
        virtual void vUndoMove(const Move& move) = 0;

        Square chessSquare(int index) const;
        Square chessSquare(const QString& str) const;
        int squareIndex(const Square& square) const;
        int squareIndex(const QString& str) const;
        QString squareString(int index) const;
        QString squareString(const Square& square) const;

        virtual QString lanMoveString(const Move& move);
        virtual QString sanMoveString(const Move& move) = 0;
        virtual Move moveFromLanString(const QString& str);
        virtual Move moveFromSanString(const QString& str) = 0;
        virtual int maxPieceSymbolLength() const;

        virtual QString vFenString(FenNotation notation) const = 0;
        virtual bool vSetFenString(const QStringList& fen) = 0;

        void generateMoves(QVarLengthArray<Move>& moves,
                   int pieceType = Piece::NoPiece) const;
        void generateDropMoves(QVarLengthArray<Move>& moves, int pieceType) const;
        virtual void generateMovesForPiece(QVarLengthArray<Move>& moves,
                           int pieceType,
                           int square) const = 0;
        void generateHoppingMoves(int sourceSquare,
                      const QVarLengthArray<int>& offsets,
                      QVarLengthArray<Move>& moves) const;
        void generateSlidingMoves(int sourceSquare,
                      const QVarLengthArray<int>& offsets,
                      QVarLengthArray<Move>& moves) const;
        virtual bool isLegalPosition() = 0;
        virtual bool vIsLegalMove(const Move& move);
        virtual int captureType(const Move& move) const;
        void xorKey(quint64 key);
        bool moveExists(const Move& move) const;
        bool canMove();
        int arraySize() const;
        Piece pieceAt(int square) const;
        void setSquare(int square, Piece piece);
        const Move& lastMove() const;
        virtual int reserveType(int pieceType) const;
        void addToReserve(const Piece& piece, int count = 1);
        void removeFromReserve(const Piece& piece);

    private:
        struct PieceData
        {
            QString name;
            QString symbol;
            unsigned movement;
            QString representation;
        };
        struct MoveData
        {
            Move move;
            quint64 key;
        };
        friend LIB_EXPORT QDebug operator<<(QDebug dbg, const Board* board);

        bool m_initialized;
        int m_width;
        int m_height;
        Side m_side;
        Side m_startingSide;
        QString m_startingFen;
        int m_maxPieceSymbolLength;
        quint64 m_key;
        Zobrist* m_zobrist;
        QSharedPointer<Zobrist> m_sharedZobrist;
        QVarLengthArray<PieceData> m_pieceData;
        QVarLengthArray<Piece> m_squares;
        QVector<MoveData> m_moveHistory;
        QVector<int> m_reserve[2];
};


extern LIB_EXPORT QDebug operator<<(QDebug dbg, const Board* board);

inline int Board::arraySize() const
{
    return m_squares.size();
}

inline Side Board::sideToMove() const
{
    return m_side;
}

inline Side Board::startingSide() const
{
    return m_startingSide;
}

inline QString Board::startingFenString() const
{
    return m_startingFen;
}

inline quint64 Board::key() const
{
    return m_key;
}

inline void Board::xorKey(quint64 key)
{
    m_key ^= key;
}

inline Piece Board::pieceAt(int square) const
{
    return m_squares[square];
}

inline void Board::setSquare(int square, Piece piece)
{
    Piece& old = m_squares[square];
    if (old.isValid())
        xorKey(m_zobrist->piece(old, square));
    if (piece.isValid())
        xorKey(m_zobrist->piece(piece, square));

    old = piece;
}

inline int Board::plyCount() const
{
    return m_moveHistory.size();
}

inline const Move& Board::lastMove() const
{
    return m_moveHistory.last().move;
}

inline bool Board::pieceHasMovement(int pieceType, unsigned movement) const
{
    Q_ASSERT(pieceType != Piece::NoPiece);
    Q_ASSERT(pieceType < m_pieceData.size());

    return (m_pieceData[pieceType].movement & movement);
}

} // namespace Chess
#endif // BOARD_H