save Preferred, Stage, Song, and Current modifiers separately. This eliminates the fragile mods store/restore.

stepmania/src/AdjustSync.cpp

@@ -64,7 +64,7 @@ static LocalizedString AUTOSYNC_SONG			( "AdjustSync", "Autosync Song" );
 static LocalizedString AUTOSYNC_MACHINE			( "AdjustSync", "Autosync Machine" );
 void AdjustSync::HandleAutosync( float fNoteOffBySeconds )
 {
-	if( GAMESTATE->m_SongOptions.m_AutosyncType == SongOptions::AUTOSYNC_OFF )
+	if( GAMESTATE->m_SongOptions.GetCurrent().m_AutosyncType == SongOptions::AUTOSYNC_OFF )
 		return;
 
 	s_fAutosyncOffset[s_iAutosyncOffsetSample] = fNoteOffBySeconds;
@@ -77,7 +77,7 @@ void AdjustSync::HandleAutosync( float fNoteOffBySeconds )
 	const float stddev = calc_stddev( s_fAutosyncOffset, s_fAutosyncOffset+SAMPLE_COUNT );
 
 	RString sAutosyncType;
-	switch( GAMESTATE->m_SongOptions.m_AutosyncType )
+	switch( GAMESTATE->m_SongOptions.GetCurrent().m_AutosyncType )
 	{
 	case SongOptions::AUTOSYNC_SONG:
 		sAutosyncType = AUTOSYNC_SONG;
@@ -91,7 +91,7 @@ void AdjustSync::HandleAutosync( float fNoteOffBySeconds )
 
 	if( stddev < .03 )  // If they stepped with less than .03 error
 	{
-		switch( GAMESTATE->m_SongOptions.m_AutosyncType )
+		switch( GAMESTATE->m_SongOptions.GetCurrent().m_AutosyncType )
 		{
 		case SongOptions::AUTOSYNC_SONG:
 			GAMESTATE->m_pCurSong->m_Timing.m_fBeat0OffsetInSeconds += mean;

stepmania/src/ArrowEffects.cpp

@@ -18,7 +18,7 @@ const float ARROW_SPACING	= ARROW_SIZE;// + 2;
 
 static float GetNoteFieldHeight( const PlayerState* pPlayerState )
 {
-	return SCREEN_HEIGHT + fabsf(pPlayerState->m_CurrentPlayerOptions.m_fPerspectiveTilt)*200;
+	return SCREEN_HEIGHT + fabsf(pPlayerState->m_PlayerOptions.GetCurrent().m_fPerspectiveTilt)*200;
 }
 
 namespace
@@ -180,31 +180,31 @@ float ArrowEffects::GetYOffset( const PlayerState* pPlayerState, int iCol, float
 
 	/* Usually, fTimeSpacing is 0 or 1, in which case we use entirely beat spacing or
 	 * entirely time spacing (respectively).  Occasionally, we tween between them. */
-	if( pPlayerState->m_CurrentPlayerOptions.m_fTimeSpacing != 1.0f )
+	if( pPlayerState->m_PlayerOptions.GetCurrent().m_fTimeSpacing != 1.0f )
 	{
 		float fSongBeat = GAMESTATE->m_fSongBeat;
 		float fBeatsUntilStep = fNoteBeat - fSongBeat;
 		float fYOffsetBeatSpacing = fBeatsUntilStep * ARROW_SPACING;
-		fYOffset += fYOffsetBeatSpacing * (1-pPlayerState->m_CurrentPlayerOptions.m_fTimeSpacing);
+		fYOffset += fYOffsetBeatSpacing * (1-pPlayerState->m_PlayerOptions.GetCurrent().m_fTimeSpacing);
 	}
 
-	if( pPlayerState->m_CurrentPlayerOptions.m_fTimeSpacing != 0.0f )
+	if( pPlayerState->m_PlayerOptions.GetCurrent().m_fTimeSpacing != 0.0f )
 	{
 		float fSongSeconds = GAMESTATE->m_fMusicSeconds;
 		float fNoteSeconds = GAMESTATE->m_pCurSong->GetElapsedTimeFromBeat(fNoteBeat);
 		float fSecondsUntilStep = fNoteSeconds - fSongSeconds;
-		float fBPM = pPlayerState->m_CurrentPlayerOptions.m_fScrollBPM;
+		float fBPM = pPlayerState->m_PlayerOptions.GetCurrent().m_fScrollBPM;
 		float fBPS = fBPM/60.f;
 		float fYOffsetTimeSpacing = fSecondsUntilStep * fBPS * ARROW_SPACING;
-		fYOffset += fYOffsetTimeSpacing * pPlayerState->m_CurrentPlayerOptions.m_fTimeSpacing;
+		fYOffset += fYOffsetTimeSpacing * pPlayerState->m_PlayerOptions.GetCurrent().m_fTimeSpacing;
 	}
 
 	// don't mess with the arrows after they've crossed 0
 	if( fYOffset < 0 )
-		return fYOffset * pPlayerState->m_CurrentPlayerOptions.m_fScrollSpeed;
+		return fYOffset * pPlayerState->m_PlayerOptions.GetCurrent().m_fScrollSpeed;
 
-	const float* fAccels = pPlayerState->m_CurrentPlayerOptions.m_fAccels;
+	const float* fAccels = pPlayerState->m_PlayerOptions.GetCurrent().m_fAccels;
-	//const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	//const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 
 
 	float fYAdjust = 0;	// fill this in depending on PlayerOptions
@@ -248,8 +248,8 @@ float ArrowEffects::GetYOffset( const PlayerState* pPlayerState, int iCol, float
 	//
 	// Factor in scroll speed
 	//
-	float fScrollSpeed = pPlayerState->m_CurrentPlayerOptions.m_fScrollSpeed;
+	float fScrollSpeed = pPlayerState->m_PlayerOptions.GetCurrent().m_fScrollSpeed;
-	if( pPlayerState->m_CurrentPlayerOptions.m_fRandomSpeed > 0 && !bAbsolute )
+	if( pPlayerState->m_PlayerOptions.GetCurrent().m_fRandomSpeed > 0 && !bAbsolute )
 	{
 		int seed = GAMESTATE->m_iStageSeed + ( BeatToNoteRow( fNoteBeat ) << 8 ) + (iCol * 100);
 
@@ -263,7 +263,7 @@ float ArrowEffects::GetYOffset( const PlayerState* pPlayerState, int iCol, float
 		fScrollSpeed *=
 				SCALE( fRandom,
 						0.0f, 1.0f,
-						1.0f, pPlayerState->m_CurrentPlayerOptions.m_fRandomSpeed + 1.0f );
+						1.0f, pPlayerState->m_PlayerOptions.GetCurrent().m_fRandomSpeed + 1.0f );
 	}	
 
 
@@ -282,16 +282,16 @@ float ArrowEffects::GetYOffset( const PlayerState* pPlayerState, int iCol, float
 static void ArrowGetReverseShiftAndScale( const PlayerState* pPlayerState, int iCol, float fYReverseOffsetPixels, float &fShiftOut, float &fScaleOut )
 {
 	/* XXX: Hack: we need to scale the reverse shift by the zoom. */
-	float fTinyPercent = pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_TINY];
+	float fTinyPercent = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_TINY];
 	float fZoom = 1 - fTinyPercent*0.5f;
 	
 	// don't divide by 0
 	if( fabsf(fZoom) < 0.01 )
 		fZoom = 0.01f;
 
-	float fPercentReverse = pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(iCol);
+	float fPercentReverse = pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(iCol);
 	fShiftOut = SCALE( fPercentReverse, 0.f, 1.f, -fYReverseOffsetPixels/fZoom/2, fYReverseOffsetPixels/fZoom/2 );
-	float fPercentCentered = pPlayerState->m_CurrentPlayerOptions.m_fScrolls[PlayerOptions::SCROLL_CENTERED];
+	float fPercentCentered = pPlayerState->m_PlayerOptions.GetCurrent().m_fScrolls[PlayerOptions::SCROLL_CENTERED];
 	fShiftOut = SCALE( fPercentCentered, 0.f, 1.f, fShiftOut, 0.0f );
 
 	fScaleOut = SCALE( fPercentReverse, 0.f, 1.f, 1.f, -1.f );
@@ -310,7 +310,7 @@ float ArrowEffects::GetYPos( const PlayerState* pPlayerState, int iCol, float fY
 		f += fShift;
 	}
 
-	const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 
 	if( fEffects[PlayerOptions::EFFECT_TIPSY] != 0 )
 		f += fEffects[PlayerOptions::EFFECT_TIPSY] * ( RageFastCos( RageTimer::GetTimeSinceStartFast()*1.2f + iCol*1.8f) * ARROW_SIZE*0.4f );
@@ -321,7 +321,7 @@ float ArrowEffects::GetYOffsetFromYPos( const PlayerState* pPlayerState, int iCo
 {
 	float f = YPos;
 
-	const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 	if( fEffects[PlayerOptions::EFFECT_TIPSY] != 0 )
 		f -= fEffects[PlayerOptions::EFFECT_TIPSY] * ( RageFastCos( RageTimer::GetTimeSinceStartFast()*1.2f + iCol*2.f) * ARROW_SIZE*0.4f );
 
@@ -340,7 +340,7 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
 	float fPixelOffsetFromCenter = 0;	// fill this in below
 	
 	const Style* pStyle = GAMESTATE->GetCurrentStyle();
-	const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 
 	// TODO: Don't index by PlayerNumber.
 	const Style::ColumnInfo* pCols = pStyle->m_ColumnInfo[pPlayerState->m_PlayerNumber];
@@ -394,11 +394,11 @@ float ArrowEffects::GetXPos( const PlayerState* pPlayerState, int iColNum, float
 
 float ArrowEffects::GetRotation( const PlayerState* pPlayerState, float fNoteBeat ) 
 {
-	if( pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_DIZZY] != 0 )
+	if( pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_DIZZY] != 0 )
 	{
 		const float fSongBeat = GAMESTATE->m_fSongBeat;
 		float fDizzyRotation = fNoteBeat - fSongBeat;
-		fDizzyRotation *= pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_DIZZY];
+		fDizzyRotation *= pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_DIZZY];
 		fDizzyRotation = fmodf( fDizzyRotation, 2*PI );
 		fDizzyRotation *= 180/PI;
 		return fDizzyRotation;
@@ -415,14 +415,14 @@ static float GetCenterLine( const PlayerState* pPlayerState )
 {
 	/* Another mini hack: if EFFECT_MINI is on, then our center line is at eg. 320, 
 	 * not 160. */
-	const float fMiniPercent = pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_TINY];
+	const float fMiniPercent = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_TINY];
 	const float fZoom = 1 - fMiniPercent*0.5f;
 	return CENTER_LINE_Y / fZoom;
 }
 
 static float GetHiddenSudden( const PlayerState* pPlayerState ) 
 {
-	const float* fAppearances = pPlayerState->m_CurrentPlayerOptions.m_fAppearances;
+	const float* fAppearances = pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances;
 	return fAppearances[PlayerOptions::APPEARANCE_HIDDEN] *
 		fAppearances[PlayerOptions::APPEARANCE_SUDDEN];
 }
@@ -443,28 +443,28 @@ static float GetHiddenEndLine( const PlayerState* pPlayerState )
 {
 	return GetCenterLine( pPlayerState ) + 
 		FADE_DIST_Y * SCALE( GetHiddenSudden(pPlayerState), 0.f, 1.f, -1.0f, -1.25f ) + 
-		GetCenterLine( pPlayerState ) * pPlayerState->m_CurrentPlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN_OFFSET];
+		GetCenterLine( pPlayerState ) * pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN_OFFSET];
 }
 
 static float GetHiddenStartLine( const PlayerState* pPlayerState )
 {
 	return GetCenterLine( pPlayerState ) + 
 		FADE_DIST_Y * SCALE( GetHiddenSudden(pPlayerState), 0.f, 1.f, +0.0f, -0.25f ) + 
-		GetCenterLine( pPlayerState ) * pPlayerState->m_CurrentPlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN_OFFSET];
+		GetCenterLine( pPlayerState ) * pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN_OFFSET];
 }
 
 static float GetSuddenEndLine( const PlayerState* pPlayerState )
 {
 	return GetCenterLine( pPlayerState ) + 
 		FADE_DIST_Y * SCALE( GetHiddenSudden(pPlayerState), 0.f, 1.f, -0.0f, +0.25f ) + 
-		GetCenterLine( pPlayerState ) * pPlayerState->m_CurrentPlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_SUDDEN_OFFSET];
+		GetCenterLine( pPlayerState ) * pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances[PlayerOptions::APPEARANCE_SUDDEN_OFFSET];
 }
 
 static float GetSuddenStartLine( const PlayerState* pPlayerState )
 {
 	return GetCenterLine( pPlayerState ) + 
 		FADE_DIST_Y * SCALE( GetHiddenSudden(pPlayerState), 0.f, 1.f, +1.0f, +1.25f ) + 
-		GetCenterLine( pPlayerState ) * pPlayerState->m_CurrentPlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_SUDDEN_OFFSET];
+		GetCenterLine( pPlayerState ) * pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances[PlayerOptions::APPEARANCE_SUDDEN_OFFSET];
 }
 
 // used by ArrowGetAlpha and ArrowGetGlow below
