PlayerStageStats.h

#ifndef PlayerStageStats_H
#define PlayerStageStats_H
 
#include "Grade.h"
#include "Etterna/Models/HighScore/HighScore.h"
#include "Etterna/Models/NoteData/NoteDataStructures.h"
#include "PlayerNumber.h"
#include "RadarValues.h"
#include "NoteTypes.h"
#include <map>
 
class Steps;
class Style;
struct lua_State;
 
class PlayerStageStats
{
  public:
    PlayerStageStats() { InternalInit(); }
    void InternalInit();
    void Init(PlayerNumber pn);
    void Init(MultiPlayer pn);
 
    std::vector<NoteInfo> serializednd;
 
    void AddStats(const PlayerStageStats& other); // accumulate
 
    static auto GetGrade(float p) -> Grade;
    [[nodiscard]] auto GetGrade() const -> Grade;
    static auto MakePercentScore(int iActual, int iPossible) -> float;
    static auto FormatPercentScore(float fPercentScore) -> std::string;
    // Calculate the difficulty rating for a specific score obtained by a player
    // - Mina
    auto GetWifeGrade() -> Grade;
    [[nodiscard]] auto CalcSSR(float ssrpercent) const -> std::vector<float>;
    void GenerateValidationKeys(HighScore& hs) const;
    [[nodiscard]] auto GetPercentDancePoints() const -> float;
    [[nodiscard]] auto GetWifeScore() const -> float;
    [[nodiscard]] auto GetCurWifeScore() const -> float;
    [[nodiscard]] auto GetMaxWifeScore() const -> float;
    [[nodiscard]] auto GetTimingScale() const -> float;
    [[nodiscard]] auto GetInputDataVector() const -> std::vector<InputDataEvent>;
    [[nodiscard]] auto GetMissDataVector() const
      -> std::vector<MissReplayResult>;
    [[nodiscard]] auto GetOffsetVector() const -> std::vector<float>;
    [[nodiscard]] auto GetNoteRowVector() const -> std::vector<int>;
    [[nodiscard]] auto GetTrackVector() const -> std::vector<int>;
    [[nodiscard]] auto GetTapNoteTypeVector() const -> std::vector<TapNoteType>;
    [[nodiscard]] auto GetHoldReplayDataVector() const
      -> std::vector<HoldReplayResult>;
    [[nodiscard]] auto GetMineReplayDataVector() const
      -> std::vector<MineReplayResult>;
    [[nodiscard]] auto GetCurMaxPercentDancePoints() const -> float;
 
    [[nodiscard]] auto GetLessonScoreActual() const -> int;
    [[nodiscard]] auto GetLessonScoreNeeded() const -> int;
    void ResetScoreForLesson();
 
    bool m_for_multiplayer{};
    PlayerNumber m_player_number;
    MultiPlayer m_multiplayer_number;
    const Style* m_pStyle{};
 
    bool m_bJoined{};
    bool m_bPlayerCanAchieveFullCombo{};
    std::vector<Steps*> m_vpPossibleSteps;
    int m_iStepsPlayed{}; // how many of m_vpPossibleStepshow many of
                          // m_vpPossibleSteps were played
 
    bool m_bFailed{};
 
    int m_iPossibleDancePoints{};
    int m_iCurPossibleDancePoints{};
    int m_iActualDancePoints{};
    int m_iPossibleGradePoints{};
    float m_fWifeScore{};
    float CurWifeScore{};
    float MaxWifeScore{};
    float m_fTimingScale{};
    std::vector<MineReplayResult> m_vMineReplayData;
    std::vector<HoldReplayResult> m_vHoldReplayData;
    std::vector<float> m_vOffsetVector;
    std::vector<int> m_vNoteRowVector;
    std::vector<TapNoteType> m_vTapNoteTypeVector;
    std::vector<int> m_vTrackVector;
    std::vector<InputDataEvent> InputData;
    std::vector<MissReplayResult> m_vNoteMissVector;
    int m_iTapNoteScores[NUM_TapNoteScore]{};
    int m_iHoldNoteScores[NUM_HoldNoteScore]{};
    unsigned int m_iCurCombo{};
    unsigned int m_iMaxCombo{};
    unsigned int m_iCurMissCombo{};
    int m_iCurScoreMultiplier{};
    unsigned int m_iScore{};
    unsigned int m_iCurMaxScore{};
    unsigned int m_iMaxScore{};
 
