GameConstantsAndTypes.h

/* GameConstantsAndTypes - Things used in many places that don't change often.
 */
 
#ifndef GAME_CONSTANTS_AND_TYPES_H
#define GAME_CONSTANTS_AND_TYPES_H
 
#include "EnumHelper.h"
#include "Etterna/Models/NoteData/NoteDataStructures.h"
#include <cfloat> // need the max for default.
 
// Note definitions
const int MIN_METER = 1;
const int MAX_METER = 35;
 
// some components of the game care about some negative number
// and break if you pass it
// so this defines the point at which behavior is undefined
// usually you only reach this if you have a huge starting bpm
const int ARBITRARY_MIN_GAMEPLAY_NUMBER = -200000;
 
// the hard end of the boo window and start of the miss window
// dont let anyone hit a note outside of this
const float MISS_WINDOW_BEGIN_SEC = 0.18F;
 
// 75ms in both directions, around a j5 great
const float MINE_WINDOW_SEC = 0.075F;
 
// taps within alive holds/rolls must be this far away from 
// the next note so that they do not count.
// this prevents unwanted cbs from roll tapping
const float TAP_IN_HOLD_REQ_SEC = 0.135F;
 
// how long between each subsequent release on a hold a
// repress must take place before the hold dies
const float HOLD_DROP_SEC = 0.250F;
 
// how long between each subsequent tap on a roll before death
const float ROLL_DROP_SEC = 0.500F;
 
const float MIN_MUSIC_RATE = 0.05F;
const float MAX_MUSIC_RATE = 3.F;
 
enum GameplayMode
{
    GameplayMode_Normal,
    GameplayMode_Practice,
    GameplayMode_Replay,
    GameplayMode_Spectate,
    NUM_GameplayMode,
    GameplayMode_Invalid
};
 
auto
SkillsetToString(Skillset ss) -> const std::string&;
 
auto CalcPatternModToString(CalcPatternMod) -> const std::string&;
auto CalcDiffValueToString(CalcDiffValue) -> const std::string&;
auto CalcDebugMiscToString(CalcDebugMisc) -> const std::string&;
 
enum NSScoreBoardColumn
{
    NSSB_NAMES = 0,
    NSSB_COMBO,
    NSSB_GRADE,
    NUM_NSScoreBoardColumn,
    NSScoreBoardColumn_Invalid
};
 
enum ValidationKey
{
    ValidationKey_Brittle,
    ValidationKey_Weak,
    NUM_ValidationKey,
    ValidationKey_Invalid,
};
 
auto
ValidationKeyToString(ValidationKey ss) -> const std::string&;
 
enum RadarCategory
{
    RadarCategory_Notes,        
    RadarCategory_TapsAndHolds, 
    RadarCategory_Jumps,        
    RadarCategory_Holds,        
    RadarCategory_Mines,        
    RadarCategory_Hands,        
    RadarCategory_Rolls,        
    RadarCategory_Lifts,        
    RadarCategory_Fakes,        
    NUM_RadarCategory,          
    RadarCategory_Invalid
};
auto
RadarCategoryToString(RadarCategory cat) -> const std::string&;
auto
RadarCategoryToLocalizedString(RadarCategory cat) -> const std::string&;
LuaDeclareType(RadarCategory);
 
enum StepsTypeCategory
{
    StepsTypeCategory_Single, 
    StepsTypeCategory_Double, 
};
 
enum StepsType
{
    StepsType_dance_single = 0,
    StepsType_dance_double,
    StepsType_dance_solo,
    StepsType_dance_threepanel,
    StepsType_pump_single,
    StepsType_pump_halfdouble,
    StepsType_pump_double,
    StepsType_kb7_single,
    StepsType_ez2_single,
    StepsType_ez2_double,
    StepsType_ez2_real,
    StepsType_ds3ddx_single,
    StepsType_beat_single5,
    StepsType_beat_double5,
    StepsType_beat_single7,
    StepsType_beat_double7,
    StepsType_maniax_single,
    StepsType_maniax_double,
    StepsType_popn_five,
    StepsType_popn_nine,
    NUM_StepsType, // leave this at the end
    StepsType_Invalid,
};
LuaDeclareType(StepsType);
 