@@ -478,7 +478,7 @@ float ArrowGetPercentVisible( const PlayerState* pPlayerState, int iCol, float f
 	if( fYPos < 0 )	// past Gray Arrows
 		return 1;	// totally visible
 
-	const float* fAppearances = pPlayerState->m_CurrentPlayerOptions.m_fAppearances;
+	const float* fAppearances = pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances;
 
 	float fVisibleAdjust = 0;
 
@@ -551,7 +551,7 @@ float ArrowEffects::GetBrightness( const PlayerState* pPlayerState, float fNoteB
 float ArrowEffects::GetZPos( const PlayerState* pPlayerState, int iCol, float fYOffset )
 {
 	float fZPos=0;
-	const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 
 	if( fEffects[PlayerOptions::EFFECT_BUMPY] != 0 )
 		fZPos += fEffects[PlayerOptions::EFFECT_BUMPY] * 40*RageFastSin( fYOffset/16.0f );
@@ -561,7 +561,7 @@ float ArrowEffects::GetZPos( const PlayerState* pPlayerState, int iCol, float fY
 
 bool ArrowEffects::NeedZBuffer( const PlayerState* pPlayerState )
 {
-	const float* fEffects = pPlayerState->m_CurrentPlayerOptions.m_fEffects;
+	const float* fEffects = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects;
 	if( fEffects[PlayerOptions::EFFECT_BUMPY] != 0 )
 		return true;
 
@@ -576,7 +576,7 @@ float ArrowEffects::GetZoom( const PlayerState* pPlayerState )
 		(GAMESTATE->GetNumSidesJoined()==2 || GAMESTATE->AnyPlayersAreCpu()) )
 		fZoom *= 0.6f;
 
-	float fMiniPercent = pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_MINI];
+	float fMiniPercent = pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_MINI];
 	if( fMiniPercent != 0 )
 	{
 		fMiniPercent = powf( 0.5f, fMiniPercent );

stepmania/src/Background.cpp

@@ -753,7 +753,7 @@ void BackgroundImpl::Layer::UpdateCurBGChange( const Song *pSong, float fLastMus
 	pSong->m_Timing.GetBeatAndBPSFromElapsedTime( fCurrentTime, fBeat, fBPS, bFreeze );
 
 	/* Calls to Update() should *not* be scaled by music rate; fCurrentTime is. Undo it. */
-	const float fRate = GAMESTATE->m_SongOptions.m_fMusicRate;
+	const float fRate = GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 	// Find the BGSegment we're in
 	const int i = FindBGSegmentForBeat( fBeat );
@@ -989,8 +989,8 @@ void BrightnessOverlay::Update( float fDeltaTime )
 
 void BrightnessOverlay::SetActualBrightness()
 {
-	float fLeftBrightness = 1-GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_fCover;
+	float fLeftBrightness = 1-GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.GetCurrent().m_fCover;
-	float fRightBrightness = 1-GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.m_fCover;
+	float fRightBrightness = 1-GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.GetCurrent().m_fCover;
 
 	float fBaseBGBrightness = PREFSMAN->m_fBGBrightness;
 

stepmania/src/CodeDetector.cpp

@@ -215,9 +215,6 @@ bool CodeDetector::EnteredModeMenu( GameController controller )
 #define  INCREMENT_SCROLL_SPEED(s)	(s==0.5f) ? s=0.75f : (s==0.75f) ? s=1.0f : (s==1.0f) ? s=1.5f : (s==1.5f) ? s=2.0f : (s==2.0f) ? s=3.0f : (s==3.0f) ? s=4.0f : (s==4.0f) ? s=5.0f : (s==5.0f) ? s=8.0f : s=0.5f;
 #define  DECREMENT_SCROLL_SPEED(s)	(s==0.75f) ? s=0.5f : (s==1.0f) ? s=0.75f : (s==1.5f) ? s=1.0f : (s==2.0f) ? s=1.5f : (s==3.0f) ? s=2.0f : (s==4.0f) ? s=3.0f : (s==5.0f) ? s=4.0f : (s==8.0f) ? s=4.0f : s=8.0f;
 
-#define  TOGGLE_HIDDEN ZERO(GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_fAppearances); GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN] = 1; 
-#define  TOGGLE_RANDOMVANISH ZERO(GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_fAppearances); GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH] = 1;
-
 bool CodeDetector::DetectAndAdjustMusicOptions( GameController controller )
 {
 	const Style* pStyle = GAMESTATE->GetCurrentStyle();
@@ -227,7 +224,7 @@ bool CodeDetector::DetectAndAdjustMusicOptions( GameController controller )
 	{
 		Code code = (Code)c;
 		
-		PlayerOptions& po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions;
+		PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred();
 
 		if( EnteredCode(controller,code) )
 		{
@@ -250,10 +247,20 @@ bool CodeDetector::DetectAndAdjustMusicOptions( GameController controller )
 			case CODE_MINES:			TOGGLE( po.m_bTransforms[PlayerOptions::TRANSFORM_NOMINES], true, false );	break;
 			case CODE_DARK:				FLOAT_TOGGLE( po.m_fDark );				break;
 			case CODE_CANCEL_ALL:			GAMESTATE->GetDefaultPlayerOptions( po );		break;
-			case CODE_HIDDEN:			TOGGLE_HIDDEN;						break;
+			case CODE_HIDDEN:
-			case CODE_RANDOMVANISH:			TOGGLE_RANDOMVANISH;					break;
+				ZERO(po.m_fAppearances);
+				po.m_fAppearances[PlayerOptions::APPEARANCE_HIDDEN] = 1;
+				break;
+			case CODE_RANDOMVANISH:
+				ZERO(po.m_fAppearances);
+				po.m_fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH] = 1;
+				break;
 			default:	break;
 			}
+
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, = po );
+
+
 			return true;	// don't check any more
 		}
 	}

stepmania/src/DancingCharacters.cpp

@@ -179,7 +179,7 @@ void DancingCharacters::Update( float fDelta )
 
 		/* It's OK for the animation to go slower than natural when we're
 		 * at a very low music rate. */
-		fUpdateScale *= GAMESTATE->m_SongOptions.m_fMusicRate;
+		fUpdateScale *= GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 		FOREACH_PlayerNumber( p )
 		{

stepmania/src/Foreground.cpp

@@ -59,7 +59,7 @@ void Foreground::LoadFromSong( const Song *pSong )
 void Foreground::Update( float fDeltaTime )
 {
 	/* Calls to Update() should *not* be scaled by music rate. Undo it. */
-	const float fRate = GAMESTATE->m_SongOptions.m_fMusicRate;
+	const float fRate = GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 	for( unsigned i=0; i < m_BGAnimations.size(); ++i )
 	{

stepmania/src/GameCommand.cpp

@@ -39,7 +39,8 @@ void GameCommand::Init()
 	m_pm = PLAY_MODE_INVALID;
 	m_dc = DIFFICULTY_INVALID;
 	m_CourseDifficulty = DIFFICULTY_INVALID;
-	m_sModifiers = "";
+	m_sPreferredModifiers = "";
+	m_sStageModifiers = "";
 	m_sAnnouncer = "";
 	m_sScreen = "";
 	m_LuaFunction.Unset();
@@ -97,17 +98,28 @@ bool GameCommand::DescribesCurrentMode( PlayerNumber pn ) const
 	if( m_sAnnouncer != "" && m_sAnnouncer != ANNOUNCER->GetCurAnnouncerName() )
 		return false;
 
-	if( m_sModifiers != "" )
+	if( m_sPreferredModifiers != "" )
 	{
-		/* Apply modifiers. */
+		PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred();
-		PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions;
+		SongOptions so = GAMESTATE->m_SongOptions.GetPreferred();
-		SongOptions so = GAMESTATE->m_SongOptions;
+		po.FromString( m_sPreferredModifiers );
-		po.FromString( m_sModifiers );
+		so.FromString( m_sPreferredModifiers );
-		so.FromString( m_sModifiers );
 
-		if( po != GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions )
+		if( po != GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred() )
 			return false;
-		if( so != GAMESTATE->m_SongOptions )
+		if( so != GAMESTATE->m_SongOptions.GetPreferred() )
+			return false;
+	}
+	if( m_sStageModifiers != "" )
+	{
+		PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetStage();
+		SongOptions so = GAMESTATE->m_SongOptions.GetStage();
+		po.FromString( m_sStageModifiers );
+		so.FromString( m_sStageModifiers );
+
+		if( po != GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetStage() )
+			return false;
+		if( so != GAMESTATE->m_SongOptions.GetStage() )
 			return false;
 	}
 
@@ -214,9 +226,16 @@ void GameCommand::LoadOne( const Command& cmd )
 
 	else if( sName == "mod" )
 	{
-		if( m_sModifiers != "" )
+		if( m_sPreferredModifiers != "" )
-			m_sModifiers += ",";
+			m_sPreferredModifiers += ",";
-		m_sModifiers += sValue;
+		m_sPreferredModifiers += sValue;
+	}
+
+	else if( sName == "stagemod" )
+	{
+		if( m_sStageModifiers != "" )
+			m_sStageModifiers += ",";
+		m_sStageModifiers += sValue;
 	}
 	
 	else if( sName == "lua" )
@@ -540,10 +559,20 @@ bool GameCommand::IsPlayable( RString *why ) const
 		}
 	}
 
-	if( !m_sModifiers.empty() )
+	if( !m_sPreferredModifiers.empty() )
 	{
 		// TODO: Split this and check each modifier individually
-		if( UNLOCKMAN->ModifierIsLocked(m_sModifiers) )
+		if( UNLOCKMAN->ModifierIsLocked(m_sPreferredModifiers) )
+		{	if( why )
+				*why = "Modifier is locked";
+			return false;
+		}
+	}
+
+	if( !m_sStageModifiers.empty() )
+	{
+		// TODO: Split this and check each modifier individually
+		if( UNLOCKMAN->ModifierIsLocked(m_sStageModifiers) )
 		{	if( why )
 				*why = "Modifier is locked";
 			return false;
@@ -643,9 +672,12 @@ void GameCommand::ApplySelf( const vector<PlayerNumber> &vpns ) const
 			GAMESTATE->ChangePreferredDifficulty( *pn, m_dc );
 	if( m_sAnnouncer != "" )
 		ANNOUNCER->SwitchAnnouncer( m_sAnnouncer );
-	if( m_sModifiers != "" )
+	if( m_sPreferredModifiers != "" )
 		FOREACH_CONST( PlayerNumber, vpns, pn )
-			GAMESTATE->ApplyModifiers( *pn, m_sModifiers );
+			GAMESTATE->ApplyPreferredModifiers( *pn, m_sPreferredModifiers );
+	if( m_sStageModifiers != "" )
+		FOREACH_CONST( PlayerNumber, vpns, pn )
+			GAMESTATE->ApplyStageModifiers( *pn, m_sStageModifiers );
 	if( m_LuaFunction.IsSet() )
 	{
 		Lua *L = LUA->Get();
@@ -735,17 +767,25 @@ void GameCommand::ApplySelf( const vector<PlayerNumber> &vpns ) const
 	}
 	if( m_bApplyDefaultOptions )
 	{
+		// applying options affects only the current stage
 		FOREACH_PlayerNumber( p )
-			GAMESTATE->GetDefaultPlayerOptions( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions );
+		{
-		GAMESTATE->GetDefaultSongOptions( GAMESTATE->m_SongOptions );
+			PlayerOptions po;
+			GAMESTATE->GetDefaultPlayerOptions( po );
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = po );
+		}
+
+		SongOptions so;
+		GAMESTATE->GetDefaultSongOptions( so );
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, = so );
 	}
 	// HACK:  Set life type to BATTERY just once here so it happens once and 
 	// we don't override the user's changes if they back out.
 	if( GAMESTATE->m_PlayMode == PLAY_MODE_ONI && 
 		GAMESTATE->m_PlayMode != OldPlayMode &&
-		GAMESTATE->m_SongOptions.m_LifeType == SongOptions::LIFE_BAR )
+		GAMESTATE->m_SongOptions.GetStage().m_LifeType == SongOptions::LIFE_BAR )
 	{
-		GAMESTATE->m_SongOptions.m_LifeType = SongOptions::LIFE_BATTERY;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_LifeType = SongOptions::LIFE_BATTERY );
 	}
 }
 
@@ -756,7 +796,8 @@ bool GameCommand::IsZero() const
 		m_pStyle != NULL ||
 		m_dc != DIFFICULTY_INVALID ||
 		m_sAnnouncer != "" ||
-		m_sModifiers != "" ||
+		m_sPreferredModifiers != "" ||
+		m_sStageModifiers != "" ||
 		m_pSong != NULL || 
 		m_pSteps != NULL || 
 		m_pCourse != NULL || 

stepmania/src/GameCommand.h

@@ -60,7 +60,8 @@ public:
 	Difficulty	m_dc;
 	CourseDifficulty	m_CourseDifficulty;
 	RString		m_sAnnouncer;
-	RString		m_sModifiers;
+	RString		m_sPreferredModifiers;
+	RString		m_sStageModifiers;
 	RString		m_sScreen;
 	LuaExpression	m_LuaFunction;
 	Song*		m_pSong;

stepmania/src/GameState.cpp

@@ -215,6 +215,8 @@ void GameState::Reset()
 	FOREACH_MultiPlayer( p )
 		m_pMultiPlayerState[p]->Reset();
 
+	m_SongOptions.Init();
+
 	ResetMusicStatistics();
 	ResetStageStatistics();
 
@@ -230,7 +232,9 @@ void GameState::Reset()
 
 	STATSMAN->Reset();
 
-	GAMESTATE->GetDefaultSongOptions( m_SongOptions );
+	SongOptions so;
+	GAMESTATE->GetDefaultSongOptions( so );
+	MODS_GROUP_ASSIGN( m_SongOptions, ModsLevel_Preferred, = so );
 	
 	FOREACH_PlayerNumber(p)
 	{
@@ -242,7 +246,9 @@ void GameState::Reset()
 		// could be done in the title menu GameCommand, but then it wouldn't
 		// affect demo, and other non-gameplay things ...) -glenn
 		
-		GAMESTATE->GetDefaultPlayerOptions( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions );
+		PlayerOptions po;
+		GAMESTATE->GetDefaultPlayerOptions( po );
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Preferred, = po );
 	}
 
 	FOREACH_PlayerNumber(p)
@@ -363,8 +369,8 @@ void GameState::PlayersFinalized()
 			 * sets a default of "reverse", and the player turns it off, we should
 			 * set it off.  However, don't reset modifiers that aren't saved by the
 			 * profile, so we don't ignore unsaved modifiers when a profile is in use. */
-			GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.ResetSavedPrefs();
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, .ResetSavedPrefs() );
-			GAMESTATE->ApplyModifiers( pn, sModifiers );
+			GAMESTATE->ApplyPreferredModifiers( pn, sModifiers );
 		}
 		// Only set the sort order if it wasn't already set by a GameCommand (or by an earlier profile)
 		if( m_PreferredSortOrder == SORT_INVALID && pProfile->m_SortOrder != SORT_INVALID )
@@ -380,7 +386,7 @@ void GameState::PlayersFinalized()
 	}
 
 	FOREACH_PotentialCpuPlayer( pn )
-		ApplyModifiers( pn, CommonMetrics::DEFAULT_CPU_MODIFIERS );
+		ApplyPreferredModifiers( pn, CommonMetrics::DEFAULT_CPU_MODIFIERS );
 }
 
 void GameState::EndGame()
@@ -478,6 +484,10 @@ void GameState::BeginStage()
 
 	GAMESTATE->ResetStageStatistics();
 
+	FOREACH_PlayerNumber( p )
+		MODS_GROUP_ASSIGN( m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = m_pPlayerState[p]->m_PlayerOptions.GetPreferred() );
+	MODS_GROUP_ASSIGN( m_SongOptions, ModsLevel_Stage, = m_SongOptions.GetPreferred() );
+
 	m_iNumStagesOfThisSong = GetNumStagesForCurrentSong();
 	ASSERT( m_iNumStagesOfThisSong != -1 );
 }
@@ -511,8 +521,6 @@ void GameState::FinishStage()
 	if( !m_bMultiplayer )	// no saved stats in multiplayer
 		CommitStageStats();
 
-	RestoreSelectedOptions();
-
 	m_bStatsCommitted = false;
 
 	// Increment the stage counter.
@@ -548,7 +556,7 @@ void GameState::SaveCurrentSettingsToProfile( PlayerNumber pn )
 
 	Profile* pProfile = PROFILEMAN->GetProfile(pn);
 
-	pProfile->SetDefaultModifiers( this->m_pCurGame, m_pPlayerState[pn]->m_PlayerOptions.GetSavedPrefsString() );
+	pProfile->SetDefaultModifiers( this->m_pCurGame, m_pPlayerState[pn]->m_PlayerOptions.GetPreferred().GetSavedPrefsString() );
 	if( IsSongSort(m_PreferredSortOrder) )
 		pProfile->m_SortOrder = m_PreferredSortOrder;
 	if( m_PreferredDifficulty[pn] != DIFFICULTY_INVALID )
