westernboard.h

/*
    This file is part of Cute Chess.

    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 WESTERNBOARD_H
#define WESTERNBOARD_H

#include "board.h"

namespace Chess {

class WesternZobrist;


class LIB_EXPORT WesternBoard : public Board
{
    public:
        enum WesternPieceType
        {
            Pawn = 1,   
            Knight,     
            Bishop,     
            Rook,       
            Queen,      
            King        
        };

        WesternBoard(WesternZobrist* zobrist);

        // Inherited from Board
        virtual int width() const;
        virtual int height() const;
        virtual Result result();
        virtual int reversibleMoveCount() const;

    protected:
        enum CastlingSide
        {
            QueenSide,  
            KingSide,   
            NoCastlingSide  
        };

        static const unsigned KnightMovement = 2;
        static const unsigned BishopMovement = 4;
        static const unsigned RookMovement = 8;

        enum StepType
        {
             NoStep = 0,      
             FreeStep =  1,   
             CaptureStep = 2  
             /* FreeOrCaptureStep = FreeStep|CaptureStep //!< like King or Sergeant*/
        };
        struct PawnStep { StepType type; int file; };
        QVarLengthArray<PawnStep, 8> m_pawnSteps;
        int pawnAmbiguity(StepType type = FreeStep) const;
        virtual bool kingsCountAssertion(int whiteKings,
                         int blackKings) const;
        virtual bool kingCanCapture() const;
        virtual void addPromotions(int sourceSquare,
                       int targetSquare,
                       QVarLengthArray<Move>& moves) const;
        int kingSquare(Side side) const;
        int enpassantSquare() const;
        bool hasCastlingRight(Side side, CastlingSide castlingSide) const;
        void removeCastlingRights(int square);
        virtual int castlingFile(CastlingSide castlingSide) const;
        virtual bool inCheck(Side side, int square = 0) const;

        virtual QString vFenIncludeString(FenNotation notation) const;

        // Inherited from Board
        virtual void vInitialize();
        virtual QString vFenString(FenNotation notation) const;
        virtual bool vSetFenString(const QStringList& fen);
        virtual QString lanMoveString(const Move& move);
        virtual QString sanMoveString(const Move& move);
        virtual Move moveFromLanString(const QString& str);
        virtual Move moveFromSanString(const QString& str);
        virtual void vMakeMove(const Move& move,
                       BoardTransition* transition);
        virtual void vUndoMove(const Move& move);
        virtual void generateMovesForPiece(QVarLengthArray<Move>& moves,
                           int pieceType,
                           int square) const;
        virtual bool vIsLegalMove(const Move& move);
        virtual bool isLegalPosition();
        virtual int captureType(const Move& move) const;

    private:
        struct CastlingRights
        {
            // Usage: 'rookSquare[Side][CastlingSide]'
            // A value of zero (square 0) means no castling rights
            int rookSquare[2][2];
        };

        // Data for reversing/unmaking a move
        struct MoveData
        {
            Piece capture;
            int enpassantSquare;
            int enpassantTarget;
            CastlingRights castlingRights;
            CastlingSide castlingSide;
            int reversibleMoveCount;
        };

        void generateCastlingMoves(QVarLengthArray<Move>& moves) const;
        void generatePawnMoves(int sourceSquare,
                       QVarLengthArray<Move>& moves) const;

        bool canCastle(CastlingSide castlingSide) const;
        QString castlingRightsString(FenNotation notation) const;
        bool parseCastlingRights(QChar c);
        CastlingSide castlingSide(const Move& move) const;
        void setEnpassantSquare(int square,
                    int target=0);
        void setCastlingSquare(Side side,
                       CastlingSide cside,
                       int square);
        inline int pawnPushOffset(const PawnStep& ps,
                      int sign) const;

        int m_arwidth;
        int m_sign;
        int m_kingSquare[2];
        int m_enpassantSquare;
        int m_enpassantTarget;
        int m_reversibleMoveCount;
        bool m_kingCanCapture;
        bool m_pawnAmbiguous;
        QVector<MoveData> m_history;
        CastlingRights m_castlingRights;
        int m_castleTarget[2][2];
        const WesternZobrist* m_zobrist;

        QVarLengthArray<int> m_knightOffsets;
        QVarLengthArray<int> m_bishopOffsets;
        QVarLengthArray<int> m_rookOffsets;
};


} // namespace Chess
#endif // WESTERNBOARD_H