enum SortOrder
{
    SORT_GROUP,      
    SORT_TITLE,      
    SORT_BPM,        
    SORT_TOP_GRADES, 
    SORT_ARTIST,     
    SORT_GENRE,      
    SORT_MODE_MENU,  
    SORT_FAVORITES,
    SORT_Overall,
    SORT_Stream,
    SORT_Jumpstream,
    SORT_Handstream,
    SORT_Stamina,
    SORT_JackSpeed,
    SORT_Chordjack,
    SORT_Technical,
    SORT_LENGTH,
    SORT_DATE_ADDED,
    SORT_CHART_AUTHOR,
    SORT_Ungrouped, 
    NUM_SortOrder,
    SortOrder_Invalid
};
 
auto
SortOrderToString(SortOrder so) -> const std::string&;
auto
SortOrderToLocalizedString(SortOrder so) -> const std::string&;
auto
StringToSortOrder(const std::string& str) -> SortOrder;
LuaDeclareType(SortOrder);
inline auto
IsSongSort(SortOrder so) -> bool
{
    return so >= SORT_GROUP && so <= SORT_GENRE;
}
 
enum TapNoteScore
{
    TNS_None,           
    TNS_HitMine,        
    TNS_AvoidMine,      
    TNS_CheckpointMiss, 
    TNS_Miss,           
    TNS_W5,             
    TNS_W4,             
    TNS_W3, 
    TNS_W2, 
    TNS_W1, 
    TNS_CheckpointHit, 
    NUM_TapNoteScore,  
    TapNoteScore_Invalid,
};
auto
TapNoteScoreToString(TapNoteScore tns) -> const std::string&;
auto
TapNoteScoreToLocalizedString(TapNoteScore tns) -> const std::string&;
auto
StringToTapNoteScore(const std::string& str) -> TapNoteScore;
LuaDeclareType(TapNoteScore);
 
enum HoldNoteScore
{
    HNS_None,   
    HNS_LetGo,  
    HNS_Held,   
    HNS_Missed, 
    NUM_HoldNoteScore, 
    HoldNoteScore_Invalid,
};
auto
HoldNoteScoreToString(HoldNoteScore hns) -> const std::string&;
 
auto
HoldNoteScoreToLocalizedString(HoldNoteScore hns) -> const std::string&;
auto
StringToHoldNoteScore(const std::string& str) -> HoldNoteScore;
LuaDeclareType(HoldNoteScore);
 
enum TimingWindow
{
    TW_W1,
    TW_W2,
    TW_W3,
    TW_W4,
    TW_W5,
    TW_Mine,
    TW_Hold,
    TW_Roll,
    TW_Checkpoint,
    NUM_TimingWindow
};
auto
TimingWindowToString(TimingWindow tw) -> const std::string&;
 
enum ScoreEvent
{
    SE_CheckpointHit,
    SE_W1,
    SE_W2,
    SE_W3,
    SE_W4,
    SE_W5,
    SE_Miss,
    SE_HitMine,
    SE_CheckpointMiss,
    SE_Held,
    SE_LetGo,
    SE_Missed,
    NUM_ScoreEvent
};
auto
ScoreEventToString(ScoreEvent se) -> const std::string&;
 
enum GameButtonType
{
    GameButtonType_Step,
    GameButtonType_Menu
};
 
enum TapNoteScoreJudgeType
{
    TapNoteScoreJudgeType_MinimumScore,
    TapNoteScoreJudgeType_LastScore,
    NUM_TapNoteScoreJudgeType,
    TapNoteScoreJudgeType_Invalid,
};
auto
TapNoteScoreJudgeTypeToString(TapNoteScoreJudgeType jt) -> const std::string&;
LuaDeclareType(TapNoteScoreJudgeType);
 
enum ProfileSlot
{
    ProfileSlot_Player1,
    ProfileSlot_Player2,
    NUM_ProfileSlot,
    ProfileSlot_Invalid
};
auto
ProfileSlotToString(ProfileSlot ps) -> const std::string&;
LuaDeclareType(ProfileSlot);
 