@@ -563,6 +571,8 @@ void GameState::SaveCurrentSettingsToProfile( PlayerNumber pn )
 
 void GameState::Update( float fDelta )
 {
+	m_SongOptions.Update( fDelta );
+
 	FOREACH_PlayerNumber( p )
 	{
 		m_pPlayerState[p]->Update( fDelta );
@@ -1061,51 +1071,29 @@ void GameState::GetDefaultSongOptions( SongOptions &so )
 	so.FromString( CommonMetrics::DEFAULT_MODIFIERS );
 }
 
-void GameState::ApplyModifiers( PlayerNumber pn, RString sModifiers )
+void GameState::ApplyPreferredModifiers( PlayerNumber pn, RString sModifiers )
 {
-	m_pPlayerState[pn]->m_PlayerOptions.FromString( sModifiers );
+	MODS_GROUP_ASSIGN( m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, .FromString(sModifiers) );
-	m_SongOptions.FromString( sModifiers );
+	MODS_GROUP_ASSIGN( m_SongOptions, ModsLevel_Preferred, .FromString(sModifiers) );
 }
 
-/* Store the player's preferred options.  This is called at the very beginning
+void GameState::ApplyStageModifiers( PlayerNumber pn, RString sModifiers )
- * of gameplay. */
-void GameState::StoreSelectedOptions()
 {
-	FOREACH_PlayerNumber( pn )
+	MODS_GROUP_ASSIGN( m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Stage, .FromString(sModifiers) );
-		m_pPlayerState[pn]->m_StoredPlayerOptions = m_pPlayerState[pn]->m_PlayerOptions;
+	MODS_GROUP_ASSIGN( m_SongOptions, ModsLevel_Stage, .FromString(sModifiers) );
-	m_StoredSongOptions = m_SongOptions;
 }
 
-void GameState::StoreStageOptions()
+void GameState::ResetOptions()
-{
-	FOREACH_PlayerNumber( pn )
-		m_pPlayerState[pn]->m_StagePlayerOptions = m_pPlayerState[pn]->m_PlayerOptions;
-	m_StoredSongOptions = m_SongOptions;
-}
-
-/* Restore the preferred options.  This is called after a song ends, before
- * setting new course options, so options from one song don't carry into the
- * next and we default back to the preferred options.  This is also called
- * at the end of gameplay to restore options. */
-void GameState::RestoreSelectedOptions()
-{
-	FOREACH_PlayerNumber( pn )
-		m_pPlayerState[pn]->m_PlayerOptions = m_pPlayerState[pn]->m_StoredPlayerOptions;
-	m_SongOptions = m_StoredSongOptions;
-}
-
-void GameState::RestoreStageOptions()
-{
-	FOREACH_PlayerNumber( pn )
-		m_pPlayerState[pn]->m_PlayerOptions = m_pPlayerState[pn]->m_StagePlayerOptions;
-	m_SongOptions = m_StoredSongOptions;
-}
-
-void GameState::ResetCurrentOptions()
 {
 	FOREACH_PlayerNumber( p )
-		GetDefaultPlayerOptions( m_pPlayerState[p]->m_PlayerOptions );
+	{
-	GetDefaultSongOptions( m_SongOptions );
+		PlayerOptions po;
+		GetDefaultPlayerOptions( po );
+		MODS_GROUP_ASSIGN( m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Preferred, = po );
+	}
+	SongOptions so;
+	GetDefaultSongOptions( so );
+	MODS_GROUP_ASSIGN( m_SongOptions, ModsLevel_Preferred, = so );
 }
 
 bool GameState::IsDisqualified( PlayerNumber pn )
@@ -1124,7 +1112,7 @@ bool GameState::IsDisqualified( PlayerNumber pn )
 		return true;
 #endif //DEBUG
 
-	const PlayerOptions &po = GAMESTATE->m_pPlayerState[pn]->m_StoredPlayerOptions;
+	const PlayerOptions &po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred();
 
 	// Check the stored player options for disqualify.  Don't disqualify because
 	// of mods that were forced.
@@ -1138,7 +1126,7 @@ void GameState::GetAllUsedNoteSkins( vector<RString> &out ) const
 {
 	FOREACH_EnabledPlayer( pn )
 	{
-		out.push_back( m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin );
+		out.push_back( m_pPlayerState[pn]->m_PlayerOptions.GetCurrent().m_sNoteSkin );
 
 		/* Add note skins that are used in courses. */
 		if( this->IsCourseMode() )
@@ -1182,7 +1170,7 @@ void setmax( T &a, const T &b )
 SongOptions::FailType GameState::GetPlayerFailType( const PlayerState *pPlayerState ) const
 {
 	PlayerNumber pn = pPlayerState->m_PlayerNumber;
-	SongOptions::FailType ft = m_SongOptions.m_FailType;
+	SongOptions::FailType ft = m_SongOptions.GetCurrent().m_FailType;
 
 	/* If the player changed the fail mode explicitly, leave it alone. */
 	if( this->m_bChangedFailTypeOnScreenSongOptions )
@@ -1787,12 +1775,12 @@ float GameState::GetGoalPercentComplete( PlayerNumber pn )
 
 bool GameState::PlayerIsUsingModifier( PlayerNumber pn, const RString &sModifier )
 {
-	PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions;
+	PlayerOptions po = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetCurrent();
-	SongOptions so = GAMESTATE->m_SongOptions;
+	SongOptions so = GAMESTATE->m_SongOptions.GetCurrent();
 	po.FromString( sModifier );
 	so.FromString( sModifier );
 
-	return po == GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions && so == GAMESTATE->m_SongOptions;
+	return po == GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetCurrent()  &&  so == GAMESTATE->m_SongOptions.GetCurrent();
 }
 
 Profile* GameState::GetEditLocalProfile()
@@ -1946,7 +1934,7 @@ public:
 	static int GetNumSidesJoined( T* p, lua_State *L )		{ lua_pushnumber(L, p->GetNumSidesJoined() ); return 1; }
 	static int GetCoinMode( T* p, lua_State *L )			{ lua_pushnumber(L, p->GetCoinMode() ); return 1; }
 	static int GetPremium( T* p, lua_State *L )			{ lua_pushnumber(L, p->GetPremium() ); return 1; }
-	static int GetSongOptionsString( T* p, lua_State *L )		{ lua_pushstring(L, p->m_SongOptions.GetString() ); return 1; }
+	static int GetSongOptionsString( T* p, lua_State *L )		{ lua_pushstring(L, p->m_SongOptions.GetCurrent().GetString() ); return 1; }
 	static int IsWinner( T* p, lua_State *L )
 	{
 		PlayerNumber pn = (PlayerNumber)IArg(1);

stepmania/src/GameState.h

@@ -11,6 +11,7 @@
 #include "Difficulty.h"
 #include "MessageManager.h"
 #include "SongOptions.h"
+#include "ModsGroup.h"
 
 #include <map>
 #include <deque>
@@ -117,22 +118,22 @@ public:
 	int				m_iNumStagesOfThisSong;
 	int				m_iCurrentStageIndex;
 
-	int				GetStageIndex() const;
+	int		GetStageIndex() const;
-	void				BeginStage();
+	void		BeginStage();
-	void				CancelStage();
+	void		CancelStage();
-	void				CommitStageStats();
+	void		CommitStageStats();
-	void				FinishStage();
+	void		FinishStage();
-	int				GetNumStagesLeft() const;
+	int		GetNumStagesLeft() const;
-	bool				IsFinalStage() const;
+	bool		IsFinalStage() const;
-	bool				IsExtraStage() const;
+	bool		IsExtraStage() const;
-	bool				IsExtraStage2() const;
+	bool		IsExtraStage2() const;
-	Stage				GetCurrentStage() const;
+	Stage		GetCurrentStage() const;
-	bool				IsStagePossible( Stage s ) const;
+	bool		IsStagePossible( Stage s ) const;
-	int				GetCourseSongIndex() const;
+	int		GetCourseSongIndex() const;
-	RString				GetPlayerDisplayName( PlayerNumber pn ) const;
+	RString		GetPlayerDisplayName( PlayerNumber pn ) const;
 
-	bool				m_bLoadingNextSong;
+	bool		m_bLoadingNextSong;
-	int				GetLoadingCourseSongIndex() const;
+	int		GetLoadingCourseSongIndex() const;
 
 	//
 	// State Info used during gameplay
@@ -204,17 +205,13 @@ public:
 	// Options stuff
 	//
 
-	SongOptions		m_SongOptions;
+	ModsGroup<SongOptions>	m_SongOptions;
-	SongOptions		m_StoredSongOptions;
 
 	void GetDefaultPlayerOptions( PlayerOptions &po );
 	void GetDefaultSongOptions( SongOptions &so );
-	void ApplyModifiers( PlayerNumber pn, RString sModifiers );
+	void ApplyPreferredModifiers( PlayerNumber pn, RString sModifiers );
-	void StoreSelectedOptions();
+	void ApplyStageModifiers( PlayerNumber pn, RString sModifiers );
-	void StoreStageOptions();
+	void ResetOptions();
-	void RestoreSelectedOptions();
-	void RestoreStageOptions();
-	void ResetCurrentOptions();
 
 	bool IsDisqualified( PlayerNumber pn );
 	bool PlayerIsUsingModifier( PlayerNumber pn, const RString &sModifier );

stepmania/src/LifeMeterBar.cpp

@@ -49,7 +49,7 @@ const float FAIL_THRESHOLD = 0;
 
 LifeMeterBar::LifeMeterBar()
 {
-	switch( GAMESTATE->m_SongOptions.m_DrainType )
+	switch( GAMESTATE->m_SongOptions.GetStage().m_DrainType )
 	{
 	case SongOptions::DRAIN_NORMAL:
 		m_fLifePercentage = INITIAL_VALUE;
@@ -157,9 +157,9 @@ void LifeMeterBar::ChangeLife( TapNoteScore score )
 	if( IsHot()  &&  score < TNS_W4 )
 		fDeltaLife = -0.10f;		// make it take a while to get back to "hot"
 
-	switch( GAMESTATE->m_SongOptions.m_DrainType )
+	switch( GAMESTATE->m_SongOptions.GetSong().m_DrainType )
 	{
-	DEFAULT_FAIL( GAMESTATE->m_SongOptions.m_DrainType );
+	DEFAULT_FAIL( GAMESTATE->m_SongOptions.GetSong().m_DrainType );
 	case SongOptions::DRAIN_NORMAL:
 		break;
 	case SongOptions::DRAIN_NO_RECOVER:
@@ -179,7 +179,7 @@ void LifeMeterBar::ChangeLife( TapNoteScore score )
 void LifeMeterBar::ChangeLife( HoldNoteScore score, TapNoteScore tscore )
 {
 	float fDeltaLife=0.f;
-	switch( GAMESTATE->m_SongOptions.m_DrainType )
+	switch( GAMESTATE->m_SongOptions.GetSong().m_DrainType )
 	{
 	case SongOptions::DRAIN_NORMAL:
 		switch( score )
@@ -247,7 +247,7 @@ void LifeMeterBar::ChangeLife( float fDeltaLife )
 	if( m_pPlayerStageStats->bFailed )
 		fDeltaLife = 0;
 
-	switch( GAMESTATE->m_SongOptions.m_DrainType )
+	switch( GAMESTATE->m_SongOptions.GetSong().m_DrainType )
 	{
 	case SongOptions::DRAIN_NORMAL:
 	case SongOptions::DRAIN_NO_RECOVER:
@@ -283,8 +283,8 @@ void LifeMeterBar::AfterLifeChanged()
 
 bool LifeMeterBar::IsPastPassmark() const
 {
-	if( m_pPlayerState->m_PlayerOptions.m_fPassmark > 0 )
+	if( m_pPlayerState->m_PlayerOptions.GetSong().m_fPassmark > 0 )
-		return m_fLifePercentage >= m_pPlayerState->m_PlayerOptions.m_fPassmark;
+		return m_fLifePercentage >= m_pPlayerState->m_PlayerOptions.GetSong().m_fPassmark;
 	else
 		return false;
 }

stepmania/src/LifeMeterBattery.cpp

@@ -16,7 +16,7 @@ const float BATTERY_BLINK_TIME		= 1.2f;
 
 LifeMeterBattery::LifeMeterBattery()
 {
-	m_iLivesLeft = GAMESTATE->m_SongOptions.m_iBatteryLives;
+	m_iLivesLeft = GAMESTATE->m_SongOptions.GetStage().m_iBatteryLives;
 	m_iTrailingLivesLeft = m_iLivesLeft;
 
 	m_fBatteryBlinkTime = 0;
@@ -67,12 +67,12 @@ void LifeMeterBattery::OnSongEnded()
 	if( m_pPlayerStageStats->bFailedEarlier )
 		return;
 
-	if( m_iLivesLeft < GAMESTATE->m_SongOptions.m_iBatteryLives )
+	if( m_iLivesLeft < GAMESTATE->m_SongOptions.GetSong().m_iBatteryLives )
 	{
 		m_iTrailingLivesLeft = m_iLivesLeft;
 		PlayerNumber pn = m_pPlayerState->m_PlayerNumber;
 		m_iLivesLeft += ( GAMESTATE->m_pCurSteps[pn]->GetMeter()>=8 ? 2 : 1 );
-		m_iLivesLeft = min( m_iLivesLeft, GAMESTATE->m_SongOptions.m_iBatteryLives );
+		m_iLivesLeft = min( m_iLivesLeft, GAMESTATE->m_SongOptions.GetSong().m_iBatteryLives );
 		m_soundGainLife.Play();
 	}
 
@@ -153,10 +153,10 @@ bool LifeMeterBattery::IsFailing() const
 
 float LifeMeterBattery::GetLife() const
 {
-	if( !GAMESTATE->m_SongOptions.m_iBatteryLives )
+	if( !GAMESTATE->m_SongOptions.GetSong().m_iBatteryLives )
 		return 1;
 
-	return float(m_iLivesLeft) / GAMESTATE->m_SongOptions.m_iBatteryLives;
+	return float(m_iLivesLeft) / GAMESTATE->m_SongOptions.GetSong().m_iBatteryLives;
 }
 
 void LifeMeterBattery::ForceFail()

stepmania/src/LyricDisplay.cpp

@@ -68,7 +68,7 @@ void LyricDisplay::Update( float fDeltaTime )
 	float fShowLength = max( fDistance - fTweenBufferTime, 0.0f );
 
 	// Make lyrics show faster for faster song rates.
-	fShowLength /= GAMESTATE->m_SongOptions.m_fMusicRate;
+	fShowLength /= GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 	for( int i=0; i<2; i++ )
 	{

stepmania/src/MusicWheel.cpp

@@ -121,10 +121,10 @@ void MusicWheel::Load( RString sType )
 		FOREACH_HumanPlayer( p )
 		{
 			GAMESTATE->m_pCurSteps[p].Set( pSteps );
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions = po;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = po);
 			GAMESTATE->m_PreferredDifficulty[p].Set( pSteps->GetDifficulty() );
 		}
-		GAMESTATE->m_SongOptions = so;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, = so );
 	}
 
 	/* Update for SORT_MOST_PLAYED. */

stepmania/src/NetworkSyncManager.cpp

@@ -442,13 +442,13 @@ void NetworkSyncManager::StartRequest(short position)
 		m_packet.WriteNT(RString(""));
 
 	//Send Player (and song) Options
-	m_packet.WriteNT(GAMESTATE->m_SongOptions.GetString());
+	m_packet.WriteNT( GAMESTATE->m_SongOptions.GetCurrent().GetString() );
 
 	int players=0;
 	FOREACH_PlayerNumber (p)
 	{
 		++players;
-		m_packet.WriteNT(GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetString());
+		m_packet.WriteNT(GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetCurrent().GetString());
 	}
 	for (int i=0; i<2-players; ++i)
 		m_packet.WriteNT("");	//Write a NULL if no player
@@ -785,7 +785,7 @@ void NetworkSyncManager::ReportPlayerOptions()
 	m_packet.ClearPacket();
 	m_packet.Write1( NSCUPOpts );
 	FOREACH_PlayerNumber (pn)
-		m_packet.WriteNT( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetString() );
+		m_packet.WriteNT( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetCurrent().GetString() );
 	NetPlayerClient->SendPack((char*)&m_packet.Data, m_packet.Position); 
 }
 

stepmania/src/NoteDisplay.cpp

@@ -483,7 +483,7 @@ void NoteDisplay::DrawHoldTopCap( const TapNote& tn, int iCol, int iRow, bool bI
 	const float fYCapTop	 = fYHead+cache->m_iStartDrawingHoldBodyOffsetFromHead-fFrameHeight;
 	const float fYCapBottom  = fYHead+cache->m_iStartDrawingHoldBodyOffsetFromHead;
 
-	bool bReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(iCol) > 0.5f;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(iCol) > 0.5f;
 
 	if( bGlow )
 		fColorScale = 1;
@@ -573,7 +573,7 @@ void NoteDisplay::DrawHoldBody( const TapNote& tn, int iCol, int iRow, bool bIsB
 	const float fYBodyTop = fYHead + cache->m_iStartDrawingHoldBodyOffsetFromHead;
 	const float fYBodyBottom = fYTail + cache->m_iStopDrawingHoldBodyOffsetFromTail;
 
-	const bool bReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(iCol) > 0.5f;
+	const bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(iCol) > 0.5f;
 	bool bAnchorToBottom = bReverse && cache->m_bFlipHeadAndTailWhenReverse;
 
 	if( bGlow )
@@ -670,7 +670,7 @@ void NoteDisplay::DrawHoldBottomCap( const TapNote& tn, int iCol, int iRow, bool
 	const float fYCapTop		= fYTail+cache->m_iStopDrawingHoldBodyOffsetFromTail;
 	const float fYCapBottom		= fYTail+cache->m_iStopDrawingHoldBodyOffsetFromTail+fFrameHeight;
 
-	bool bReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(iCol) > 0.5f;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(iCol) > 0.5f;
 
 	if( bGlow )
 		fColorScale = 1;
@@ -869,7 +869,7 @@ void NoteDisplay::DrawHold( const TapNote &tn, int iCol, int iRow, bool bIsBeing
 
 	// bDrawGlowOnly is a little hacky.  We need to draw the diffuse part and the glow part one pass at a time to minimize state changes
 
-	bool bReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(iCol) > 0.5f;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(iCol) > 0.5f;
 	float fStartBeat = NoteRowToBeat( max(tn.HoldResult.iLastHeldRow, iRow) );
 	float fThrowAway = 0;
 

stepmania/src/NoteField.cpp

@@ -92,7 +92,7 @@ void NoteField::CacheAllUsedNoteSkins()
 	 * play, so we don't have to load them later (such as between course songs). */
 	vector<RString> asSkins;
 	GAMESTATE->GetAllUsedNoteSkins( asSkins );
-	asSkins.push_back( m_pPlayerState->m_PlayerOptions.m_sNoteSkin );
+	asSkins.push_back( m_pPlayerState->m_PlayerOptions.GetStage().m_sNoteSkin );
 
 	for( unsigned i=0; i < asSkins.size(); ++i )
 		CacheNoteSkin( asSkins[i] );
@@ -108,13 +108,13 @@ void NoteField::CacheAllUsedNoteSkins()
 	FOREACHS( RString, setNoteSkinsToUnload, s )
 		UncacheNoteSkin( *s );
 
-	map<RString, NoteDisplayCols *>::iterator it = m_NoteDisplays.find( m_pPlayerState->m_PlayerOptions.m_sNoteSkin );
+	map<RString, NoteDisplayCols *>::iterator it = m_NoteDisplays.find( m_pPlayerState->m_PlayerOptions.GetCurrent().m_sNoteSkin );
-	ASSERT_M( it != m_NoteDisplays.end(), m_pPlayerState->m_PlayerOptions.m_sNoteSkin );
+	ASSERT_M( it != m_NoteDisplays.end(), m_pPlayerState->m_PlayerOptions.GetCurrent().m_sNoteSkin );
 	m_pCurDisplay = it->second;
 	memset( m_pDisplays, 0, sizeof(m_pDisplays) );
 	FOREACH_EnabledPlayer( pn )
 	{
-		const RString& sNoteSkin = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin;
+		const RString& sNoteSkin = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetCurrent().m_sNoteSkin;
 		it = m_NoteDisplays.find( sNoteSkin );
 		ASSERT_M( it != m_NoteDisplays.end(), sNoteSkin );
 		m_pDisplays[pn] = it->second;
@@ -147,13 +147,13 @@ void NoteField::Load(
 		ssprintf("%d = %d",m_pNoteData->GetNumTracks(), GAMESTATE->GetCurrentStyle()->m_iColsPerPlayer) );
 
 	// The note skin may have changed at the beginning of a new course song.
-	map<RString, NoteDisplayCols *>::iterator it = m_NoteDisplays.find( m_pPlayerState->m_PlayerOptions.m_sNoteSkin );
+	map<RString, NoteDisplayCols *>::iterator it = m_NoteDisplays.find( m_pPlayerState->m_PlayerOptions.GetCurrent().m_sNoteSkin );
-	ASSERT_M( it != m_NoteDisplays.end(), m_pPlayerState->m_PlayerOptions.m_sNoteSkin );
+	ASSERT_M( it != m_NoteDisplays.end(), m_pPlayerState->m_PlayerOptions.GetCurrent().m_sNoteSkin );
 	m_pCurDisplay = it->second;
 	memset( m_pDisplays, 0, sizeof(m_pDisplays) );
 	FOREACH_EnabledPlayer( pn )
 	{
-		const RString& sNoteSkin = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin;
+		const RString& sNoteSkin = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetCurrent().m_sNoteSkin;
 		it = m_NoteDisplays.find( sNoteSkin );
 		ASSERT_M( it != m_NoteDisplays.end(), sNoteSkin );
 		m_pDisplays[pn] = it->second;
@@ -233,7 +233,7 @@ void NoteField::DrawBeatBar( const float fBeat )
 	}
 	else
 	{
-		float fScrollSpeed = m_pPlayerState->m_CurrentPlayerOptions.m_fScrollSpeed;
+		float fScrollSpeed = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fScrollSpeed;
 		switch( nt )
 		{
 		default:	ASSERT(0);
@@ -370,7 +370,7 @@ float FindFirstDisplayedBeat( const PlayerState* pPlayerState, int iFirstPixelTo
 	 * of the stream. */
 	bool bBoomerang;
 	{
-		const float* fAccels = pPlayerState->m_CurrentPlayerOptions.m_fAccels;
+		const float* fAccels = pPlayerState->m_PlayerOptions.GetCurrent().m_fAccels;
 		bBoomerang = (fAccels[PlayerOptions::ACCEL_BOOMERANG] != 0);
 	}
 
@@ -405,7 +405,7 @@ float FindLastDisplayedBeat( const PlayerState* pPlayerState, int iLastPixelToDr
 
 	bool bBoomerang;
 	{
-		const float* fAccels = pPlayerState->m_CurrentPlayerOptions.m_fAccels;
+		const float* fAccels = pPlayerState->m_PlayerOptions.GetCurrent().m_fAccels;
 		bBoomerang = (fAccels[PlayerOptions::ACCEL_BOOMERANG] != 0);
 	}
 
@@ -454,7 +454,7 @@ void NoteField::DrawPrimitives()
 	NoteDisplayCols *cur = m_pCurDisplay;
 	cur->m_ReceptorArrowRow.Draw();
 
-	const PlayerOptions &current_po = m_pPlayerState->m_CurrentPlayerOptions;
+	const PlayerOptions &current_po = m_pPlayerState->m_PlayerOptions.GetCurrent();
 
 	//
 	// Adjust draw range depending on some effects

stepmania/src/OptionIconRow.cpp

@@ -103,7 +103,7 @@ void OptionIconRow::SetFromGameState( PlayerNumber pn )
 {
 	// init
 
-	RString sOptions = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetString();
+	RString sOptions = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetStage().GetString();
 	vector<RString> asOptions;
 	split( sOptions, ", ", asOptions, true );
 

stepmania/src/OptionRowHandler.cpp

@@ -248,7 +248,7 @@ public:
 	virtual void GetIconTextAndGameCommand( int iFirstSelection, RString &sIconTextOut, GameCommand &gcOut ) const
 	{
 		sIconTextOut = m_bUseModNameForIcon ?
-			m_aListEntries[iFirstSelection].m_sModifiers :
+			m_aListEntries[iFirstSelection].m_sPreferredModifiers :
 			m_Def.m_vsChoices[iFirstSelection];
 
 		gcOut = m_aListEntries[iFirstSelection];
@@ -282,7 +282,7 @@ class OptionRowHandlerListNoteSkins : public OptionRowHandlerList
 		for( unsigned skin=0; skin<arraySkinNames.size(); skin++ )
 		{
 			GameCommand mc;
-			mc.m_sModifiers = arraySkinNames[skin];
+			mc.m_sPreferredModifiers = arraySkinNames[skin];
 			m_aListEntries.push_back( mc );
 			m_Def.m_vsChoices.push_back( arraySkinNames[skin] );
 		}

stepmania/src/PercentageDisplay.cpp

@@ -130,7 +130,7 @@ void PercentageDisplay::Refresh()
 		
 		if( m_bApplyScoreDisplayOptions )
 		{
-			switch( m_pPlayerState->m_CurrentPlayerOptions.m_ScoreDisplay )
+			switch( m_pPlayerState->m_PlayerOptions.GetCurrent().m_ScoreDisplay )
 			{
 			case PlayerOptions::SCORING_ADD:
 				// nothing to do

stepmania/src/Player.cpp

@@ -330,7 +330,7 @@ void Player::Load()
 	// TODO: Remove use of PlayerNumber.
 	PlayerNumber pn = m_pPlayerState->m_PlayerNumber;
 
-	bool bOniDead = GAMESTATE->m_SongOptions.m_LifeType == SongOptions::LIFE_BATTERY  &&  
+	bool bOniDead = GAMESTATE->m_SongOptions.GetStage().m_LifeType == SongOptions::LIFE_BATTERY  &&  
 		(m_pPlayerStageStats == NULL || m_pPlayerStageStats->bFailed);
 
 	/* The editor reuses Players ... so we really need to make sure everything
@@ -355,7 +355,7 @@ void Player::Load()
 //		m_pScore->Init( pn );
 
 	/* Apply transforms. */
-	NoteDataUtil::TransformNoteData( m_NoteData, m_pPlayerState->m_PlayerOptions, GAMESTATE->GetCurrentStyle()->m_StepsType );
+	NoteDataUtil::TransformNoteData( m_NoteData, m_pPlayerState->m_PlayerOptions.GetStage(), GAMESTATE->GetCurrentStyle()->m_StepsType );
 	
 	switch( GAMESTATE->m_PlayMode )
 	{
@@ -363,7 +363,7 @@ void Player::Load()
 	case PLAY_MODE_BATTLE:
 		{
 			// ugly, ugly, ugly.  Works only w/ dance.
-			NoteDataUtil::TransformNoteData( m_NoteData, m_pPlayerState->m_PlayerOptions, GAMESTATE->GetCurrentStyle()->m_StepsType );
+			NoteDataUtil::TransformNoteData( m_NoteData, m_pPlayerState->m_PlayerOptions.GetStage(), GAMESTATE->GetCurrentStyle()->m_StepsType );
 			
 			// shuffle either p1 or p2
 			static int count = 0;
@@ -397,7 +397,7 @@ void Player::Load()
 		m_pNoteField->Load( &m_NoteData, iStartDrawingAtPixels, iStopDrawingAtPixels );
 	}
 
-	const bool bReverse = m_pPlayerState->m_PlayerOptions.GetReversePercentForColumn( 0 ) == 1;
+	const bool bReverse = m_pPlayerState->m_PlayerOptions.GetStage().GetReversePercentForColumn( 0 ) == 1;
 	bool bPlayerUsingBothSides = GAMESTATE->GetCurrentStyle()->m_StyleType==ONE_PLAYER_TWO_SIDES;
 	if( m_pCombo )
 	{
@@ -466,8 +466,8 @@ void Player::Update( float fDeltaTime )
 	if( m_pNoteField )
 		m_pNoteField->Update( fDeltaTime );
 
-	float fMiniPercent = m_pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_MINI];
+	float fMiniPercent = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_MINI];
-	float fTinyPercent = m_pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_TINY];
+	float fTinyPercent = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_TINY];
 	float fJudgmentZoom = min( powf(0.5f, fMiniPercent+fTinyPercent), 1.0f );
 	
 	//
@@ -476,7 +476,7 @@ void Player::Update( float fDeltaTime )
 	{
 		for( int c=0; c<GAMESTATE->GetCurrentStyle()->m_iColsPerPlayer; c++ )
 		{
-			float fPercentReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(c);
+			float fPercentReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(c);
 			float fHoldJudgeYPos = SCALE( fPercentReverse, 0.f, 1.f, HOLD_JUDGMENT_Y_STANDARD, HOLD_JUDGMENT_Y_REVERSE );
 //			float fGrayYPos = SCALE( fPercentReverse, 0.f, 1.f, GRAY_ARROWS_Y_STANDARD, GRAY_ARROWS_Y_REVERSE );
 
@@ -494,8 +494,8 @@ void Player::Update( float fDeltaTime )
 	//if( m_pNoteField )
 	//	m_pNoteField->SetY( fGrayYPos );
 
-	const bool bReverse = m_pPlayerState->m_PlayerOptions.GetReversePercentForColumn(0) == 1;
+	const bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(0) == 1;
-	float fPercentCentered = m_pPlayerState->m_CurrentPlayerOptions.m_fScrolls[PlayerOptions::SCROLL_CENTERED];
+	float fPercentCentered = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fScrolls[PlayerOptions::SCROLL_CENTERED];
 	if( m_pCombo )
 	{
 		m_pCombo->SetY( 
@@ -787,7 +787,7 @@ void Player::DrawPrimitives()
 
 
 	// Draw these below everything else.
-	if( m_pPlayerState->m_PlayerOptions.m_fBlind == 0 )
+	if( m_pPlayerState->m_PlayerOptions.GetCurrent().m_fBlind == 0 )
 	{
 		if( m_pCombo )
 			m_pCombo->Draw();
@@ -802,9 +802,9 @@ void Player::DrawPrimitives()
 	if( HOLD_JUDGMENTS_UNDER_FIELD )
 		DrawHoldJudgments();
 
-	float fTilt = m_pPlayerState->m_CurrentPlayerOptions.m_fPerspectiveTilt;
+	float fTilt = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fPerspectiveTilt;
-	float fSkew = m_pPlayerState->m_CurrentPlayerOptions.m_fSkew;
+	float fSkew = m_pPlayerState->m_PlayerOptions.GetCurrent().m_fSkew;
-	bool bReverse = m_pPlayerState->m_CurrentPlayerOptions.GetReversePercentForColumn(0)>0.5;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(0)>0.5;
 
 
 	DISPLAY->CameraPushMatrix();
@@ -820,7 +820,7 @@ void Player::DrawPrimitives()
 
 		float fTiltDegrees = SCALE(fTilt,-1.f,+1.f,+30,-30) * (bReverse?-1:1);
 
-		float fZoom = SCALE( m_pPlayerState->m_CurrentPlayerOptions.m_fEffects[PlayerOptions::EFFECT_TINY], 0.f, 1.f, 1.f, 0.5f );
+		float fZoom = SCALE( m_pPlayerState->m_PlayerOptions.GetCurrent().m_fEffects[PlayerOptions::EFFECT_TINY], 0.f, 1.f, 1.f, 0.5f );
 		if( fTilt > 0 )
 			fZoom *= SCALE( fTilt, 0.f, 1.f, 1.f, 0.9f );
 		else
@@ -853,7 +853,7 @@ void Player::DrawPrimitives()
 
 void Player::DrawTapJudgments()
 {
-	if( m_pPlayerState->m_PlayerOptions.m_fBlind > 0 )
+	if( m_pPlayerState->m_PlayerOptions.GetCurrent().m_fBlind > 0 )
 		return;
 
 	if( m_sprJudgmentFrame.IsLoaded() )
@@ -864,7 +864,7 @@ void Player::DrawTapJudgments()
 
 void Player::DrawHoldJudgments()
 {
-	if( m_pPlayerState->m_PlayerOptions.m_fBlind > 0 )
+	if( m_pPlayerState->m_PlayerOptions.GetCurrent().m_fBlind > 0 )
 		return;
 
 	for( int c=0; c<m_NoteData.GetNumTracks(); c++ )
@@ -926,7 +926,7 @@ int Player::GetClosestNote( int col, int iNoteRow, int iMaxRowsAhead, int iMaxRo
 void Player::Step( int col, int row, const RageTimer &tm, bool bHeld )
 {
 	// If we're playing on oni and we've died, do nothing.
-	if( GAMESTATE->m_SongOptions.m_LifeType == SongOptions::LIFE_BATTERY && m_pPlayerStageStats  && m_pPlayerStageStats->bFailed )
+	if( GAMESTATE->m_SongOptions.GetCurrent().m_LifeType == SongOptions::LIFE_BATTERY && m_pPlayerStageStats  && m_pPlayerStageStats->bFailed )
 		return;
 	
 	DEBUG_ASSERT_M( col >= 0  &&  col <= m_NoteData.GetNumTracks(), ssprintf("%i, %i", col, m_NoteData.GetNumTracks()) );
@@ -1052,7 +1052,7 @@ void Player::Step( int col, int row, const RageTimer &tm, bool bHeld )
 	 * 2. Clamp the distance searched backward to the previous row graded.
 	 * Either option would fundamentally change the grading of two quick notes "jack hammers." Hmm.
 	 */
-	const int iStepSearchRows = BeatToNoteRow( StepSearchDistance * GAMESTATE->m_fCurBPS * GAMESTATE->m_SongOptions.m_fMusicRate );
+	const int iStepSearchRows = BeatToNoteRow( StepSearchDistance * GAMESTATE->m_fCurBPS * GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate );
 	int iIndexOverlappingNote = row == -1 ? GetClosestNote( col, BeatToNoteRow(fSongBeat), iStepSearchRows, iStepSearchRows, false ) : row;
 	
 	// calculate TapNoteScore
@@ -1073,13 +1073,13 @@ void Player::Step( int col, int row, const RageTimer &tm, bool bHeld )
 
 			/* GAMESTATE->m_fMusicSeconds is the music time as of GAMESTATE->m_LastBeatUpdate. Figure
 			 * out what the music time is as of now. */
-			const float fCurrentMusicSeconds = GAMESTATE->m_fMusicSeconds + (GAMESTATE->m_LastBeatUpdate.Ago()*GAMESTATE->m_SongOptions.m_fMusicRate);
+			const float fCurrentMusicSeconds = GAMESTATE->m_fMusicSeconds + (GAMESTATE->m_LastBeatUpdate.Ago()*GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate);
 
 			/* ... which means it happened at this point in the music: */
-			const float fMusicSeconds = fCurrentMusicSeconds - fTimeSinceStep * GAMESTATE->m_SongOptions.m_fMusicRate;
+			const float fMusicSeconds = fCurrentMusicSeconds - fTimeSinceStep * GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 			// The offset from the actual step in seconds:
-			fNoteOffset = (fStepSeconds - fMusicSeconds) / GAMESTATE->m_SongOptions.m_fMusicRate;	// account for music rate
+			fNoteOffset = (fStepSeconds - fMusicSeconds) / GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;	// account for music rate
 //			LOG->Trace("step was %.3f ago, music is off by %f: %f vs %f, step was %f off", 
 //				fTimeSinceStep, GAMESTATE->m_LastBeatUpdate.Ago()/GAMESTATE->m_SongOptions.m_fMusicRate,
 //				fStepSeconds, fMusicSeconds, fNoteOffset );
@@ -1230,7 +1230,7 @@ void Player::Step( int col, int row, const RageTimer &tm, bool bHeld )
 		{
 			if( tn.type != TapNote::mine )
 			{
-				const bool bBlind = !!m_pPlayerState->m_PlayerOptions.m_fBlind;
+				const bool bBlind = (m_pPlayerState->m_PlayerOptions.GetCurrent().m_fBlind != 0);
 				// XXX This is the wrong combo for shared players. STATSMAN->m_CurStageStats.m_Player[pn] might work but could be wrong.
 				const bool bBright = m_pPlayerStageStats && m_pPlayerStageStats->iCurCombo > int(BRIGHT_GHOST_COMBO_THRESHOLD) || bBlind;			
 				if( m_pNoteField )
@@ -1431,7 +1431,7 @@ void Player::UpdateJudgedRows()
 void Player::FlashGhostRow( int iRow, PlayerNumber pn )
 {
 	TapNoteScore lastTNS = NoteDataWithScoring::LastTapNoteWithResult( m_NoteData, iRow, pn ).result.tns;
-	const bool bBlind = !!m_pPlayerState->m_PlayerOptions.m_fBlind;
+	const bool bBlind = (m_pPlayerState->m_PlayerOptions.GetCurrent().m_fBlind != 0);
 	// XXX This is the wrong combo for shared players. STATSMAN->m_CurStageStats.m_Player[pn] might work but could be wrong.
 	const bool bBright = m_pPlayerStageStats && m_pPlayerStageStats->iCurCombo > int(BRIGHT_GHOST_COMBO_THRESHOLD) || bBlind;
 		
@@ -1453,7 +1453,7 @@ void Player::FlashGhostRow( int iRow, PlayerNumber pn )
 void Player::CrossedRow( int iNoteRow, const RageTimer &now )
 {
 	// If we're doing random vanish, randomise notes on the fly.
-	if( m_pPlayerState->m_CurrentPlayerOptions.m_fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH]==1 )
+	if( m_pPlayerState->m_PlayerOptions.GetCurrent().m_fAppearances[PlayerOptions::APPEARANCE_RANDOMVANISH]==1 )
 		RandomizeNotes( iNoteRow );
 
 	// check to see if there's a note at the crossed row
@@ -1505,7 +1505,7 @@ void Player::RandomizeNotes( int iNoteRow )
 	/* This is incorrect: if m_fScrollSpeed is 0.5, we'll never change
 	 * any odd rows, and if it's 2, we'll shuffle each row twice. */
 	int iNewNoteRow = iNoteRow + ROWS_PER_BEAT*2;
-	iNewNoteRow = int( iNewNoteRow / m_pPlayerState->m_PlayerOptions.m_fScrollSpeed );
+	iNewNoteRow = int( iNewNoteRow / m_pPlayerState->m_PlayerOptions.GetCurrent().m_fScrollSpeed );
 
 	int iNumOfTracks = m_NoteData.GetNumTracks();
 	for( int t=0; t+1 < iNumOfTracks; t++ )
@@ -1737,7 +1737,7 @@ void Player::HandleHoldScore( const TapNote &tn )
 
 float Player::GetMaxStepDistanceSeconds()
 {
-	return GAMESTATE->m_SongOptions.m_fMusicRate * ADJUSTED_WINDOW_SECONDS(TW_W5);
+	return GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate * ADJUSTED_WINDOW_SECONDS(TW_W5);
 }
 
 void Player::FadeToFail()

stepmania/src/PlayerOptions.cpp

@@ -42,27 +42,28 @@ void PlayerOptions::Init()
 
 void PlayerOptions::Approach( const PlayerOptions& other, float fDeltaSeconds )
 {
-#define APP( opt ) \
+#define APPROACH( opt ) \
 	fapproach( m_ ## opt, other.m_ ## opt, fDeltaSeconds * other.m_Speed ## opt );
 
-	APP( fTimeSpacing );
+	APPROACH( fTimeSpacing );
-	APP( fScrollSpeed );
+	APPROACH( fScrollSpeed );
 	fapproach( m_fScrollBPM, other.m_fScrollBPM, fDeltaSeconds * other.m_SpeedfScrollBPM*150 );
 	for( int i=0; i<NUM_ACCELS; i++ )
-		APP( fAccels[i] );
+		APPROACH( fAccels[i] );
 	for( int i=0; i<NUM_EFFECTS; i++ )
-		APP( fEffects[i] );
+		APPROACH( fEffects[i] );
 	for( int i=0; i<NUM_APPEARANCES; i++ )
-		APP( fAppearances[i] );
+		APPROACH( fAppearances[i] );
 	for( int i=0; i<NUM_SCROLLS; i++ )
-		APP( fScrolls[i] );
+		APPROACH( fScrolls[i] );
-	APP( fDark );
+	APPROACH( fDark );
-	APP( fBlind );
+	APPROACH( fBlind );
-	APP( fCover );
+	APPROACH( fCover );
-	APP( fPerspectiveTilt );
+	APPROACH( fPerspectiveTilt );
-	APP( fSkew );
+	APPROACH( fSkew );
-	APP( fPassmark );
+	APPROACH( fPassmark );
-	APP( fRandomSpeed );
+	APPROACH( fRandomSpeed );
+#undef APPROACH
 }
 
 static void AddPart( vector<RString> &AddTo, float level, RString name )

stepmania/src/PlayerOptions.h

@@ -114,16 +114,16 @@ public:
 	float	m_fTimeSpacing,			m_SpeedfTimeSpacing;	// instead of Beat spacing
 	float	m_fScrollSpeed,			m_SpeedfScrollSpeed;	// used if !m_bTimeSpacing
 	float	m_fScrollBPM,			m_SpeedfScrollBPM;		// used if m_bTimeSpacing
-	float	m_fAccels[NUM_ACCELS],	m_SpeedfAccels[NUM_ACCELS];
+	float	m_fAccels[NUM_ACCELS],		m_SpeedfAccels[NUM_ACCELS];
-	float	m_fEffects[NUM_EFFECTS],m_SpeedfEffects[NUM_EFFECTS];
+	float	m_fEffects[NUM_EFFECTS],	m_SpeedfEffects[NUM_EFFECTS];
 	float	m_fAppearances[NUM_APPEARANCES],m_SpeedfAppearances[NUM_APPEARANCES];
-	float	m_fScrolls[NUM_SCROLLS],m_SpeedfScrolls[NUM_SCROLLS];
+	float	m_fScrolls[NUM_SCROLLS],	m_SpeedfScrolls[NUM_SCROLLS];
-	float	m_fDark,				m_SpeedfDark;
+	float	m_fDark,			m_SpeedfDark;
-	float	m_fBlind,				m_SpeedfBlind;
+	float	m_fBlind,			m_SpeedfBlind;
-	float	m_fCover,				m_SpeedfCover;	// hide the background per-player--can't think of a good name
+	float	m_fCover,			m_SpeedfCover;	// hide the background per-player--can't think of a good name
 	bool	m_bSetTiltOrSkew;				// true if the tilt or skew was set by FromString
 	float	m_fPerspectiveTilt,		m_SpeedfPerspectiveTilt;		// -1 = near, 0 = overhead, +1 = space
-	float	m_fSkew,				m_SpeedfSkew;		// 0 = vanish point is in center of player, 1 = vanish point is in center of screen
+	float	m_fSkew,			m_SpeedfSkew;		// 0 = vanish point is in center of player, 1 = vanish point is in center of screen
 
 	float	m_fRandomSpeed,			m_SpeedfRandomSpeed;
 

stepmania/src/PlayerState.cpp

@@ -12,10 +12,7 @@ PlayerState::PlayerState()
 
 void PlayerState::Reset()
 {
-	m_CurrentPlayerOptions.Init();
 	m_PlayerOptions.Init();
-	m_StagePlayerOptions.Init();
-	m_StoredPlayerOptions.Init();
 
 	m_fLastDrawnBeat = -100;
 
@@ -41,10 +38,7 @@ void PlayerState::Reset()
 
 void PlayerState::Update( float fDelta )
 {
-	// Don't let the mod approach speed be affected by Tab.
+	m_PlayerOptions.Update( fDelta );
-	// TODO: Find a more elegant way of handling this.
-	float fRealDelta = m_timerPlayerOptions.GetDeltaTime();
-	m_CurrentPlayerOptions.Approach( m_PlayerOptions, fRealDelta );
 
 	// TRICKY: GAMESTATE->Update is run before any of the Screen update's,
 	// so we'll clear these flags here and let them get turned on later
@@ -138,14 +132,14 @@ void PlayerState::RemoveAllInventory()
 void PlayerState::RebuildPlayerOptionsFromActiveAttacks()
 {
 	// rebuild player options
-	PlayerOptions po = m_StagePlayerOptions;
+	PlayerOptions po = m_PlayerOptions.GetStage();
 	for( unsigned s=0; s<m_ActiveAttacks.size(); s++ )
 	{
 		if( !m_ActiveAttacks[s].bOn )
 			continue; /* hasn't started yet */
 		po.FromString( m_ActiveAttacks[s].sModifiers );
 	}
-	m_PlayerOptions = po;
+	MODS_GROUP_ASSIGN( m_PlayerOptions, ModsLevel_Song, = po );
 
 
 	int iSumOfAttackLevels = GetSumOfActiveAttackLevels();

stepmania/src/PlayerState.h

@@ -8,6 +8,7 @@
 #include "Attack.h"
 #include "RageTimer.h"
 struct lua_State;
+#include "ModsGroup.h"
 
 class PlayerState
 {
@@ -23,11 +24,7 @@ public:
 	MultiPlayer		m_mp;
 	
 
-	RageTimer		m_timerPlayerOptions;
+	ModsGroup<PlayerOptions>	m_PlayerOptions;
-	PlayerOptions		m_CurrentPlayerOptions;	// current approaches destination
-	PlayerOptions		m_PlayerOptions;	// change this, and current will move gradually toward it
-	PlayerOptions		m_StagePlayerOptions;	// options that are in effect for this stage.  May be different from m_StoredPlayerOptions if using forced beginner or forced Survial mods
-	PlayerOptions		m_StoredPlayerOptions;	// user's choices on the PlayerOptions screen
 
 	//
 	// Used in Gameplay

stepmania/src/ReceptorArrow.cpp

@@ -23,7 +23,7 @@ void ReceptorArrow::Load( const PlayerState* pPlayerState, int iColNo )
 	m_pReceptor.Load( NOTESKIN->GetPath(sButton,"receptor") );
 	this->AddChild( m_pReceptor );
 
-	bool bReverse = m_pPlayerState->m_PlayerOptions.GetReversePercentForColumn(m_iColNo) > 0.5f;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(m_iColNo) > 0.5f;
 	m_pReceptor->PlayCommand( bReverse? "ReverseOn":"ReverseOff" );
 	m_bWasReverse = bReverse;
 }
@@ -32,7 +32,7 @@ void ReceptorArrow::Update( float fDeltaTime )
 {
 	ActorFrame::Update( fDeltaTime );
 
-	bool bReverse = m_pPlayerState->m_PlayerOptions.GetReversePercentForColumn(m_iColNo) > 0.5f;
+	bool bReverse = m_pPlayerState->m_PlayerOptions.GetCurrent().GetReversePercentForColumn(m_iColNo) > 0.5f;
 	if( bReverse != m_bWasReverse )
 	{
 		m_pReceptor->PlayCommand( bReverse? "ReverseOn":"ReverseOff" );

stepmania/src/ReceptorArrowRow.cpp

@@ -44,7 +44,7 @@ void ReceptorArrowRow::Update( float fDeltaTime )
 	for( unsigned c=0; c<m_ReceptorArrow.size(); c++ )
 	{
 		// m_fDark==1 or m_fFadeToFailPercent==1 should make fBaseAlpha==0
-		float fBaseAlpha = (1 - m_pPlayerState->m_CurrentPlayerOptions.m_fDark) * (1 - m_fFadeToFailPercent);
+		float fBaseAlpha = (1 - m_pPlayerState->m_PlayerOptions.GetCurrent().m_fDark) * (1 - m_fFadeToFailPercent);
 		CLAMP( fBaseAlpha, 0.0f, 1.0f );
 		m_ReceptorArrow[c]->SetBaseAlpha( fBaseAlpha );
 

stepmania/src/ScoreDisplayNormal.cpp

@@ -48,7 +48,7 @@ void ScoreDisplayNormal::SetScore( int iNewScore )
 	int iMaxScore = STATSMAN->m_CurStageStats.m_player[pn].iMaxScore;
 	int iCurMaxScore = STATSMAN->m_CurStageStats.m_player[pn].iCurMaxScore;
 
-	switch( m_pPlayerState->m_CurrentPlayerOptions.m_ScoreDisplay )
+	switch( m_pPlayerState->m_PlayerOptions.GetCurrent().m_ScoreDisplay )
 	{
 	case PlayerOptions::SCORING_ADD:
 		// nothing to do

stepmania/src/ScoreKeeperNormal.cpp

@@ -76,7 +76,7 @@ void ScoreKeeperNormal::Load(
 		 * have eg. GAMESTATE->GetOptionsForCourse(po,so,pn) to get options based on
 		 * the last call to StoreSelectedOptions and the modifiers list, but that'd
 		 * mean moving the queues in ScreenGameplay to GameState ... */
-		NoteDataUtil::TransformNoteData( nd, m_pPlayerState->m_PlayerOptions, pSteps->m_StepsType );
+		NoteDataUtil::TransformNoteData( nd, m_pPlayerState->m_PlayerOptions.GetStage(), pSteps->m_StepsType );
 		RadarValues rvPost;
 		NoteDataUtil::CalculateRadarValues( nd, pSong->m_fMusicLengthSeconds, rvPost );
 		 

stepmania/src/ScreenDebugOverlay.cpp

@@ -477,12 +477,11 @@ class DebugLineAssistTick : public IDebugLine
 	virtual RString GetDescription() { return ASSIST_TICK.GetValue(); }
 	virtual RString GetValue() { return IsEnabled() ? ON.GetValue():OFF.GetValue(); }
 	virtual Type GetType() const { return gameplay_only; }
-	virtual bool IsEnabled() { return GAMESTATE->m_SongOptions.m_bAssistTick; }
+	virtual bool IsEnabled() { return GAMESTATE->m_SongOptions.GetSong().m_bAssistTick; }
 	virtual void Do( RString &sMessageOut )
 	{
-		GAMESTATE->m_SongOptions.m_bAssistTick = !GAMESTATE->m_SongOptions.m_bAssistTick;
+		bool bAssistTick = !GAMESTATE->m_SongOptions.GetSong().m_bAssistTick;
-		// Store this change, so it sticks if we change songs
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Song, .m_bAssistTick = bAssistTick );
-		GAMESTATE->m_StoredSongOptions.m_bAssistTick = GAMESTATE->m_SongOptions.m_bAssistTick;
 		MESSAGEMAN->Broadcast( Message_AssistTickChanged );
 		IDebugLine::Do( sMessageOut );
 	}
@@ -493,7 +492,7 @@ class DebugLineAutosync : public IDebugLine
 	virtual RString GetDescription() { return AUTOSYNC.GetValue(); }
 	virtual RString GetValue()
 	{ 
-		switch( GAMESTATE->m_SongOptions.m_AutosyncType )
+		switch( GAMESTATE->m_SongOptions.GetSong().m_AutosyncType )
 		{
 		case SongOptions::AUTOSYNC_OFF:		return OFF.GetValue();		break;
 		case SongOptions::AUTOSYNC_SONG:	return SONG.GetValue();		break;
@@ -502,12 +501,12 @@ class DebugLineAutosync : public IDebugLine
 		}
 	}
 	virtual Type GetType() const { return IDebugLine::gameplay_only; }
-	virtual bool IsEnabled() { return GAMESTATE->m_SongOptions.m_AutosyncType!=SongOptions::AUTOSYNC_OFF; }
+	virtual bool IsEnabled() { return GAMESTATE->m_SongOptions.GetSong().m_AutosyncType!=SongOptions::AUTOSYNC_OFF; }
 	virtual void Do( RString &sMessageOut )
 	{
-		SongOptions::AutosyncType as = (SongOptions::AutosyncType)(GAMESTATE->m_SongOptions.m_AutosyncType+1);
+		SongOptions::AutosyncType as = enum_add2( GAMESTATE->m_SongOptions.GetSong().m_AutosyncType, 1 );
 		wrap( (int&)as, SongOptions::NUM_AUTOSYNC_TYPES );
-		GAMESTATE->m_SongOptions.m_AutosyncType = as;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Song, .m_AutosyncType = as );
 		MESSAGEMAN->Broadcast( Message_AutosyncChanged );
 		IDebugLine::Do( sMessageOut );
 	}

stepmania/src/ScreenEdit.cpp

@@ -680,8 +680,6 @@ void ScreenEdit::Init()
 	GAMESTATE->m_fSongBeat = 0;
 	m_fTrailingBeat = GAMESTATE->m_fSongBeat;
 
-	GAMESTATE->StoreSelectedOptions();
-
 	m_iShiftAnchor = -1;
 	m_iStartPlayingAt = -1;
 	m_iStopPlayingAt = -1;
@@ -695,15 +693,15 @@ void ScreenEdit::Init()
 	
 	FOREACH_PlayerNumber( pn )
 	{
-		m_sOldNoteSkins[pn] = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin;
+		m_sOldNoteSkins[pn] = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetStage().m_sNoteSkin;
 		const RString &sNoteSkin = EDITOR_NOTE_SKINS[pn];
 		
 		if( NOTESKIN->DoesNoteSkinExist(sNoteSkin) )
-			GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin = sNoteSkin;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Stage, .m_sNoteSkin = sNoteSkin );
 	}
 
 	m_PlayerStateEdit.m_PlayerNumber = PLAYER_1;
-	m_PlayerStateEdit.m_PlayerOptions.m_sNoteSkin = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_sNoteSkin;
+	MODS_GROUP_ASSIGN( m_PlayerStateEdit.m_PlayerOptions, ModsLevel_Stage, .m_sNoteSkin = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.GetStage().m_sNoteSkin );
 
 	m_pSteps->GetNoteData( m_NoteDataEdit );
 	m_NoteFieldEdit.SetXY( EDIT_X, EDIT_Y );
@@ -776,7 +774,7 @@ void ScreenEdit::Init()
 ScreenEdit::~ScreenEdit()
 {
 	FOREACH_PlayerNumber( pn )
-		GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.m_sNoteSkin = m_sOldNoteSkins[pn];
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Stage, .m_sNoteSkin = m_sOldNoteSkins[pn] );
 	// UGLY: Don't delete the Song's steps.
 	m_songLastSave.DetachSteps();
 
@@ -798,7 +796,7 @@ void ScreenEdit::EndScreen()
 // play assist ticks
 void ScreenEdit::PlayTicks()
 {
-	if( !GAMESTATE->m_SongOptions.m_bAssistTick || m_EditState != STATE_PLAYING )
+	if( !GAMESTATE->m_SongOptions.GetStage().m_bAssistTick  ||  m_EditState != STATE_PLAYING )
 		return;
 			
 	/* Sound cards have a latency between when a sample is Play()ed and when the sound
@@ -962,7 +960,7 @@ void ScreenEdit::Update( float fDeltaTime )
 	float fDelta = GAMESTATE->m_fSongBeat - m_fTrailingBeat;
 	if( fabsf(fDelta) < 10 )
 		fapproach( m_fTrailingBeat, GAMESTATE->m_fSongBeat,
-			fDeltaTime*40 / m_NoteFieldEdit.GetPlayerState()->m_CurrentPlayerOptions.m_fScrollSpeed );
+			fDeltaTime*40 / m_NoteFieldEdit.GetPlayerState()->m_PlayerOptions.GetCurrent().m_fScrollSpeed );
 	else
 		fapproach( m_fTrailingBeat, GAMESTATE->m_fSongBeat,
 			fabsf(fDelta) * fDeltaTime*5 );
@@ -1233,7 +1231,7 @@ void ScreenEdit::InputEdit( const InputEventPlus &input, EditButton EditB )
 	case EDIT_BUTTON_SCROLL_SPEED_DOWN:
 		{
 			PlayerState *pPlayerState = const_cast<PlayerState *> (m_NoteFieldEdit.GetPlayerState());
-			float& fScrollSpeed = pPlayerState->m_PlayerOptions.m_fScrollSpeed;
+			float fScrollSpeed = pPlayerState->m_PlayerOptions.GetStage().m_fScrollSpeed;
 
 			const float fSpeeds[] = { 1.0f, 1.5f, 2.0f, 3.0f, 4.0f, 6.0f, 8.0f };
 			int iSpeed = 0;
@@ -1258,6 +1256,7 @@ void ScreenEdit::InputEdit( const InputEventPlus &input, EditButton EditB )
 				fScrollSpeed = fSpeeds[iSpeed];
 			}
 
+			MODS_GROUP_ASSIGN( pPlayerState->m_PlayerOptions, ModsLevel_Stage, .m_fScrollSpeed = fScrollSpeed );
 			break;
 		}
 
@@ -1389,7 +1388,7 @@ void ScreenEdit::InputEdit( const InputEventPlus &input, EditButton EditB )
 		DoHelp();
 		break;
 	case EDIT_BUTTON_TOGGLE_ASSIST_TICK:
-		GAMESTATE->m_SongOptions.m_bAssistTick ^= 1;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_bAssistTick ^= 1 );
 		break;
 	case EDIT_BUTTON_OPEN_NEXT_STEPS:
 	case EDIT_BUTTON_OPEN_PREV_STEPS:
@@ -1784,7 +1783,7 @@ void ScreenEdit::InputEdit( const InputEventPlus &input, EditButton EditB )
 			}
 			g_fLastInsertAttackPositionSeconds = fStart;
 			g_fLastInsertAttackDurationSeconds = fEnd - fStart;
-			GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions = po;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Stage, = po );
 			SCREENMAN->AddNewScreenToTop( "ScreenPlayerOptions", SM_BackFromInsertCourseAttackPlayerOptions );
 			
 		}
@@ -2028,7 +2027,7 @@ void ScreenEdit::InputPlay( const InputEventPlus &input, EditButton EditB )
 		TransitionEditState( STATE_EDITING );
 		break;
 	case EDIT_BUTTON_TOGGLE_ASSIST_TICK:
-		GAMESTATE->m_SongOptions.m_bAssistTick ^= 1;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_bAssistTick ^= 1 );
 		break;
 	case EDIT_BUTTON_TOGGLE_AUTOPLAY:
 		{
@@ -2151,12 +2150,13 @@ void ScreenEdit::TransitionEditState( EditState em )
 		{
 		case STATE_RECORDING:
 		case STATE_RECORDING_PAUSED:
-			GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_fScrolls[PlayerOptions::SCROLL_CENTERED] = 1.0f;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Stage, .m_fScrolls[PlayerOptions::SCROLL_CENTERED] = 1.0f );
 			break;
 		}
 
 		/* Snap to current options. */
-		GAMESTATE->m_pPlayerState[PLAYER_1]->m_CurrentPlayerOptions = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions;
+
+		GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_current = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.GetStage();
 	}
 
 	switch( em )
@@ -2205,9 +2205,6 @@ void ScreenEdit::TransitionEditState( EditState em )
 	switch( em )
 	{
 	case STATE_PLAYING:
-		GAMESTATE->RestoreSelectedOptions();
-		GAMESTATE->StoreStageOptions();
-
 		/* If we're in course display mode, set that up. */
 		SetupCourseAttacks();
 		
@@ -2275,7 +2272,7 @@ void ScreenEdit::TransitionEditState( EditState em )
 		LOG->Trace( "Starting playback at %f", fStartSeconds );
 
 		RageSoundParams p;
-		p.SetPlaybackRate( GAMESTATE->m_SongOptions.m_fMusicRate );
+		p.SetPlaybackRate( GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate );
 		p.m_StartSecond = fStartSeconds;
 		p.m_bAccurateSync = true;
 		p.StopMode = RageSoundParams::M_CONTINUE;
@@ -2415,9 +2412,6 @@ void ScreenEdit::HandleScreenMessage( const ScreenMessage SM )
 	}
 	else if( SM == SM_BackFromOptions )
 	{
-		// Store the new options, so they stick when we RebuildPlayerOptionsFromActiveAttacks.
-		GAMESTATE->StoreSelectedOptions();
-
 		// The options may have changed the note skin.
 		m_NoteFieldRecord.CacheAllUsedNoteSkins();
 		m_Player->CacheAllUsedNoteSkins();
@@ -2434,7 +2428,7 @@ void ScreenEdit::HandleScreenMessage( const ScreenMessage SM )
 	}
 	else if( SM == SM_BackFromInsertTapAttackPlayerOptions )
 	{
-		PlayerOptions poChosen = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions;
+		PlayerOptions poChosen = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.GetPreferred();
 		RString sMods = poChosen.GetString();
 		const int row = BeatToNoteRow( GAMESTATE->m_fSongBeat );
 		
@@ -2474,13 +2468,13 @@ void ScreenEdit::HandleScreenMessage( const ScreenMessage SM )
 			if( iAttack >= 0 )
 				po.FromString( ce.attacks[iAttack].sModifiers );
 
-			GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions = po;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Preferred, = po );
 			SCREENMAN->AddNewScreenToTop( "ScreenPlayerOptions", SM_BackFromInsertCourseAttackPlayerOptions );
 		}
 	}
 	else if( SM == SM_BackFromInsertCourseAttackPlayerOptions )
 	{
-		PlayerOptions poChosen = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions;
+		PlayerOptions poChosen = GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.GetPreferred();
 		RString sMods = poChosen.GetString();
 
 		Course *pCourse = GAMESTATE->m_pCurCourse;

stepmania/src/ScreenEnding.cpp

@@ -40,11 +40,11 @@ ScreenEnding::ScreenEnding() : ScreenAttract( false/*dont reset GAMESTATE*/ )
 		GAMESTATE->m_pCurSteps[PLAYER_2].Set( GAMESTATE->m_pCurSong->GetAllSteps()[0] );
 		STATSMAN->m_CurStageStats.m_player[PLAYER_1].vpPlayedSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_1] );
 		STATSMAN->m_CurStageStats.m_player[PLAYER_2].vpPlayedSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_2] );
-		GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_fScrollSpeed = 2;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Stage, .m_fScrollSpeed = 2 );
-		GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.m_fScrollSpeed = 2;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions, ModsLevel_Stage, .m_fScrollSpeed = 2 );
 		GAMESTATE->m_iCurrentStageIndex = 0;
-		GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.ChooseRandomModifiers();
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Stage, .ChooseRandomModifiers() );
-		GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.ChooseRandomModifiers();
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions, ModsLevel_Stage, .ChooseRandomModifiers() );
 
 		for( float f = 0; f < 100.0f; f += 1.0f )
 		{

stepmania/src/ScreenEvaluation.cpp

@@ -107,7 +107,7 @@ ScreenEvaluation::ScreenEvaluation()
 		FOREACH_PlayerNumber( p )
 		{
 			if( RandomInt(2) )
-				GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_bTransforms[PlayerOptions::TRANSFORM_ECHO] = true;	// show "disqualified"
+				MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .m_bTransforms[PlayerOptions::TRANSFORM_ECHO] = true );	// show "disqualified"
 
 			GAMESTATE->m_bSideIsJoined[p] = true;
 			GAMESTATE->m_pCurSteps[p].Set( GAMESTATE->m_pCurSong->GetAllSteps()[0] );
@@ -117,8 +117,10 @@ ScreenEvaluation::ScreenEvaluation()
 				GAMESTATE->m_pCurTrail[p].Set( apTrails[0] );
 			STATSMAN->m_CurStageStats.m_player[p].vpPlayedSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_1] );
 			STATSMAN->m_CurStageStats.m_player[p].vpPossibleSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_1] );
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_fScrollSpeed = 2;
+			
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.ChooseRandomModifiers();
+			
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .m_fScrollSpeed = 2 );
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .ChooseRandomModifiers() );
 		}
 
 		for( float f = 0; f < 100.0f; f += 1.0f )
@@ -328,7 +330,7 @@ void ScreenEvaluation::Init()
 				m_textPlayerOptions[p].SetName( ssprintf("PlayerOptionsP%d",p+1) );
 				SET_XY_AND_ON_COMMAND( m_textPlayerOptions[p] );
 				vector<RString> v;
-				GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetLocalizedMods( v );
+				GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetStage().GetLocalizedMods( v );
 				RString sPO = join( PLAYER_OPTIONS_SEPARATOR, v );
 				m_textPlayerOptions[p].SetText( sPO );
 				this->AddChild( &m_textPlayerOptions[p] );

stepmania/src/ScreenEz2SelectMusic.cpp

@@ -315,7 +315,7 @@ void ScreenEz2SelectMusic::Input( const InputEventPlus &input )
 
 void ScreenEz2SelectMusic::UpdateOptions(PlayerNumber pn, int nosound)
 {
-	sOptions = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetString();
+	sOptions = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred().GetString();
 
 	LOG->Trace( "DEBUG: " + sOptions );
 

stepmania/src/ScreenGameplay.cpp

@@ -135,7 +135,7 @@ void PlayerInfo::Load( PlayerNumber pn, MultiPlayer mp, bool bShowNoteField )
 			break;
 		case PLAY_MODE_ONI:
 		case PLAY_MODE_ENDLESS:
-			if( GAMESTATE->m_SongOptions.m_LifeType == SongOptions::LIFE_TIME )
+			if( GAMESTATE->m_SongOptions.GetStage().m_LifeType == SongOptions::LIFE_TIME )
 				m_pPrimaryScoreDisplay = new ScoreDisplayLifeTime;
 			else
 				m_pPrimaryScoreDisplay = new ScoreDisplayOni;
@@ -180,10 +180,7 @@ void PlayerInfo::Load( PlayerNumber pn, MultiPlayer mp, bool bShowNoteField )
 
 	if( IsMultiPlayer() )
 	{
-		pPlayerState->m_CurrentPlayerOptions	= GAMESTATE->m_pPlayerState[PLAYER_1]->m_CurrentPlayerOptions;
+		pPlayerState->m_PlayerOptions	= GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions;
-		pPlayerState->m_PlayerOptions		= GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions;
-		pPlayerState->m_StagePlayerOptions	= GAMESTATE->m_pPlayerState[PLAYER_1]->m_StagePlayerOptions;
-		pPlayerState->m_StoredPlayerOptions	= GAMESTATE->m_pPlayerState[PLAYER_1]->m_StoredPlayerOptions;
 	}
 }
 
@@ -351,17 +348,11 @@ void ScreenGameplay::Init( bool bUseSongBackgroundAndForeground )
 		m_pSongForeground = new Foreground;
 	}
 
-	/* Save selected options before we change them in ScreenInitCommand. */
-	GAMESTATE->StoreSelectedOptions();
-
 	ScreenWithMenuElements::Init();
 
 	this->FillPlayerInfo( m_vPlayerInfo );
 	ASSERT_M( !m_vPlayerInfo.empty(), "m_vPlayerInfo must be filled by FillPlayerInfo" );
 
-	/* Save selected stage options now that we've changed them in ScreenInitCommand. */
-	GAMESTATE->StoreStageOptions();
-
 	/* Pause MEMCARDMAN.  If a memory card is removed, we don't want to interrupt the
 	 * player by making a noise until the game finishes. */
 	if( !GAMESTATE->m_bDemonstrationOrJukebox )
@@ -491,7 +482,7 @@ void ScreenGameplay::Init( bool bUseSongBackgroundAndForeground )
 	this->AddChild( &m_SongFinished );
 
 
-	bool bBattery = GAMESTATE->m_SongOptions.m_LifeType==SongOptions::LIFE_BATTERY;
+	bool bBattery = GAMESTATE->m_SongOptions.GetStage().m_LifeType==SongOptions::LIFE_BATTERY;
 
 	//
 	// Add LifeFrame
@@ -548,7 +539,7 @@ void ScreenGameplay::Init( bool bUseSongBackgroundAndForeground )
 			if( !GAMESTATE->IsPlayerEnabled(pi->m_pn) && !SHOW_LIFE_METER_FOR_DISABLED_PLAYERS )
 				continue;	// skip
 
-			pi->m_pLifeMeter = LifeMeter::MakeLifeMeter( GAMESTATE->m_SongOptions.m_LifeType );
+			pi->m_pLifeMeter = LifeMeter::MakeLifeMeter( GAMESTATE->m_SongOptions.GetStage().m_LifeType );
 			pi->m_pLifeMeter->Load( pi->GetPlayerState(), pi->GetPlayerStageStats() );
 			pi->m_pLifeMeter->SetName( ssprintf("Life%s",pi->GetName().c_str()) );
 			SET_XY( pi->m_pLifeMeter );
@@ -682,7 +673,7 @@ void ScreenGameplay::Init( bool bUseSongBackgroundAndForeground )
 	m_textSongOptions.SetShadowLength( 0 );
 	m_textSongOptions.SetName( "SongOptions" );
 	SET_XY( m_textSongOptions );
-	m_textSongOptions.SetText( GAMESTATE->m_SongOptions.GetLocalizedString() );
+	m_textSongOptions.SetText( GAMESTATE->m_SongOptions.GetStage().GetLocalizedString() );
 	this->AddChild( &m_textSongOptions );
 
 	FOREACH_VisiblePlayerInfo( m_vPlayerInfo, pi )
@@ -846,7 +837,7 @@ void ScreenGameplay::InitSongQueues()
 			// In a survival course, override stored mods
 			if( pCourse->GetCourseType() == COURSE_TYPE_SURVIVAL )
 			{
-				pi->GetPlayerState()->m_StagePlayerOptions.FromString( "clearall,"+CommonMetrics::DEFAULT_MODIFIERS.GetValue() );
+				MODS_GROUP_ASSIGN( pi->GetPlayerState()->m_PlayerOptions, ModsLevel_Stage, .FromString("clearall,"+CommonMetrics::DEFAULT_MODIFIERS.GetValue()) );
 				pi->GetPlayerState()->RebuildPlayerOptionsFromActiveAttacks();
 			}
 		}
@@ -977,14 +968,14 @@ void ScreenGameplay::SetupSong( int iSongIndex )
 				a.fStartSecond = -1;	// now
 			
 			pi->GetPlayerState()->LaunchAttack( a );
-			GAMESTATE->m_SongOptions.FromString( a.sModifiers );
+			MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Song, .FromString(a.sModifiers) );
 		}
 
 		/* Update attack bOn flags. */
 		pi->GetPlayerState()->Update( 0 );
 
 		/* Hack: Course modifiers that are set to start immediately shouldn't tween on. */
-		pi->GetPlayerState()->m_CurrentPlayerOptions = pi->GetPlayerState()->m_PlayerOptions;
+		pi->GetPlayerState()->m_PlayerOptions.m_current = pi->GetPlayerState()->m_PlayerOptions.GetStage();
 	}
 }
 
@@ -1033,14 +1024,12 @@ void ScreenGameplay::LoadNextSong()
 	// No need to do this here.  We do it in SongFinished().
 	//GAMESTATE->RemoveAllActiveAttacks();
 
-	GAMESTATE->RestoreStageOptions();
-
 	/* If we're in battery mode, force FailImmediate.  We assume in PlayerMinus::Step that
 	 * failed players can't step. */
-	if( GAMESTATE->m_SongOptions.m_LifeType == SongOptions::LIFE_BATTERY )
+	if( GAMESTATE->m_SongOptions.GetCurrent().m_LifeType == SongOptions::LIFE_BATTERY )
-		GAMESTATE->m_SongOptions.m_FailType = SongOptions::FAIL_IMMEDIATE;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Song, .m_FailType = SongOptions::FAIL_IMMEDIATE );
 
-	m_textSongOptions.SetText( GAMESTATE->m_SongOptions.GetString() );
+	m_textSongOptions.SetText( GAMESTATE->m_SongOptions.GetCurrent().GetString() );
 
 	SetupSong( iPlaySongIndex );
 
@@ -1063,17 +1052,17 @@ void ScreenGameplay::LoadNextSong()
 		}
 
 		if( pi->m_ptextPlayerOptions )
-			pi->m_ptextPlayerOptions->SetText( pi->GetPlayerState()->m_PlayerOptions.GetString() );
+			pi->m_ptextPlayerOptions->SetText( pi->GetPlayerState()->m_PlayerOptions.GetCurrent().GetString() );
 		if( pi->m_pActiveAttackList )
 			pi->m_pActiveAttackList->Refresh();
 
 		// reset oni game over graphic
 		SET_XY_AND_ON_COMMAND( pi->m_sprOniGameOver );
 
-		if( GAMESTATE->m_SongOptions.m_LifeType==SongOptions::LIFE_BATTERY && pi->GetPlayerStageStats()->bFailed )	// already failed
+		if( GAMESTATE->m_SongOptions.GetCurrent().m_LifeType==SongOptions::LIFE_BATTERY && pi->GetPlayerStageStats()->bFailed )	// already failed
 			pi->ShowOniGameOver();
 
-		if( GAMESTATE->m_SongOptions.m_LifeType==SongOptions::LIFE_BAR && 
+		if( GAMESTATE->m_SongOptions.GetCurrent().m_LifeType==SongOptions::LIFE_BAR && 
 			GAMESTATE->m_PlayMode == PLAY_MODE_REGULAR && 
 			!GAMESTATE->IsEventMode() && 
 			!GAMESTATE->m_bDemonstrationOrJukebox )
@@ -1084,7 +1073,7 @@ void ScreenGameplay::LoadNextSong()
 					PREFSMAN->m_iSongsPerPlay, 
 					PREFSMAN->m_iProgressiveStageLifebar);
 		}
-		if( GAMESTATE->m_SongOptions.m_LifeType==SongOptions::LIFE_BAR && GAMESTATE->m_PlayMode == PLAY_MODE_NONSTOP )
+		if( GAMESTATE->m_SongOptions.GetCurrent().m_LifeType==SongOptions::LIFE_BAR && GAMESTATE->m_PlayMode == PLAY_MODE_NONSTOP )
 		{
 			if( pi->m_pLifeMeter )
 				pi->m_pLifeMeter->UpdateNonstopLifebar(
@@ -1137,7 +1126,7 @@ void ScreenGameplay::LoadNextSong()
 	bool bAtLeastOneReverse = false;
 	FOREACH_EnabledPlayerInfo( m_vPlayerInfo, pi )
 	{
-		if( pi->GetPlayerState()->m_PlayerOptions.m_fScrolls[PlayerOptions::SCROLL_REVERSE] == 1 )
+		if( pi->GetPlayerState()->m_PlayerOptions.GetCurrent().m_fScrolls[PlayerOptions::SCROLL_REVERSE] == 1 )
 			bAtLeastOneReverse = true;
 		else
 			bAllReverse = false;
@@ -1145,7 +1134,7 @@ void ScreenGameplay::LoadNextSong()
 
 	FOREACH_EnabledPlayerInfo( m_vPlayerInfo, pi )
 	{
-		bool bReverse = pi->GetPlayerState()->m_PlayerOptions.m_fScrolls[PlayerOptions::SCROLL_REVERSE] == 1;
+		bool bReverse = pi->GetPlayerState()->m_PlayerOptions.GetCurrent().m_fScrolls[PlayerOptions::SCROLL_REVERSE] == 1;
 
 		if( pi->m_pDifficultyIcon )
 		{
@@ -1329,7 +1318,7 @@ float ScreenGameplay::StartPlayingSong(float MinTimeToNotes, float MinTimeToMusi
 	
 	RageSoundParams p;
 	p.m_bAccurateSync = true;
-	p.SetPlaybackRate( GAMESTATE->m_SongOptions.m_fMusicRate );
+	p.SetPlaybackRate( GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate );
 	p.StopMode = RageSoundParams::M_CONTINUE;
 	p.m_StartSecond = fStartSecond;
 
@@ -1381,7 +1370,7 @@ void ScreenGameplay::PauseGame( bool bPause, GameController gc )
 // play assist ticks
 void ScreenGameplay::PlayTicks()
 {
-	if( !GAMESTATE->m_SongOptions.m_bAssistTick )
+	if( !GAMESTATE->m_SongOptions.GetCurrent().m_bAssistTick )
 		return;
 
 	/* Sound cards have a latency between when a sample is Play()ed and when the sound
@@ -1412,7 +1401,7 @@ void ScreenGameplay::PlayTicks()
 		const float fTickBeat = NoteRowToBeat( iTickRow );
 		const float fTickSecond = GAMESTATE->m_pCurSong->m_Timing.GetElapsedTimeFromBeatNoOffset( fTickBeat );
 		float fSecondsUntil = fTickSecond - GAMESTATE->m_fMusicSeconds;
-		fSecondsUntil /= GAMESTATE->m_SongOptions.m_fMusicRate; /* 2x music rate means the time until the tick is halved */
+		fSecondsUntil /= GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate; /* 2x music rate means the time until the tick is halved */
 
 		RageSoundParams p;
 		p.m_StartTime = GAMESTATE->m_LastBeatUpdate + (fSecondsUntil - (float)CommonMetrics::TICK_EARLY_SECONDS);
@@ -1602,7 +1591,7 @@ void ScreenGameplay::Update( float fDeltaTime )
 			PlayerNumber pn = pi->GetStepsAndTrailIndex();
 
 			SongOptions::FailType ft = GAMESTATE->GetPlayerFailType( pi->GetPlayerState() );
-			SongOptions::LifeType lt = GAMESTATE->m_SongOptions.m_LifeType;
+			SongOptions::LifeType lt = GAMESTATE->m_SongOptions.GetCurrent().m_LifeType;
 
 			if( ft == SongOptions::FAIL_OFF )
 				continue;
@@ -1676,7 +1665,7 @@ void ScreenGameplay::Update( float fDeltaTime )
 		//
 		FOREACH_EnabledPlayerInfo( m_vPlayerInfo, pi )
 			if( !pi->GetPlayerStageStats()->bFailed )
-				pi->GetPlayerStageStats()->fAliveSeconds += fDeltaTime * GAMESTATE->m_SongOptions.m_fMusicRate;
+				pi->GetPlayerStageStats()->fAliveSeconds += fDeltaTime * GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate;
 
 		// update fGameplaySeconds
 		STATSMAN->m_CurStageStats.fGameplaySeconds += fDeltaTime;
@@ -2262,12 +2251,6 @@ void ScreenGameplay::StageFinished( bool bBackedOut )
 	// save current stage stats
 	if( !bBackedOut )
 		STATSMAN->m_vPlayedStageStats.push_back( STATSMAN->m_CurStageStats );
-
-	/* Reset options. */
-	if( bBackedOut )
-		GAMESTATE->RestoreSelectedOptions();
-	else
-		GAMESTATE->RestoreStageOptions();
 }
 
 void ScreenGameplay::HandleScreenMessage( const ScreenMessage SM )
@@ -2302,12 +2285,12 @@ void ScreenGameplay::HandleScreenMessage( const ScreenMessage SM )
 		FOREACH_EnabledPlayerInfo( m_vPlayerInfo, pi )
 		{
 			/* If either player's passmark is enabled, check it. */
-			if( pi->GetPlayerState()->m_PlayerOptions.m_fPassmark > 0 &&
+			if( pi->GetPlayerState()->m_PlayerOptions.GetCurrent().m_fPassmark > 0 &&
 				pi->m_pLifeMeter &&
-				pi->m_pLifeMeter->GetLife() < pi->GetPlayerState()->m_PlayerOptions.m_fPassmark )
+				pi->m_pLifeMeter->GetLife() < pi->GetPlayerState()->m_PlayerOptions.GetCurrent().m_fPassmark )
 			{
 				LOG->Trace("Player %i failed: life %f is under %f",
-					pi->GetPlayerStateAndStageStatsIndex()+1, pi->m_pLifeMeter->GetLife(), pi->GetPlayerState()->m_PlayerOptions.m_fPassmark );
+					pi->GetPlayerStateAndStageStatsIndex()+1, pi->m_pLifeMeter->GetLife(), pi->GetPlayerState()->m_PlayerOptions.GetCurrent().m_fPassmark );
 				pi->GetPlayerStageStats()->bFailed = true;
 			}
 

stepmania/src/ScreenGameplaySyncMachine.cpp

@@ -28,7 +28,7 @@ void ScreenGameplaySyncMachine::Init()
 	ASSERT( pSteps );
 	GAMESTATE->m_pCurSteps[0].Set( pSteps );
 
-	GAMESTATE->m_SongOptions.m_AutosyncType = SongOptions::AUTOSYNC_MACHINE;
+	MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_AutosyncType = SongOptions::AUTOSYNC_MACHINE );
 	PREFSMAN->m_AutoPlay.Set( PC_HUMAN );
 
 	ScreenGameplayNormal::Init( false );

stepmania/src/ScreenHowToPlay.cpp

@@ -170,7 +170,7 @@ void ScreenHowToPlay::Init()
 		SET_XY_AND_ON_COMMAND( m_Player );
 
 		// Don't show judgement
-		GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_fBlind = 1;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions, ModsLevel_Stage, .m_fBlind = 1 );
 		GAMESTATE->m_MasterPlayerNumber = PLAYER_1;
 		GAMESTATE->m_bDemonstrationOrJukebox = true;
 	}

stepmania/src/ScreenJukebox.cpp

@@ -200,13 +200,13 @@ void ScreenJukebox::Init()
 		{
 			/* Lots and lots of arrows.  This might even bias to arrows a little
 			 * too much. */
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions = PlayerOptions();
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = PlayerOptions() );
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_fScrollSpeed = .25f;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .m_fScrollSpeed = .25f );
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_fPerspectiveTilt = -1;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .m_fPerspectiveTilt = -1 );
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_fEffects[ PlayerOptions::EFFECT_MINI ] = 1;
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, .m_fEffects[ PlayerOptions::EFFECT_MINI ] = 1 );
 		}
-		GAMESTATE->m_SongOptions.m_LifeType = SongOptions::LIFE_BATTERY;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_LifeType = SongOptions::LIFE_BATTERY );
-		GAMESTATE->m_SongOptions.m_FailType = SongOptions::FAIL_OFF;
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_FailType = SongOptions::FAIL_OFF );
 	}
 
 	FOREACH_EnabledPlayer( p )
@@ -216,14 +216,18 @@ void ScreenJukebox::Init()
 
 		if( GAMESTATE->m_bJukeboxUsesModifiers )
 		{
-			GAMESTATE->GetDefaultPlayerOptions( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions );
+			PlayerOptions po;
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.ChooseRandomModifiers();
+			GAMESTATE->GetDefaultPlayerOptions( po );
+			po.ChooseRandomModifiers();
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = po );
 		}
 	}
 
-	GAMESTATE->GetDefaultSongOptions( GAMESTATE->m_SongOptions );
+	SongOptions so;
+	GAMESTATE->GetDefaultSongOptions( so );
+	MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, = so );
 
-	GAMESTATE->m_SongOptions.m_FailType = SongOptions::FAIL_OFF;
+	MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_FailType = SongOptions::FAIL_OFF );
 
 	GAMESTATE->m_bDemonstrationOrJukebox = true;
 

stepmania/src/ScreenNameEntry.cpp

@@ -111,15 +111,11 @@ void ScreenNameEntry::Init()
 	g_iNumCharsToDrawTotal = NUM_CHARS_TO_DRAW_TOTAL;
 	g_fFakeBeatsPerSec = FAKE_BEATS_PER_SEC;
 
-	/* Save options.  We'll reset them to display letters, and we must put them
-	 * back when we're done. */
-	GAMESTATE->StoreSelectedOptions();
-
 	// reset Player and Song Options
 	{
 		FOREACH_PlayerNumber( p )
-			GAMESTATE->m_pPlayerState[p]->m_PlayerOptions = PlayerOptions();
+			MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = PlayerOptions() );
-		GAMESTATE->m_SongOptions = SongOptions();
+		MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, = SongOptions() );
 	}
 
 	vector<GameState::RankingFeat> aFeats[NUM_PLAYERS];
@@ -169,14 +165,16 @@ void ScreenNameEntry::Init()
 			continue;	// skip
 
 		// remove modifiers that may have been on the last song
-		GAMESTATE->GetDefaultPlayerOptions( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions );
+		PlayerOptions po;
+		GAMESTATE->GetDefaultPlayerOptions( po );
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions, ModsLevel_Stage, = po );
 
 		ASSERT( GAMESTATE->IsHumanPlayer(p) );	// they better be enabled if they made a high score!
 
 		float fPlayerX = PLAYER_X(p,GAMESTATE->GetCurrentStyle()->m_StyleType);
 
 		{
-			LockNoteSkin l( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.m_sNoteSkin );
+			LockNoteSkin l( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetCurrent().m_sNoteSkin );
 
 			m_ReceptorArrowRow[p].Load( GAMESTATE->m_pPlayerState[p], 0 );
 			m_ReceptorArrowRow[p].SetX( fPlayerX );
@@ -376,8 +374,6 @@ void ScreenNameEntry::HandleScreenMessage( const ScreenMessage SM )
 	}
 	else if( SM == SM_GoToNextScreen )
 	{
-		GAMESTATE->RestoreSelectedOptions();
-
 		// There shouldn't be NameEntry in event mode.  -Chris
 //		/* Hack: go back to the select course screen in event mode. */
 //		if( GAMESTATE->GetEventMode() && GAMESTATE->IsCourseMode() )

stepmania/src/ScreenOptionsEditCourseEntry.cpp

@@ -312,7 +312,7 @@ void ScreenOptionsEditCourseEntry::HandleScreenMessage( const ScreenMessage SM )
 	}
 	else if( SM == SM_BackFromCoursePlayerOptions )
 	{
-		const PlayerOptions &po = GAMESTATE->m_pPlayerState[GAMESTATE->m_MasterPlayerNumber]->m_PlayerOptions;
+		const PlayerOptions &po = GAMESTATE->m_pPlayerState[GAMESTATE->m_MasterPlayerNumber]->m_PlayerOptions.GetPreferred();
 		CourseEntry &ce = pCourse->m_vEntries[GAMESTATE->m_iEditCourseEntryIndex];
 		
 		ce.sModifiers = po.GetString();

stepmania/src/ScreenPlayerOptions.cpp

@@ -99,7 +99,9 @@ void ScreenPlayerOptions::Input( const InputEventPlus &input )
 	if( GAMESTATE->IsHumanPlayer(pn) && CodeDetector::EnteredCode(input.GameI.controller,CODE_CANCEL_ALL_PLAYER_OPTIONS) )
 	{
 		// apply the game default mods, but not the Profile saved mods
-		GAMESTATE->GetDefaultPlayerOptions( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions );
+		PlayerOptions po;
+		GAMESTATE->GetDefaultPlayerOptions( po );
+		MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, = po );
 		
 		MESSAGEMAN->Broadcast( ssprintf("CancelAllP%i", pn+1) );
 
@@ -152,15 +154,14 @@ void ScreenPlayerOptions::UpdateDisqualified( int row, PlayerNumber pn )
 	ASSERT( GAMESTATE->IsHumanPlayer(pn) );
 
 	// save original player options 
-	PlayerOptions poOrig = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions;
+	PlayerOptions poOrig = GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions.GetPreferred();
 
 	// Find out if the current row when exprorted causes disqualification.
 	// Exporting the row will fill GAMESTATE->m_PlayerOptions.
-	GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions = PlayerOptions();
+	MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, = PlayerOptions() );
 	vector<PlayerNumber> v;
 	v.push_back( pn );
 	ExportOptions( row, v );
-	GAMESTATE->StoreSelectedOptions();
 	bool bRowCausesDisqualified = GAMESTATE->IsDisqualified( pn );
 	m_bRowCausesDisqualified[pn][row] = bRowCausesDisqualified;
 
@@ -177,7 +178,7 @@ void ScreenPlayerOptions::UpdateDisqualified( int row, PlayerNumber pn )
 	m_sprDisqualify[pn]->SetHidden( !bDisqualified );
 
 	// restore previous player options in case the user escapes back after this
-	GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions = poOrig;
+	MODS_GROUP_ASSIGN( GAMESTATE->m_pPlayerState[pn]->m_PlayerOptions, ModsLevel_Preferred, = poOrig );
 }
 
 // lua start

stepmania/src/ScreenSelectMusic.cpp

@@ -1170,8 +1170,8 @@ void ScreenSelectMusic::MenuStart( PlayerNumber pn )
 			// apply #LIVES
 			if( pCourse->m_iLives != -1 )
 			{
-				GAMESTATE->m_SongOptions.m_LifeType = SongOptions::LIFE_BATTERY;
+				MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_LifeType = SongOptions::LIFE_BATTERY );
-				GAMESTATE->m_SongOptions.m_iBatteryLives = pCourse->m_iLives;
+				MODS_GROUP_ASSIGN( GAMESTATE->m_SongOptions, ModsLevel_Stage, .m_iBatteryLives = pCourse->m_iLives );
 			}
 
 			m_bMadeChoice = true;

stepmania/src/ScreenSongOptions.cpp

@@ -22,11 +22,11 @@ void ScreenSongOptions::Init()
 
 void ScreenSongOptions::ExportOptions( int iRow, const vector<PlayerNumber> &vpns )
 {
-	const SongOptions::FailType ft = GAMESTATE->m_SongOptions.m_FailType;
+	const SongOptions::FailType ft = GAMESTATE->m_SongOptions.GetPreferred().m_FailType;
 
 	ScreenOptionsMaster::ExportOptions( iRow, vpns );
 
-	if( ft != GAMESTATE->m_SongOptions.m_FailType )
+	if( ft != GAMESTATE->m_SongOptions.GetPreferred().m_FailType )
 		GAMESTATE->m_bChangedFailTypeOnScreenSongOptions = true;
 }
 

stepmania/src/ScreenSyncOverlay.cpp

@@ -98,7 +98,7 @@ void ScreenSyncOverlay::UpdateText()
 		}
 	}
 