    RadarValues m_radarPossible;
    RadarValues m_radarActual;
    int m_iSongsPassed{};
    int m_iSongsPlayed{};
    float m_fLifeRemainingSeconds{};
 
    // workout
    float m_iNumControllerSteps{};
 
    bool everusedautoplay{};
    bool filegotmines{}; // this needs to be set before any notedata transforms
    bool filegotholds{};
    bool gaveuplikeadumbass{}; // flag 'giving up' status so i can flag it as
                               // failing so i dont have to remove the feature
                               // entirely -mina
    bool usedDoubleSetup{};
 
    std::map<float, float> m_fLifeRecord;
    void SetLifeRecordAt(float fLife, float fStepsSecond);
    void GetLifeRecord(float* fLifeOut,
                       int iNumSamples,
                       float fStepsEndSecond) const;
    [[nodiscard]] auto GetLifeRecordAt(float fStepsSecond) const -> float;
    [[nodiscard]] auto GetLifeRecordLerpAt(float fStepsSecond) const -> float;
    [[nodiscard]] auto GetCurrentLife() const -> float;
 
    std::map<float, float> WifeRecord;
    void SetWifeRecordAt(float Wife, float fStepsSecond);
    void GetWifeRecord(float* WifeOut,
                       int iNumSamples,
                       float fStepsEndSecond) const;
    [[nodiscard]] auto GetWifeRecordAt(float fStepsSecond) const -> float;
    [[nodiscard]] auto GetWifeRecordLerpAt(float fStepsSecond) const -> float;
 
    struct Combo_t
    {
        // Update GetComboList in PlayerStageStats.cpp when adding new members
        // that should be visible from the Lua side.
        float m_fStartSecond{ 0 };
        float m_fSizeSeconds{ 0 };
 
        int m_cnt{ 0 };
 
        int m_rollover{ 0 };
 
        [[nodiscard]] auto GetStageCnt() const -> int
        {
            return m_cnt - m_rollover;
        }
 
        Combo_t() = default;
        [[nodiscard]] auto IsZero() const -> bool { return m_fStartSecond < 0; }
    };
    std::vector<Combo_t> m_ComboList;
    float m_fFirstSecond{};
    float m_fLastSecond{};
 
    [[nodiscard]] auto GetComboAtStartOfStage() const -> int;
    [[nodiscard]] auto FullComboOfScore(TapNoteScore tnsAllGreaterOrEqual) const
      -> bool;
    [[nodiscard]] auto FullCombo() const -> bool
    {
        return FullComboOfScore(TNS_W3);
    }
    [[nodiscard]] auto GetBestFullComboTapNoteScore() const -> TapNoteScore;
    [[nodiscard]] auto SingleDigitsOfScore(
      TapNoteScore tnsAllGreaterOrEqual) const -> bool;
    [[nodiscard]] auto OneOfScore(TapNoteScore tnsAllGreaterOrEqual) const
      -> bool;
    [[nodiscard]] auto GetTotalTaps() const -> int;
    [[nodiscard]] auto GetPercentageOfTaps(TapNoteScore tns) const -> float;
    void UpdateComboList(float fSecond, bool rollover);
    [[nodiscard]] auto GetMaxCombo() const -> Combo_t;
 
    int m_iPersonalHighScoreIndex{};
    int m_iMachineHighScoreIndex{};
    bool m_bDisqualified{};
    [[nodiscard]] auto IsDisqualified() const -> bool;
 
    void UnloadReplayData(); // i don't really trust the deconstructors here,
                             // also prefer flexibility in this -mina
    HighScore m_HighScore;
    float m_fPlayedSeconds{};
 
    // Lua
    void PushSelf(lua_State* L);
};
 
#endif