InteractionManager.h

// Wykonane przez Piotra Chudzińskiego w dniu 14.04.2025
#pragma once
 
#include <andromenda/ActionRegistry.h>
#include <foundation/Collections.h>
#include <foundation/Common.h>
#include <game/Card/CardHelper.h>
#include <game/Card/Deck.h>
#include <phosphorus/GameBootstrapper.h>
#include <phosphorus/GameSerializer.h>
#include "GameRulesEngine.h"
 
namespace Game
{
    class Card;

    enum class InteractionType : uint8
    {
        StockTakeNextCard = 0,
        BulkCard = 1,
        Card = 2
    };

    struct IInteraction
    {
        virtual ~IInteraction() = default;

        InteractionType Type;

        virtual void Do() {}

        virtual void Undo() {}

        virtual void Serialize(nlohmann::json &obj) {}
    };
 
    struct StockNextCardInteraction;
    struct CardInteraction;
    struct BulkCardInteraction;

    class InteractionManager
    {
    private:
        friend class ReplaySystem;

        inline static std::vector<IInteraction *> m_Motions;

        inline static int32 m_AllowedReverts = 0;

        static bool canRevert();
 
    public:
        inline static Deck *Deck = nullptr;

        inline static std::function<void()> ReloadCallback;
 
        ~InteractionManager();

        static int32 GetMotionCount();

        static void SetAllowedReverts(int32 allowedReverts);

        static int32 GetAvailableReverts();

        static void Clear();

        template<typename T, class... Args>
        static T *Push(InteractionType type, Args &&...args)
        {
            static_assert(std::is_base_of_v<IInteraction, T>, "T must be derived from IInteraction");
 
            IInteraction *im = new T(std::forward<Args>(args)...);
            im->Type = type;
            im->Do();
            m_Motions.push_back(im);
            ReloadCallback();
 
            GameRulesEngine::CheckForWin();
 
            return static_cast<T *>(im);
        }

        static void TakeStockNextCard();

        static void MoveCard(Card *card, CardStack *targetStack, bool authorizedMove = false);

        static void MoveCards(const std::vector<Card *> &cards, CardStack *targetStack);

        static void SaveMovement(std::ostream &stream);

        static void LoadMovement(std::istream &stream);

        static bool ProvideActions(Andromenda::ActionRegistry &registry);

        static void PlayIllegalSound();
 
        static void Undo();
    };

    struct BulkCardInteraction : IInteraction
    {
    private:
        BulkCardInteraction() = default;
 
    public:
        inline static std::vector<Card *> GrabbedCards;

        std::vector<Card *> Cards;

        CardStack *Stack;

        CardStack *PreviousStack;

        int32 PreviousIndex;

        int32 FlippedCardIndex = -1;
 
        BulkCardInteraction(const std::vector<Card *> &cards, CardStack *stack);

        void Do() override;

        void Undo() override;

        void Serialize(nlohmann::json &obj) override;

        static BulkCardInteraction *Load(nlohmann::json &obj);
    };

    struct CardInteraction : IInteraction
    {
    private:
        CardInteraction() = default;
 
    public:
        inline static Card *Grabbed = nullptr;

        Card *Card;

        CardStack *Stack;

        CardStack *PreviousStack;

        int32 PreviousIndex;

        int32 FlippedCardIndex = -1;
 
        CardInteraction(::Game::Card *card, CardStack *stack);

        void Do() override;

        void Undo() override;

        void Serialize(nlohmann::json &obj) override;

        static CardInteraction *Load(nlohmann::json &obj);
    };

    struct StockNextCardInteraction : IInteraction
    {
        inline static int32 StackIndex = 0;

        int32 Index;

        int32 NewIndex;
 
        StockNextCardInteraction();

        void Do() override;

        void Undo() override;

        static Card *GetCard() { return InteractionManager::Deck->Stock->Get(StackIndex); }

        static int32 GetStockSize();

        void Serialize(nlohmann::json &obj) override;

        static StockNextCardInteraction *Load(nlohmann::json &obj);
    };
} // namespace Game