Solitaire.h

// Wykonane przez Piotra Chudzińskiego w dniu 10.04.2025
#pragma once
#include <kalium/AudioSystem.h>
#include <phosphorus/GameBootstrapper.h>
#include <phosphorus/IGame.h>
#include "Screens/Screen.h"
 
namespace Game
{
    enum class GameState : uint8
    {
        Uninitialized,
        Playing,
        Replaying
    };

    enum class Difficulty : uint8
    {
        Easy,
        Medium,
        Hard
    };

    enum class ScoringMode : uint32
    {
        Microsoft = 0,
        ClassicEasy,
        VegasStyle,
        SpeedRun,
        Hardcore,
        Alternative
    };
 
    enum class GenerateMode : uint8
    {
        Predefined = 0,
        Solve = 1
    };

    class SolitaireSessionSettings : public Phosphorus::GameObject
    {
    protected:
        GameObject *clone() override { return new SolitaireSessionSettings(); }
 
    public:
        Phosphorus::EnumParameter<ScoringMode> ScoringMode;

        Phosphorus::EnumParameter<Difficulty> Difficulty;
 
        Phosphorus::EnumParameter<GenerateMode> GenerateMode;
 
        SolitaireSessionSettings() :
            ScoringMode("Punktacja", ScoringMode::Microsoft), Difficulty("Poziom", Difficulty::Easy),
            GenerateMode("GenerateMode", GenerateMode::Predefined)
        {
            addParameter(&ScoringMode);
            ScoringMode.SetDisplayName("session.scoring");
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, Microsoft);
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, ClassicEasy);
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, VegasStyle);
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, SpeedRun);
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, Hardcore);
            DEFINE_ENUM_VALUE(ScoringMode, ScoringMode, Alternative);
 
            addParameter(&Difficulty);
            Difficulty.SetDisplayName("session.difficulty");
            Difficulty.Bind(Difficulty::Easy, L"1");
            Difficulty.Bind(Difficulty::Medium, L"2");
            Difficulty.Bind(Difficulty::Hard, L"3");
 
            addParameter(&GenerateMode);
            GenerateMode.SetDisplayName("session.generate");
            GenerateMode.Bind(GenerateMode::Predefined, _TW("generate.predefined"));
            GenerateMode.Bind(GenerateMode::Solve, _TW("generate.solve"));
        }
 

        String GetIdentifer() const override { return "SessionSettings"; }
    };

    class SolitaireStatistics : public Phosphorus::GameObject
    {
    protected:
        GameObject *clone() override { return new SolitaireStatistics(); }
 
    public:
        Phosphorus::IntParameter RevertedInteractions;

        Phosphorus::IntParameter StockViewedCards;

        Phosphorus::Int64Parameter TimePlayed;

        Phosphorus::IntParameter Score;
 
        SolitaireStatistics() :
            RevertedInteractions("RevertedInteractions", 0), StockViewedCards("StockViewedCards", 0),
            TimePlayed("TimePlayed", 0), Score("Score", 0)
        {
            addParameter(&RevertedInteractions);
            addParameter(&TimePlayed);
            addParameter(&Score);
            addParameter(&StockViewedCards);
        }

        String GetIdentifer() const override { return "Statistics"; }
    };
 
    enum Language
    {
        Polish,
        English
    };

    class SolitaireSettings : public Phosphorus::GameObject
    {
    private:
        GameObject *clone() override { return new SolitaireSettings(); }
 
    public:
        Phosphorus::BoolParameter Audio;

        Phosphorus::EnumParameter<Language> Language;
 
        SolitaireSettings() : Audio("Audio", true), Language("Language", Language::English)
        {
            addParameter(&Audio);
            addParameter(&Language);
 
            Language.SetDisplayName("generic.language");
            Language.Bind(Language::Polish, L"Polski");
            Language.Bind(Language::English, L"English");
        }

        String GetIdentifer() const override { return "SolitaireSettings"; }
    };

    class Solitaire : public Phosphorus::IGame, public Andromenda::IActionProvider
    {
    private:
        std::stack<IScreen *> m_ScreenStack;

        void updateScreenState();

        Kalium::AudioSystem m_AudioSystem;

        IScreen *m_PrevPeekScreen;
 
    public:
        GameState GameState = GameState::Uninitialized;

        SolitaireStatistics *Statistics = nullptr;

        SolitaireSessionSettings *SessionSettings = nullptr;

        inline static SolitaireSettings *GetSettings()
        {
            return dynamic_cast<SolitaireSettings *>(Phosphorus::GameInstance->GameSettings);
        }

        Phosphorus::ProductInfo GetProductInfo() override;
 
        Solitaire(Phosphorus::GameOptions &options) :
            IGame(options, nullptr), m_AudioSystem(m_VfsManager), m_PrevPeekScreen(nullptr)
        {
            m_Surface = new Andromenda::Surface(std::bind(&Solitaire::OnSurfaceCallback, this, std::placeholders::_1),
                                                std::bind(&Solitaire::OnRender, this));
        };
 
        ~Solitaire();

        void Run() override;

        void OnSurfaceCallback(const String &id) override;

        void OnRender() override;

        void PushScreen(IScreen *screen);

        void PopScreen(int32 count = 1);

        void PlayOneShot(const String &path);

        void SetTitle(const WideString &title);

        void OnWin();

        void OnLoadFromFile();

        void OnNewGame();

        Phosphorus::VfsManager &GetVfsManager();

        void ProvideActions(Andromenda::ActionRegistry &registry) override;
    };
} // namespace Game