doxygen/html/HighScore_8h_source.html

#ifndef HIGH_SCORE_H

#define HIGH_SCORE_H


#include "Etterna/Models/Misc/DateTime.h"

#include "Etterna/Models/Misc/GameConstantsAndTypes.h"

#include "Etterna/Models/Misc/Grade.h"

#include "Etterna/Models/HighScore/Replay.h"


class XNode;

struct RadarValues;

struct lua_State;


struct HighScoreImpl;


struct HighScore

{

    HighScore();


    [[nodiscard]] auto GetName() const -> const std::string&;

    [[nodiscard]] auto DebugString() const -> std::string;

    [[nodiscard]] auto GetChartKey() const -> const std::string&;

    [[nodiscard]] auto GetSSRCalcVersion() const -> int;

    [[nodiscard]] auto GetGrade() const -> Grade;

    [[nodiscard]] auto GetScore() const -> unsigned int;

    [[nodiscard]] auto IsEmpty() const -> bool;

    [[nodiscard]] auto IsEmptyNormalized() const -> bool;

    [[nodiscard]] auto GetWifeGrade() const -> Grade;

    auto ConvertDpToWife() -> float;

    [[nodiscard]] auto GetPercentDP() const -> float;

    [[nodiscard]] auto GetWifeScore() const -> float;

    [[nodiscard]] auto GetWifePoints() const -> float;

    [[nodiscard]] auto GetSSRNormPercent() const -> float;

    [[nodiscard]] auto GetMusicRate() const -> float;

    [[nodiscard]] auto GetSongOffset() const -> float;

    [[nodiscard]] auto GetJudgeScale() const -> float;

    [[nodiscard]] auto GetChordCohesion() const -> bool;

    [[nodiscard]] auto GetEtternaValid() const -> bool;

    [[nodiscard]] auto GetDSFlag() const -> bool;

    [[nodiscard]] auto GetStageSeed() const -> int;

    [[nodiscard]] auto IsUploadedToServer(const std::string& s) const -> bool;

    std::vector<float> timeStamps;