-	switch( GAMESTATE->m_SongOptions.m_AutosyncType )
+	switch( GAMESTATE->m_SongOptions.GetCurrent().m_AutosyncType )
 	{
 	case SongOptions::AUTOSYNC_OFF:							break;
 	case SongOptions::AUTOSYNC_SONG:	vs.push_back(AUTO_SYNC_SONG);		break;

stepmania/src/SongOptions.cpp

@@ -12,10 +12,29 @@ void SongOptions::Init()
 	m_FailType = FAIL_IMMEDIATE;
 	m_bAssistTick = false;
 	m_fMusicRate = 1.0f;
+	m_SpeedfMusicRate = 1.0f;
 	m_AutosyncType = AUTOSYNC_OFF;
 	m_bSaveScore = true;
 }
 
+void SongOptions::Approach( const SongOptions& other, float fDeltaSeconds )
+{
+#define APPROACH( opt ) \
+	fapproach( m_ ## opt, other.m_ ## opt, fDeltaSeconds * other.m_Speed ## opt );
+#define DO_COPY( x ) \
+	x = other.x;
+
+	DO_COPY( m_LifeType );
+	DO_COPY( m_DrainType );
+	DO_COPY( m_iBatteryLives );
+	APPROACH( fMusicRate );
+	DO_COPY( m_bAssistTick );
+	DO_COPY( m_AutosyncType );
+	DO_COPY( m_bSaveScore );
+#undef APPROACH
+#undef DO_COPY
+}
+
 void SongOptions::GetMods( vector<RString> &AddTo ) const
 {
 	switch( m_LifeType )

stepmania/src/SongOptions.h

@@ -27,7 +27,7 @@ public:
 		FAIL_END_OF_SONG,			// fail on end of song if life touched 0
 		FAIL_OFF };					// never fail
 	FailType m_FailType;
-	float m_fMusicRate;
+	float m_fMusicRate,	m_SpeedfMusicRate;
 	bool m_bAssistTick;
 	enum AutosyncType { 
 		AUTOSYNC_OFF,
@@ -38,8 +38,10 @@ public:
 	AutosyncType m_AutosyncType;
 	bool m_bSaveScore;
 
+
 	SongOptions() { Init(); };
 	void Init();
+	void Approach( const SongOptions& other, float fDeltaSeconds );
 	void GetMods( vector<RString> &AddTo ) const;
 	void GetLocalizedMods( vector<RString> &AddTo ) const;
 	RString GetString() const;

stepmania/src/StageStats.cpp

@@ -151,7 +151,7 @@ void StageStats::CommitScores( bool bSummary )
 	}
 
 	// don't save scores if the player chose not to
-	if( !GAMESTATE->m_SongOptions.m_bSaveScore )
+	if( !GAMESTATE->m_SongOptions.GetCurrent().m_bSaveScore )
 		return;
 
 	LOG->Trace( "saving stats and high scores" );
@@ -172,7 +172,7 @@ void StageStats::CommitScores( bool bSummary )
 		hs.SetScore( m_player[p].iScore );
 		hs.SetPercentDP( m_player[p].GetPercentDancePoints() );
 		hs.SetSurviveSeconds( m_player[p].fAliveSeconds );
-		hs.SetModifiers( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetString() );
+		hs.SetModifiers( GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetStage().GetString() );
 		hs.SetDateTime( DateTime::GetNowDateTime() );
 		hs.SetPlayerGuid( PROFILEMAN->IsPersistentProfile(p) ? PROFILEMAN->GetProfile(p)->m_sGuid : RString("") );
 		hs.SetMachineGuid( PROFILEMAN->GetMachineProfile()->m_sGuid );