From b6cf3477b4a1b052d707305efdf8e0f185166ce4 Mon Sep 17 00:00:00 2001 From: Chris Danford Date: Sat, 8 Oct 2005 00:57:40 +0000 Subject: [PATCH] Use generic names for TapNoteScore values since they are treated genericly by the code. Theme changes coming... --- stepmania/src/CombinedLifeMeterTug.cpp | 18 +-- stepmania/src/Combo.cpp | 28 ++-- stepmania/src/Combo.h | 6 +- stepmania/src/Game.cpp | 10 +- stepmania/src/Game.h | 10 +- stepmania/src/GameConstantsAndTypes.cpp | 79 +++++++--- stepmania/src/GameConstantsAndTypes.h | 33 ++-- stepmania/src/GameManager.cpp | 100 ++++++------ stepmania/src/GameState.cpp | 10 +- stepmania/src/GameState.h | 2 +- stepmania/src/HighScore.cpp | 8 +- stepmania/src/HoldJudgment.cpp | 6 +- stepmania/src/Judgment.cpp | 34 ++-- stepmania/src/LifeMeterBar.cpp | 64 ++++---- stepmania/src/LifeMeterBar.h | 2 +- stepmania/src/LifeMeterBattery.cpp | 20 +-- stepmania/src/LifeMeterTime.cpp | 18 +-- stepmania/src/NetworkSyncManager.cpp | 4 +- stepmania/src/NetworkSyncServer.cpp | 10 +- stepmania/src/NoteDataWithScoring.cpp | 38 ++--- stepmania/src/NoteField.cpp | 2 +- stepmania/src/NoteTypes.h | 8 +- stepmania/src/Player.cpp | 148 +++++++++--------- stepmania/src/PlayerAI.cpp | 26 +-- stepmania/src/PlayerStageStats.cpp | 86 +++++----- stepmania/src/PlayerStageStats.h | 6 +- stepmania/src/Preference.cpp | 2 +- stepmania/src/PrefsManager.cpp | 98 ++++++------ stepmania/src/PrefsManager.h | 100 ++++++------ stepmania/src/Profile.cpp | 1 - stepmania/src/ReceptorArrow.h | 2 +- stepmania/src/ScoreDisplayLifeTime.cpp | 18 +-- stepmania/src/ScoreKeeperMAX2.cpp | 120 +++++++------- stepmania/src/ScoreKeeperMAX2.h | 2 +- stepmania/src/ScoreKeeperRave.cpp | 16 +- stepmania/src/ScreenEdit.cpp | 2 +- stepmania/src/ScreenEnding.cpp | 12 +- stepmania/src/ScreenEvaluation.cpp | 26 +-- stepmania/src/ScreenEvaluationMultiplayer.cpp | 32 ++-- stepmania/src/ScreenEvaluationMultiplayer.h | 10 +- stepmania/src/ScreenGameplay.cpp | 8 +- stepmania/src/ScreenHowToPlay.cpp | 20 +-- stepmania/src/ScreenHowToPlay.h | 4 +- stepmania/src/ScreenNameEntry.cpp | 2 +- stepmania/src/ScreenOptionsMasterPrefs.cpp | 8 +- 45 files changed, 646 insertions(+), 613 deletions(-) diff --git a/stepmania/src/CombinedLifeMeterTug.cpp b/stepmania/src/CombinedLifeMeterTug.cpp index d2bb6b0919..31228397fa 100644 --- a/stepmania/src/CombinedLifeMeterTug.cpp +++ b/stepmania/src/CombinedLifeMeterTug.cpp @@ -47,13 +47,13 @@ void CombinedLifeMeterTug::ChangeLife( PlayerNumber pn, TapNoteScore score ) float fPercentToMove = 0; switch( score ) { - case TNS_MARVELOUS: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeMarvelous; break; - case TNS_PERFECT: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangePerfect; break; - case TNS_GREAT: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeGreat; break; - case TNS_GOOD: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeGood; break; - case TNS_BOO: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeBoo; break; - case TNS_MISS: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeMiss; break; - case TNS_HIT_MINE: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeHitMine; break; + case TNS_Tier1: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeTier1; break; + case TNS_Tier2: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeTier2; break; + case TNS_Tier3: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeTier3; break; + case TNS_Tier4: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeTier4; break; + case TNS_Tier5: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeTier5; break; + case TNS_Miss: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeMiss; break; + case TNS_HitMine: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeHitMine; break; default: ASSERT(0); break; } @@ -70,8 +70,8 @@ void CombinedLifeMeterTug::ChangeLife( PlayerNumber pn, HoldNoteScore score, Tap float fPercentToMove = 0; switch( score ) { - case HNS_OK: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeOK; break; - case HNS_NG: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeNG; break; + case HNS_Held: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeHeld; break; + case HNS_LetGo: fPercentToMove = PREFSMAN->m_fTugMeterPercentChangeLetGo; break; default: ASSERT(0); break; } diff --git a/stepmania/src/Combo.cpp b/stepmania/src/Combo.cpp index 1cb6993601..9e2bbfb024 100644 --- a/stepmania/src/Combo.cpp +++ b/stepmania/src/Combo.cpp @@ -34,11 +34,11 @@ void Combo::Load( PlayerState *pPlayerState, PlayerStageStats *pPlayerStageStats NUMBER_MAX_ZOOM .Load(m_sName,"NumberMaxZoom"); NUMBER_MAX_ZOOM_AT .Load(m_sName,"NumberMaxZoomAt"); PULSE_COMMAND .Load(m_sName,"PulseCommand"); - FULL_COMBO_GREATS_COMMAND .Load(m_sName,"FullComboGreatsCommand"); - FULL_COMBO_PERFECTS_COMMAND .Load(m_sName,"FullComboPerfectsCommand"); - FULL_COMBO_MARVELOUSES_COMMAND .Load(m_sName,"FullComboMarvelousesCommand"); - FULL_COMBO_BROKEN_COMMAND .Load(m_sName,"FullComboBrokenCommand"); - SHOW_MISS_COMBO .Load(m_sName,"ShowMissCombo"); + FULL_COMBO_TIER3_COMMAND .Load(m_sName,"FullComboTier3Command"); + FULL_COMBO_TIER2_COMMAND .Load(m_sName,"FullComboTier2Command"); + FULL_COMBO_TIER1_COMMAND .Load(m_sName,"FullComboTier1Command"); + FULL_COMBO_BROKEN_COMMAND .Load(m_sName,"FullComboBrokenCommand"); + SHOW_MISS_COMBO .Load(m_sName,"ShowMissCombo"); m_spr100Milestone.Load( THEME->GetPathG(m_sName,"100milestone") ); this->AddChild( m_spr100Milestone ); @@ -126,20 +126,20 @@ void Combo::SetCombo( int iCombo, int iMisses ) if( bPastMidpoint ) { - if( m_pPlayerStageStats->FullComboOfScore(TNS_MARVELOUS) ) + if( m_pPlayerStageStats->FullComboOfScore(TNS_Tier1) ) { - sprLabel->RunCommands( FULL_COMBO_MARVELOUSES_COMMAND ); - m_textNumber.RunCommands( FULL_COMBO_MARVELOUSES_COMMAND ); + sprLabel->RunCommands( FULL_COMBO_TIER1_COMMAND ); + m_textNumber.RunCommands( FULL_COMBO_TIER1_COMMAND ); } - else if( bPastMidpoint && m_pPlayerStageStats->FullComboOfScore(TNS_PERFECT) ) + else if( bPastMidpoint && m_pPlayerStageStats->FullComboOfScore(TNS_Tier2) ) { - sprLabel->RunCommands( FULL_COMBO_PERFECTS_COMMAND ); - m_textNumber.RunCommands( FULL_COMBO_PERFECTS_COMMAND ); + sprLabel->RunCommands( FULL_COMBO_TIER2_COMMAND ); + m_textNumber.RunCommands( FULL_COMBO_TIER2_COMMAND ); } - else if( bPastMidpoint && m_pPlayerStageStats->FullComboOfScore(TNS_GREAT) ) + else if( bPastMidpoint && m_pPlayerStageStats->FullComboOfScore(TNS_Tier3) ) { - sprLabel->RunCommands( FULL_COMBO_GREATS_COMMAND ); - m_textNumber.RunCommands( FULL_COMBO_GREATS_COMMAND ); + sprLabel->RunCommands( FULL_COMBO_TIER3_COMMAND ); + m_textNumber.RunCommands( FULL_COMBO_TIER3_COMMAND ); } else { diff --git a/stepmania/src/Combo.h b/stepmania/src/Combo.h index 701bde23c7..84d48b764e 100644 --- a/stepmania/src/Combo.h +++ b/stepmania/src/Combo.h @@ -33,9 +33,9 @@ protected: ThemeMetric NUMBER_MAX_ZOOM_AT; ThemeMetric PULSE_COMMAND; ThemeMetric TWEEN_SECONDS; - ThemeMetric FULL_COMBO_GREATS_COMMAND; - ThemeMetric FULL_COMBO_PERFECTS_COMMAND; - ThemeMetric FULL_COMBO_MARVELOUSES_COMMAND; + ThemeMetric FULL_COMBO_TIER3_COMMAND; + ThemeMetric FULL_COMBO_TIER2_COMMAND; + ThemeMetric FULL_COMBO_TIER1_COMMAND; ThemeMetric FULL_COMBO_BROKEN_COMMAND; ThemeMetric SHOW_MISS_COMBO; diff --git a/stepmania/src/Game.cpp b/stepmania/src/Game.cpp index 8d71b39bb1..a238d63165 100644 --- a/stepmania/src/Game.cpp +++ b/stepmania/src/Game.cpp @@ -105,11 +105,11 @@ TapNoteScore Game::MapTapNoteScore( TapNoteScore tns ) const { switch( tns ) { - case TNS_MARVELOUS: return m_mapMarvelousTo; - case TNS_PERFECT: return m_mapPerfectTo; - case TNS_GREAT: return m_mapGreatTo; - case TNS_GOOD: return m_mapGoodTo; - case TNS_BOO: return m_mapBooTo; + case TNS_Tier1: return m_mapTier1To; + case TNS_Tier2: return m_mapTier2To; + case TNS_Tier3: return m_mapTier3To; + case TNS_Tier4: return m_mapTier4To; + case TNS_Tier5: return m_mapTier5To; default: return tns; } } diff --git a/stepmania/src/Game.h b/stepmania/src/Game.h index 8bc243d5d3..922268db64 100644 --- a/stepmania/src/Game.h +++ b/stepmania/src/Game.h @@ -57,11 +57,11 @@ public: CString ColToButtonName( int col ) const; // looks up current style. Yuck. TapNoteScore MapTapNoteScore( TapNoteScore tns ) const; - TapNoteScore m_mapMarvelousTo; - TapNoteScore m_mapPerfectTo; - TapNoteScore m_mapGreatTo; - TapNoteScore m_mapGoodTo; - TapNoteScore m_mapBooTo; + TapNoteScore m_mapTier1To; + TapNoteScore m_mapTier2To; + TapNoteScore m_mapTier3To; + TapNoteScore m_mapTier4To; + TapNoteScore m_mapTier5To; // // Lua diff --git a/stepmania/src/GameConstantsAndTypes.cpp b/stepmania/src/GameConstantsAndTypes.cpp index b1306f93ff..7dcfd70e94 100644 --- a/stepmania/src/GameConstantsAndTypes.cpp +++ b/stepmania/src/GameConstantsAndTypes.cpp @@ -175,15 +175,36 @@ static const CString TapNoteScoreNames[] = { "HitMine", "AvoidMine", "Miss", - "Boo", - "Good", - "Great", - "Perfect", - "Marvelous", + "Tier5", + "Tier4", + "Tier3", + "Tier2", + "Tier1", }; -XToString( TapNoteScore, NUM_TAP_NOTE_SCORES ); -StringToX( TapNoteScore ); -XToThemedString( TapNoteScore, NUM_TAP_NOTE_SCORES ); +XToString( TapNoteScore, NUM_TapNoteScore ); +TapNoteScore StringToTapNoteScore( const CString &s ) +{ + // for backward compatibility + if ( s == "Boo" ) return TNS_Tier5; + else if( s == "Good" ) return TNS_Tier4; + else if( s == "Great" ) return TNS_Tier3; + else if( s == "Perfect" ) return TNS_Tier2; + else if( s == "Marvelous" ) return TNS_Tier1; + + // new style + else if( s == "None" ) return TNS_None; + else if( s == "HitMine" ) return TNS_HitMine; + else if( s == "AvoidMine" ) return TNS_AvoidMine; + else if( s == "Miss" ) return TNS_Miss; + else if( s == "Tier5" ) return TNS_Tier5; + else if( s == "Tier4" ) return TNS_Tier4; + else if( s == "Tier3" ) return TNS_Tier3; + else if( s == "Tier2" ) return TNS_Tier2; + else if( s == "Tier1" ) return TNS_Tier1; + + return TNS_INVALID; +} +XToThemedString( TapNoteScore, NUM_TapNoteScore ); static void LuaTapNoteScores( lua_State* L ) { FOREACH_TapNoteScore( i ) @@ -198,12 +219,24 @@ REGISTER_WITH_LUA_FUNCTION( LuaTapNoteScores ); static const CString HoldNoteScoreNames[] = { "None", - "NG", - "OK", + "LetGo", + "Held", }; -XToString( HoldNoteScore, NUM_HOLD_NOTE_SCORES ); -StringToX( HoldNoteScore ); -XToThemedString( HoldNoteScore, NUM_HOLD_NOTE_SCORES ); +XToString( HoldNoteScore, NUM_HoldNoteScore ); +HoldNoteScore StringToHoldNoteScore( const CString &s ) +{ + // for backward compatibility + if ( s == "NG" ) return HNS_LetGo; + else if( s == "OK" ) return HNS_Held; + + // new style + else if( s == "None" ) return HNS_None; + else if( s == "LetGo" ) return HNS_LetGo; + else if( s == "Held" ) return HNS_Held; + + return HNS_INVALID; +} +XToThemedString( HoldNoteScore, NUM_HoldNoteScore ); static void LuaHoldNoteScores( lua_State* L ) { FOREACH_HoldNoteScore( i ) @@ -228,16 +261,16 @@ XToString( MemoryCardState, NUM_MEMORY_CARD_STATES ); static const CString PerDifficultyAwardNames[] = { - "FullComboGreats", - "SingleDigitGreats", - "OneGreat", - "FullComboPerfects", - "SingleDigitPerfects", - "OnePerfect", - "FullComboMarvelouses", - "Greats80Percent", - "Greats90Percent", - "Greats100Percent", + "FullComboTier3", + "SingleDigitTier3", + "OneTier3", + "FullComboTier2", + "SingleDigitTier2", + "OneTier2", + "FullComboTier1", + "Tier3s80Percent", + "Tier3s90Percent", + "Tier3s100Percent", }; XToString( PerDifficultyAward, NUM_PER_DIFFICULTY_AWARDS ); XToThemedString( PerDifficultyAward, NUM_PER_DIFFICULTY_AWARDS ); diff --git a/stepmania/src/GameConstantsAndTypes.h b/stepmania/src/GameConstantsAndTypes.h index 3d9bc04783..c95d5b1fdd 100644 --- a/stepmania/src/GameConstantsAndTypes.h +++ b/stepmania/src/GameConstantsAndTypes.h @@ -127,19 +127,19 @@ inline bool IsSongSort( SortOrder so ) { return so >= SORT_PREFERRED && so <= SO // enum TapNoteScore { - TNS_NONE, - TNS_HIT_MINE, - TNS_AVOIDED_MINE, - TNS_MISS, - TNS_BOO, - TNS_GOOD, - TNS_GREAT, - TNS_PERFECT, - TNS_MARVELOUS, - NUM_TAP_NOTE_SCORES, + TNS_None, + TNS_HitMine, + TNS_AvoidMine, + TNS_Miss, + TNS_Tier5, + TNS_Tier4, + TNS_Tier3, + TNS_Tier2, + TNS_Tier1, + NUM_TapNoteScore, TNS_INVALID, }; -#define FOREACH_TapNoteScore( tns ) FOREACH_ENUM( TapNoteScore, NUM_TAP_NOTE_SCORES, tns ) +#define FOREACH_TapNoteScore( tns ) FOREACH_ENUM( TapNoteScore, NUM_TapNoteScore, tns ) const CString& TapNoteScoreToString( TapNoteScore tns ); const CString& TapNoteScoreToThemedString( TapNoteScore tns ); TapNoteScore StringToTapNoteScore( const CString& str ); @@ -147,12 +147,13 @@ TapNoteScore StringToTapNoteScore( const CString& str ); enum HoldNoteScore { - HNS_NONE, // this HoldNote has not been scored yet - HNS_NG, // the HoldNote has passed and they missed it - HNS_OK, // the HoldNote has passed and was successfully held all the way through - NUM_HOLD_NOTE_SCORES + HNS_None, // this HoldNote has not been scored yet + HNS_LetGo, // the HoldNote has passed and they missed it + HNS_Held, // the HoldNote has passed and was successfully held all the way through + NUM_HoldNoteScore, + HNS_INVALID, }; -#define FOREACH_HoldNoteScore( hns ) FOREACH_ENUM( HoldNoteScore, NUM_HOLD_NOTE_SCORES, hns ) +#define FOREACH_HoldNoteScore( hns ) FOREACH_ENUM( HoldNoteScore, NUM_HoldNoteScore, hns ) const CString& HoldNoteScoreToString( HoldNoteScore hns ); const CString& HoldNoteScoreToThemedString( HoldNoteScore hns ); diff --git a/stepmania/src/GameManager.cpp b/stepmania/src/GameManager.cpp index 3d437f912e..15e633838f 100644 --- a/stepmania/src/GameManager.cpp +++ b/stepmania/src/GameManager.cpp @@ -186,11 +186,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // DANCE_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_PUMP "pump", // m_szName @@ -270,11 +270,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // PUMP_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { "ez2", // m_szName @@ -360,11 +360,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // EZ2_BUTTON_OPERATOR }, }, - TNS_PERFECT, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_PERFECT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_MISS, // m_mapBooTo + TNS_Tier2, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier2, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Miss, // m_mapTier5To }, { // GAME_PARA "para", // m_szName @@ -444,11 +444,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // PARA_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_DS3DDX "ds3ddx", // m_szName @@ -537,11 +537,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // DS3DDX_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_BEAT "beat", // m_szName @@ -633,11 +633,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // BEAT_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_MANIAX "maniax", // m_szName @@ -714,11 +714,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // MANIAX_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_TECHNO "techno", // m_szName @@ -810,11 +810,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // TECHNO_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, { // GAME_POPN "popn", // m_szName @@ -906,11 +906,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // BEAT_BUTTON_OPERATOR }, }, - TNS_PERFECT, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GREAT, // m_mapGoodTo - TNS_MISS, // m_mapBooTo + TNS_Tier2, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier3, // m_mapTier4To + TNS_Miss, // m_mapTier5To }, { // GAME_LIGHTS "lights", // m_szName @@ -999,11 +999,11 @@ Game g_Games[NUM_GAMES] = NO_DEFAULT_KEY // LIGHTS_BUTTON_OPERATOR }, }, - TNS_MARVELOUS, // m_mapMarvelousTo - TNS_PERFECT, // m_mapPerfectTo - TNS_GREAT, // m_mapGreatTo - TNS_GOOD, // m_mapGoodTo - TNS_BOO, // m_mapBooTo + TNS_Tier1, // m_mapTier1To + TNS_Tier2, // m_mapTier2To + TNS_Tier3, // m_mapTier3To + TNS_Tier4, // m_mapTier4To + TNS_Tier5, // m_mapTier5To }, }; diff --git a/stepmania/src/GameState.cpp b/stepmania/src/GameState.cpp index 4d77c485db..a15e67590b 100644 --- a/stepmania/src/GameState.cpp +++ b/stepmania/src/GameState.cpp @@ -1282,13 +1282,13 @@ SongOptions::FailType GameState::GetPlayerFailType( const PlayerState *pPlayerSt return ft; } -bool GameState::ShowMarvelous() const +bool GameState::ShowTier1() const { - switch( PREFSMAN->m_MarvelousTiming ) + switch( PREFSMAN->m_Tier1Timing ) { - case PrefsManager::MARVELOUS_NEVER: return false; - case PrefsManager::MARVELOUS_COURSES_ONLY: return IsCourseMode(); - case PrefsManager::MARVELOUS_EVERYWHERE: return true; + case PrefsManager::TIER1_NEVER: return false; + case PrefsManager::TIER1_COURSES_ONLY: return IsCourseMode(); + case PrefsManager::TIER1_EVERYWHERE: return true; default: ASSERT(0); } } diff --git a/stepmania/src/GameState.h b/stepmania/src/GameState.h index eb03884508..26643f079f 100644 --- a/stepmania/src/GameState.h +++ b/stepmania/src/GameState.h @@ -100,7 +100,7 @@ public: bool IsCourseMode() const; bool IsBattleMode() const; /* not Rave */ - bool ShowMarvelous() const; + bool ShowTier1() const; CString m_sLoadingMessage; // used in loading screen BroadcastOnChange m_sPreferredSongGroup; // GROUP_ALL denotes no preferred group diff --git a/stepmania/src/HighScore.cpp b/stepmania/src/HighScore.cpp index 34dec0d0a6..c09a0fc048 100644 --- a/stepmania/src/HighScore.cpp +++ b/stepmania/src/HighScore.cpp @@ -21,8 +21,8 @@ struct HighScoreImpl CString sPlayerGuid; // who made this high score CString sMachineGuid; // where this high score was made int iProductID; - int iTapNoteScores[NUM_TAP_NOTE_SCORES]; - int iHoldNoteScores[NUM_HOLD_NOTE_SCORES]; + int iTapNoteScores[NUM_TapNoteScore]; + int iHoldNoteScores[NUM_HoldNoteScore]; RadarValues radarValues; float fLifeRemainingSeconds; @@ -94,11 +94,11 @@ XNode *HighScoreImpl::CreateNode() const pNode->AppendChild( "ProductID", iProductID ); XNode* pTapNoteScores = pNode->AppendChild( "TapNoteScores" ); FOREACH_TapNoteScore( tns ) - if( tns != TNS_NONE ) // HACK: don't save meaningless "none" count + if( tns != TNS_None ) // HACK: don't save meaningless "none" count pTapNoteScores->AppendChild( TapNoteScoreToString(tns), iTapNoteScores[tns] ); XNode* pHoldNoteScores = pNode->AppendChild( "HoldNoteScores" ); FOREACH_HoldNoteScore( hns ) - if( hns != HNS_NONE ) // HACK: don't save meaningless "none" count + if( hns != HNS_None ) // HACK: don't save meaningless "none" count pHoldNoteScores->AppendChild( HoldNoteScoreToString(hns), iHoldNoteScores[hns] ); pNode->AppendChild( radarValues.CreateNode() ); pNode->AppendChild( "LifeRemainingSeconds", fLifeRemainingSeconds ); diff --git a/stepmania/src/HoldJudgment.cpp b/stepmania/src/HoldJudgment.cpp index 826d816c2f..b5c51dce9c 100644 --- a/stepmania/src/HoldJudgment.cpp +++ b/stepmania/src/HoldJudgment.cpp @@ -33,13 +33,13 @@ void HoldJudgment::SetHoldJudgment( HoldNoteScore hns ) switch( hns ) { - case HNS_NONE: + case HNS_None: ASSERT(0); - case HNS_OK: + case HNS_Held: m_sprJudgment->SetState( 0 ); m_sprJudgment->RunCommands( OK_COMMAND ); break; - case HNS_NG: + case HNS_LetGo: m_sprJudgment->SetState( 1 ); m_sprJudgment->RunCommands( NG_COMMAND ); break; diff --git a/stepmania/src/Judgment.cpp b/stepmania/src/Judgment.cpp index 3bbffe7afc..947859f372 100644 --- a/stepmania/src/Judgment.cpp +++ b/stepmania/src/Judgment.cpp @@ -6,12 +6,12 @@ #include "ThemeManager.h" #include "ThemeMetric.h" -static ThemeMetric MARVELOUS_COMMAND ("Judgment","MarvelousCommand"); -static ThemeMetric PERFECT_COMMAND ("Judgment","PerfectCommand"); -static ThemeMetric GREAT_COMMAND ("Judgment","GreatCommand"); -static ThemeMetric GOOD_COMMAND ("Judgment","GoodCommand"); -static ThemeMetric BOO_COMMAND ("Judgment","BooCommand"); -static ThemeMetric MISS_COMMAND ("Judgment","MissCommand"); +static ThemeMetric TIER1_COMMAND ("Judgment","Tier1Command"); +static ThemeMetric TIER2_COMMAND ("Judgment","Tier2Command"); +static ThemeMetric TIER3_COMMAND ("Judgment","Tier3Command"); +static ThemeMetric TIER4_COMMAND ("Judgment","Tier4Command"); +static ThemeMetric TIER5_COMMAND ("Judgment","Tier5Command"); +static ThemeMetric MISS_COMMAND ("Judgment","MissCommand"); Judgment::Judgment() { @@ -48,27 +48,27 @@ void Judgment::SetJudgment( TapNoteScore score, bool bEarly ) switch( score ) { - case TNS_MARVELOUS: + case TNS_Tier1: m_sprJudgment.SetState( 0 * iStateMult + iStateAdd ); - m_sprJudgment.RunCommands( MARVELOUS_COMMAND ); + m_sprJudgment.RunCommands( TIER1_COMMAND ); break; - case TNS_PERFECT: + case TNS_Tier2: m_sprJudgment.SetState( 1 * iStateMult + iStateAdd ); - m_sprJudgment.RunCommands( PERFECT_COMMAND ); + m_sprJudgment.RunCommands( TIER2_COMMAND ); break; - case TNS_GREAT: + case TNS_Tier3: m_sprJudgment.SetState( 2 * iStateMult + iStateAdd ); - m_sprJudgment.RunCommands( GREAT_COMMAND ); + m_sprJudgment.RunCommands( TIER3_COMMAND ); break; - case TNS_GOOD: + case TNS_Tier4: m_sprJudgment.SetState( 3 * iStateMult + iStateAdd ); - m_sprJudgment.RunCommands( GOOD_COMMAND ); + m_sprJudgment.RunCommands( TIER4_COMMAND ); break; - case TNS_BOO: + case TNS_Tier5: m_sprJudgment.SetState( 4 * iStateMult + iStateAdd ); - m_sprJudgment.RunCommands( BOO_COMMAND ); + m_sprJudgment.RunCommands( TIER5_COMMAND ); break; - case TNS_MISS: + case TNS_Miss: m_sprJudgment.SetState( 5 * iStateMult + iStateAdd ); m_sprJudgment.RunCommands( MISS_COMMAND ); break; diff --git a/stepmania/src/LifeMeterBar.cpp b/stepmania/src/LifeMeterBar.cpp index d66c02e4c9..7d7c69acf7 100644 --- a/stepmania/src/LifeMeterBar.cpp +++ b/stepmania/src/LifeMeterBar.cpp @@ -127,29 +127,29 @@ void LifeMeterBar::ChangeLife( TapNoteScore score ) case SongOptions::DRAIN_NORMAL: switch( score ) { - case TNS_MARVELOUS: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeMarvelous; break; - case TNS_PERFECT: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangePerfect; break; - case TNS_GREAT: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeGreat; break; - case TNS_GOOD: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeGood; break; - case TNS_BOO: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeBoo; break; - case TNS_MISS: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeMiss; break; - case TNS_HIT_MINE: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeHitMine; break; + case TNS_Tier1: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier1; break; + case TNS_Tier2: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier2; break; + case TNS_Tier3: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier3; break; + case TNS_Tier4: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier4; break; + case TNS_Tier5: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier5; break; + case TNS_Miss: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeMiss; break; + case TNS_HitMine: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeHitMine; break; default: ASSERT(0); } - if( IsHot() && score < TNS_GOOD ) + if( IsHot() && score < TNS_Tier4 ) fDeltaLife = -0.10f; // make it take a while to get back to "doing great" break; case SongOptions::DRAIN_NO_RECOVER: switch( score ) { - case TNS_MARVELOUS: fDeltaLife = +0.000f; break; - case TNS_PERFECT: fDeltaLife = +0.000f; break; - case TNS_GREAT: fDeltaLife = +0.000f; break; - case TNS_GOOD: fDeltaLife = +0.000f; break; - case TNS_BOO: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeBoo; break; - case TNS_MISS: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeMiss; break; - case TNS_HIT_MINE: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeHitMine; break; + case TNS_Tier1: fDeltaLife = +0.000f; break; + case TNS_Tier2: fDeltaLife = +0.000f; break; + case TNS_Tier3: fDeltaLife = +0.000f; break; + case TNS_Tier4: fDeltaLife = +0.000f; break; + case TNS_Tier5: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeTier5; break; + case TNS_Miss: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeMiss; break; + case TNS_HitMine: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeHitMine; break; default: ASSERT(0); } @@ -157,13 +157,13 @@ void LifeMeterBar::ChangeLife( TapNoteScore score ) case SongOptions::DRAIN_SUDDEN_DEATH: switch( score ) { - case TNS_MARVELOUS: fDeltaLife = +0; break; - case TNS_PERFECT: fDeltaLife = +0; break; - case TNS_GREAT: fDeltaLife = +0; break; - case TNS_GOOD: fDeltaLife = -1.0; break; - case TNS_BOO: fDeltaLife = -1.0; break; - case TNS_MISS: fDeltaLife = -1.0; break; - case TNS_HIT_MINE: fDeltaLife = -1.0; break; + case TNS_Tier1: fDeltaLife = +0; break; + case TNS_Tier2: fDeltaLife = +0; break; + case TNS_Tier3: fDeltaLife = +0; break; + case TNS_Tier4: fDeltaLife = -1.0; break; + case TNS_Tier5: fDeltaLife = -1.0; break; + case TNS_Miss: fDeltaLife = -1.0; break; + case TNS_HitMine: fDeltaLife = -1.0; break; default: ASSERT(0); } @@ -188,19 +188,19 @@ void LifeMeterBar::ChangeLife( HoldNoteScore score, TapNoteScore tscore ) case SongOptions::DRAIN_NORMAL: switch( score ) { - case HNS_OK: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeOK; break; - case HNS_NG: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeNG; break; + case HNS_Held: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeHeld; break; + case HNS_LetGo: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeLetGo; break; default: ASSERT(0); } - if( IsHot() && score == HNS_NG ) + if( IsHot() && score == HNS_LetGo ) fDeltaLife = -0.10f; // make it take a while to get back to "doing great" break; case SongOptions::DRAIN_NO_RECOVER: switch( score ) { - case HNS_OK: fDeltaLife = +0.000f; break; - case HNS_NG: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeNG; break; + case HNS_Held: fDeltaLife = +0.000f; break; + case HNS_LetGo: fDeltaLife = PREFSMAN->m_fLifeDeltaPercentChangeLetGo; break; default: ASSERT(0); } @@ -208,8 +208,8 @@ void LifeMeterBar::ChangeLife( HoldNoteScore score, TapNoteScore tscore ) case SongOptions::DRAIN_SUDDEN_DEATH: switch( score ) { - case HNS_OK: fDeltaLife = +0; break; - case HNS_NG: fDeltaLife = -1.0; break; + case HNS_Held: fDeltaLife = +0; break; + case HNS_LetGo: fDeltaLife = -1.0; break; default: ASSERT(0); } @@ -419,14 +419,14 @@ void LifeMeterBar::UpdateNonstopLifebar(const int cleared, return; } -void LifeMeterBar::FillForHowToPlay(int NumPerfects, int NumMisses) +void LifeMeterBar::FillForHowToPlay(int NumTier2s, int NumMisses) { m_iProgressiveLifebar = 0; // disable progressive lifebar - float AmountForPerfect = NumPerfects * m_fLifeDifficulty * 0.008f; + float AmountForTier2 = NumTier2s * m_fLifeDifficulty * 0.008f; float AmountForMiss = NumMisses / m_fLifeDifficulty * 0.08f; - m_fLifePercentage = AmountForMiss - AmountForPerfect; + m_fLifePercentage = AmountForMiss - AmountForTier2; CLAMP( m_fLifePercentage, 0.0f, 1.0f ); AfterLifeChanged(); } diff --git a/stepmania/src/LifeMeterBar.h b/stepmania/src/LifeMeterBar.h index f6562e7ad4..087da18014 100644 --- a/stepmania/src/LifeMeterBar.h +++ b/stepmania/src/LifeMeterBar.h @@ -32,7 +32,7 @@ public: virtual void ForceFail(); void UpdateNonstopLifebar(int cleared, int total, int ProgressiveLifebarDifficulty); - void FillForHowToPlay(int NumPerfects, int NumMisses); + void FillForHowToPlay(int NumTier2s, int NumMisses); // this function is solely for HowToPlay private: diff --git a/stepmania/src/LifeMeterBattery.cpp b/stepmania/src/LifeMeterBattery.cpp index f8cf40fc2a..4c59ed2480 100644 --- a/stepmania/src/LifeMeterBattery.cpp +++ b/stepmania/src/LifeMeterBattery.cpp @@ -87,14 +87,14 @@ void LifeMeterBattery::ChangeLife( TapNoteScore score ) switch( score ) { - case TNS_MARVELOUS: - case TNS_PERFECT: - case TNS_GREAT: + case TNS_Tier1: + case TNS_Tier2: + case TNS_Tier3: break; - case TNS_GOOD: - case TNS_BOO: - case TNS_MISS: - case TNS_HIT_MINE: + case TNS_Tier4: + case TNS_Tier5: + case TNS_Miss: + case TNS_HitMine: m_iTrailingLivesLeft = m_iLivesLeft; m_iLivesLeft--; m_soundLoseLife.Play(); @@ -117,10 +117,10 @@ void LifeMeterBattery::ChangeLife( HoldNoteScore score, TapNoteScore tscore ) { switch( score ) { - case HNS_OK: + case HNS_Held: break; - case HNS_NG: - ChangeLife( TNS_MISS ); // NG is the same as a miss + case HNS_LetGo: + ChangeLife( TNS_Miss ); // LetGo is the same as a miss break; default: ASSERT(0); diff --git a/stepmania/src/LifeMeterTime.cpp b/stepmania/src/LifeMeterTime.cpp index 11b074c326..e058e4aa8a 100644 --- a/stepmania/src/LifeMeterTime.cpp +++ b/stepmania/src/LifeMeterTime.cpp @@ -91,13 +91,13 @@ void LifeMeterTime::ChangeLife( TapNoteScore tns ) float fMeterChange = 0; switch( tns ) { - case TNS_MARVELOUS: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMarvelous; break; - case TNS_PERFECT: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangePerfect; break; - case TNS_GREAT: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeGreat; break; - case TNS_GOOD: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeGood; break; - case TNS_BOO: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeBoo; break; - case TNS_MISS: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMiss; break; - case TNS_HIT_MINE: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHitMine; break; + case TNS_Tier1: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier1; break; + case TNS_Tier2: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier2; break; + case TNS_Tier3: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier3; break; + case TNS_Tier4: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier4; break; + case TNS_Tier5: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier5; break; + case TNS_Miss: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMiss; break; + case TNS_HitMine: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHitMine; break; default: ASSERT(0); } @@ -115,8 +115,8 @@ void LifeMeterTime::ChangeLife( HoldNoteScore hns, TapNoteScore tns ) float fMeterChange = 0; switch( hns ) { - case HNS_OK: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeOK; break; - case HNS_NG: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeNG; break; + case HNS_Held: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHeld; break; + case HNS_LetGo: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeLetGo; break; default: ASSERT(0); } diff --git a/stepmania/src/NetworkSyncManager.cpp b/stepmania/src/NetworkSyncManager.cpp index 003874c6ab..dda1ddca55 100644 --- a/stepmania/src/NetworkSyncManager.cpp +++ b/stepmania/src/NetworkSyncManager.cpp @@ -302,7 +302,7 @@ void NetworkSyncManager::ReportScore(int playerID, int step, int score, int comb m_packet.ClearPacket(); m_packet.Write1( NSCGSU ); - uint8_t ctr = (uint8_t) (playerID * 16 + step - ( TNS_MISS - 1 ) ); + uint8_t ctr = (uint8_t) (playerID * 16 + step - ( TNS_Miss - 1 ) ); m_packet.Write1(ctr); ctr = uint8_t( STATSMAN->m_CurStageStats.m_player[playerID].GetGrade()*16 ); @@ -331,7 +331,7 @@ void NetworkSyncManager::ReportScore(int playerID, int step, int score, int comb iOffset=1; //Report 0 if hold, or miss (don't forget mines should report) - if (((stepTNS_MARVELOUS))&&(step!=TNS_HIT_MINE)) + if (((stepTNS_Tier1))&&(step!=TNS_HitMine)) iOffset = 0; m_packet.Write2((uint16_t) iOffset); diff --git a/stepmania/src/NetworkSyncServer.cpp b/stepmania/src/NetworkSyncServer.cpp index 66b80c8d91..4c032c46b2 100644 --- a/stepmania/src/NetworkSyncServer.cpp +++ b/stepmania/src/NetworkSyncServer.cpp @@ -977,19 +977,19 @@ void StepManiaLanServer::CheckLowerJudge(const unsigned int clientNum) if (Client[clientNum]->IsPlaying(x)) { if ((Client[clientNum]->Player[x].currstep == 2)&& - (PREFSMAN->m_fJudgeWindowSecondsBoo < Client[clientNum]->Player[x].offset)) + (PREFSMAN->m_fJudgeWindowSecondsTier5 < Client[clientNum]->Player[x].offset)) Client[clientNum]->lowerJudge = true; if ((Client[clientNum]->Player[x].currstep == 3)&& - (PREFSMAN->m_fJudgeWindowSecondsGood < Client[clientNum]->Player[x].offset)) + (PREFSMAN->m_fJudgeWindowSecondsTier4 < Client[clientNum]->Player[x].offset)) Client[clientNum]->lowerJudge = true; if ((Client[clientNum]->Player[x].currstep == 4)&& - (PREFSMAN->m_fJudgeWindowSecondsGreat < Client[clientNum]->Player[x].offset)) + (PREFSMAN->m_fJudgeWindowSecondsTier3 < Client[clientNum]->Player[x].offset)) Client[clientNum]->lowerJudge = true; if ((Client[clientNum]->Player[x].currstep == 5)&& - (PREFSMAN->m_fJudgeWindowSecondsPerfect < Client[clientNum]->Player[x].offset)) + (PREFSMAN->m_fJudgeWindowSecondsTier2 < Client[clientNum]->Player[x].offset)) Client[clientNum]->lowerJudge = true; if ((Client[clientNum]->Player[x].currstep == 6)&& - (PREFSMAN->m_fJudgeWindowSecondsMarvelous < Client[clientNum]->Player[x].offset)) + (PREFSMAN->m_fJudgeWindowSecondsTier1 < Client[clientNum]->Player[x].offset)) Client[clientNum]->lowerJudge = true; } } diff --git a/stepmania/src/NoteDataWithScoring.cpp b/stepmania/src/NoteDataWithScoring.cpp index 479d3ecf81..523bd2cf40 100644 --- a/stepmania/src/NoteDataWithScoring.cpp +++ b/stepmania/src/NoteDataWithScoring.cpp @@ -72,7 +72,7 @@ int GetSuccessfulMines( const NoteData &in, int iStartIndex = 0, int iEndIndex = for( int t=0; t= TNS_MISS; + return MinTapNoteScore( in, row ) >= TNS_Miss; } namespace { -/* Return the ratio of actual to possible Perfects. */ +/* Return the ratio of actual to possible Tier2s. */ float GetActualStreamRadarValue( const NoteData &in, float fSongSeconds, PlayerNumber pn ) { int iTotalSteps = in.GetNumTapNotes(); if( iTotalSteps == 0 ) return 1.0f; - const int Perfects = GetNumTapNotesWithScore( in, TNS_PERFECT ); - return clamp( float(Perfects)/iTotalSteps, 0.0f, 1.0f ); + const int Tier2s = GetNumTapNotesWithScore( in, TNS_Tier2 ); + return clamp( float(Tier2s)/iTotalSteps, 0.0f, 1.0f ); } /* Return the ratio of actual combo to max combo. */ @@ -215,7 +215,7 @@ float GetActualVoltageRadarValue( const NoteData &in, float fSongSeconds, Player return clamp( fComboPercent, 0.0f, 1.0f ); } -/* Return the ratio of actual to possible Perfects on jumps. */ +/* Return the ratio of actual to possible Tier2s on jumps. */ float GetActualAirRadarValue( const NoteData &in, float fSongSeconds, PlayerNumber pn ) { const int iTotalDoubles = in.GetNumJumps(); @@ -223,7 +223,7 @@ float GetActualAirRadarValue( const NoteData &in, float fSongSeconds, PlayerNumb return 1.0f; // no jumps in song // number of doubles - const int iNumDoubles = GetNumNWithScore( in, TNS_PERFECT, 2 ); + const int iNumDoubles = GetNumNWithScore( in, TNS_Tier2, 2 ); return clamp( (float)iNumDoubles / iTotalDoubles, 0.0f, 1.0f ); } @@ -247,8 +247,8 @@ float GetActualFreezeRadarValue( const NoteData &in, float fSongSeconds, PlayerN return 1.0f; const int ActualHolds = - GetNumHoldNotesWithScore( in, TapNote::hold_head_hold, HNS_OK ) + - GetNumHoldNotesWithScore( in, TapNote::hold_head_roll, HNS_OK ); + GetNumHoldNotesWithScore( in, TapNote::hold_head_hold, HNS_Held ) + + GetNumHoldNotesWithScore( in, TapNote::hold_head_roll, HNS_Held ); return clamp( float(ActualHolds) / iTotalHolds, 0.0f, 1.0f ); } @@ -268,12 +268,12 @@ void NoteDataWithScoring::GetActualRadarValues( const NoteData &in, PlayerNumber case RADAR_AIR: out[rc] = GetActualAirRadarValue( in, fSongSeconds, pn ); break; case RADAR_FREEZE: out[rc] = GetActualFreezeRadarValue( in, fSongSeconds, pn ); break; case RADAR_CHAOS: out[rc] = GetActualChaosRadarValue( in, fSongSeconds, pn ); break; - case RADAR_NUM_TAPS_AND_HOLDS: out[rc] = (float) GetNumNWithScore( in, TNS_GOOD, 1 ); break; - case RADAR_NUM_JUMPS: out[rc] = (float) GetNumNWithScore( in, TNS_GOOD, 2 ); break; - case RADAR_NUM_HOLDS: out[rc] = (float) GetNumHoldNotesWithScore( in, TapNote::hold_head_hold, HNS_OK ); break; + case RADAR_NUM_TAPS_AND_HOLDS: out[rc] = (float) GetNumNWithScore( in, TNS_Tier4, 1 ); break; + case RADAR_NUM_JUMPS: out[rc] = (float) GetNumNWithScore( in, TNS_Tier4, 2 ); break; + case RADAR_NUM_HOLDS: out[rc] = (float) GetNumHoldNotesWithScore( in, TapNote::hold_head_hold, HNS_Held ); break; case RADAR_NUM_MINES: out[rc] = (float) GetSuccessfulMines( in ); break; case RADAR_NUM_HANDS: out[rc] = (float) GetSuccessfulHands( in ); break; - case RADAR_NUM_ROLLS: out[rc] = (float) GetNumHoldNotesWithScore( in, TapNote::hold_head_roll, HNS_OK ); break; + case RADAR_NUM_ROLLS: out[rc] = (float) GetNumHoldNotesWithScore( in, TapNote::hold_head_roll, HNS_Held ); break; default: ASSERT(0); } } diff --git a/stepmania/src/NoteField.cpp b/stepmania/src/NoteField.cpp index 7f9daa0072..87dc8d4c74 100644 --- a/stepmania/src/NoteField.cpp +++ b/stepmania/src/NoteField.cpp @@ -680,7 +680,7 @@ void NoteField::DrawPrimitives() continue; // skip const HoldNoteResult &Result = tn.HoldResult; - if( Result.hns == HNS_OK ) // if this HoldNote was completed + if( Result.hns == HNS_Held ) // if this HoldNote was completed continue; // don't draw anything int iStartRow = begin->first; diff --git a/stepmania/src/NoteTypes.h b/stepmania/src/NoteTypes.h index 9cb1c4e19f..43b9fefe3f 100644 --- a/stepmania/src/NoteTypes.h +++ b/stepmania/src/NoteTypes.h @@ -9,14 +9,14 @@ struct TapNoteResult { TapNoteResult() { - tns = TNS_NONE; + tns = TNS_None; fTapNoteOffset = 0; } TapNoteScore tns; /* Offset, in seconds, for a tap grade. Negative numbers mean the note * was hit early; positive numbers mean it was hit late. These values are - * only meaningful for graded taps (tns >= TNS_BOO). */ + * only meaningful for graded taps (tns >= TNS_Tier5). */ float fTapNoteOffset; /* If the whole row has been judged, all taps on the row will be set to hidden. */ @@ -39,7 +39,7 @@ struct HoldNoteResult HoldNoteResult() { - hns = HNS_NONE; + hns = HNS_None; fLife = 1.0f; iLastHeldRow = 0; bHeld = bActive = false; @@ -73,7 +73,7 @@ struct TapNote original, // part of the original NoteData addition, // additional note added by a transform removed, // Removed taps, e.g. in Little - play keysounds here as if - // judged Perfect, but don't bother rendering or judging this + // judged Tier2, but don't bother rendering or judging this // step. Also used for when we implement auto-scratch, // and for if/when we do a "reduce" modifier that cancels out // all but N keys on a line [useful for beat->dance autogen, too]. diff --git a/stepmania/src/Player.cpp b/stepmania/src/Player.cpp index 0b0c5a8ff8..07bc39544d 100644 --- a/stepmania/src/Player.cpp +++ b/stepmania/src/Player.cpp @@ -48,7 +48,7 @@ CString ATTACK_DISPLAY_X_NAME( size_t p, size_t both_sides ){ return "AttackDisp static const float StepSearchDistance = 1.0f; enum HoldWindow { HW_OK, HW_Roll }; -enum TapWindow { TW_Marvelous, TW_Perfect, TW_Great, TW_Good, TW_Boo, TW_Mine, TW_Attack }; +enum TapWindow { TW_Tier1, TW_Tier2, TW_Tier3, TW_Tier4, TW_Tier5, TW_Mine, TW_Attack }; float AdjustedWindowTap( TapWindow tw, bool bIsPlayingBeginner ) @@ -56,18 +56,18 @@ float AdjustedWindowTap( TapWindow tw, bool bIsPlayingBeginner ) float fSecs = 0; switch( tw ) { - case TW_Marvelous: fSecs = PREFSMAN->m_fJudgeWindowSecondsMarvelous; break; - case TW_Perfect: fSecs = PREFSMAN->m_fJudgeWindowSecondsPerfect; break; - case TW_Great: fSecs = PREFSMAN->m_fJudgeWindowSecondsGreat; break; - case TW_Good: fSecs = PREFSMAN->m_fJudgeWindowSecondsGood; break; - case TW_Boo: fSecs = PREFSMAN->m_fJudgeWindowSecondsBoo; break; + case TW_Tier1: fSecs = PREFSMAN->m_fJudgeWindowSecondsTier1; break; + case TW_Tier2: fSecs = PREFSMAN->m_fJudgeWindowSecondsTier2; break; + case TW_Tier3: fSecs = PREFSMAN->m_fJudgeWindowSecondsTier3; break; + case TW_Tier4: fSecs = PREFSMAN->m_fJudgeWindowSecondsTier4; break; + case TW_Tier5: fSecs = PREFSMAN->m_fJudgeWindowSecondsTier5; break; case TW_Mine: fSecs = PREFSMAN->m_fJudgeWindowSecondsMine; break; case TW_Attack: fSecs = PREFSMAN->m_fJudgeWindowSecondsAttack; break; default: ASSERT(0); } fSecs *= PREFSMAN->m_fJudgeWindowScale; fSecs += PREFSMAN->m_fJudgeWindowAdd; - if( bIsPlayingBeginner && PREFSMAN->m_bMercifulBeginner && tw==TW_Boo ) + if( bIsPlayingBeginner && PREFSMAN->m_bMercifulBeginner && tw==TW_Tier5 ) fSecs += 0.5f; return fSecs; } @@ -77,7 +77,7 @@ float AdjustedWindowHold( HoldWindow hw, bool bIsPlayingBeginner ) float fSecs = 0; switch( hw ) { - case HW_OK: fSecs = PREFSMAN->m_fJudgeWindowSecondsOK; break; + case HW_OK: fSecs = PREFSMAN->m_fJudgeWindowSecondsHeld; break; case HW_Roll: fSecs = PREFSMAN->m_fJudgeWindowSecondsRoll; break; default: ASSERT(0); } @@ -333,7 +333,7 @@ void Player::Load( const NoteData& noteData ) { m_bLoaded = true; - m_LastTapNoteScore = TNS_NONE; + m_LastTapNoteScore = TNS_None; m_iRowLastCrossed = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat ) - 1; // why this? m_iMineRowLastCrossed = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat ) - 1; // why this? @@ -580,7 +580,7 @@ void Player::Update( float fDeltaTime ) const TapNote &tn = m_NoteData.GetTapNote( iTrack, iHeadRow ); if( tn.type != TapNote::hold_head || tn.subType != TapNote::hold_head_roll ) continue; - if( tn.HoldResult.hns != HNS_NONE ) + if( tn.HoldResult.hns != HNS_None ) continue; if( tn.HoldResult.fLife >= 0.5f ) continue; @@ -613,7 +613,7 @@ void Player::Update( float fDeltaTime ) tn.HoldResult.bActive = false; HoldNoteScore hns = tn.HoldResult.hns; - if( hns != HNS_NONE ) // if this HoldNote already has a result + if( hns != HNS_None ) // if this HoldNote already has a result continue; // we don't need to update the logic for this one // TODO: Remove use of PlayerNumber. @@ -621,7 +621,7 @@ void Player::Update( float fDeltaTime ) // if they got a bad score or haven't stepped on the corresponding tap yet const TapNoteScore tns = tn.result.tns; - const bool bSteppedOnTapNote = tns != TNS_NONE && tns != TNS_MISS; // did they step on the start of this hold? + const bool bSteppedOnTapNote = tns != TNS_None && tns != TNS_Miss; // did they step on the start of this hold? bool bIsHoldingButton = false; if( m_pPlayerState->m_PlayerController != PC_HUMAN ) @@ -686,25 +686,25 @@ void Player::Update( float fDeltaTime ) /* check for NG. If the head was missed completely, don't count an NG. */ if( bSteppedOnTapNote && fLife == 0 ) // the player has not pressed the button for a long time! - hns = HNS_NG; + hns = HNS_LetGo; // check for OK if( iSongRow >= iEndRow && bSteppedOnTapNote && fLife > 0 ) // if this HoldNote is in the past { fLife = 1; - hns = HNS_OK; + hns = HNS_Held; bool bBright = m_pPlayerStageStats && m_pPlayerStageStats->iCurCombo>(int)BRIGHT_GHOST_COMBO_THRESHOLD; if( m_pNoteField ) - m_pNoteField->DidHoldNote( iTrack, HNS_OK, bBright ); // bright ghost flash + m_pNoteField->DidHoldNote( iTrack, HNS_Held, bBright ); // bright ghost flash } - if( hns != HNS_NONE ) + if( hns != HNS_None ) { /* this note has been judged */ HandleHoldScore( hns, tns ); m_vHoldJudgment[iTrack]->SetHoldJudgment( hns ); - int ms_error = (hns == HNS_OK)? 0:MAX_PRO_TIMING_ERROR; + int ms_error = (hns == HNS_Held)? 0:MAX_PRO_TIMING_ERROR; if( m_pPlayerStageStats ) m_pPlayerStageStats->iTotalError += ms_error; @@ -907,7 +907,7 @@ int Player::GetClosestNoteDirectional( int col, int iStartRow, int iEndRow, bool const TapNote &tn = begin->second; if( tn.type == TapNote::empty ) break; - if( !bAllowGraded && tn.result.tns != TNS_NONE ) + if( !bAllowGraded && tn.result.tns != TNS_None ) break; return begin->first; @@ -986,12 +986,12 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) int iRow = begin->first; HoldNoteScore hns = tn.HoldResult.hns; - if( hns != HNS_NONE ) // if this HoldNote already has a result + if( hns != HNS_None ) // if this HoldNote already has a result continue; // we don't need to update the logic for this one // if they got a bad score or haven't stepped on the corresponding tap yet const TapNoteScore tns = tn.result.tns; - const bool bSteppedOnTapNote = tns != TNS_NONE && tns != TNS_MISS; // did they step on the start of this roll? + const bool bSteppedOnTapNote = tns != TNS_None && tns != TNS_Miss; // did they step on the start of this roll? int iEndRow = iRow + tn.iDuration; @@ -1018,7 +1018,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) bool bBright = m_pPlayerStageStats && m_pPlayerStageStats->iCurCombo>(int)BRIGHT_GHOST_COMBO_THRESHOLD; if( m_pNoteField ) - m_pNoteField->DidHoldNote( col, HNS_OK, bBright ); + m_pNoteField->DidHoldNote( col, HNS_Held, bBright ); } break; default: @@ -1082,7 +1082,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) iStepSearchRows, iStepSearchRows, false ); // calculate TapNoteScore - TapNoteScore score = TNS_NONE; + TapNoteScore score = TNS_None; if( iIndexOverlappingNote != -1 ) { @@ -1109,7 +1109,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) // fStepSeconds, fMusicSeconds, fNoteOffset ); } - const float fSecondsFromPerfect = fabsf( fNoteOffset ); + const float fSecondsFromTier2 = fabsf( fNoteOffset ); TapNote tn = m_NoteData.GetTapNote( col, iIndexOverlappingNote ); @@ -1122,21 +1122,21 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) { case TapNote::mine: // stepped too close to mine? - if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Mine) ) - score = TNS_HIT_MINE; + if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Mine) ) + score = TNS_HitMine; break; case TapNote::attack: - if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Attack) && !tn.result.bHidden ) - score = TNS_PERFECT; /* sentinel */ + if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Attack) && !tn.result.bHidden ) + score = TNS_Tier2; /* sentinel */ break; default: - if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Marvelous) ) score = TNS_MARVELOUS; - else if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Perfect) ) score = TNS_PERFECT; - else if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Great) ) score = TNS_GREAT; - else if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Good) ) score = TNS_GOOD; - else if( fSecondsFromPerfect <= ADJUSTED_WINDOW_TAP(TW_Boo) ) score = TNS_BOO; - else score = TNS_NONE; + if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Tier1) ) score = TNS_Tier1; + else if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Tier2) ) score = TNS_Tier2; + else if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Tier3) ) score = TNS_Tier3; + else if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Tier4) ) score = TNS_Tier4; + else if( fSecondsFromTier2 <= ADJUSTED_WINDOW_TAP(TW_Tier5) ) score = TNS_Tier5; + else score = TNS_None; break; } break; @@ -1145,16 +1145,16 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) case PC_AUTOPLAY: score = PlayerAI::GetTapNoteScore( m_pPlayerState ); - // GetTapNoteScore always returns TNS_MARVELOUS in autoplay. + // GetTapNoteScore always returns TNS_Tier1 in autoplay. // If the step is far away, don't judge it. if( m_pPlayerState->m_PlayerController == PC_AUTOPLAY && - fSecondsFromPerfect > ADJUSTED_WINDOW_TAP(TW_Boo) ) + fSecondsFromTier2 > ADJUSTED_WINDOW_TAP(TW_Tier5) ) { - score = TNS_NONE; + score = TNS_None; break; } - // TRICKY: We're asking the AI to judge mines. consider TNS_GOOD and below + // TRICKY: We're asking the AI to judge mines. consider TNS_Tier4 and below // as "mine was hit" and everything else as "mine was avoided" if( tn.type == TapNote::mine ) { @@ -1170,22 +1170,22 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) // The CPU hits a lot of mines. Make it less likely to hit // mines that don't have a tap note on the same row. bool bTapsOnRow = m_NoteData.IsThereATapOrHoldHeadAtRow( iIndexOverlappingNote ); - TapNoteScore get_to_avoid = bTapsOnRow ? TNS_GREAT : TNS_GOOD; + TapNoteScore get_to_avoid = bTapsOnRow ? TNS_Tier3 : TNS_Tier4; if( score >= get_to_avoid ) return; // avoided else - score = TNS_HIT_MINE; + score = TNS_HitMine; } - if( tn.type == TapNote::attack && score > TNS_GOOD ) - score = TNS_PERFECT; /* sentinel */ + if( tn.type == TapNote::attack && score > TNS_Tier4 ) + score = TNS_Tier2; /* sentinel */ /* AI will generate misses here. Don't handle a miss like a regular note because * we want the judgment animation to appear delayed. Instead, return early if * AI generated a miss, and let UpdateMissedTapNotesOlderThan() detect and handle the * misses. */ - if( score == TNS_MISS ) + if( score == TNS_Miss ) return; // Put some small, random amount in fNoteOffset so that demonstration @@ -1196,13 +1196,13 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) default: ASSERT(0); - score = TNS_NONE; + score = TNS_None; break; } - if( tn.type == TapNote::attack && score == TNS_PERFECT ) + if( tn.type == TapNote::attack && score == TNS_Tier2 ) { - score = TNS_NONE; // don't score this as anything + score = TNS_None; // don't score this as anything m_soundAttackLaunch.Play(); @@ -1233,7 +1233,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) } } - if( score == TNS_HIT_MINE ) + if( score == TNS_HitMine ) { if( tn.bKeysound && tn.iKeysoundIndex < (int) m_vKeysounds.size() ) m_vKeysounds[tn.iKeysoundIndex].Play(); @@ -1257,16 +1257,16 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) m_pNoteField->DidTapNote( col, score, false ); } - if( m_pPlayerState->m_PlayerController == PC_HUMAN && score >= TNS_GREAT ) + if( m_pPlayerState->m_PlayerController == PC_HUMAN && score >= TNS_Tier3 ) HandleAutosync( fNoteOffset ); // Do game-specific and mode-specific score mapping. score = GAMESTATE->GetCurrentGame()->MapTapNoteScore( score ); - if( score == TNS_MARVELOUS && !GAMESTATE->ShowMarvelous() ) - score = TNS_PERFECT; + if( score == TNS_Tier1 && !GAMESTATE->ShowTier1() ) + score = TNS_Tier2; bool bSteppedEarly = -fNoteOffset < 0; - if( IsPlayingBeginner() && PREFSMAN->m_bMercifulBeginner && score==TNS_BOO && bSteppedEarly ) + if( IsPlayingBeginner() && PREFSMAN->m_bMercifulBeginner && score==TNS_Tier5 && bSteppedEarly ) { if( m_pJudgment ) m_pJudgment->SetJudgment( score, bSteppedEarly ); @@ -1275,12 +1275,12 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) { tn.result.tns = score; - if( score != TNS_NONE ) + if( score != TNS_None ) tn.result.fTapNoteOffset = -fNoteOffset; - if( score != TNS_NONE && score != TNS_MISS ) + if( score != TNS_None && score != TNS_Miss ) { - int ms_error = (int) roundf( fSecondsFromPerfect * 1000 ); + int ms_error = (int) roundf( fSecondsFromTier2 * 1000 ); ms_error = min( ms_error, MAX_PRO_TIMING_ERROR.GetValue() ); if( m_pPlayerStageStats ) @@ -1289,7 +1289,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) //LOG->Trace("XXX: %i col %i, at %f, music at %f, step was at %f, off by %f", // score, col, fStepSeconds, fCurrentMusicSeconds, fMusicSeconds, fNoteOffset ); - // LOG->Trace("Note offset: %f (fSecondsFromPerfect = %f), Score: %i", fNoteOffset, fSecondsFromPerfect, score); + // LOG->Trace("Note offset: %f (fSecondsFromTier2 = %f), Score: %i", fNoteOffset, fSecondsFromTier2, score); m_NoteData.SetTapNote( col, iIndexOverlappingNote, tn ); @@ -1323,7 +1323,7 @@ void Player::HandleStep( int col, const RageTimer &tm, bool bHeld ) if( m_pNoteField ) m_pNoteField->Step( col, score ); - bool bSteppedOnATap = score != TNS_NONE; + bool bSteppedOnATap = score != TNS_None; if( bSteppedOnATap ) { @@ -1398,7 +1398,7 @@ void Player::DisplayJudgedRow( int iIndexThatWasSteppedOn, TapNoteScore score, i // If the score is great or better, remove the note from the screen to // indicate success. (Or always if blind is on.) - if( score >= TNS_GREAT || m_pPlayerState->m_PlayerOptions.m_fBlind ) + if( score >= TNS_Tier3 || m_pPlayerState->m_PlayerOptions.m_fBlind ) { tn.result.bHidden = true; m_NoteData.SetTapNote( iTrack, iIndexThatWasSteppedOn, tn ); @@ -1409,7 +1409,7 @@ void Player::DisplayJudgedRow( int iIndexThatWasSteppedOn, TapNoteScore score, i if (m_pPlayerState->m_PlayerOptions.m_fBlind) { if( m_pNoteField ) - m_pNoteField->DidTapNote( iTrack, TNS_MARVELOUS, bBright ); + m_pNoteField->DidTapNote( iTrack, TNS_Tier1, bBright ); } else { @@ -1423,7 +1423,7 @@ void Player::OnRowCompletelyJudged( int iIndexThatWasSteppedOn ) { // LOG->Trace( "Player::OnRowCompletelyJudged" ); - /* Find the minimum score of the row. This will never be TNS_NONE, since this + /* Find the minimum score of the row. This will never be TNS_None, since this * function is only called when a row is completed. */ /* Instead, use the last tap score. /* I'm not sure this is right, either. Can you really jump a boo and a perfect @@ -1441,9 +1441,9 @@ void Player::OnRowCompletelyJudged( int iIndexThatWasSteppedOn ) TapNoteResult tnr = NoteDataWithScoring::LastTapNoteResult( m_NoteData, iIndexThatWasSteppedOn ); TapNoteScore score = tnr.tns; - ASSERT(score != TNS_NONE); - ASSERT(score != TNS_HIT_MINE); - ASSERT(score != TNS_AVOIDED_MINE); + ASSERT(score != TNS_None); + ASSERT(score != TNS_HitMine); + ASSERT(score != TNS_AvoidMine); /* If the whole row was hit with perfects or greats, remove the row * from the NoteField, so it disappears. */ @@ -1526,18 +1526,18 @@ void Player::UpdateTapNotesMissedOlderThan( float fMissIfOlderThanSeconds ) case TapNote::attack: continue; /* no note here */ } - if( tn.result.tns != TNS_NONE ) /* note here is already hit */ + if( tn.result.tns != TNS_None ) /* note here is already hit */ continue; if( tn.type == TapNote::mine ) { - tn.result.tns = TNS_AVOIDED_MINE; + tn.result.tns = TNS_AvoidMine; } else { // A normal note. Penalize for not stepping on it. MissedNoteOnThisRow = true; - tn.result.tns = TNS_MISS; + tn.result.tns = TNS_Miss; if( m_pPlayerStageStats ) m_pPlayerStageStats->iTotalError += MAX_PRO_TIMING_ERROR; } @@ -1555,7 +1555,7 @@ void Player::UpdateTapNotesMissedOlderThan( float fMissIfOlderThanSeconds ) if( iNumMissesFound > 0 ) { if( m_pJudgment ) - m_pJudgment->SetJudgment( TNS_MISS, false ); + m_pJudgment->SetJudgment( TNS_Miss, false ); } } @@ -1573,7 +1573,7 @@ void Player::CrossedRow( int iNoteRow ) for( int t=0; tm_CurStageStats.bUsedAutoplay = true; @@ -1668,19 +1668,19 @@ void Player::HandleTapRowScore( unsigned row ) int &iCurMissCombo = m_pPlayerStageStats ? m_pPlayerStageStats->iCurMissCombo : iDummy; switch( scoreOfLastTap ) { - case TNS_MARVELOUS: - case TNS_PERFECT: - case TNS_GREAT: + case TNS_Tier1: + case TNS_Tier2: + case TNS_Tier3: iCurMissCombo = 0; SCREENMAN->PostMessageToTopScreen( SM_MissComboAborted, 0 ); break; - case TNS_MISS: + case TNS_Miss: ++iCurMissCombo; - m_LastTapNoteScore = TNS_MISS; + m_LastTapNoteScore = TNS_Miss; - case TNS_GOOD: - case TNS_BOO: + case TNS_Tier4: + case TNS_Tier5: if( iCurCombo > 50 ) SCREENMAN->PostMessageToTopScreen( SM_ComboStopped, 0 ); iCurCombo = 0; @@ -1836,7 +1836,7 @@ void Player::HandleHoldScore( HoldNoteScore holdScore, TapNoteScore tapScore ) float Player::GetMaxStepDistanceSeconds() { - return GAMESTATE->m_SongOptions.m_fMusicRate * ADJUSTED_WINDOW_TAP(TW_Boo); + return GAMESTATE->m_SongOptions.m_fMusicRate * ADJUSTED_WINDOW_TAP(TW_Tier5); } void Player::FadeToFail() diff --git a/stepmania/src/PlayerAI.cpp b/stepmania/src/PlayerAI.cpp index f5108f7e85..6034caddfa 100644 --- a/stepmania/src/PlayerAI.cpp +++ b/stepmania/src/PlayerAI.cpp @@ -10,20 +10,20 @@ struct TapScoreDistribution { - float fPercent[NUM_TAP_NOTE_SCORES]; + float fPercent[NUM_TapNoteScore]; TapNoteScore GetTapNoteScore() { float fRand = randomf(0,1); float fCumulativePercent = 0; - for( int i=0; i<=TNS_MARVELOUS; i++ ) + for( int i=0; i<=TNS_Tier1; i++ ) { fCumulativePercent += fPercent[i]; if( fRand <= fCumulativePercent+1e-4 ) /* rounding error */ return (TapNoteScore)i; } ASSERT(0); // the fCumulativePercents must sum to 1.0, so we should never get here! - return TNS_MARVELOUS; + return TNS_Tier1; } }; @@ -44,18 +44,18 @@ void PlayerAI::InitFromDisk() RageException::Throw( "AI.ini: '%s' doesn't exist.", sKey.c_str() ); TapScoreDistribution& dist = g_Distributions[i]; - dist.fPercent[TNS_NONE] = 0; - pNode->GetAttrValue( "MissWeight", dist.fPercent[TNS_MISS] ); - pNode->GetAttrValue( "BooWeight", dist.fPercent[TNS_BOO] ); - pNode->GetAttrValue( "GoodWeight", dist.fPercent[TNS_GOOD] ); - pNode->GetAttrValue( "GreatWeight", dist.fPercent[TNS_GREAT] ); - pNode->GetAttrValue( "PerfectWeight", dist.fPercent[TNS_PERFECT] ); - pNode->GetAttrValue( "MarvelousWeight", dist.fPercent[TNS_MARVELOUS] ); + dist.fPercent[TNS_None] = 0; + pNode->GetAttrValue( "MissWeight", dist.fPercent[TNS_Miss] ); + pNode->GetAttrValue( "Tier5Weight", dist.fPercent[TNS_Tier5] ); + pNode->GetAttrValue( "Tier4Weight", dist.fPercent[TNS_Tier4] ); + pNode->GetAttrValue( "Tier3Weight", dist.fPercent[TNS_Tier3] ); + pNode->GetAttrValue( "Tier2Weight", dist.fPercent[TNS_Tier2] ); + pNode->GetAttrValue( "Tier1Weight", dist.fPercent[TNS_Tier1] ); float fSum = 0; - for( int j=0; jm_PlayerController == PC_AUTOPLAY ) - return TNS_MARVELOUS; + return TNS_Tier1; int iCpuSkill = pPlayerState->m_iCpuSkill; diff --git a/stepmania/src/PlayerStageStats.cpp b/stepmania/src/PlayerStageStats.cpp index 21af24f326..8f24fb0310 100644 --- a/stepmania/src/PlayerStageStats.cpp +++ b/stepmania/src/PlayerStageStats.cpp @@ -13,7 +13,7 @@ #include "ScoreKeeperMAX2.h" #define GRADE_PERCENT_TIER(i) THEME->GetMetricF("PlayerStageStats",ssprintf("GradePercent%s",GradeToString((Grade)i).c_str())) -#define GRADE_TIER02_IS_ALL_PERFECTS THEME->GetMetricB("PlayerStageStats","GradeTier02IsAllPerfects") +#define GRADE_TIER02_IS_ALL_PERFECTS THEME->GetMetricB("PlayerStageStats","GradeTier02IsAllTier2s") const float LESSON_PASS_THRESHOLD = 0.8f; @@ -63,9 +63,9 @@ void PlayerStageStats::AddStats( const PlayerStageStats& other ) iCurPossibleDancePoints += other.iCurPossibleDancePoints; iPossibleGradePoints += other.iPossibleGradePoints; - for( int t=0; tTrace( "GetGrade: Grade: %s, %i", GradeToString(grade).c_str(), GRADE_TIER02_IS_ALL_PERFECTS ); if( GRADE_TIER02_IS_ALL_PERFECTS ) { - if( iTapNoteScores[TNS_MARVELOUS] > 0 && - iTapNoteScores[TNS_PERFECT] == 0 && - iTapNoteScores[TNS_GREAT] == 0 && - iTapNoteScores[TNS_GOOD] == 0 && - iTapNoteScores[TNS_BOO] == 0 && - iTapNoteScores[TNS_MISS] == 0 && - iTapNoteScores[TNS_HIT_MINE] == 0 && - iHoldNoteScores[HNS_NG] == 0 ) + if( iTapNoteScores[TNS_Tier1] > 0 && + iTapNoteScores[TNS_Tier2] == 0 && + iTapNoteScores[TNS_Tier3] == 0 && + iTapNoteScores[TNS_Tier4] == 0 && + iTapNoteScores[TNS_Tier5] == 0 && + iTapNoteScores[TNS_Miss] == 0 && + iTapNoteScores[TNS_HitMine] == 0 && + iHoldNoteScores[HNS_LetGo] == 0 ) return Grade_Tier01; - if( iTapNoteScores[TNS_PERFECT] > 0 && - iTapNoteScores[TNS_GREAT] == 0 && - iTapNoteScores[TNS_GOOD] == 0 && - iTapNoteScores[TNS_BOO] == 0 && - iTapNoteScores[TNS_MISS] == 0 && - iTapNoteScores[TNS_HIT_MINE] == 0 && - iHoldNoteScores[HNS_NG] == 0 ) + if( iTapNoteScores[TNS_Tier2] > 0 && + iTapNoteScores[TNS_Tier3] == 0 && + iTapNoteScores[TNS_Tier4] == 0 && + iTapNoteScores[TNS_Tier5] == 0 && + iTapNoteScores[TNS_Miss] == 0 && + iTapNoteScores[TNS_HitMine] == 0 && + iHoldNoteScores[HNS_LetGo] == 0 ) return Grade_Tier02; return max( grade, Grade_Tier03 ); @@ -235,12 +235,12 @@ int PlayerStageStats::GetLessonScoreActual() const { switch( tns ) { - case TNS_AVOIDED_MINE: - case TNS_BOO: - case TNS_GOOD: - case TNS_GREAT: - case TNS_PERFECT: - case TNS_MARVELOUS: + case TNS_AvoidMine: + case TNS_Tier5: + case TNS_Tier4: + case TNS_Tier3: + case TNS_Tier2: + case TNS_Tier1: iScore += iTapNoteScores[tns]; break; } @@ -250,7 +250,7 @@ int PlayerStageStats::GetLessonScoreActual() const { switch( hns ) { - case HNS_OK: + case HNS_Held: iScore += iHoldNoteScores[hns]; break; } @@ -453,22 +453,22 @@ int PlayerStageStats::GetComboAtStartOfStage() const bool PlayerStageStats::FullComboOfScore( TapNoteScore tnsAllGreaterOrEqual ) const { - ASSERT( tnsAllGreaterOrEqual >= TNS_GREAT ); - ASSERT( tnsAllGreaterOrEqual <= TNS_MARVELOUS ); + ASSERT( tnsAllGreaterOrEqual >= TNS_Tier3 ); + ASSERT( tnsAllGreaterOrEqual <= TNS_Tier1 ); // If missed any holds, then it's not a full combo - if( iHoldNoteScores[HNS_NG] > 0 ) + if( iHoldNoteScores[HNS_LetGo] > 0 ) return false; // If has any of the judgments below, then not a full combo - for( int i=TNS_MISS; i 0 ) return false; } // If has at least one of the judgments equal to or above, then is a full combo. - for( int i=tnsAllGreaterOrEqual; i 0 ) return true; @@ -492,7 +492,7 @@ bool PlayerStageStats::OneOfScore( TapNoteScore tnsAllGreaterOrEqual ) const int PlayerStageStats::GetTotalTaps() const { int iTotalTaps = 0; - for( int i=TNS_MISS; iIsDisqualified(p) ) { - if( FullComboOfScore( TNS_GREAT ) ) + if( FullComboOfScore( TNS_Tier3 ) ) vPdas.push_back( AWARD_FULL_COMBO_GREATS ); - if( SingleDigitsOfScore( TNS_GREAT ) ) + if( SingleDigitsOfScore( TNS_Tier3 ) ) vPdas.push_back( AWARD_SINGLE_DIGIT_GREATS ); - if( FullComboOfScore( TNS_PERFECT ) ) + if( FullComboOfScore( TNS_Tier2 ) ) vPdas.push_back( AWARD_FULL_COMBO_PERFECTS ); - if( SingleDigitsOfScore( TNS_PERFECT ) ) + if( SingleDigitsOfScore( TNS_Tier2 ) ) vPdas.push_back( AWARD_SINGLE_DIGIT_PERFECTS ); - if( FullComboOfScore( TNS_MARVELOUS ) ) + if( FullComboOfScore( TNS_Tier1 ) ) vPdas.push_back( AWARD_FULL_COMBO_MARVELOUSES ); - if( OneOfScore( TNS_GREAT ) ) + if( OneOfScore( TNS_Tier3 ) ) vPdas.push_back( AWARD_ONE_GREAT ); - if( OneOfScore( TNS_PERFECT ) ) + if( OneOfScore( TNS_Tier2 ) ) vPdas.push_back( AWARD_ONE_PERFECT ); - float fPercentGreats = GetPercentageOfTaps( TNS_GREAT ); - if( fPercentGreats >= 0.8f ) + float fPercentTier3s = GetPercentageOfTaps( TNS_Tier3 ); + if( fPercentTier3s >= 0.8f ) vPdas.push_back( AWARD_GREATS_80_PERCENT ); - if( fPercentGreats >= 0.9f ) + if( fPercentTier3s >= 0.9f ) vPdas.push_back( AWARD_GREATS_90_PERCENT ); - if( fPercentGreats >= 1.f ) + if( fPercentTier3s >= 1.f ) vPdas.push_back( AWARD_GREATS_100_PERCENT ); } diff --git a/stepmania/src/PlayerStageStats.h b/stepmania/src/PlayerStageStats.h index 6f3a5a698d..357193900d 100644 --- a/stepmania/src/PlayerStageStats.h +++ b/stepmania/src/PlayerStageStats.h @@ -43,8 +43,8 @@ public: int iCurPossibleDancePoints; int iActualDancePoints; int iPossibleGradePoints; - int iTapNoteScores[NUM_TAP_NOTE_SCORES]; - int iHoldNoteScores[NUM_HOLD_NOTE_SCORES]; + int iTapNoteScores[NUM_TapNoteScore]; + int iHoldNoteScores[NUM_HoldNoteScore]; int iCurCombo; int iMaxCombo; int iCurMissCombo; @@ -94,7 +94,7 @@ public: int GetComboAtStartOfStage() const; bool FullComboOfScore( TapNoteScore tnsAllGreaterOrEqual ) const; - bool FullCombo() const { return FullComboOfScore(TNS_GREAT); } + bool FullCombo() const { return FullComboOfScore(TNS_Tier3); } bool SingleDigitsOfScore( TapNoteScore tnsAllGreaterOrEqual ) const; bool OneOfScore( TapNoteScore tnsAllGreaterOrEqual ) const; int GetTotalTaps() const; diff --git a/stepmania/src/Preference.cpp b/stepmania/src/Preference.cpp index 1b4dcc6158..f0ba528202 100644 --- a/stepmania/src/Preference.cpp +++ b/stepmania/src/Preference.cpp @@ -59,7 +59,7 @@ READFROM_AND_WRITETO( CString, CString& ) READFROM_AND_WRITETO( PrefsManager::BackgroundMode, int& ) READFROM_AND_WRITETO( PrefsManager::BannerCache, int& ) READFROM_AND_WRITETO( PrefsManager::MusicWheelUsesSections, int& ) -READFROM_AND_WRITETO( PrefsManager::MarvelousTiming, int& ) +READFROM_AND_WRITETO( PrefsManager::Tier1Timing, int& ) READFROM_AND_WRITETO( CoinMode, int& ) READFROM_AND_WRITETO( Premium, int& ) READFROM_AND_WRITETO( PrefsManager::Maybe, int& ) diff --git a/stepmania/src/PrefsManager.cpp b/stepmania/src/PrefsManager.cpp index d86d58a79d..db0e3c92ba 100644 --- a/stepmania/src/PrefsManager.cpp +++ b/stepmania/src/PrefsManager.cpp @@ -92,36 +92,36 @@ PrefsManager::PrefsManager() : m_fJudgeWindowScale ( "JudgeWindowScale", 1.0f ), m_fJudgeWindowAdd ( "JudgeWindowAdd", 0 ), - m_fJudgeWindowSecondsMarvelous ( "JudgeWindowSecondsMarvelous", 0.0225f ), - m_fJudgeWindowSecondsPerfect ( "JudgeWindowSecondsPerfect", 0.045f ), - m_fJudgeWindowSecondsGreat ( "JudgeWindowSecondsGreat", 0.090f ), - m_fJudgeWindowSecondsGood ( "JudgeWindowSecondsGood", 0.135f ), - m_fJudgeWindowSecondsBoo ( "JudgeWindowSecondsBoo", 0.180f ), - m_fJudgeWindowSecondsOK ( "JudgeWindowSecondsOK", 0.250f ), // allow enough time to take foot off and put back on + m_fJudgeWindowSecondsTier1 ( "JudgeWindowSecondsTier1", 0.0225f ), + m_fJudgeWindowSecondsTier2 ( "JudgeWindowSecondsTier2", 0.045f ), + m_fJudgeWindowSecondsTier3 ( "JudgeWindowSecondsTier3", 0.090f ), + m_fJudgeWindowSecondsTier4 ( "JudgeWindowSecondsTier4", 0.135f ), + m_fJudgeWindowSecondsTier5 ( "JudgeWindowSecondsTier5", 0.180f ), + m_fJudgeWindowSecondsHeld ( "JudgeWindowSecondsHeld", 0.250f ), // allow enough time to take foot off and put back on m_fJudgeWindowSecondsRoll ( "JudgeWindowSecondsRoll", 0.350f ), m_fJudgeWindowSecondsMine ( "JudgeWindowSecondsMine", 0.090f ), // same as great m_fJudgeWindowSecondsAttack ( "JudgeWindowSecondsAttack", 0.135f ), m_fLifeDifficultyScale ( "LifeDifficultyScale", 1.0f ), - m_fLifeDeltaPercentChangeMarvelous ( "LifeDeltaPercentChangeMarvelous", +0.008f ), - m_fLifeDeltaPercentChangePerfect ( "LifeDeltaPercentChangePerfect", +0.008f ), - m_fLifeDeltaPercentChangeGreat ( "LifeDeltaPercentChangeGreat", +0.004f ), - m_fLifeDeltaPercentChangeGood ( "LifeDeltaPercentChangeGood", +0.000f ), - m_fLifeDeltaPercentChangeBoo ( "LifeDeltaPercentChangeBoo", -0.040f ), + m_fLifeDeltaPercentChangeTier1 ( "LifeDeltaPercentChangeTier1", +0.008f ), + m_fLifeDeltaPercentChangeTier2 ( "LifeDeltaPercentChangeTier2", +0.008f ), + m_fLifeDeltaPercentChangeTier3 ( "LifeDeltaPercentChangeTier3", +0.004f ), + m_fLifeDeltaPercentChangeTier4 ( "LifeDeltaPercentChangeTier4", +0.000f ), + m_fLifeDeltaPercentChangeTier5 ( "LifeDeltaPercentChangeTier5", -0.040f ), m_fLifeDeltaPercentChangeMiss ( "LifeDeltaPercentChangeMiss", -0.080f ), m_fLifeDeltaPercentChangeHitMine ( "LifeDeltaPercentChangeHitMine", -0.160f ), - m_fLifeDeltaPercentChangeOK ( "LifeDeltaPercentChangeOK", +0.008f ), - m_fLifeDeltaPercentChangeNG ( "LifeDeltaPercentChangeNG", -0.080f ), + m_fLifeDeltaPercentChangeHeld ( "LifeDeltaPercentChangeHeld", +0.008f ), + m_fLifeDeltaPercentChangeLetGo ( "LifeDeltaPercentChangeLetGo", -0.080f ), - m_fTugMeterPercentChangeMarvelous ( "TugMeterPercentChangeMarvelous", +0.010f ), - m_fTugMeterPercentChangePerfect ( "TugMeterPercentChangePerfect", +0.008f ), - m_fTugMeterPercentChangeGreat ( "TugMeterPercentChangeGreat", +0.004f ), - m_fTugMeterPercentChangeGood ( "TugMeterPercentChangeGood", +0.000f ), - m_fTugMeterPercentChangeBoo ( "TugMeterPercentChangeBoo", -0.010f ), + m_fTugMeterPercentChangeTier1 ( "TugMeterPercentChangeTier1", +0.010f ), + m_fTugMeterPercentChangeTier2 ( "TugMeterPercentChangeTier2", +0.008f ), + m_fTugMeterPercentChangeTier3 ( "TugMeterPercentChangeTier3", +0.004f ), + m_fTugMeterPercentChangeTier4 ( "TugMeterPercentChangeTier4", +0.000f ), + m_fTugMeterPercentChangeTier5 ( "TugMeterPercentChangeTier5", -0.010f ), m_fTugMeterPercentChangeMiss ( "TugMeterPercentChangeMiss", -0.020f ), m_fTugMeterPercentChangeHitMine ( "TugMeterPercentChangeHitMine", -0.040f ), - m_fTugMeterPercentChangeOK ( "TugMeterPercentChangeOK", +0.008f ), - m_fTugMeterPercentChangeNG ( "TugMeterPercentChangeNG", -0.020f ), + m_fTugMeterPercentChangeHeld ( "TugMeterPercentChangeHeld", +0.008f ), + m_fTugMeterPercentChangeLetGo ( "TugMeterPercentChangeLetGo", -0.020f ), m_iRegenComboAfterFail ( "RegenComboAfterFail", 10 ), m_iRegenComboAfterMiss ( "RegenComboAfterMiss", 5 ), @@ -134,46 +134,46 @@ PrefsManager::PrefsManager() : m_bFailOffForFirstStageEasy ( "FailOffForFirstStageEasy", false ), m_bMercifulBeginner ( "MercifulBeginner", false ), - m_iPercentScoreWeightMarvelous ( "PercentScoreWeightMarvelous", 3 ), - m_iPercentScoreWeightPerfect ( "PercentScoreWeightPerfect", 2 ), - m_iPercentScoreWeightGreat ( "PercentScoreWeightGreat", 1 ), - m_iPercentScoreWeightGood ( "PercentScoreWeightGood", 0 ), - m_iPercentScoreWeightBoo ( "PercentScoreWeightBoo", 0 ), + m_iPercentScoreWeightTier1 ( "PercentScoreWeightTier1", 3 ), + m_iPercentScoreWeightTier2 ( "PercentScoreWeightTier2", 2 ), + m_iPercentScoreWeightTier3 ( "PercentScoreWeightTier3", 1 ), + m_iPercentScoreWeightTier4 ( "PercentScoreWeightTier4", 0 ), + m_iPercentScoreWeightTier5 ( "PercentScoreWeightTier5", 0 ), m_iPercentScoreWeightMiss ( "PercentScoreWeightMiss", 0 ), m_iPercentScoreWeightHitMine ( "PercentScoreWeightHitMine", -2 ), - m_iPercentScoreWeightOK ( "PercentScoreWeightOK", 3 ), - m_iPercentScoreWeightNG ( "PercentScoreWeightNG", 0 ), + m_iPercentScoreWeightHeld ( "PercentScoreWeightHeld", 3 ), + m_iPercentScoreWeightLetGo ( "PercentScoreWeightLetGo", 0 ), - m_iGradeWeightMarvelous ( "GradeWeightMarvelous", 2 ), - m_iGradeWeightPerfect ( "GradeWeightPerfect", 2 ), - m_iGradeWeightGreat ( "GradeWeightGreat", 1 ), - m_iGradeWeightGood ( "GradeWeightGood", 0 ), - m_iGradeWeightBoo ( "GradeWeightBoo", -4 ), + m_iGradeWeightTier1 ( "GradeWeightTier1", 2 ), + m_iGradeWeightTier2 ( "GradeWeightTier2", 2 ), + m_iGradeWeightTier3 ( "GradeWeightTier3", 1 ), + m_iGradeWeightTier4 ( "GradeWeightTier4", 0 ), + m_iGradeWeightTier5 ( "GradeWeightTier5", -4 ), m_iGradeWeightMiss ( "GradeWeightMiss", -8 ), m_iGradeWeightHitMine ( "GradeWeightHitMine", -8 ), - m_iGradeWeightOK ( "GradeWeightOK", 6 ), - m_iGradeWeightNG ( "GradeWeightNG", 0 ), + m_iGradeWeightHeld ( "GradeWeightHeld", 6 ), + m_iGradeWeightLetGo ( "GradeWeightLetGo", 0 ), - m_fSuperMeterPercentChangeMarvelous ( "SuperMeterPercentChangeMarvelous", +0.05f ), - m_fSuperMeterPercentChangePerfect ( "SuperMeterPercentChangePerfect", +0.04f ), - m_fSuperMeterPercentChangeGreat ( "SuperMeterPercentChangeGreat", +0.02f ), - m_fSuperMeterPercentChangeGood ( "SuperMeterPercentChangeGood", +0.00f ), - m_fSuperMeterPercentChangeBoo ( "SuperMeterPercentChangeBoo", -0.00f ), + m_fSuperMeterPercentChangeTier1 ( "SuperMeterPercentChangeTier1", +0.05f ), + m_fSuperMeterPercentChangeTier2 ( "SuperMeterPercentChangeTier2", +0.04f ), + m_fSuperMeterPercentChangeTier3 ( "SuperMeterPercentChangeTier3", +0.02f ), + m_fSuperMeterPercentChangeTier4 ( "SuperMeterPercentChangeTier4", +0.00f ), + m_fSuperMeterPercentChangeTier5 ( "SuperMeterPercentChangeTier5", -0.00f ), m_fSuperMeterPercentChangeMiss ( "SuperMeterPercentChangeMiss", -0.20f ), m_fSuperMeterPercentChangeHitMine ( "SuperMeterPercentChangeHitMine", -0.40f ), - m_fSuperMeterPercentChangeOK ( "SuperMeterPercentChangeOK", +0.04f ), - m_fSuperMeterPercentChangeNG ( "SuperMeterPercentChangeNG", -0.20f ), + m_fSuperMeterPercentChangeHeld ( "SuperMeterPercentChangeHeld", +0.04f ), + m_fSuperMeterPercentChangeLetGo ( "SuperMeterPercentChangeLetGo", -0.20f ), m_bMercifulSuperMeter ( "MercifulSuperMeter", true ), - m_fTimeMeterSecondsChangeMarvelous ( "TimeMeterSecondsChangeMarvelous", +0.1f ), - m_fTimeMeterSecondsChangePerfect ( "TimeMeterSecondsChangePerfect", 0.0f ), - m_fTimeMeterSecondsChangeGreat ( "TimeMeterSecondsChangeGreat", -0.5f ), - m_fTimeMeterSecondsChangeGood ( "TimeMeterSecondsChangeGood", -1.0f ), - m_fTimeMeterSecondsChangeBoo ( "TimeMeterSecondsChangeBoo", -2.0f ), + m_fTimeMeterSecondsChangeTier1 ( "TimeMeterSecondsChangeTier1", +0.1f ), + m_fTimeMeterSecondsChangeTier2 ( "TimeMeterSecondsChangeTier2", 0.0f ), + m_fTimeMeterSecondsChangeTier3 ( "TimeMeterSecondsChangeTier3", -0.5f ), + m_fTimeMeterSecondsChangeTier4 ( "TimeMeterSecondsChangeTier4", -1.0f ), + m_fTimeMeterSecondsChangeTier5 ( "TimeMeterSecondsChangeTier5", -2.0f ), m_fTimeMeterSecondsChangeMiss ( "TimeMeterSecondsChangeMiss", -4.0f ), m_fTimeMeterSecondsChangeHitMine ( "TimeMeterSecondsChangeHitMine", -2.0f ), - m_fTimeMeterSecondsChangeOK ( "TimeMeterSecondsChangeOK", -0.0f ), - m_fTimeMeterSecondsChangeNG ( "TimeMeterSecondsChangeNG", -4.0f ), + m_fTimeMeterSecondsChangeHeld ( "TimeMeterSecondsChangeHeld", -0.0f ), + m_fTimeMeterSecondsChangeLetGo ( "TimeMeterSecondsChangeLetGo", -4.0f ), m_AutoPlay ( "AutoPlay", PC_HUMAN ), m_bDelayedBack ( "DelayedBack", true ), @@ -185,7 +185,7 @@ PrefsManager::PrefsManager() : m_MusicWheelUsesSections ( "MusicWheelUsesSections", ALWAYS ), m_iMusicWheelSwitchSpeed ( "MusicWheelSwitchSpeed", 10 ), m_bEasterEggs ( "EasterEggs", true ), - m_MarvelousTiming ( "MarvelousTiming", MARVELOUS_EVERYWHERE ), + m_Tier1Timing ( "Tier1Timing", TIER1_EVERYWHERE ), m_bEventMode ( "EventMode", false ), m_iCoinsPerCredit ( "CoinsPerCredit", 1 ), m_iSongsPerPlay ( "SongsPerPlay", 3 ), diff --git a/stepmania/src/PrefsManager.h b/stepmania/src/PrefsManager.h index c9f6d11fc9..ea5a8caa9d 100644 --- a/stepmania/src/PrefsManager.h +++ b/stepmania/src/PrefsManager.h @@ -61,37 +61,37 @@ public: Preference m_fJudgeWindowScale; Preference m_fJudgeWindowAdd; // this is useful for compensating for changes in sampling rate between devices - Preference m_fJudgeWindowSecondsMarvelous; - Preference m_fJudgeWindowSecondsPerfect; - Preference m_fJudgeWindowSecondsGreat; - Preference m_fJudgeWindowSecondsGood; - Preference m_fJudgeWindowSecondsBoo; - Preference m_fJudgeWindowSecondsOK; + Preference m_fJudgeWindowSecondsTier1; + Preference m_fJudgeWindowSecondsTier2; + Preference m_fJudgeWindowSecondsTier3; + Preference m_fJudgeWindowSecondsTier4; + Preference m_fJudgeWindowSecondsTier5; + Preference m_fJudgeWindowSecondsHeld; Preference m_fJudgeWindowSecondsRoll; Preference m_fJudgeWindowSecondsMine; Preference m_fJudgeWindowSecondsAttack; Preference m_fLifeDifficultyScale; - Preference m_fLifeDeltaPercentChangeMarvelous; - Preference m_fLifeDeltaPercentChangePerfect; - Preference m_fLifeDeltaPercentChangeGreat; - Preference m_fLifeDeltaPercentChangeGood; - Preference m_fLifeDeltaPercentChangeBoo; + Preference m_fLifeDeltaPercentChangeTier1; + Preference m_fLifeDeltaPercentChangeTier2; + Preference m_fLifeDeltaPercentChangeTier3; + Preference m_fLifeDeltaPercentChangeTier4; + Preference m_fLifeDeltaPercentChangeTier5; Preference m_fLifeDeltaPercentChangeMiss; Preference m_fLifeDeltaPercentChangeHitMine; - Preference m_fLifeDeltaPercentChangeOK; - Preference m_fLifeDeltaPercentChangeNG; + Preference m_fLifeDeltaPercentChangeHeld; + Preference m_fLifeDeltaPercentChangeLetGo; // tug meter used in rave - Preference m_fTugMeterPercentChangeMarvelous; - Preference m_fTugMeterPercentChangePerfect; - Preference m_fTugMeterPercentChangeGreat; - Preference m_fTugMeterPercentChangeGood; - Preference m_fTugMeterPercentChangeBoo; + Preference m_fTugMeterPercentChangeTier1; + Preference m_fTugMeterPercentChangeTier2; + Preference m_fTugMeterPercentChangeTier3; + Preference m_fTugMeterPercentChangeTier4; + Preference m_fTugMeterPercentChangeTier5; Preference m_fTugMeterPercentChangeMiss; Preference m_fTugMeterPercentChangeHitMine; - Preference m_fTugMeterPercentChangeOK; - Preference m_fTugMeterPercentChangeNG; + Preference m_fTugMeterPercentChangeHeld; + Preference m_fTugMeterPercentChangeLetGo; // Whoever added these: Please add a comment saying what they do. -Chris Preference m_iRegenComboAfterFail; @@ -106,49 +106,49 @@ public: Preference m_bMercifulBeginner; // don't subtract from percent score or grade DP, larger boo window // percent score (the number that is shown on the screen and saved to memory card) - Preference m_iPercentScoreWeightMarvelous; - Preference m_iPercentScoreWeightPerfect; - Preference m_iPercentScoreWeightGreat; - Preference m_iPercentScoreWeightGood; - Preference m_iPercentScoreWeightBoo; + Preference m_iPercentScoreWeightTier1; + Preference m_iPercentScoreWeightTier2; + Preference m_iPercentScoreWeightTier3; + Preference m_iPercentScoreWeightTier4; + Preference m_iPercentScoreWeightTier5; Preference m_iPercentScoreWeightMiss; Preference m_iPercentScoreWeightHitMine; - Preference m_iPercentScoreWeightOK; - Preference m_iPercentScoreWeightNG; + Preference m_iPercentScoreWeightHeld; + Preference m_iPercentScoreWeightLetGo; // grades are calculated based on a percentage, but might have different weights than the percent score - Preference m_iGradeWeightMarvelous; - Preference m_iGradeWeightPerfect; - Preference m_iGradeWeightGreat; - Preference m_iGradeWeightGood; - Preference m_iGradeWeightBoo; + Preference m_iGradeWeightTier1; + Preference m_iGradeWeightTier2; + Preference m_iGradeWeightTier3; + Preference m_iGradeWeightTier4; + Preference m_iGradeWeightTier5; Preference m_iGradeWeightMiss; Preference m_iGradeWeightHitMine; - Preference m_iGradeWeightOK; - Preference m_iGradeWeightNG; + Preference m_iGradeWeightHeld; + Preference m_iGradeWeightLetGo; // super meter used in rave - Preference m_fSuperMeterPercentChangeMarvelous; - Preference m_fSuperMeterPercentChangePerfect; - Preference m_fSuperMeterPercentChangeGreat; - Preference m_fSuperMeterPercentChangeGood; - Preference m_fSuperMeterPercentChangeBoo; + Preference m_fSuperMeterPercentChangeTier1; + Preference m_fSuperMeterPercentChangeTier2; + Preference m_fSuperMeterPercentChangeTier3; + Preference m_fSuperMeterPercentChangeTier4; + Preference m_fSuperMeterPercentChangeTier5; Preference m_fSuperMeterPercentChangeMiss; Preference m_fSuperMeterPercentChangeHitMine; - Preference m_fSuperMeterPercentChangeOK; - Preference m_fSuperMeterPercentChangeNG; + Preference m_fSuperMeterPercentChangeHeld; + Preference m_fSuperMeterPercentChangeLetGo; Preference m_bMercifulSuperMeter; // negative super deltas are scaled by the players life percentage // time meter used in survival - Preference m_fTimeMeterSecondsChangeMarvelous; - Preference m_fTimeMeterSecondsChangePerfect; - Preference m_fTimeMeterSecondsChangeGreat; - Preference m_fTimeMeterSecondsChangeGood; - Preference m_fTimeMeterSecondsChangeBoo; + Preference m_fTimeMeterSecondsChangeTier1; + Preference m_fTimeMeterSecondsChangeTier2; + Preference m_fTimeMeterSecondsChangeTier3; + Preference m_fTimeMeterSecondsChangeTier4; + Preference m_fTimeMeterSecondsChangeTier5; Preference m_fTimeMeterSecondsChangeMiss; Preference m_fTimeMeterSecondsChangeHitMine; - Preference m_fTimeMeterSecondsChangeOK; - Preference m_fTimeMeterSecondsChangeNG; + Preference m_fTimeMeterSecondsChangeHeld; + Preference m_fTimeMeterSecondsChangeLetGo; Preference m_AutoPlay; Preference m_bDelayedBack; @@ -161,8 +161,8 @@ public: Preference m_MusicWheelUsesSections; Preference m_iMusicWheelSwitchSpeed; Preference m_bEasterEggs; - enum MarvelousTiming { MARVELOUS_NEVER, MARVELOUS_COURSES_ONLY, MARVELOUS_EVERYWHERE }; - Preference m_MarvelousTiming; + enum Tier1Timing { TIER1_NEVER, TIER1_COURSES_ONLY, TIER1_EVERYWHERE }; + Preference m_Tier1Timing; Preference m_bEventMode; Preference m_iCoinsPerCredit; Preference m_iSongsPerPlay; diff --git a/stepmania/src/Profile.cpp b/stepmania/src/Profile.cpp index 1e9160c173..cd98f7b916 100644 --- a/stepmania/src/Profile.cpp +++ b/stepmania/src/Profile.cpp @@ -34,7 +34,6 @@ const CString PUBLIC_KEY_FILE = "public.key"; const CString SCREENSHOTS_SUBDIR = "Screenshots/"; const CString EDIT_STEPS_SUBDIR = "Edits/"; const CString EDIT_COURSES_SUBDIR = "EditCourses/"; -const CString LASTGOOD_SUBDIR = "LastGood/"; #define GUID_SIZE_BYTES 8 diff --git a/stepmania/src/ReceptorArrow.h b/stepmania/src/ReceptorArrow.h index 6323784b1f..68b326400b 100644 --- a/stepmania/src/ReceptorArrow.h +++ b/stepmania/src/ReceptorArrow.h @@ -27,7 +27,7 @@ private: AutoActor m_pReceptorWaiting; AutoActor m_pReceptorGo; - apActorCommands m_sScoreCommand[NUM_TAP_NOTE_SCORES]; + apActorCommands m_sScoreCommand[NUM_TapNoteScore]; AutoActor m_pPressBlock; bool m_bIsPressed; diff --git a/stepmania/src/ScoreDisplayLifeTime.cpp b/stepmania/src/ScoreDisplayLifeTime.cpp index d2daf90265..a8eec3d3da 100644 --- a/stepmania/src/ScoreDisplayLifeTime.cpp +++ b/stepmania/src/ScoreDisplayLifeTime.cpp @@ -95,13 +95,13 @@ void ScoreDisplayLifeTime::OnJudgment( TapNoteScore tns ) float fMeterChange = 0; switch( tns ) { - case TNS_MARVELOUS: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMarvelous; break; - case TNS_PERFECT: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangePerfect; break; - case TNS_GREAT: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeGreat; break; - case TNS_GOOD: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeGood; break; - case TNS_BOO: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeBoo; break; - case TNS_MISS: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMiss; break; - case TNS_HIT_MINE: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHitMine; break; + case TNS_Tier1: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier1; break; + case TNS_Tier2: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier2; break; + case TNS_Tier3: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier3; break; + case TNS_Tier4: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier4; break; + case TNS_Tier5: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeTier5; break; + case TNS_Miss: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeMiss; break; + case TNS_HitMine: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHitMine; break; default: ASSERT(0); } @@ -116,8 +116,8 @@ void ScoreDisplayLifeTime::OnJudgment( HoldNoteScore hns, TapNoteScore tns ) float fMeterChange = 0; switch( hns ) { - case HNS_OK: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeOK; break; - case HNS_NG: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeNG; break; + case HNS_Held: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeHeld; break; + case HNS_LetGo: fMeterChange = PREFSMAN->m_fTimeMeterSecondsChangeLetGo; break; default: ASSERT(0); } diff --git a/stepmania/src/ScoreKeeperMAX2.cpp b/stepmania/src/ScoreKeeperMAX2.cpp index c81bfd5ad9..4f0b229970 100644 --- a/stepmania/src/ScoreKeeperMAX2.cpp +++ b/stepmania/src/ScoreKeeperMAX2.cpp @@ -103,9 +103,9 @@ void ScoreKeeperMAX2::Load( m_iRoundTo = 5; if (!GAMESTATE->IsCourseMode()) { - m_ComboBonusFactor[TNS_MARVELOUS] = 55; - m_ComboBonusFactor[TNS_PERFECT] = 55; - m_ComboBonusFactor[TNS_GREAT] = 33; + m_ComboBonusFactor[TNS_Tier1] = 55; + m_ComboBonusFactor[TNS_Tier2] = 55; + m_ComboBonusFactor[TNS_Tier3] = 33; } break; default: @@ -230,11 +230,11 @@ void ScoreKeeperMAX2::AddScore( TapNoteScore score ) /* Regular scoring: - Let p = score multiplier (Perfect = 10, Great = 5, other = 0) + Let p = score multiplier (Tier2 = 10, Tier3 = 5, other = 0) Note on NONSTOP Mode scoring - Let p = score multiplier (Marvelous = 10, Perfect = 9, Great = 5, other = 0) + Let p = score multiplier (Tier1 = 10, Tier2 = 9, Tier3 = 5, other = 0) N = total number of steps and freeze steps S = The sum of all integers from 1 to N (the total number of steps/freeze steps) @@ -250,7 +250,7 @@ void ScoreKeeperMAX2::AddScore( TapNoteScore score ) Now, through simple algebraic manipulation: S = 1+...+N = (1+N)*N/2 (1 through N added together) - Okay, time for an example. Suppose we wanted to calculate the step score of a "Great" on the 57th step of + Okay, time for an example. Suppose we wanted to calculate the step score of a "Tier3" on the 57th step of a 441 step, 8-foot difficulty song (I'm just making this one up): S = (1 + 441)*441 / 2 @@ -264,16 +264,16 @@ void ScoreKeeperMAX2::AddScore( TapNoteScore score ) Remember this is just the score for the step, not the cumulative score up to the 57th step. Also, please note that I am currently checking into rounding errors with the system and if there are any, how they are resolved in the system. - Note: if you got all Perfect on this song, you would get (p=10)*B, which is 80,000,000. In fact, the maximum possible + Note: if you got all Tier2 on this song, you would get (p=10)*B, which is 80,000,000. In fact, the maximum possible score for any song is the number of feet difficulty X 10,000,000. */ int p = 0; // score multiplier switch( score ) { - case TNS_MARVELOUS: p = 10; break; - case TNS_PERFECT: p = GAMESTATE->ShowMarvelous()? 9:10; break; - case TNS_GREAT: p = 5; break; + case TNS_Tier1: p = 10; break; + case TNS_Tier2: p = GAMESTATE->ShowTier1()? 9:10; break; + case TNS_Tier3: p = 5; break; default: p = 0; break; } @@ -306,7 +306,7 @@ void ScoreKeeperMAX2::AddScore( TapNoteScore score ) /* And add the maximum this step could have been worth to the max score up to now. */ iCurMaxScore += GetScore(10, B, sum, m_iTapNotesHit); - if ( m_iTapNotesHit == m_iNumTapsAndHolds && score >= TNS_PERFECT ) + if ( m_iTapNotesHit == m_iNumTapsAndHolds && score >= TNS_Tier2 ) { if (!m_pPlayerStageStats->bFailedEarlier) iScore += m_iPointBonus; @@ -336,11 +336,11 @@ void ScoreKeeperMAX2::AddScore( TapNoteScore score ) void ScoreKeeperMAX2::HandleTapScore( TapNoteScore score ) { - if( score == TNS_HIT_MINE ) + if( score == TNS_HitMine ) { if( !m_pPlayerStageStats->bFailed ) - m_pPlayerStageStats->iActualDancePoints += TapNoteScoreToDancePoints( TNS_HIT_MINE ); - m_pPlayerStageStats->iTapNoteScores[TNS_HIT_MINE] += 1; + m_pPlayerStageStats->iActualDancePoints += TapNoteScoreToDancePoints( TNS_HitMine ); + m_pPlayerStageStats->iTapNoteScores[TNS_HitMine] += 1; } } @@ -351,13 +351,13 @@ void ScoreKeeperMAX2::HandleTapRowScore( TapNoteScore scoreOfLastTap, int iNumTa // Update dance points. if( !m_pPlayerStageStats->bFailed ) m_pPlayerStageStats->iActualDancePoints += TapNoteScoreToDancePoints( scoreOfLastTap ); - m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_MARVELOUS ); + m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_Tier1 ); // update judged row totals m_pPlayerStageStats->iTapNoteScores[scoreOfLastTap] += 1; // increment the current total possible dance score - m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_MARVELOUS ); + m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_Tier1 ); // // Regular combo @@ -387,8 +387,8 @@ void ScoreKeeperMAX2::HandleTapRowScore( TapNoteScore scoreOfLastTap, int iNumTa // switch( scoreOfLastTap ) { - case TNS_MARVELOUS: - case TNS_PERFECT: + case TNS_Tier1: + case TNS_Tier2: m_iCurToastyCombo += iNumTapsInRow; if( m_iCurToastyCombo >= 250 && @@ -420,23 +420,23 @@ void ScoreKeeperMAX2::HandleHoldScore( HoldNoteScore holdScore, TapNoteScore tap // update dance points totals if( !m_pPlayerStageStats->bFailed ) m_pPlayerStageStats->iActualDancePoints += HoldNoteScoreToDancePoints( holdScore ); - m_pPlayerStageStats->iCurPossibleDancePoints += HoldNoteScoreToDancePoints( HNS_OK ); + m_pPlayerStageStats->iCurPossibleDancePoints += HoldNoteScoreToDancePoints( HNS_Held ); m_pPlayerStageStats->iHoldNoteScores[holdScore] ++; // increment the current total possible dance score - m_pPlayerStageStats->iCurPossibleDancePoints += HoldNoteScoreToDancePoints( HNS_OK ); + m_pPlayerStageStats->iCurPossibleDancePoints += HoldNoteScoreToDancePoints( HNS_Held ); - if( holdScore == HNS_OK ) - AddScore( TNS_MARVELOUS ); - else if ( holdScore == HNS_NG ) - AddScore( TNS_GOOD ); // required for subtractive score display to work properly + if( holdScore == HNS_Held ) + AddScore( TNS_Tier1 ); + else if ( holdScore == HNS_LetGo ) + AddScore( TNS_Tier4 ); // required for subtractive score display to work properly // TODO: Remove indexing with PlayerNumber PlayerNumber pn = m_pPlayerState->m_PlayerNumber; NSMAN->ReportScore( pn, - holdScore+TNS_MARVELOUS, + holdScore+TNS_Tier1, m_pPlayerStageStats->iScore, m_pPlayerStageStats->iCurCombo ); } @@ -444,16 +444,16 @@ void ScoreKeeperMAX2::HandleHoldScore( HoldNoteScore holdScore, TapNoteScore tap int ScoreKeeperMAX2::GetPossibleDancePoints( const RadarValues& radars ) { - /* Note that, if Marvelous timing is disabled or not active (not course mode), + /* Note that, if Tier1 timing is disabled or not active (not course mode), * PERFECT will be used instead. */ int NumTaps = int(radars[RADAR_NUM_TAPS_AND_HOLDS]); int NumHolds = int(radars[RADAR_NUM_HOLDS]); int NumRolls = int(radars[RADAR_NUM_ROLLS]); return - NumTaps*TapNoteScoreToDancePoints(TNS_MARVELOUS, false)+ - NumHolds*HoldNoteScoreToDancePoints(HNS_OK, false) + - NumRolls*HoldNoteScoreToDancePoints(HNS_OK, false); + NumTaps*TapNoteScoreToDancePoints(TNS_Tier1, false)+ + NumHolds*HoldNoteScoreToDancePoints(HNS_Held, false) + + NumRolls*HoldNoteScoreToDancePoints(HNS_Held, false); } int ScoreKeeperMAX2::GetPossibleDancePoints( const RadarValues& fOriginalRadars, const RadarValues& fPostRadars ) @@ -469,16 +469,16 @@ int ScoreKeeperMAX2::GetPossibleDancePoints( const RadarValues& fOriginalRadars, int ScoreKeeperMAX2::GetPossibleGradePoints( const RadarValues& radars ) { - /* Note that, if Marvelous timing is disabled or not active (not course mode), + /* Note that, if Tier1 timing is disabled or not active (not course mode), * PERFECT will be used instead. */ int NumTaps = int(radars[RADAR_NUM_TAPS_AND_HOLDS]); int NumHolds = int(radars[RADAR_NUM_HOLDS]); int NumRolls = int(radars[RADAR_NUM_ROLLS]); return - NumTaps*TapNoteScoreToGradePoints(TNS_MARVELOUS, false)+ - NumHolds*HoldNoteScoreToGradePoints(HNS_OK, false) + - NumRolls*HoldNoteScoreToGradePoints(HNS_OK, false); + NumTaps*TapNoteScoreToGradePoints(TNS_Tier1, false)+ + NumHolds*HoldNoteScoreToGradePoints(HNS_Held, false) + + NumRolls*HoldNoteScoreToGradePoints(HNS_Held, false); } int ScoreKeeperMAX2::GetPossibleGradePoints( const RadarValues& fOriginalRadars, const RadarValues& fPostRadars ) @@ -513,22 +513,22 @@ int ScoreKeeperMAX2::HoldNoteScoreToGradePoints( HoldNoteScore hns ) const int ScoreKeeperMAX2::TapNoteScoreToDancePoints( TapNoteScore tns, bool bBeginner ) { - if( !GAMESTATE->ShowMarvelous() && tns == TNS_MARVELOUS ) - tns = TNS_PERFECT; + if( !GAMESTATE->ShowTier1() && tns == TNS_Tier1 ) + tns = TNS_Tier2; /* This is used for Oni percentage displays. Grading values are currently in * StageStats::GetGrade. */ int iWeight = 0; switch( tns ) { - case TNS_NONE: iWeight = 0; - case TNS_HIT_MINE: iWeight = PREFSMAN->m_iPercentScoreWeightHitMine; break; - case TNS_MISS: iWeight = PREFSMAN->m_iPercentScoreWeightMiss; break; - case TNS_BOO: iWeight = PREFSMAN->m_iPercentScoreWeightBoo; break; - case TNS_GOOD: iWeight = PREFSMAN->m_iPercentScoreWeightGood; break; - case TNS_GREAT: iWeight = PREFSMAN->m_iPercentScoreWeightGreat; break; - case TNS_PERFECT: iWeight = PREFSMAN->m_iPercentScoreWeightPerfect; break; - case TNS_MARVELOUS: iWeight = PREFSMAN->m_iPercentScoreWeightMarvelous; break; + case TNS_None: iWeight = 0; + case TNS_HitMine: iWeight = PREFSMAN->m_iPercentScoreWeightHitMine; break; + case TNS_Miss: iWeight = PREFSMAN->m_iPercentScoreWeightMiss; break; + case TNS_Tier5: iWeight = PREFSMAN->m_iPercentScoreWeightTier5; break; + case TNS_Tier4: iWeight = PREFSMAN->m_iPercentScoreWeightTier4; break; + case TNS_Tier3: iWeight = PREFSMAN->m_iPercentScoreWeightTier3; break; + case TNS_Tier2: iWeight = PREFSMAN->m_iPercentScoreWeightTier2; break; + case TNS_Tier1: iWeight = PREFSMAN->m_iPercentScoreWeightTier1; break; default: FAIL_M( ssprintf("%i", tns) ); } if( bBeginner && PREFSMAN->m_bMercifulBeginner ) @@ -541,9 +541,9 @@ int ScoreKeeperMAX2::HoldNoteScoreToDancePoints( HoldNoteScore hns, bool bBeginn int iWeight = 0; switch( hns ) { - case HNS_NONE: iWeight = 0; break; - case HNS_NG: iWeight = PREFSMAN->m_iPercentScoreWeightNG; break; - case HNS_OK: iWeight = PREFSMAN->m_iPercentScoreWeightOK; break; + case HNS_None: iWeight = 0; break; + case HNS_LetGo: iWeight = PREFSMAN->m_iPercentScoreWeightLetGo; break; + case HNS_Held: iWeight = PREFSMAN->m_iPercentScoreWeightHeld; break; default: FAIL_M( ssprintf("%i", hns) ); } if( bBeginner && PREFSMAN->m_bMercifulBeginner ) @@ -553,23 +553,23 @@ int ScoreKeeperMAX2::HoldNoteScoreToDancePoints( HoldNoteScore hns, bool bBeginn int ScoreKeeperMAX2::TapNoteScoreToGradePoints( TapNoteScore tns, bool bBeginner ) { - if( !GAMESTATE->ShowMarvelous() && tns == TNS_MARVELOUS ) - tns = TNS_PERFECT; + if( !GAMESTATE->ShowTier1() && tns == TNS_Tier1 ) + tns = TNS_Tier2; /* This is used for Oni percentage displays. Grading values are currently in * StageStats::GetGrade. */ int iWeight = 0; switch( tns ) { - case TNS_NONE: iWeight = 0; - case TNS_AVOIDED_MINE: iWeight = 0; - case TNS_HIT_MINE: iWeight = PREFSMAN->m_iGradeWeightHitMine; break; - case TNS_MISS: iWeight = PREFSMAN->m_iGradeWeightMiss; break; - case TNS_BOO: iWeight = PREFSMAN->m_iGradeWeightBoo; break; - case TNS_GOOD: iWeight = PREFSMAN->m_iGradeWeightGood; break; - case TNS_GREAT: iWeight = PREFSMAN->m_iGradeWeightGreat; break; - case TNS_PERFECT: iWeight = PREFSMAN->m_iGradeWeightPerfect; break; - case TNS_MARVELOUS: iWeight = PREFSMAN->m_iGradeWeightMarvelous;break; + case TNS_None: iWeight = 0; + case TNS_AvoidMine: iWeight = 0; + case TNS_HitMine: iWeight = PREFSMAN->m_iGradeWeightHitMine; break; + case TNS_Miss: iWeight = PREFSMAN->m_iGradeWeightMiss; break; + case TNS_Tier5: iWeight = PREFSMAN->m_iGradeWeightTier5; break; + case TNS_Tier4: iWeight = PREFSMAN->m_iGradeWeightTier4; break; + case TNS_Tier3: iWeight = PREFSMAN->m_iGradeWeightTier3; break; + case TNS_Tier2: iWeight = PREFSMAN->m_iGradeWeightTier2; break; + case TNS_Tier1: iWeight = PREFSMAN->m_iGradeWeightTier1;break; default: FAIL_M( ssprintf("%i", tns) ); } if( bBeginner && PREFSMAN->m_bMercifulBeginner ) @@ -582,9 +582,9 @@ int ScoreKeeperMAX2::HoldNoteScoreToGradePoints( HoldNoteScore hns, bool bBeginn int iWeight = 0; switch( hns ) { - case HNS_NONE: iWeight = 0; break; - case HNS_NG: iWeight = PREFSMAN->m_iGradeWeightNG; break; - case HNS_OK: iWeight = PREFSMAN->m_iGradeWeightOK; break; + case HNS_None: iWeight = 0; break; + case HNS_LetGo: iWeight = PREFSMAN->m_iGradeWeightLetGo; break; + case HNS_Held: iWeight = PREFSMAN->m_iGradeWeightHeld; break; default: FAIL_M( ssprintf("%i", hns) ); } if( bBeginner && PREFSMAN->m_bMercifulBeginner ) diff --git a/stepmania/src/ScoreKeeperMAX2.h b/stepmania/src/ScoreKeeperMAX2.h index 1c63003e00..9d47071003 100644 --- a/stepmania/src/ScoreKeeperMAX2.h +++ b/stepmania/src/ScoreKeeperMAX2.h @@ -33,7 +33,7 @@ class ScoreKeeperMAX2: public ScoreKeeper /* Configuration: */ /* Score after each tap will be rounded to the nearest m_iRoundTo; 1 to do nothing. */ int m_iRoundTo; - int m_ComboBonusFactor[NUM_TAP_NOTE_SCORES]; + int m_ComboBonusFactor[NUM_TapNoteScore]; public: ScoreKeeperMAX2( diff --git a/stepmania/src/ScoreKeeperRave.cpp b/stepmania/src/ScoreKeeperRave.cpp index cab742b8f1..afc968bd6e 100644 --- a/stepmania/src/ScoreKeeperRave.cpp +++ b/stepmania/src/ScoreKeeperRave.cpp @@ -28,7 +28,7 @@ void ScoreKeeperRave::HandleTapScore( TapNoteScore score ) float fPercentToMove = 0; switch( score ) { - case TNS_HIT_MINE: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeHitMine; break; + case TNS_HitMine: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeHitMine; break; } AddSuperMeterDelta( fPercentToMove ); @@ -41,12 +41,12 @@ void ScoreKeeperRave::HandleTapRowScore( TapNoteScore scoreOfLastTap, int iNumTa float fPercentToMove; switch( scoreOfLastTap ) { - case TNS_MARVELOUS: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeMarvelous; break; - case TNS_PERFECT: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangePerfect; break; - case TNS_GREAT: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeGreat; break; - case TNS_GOOD: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeGood; break; - case TNS_BOO: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeBoo; break; - case TNS_MISS: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeMiss; break; + case TNS_Tier1: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeTier1; break; + case TNS_Tier2: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeTier2; break; + case TNS_Tier3: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeTier3; break; + case TNS_Tier4: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeTier4; break; + case TNS_Tier5: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeTier5; break; + case TNS_Miss: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeMiss; break; default: ASSERT(0); fPercentToMove = +0.00f; break; } AddSuperMeterDelta( fPercentToMove ); @@ -57,7 +57,7 @@ void ScoreKeeperRave::HandleHoldScore( HoldNoteScore holdScore, TapNoteScore tap float fPercentToMove = 0; switch( tapScore ) { - case TNS_HIT_MINE: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeHitMine; break; + case TNS_HitMine: fPercentToMove = PREFSMAN->m_fSuperMeterPercentChangeHitMine; break; } AddSuperMeterDelta( fPercentToMove ); } diff --git a/stepmania/src/ScreenEdit.cpp b/stepmania/src/ScreenEdit.cpp index e8fa25717e..98c47b4ef3 100644 --- a/stepmania/src/ScreenEdit.cpp +++ b/stepmania/src/ScreenEdit.cpp @@ -1775,7 +1775,7 @@ void ScreenEdit::InputRecord( const InputEventPlus &input, EditButton EditB ) tn = TAP_ORIGINAL_MINE; m_NoteDataRecord.SetTapNote( iCol, iRow, tn ); - m_NoteFieldRecord.Step( iCol, TNS_MARVELOUS ); + m_NoteFieldRecord.Step( iCol, TNS_Tier1 ); } break; case IET_SLOW_REPEAT: diff --git a/stepmania/src/ScreenEnding.cpp b/stepmania/src/ScreenEnding.cpp index 578c19b797..8117d2454a 100644 --- a/stepmania/src/ScreenEnding.cpp +++ b/stepmania/src/ScreenEnding.cpp @@ -171,12 +171,12 @@ ScreenEnding::ScreenEnding( CString sClassName ) : ScreenAttract( sClassName, fa STATSMAN->m_CurStageStats.m_player[PLAYER_1].iCurCombo = 250; STATSMAN->m_CurStageStats.m_player[PLAYER_1].UpdateComboList( 100, false ); - STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_MARVELOUS] = rand()%2; - STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_PERFECT] = rand()%2; - STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_GREAT] = rand()%2; - STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_MARVELOUS] = rand()%2; - STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_PERFECT] = rand()%2; - STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_GREAT] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_Tier1] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_Tier2] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_Tier3] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_Tier1] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_Tier2] = rand()%2; + STATSMAN->m_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_Tier3] = rand()%2; STATSMAN->m_vPlayedStageStats.clear(); } diff --git a/stepmania/src/ScreenEvaluation.cpp b/stepmania/src/ScreenEvaluation.cpp index d375ce14e7..aee0c8b11a 100644 --- a/stepmania/src/ScreenEvaluation.cpp +++ b/stepmania/src/ScreenEvaluation.cpp @@ -41,7 +41,7 @@ const int NUM_SCORE_DIGITS = 9; #define BANNER_HEIGHT THEME->GetMetricF(m_sName,"BannerHeight") const char* JUDGE_STRING[NUM_JUDGE_LINES] = { - "Marvelous", "Perfect", "Great", "Good", "Boo", "Miss", "OK", "MaxCombo", "TotalError" + "Tier1", "Tier2", "Tier3", "Tier4", "Tier5", "Miss", "OK", "MaxCombo", "TotalError" }; const char* STATS_STRING[NUM_STATS_LINES] = { @@ -157,10 +157,10 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : ScreenWithMenuElement { STATSMAN->m_CurStageStats.m_player[p].bFailedEarlier = true; } - STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_MARVELOUS] = rand()%3; - STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_PERFECT] = rand()%3; - STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_GREAT] = rand()%3; - STATSMAN->m_CurStageStats.m_player[p].iPossibleGradePoints = 4*ScoreKeeperMAX2::TapNoteScoreToGradePoints(TNS_MARVELOUS, false); + STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier1] = rand()%3; + STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier2] = rand()%3; + STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier3] = rand()%3; + STATSMAN->m_CurStageStats.m_player[p].iPossibleGradePoints = 4*ScoreKeeperMAX2::TapNoteScoreToGradePoints(TNS_Tier1, false); STATSMAN->m_CurStageStats.m_player[p].fLifeRemainingSeconds = randomf( 90, 580 ); } @@ -473,7 +473,7 @@ void ScreenEvaluation::Init() // for( int l=0; lShowMarvelous() ) + if( l == 0 && !GAMESTATE->ShowTier1() ) continue; // skip if( SHOW_JUDGMENT(l) ) @@ -500,13 +500,13 @@ void ScreenEvaluation::Init() int iValue; switch( l ) { - case marvelous: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_MARVELOUS]; break; - case perfect: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_PERFECT]; break; - case great: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_GREAT]; break; - case good: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_GOOD]; break; - case boo: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_BOO]; break; - case miss: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_MISS]; break; - case ok: iValue = STATSMAN->m_CurStageStats.m_player[p].iHoldNoteScores[HNS_OK]; break; + case marvelous: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier1]; break; + case perfect: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier2]; break; + case great: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier3]; break; + case good: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier4]; break; + case boo: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Tier5]; break; + case miss: iValue = STATSMAN->m_CurStageStats.m_player[p].iTapNoteScores[TNS_Miss]; break; + case ok: iValue = STATSMAN->m_CurStageStats.m_player[p].iHoldNoteScores[HNS_Held]; break; case max_combo: iValue = STATSMAN->m_CurStageStats.m_player[p].GetMaxCombo().cnt; break; case error: iValue = STATSMAN->m_CurStageStats.m_player[p].iTotalError; break; default: iValue = 0; ASSERT(0); diff --git a/stepmania/src/ScreenEvaluationMultiplayer.cpp b/stepmania/src/ScreenEvaluationMultiplayer.cpp index e5453f8799..c8c96bb238 100644 --- a/stepmania/src/ScreenEvaluationMultiplayer.cpp +++ b/stepmania/src/ScreenEvaluationMultiplayer.cpp @@ -15,11 +15,11 @@ static const CString JudgeLineNames[] = { - "Marvelous", - "Perfect", - "Great", - "Good", - "Boo", + "Tier1", + "Tier2", + "Tier3", + "Tier4", + "Tier5", "Miss", "Ok", }; @@ -76,13 +76,13 @@ public: switch( i ) { default: ASSERT(0); - case JudgeLine_Marvelous: iVal = pPlayerStageStats->iTapNoteScores[TNS_MARVELOUS];break; - case JudgeLine_Perfect: iVal = pPlayerStageStats->iTapNoteScores[TNS_PERFECT]; break; - case JudgeLine_Great: iVal = pPlayerStageStats->iTapNoteScores[TNS_GREAT]; break; - case JudgeLine_Good: iVal = pPlayerStageStats->iTapNoteScores[TNS_GOOD]; break; - case JudgeLine_Boo: iVal = pPlayerStageStats->iTapNoteScores[TNS_BOO]; break; - case JudgeLine_Miss: iVal = pPlayerStageStats->iTapNoteScores[TNS_MISS]; break; - case JudgeLine_Ok: iVal = pPlayerStageStats->iHoldNoteScores[HNS_OK]; break; + case JudgeLine_Tier1: iVal = pPlayerStageStats->iTapNoteScores[TNS_Tier1];break; + case JudgeLine_Tier2: iVal = pPlayerStageStats->iTapNoteScores[TNS_Tier2]; break; + case JudgeLine_Tier3: iVal = pPlayerStageStats->iTapNoteScores[TNS_Tier3]; break; + case JudgeLine_Tier4: iVal = pPlayerStageStats->iTapNoteScores[TNS_Tier4]; break; + case JudgeLine_Tier5: iVal = pPlayerStageStats->iTapNoteScores[TNS_Tier5]; break; + case JudgeLine_Miss: iVal = pPlayerStageStats->iTapNoteScores[TNS_Miss]; break; + case JudgeLine_Ok: iVal = pPlayerStageStats->iHoldNoteScores[HNS_Held]; break; } CString s = ssprintf( "%3d", iVal ); @@ -149,10 +149,10 @@ ScreenEvaluationMultiplayer::ScreenEvaluationMultiplayer( CString sClassName ) : { STATSMAN->m_CurStageStats.m_multiPlayer[p].bFailedEarlier = true; } - STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_MARVELOUS] = rand()%3; - STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_PERFECT] = rand()%3; - STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_GREAT] = rand()%3; - STATSMAN->m_CurStageStats.m_multiPlayer[p].iPossibleGradePoints = 4*ScoreKeeperMAX2::TapNoteScoreToGradePoints(TNS_MARVELOUS, false); + STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_Tier1] = rand()%3; + STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_Tier2] = rand()%3; + STATSMAN->m_CurStageStats.m_multiPlayer[p].iTapNoteScores[TNS_Tier3] = rand()%3; + STATSMAN->m_CurStageStats.m_multiPlayer[p].iPossibleGradePoints = 4*ScoreKeeperMAX2::TapNoteScoreToGradePoints(TNS_Tier1, false); STATSMAN->m_CurStageStats.m_multiPlayer[p].fLifeRemainingSeconds = randomf( 90, 580 ); } diff --git a/stepmania/src/ScreenEvaluationMultiplayer.h b/stepmania/src/ScreenEvaluationMultiplayer.h index 80dc6524a3..64ae7c8acd 100644 --- a/stepmania/src/ScreenEvaluationMultiplayer.h +++ b/stepmania/src/ScreenEvaluationMultiplayer.h @@ -7,11 +7,11 @@ class MultiplayerEvalScoreRow; enum JudgeLine { - JudgeLine_Marvelous, - JudgeLine_Perfect, - JudgeLine_Great, - JudgeLine_Good, - JudgeLine_Boo, + JudgeLine_Tier1, + JudgeLine_Tier2, + JudgeLine_Tier3, + JudgeLine_Tier4, + JudgeLine_Tier5, JudgeLine_Miss, JudgeLine_Ok, NUM_JudgeLine, diff --git a/stepmania/src/ScreenGameplay.cpp b/stepmania/src/ScreenGameplay.cpp index eb5bc7779c..c036478051 100644 --- a/stepmania/src/ScreenGameplay.cpp +++ b/stepmania/src/ScreenGameplay.cpp @@ -1744,12 +1744,12 @@ void ScreenGameplay::Update( float fDeltaTime ) switch( tns ) { - case TNS_GOOD: - case TNS_GREAT: + case TNS_Tier4: + case TNS_Tier3: state = AS2D_GOOD; break; - case TNS_PERFECT: - case TNS_MARVELOUS: + case TNS_Tier2: + case TNS_Tier1: state = AS2D_GREAT; break; default: diff --git a/stepmania/src/ScreenHowToPlay.cpp b/stepmania/src/ScreenHowToPlay.cpp index d5e73dc3f9..e86f54f8ee 100644 --- a/stepmania/src/ScreenHowToPlay.cpp +++ b/stepmania/src/ScreenHowToPlay.cpp @@ -22,7 +22,7 @@ #include "StatsManager.h" static const ThemeMetric STEPFILE ("ScreenHowToPlay","Stepfile"); -static const ThemeMetric NUM_PERFECTS ("ScreenHowToPlay","NumPerfects"); +static const ThemeMetric NUM_TIER2S ("ScreenHowToPlay","NumTier2s"); static const ThemeMetric NUM_MISSES ("ScreenHowToPlay","NumMisses"); static const ThemeMetric USELIFEBAR ("ScreenHowToPlay","UseLifeMeterBar"); static const ThemeMetric USECHARACTER ("ScreenHowToPlay","UseCharacter"); @@ -69,8 +69,8 @@ static bool HaveAllCharAnimations() REGISTER_SCREEN_CLASS( ScreenHowToPlay ); ScreenHowToPlay::ScreenHowToPlay( CString sName ) : ScreenAttract( sName ) { - m_iPerfects = 0; - m_iNumPerfects = NUM_PERFECTS; + m_iTier2s = 0; + m_iNumTier2s = NUM_TIER2S; // initialize these because they might not be used. m_pPlayer = NULL; @@ -128,7 +128,7 @@ void ScreenHowToPlay::Init() m_pLifeMeterBar->SetName("LifeMeterBar"); m_pLifeMeterBar->Load( GAMESTATE->m_pPlayerState[PLAYER_1], &STATSMAN->m_CurStageStats.m_player[PLAYER_1] ); SET_XY_AND_ON_COMMAND( m_pLifeMeterBar ); - m_pLifeMeterBar->FillForHowToPlay( NUM_PERFECTS, NUM_MISSES ); + m_pLifeMeterBar->FillForHowToPlay( NUM_TIER2S, NUM_MISSES ); } GAMESTATE->m_pCurStyle.Set( GAMEMAN->GetHowToPlayStyleForGame(GAMESTATE->m_pCurGame) ); @@ -205,7 +205,7 @@ void ScreenHowToPlay::Step() int iStep = 0; const int iNoteRow = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat + 0.6f ); // if we want to miss from here on out, don't process steps. - if( m_iPerfects < m_iNumPerfects && m_NoteData.IsThereATapAtRow( iNoteRow ) ) + if( m_iTier2s < m_iNumTier2s && m_NoteData.IsThereATapAtRow( iNoteRow ) ) { const int iNumTracks = m_NoteData.GetNumTracks(); for( int k=0; kChangeLife(TNS_PERFECT); + if ( m_iTier2s < m_iNumTier2s ) + m_pLifeMeterBar->ChangeLife(TNS_Tier2); else - m_pLifeMeterBar->ChangeLife(TNS_MISS); + m_pLifeMeterBar->ChangeLife(TNS_Miss); } - m_iPerfects++; + m_iTier2s++; iLastNoteRowCounted = iCurNoteRow; } // once we hit the number of perfects we want, we want to fail. // switch the controller to HUMAN. since we aren't taking input, // the steps will always be misses. - if(m_iPerfects > m_iNumPerfects) + if(m_iTier2s > m_iNumTier2s) GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerController = PC_HUMAN; if ( m_pmCharacter ) diff --git a/stepmania/src/ScreenHowToPlay.h b/stepmania/src/ScreenHowToPlay.h index ba455dfb42..74099d63d0 100644 --- a/stepmania/src/ScreenHowToPlay.h +++ b/stepmania/src/ScreenHowToPlay.h @@ -26,8 +26,8 @@ protected: Player* m_pPlayer; Model* m_pmCharacter; Model* m_pmDancePad; - int m_iPerfects; - int m_iNumPerfects; + int m_iTier2s; + int m_iNumTier2s; Song m_Song; NoteData m_NoteData; diff --git a/stepmania/src/ScreenNameEntry.cpp b/stepmania/src/ScreenNameEntry.cpp index 6f639b59d0..025131e7ed 100644 --- a/stepmania/src/ScreenNameEntry.cpp +++ b/stepmania/src/ScreenNameEntry.cpp @@ -358,7 +358,7 @@ void ScreenNameEntry::Input( const InputEventPlus &input ) int iStringIndex = m_ColToStringIndex[input.StyleI.player][input.StyleI.col]; if( iStringIndex != -1 ) { - m_ReceptorArrowRow[input.StyleI.player].Step( input.StyleI.col, TNS_MARVELOUS ); + m_ReceptorArrowRow[input.StyleI.player].Step( input.StyleI.col, TNS_Tier1 ); m_soundStep.Play(); char c = NAME_CHARS[GetClosestCharIndex(m_fFakeBeat)]; m_textSelectedChars[input.StyleI.player][input.StyleI.col].SetText( ssprintf("%c",c) ); diff --git a/stepmania/src/ScreenOptionsMasterPrefs.cpp b/stepmania/src/ScreenOptionsMasterPrefs.cpp index 076cf89452..f62ebe3f3b 100644 --- a/stepmania/src/ScreenOptionsMasterPrefs.cpp +++ b/stepmania/src/ScreenOptionsMasterPrefs.cpp @@ -308,10 +308,10 @@ MOVE( AllowExtraStage, PREFSMAN->m_bAllowExtraStage ); MOVE( PickExtraStage, PREFSMAN->m_bPickExtraStage ); MOVE( UnlockSystem, PREFSMAN->m_bUseUnlockSystem ); -static void MarvelousTiming( int &sel, bool ToSel, const ConfOption *pConfOption ) +static void Tier1Timing( int &sel, bool ToSel, const ConfOption *pConfOption ) { - const PrefsManager::MarvelousTiming mapping[] = { PrefsManager::MARVELOUS_NEVER, PrefsManager::MARVELOUS_COURSES_ONLY, PrefsManager::MARVELOUS_EVERYWHERE }; - MoveMap( sel, PREFSMAN->m_MarvelousTiming, ToSel, mapping, ARRAYSIZE(mapping) ); + const PrefsManager::Tier1Timing mapping[] = { PrefsManager::TIER1_NEVER, PrefsManager::TIER1_COURSES_ONLY, PrefsManager::TIER1_EVERYWHERE }; + MoveMap( sel, PREFSMAN->m_Tier1Timing, ToSel, mapping, ARRAYSIZE(mapping) ); } static void CoinModeM( int &sel, bool ToSel, const ConfOption *pConfOption ) @@ -570,7 +570,7 @@ static void InitializeConfOptions() ADD( ConfOption( "SoloSingles", SoloSingles, "OFF","ON" ) ); ADD( ConfOption( "HiddenSongs", MovePref, "OFF","ON" ) ); ADD( ConfOption( "EasterEggs", EasterEggs, "OFF","ON" ) ); - ADD( ConfOption( "MarvelousTiming", MarvelousTiming, "NEVER","COURSES ONLY","ALWAYS" ) ); + ADD( ConfOption( "Tier1Timing", Tier1Timing, "NEVER","COURSES ONLY","ALWAYS" ) ); ADD( ConfOption( "AllowExtraStage", AllowExtraStage, "OFF","ON" ) ); ADD( ConfOption( "PickExtraStage", PickExtraStage, "OFF","ON" ) ); ADD( ConfOption( "UnlockSystem", UnlockSystem, "OFF","ON" ) );