extern const std::string RANKING_TO_FILL_IN_MARKER;
inline auto
IsRankingToFillIn(const std::string& sName) -> bool
{
    return !sName.empty() && sName[0] == '#';
}
 
// Group stuff
extern const std::string GROUP_ALL;
 
enum PlayerController
{
    PC_HUMAN,
    PC_AUTOPLAY,
    PC_CPU,
    PC_REPLAY,
    PC_SPECTATE,
    NUM_PlayerController,
    PlayerController_Invalid
};
auto
PlayerControllerToString(PlayerController pc) -> const std::string&;
LuaDeclareType(PlayerController);
 
enum HealthState
{
    HealthState_Hot,    
    HealthState_Alive,  
    HealthState_Danger, 
    HealthState_Dead,   
    NUM_HealthState,
    HealthState_Invalid
};
LuaDeclareType(HealthState);
 
struct DisplayBpms
{
    void Add(float f);
    [[nodiscard]] auto GetMin() const -> float;
    [[nodiscard]] auto GetMax() const -> float;
    [[nodiscard]] auto GetMaxWithin(float highest = FLT_MAX) const -> float;
    [[nodiscard]] auto BpmIsConstant() const -> bool;
    [[nodiscard]] auto IsSecret() const -> bool;
    std::vector<float> vfBpms;
};
 
enum StyleType
{
    StyleType_OnePlayerOneSide,  
    StyleType_OnePlayerTwoSides, 
    NUM_StyleType,
    StyleType_Invalid
};
auto
StyleTypeToString(StyleType s) -> const std::string&;
auto
StringToStyleType(const std::string& s) -> StyleType;
LuaDeclareType(StyleType);
 
enum SampleMusicPreviewMode
{
    SampleMusicPreviewMode_Normal, 
    SampleMusicPreviewMode_StartToPreview,
    SampleMusicPreviewMode_ScreenMusic, 
    SampleMusicPreviewMode_LastSong,    
    SampleMusicPreviewMode_Nothing, // music never plays
    NUM_SampleMusicPreviewMode,
    SampleMusicPreviewMode_Invalid,
};
auto SampleMusicPreviewModeToString(SampleMusicPreviewMode)
  -> const std::string&;
auto
StringToSampleMusicPreviewMode(const std::string& s) -> SampleMusicPreviewMode;
LuaDeclareType(SampleMusicPreviewMode);
 
enum Stage
{
    Stage_1st,    
    Stage_2nd,    
    Stage_3rd,    
    Stage_4th,    
    Stage_5th,    
    Stage_6th,    
    Stage_Next,   
    Stage_Final,  
    Stage_Extra1, 
    Stage_Extra2, 
    Stage_Event,  
    Stage_Demo,   
    NUM_Stage,    
    Stage_Invalid,
};
auto
StageToString(Stage s) -> const std::string&;
LuaDeclareType(Stage);
auto
StageToLocalizedString(Stage i) -> const std::string&;
 
enum ProfileLoadResult
{
    ProfileLoadResult_Success,
    ProfileLoadResult_FailedNoProfile,
    ProfileLoadResult_FailedTampered
};
 
enum MultiPlayerStatus
{
    MultiPlayerStatus_Joined,
    MultiPlayerStatus_NotJoined,
    MultiPlayerStatus_Unplugged,
    MultiPlayerStatus_MissingMultitap,
    NUM_MultiPlayerStatus,
    MultiPlayerStatus_Invalid
};
auto
MultiPlayerStatusToString(MultiPlayerStatus i) -> const std::string&;
 
enum FailType
{
    FailType_Immediate,         
    FailType_ImmediateContinue, 
    FailType_Off,               
    NUM_FailType,
    FailType_Invalid
};
 
auto
FailTypeToString(FailType cat) -> const std::string&;
auto
FailTypeToLocalizedString(FailType cat) -> const std::string&;
LuaDeclareType(FailType);
 
#endif