actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use generic names for TapNoteScore values since they are treated genericly by the code.

Browse Source 
Theme changes coming...
This commit is contained in:
Chris Danford
2005-10-08 00:57:40 +00:00
parent 833acb950d
commit b6cf3477b4
45 changed files with 646 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files
stepmania/src/CombinedLifeMeterTug.cpp
+9 -9
View File
@@ -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;
}
stepmania/src/Combo.cpp
+14 -14
View File
@@ -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
{
stepmania/src/Combo.h
+3 -3
View File
@@ -33,9 +33,9 @@ protected:
ThemeMetric<float> NUMBER_MAX_ZOOM_AT;
ThemeMetric<apActorCommands> PULSE_COMMAND;
ThemeMetric<float> TWEEN_SECONDS;
ThemeMetric<apActorCommands> FULL_COMBO_GREATS_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_PERFECTS_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_MARVELOUSES_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_TIER3_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_TIER2_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_TIER1_COMMAND;
ThemeMetric<apActorCommands> FULL_COMBO_BROKEN_COMMAND;
ThemeMetric<bool> SHOW_MISS_COMBO;
stepmania/src/Game.cpp
+5 -5
View File
@@ -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;
}
}
stepmania/src/Game.h
+5 -5
View File
@@ -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
stepmania/src/GameConstantsAndTypes.cpp
+56 -23
View File
@@ -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 );
stepmania/src/GameConstantsAndTypes.h
+17 -16
View File
@@ -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 );
stepmania/src/GameManager.cpp
+50 -50
View File
@@ -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
},
};
stepmania/src/GameState.cpp
+5 -5
View File
@@ -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);
}
}
stepmania/src/GameState.h
+1 -1
View File
@@ -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<CString> m_sPreferredSongGroup; // GROUP_ALL denotes no preferred group
stepmania/src/HighScore.cpp
+4 -4
View File
@@ -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 );
stepmania/src/HoldJudgment.cpp
+3 -3
View File
@@ -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;
stepmania/src/Judgment.cpp
+17 -17
View File
@@ -6,12 +6,12 @@
#include "ThemeManager.h"
#include "ThemeMetric.h"
static ThemeMetric<apActorCommands> MARVELOUS_COMMAND ("Judgment","MarvelousCommand");
static ThemeMetric<apActorCommands> PERFECT_COMMAND ("Judgment","PerfectCommand");
static ThemeMetric<apActorCommands> GREAT_COMMAND ("Judgment","GreatCommand");
static ThemeMetric<apActorCommands> GOOD_COMMAND ("Judgment","GoodCommand");
static ThemeMetric<apActorCommands> BOO_COMMAND ("Judgment","BooCommand");
static ThemeMetric<apActorCommands> MISS_COMMAND ("Judgment","MissCommand");
static ThemeMetric<apActorCommands> TIER1_COMMAND ("Judgment","Tier1Command");
static ThemeMetric<apActorCommands> TIER2_COMMAND ("Judgment","Tier2Command");
static ThemeMetric<apActorCommands> TIER3_COMMAND ("Judgment","Tier3Command");
static ThemeMetric<apActorCommands> TIER4_COMMAND ("Judgment","Tier4Command");
static ThemeMetric<apActorCommands> TIER5_COMMAND ("Judgment","Tier5Command");
static ThemeMetric<apActorCommands> 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;
stepmania/src/LifeMeterBar.cpp
+32 -32
View File
@@ -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();
}
stepmania/src/LifeMeterBar.h
+1 -1
View File
@@ -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:
stepmania/src/LifeMeterBattery.cpp
+10 -10
View File
@@ -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);
stepmania/src/LifeMeterTime.cpp
+9 -9
View File
@@ -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);
}
stepmania/src/NetworkSyncManager.cpp
+2 -2
View File
@@ -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 (((step<TNS_BOO)||(step>TNS_MARVELOUS))&&(step!=TNS_HIT_MINE))
if (((step<TNS_Tier5)||(step>TNS_Tier1))&&(step!=TNS_HitMine))
iOffset = 0;
m_packet.Write2((uint16_t) iOffset);
stepmania/src/NetworkSyncServer.cpp
+5 -5
View File
@@ -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;
}
}
stepmania/src/NoteDataWithScoring.cpp
+19 -19
View File
@@ -72,7 +72,7 @@ int GetSuccessfulMines( const NoteData &in, int iStartIndex = 0, int iEndIndex =
for( int t=0; t<in.GetNumTracks(); t++ )
{
const TapNote &tn = in.GetTapNote(t,i);
if( tn.type == TapNote::mine && tn.result.tns == TNS_AVOIDED_MINE )
if( tn.type == TapNote::mine && tn.result.tns == TNS_AvoidMine )
iNumSuccessfulMinesNotes++;
}
}
@@ -97,7 +97,7 @@ int GetSuccessfulHands( const NoteData &in, int iStartIndex = 0, int iEndIndex =
continue;
if( tn.type == TapNote::mine ) // mines don't count
continue;
if( tn.result.tns <= TNS_BOO )
if( tn.result.tns <= TNS_Tier5 )
Missed = true;
}
@@ -130,7 +130,7 @@ int GetSuccessfulHands( const NoteData &in, int iStartIndex = 0, int iEndIndex =
/* Return the last tap score of a row: the grade of the tap that completed
* the row. If the row has no tap notes, return -1. If any tap notes aren't
* graded (any tap is TNS_NONE) or are missed (TNS_MISS), return it. */
* graded (any tap is TNS_None) or are missed (TNS_Miss), return it. */
int LastTapNoteScoreTrack( const NoteData &in, unsigned iRow )
{
float scoretime = -9999;
@@ -144,7 +144,7 @@ int LastTapNoteScoreTrack( const NoteData &in, unsigned iRow )
TapNoteScore tns = tn.result.tns;
if( tns == TNS_MISS || tns == TNS_NONE )
if( tns == TNS_Miss || tns == TNS_None )
return t;
float tm = tn.result.fTapNoteOffset;
@@ -169,13 +169,13 @@ TapNoteResult NoteDataWithScoring::LastTapNoteResult( const NoteData &in, unsign
/* Return the minimum tap score of a row. If the row isn't complete (not all
* taps have been hit), return TNS_NONE or TNS_MISS. */
* taps have been hit), return TNS_None or TNS_Miss. */
TapNoteScore NoteDataWithScoring::MinTapNoteScore( const NoteData &in, unsigned row )
{
TapNoteScore score = TNS_MARVELOUS;
TapNoteScore score = TNS_Tier1;
for( int t=0; t<in.GetNumTracks(); t++ )
{
/* Ignore mines, or the score will always be TNS_NONE. */
/* Ignore mines, or the score will always be TNS_None. */
const TapNote &tn = in.GetTapNote(t, row);
if( tn.type == TapNote::empty || tn.type == TapNote::mine )
continue;
@@ -187,20 +187,20 @@ TapNoteScore NoteDataWithScoring::MinTapNoteScore( const NoteData &in, unsigned
bool NoteDataWithScoring::IsRowCompletelyJudged( const NoteData &in, unsigned row )
{
return MinTapNoteScore( in, row ) >= 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);
}
}
stepmania/src/NoteField.cpp
+1 -1
View File
@@ -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;
stepmania/src/NoteTypes.h
+4 -4
View File
@@ -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].
stepmania/src/Player.cpp
+74 -74
View File
@@ -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; t<m_NoteData.GetNumTracks(); t++ )
{
TapNote tn = m_NoteData.GetTapNote(t, iNoteRow);
if( tn.type != TapNote::empty && tn.result.tns == TNS_NONE )
if( tn.type != TapNote::empty && tn.result.tns == TNS_None )
{
Step( t, now );
STATSMAN->m_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()
stepmania/src/PlayerAI.cpp
+13 -13
View File
@@ -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; j<NUM_TAP_NOTE_SCORES; j++ )
for( int j=0; j<NUM_TapNoteScore; j++ )
fSum += dist.fPercent[j];
for( int j=0; j<NUM_TAP_NOTE_SCORES; j++ )
for( int j=0; j<NUM_TapNoteScore; j++ )
dist.fPercent[j] /= fSum;
}
}
@@ -64,7 +64,7 @@ void PlayerAI::InitFromDisk()
TapNoteScore PlayerAI::GetTapNoteScore( const PlayerState* pPlayerState )
{
if( pPlayerState->m_PlayerController == PC_AUTOPLAY )
return TNS_MARVELOUS;
return TNS_Tier1;
int iCpuSkill = pPlayerState->m_iCpuSkill;
stepmania/src/PlayerStageStats.cpp
+43 -43
View File
@@ -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; t<NUM_TAP_NOTE_SCORES; t++ )
for( int t=0; t<NUM_TapNoteScore; t++ )
iTapNoteScores[t] += other.iTapNoteScores[t];
for( int h=0; h<NUM_HOLD_NOTE_SCORES; h++ )
for( int h=0; h<NUM_HoldNoteScore; h++ )
iHoldNoteScores[h] += other.iHoldNoteScores[h];
iCurCombo += other.iCurCombo;
iMaxCombo += other.iMaxCombo;
@@ -173,23 +173,23 @@ Grade PlayerStageStats::GetGrade() const
LOG->Trace( "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<tnsAllGreaterOrEqual; i++ )
for( int i=TNS_Miss; i<tnsAllGreaterOrEqual; i++ )
{
if( iTapNoteScores[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<NUM_TAP_NOTE_SCORES; i++ )
for( int i=tnsAllGreaterOrEqual; i<NUM_TapNoteScore; i++ )
{
if( iTapNoteScores[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; i<NUM_TAP_NOTE_SCORES; i++ )
for( int i=TNS_Miss; i<NUM_TapNoteScore; i++ )
{
iTotalTaps += iTapNoteScores[i];
}
@@ -502,7 +502,7 @@ int PlayerStageStats::GetTotalTaps() const
float PlayerStageStats::GetPercentageOfTaps( TapNoteScore tns ) const
{
int iTotalTaps = 0;
for( int i=TNS_MISS; i<NUM_TAP_NOTE_SCORES; i++ )
for( int i=TNS_Miss; i<NUM_TapNoteScore; i++ )
{
iTotalTaps += iTapNoteScores[i];
}
@@ -526,28 +526,28 @@ void PlayerStageStats::CalcAwards( PlayerNumber p, bool bGaveUp, bool bUsedAutop
// don't give per-difficutly awards if using easy mods
if( !GAMESTATE->IsDisqualified(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 );
}
stepmania/src/PlayerStageStats.h
+3 -3
View File
@@ -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;
stepmania/src/Preference.cpp
+1 -1
View File
@@ -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& )
stepmania/src/PrefsManager.cpp
+49 -49
View File
@@ -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 ),
stepmania/src/PrefsManager.h
+50 -50
View File
@@ -61,37 +61,37 @@ public:
Preference<float> m_fJudgeWindowScale;
Preference<float> m_fJudgeWindowAdd; // this is useful for compensating for changes in sampling rate between devices
Preference<float> m_fJudgeWindowSecondsMarvelous;
Preference<float> m_fJudgeWindowSecondsPerfect;
Preference<float> m_fJudgeWindowSecondsGreat;
Preference<float> m_fJudgeWindowSecondsGood;
Preference<float> m_fJudgeWindowSecondsBoo;
Preference<float> m_fJudgeWindowSecondsOK;
Preference<float> m_fJudgeWindowSecondsTier1;
Preference<float> m_fJudgeWindowSecondsTier2;
Preference<float> m_fJudgeWindowSecondsTier3;
Preference<float> m_fJudgeWindowSecondsTier4;
Preference<float> m_fJudgeWindowSecondsTier5;
Preference<float> m_fJudgeWindowSecondsHeld;
Preference<float> m_fJudgeWindowSecondsRoll;
Preference<float> m_fJudgeWindowSecondsMine;
Preference<float> m_fJudgeWindowSecondsAttack;
Preference<float> m_fLifeDifficultyScale;
Preference<float> m_fLifeDeltaPercentChangeMarvelous;
Preference<float> m_fLifeDeltaPercentChangePerfect;
Preference<float> m_fLifeDeltaPercentChangeGreat;
Preference<float> m_fLifeDeltaPercentChangeGood;
Preference<float> m_fLifeDeltaPercentChangeBoo;
Preference<float> m_fLifeDeltaPercentChangeTier1;
Preference<float> m_fLifeDeltaPercentChangeTier2;
Preference<float> m_fLifeDeltaPercentChangeTier3;
Preference<float> m_fLifeDeltaPercentChangeTier4;
Preference<float> m_fLifeDeltaPercentChangeTier5;
Preference<float> m_fLifeDeltaPercentChangeMiss;
Preference<float> m_fLifeDeltaPercentChangeHitMine;
Preference<float> m_fLifeDeltaPercentChangeOK;
Preference<float> m_fLifeDeltaPercentChangeNG;
Preference<float> m_fLifeDeltaPercentChangeHeld;
Preference<float> m_fLifeDeltaPercentChangeLetGo;
// tug meter used in rave
Preference<float> m_fTugMeterPercentChangeMarvelous;
Preference<float> m_fTugMeterPercentChangePerfect;
Preference<float> m_fTugMeterPercentChangeGreat;
Preference<float> m_fTugMeterPercentChangeGood;
Preference<float> m_fTugMeterPercentChangeBoo;
Preference<float> m_fTugMeterPercentChangeTier1;
Preference<float> m_fTugMeterPercentChangeTier2;
Preference<float> m_fTugMeterPercentChangeTier3;
Preference<float> m_fTugMeterPercentChangeTier4;
Preference<float> m_fTugMeterPercentChangeTier5;
Preference<float> m_fTugMeterPercentChangeMiss;
Preference<float> m_fTugMeterPercentChangeHitMine;
Preference<float> m_fTugMeterPercentChangeOK;
Preference<float> m_fTugMeterPercentChangeNG;
Preference<float> m_fTugMeterPercentChangeHeld;
Preference<float> m_fTugMeterPercentChangeLetGo;
// Whoever added these: Please add a comment saying what they do. -Chris
Preference<int> m_iRegenComboAfterFail;
@@ -106,49 +106,49 @@ public:
Preference<bool> 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<int> m_iPercentScoreWeightMarvelous;
Preference<int> m_iPercentScoreWeightPerfect;
Preference<int> m_iPercentScoreWeightGreat;
Preference<int> m_iPercentScoreWeightGood;
Preference<int> m_iPercentScoreWeightBoo;
Preference<int> m_iPercentScoreWeightTier1;
Preference<int> m_iPercentScoreWeightTier2;
Preference<int> m_iPercentScoreWeightTier3;
Preference<int> m_iPercentScoreWeightTier4;
Preference<int> m_iPercentScoreWeightTier5;
Preference<int> m_iPercentScoreWeightMiss;
Preference<int> m_iPercentScoreWeightHitMine;
Preference<int> m_iPercentScoreWeightOK;
Preference<int> m_iPercentScoreWeightNG;
Preference<int> m_iPercentScoreWeightHeld;
Preference<int> m_iPercentScoreWeightLetGo;
// grades are calculated based on a percentage, but might have different weights than the percent score
Preference<int> m_iGradeWeightMarvelous;
Preference<int> m_iGradeWeightPerfect;
Preference<int> m_iGradeWeightGreat;
Preference<int> m_iGradeWeightGood;
Preference<int> m_iGradeWeightBoo;
Preference<int> m_iGradeWeightTier1;
Preference<int> m_iGradeWeightTier2;
Preference<int> m_iGradeWeightTier3;
Preference<int> m_iGradeWeightTier4;
Preference<int> m_iGradeWeightTier5;
Preference<int> m_iGradeWeightMiss;
Preference<int> m_iGradeWeightHitMine;
Preference<int> m_iGradeWeightOK;
Preference<int> m_iGradeWeightNG;
Preference<int> m_iGradeWeightHeld;
Preference<int> m_iGradeWeightLetGo;
// super meter used in rave
Preference<float> m_fSuperMeterPercentChangeMarvelous;
Preference<float> m_fSuperMeterPercentChangePerfect;
Preference<float> m_fSuperMeterPercentChangeGreat;
Preference<float> m_fSuperMeterPercentChangeGood;
Preference<float> m_fSuperMeterPercentChangeBoo;
Preference<float> m_fSuperMeterPercentChangeTier1;
Preference<float> m_fSuperMeterPercentChangeTier2;
Preference<float> m_fSuperMeterPercentChangeTier3;
Preference<float> m_fSuperMeterPercentChangeTier4;
Preference<float> m_fSuperMeterPercentChangeTier5;
Preference<float> m_fSuperMeterPercentChangeMiss;
Preference<float> m_fSuperMeterPercentChangeHitMine;
Preference<float> m_fSuperMeterPercentChangeOK;
Preference<float> m_fSuperMeterPercentChangeNG;
Preference<float> m_fSuperMeterPercentChangeHeld;
Preference<float> m_fSuperMeterPercentChangeLetGo;
Preference<float> m_bMercifulSuperMeter; // negative super deltas are scaled by the players life percentage
// time meter used in survival
Preference<float> m_fTimeMeterSecondsChangeMarvelous;
Preference<float> m_fTimeMeterSecondsChangePerfect;
Preference<float> m_fTimeMeterSecondsChangeGreat;
Preference<float> m_fTimeMeterSecondsChangeGood;
Preference<float> m_fTimeMeterSecondsChangeBoo;
Preference<float> m_fTimeMeterSecondsChangeTier1;
Preference<float> m_fTimeMeterSecondsChangeTier2;
Preference<float> m_fTimeMeterSecondsChangeTier3;
Preference<float> m_fTimeMeterSecondsChangeTier4;
Preference<float> m_fTimeMeterSecondsChangeTier5;
Preference<float> m_fTimeMeterSecondsChangeMiss;
Preference<float> m_fTimeMeterSecondsChangeHitMine;
Preference<float> m_fTimeMeterSecondsChangeOK;
Preference<float> m_fTimeMeterSecondsChangeNG;
Preference<float> m_fTimeMeterSecondsChangeHeld;
Preference<float> m_fTimeMeterSecondsChangeLetGo;
Preference<PlayerController> m_AutoPlay;
Preference<bool> m_bDelayedBack;
@@ -161,8 +161,8 @@ public:
Preference<MusicWheelUsesSections> m_MusicWheelUsesSections;
Preference<int> m_iMusicWheelSwitchSpeed;
Preference<bool> m_bEasterEggs;
enum MarvelousTiming { MARVELOUS_NEVER, MARVELOUS_COURSES_ONLY, MARVELOUS_EVERYWHERE };
Preference<MarvelousTiming> m_MarvelousTiming;
enum Tier1Timing { TIER1_NEVER, TIER1_COURSES_ONLY, TIER1_EVERYWHERE };
Preference<Tier1Timing> m_Tier1Timing;
Preference<bool> m_bEventMode;
Preference<int> m_iCoinsPerCredit;
Preference<int> m_iSongsPerPlay;
stepmania/src/Profile.cpp
-1
View File
@@ -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
stepmania/src/ReceptorArrow.h
+1 -1
View File
@@ -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;
stepmania/src/ScoreDisplayLifeTime.cpp
+9 -9
View File
@@ -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);
}
stepmania/src/ScoreKeeperMAX2.cpp
+60 -60
View File
@@ -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 )
stepmania/src/ScoreKeeperMAX2.h
+1 -1
View File
@@ -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(
stepmania/src/ScoreKeeperRave.cpp
+8 -8
View File
@@ -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 );
}
stepmania/src/ScreenEdit.cpp
+1 -1
View File
@@ -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:
stepmania/src/ScreenEnding.cpp
+6 -6
View File
@@ -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();
}
stepmania/src/ScreenEvaluation.cpp
+13 -13
View File
@@ -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; l<NUM_JUDGE_LINES; l++ )
{
if( l == 0 && !GAMESTATE->ShowMarvelous() )
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);
stepmania/src/ScreenEvaluationMultiplayer.cpp
+16 -16
View File
@@ -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 );
}
stepmania/src/ScreenEvaluationMultiplayer.h
+5 -5
View File
@@ -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,
stepmania/src/ScreenGameplay.cpp
+4 -4
View File
@@ -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:
stepmania/src/ScreenHowToPlay.cpp
+10 -10
View File
@@ -22,7 +22,7 @@
#include "StatsManager.h"
static const ThemeMetric<CString> STEPFILE ("ScreenHowToPlay","Stepfile");
static const ThemeMetric<int> NUM_PERFECTS ("ScreenHowToPlay","NumPerfects");
static const ThemeMetric<int> NUM_TIER2S ("ScreenHowToPlay","NumTier2s");
static const ThemeMetric<int> NUM_MISSES ("ScreenHowToPlay","NumMisses");
static const ThemeMetric<bool> USELIFEBAR ("ScreenHowToPlay","UseLifeMeterBar");
static const ThemeMetric<bool> 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; k<iNumTracks; k++ )
@@ -248,19 +248,19 @@ void ScreenHowToPlay::Update( float fDelta )
{
if( m_pLifeMeterBar && !m_pPlayer )
{
if ( m_iPerfects < m_iNumPerfects )
m_pLifeMeterBar->ChangeLife(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 )
stepmania/src/ScreenHowToPlay.h
+2 -2
View File
@@ -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;
stepmania/src/ScreenNameEntry.cpp
+1 -1
View File
@@ -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) );
stepmania/src/ScreenOptionsMasterPrefs.cpp
+4 -4
View File
@@ -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" ) );