boardscene.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 BOARDSCENE_H
#define BOARDSCENE_H

#include <QGraphicsScene>
#include <QMultiMap>
#include <QPointer>
#include <board/square.h>
#include <board/genericmove.h>
#include <board/boardtransition.h>
#include <board/result.h>
namespace Chess
{
    class Board;
    class Move;
    class Side;
    class Piece;
}
class ChessGame;
class QSvgRenderer;
class QAbstractAnimation;
class QPropertyAnimation;
class GraphicsBoard;
class GraphicsPieceReserve;
class GraphicsPiece;
class PieceChooser;


class BoardScene : public QGraphicsScene
{
    Q_OBJECT

    public:
        explicit BoardScene(QObject* parent = nullptr);
        virtual ~BoardScene();

        Chess::Board* board() const;
        void setBoard(Chess::Board* board);

    public slots:
        void populate();
        void setFenString(const QString& fenString);
        void makeMove(const Chess::Move& move);
        void makeMove(const Chess::GenericMove& move);
        void undoMove();
        void flip();
        void onGameFinished(ChessGame* game, Chess::Result result);

    signals:
        void humanMove(const Chess::GenericMove& move,
                   const Chess::Side& side);

    protected:
        // Inherited from QGraphicsScene
        virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
        virtual void mousePressEvent(QGraphicsSceneMouseEvent* event);
        virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent* event);

    private slots:
        void onTransitionFinished();
        void onPromotionChosen(const Chess::Piece& promotion);

    private:
        void cancelUserMove();

        enum MoveDirection
        {
            Forward,
            Backward
        };

        QPointF squarePos(const Chess::Square& square) const;
        GraphicsPiece* pieceAt(const QPointF& pos) const;
        GraphicsPiece* createPiece(const Chess::Piece& piece);
        QPropertyAnimation* pieceAnimation(GraphicsPiece* piece,
                           const QPointF& endPoint) const;
        void stopAnimation();
        void tryMove(GraphicsPiece* piece, const QPointF& targetPos);
        void selectPiece(const QList<Chess::Piece>& types,
                 const char* member);
        void addMoveArrow(const QPointF& sourcePos,
                  const QPointF& targetPos);
        void applyTransition(const Chess::BoardTransition& transition,
                     MoveDirection direction);
        void updateMoves();

        Chess::Board* m_board;
        MoveDirection m_direction;
        Chess::BoardTransition m_transition;
        QList<Chess::BoardTransition> m_history;
        QPointF m_sourcePos;
        GraphicsBoard* m_squares;
        GraphicsPieceReserve* m_reserve;
        QPointer<PieceChooser> m_chooser;
        QPointer<QAbstractAnimation> m_anim;
        QSvgRenderer* m_renderer;
        QMultiMap<GraphicsPiece*, Chess::Square> m_targets;
        QList<Chess::GenericMove> m_moves;
        Chess::GenericMove m_promotionMove;
        GraphicsPiece* m_highlightPiece;
        QGraphicsItemGroup* m_moveArrows;
};

#endif // BOARDSCENE_H