ReplayManager.h

#pragma once
#ifndef REPLAYMAN_H
#define REPLAYMAN_H
 
#include "Etterna/Models/Lua/LuaBinding.h"
#include "Etterna/Models/HighScore/Replay.h"
#include "Etterna/Models/Misc/PlayerStageStats.h"
 
#include <unordered_map>
 
struct TemporaryReplaySettings
{
    bool replayUsedMirror = false;
    float replayRate = 1.F;
    std::string replayModifiers{};
    std::string oldModifiers{};
    float oldRate = 1.F;
    std::string oldNoteskin{};
    FailType oldFailType = FailType_Immediate;
    int replayRngSeed = 0;
    int oldRngSeed = 0;
 
    void reset()
    {
        replayRate = 1.F;
        replayModifiers = std::string();
        replayUsedMirror = false;
        replayRngSeed = 0;
        oldModifiers = std::string();
        oldRate = 1.F;
        oldNoteskin = std::string();
        oldFailType = FailType_Immediate;
        oldRngSeed = 0;
    }
};
 
struct HighScore;
class ReplayManager
{
  public:
    ReplayManager();
    ~ReplayManager();
 
    Replay* GetReplay(const HighScore* hs);
    void ReleaseReplay(Replay* replay);
    Replay* GetSpectateReplay(const std::string& playerID);
 
    Replay* InitReplayPlaybackForScore(HighScore* hs,
                                       float timingScale = 1.F,
                                       int startRow = 0);
 
    Replay* InitReplayPlaybackForSpectate(std::string playerID,
                                          std::string chartKey,
                                          float musicRate,
                                          float songOffset,
                                          float globalOffset,
                                          int rngSeed,
                                          std::string mods);
 
    void UnsetActiveReplay();
 
    Replay* GetActiveReplay();
 
    HighScore* GetActiveReplayScore();
 
    void StoreActiveReplaySettings(float replayRate,
                                   std::string& replayModifiers,
                                   bool replayUsedMirror,
                                   int replayRngSeed);
 
    void StoreOldSettings(float oldRate,
                          std::string& oldModifiers,
                          FailType oldFailType,
                          std::string& oldNoteskin,
                          int oldRngSeed);
 
    TemporaryReplaySettings GetActiveReplaySettings();
    void ResetActiveReplaySettings();
 
    static TapNoteScore GetTapNoteScoreForReplay(float fNoteOffset,
                                                 float timingScale = 1.F);
 
    auto CalculateRadarValuesForReplay(Replay& replay,
                                       RadarValues& rv,
                                       RadarValues& possibleRV) -> bool;
 
    auto RescoreReplay(Replay& replay,
                                      PlayerStageStats* pss,
                                      float timingScale = 1.F) -> bool;
 
    auto GenerateLifeRecordForReplay(Replay& replay, float timingScale = 1.F)
      -> std::map<float, float>;
 
    auto GenerateComboListForReplay(Replay& replay, float timingScale = 1.F)
      -> std::vector<PlayerStageStats::Combo_t>;
 
    void EnableCustomScoringFunctions() {
        customScoringFunctionsEnabled = true;
    }
    void DisableCustomScoringFunctions() {
        customScoringFunctionsEnabled = false;
    }
    bool isCustomScoringFunctionsEnabled() {
        return customScoringFunctionsEnabled;
    }
 
    // custom scoring functions
    // these will default to base game behavior if the custom functions arent set
 
    auto CustomTapScoringFunction(float fOffsetSeconds,
                                  TapNoteScore tns,
                                  float timingScale) -> float;
    auto CustomHoldNoteScoreScoringFunction(HoldNoteScore hns) -> float;
    auto CustomMineScoringFunction() -> float;
    auto CustomTotalWifePointsCalculation(TapNoteType tnt) -> float;
    auto CustomOffsetJudgingFunction(float fOffsetSeconds, float timingScale)
      -> TapNoteScore;
    auto CustomMissWindowFunction() -> float;
 
    void SetTotalWifePointsCalcFunction(const LuaReference& ref) {
        m_totalWifePointsCalcFunc = ref;
    }
    void SetMineScoringFunction(const LuaReference& ref) {
        m_mineScoringFunc = ref;
    }
    void SetHoldNoteScoringFunction(const LuaReference& ref) {
        m_holdNoteScoreScoringFunc = ref;
    }
    void SetTapScoringFunction(const LuaReference& ref) {
        m_tapScoringFunc = ref;
    }
    void SetOffsetJudgingFunction(const LuaReference& ref) {
        m_offsetJudgingFunc = ref;
    }
    void SetMissWindowFunction(const LuaReference& ref) {
        m_missWindowFunc = ref;
    }
    //
 
    void PushSelf(lua_State* L);
 
  private:
    std::unordered_map<std::string, std::pair<unsigned, Replay*>>
      scoresToReplays{};
 
    std::unordered_map<std::string, Replay*> spectatorReplays{};
 
    LuaReference m_totalWifePointsCalcFunc;
    LuaReference m_mineScoringFunc;
    LuaReference m_holdNoteScoreScoringFunc;
    LuaReference m_tapScoringFunc;
    LuaReference m_offsetJudgingFunc;
    LuaReference m_missWindowFunc;
 
    bool customScoringFunctionsEnabled = false;
 
};
 
extern std::shared_ptr<ReplayManager> REPLAYS;
 
#endif