shogiboard.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 SHOGIBOARD_H
#define SHOGIBOARD_H
 
#include "board.h"
 
namespace Chess {
 
class LIB_EXPORT ShogiBoard : public Board
{
    public:
        ShogiBoard();
 
        // Inherited from Board
        virtual Board* copy() const;
        virtual QList<Piece> reservePieceTypes() const;
        virtual QString variant() const;
        virtual bool variantHasDrops() const;
        virtual bool variantHasOptionalPromotions() const;
        virtual QString defaultFenString() const;
        virtual CoordinateSystem coordinateSystem() const;
        virtual int width() const;
        virtual int height() const;
        virtual Result result();
 
    protected:
        enum ShogiPieceType
        {
            Pawn = 1,       
            Lance,          
            Knight,         
            SilverGeneral,      
            GoldGeneral,            
            Bishop,         
            Rook,           
            King,           
 
            PromotedPawn,       
            PromotedLance,      
            PromotedKnight,     
            PromotedSilver,     
            PromotedBishop,     
            PromotedRook        
        };
 
        static const unsigned KnightMovement = 2;
        static const unsigned BishopMovement = 4;
        static const unsigned RookMovement = 8;
        static const unsigned FerzMovement = 16;
        static const unsigned WazirMovement = 64;
        static const unsigned LanceMovement = 128;
        static const unsigned SilverMovement = 256;
        static const unsigned GoldMovement = 512;
 
        virtual int promotedPieceType(int type) const;
        virtual int promotionRank() const;
        virtual int normalPieceType(int type) const;
        virtual bool ranksAreAllowed() const;
        virtual bool hasImpassePointRule() const;
        virtual Result impassePointRule(int points, int pieces) const;
 
        // Inherited from Board
        virtual int reserveType(int pieceType) const;
        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 isLegalPosition();
        virtual bool vIsLegalMove(const Move& move);
        virtual bool inCheck(Side side, int square = 0) const;
 
    private:
        // Data for reversing/unmaking a move
        struct MoveData
        {
            Piece capture;
        };
 
        bool rankIsAllowed(int pieceType, int square) const;
        bool fileIsAllowed(int pieceType, int square) const;
        bool inPromotionZone(int square) const;
        Result resultFromImpassePointRule() const;
 
        int m_kingSquare[2];
        int m_promotionRank;
        int m_minIndex;
        int m_maxIndex;
        int m_plyOffset;
        bool m_multiDigitNotation;
        bool m_hasImpassePointRule;
 
        QVarLengthArray<int> m_bishopOffsets;
        QVarLengthArray<int> m_rookOffsets;
        QVarLengthArray<int> m_lanceOffsets[2];
        QVarLengthArray<int> m_knightOffsets[2];
        QVarLengthArray<int> m_silverGeneralOffsets[2];
        QVarLengthArray<int> m_goldGeneralOffsets[2];
        QVector<MoveData> m_history;
};
 
} // namespace Chess
#endif // SHOGIBOARD_H