    [[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 GetMissReplayDataVector()

      -> const std::vector<MissReplayResult>&;

    [[nodiscard]] auto GetCopyOfOffsetVector() -> std::vector<float>;

    [[nodiscard]] auto GetCopyOfNoteRowVector() -> std::vector<int>;

    [[nodiscard]] auto GetCopyOfTrackVector() -> std::vector<int>;

    [[nodiscard]] auto GetCopyOfTapNoteTypeVector() -> std::vector<TapNoteType>;

    [[nodiscard]] auto GetCopyOfHoldReplayDataVector()

      -> std::vector<HoldReplayResult>;

    [[nodiscard]] auto GetCopyOfMineReplayDataVector()

      -> std::vector<MineReplayResult>;

    [[nodiscard]] auto GetCopyOfMissReplayDataVector()

      -> std::vector<MissReplayResult>;

    [[nodiscard]] auto GetCopyOfSetOnlineReplayTimestampVector()

      -> std::vector<float>;

    [[nodiscard]] auto GetInputDataVector() -> const std::vector<InputDataEvent>&;

    [[nodiscard]] auto GetScoreKey() const -> const std::string&;

    [[nodiscard]] auto GetTopScore() const -> int;

    [[nodiscard]] auto GetReplayType() -> ReplayType;

    [[nodiscard]] auto HasColumnData() -> bool;

    [[nodiscard]] auto GetPlayedSeconds() const -> float;

    [[nodiscard]] auto GetMaxCombo() const -> unsigned int;

    [[nodiscard]] auto GetModifiers() const -> const std::string&;

    [[nodiscard]] auto GetDateTime() const -> DateTime;

    [[nodiscard]] auto GetPlayerGuid() const -> const std::string&;

    [[nodiscard]] auto GetMachineGuid() const -> const std::string&;

    [[nodiscard]] auto GetCountryCode() const -> const std::string&;

    [[nodiscard]] auto GetProductID() const -> int;

    [[nodiscard]] auto GetTapNoteScore(TapNoteScore tns) const -> int;

    [[nodiscard]] auto GetTNSNormalized(TapNoteScore tns) const -> int;

    [[nodiscard]] auto GetHoldNoteScore(HoldNoteScore hns) const -> int;

    [[nodiscard]] auto GetRadarValues() const -> const RadarValues&;

    [[nodiscard]] auto GetLifeRemainingSeconds() const -> float;

    [[nodiscard]] auto GetDisqualified() const -> bool;


    void SetName(const std::string& sName);

    void SetChartKey(const std::string& ck);

    void SetSSRCalcVersion(int cv);

    void SetGrade(Grade g);

    void SetScore(unsigned int iScore);

    void SetPercentDP(float f);

    void SetWifeScore(float f);

    void SetWifePoints(float f);

    void SetSSRNormPercent(float f);

    void SetMusicRate(float f);

    void SetSongOffset(float f);

    void SetPlayedSeconds(float f);

    void SetJudgeScale(float f);

    void SetChordCohesion(bool b);

    void SetEtternaValid(bool b);

    void SetDSFlag(bool b);

    void SetStageSeed(int i);

    void AddUploadedServer(const std::string& s);

    void SetInputDataVector(const std::vector<InputDataEvent>& v);

    void SetMissDataVector(const std::vector<MissReplayResult>& v);

    void SetOffsetVector(const std::vector<float>& v);

    void SetNoteRowVector(const std::vector<int>& v);

    void SetTrackVector(const std::vector<int>& v);

    void SetTapNoteTypeVector(const std::vector<TapNoteType>& v);

    void SetHoldReplayDataVector(const std::vector<HoldReplayResult>& v);

    void SetMineReplayDataVector(const std::vector<MineReplayResult>& v);

    void SetOnlineReplayTimestampVector(const std::vector<float>& v);

    void SetScoreKey(const std::string& sk);

    void SetRescoreJudgeVector(const std::vector<int>& v);

    void SetMaxCombo(unsigned int i);

    void SetModifiers(const std::string& s);

    void SetDateTime(DateTime d);

    void SetPlayerGuid(const std::string& s);

    void SetMachineGuid(const std::string& s);

    void SetProductID(int i);

    void SetTapNoteScore(TapNoteScore tns, int i);

    void SetHoldNoteScore(HoldNoteScore hns, int i);

    void SetRadarValues(const RadarValues& rv);

    void SetLifeRemainingSeconds(float f);

    void SetDisqualified(bool b);


    auto GetNameMutable() -> std::string*;


    [[nodiscard]] auto GetNameMutable() const -> const std::string*

    {

        return const_cast<std::string*>(

          const_cast<HighScore*>(this)->GetNameMutable());

    }


    auto operator<(HighScore const& other) const -> bool;

    auto operator>(HighScore const& other) const -> bool;

    auto operator<=(HighScore const& other) const -> bool;

    auto operator>=(HighScore const& other) const -> bool;

    auto operator==(HighScore const& other) const -> bool;

    auto operator!=(HighScore const& other) const -> bool;

    auto operator=(const HighScore &) -> HighScore&;


    [[nodiscard]] auto CreateEttNode() const -> XNode*;

    void LoadFromEttNode(const XNode* pNode);


    auto WriteReplayData() -> bool;

    auto WriteInputData() -> bool;

    auto LoadReplayData() -> bool;

    auto LoadReplayDataBasic(const std::string& dir) -> bool;

    auto LoadReplayDataFull(const std::string& dir) -> bool;

    virtual auto HasReplayData() -> bool;

    void InitReplay();

    void UnloadReplayData();

    void ResetSkillsets();

    auto GetReplay() -> Replay*;


    [[nodiscard]] auto GetDisplayName() const -> const std::string&;


    // Mina stuff - Mina

    auto RescoreToWife2Judge(int x) -> float;

    auto RescoreToWife2TimeScale(float ts) -> float;

    // update wifescore (judge the score was achieved on) and ssrnorm

    auto RescoreToWife3(float pmax) -> bool;

    auto RescoreToDPJudge(int x) -> float;

    [[nodiscard]] auto GetSkillsetSSR(Skillset ss) const -> float;

    [[nodiscard]] auto GetWifeVersion() const -> int;

    void SetSkillsetSSR(Skillset ss, float ssr);

    void SetValidationKey(ValidationKey vk, std::string k);

    void SetTopScore(int i);

    void GenerateValidationKeys();

    auto GenerateBrittleValidationKey() const -> std::string;

    auto ValidateBrittleValidationKey() const -> bool;

    [[nodiscard]] auto GetValidationKey(ValidationKey vk) const

      -> const std::string&;

    void SetWifeVersion(int i);

    auto GetRescoreJudgeVector(int x) -> std::vector<int>;

    auto NormalizeJudgments() -> bool;

    // laazy

    std::string scoreid;

    int userid = -1;

    std::string avatar;

    std::string countryCode;

    bool forceuploadedthissession = false;

    int norms = 0;

    int musics = 0;

    int judges = 0;

    // Lua

    void PushSelf(lua_State* L);

    void PushReplay(lua_State* L)

    {

        CheckReplayIsInit();

        replay->PushSelf(L);

    }

    Replay* replay = nullptr;


  private:

    struct HSImplUniquePtr {

        std::unique_ptr<HighScoreImpl> p;


        HSImplUniquePtr();

        ~HSImplUniquePtr();

        HSImplUniquePtr(const HSImplUniquePtr& rhs);

        HSImplUniquePtr(std::unique_ptr<HighScoreImpl> ptr);

        auto operator=(const HSImplUniquePtr& rhs) -> HSImplUniquePtr&;


        HighScoreImpl *operator->() { return &*p; }

        HighScoreImpl &operator*() { return *p; }

        HighScoreImpl const *operator->() const { return &*p; }

        HighScoreImpl const &operator*() const { return *p; }

    };

    HSImplUniquePtr m_Impl;

    void CheckReplayIsInit();

};


struct Screenshot

{

    std::string sFileName;

    std::string sMD5;

    HighScore highScore;


    [[nodiscard]] auto CreateNode() const -> XNode*;

    void LoadFromNode(const XNode* pNode);

    auto operator<(Screenshot const& rhs) const -> bool

    {

        return highScore.GetDateTime() < rhs.highScore.GetDateTime();

    }


    auto operator==(Screenshot const& rhs) const -> bool

    {

        return sFileName == rhs.sFileName;

    }

};


#endif

Replay
Definition Replay.h:15

Replay::PushSelf
void PushSelf(lua_State *L)
Lua.

XNode
Definition XmlFile.h:95

DateTime
A standard way of determining the date and the time.
Definition DateTime.h:81

HighScoreImpl
Definition HighScore.cpp:28

HighScore
The high score that is earned by a player.
Definition HighScore.h:18

HighScore::GetName
auto GetName() const -> const std::string &
Retrieve the name of the player that set the high score.
Definition HighScore.cpp:488

HighScore::GetScore
auto GetScore() const -> unsigned int
Retrieve the score earned.
Definition HighScore.cpp:508

HighScore::GetModifiers
auto GetModifiers() const -> const std::string &
Get the modifiers used for this run.
Definition HighScore.cpp:690

HighScore::GetGrade
auto GetGrade() const -> Grade
Retrieve the grade earned from this score.
Definition HighScore.cpp:503

HighScore::IsEmpty
auto IsEmpty() const -> bool
Determine if any judgments were tallied during this run.
Definition HighScore.cpp:459

HighScore::SetName
void SetName(const std::string &sName)
Set the name of the Player that earned the score.
Definition HighScore.cpp:779

HighScore::GetDisqualified
auto GetDisqualified() const -> bool
Determine if this score was from a situation that would cause disqualification.
Definition HighScore.cpp:755

RadarValues
Cached song statistics.
Definition RadarValues.h:14

Screenshot
the picture taken of the high score.
Definition HighScore.h:241

Screenshot::sMD5
std::string sMD5
The MD5 hash of the screen shot file above.
Definition HighScore.h:245

Screenshot::highScore
HighScore highScore
The actual high score in question.
Definition HighScore.h:247

Screenshot::sFileName
std::string sFileName
the filename of the screen shot. There is no directory part.
Definition HighScore.h:243