Levels.hpp

#pragma once
 
#include "../../CP_SDK/Utils/Delegate.hpp"
#include "../../CP_SDK/Utils/Il2cpp.hpp"
#include "../../CP_SDK/Utils/MonoPtr.hpp"
 
#include <map>
 
#include <custom-types/shared/coroutine.hpp>
 
#include <GlobalNamespace/AdditionalContentModel.hpp>
#include <GlobalNamespace/BeatmapCharacteristicCollectionSO.hpp>
#include <GlobalNamespace/BeatmapCharacteristicSO.hpp>
#include <GlobalNamespace/BeatmapDifficulty.hpp>
#include <GlobalNamespace/BeatmapLevelsModel.hpp>
#include <GlobalNamespace/ColorScheme.hpp>
#include <GlobalNamespace/IBeatmapLevel.hpp>
#include <GlobalNamespace/IPreviewBeatmapLevel.hpp>
#include <GlobalNamespace/LevelCompletionResults.hpp>
#include <GlobalNamespace/MenuTransitionsHelper.hpp>
#include <GlobalNamespace/StandardLevelScenesTransitionSetupDataSO.hpp>
#include <System/Threading/CancellationTokenSource.hpp>
#include <UnityEngine/Sprite.hpp>
 
namespace CP_SDK_BS::Game {
 
    namespace _u
    {
        using namespace GlobalNamespace;
        using namespace System::Threading;
        using namespace UnityEngine;
    }
    namespace _v
    {
        using namespace CP_SDK::Utils;
    }
 
    class Levels
    {
        CP_SDK_NO_DEF_CTORS(Levels);
 
        private:
            static _v::MonoPtr<_u::Sprite>                              m_DefaultPackCover;
 
            static _v::MonoPtr<_u::AdditionalContentModel>              m_AdditionalContentModel;
            static _v::MonoPtr<_u::BeatmapCharacteristicCollectionSO>   m_BeatmapCharacteristicCollectionSO;
            static _v::MonoPtr<_u::BeatmapLevelsModel>                  m_BeatmapLevelsModel;
            static _v::MonoPtr<_u::CancellationTokenSource>             m_GetLevelCancellationTokenSource;
            static _v::MonoPtr<_u::CancellationTokenSource>             m_GetLevelEntitlementStatusTokenSource;
            static _v::MonoPtr<_u::MenuTransitionsHelper>               m_MenuTransitionsHelper;
 
            static std::vector<_v::Action<>>                            m_ReloadSongsCallbacks;
            static std::mutex                                           m_ReloadSongsCallbacksMutex;
 
        public:
            static _u::Sprite* GetDefaultPackCover();
 
        public:
            static void ReloadSongs(bool p_Full, _v::CActionRef<> p_Callback = nullptr);
            static bool HasMappingCapability(std::u16string_view p_Capability);
 
        public:
            static bool TryGetBeatmapCharacteristicSOBySerializedName(std::u16string_view p_SerializedName, _u::BeatmapCharacteristicSO** p_BeatmapCharacteristicSO);
            static std::u16string_view SanitizeBeatmapCharacteristicSOSerializedName(std::u16string_view p_SerializedName);
            static int GetBeatmapCharacteristicSOOrdering(std::u16string_view p_SerializedName);
 
        public:
            static bool LevelID_IsCustom(std::u16string_view p_LevelID);
            static bool TryGetHashFromLevelID(std::u16string_view p_LevelID, std::u16string* p_Hash);
            static std::u16string SanitizeLevelID(std::u16string_view p_LevelID);
 
        public:
            static std::u16string_view BeatmapDifficultyToBeatmapDifficultyEnumName(_u::BeatmapDifficulty p_BeatmapDifficulty);
            static std::u16string_view BeatmapDifficultySerializedNameToDifficultyName(std::u16string_view p_BeatmapDifficultySerializedName);
            static std::u16string_view BeatmapDifficultySerializedNameToDifficultyNameShort(std::u16string_view p_BeatmapDifficultySerializedName);
            static _u::BeatmapDifficulty BeatmapDifficultySerializedNameToBeatmapDifficulty(std::u16string_view p_BeatmapDifficultySerializedName);
 
        public:
            static void PreviewDifficultyBeatmapSets_ForEach(_u::IPreviewBeatmapLevel* p_PreviewBeatmapLevel, _v::CFuncRef<bool, _u::PreviewDifficultyBeatmapSet*> p_Functor);
            static bool TryGetPreviewDifficultyBeatmapSet(_u::IPreviewBeatmapLevel* p_PreviewBeatmapLevel, _u::BeatmapCharacteristicSO* p_BeatmapCharacteristicSO, _u::PreviewDifficultyBeatmapSet** p_PreviewDifficultyBeatmapSet);
            static bool PreviewDifficultyBeatmapSet_HasDifficulty(_u::PreviewDifficultyBeatmapSet* p_PreviewDifficultyBeatmapSet, _u::BeatmapDifficulty p_Difficulty);
 
        public:
            static void OwnDLCLevelByLevelID(std::u16string_view p_LevelID, _v::Action<bool> p_Callback);
            static bool TryGetPreviewBeatmapLevelForLevelID(std::u16string_view p_LevelID, _u::IPreviewBeatmapLevel** p_PreviewBeatmapLevel);
            static bool TryGetCustomRequirementsFor(_u::IPreviewBeatmapLevel*       p_PreviewBeatmapLevel,
                                                    _u::BeatmapCharacteristicSO*    p_BeatmapCharacteristicSO,
                                                    _u::BeatmapDifficulty           p_BeatmapDifficulty,
                                                    std::vector<std::u16string>*    p_CustomRequirements);
            static void LoadBeatmapLevelByLevelID(  std::u16string_view p_LevelID,
                                                    _v::Action<_v::MonoPtr<_u::IBeatmapLevel, true>> p_LoadCallback);
            static void TryLoadPreviewBeatmapLevelCoverAsync(_u::IPreviewBeatmapLevel* p_PreviewBeatmapLevel, _v::Action<bool, _u::Sprite*> p_Callback);
            static void StartBeatmapLevel(  _u::IBeatmapLevel*                  p_Level,
                                            _u::BeatmapCharacteristicSO*        p_Characteristic,
                                            _u::BeatmapDifficulty               p_Difficulty,
                                            _u::OverrideEnvironmentSettings*    p_OverrideEnvironmentSettings   = nullptr,
                                            _u::ColorScheme*                    p_ColorScheme                   = nullptr,
                                            _u::GameplayModifiers*              p_GameplayModifiers             = nullptr,
                                            _u::PlayerSpecificSettings*         p_PlayerSettings                = nullptr,
                                            _v::Action<_u::StandardLevelScenesTransitionSetupDataSO*, _u::LevelCompletionResults*, _u::IDifficultyBeatmap*> p_SongFinishedCallback = nullptr,
                                            std::u16string_view                 p_MenuButtonText                = u"Menu");
 
        private:
            static void GetBeatmapLevelFromLevelID( std::u16string_view                                                 p_LevelID,
                                                    _v::Action<_v::MonoPtr<_u::IBeatmapLevel, true>>  p_Callback);
 
        public:
            static float GetAccuracy(int p_MaxScore, int p_Score);
 
        public:
            using t_CharacteristicScores = std::vector<std::pair<_u::BeatmapDifficulty, int>>;
            using t_Scores               = std::map<_v::MonoPtr<_u::BeatmapCharacteristicSO>, t_CharacteristicScores>;
 
            static t_Scores GetScoresByLevelID(std::u16string_view p_SongHash, bool* p_HaveAnyScore, bool* p_HaveAllScores);
 
    };
 
}