Most PlayerOptions now represented by floats

Appearance PlayerOptions are now not mutually exclusive
Accel PlayerOptions are now not mutually exclusive
Most PlayerOptions linearly interpolate if changed during song

stepmania/src/ActiveItemList.cpp

@@ -44,7 +44,7 @@ void ActiveItemList::Init( PlayerNumber pn, Inventory* pInventory )
 	for( int i=0; i<MAX_ACTIVE_ITEMS_LINES; i++ )
 	{
 		m_text[i].SetHorizAlign( (Actor::HorizAlign)TEXT_HORIZ_ALIGN(pn) );
-		bool bReverse = GAMESTATE->m_PlayerOptions[pn].m_bReverseScroll;
+		bool bReverse = GAMESTATE->m_PlayerOptions[pn].m_fReverseScroll == 1;
 		float fHeight = SPACING_Y*MAX_ACTIVE_ITEMS_LINES * (bReverse ? 1 : -1 );
 		float fY = SCALE(i,0.f,MAX_ACTIVE_ITEMS_LINES,0.f,fHeight);
 		m_text[i].SetY( fY );

stepmania/src/ArrowEffects.cpp

@@ -30,55 +30,48 @@ float ArrowGetYOffset( PlayerNumber pn, float fNoteBeat )
 	float fBeatsUntilStep = fNoteBeat - fSongBeat;
 	float fYOffset = fBeatsUntilStep * ARROW_GAP;
 
-	/* With both boost and wave enabled, the effect is that the
-	 * notes "buffer" at the bottom of the screen and shoot out
-	 * at high speed.
-	 *
-	 * With wave first, the boost appears halfway down the screen.
-	 * With boost first, it appears about 1/4 down the screen.
-	 *
-	 * I'm not sure which is better. - glenn
-	 */
-	/* Boost and wave can no longer be used at the same time.  -Chris */
+	// don't mess with the arrows after they've crossed 0
+	if( fYOffset < 0 )
+		return fYOffset;
+
+	const float* fAccels = GAMESTATE->m_CurrentPlayerOptions[pn].m_fAccels;
 
 
-	switch( GAMESTATE->m_PlayerOptions[pn].m_AccelType )
+	float fYAdjust = 0;	// fill this in depending on PlayerOptions
+
+	if( fAccels[PlayerOptions::ACCEL_BOOST] > 0 )
+	{
+		float fNewYOffset = fYOffset * 1.5f / ((fYOffset+SCREEN_HEIGHT/1.2f)/SCREEN_HEIGHT); 
+		fYAdjust +=	fAccels[PlayerOptions::ACCEL_BOOST] * (fNewYOffset - fYOffset);
+	}
+	if( fAccels[PlayerOptions::ACCEL_LAND] > 0 )
+	{
+		float fNewYOffset = fYOffset * SCALE( fYOffset, 0.f, SCREEN_HEIGHT, 0.25f, 1.5f ); 
+		fYAdjust +=	fAccels[PlayerOptions::ACCEL_LAND] * (fNewYOffset - fYOffset);
+	}
+	if( fAccels[PlayerOptions::ACCEL_WAVE] > 0 )
+		fYAdjust +=	fAccels[PlayerOptions::ACCEL_WAVE] * 20.0f*sinf( fYOffset/38.0f );
+	if( fAccels[PlayerOptions::ACCEL_EXPAND] > 0 )
 	{
-	case PlayerOptions::ACCEL_BOOST:
-		if( fYOffset > 0 )	// speed the arrows back to normal after they cross 0
-			fYOffset *= 1.5f / ((fYOffset+SCREEN_HEIGHT/1.2f)/SCREEN_HEIGHT); 
-		break;
-	case PlayerOptions::ACCEL_LAND:
-		if( fYOffset > 0 )	// speed the arrows back to normal after they cross 0
-			fYOffset *= SCALE( fYOffset, 0.f, SCREEN_HEIGHT, 0.25f, 1.5f ); 
-		break;
-	case PlayerOptions::ACCEL_WAVE:
-		fYOffset += 20.0f*sinf( fYOffset/38.0f ); 
-		break;
-	case PlayerOptions::ACCEL_EXPAND:
 		if( !GAMESTATE->m_bFreeze )
 			g_fExpandSeconds += g_timerExpand.GetDeltaTime();
 		else
 			g_timerExpand.GetDeltaTime();	// throw away
-		fYOffset *= SCALE( cosf(g_fExpandSeconds*3), -1, 1, 0.5f, 1.5f ); 
-		break;
-	case PlayerOptions::ACCEL_BOOMERANG:
-		fYOffset *= SCALE( fYOffset, 0.f, SCREEN_HEIGHT, 1.5f, 0.5f );
-		break;
+		fYAdjust +=	fAccels[PlayerOptions::ACCEL_EXPAND] * (fYOffset * SCALE( cosf(g_fExpandSeconds*3), -1, 1, 0.5f, 1.5f ) - fYOffset); 
 	}
+	if( fAccels[PlayerOptions::ACCEL_BOOMERANG] > 0 )
+		fYAdjust +=	fAccels[PlayerOptions::ACCEL_BOOMERANG] * (fYOffset * SCALE( fYOffset, 0.f, SCREEN_HEIGHT, 1.5f, 0.5f )- fYOffset);
 
-	return fYOffset;
+	return fYOffset + fYAdjust;
 }
 
 float ArrowGetXPos( PlayerNumber pn, int iColNum, float fYPos ) 
 {
 	float fPixelOffsetFromCenter = GAMESTATE->GetCurrentStyleDef()->m_ColumnInfo[pn][iColNum].fXOffset;
 	
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_DRUNK] )
-		fPixelOffsetFromCenter += cosf( RageTimer::GetTimeSinceStart() + iColNum*0.2f + fYPos*6/SCREEN_HEIGHT) * ARROW_SIZE*0.5f; 
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_FLIP] )
-		fPixelOffsetFromCenter = -fPixelOffsetFromCenter; 
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_TORNADO] )
+	const float* fEffects = GAMESTATE->m_CurrentPlayerOptions[pn].m_fEffects;
+
+	if( fEffects[PlayerOptions::EFFECT_TORNADO] > 0 )
 	{
 		const StyleDef* pStyleDef = GAMESTATE->GetCurrentStyleDef();
 		float fMinX, fMaxX;
@@ -91,30 +84,35 @@ float ArrowGetXPos( PlayerNumber pn, int iColNum, float fYPos )
 		fPixelOffsetFromCenter = SCALE( cosf(fRads), -1, 1, fMinX, fMaxX );
 	}
 
+	if( fEffects[PlayerOptions::EFFECT_DRUNK] > 0 )
+		fPixelOffsetFromCenter += fEffects[PlayerOptions::EFFECT_DRUNK] * ( cosf( RageTimer::GetTimeSinceStart() + iColNum*0.2f + fYPos*10/SCREEN_HEIGHT) * ARROW_SIZE*0.5f );
+	if( fEffects[PlayerOptions::EFFECT_FLIP] > 0 )
+		fPixelOffsetFromCenter *= SCALE(fEffects[PlayerOptions::EFFECT_FLIP], 0.f, 1.f, 1.f, -1.f);
+
 	return fPixelOffsetFromCenter;
 }
 
 float ArrowGetRotation( PlayerNumber pn, float fNoteBeat ) 
 {
-	float fRotation = 0; //StyleDef.m_ColumnToRotation[iColNum];
-
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_DIZZY] )
+	if( GAMESTATE->m_CurrentPlayerOptions[pn].m_fEffects[PlayerOptions::EFFECT_DIZZY] > 0 )
 	{
 		float fSongBeat = GAMESTATE->m_fSongBeat;
-		float fBeatsUntilStep = fNoteBeat - fSongBeat;
-		fRotation += fBeatsUntilStep; 
+		float fDizzyRotation = fNoteBeat - fSongBeat;
+		fDizzyRotation = fmodf( fDizzyRotation, 2*PI );
+		return fDizzyRotation * GAMESTATE->m_CurrentPlayerOptions[pn].m_fEffects[PlayerOptions::EFFECT_DIZZY];
 	}
-	return fRotation;
+	else
+		return 0;
 }
 
 float ArrowGetYPosWithoutReverse( PlayerNumber pn, float fYOffset )
 {
-	return fYOffset * GAMESTATE->m_PlayerOptions[pn].m_fScrollSpeed;
+	return fYOffset * GAMESTATE->m_CurrentPlayerOptions[pn].m_fScrollSpeed;
 }
 
 float ArrowGetYPos( PlayerNumber pn, float fYOffset )
 {
-	return ArrowGetYPosWithoutReverse(pn,fYOffset) * (GAMESTATE->m_PlayerOptions[pn].m_bReverseScroll ? -1 : 1 );
+	return ArrowGetYPosWithoutReverse(pn,fYOffset) * SCALE( GAMESTATE->m_CurrentPlayerOptions[pn].m_fReverseScroll, 0.f, 1.f, 1.f, -1.f );
 }
 
 
@@ -122,44 +120,33 @@ const float fCenterLine = 160;	// from fYPos == 0
 const float fFadeDist = 100;
 
 // used by ArrowGetAlpha and ArrowGetGlow below
-float ArrowGetPercentVisible( PlayerNumber pn, float fYPos )
+float ArrowGetPercentVisible( PlayerNumber pn, float fYPosWithoutReverse )
 {
-	const bool bReverse = GAMESTATE->m_PlayerOptions[pn].m_bReverseScroll;
-	const float fCorrectedYPos = bReverse ? -fYPos : fYPos;
-	const float fDistFromCenterLine = fCorrectedYPos - fCenterLine;
-	float fAlpha;
+	const float fDistFromCenterLine = fYPosWithoutReverse - fCenterLine;
 
-	switch( GAMESTATE->m_PlayerOptions[pn].m_AppearanceType )
-	{ 
-	case PlayerOptions::APPEARANCE_VISIBLE:
-		fAlpha = 1;
-		break;
-	case PlayerOptions::APPEARANCE_HIDDEN:
-		fAlpha = SCALE( fDistFromCenterLine, 0, fFadeDist, 0, 1 );
-		break;
-	case PlayerOptions::APPEARANCE_SUDDEN:
-		fAlpha = SCALE( fDistFromCenterLine, 0, -fFadeDist, 0, 1 );
-		break;
-	case PlayerOptions::APPEARANCE_STEALTH:
-		fAlpha = 0;
-		break;
-	case PlayerOptions::APPEARANCE_BLINK: // this is an Ez2dancer Appearance Mode
-		fAlpha = sinf( RageTimer::GetTimeSinceStart()*12 );
-		fAlpha = froundf( fAlpha, 0.3333f );
-		break;
-	default:
-		ASSERT(0);
-		fAlpha = 1;
-	}
+	if( fYPosWithoutReverse < 0 )	// past Gray Arrows
+		return 1;	// totally visible
 
-	if( fCorrectedYPos < 0 )	// past Gray Arrows
-		fAlpha = 1;
 
-	return clamp( fAlpha, 0, 1 );
+	const float* fAppearances = GAMESTATE->m_CurrentPlayerOptions[pn].m_fAppearances;
+
+	float fVisibleAdjust = 0;
+
+	if( fAppearances[PlayerOptions::APPEARANCE_HIDDEN] > 0 )
+		fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_HIDDEN] * SCALE( fDistFromCenterLine, 0, fFadeDist, -1, 0 );
+	if( fAppearances[PlayerOptions::APPEARANCE_SUDDEN] > 0 )
+		fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_SUDDEN] * SCALE( fDistFromCenterLine, 0, -fFadeDist, -1, 0 );
+	if( fAppearances[PlayerOptions::APPEARANCE_STEALTH] > 0 )
+		fVisibleAdjust += fAppearances[PlayerOptions::APPEARANCE_STEALTH] * -1;
+	if( fAppearances[PlayerOptions::APPEARANCE_BLINK] > 0 )
+		fVisibleAdjust += clamp( sinf(RageTimer::GetTimeSinceStart()*10)-1, 0, 1 );
+
+	return clamp( 1+fVisibleAdjust, 0, 1 );
 }
 
 float ArrowGetAlpha( PlayerNumber pn, float fYPos, float fPercentFadeToFail )
 {
+	fYPos /= GAMESTATE->m_CurrentPlayerOptions[pn].m_fScrollSpeed;
 	float fPercentVisible = ArrowGetPercentVisible(pn,fYPos);
 
 	if( fPercentFadeToFail != -1 )
@@ -170,6 +157,7 @@ float ArrowGetAlpha( PlayerNumber pn, float fYPos, float fPercentFadeToFail )
 
 float ArrowGetGlow( PlayerNumber pn, float fYPos, float fPercentFadeToFail )
 {
+	fYPos /= GAMESTATE->m_CurrentPlayerOptions[pn].m_fScrollSpeed;
 	float fPercentVisible = ArrowGetPercentVisible(pn,fYPos);
 
 	if( fPercentFadeToFail != -1 )

stepmania/src/CodeDetector.cpp

@@ -151,6 +151,7 @@ bool CodeDetector::EnteredNextSort( GameController controller )
 }
 
 #define  TOGGLE(v,a,b)	if(v!=a) v=a; else v=b;
+#define  FLOAT_TOGGLE(v)	if(v!=1.f) v=1.f; else v=0.f;
 #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;
 
@@ -167,22 +168,22 @@ bool CodeDetector::DetectAndAdjustOptions( GameController controller )
 		{
 			switch( code )
 			{
-			case CODE_MIRROR:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_TurnType, PlayerOptions::TURN_MIRROR,			PlayerOptions::TURN_NONE );	break;
-			case CODE_LEFT:				TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_TurnType, PlayerOptions::TURN_LEFT,			PlayerOptions::TURN_NONE );	break;
-			case CODE_RIGHT:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_TurnType, PlayerOptions::TURN_RIGHT,			PlayerOptions::TURN_NONE );	break;
-			case CODE_SHUFFLE:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_TurnType, PlayerOptions::TURN_SHUFFLE,			PlayerOptions::TURN_NONE );	break;
-			case CODE_SUPER_SHUFFLE:	TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_TurnType, PlayerOptions::TURN_SUPER_SHUFFLE,	PlayerOptions::TURN_NONE );	break;
+			case CODE_MIRROR:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_Turn, PlayerOptions::TURN_MIRROR,			PlayerOptions::TURN_NONE );	break;
+			case CODE_LEFT:				TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_Turn, PlayerOptions::TURN_LEFT,			PlayerOptions::TURN_NONE );	break;
+			case CODE_RIGHT:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_Turn, PlayerOptions::TURN_RIGHT,			PlayerOptions::TURN_NONE );	break;
+			case CODE_SHUFFLE:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_Turn, PlayerOptions::TURN_SHUFFLE,			PlayerOptions::TURN_NONE );	break;
+			case CODE_SUPER_SHUFFLE:	TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_Turn, PlayerOptions::TURN_SUPER_SHUFFLE,	PlayerOptions::TURN_NONE );	break;
 			case CODE_NEXT_TRANSFORM:	GAMESTATE->m_PlayerOptions[pn].NextTransform();									break;
-			case CODE_NEXT_SCROLL_SPEED:INCREMENT_SCROLL_SPEED( GAMESTATE->m_PlayerOptions[pn].m_fScrollSpeed );	break;
+			case CODE_NEXT_SCROLL_SPEED:INCREMENT_SCROLL_SPEED( GAMESTATE->m_PlayerOptions[pn].m_fScrollSpeed );		break;
 			case CODE_PREVIOUS_SCROLL_SPEED:DECREMENT_SCROLL_SPEED( GAMESTATE->m_PlayerOptions[pn].m_fScrollSpeed );	break;
-			case CODE_NEXT_ACCEL:		GAMESTATE->m_PlayerOptions[pn].NextAccel();									break;
+			case CODE_NEXT_ACCEL:		GAMESTATE->m_PlayerOptions[pn].NextAccel();										break;
 			case CODE_NEXT_EFFECT:		GAMESTATE->m_PlayerOptions[pn].NextEffect();									break;
-			case CODE_NEXT_APPEARANCE:	GAMESTATE->m_PlayerOptions[pn].NextAppearance();;				break;
-			case CODE_NEXT_TURN:		GAMESTATE->m_PlayerOptions[pn].NextTurn();						break;
-			case CODE_REVERSE:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_bReverseScroll, true, false );			break;
+			case CODE_NEXT_APPEARANCE:	GAMESTATE->m_PlayerOptions[pn].NextAppearance();;								break;
+			case CODE_NEXT_TURN:		GAMESTATE->m_PlayerOptions[pn].NextTurn();										break;
+			case CODE_REVERSE:			FLOAT_TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_fReverseScroll );				break;
 			case CODE_HOLDS:			TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_bHoldNotes, true, false );				break;
-			case CODE_DARK:				TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_bDark, true, false );					break;
-			case CODE_CANCEL_ALL:		GAMESTATE->m_PlayerOptions[pn] = PlayerOptions();								break;
+			case CODE_DARK:				FLOAT_TOGGLE( GAMESTATE->m_PlayerOptions[pn].m_fDark );							break;
+			case CODE_CANCEL_ALL:		GAMESTATE->m_PlayerOptions[pn].Init();								break;
 			default:
 				ASSERT(0);	// unhandled code
 			}

stepmania/src/GameState.cpp

@@ -89,12 +89,23 @@ void GameState::Reset()
 	m_vPassedStageStats.clear();
 
 	for( p=0; p<NUM_PLAYERS; p++ )
-		m_PlayerOptions[p] = PlayerOptions();
-	m_SongOptions = SongOptions();
+	{	
+		m_CurrentPlayerOptions[p].Init();
+		m_PlayerOptions[p].Init();
+		m_StoredPlayerOptions[p].Init();
+	}
+	m_SongOptions.Init();
 	for( p=0; p<NUM_PLAYERS; p++ )
 		NOTESKIN->SwitchNoteSkin( PlayerNumber(p), PREFSMAN->m_sDefaultNoteSkin );
 }
 
+void GameState::Update( float fDelta )
+{
+	for( int p=0; p<NUM_PLAYERS; p++ )
+		m_CurrentPlayerOptions[p].Approach( m_PlayerOptions[p], fDelta );
+}
+
+
 void GameState::ResetLastRanking()
 {
 	for( int p=0; p<NUM_PLAYERS; p++ )
@@ -315,7 +326,7 @@ void GameState::GetFinalEvalStatsAndSongs( StageStats& statsOut, vector<Song*>&
 void GameState::StoreSelectedOptions()
 {
 	for( int p=0; p<NUM_PLAYERS; p++ )
-		GAMESTATE->m_SelectedOptions[p] = GAMESTATE->m_PlayerOptions[p];
+		GAMESTATE->m_StoredPlayerOptions[p] = GAMESTATE->m_PlayerOptions[p];
 }
 
 /* Restore the preferred options.  This is called after a song ends, before
@@ -325,7 +336,7 @@ void GameState::StoreSelectedOptions()
 void GameState::RestoreSelectedOptions()
 {
 	for( int p=0; p<NUM_PLAYERS; p++ )
-		GAMESTATE->m_PlayerOptions[p] = GAMESTATE->m_SelectedOptions[p];
+		GAMESTATE->m_PlayerOptions[p] = GAMESTATE->m_StoredPlayerOptions[p];
 	/* Oops.  We can't do this; it'll reset lives back to 4, and we need it
 	 * to stick around for the length of the course (for regaining).  Let's
 	 * just reset the options that can actually be set per-song. XXX */

stepmania/src/GameState.h

@@ -35,6 +35,8 @@ public:
 	void Reset();
 	void ResetLastRanking();
 
+	void Update( float fDelta );
+
 	//
 	// Main State Info
 	//
@@ -80,8 +82,6 @@ public:
 	RageColor		GetStageColor();
 	int				GetCourseSongIndex();
 
-	void StoreSelectedOptions();
-	void RestoreSelectedOptions();
 
 	//
 	// State Info used during gameplay
@@ -118,17 +118,29 @@ public:
 	void	GetFinalEvalStatsAndSongs( StageStats& statsOut, vector<Song*>& vSongsOut );	// shown on arcade final evaluation
 
 
-	PlayerOptions	m_PlayerOptions[NUM_PLAYERS];    // The currently active options
-	PlayerOptions   m_SelectedOptions[NUM_PLAYERS];  // Keep track of player-selected options for
-													 // courses separately from the active options.
+	//
+	// Options stuff
+	//
+
+	PlayerOptions	m_CurrentPlayerOptions[NUM_PLAYERS];    // current approaches destination
+	PlayerOptions	m_PlayerOptions[NUM_PLAYERS];			// change this, and current will move gradually toward it
+	PlayerOptions   m_StoredPlayerOptions[NUM_PLAYERS];	// user's choices on the PlayerOptions screen
 	SongOptions		m_SongOptions;
 
+	void StoreSelectedOptions();
+	void RestoreSelectedOptions();
+
+
 	int				m_iItems[NUM_PLAYERS][NUM_ITEM_SLOTS];
 
 	bool HasEarnedExtraStage();
 	bool m_bAllow2ndExtraStage; //only used when "Allow Selection of Extra Stage is on"
 
 
+	//
+	// Ranking Stuff
+	//
+
 	// Filled in by ScreenNameEntry and used by ScreenRanking to flash the recent high scores
 	NotesType			m_RankingNotesType;	// meaningless if a course was played
 	RankingCategory		m_RankingCategory[NUM_PLAYERS];	// meaningless if a course was played

stepmania/src/GrayArrowRow.cpp

@@ -50,14 +50,12 @@ void GrayArrowRow::Update( float fDeltaTime )
 	for( int c=0; c<m_iNumCols; c++ )
 	{
 		m_GrayArrow[c].Update( fDeltaTime );
+		m_GrayArrow[c].SetDiffuse( RageColor(1,1,1,1 - GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fDark) );
 	}
 }
 
 void GrayArrowRow::DrawPrimitives()
 {
-	if( GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_bDark )
-		return;
-
 	for( int c=0; c<m_iNumCols; c++ ) 
 	{
 		// set arrow X

stepmania/src/Inventory.cpp

@@ -130,8 +130,21 @@ void Inventory::UseItem( PlayerNumber pn, int iSlot )
 	default:	ASSERT(0);	pnToAttack = PLAYER_1;	break;
 	}
 
-	ActiveItem ai = { ITEM_DURATION_SECONDS, iItemIndex };
-	m_ActiveItems[pnToAttack].push_back( ai );
+	// see if there is already an active instance of this item index
+	bool bAddedToExisting = false;
+	for( unsigned i=0; i<m_ActiveItems[pnToAttack].size(); i++ )
+	{
+		if( m_ActiveItems[pnToAttack][i].iItemDefIndex == iItemIndex )
+		{
+			m_ActiveItems[pnToAttack][i].fSecondsLeft += ITEM_DURATION_SECONDS;
+			bAddedToExisting = true;
+		}
+	}
+	if( !bAddedToExisting )
+	{
+		ActiveItem ai = { ITEM_DURATION_SECONDS, iItemIndex };
+		m_ActiveItems[pnToAttack].push_back( ai );
+	}
 
 	RebuildPlayerOptions( pnToAttack );
 
@@ -144,7 +157,7 @@ void Inventory::UseItem( PlayerNumber pn, int iSlot )
 void Inventory::RebuildPlayerOptions( PlayerNumber pn )
 {
 	// rebuild player options
-	PlayerOptions po = GAMESTATE->m_SelectedOptions[pn];
+	PlayerOptions po = GAMESTATE->m_StoredPlayerOptions[pn];
 	for( int i=0; i<(int)m_ActiveItems[pn].size(); i++ )
 	{
 		int iItemDefIndex = m_ActiveItems[pn][i].iItemDefIndex;

stepmania/src/MusicBannerWheel.cpp

@@ -42,7 +42,7 @@ MusicBannerWheel::MusicBannerWheel()
 	if(DEFAULT_SCROLL_DIRECTION && GAMESTATE->m_pCurSong == NULL) /* check the song is null... incase they have just come back from a song and changed their PlayerOptions */
 	{
 		for(int i=0; i<NUM_PLAYERS; i++)
-			GAMESTATE->m_PlayerOptions[i].m_bReverseScroll = true;
+			GAMESTATE->m_PlayerOptions[i].m_fReverseScroll = 1;
 	}
 
 	m_ScrollingList.UseSpriteType(BANNERTYPE);

stepmania/src/MusicWheel.cpp

@@ -65,7 +65,7 @@ MusicWheel::MusicWheel()
 	if(DEFAULT_SCROLL_DIRECTION && GAMESTATE->m_pCurSong == NULL) /* check the song is null... incase they have just come back from a song and changed their PlayerOptions */
 	{
 		for(int i=0; i<NUM_PLAYERS; i++)
-			GAMESTATE->m_PlayerOptions[i].m_bReverseScroll = true;
+			GAMESTATE->m_PlayerOptions[i].m_fReverseScroll = 1;
 	}
 
 

stepmania/src/NoteDisplay.cpp

@@ -351,7 +351,7 @@ void NoteDisplay::DrawHold( const HoldNote& hn, const bool bActive, const float
 {
 	// 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
 
-	const bool bReverse = GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_bReverseScroll;
+	const bool bReverse = GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fReverseScroll == 1;
 
 	const int	iCol			= hn.iTrack;
 	const float fStartYOffset	= ArrowGetYOffset( m_PlayerNumber, hn.fStartBeat );

stepmania/src/NoteField.cpp

@@ -107,7 +107,7 @@ void NoteField::DrawBeatBar( const float fBeat )
 	}
 	else
 	{
-		float fScrollSpeed = GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_fScrollSpeed;
+		float fScrollSpeed = GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fScrollSpeed;
 		switch( nt )
 		{
 		default:	ASSERT(0);

stepmania/src/Player.cpp

@@ -107,7 +107,7 @@ void Player::Load( PlayerNumber pn, NoteData* pNoteData, LifeMeter* pLM, ScoreDi
 	if( !GAMESTATE->m_PlayerOptions[pn].m_bHoldNotes )
 		NoteDataUtil::RemoveHoldNotes(*this);
 
-	switch( GAMESTATE->m_PlayerOptions[pn].m_TurnType )
+	switch( GAMESTATE->m_PlayerOptions[pn].m_Turn )
 	{
 	case PlayerOptions::TURN_NONE:																		break;
 	case PlayerOptions::TURN_MIRROR:		NoteDataUtil::Turn( *this, NoteDataUtil::mirror );			break;
@@ -132,12 +132,12 @@ void Player::Load( PlayerNumber pn, NoteData* pNoteData, LifeMeter* pLM, ScoreDi
 	int iStopDrawingAtPixels = GAMESTATE->m_bEditing ? 400 : STOP_DRAWING_AT_PIXELS;
 
 	// If both options are on, we *do* need to multiply it twice.
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_MINI] )
+	if( GAMESTATE->m_PlayerOptions[pn].m_fEffects[PlayerOptions::EFFECT_MINI]==1 )
 	{
 		iStartDrawingAtPixels *= 2;
 		iStopDrawingAtPixels *= 2;
 	}
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_SPACE] )
+	if( GAMESTATE->m_PlayerOptions[pn].m_fEffects[PlayerOptions::EFFECT_SPACE]==1 )
 	{
 		iStartDrawingAtPixels *= 2;
 		iStopDrawingAtPixels *= 2;
@@ -148,7 +148,7 @@ void Player::Load( PlayerNumber pn, NoteData* pNoteData, LifeMeter* pLM, ScoreDi
 	m_GrayArrowRow.Load( pn );
 	m_GhostArrowRow.Load( pn );
 
-	bool bReverse = GAMESTATE->m_PlayerOptions[pn].m_bReverseScroll;
+	bool bReverse = GAMESTATE->m_PlayerOptions[pn].m_fReverseScroll == 1;
 	m_Combo.SetY( bReverse ? SCREEN_BOTTOM-COMBO_Y : SCREEN_TOP+COMBO_Y );
 	m_Judgment.SetY( bReverse ? SCREEN_BOTTOM-JUDGMENT_Y : SCREEN_TOP+JUDGMENT_Y );
 
@@ -163,7 +163,7 @@ void Player::Load( PlayerNumber pn, NoteData* pNoteData, LifeMeter* pLM, ScoreDi
 	m_GrayArrowRow.SetY( bReverse ? SCREEN_BOTTOM-GRAY_ARROWS_Y : SCREEN_TOP+GRAY_ARROWS_Y );
 	m_GhostArrowRow.SetY( bReverse ? SCREEN_BOTTOM-GRAY_ARROWS_Y : SCREEN_TOP+GRAY_ARROWS_Y );
 
-	if( GAMESTATE->m_PlayerOptions[pn].m_bEffects[PlayerOptions::EFFECT_MINI] )
+	if( GAMESTATE->m_PlayerOptions[pn].m_fEffects[PlayerOptions::EFFECT_MINI] == 1 )
 	{
 		m_NoteField.SetZoom( 0.5f );
 		m_GrayArrowRow.SetZoom( 0.5f );
@@ -272,14 +272,14 @@ void Player::DrawPrimitives()
 {
 	m_Combo.Draw();	// draw this below everything else
 
-	if( GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_bEffects[PlayerOptions::EFFECT_SPACE] )
+	if( GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fEffects[PlayerOptions::EFFECT_SPACE] == 1 )
 	{
 		DISPLAY->PushMatrix();
 		DISPLAY->EnterPerspective(45, false);
 
 		// construct view and project matrix
 		RageVector3 Eye, At, Up( 0.0f, 1.0f, 0.0f );
-		if( GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_bReverseScroll ) {
+		if( GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fReverseScroll==1 ) {
 			Eye = RageVector3( CENTER_X, -300.0f, 400.0f );
 			At = RageVector3( CENTER_X, 100.0f, 0.0f );
 		} else {
@@ -296,7 +296,7 @@ void Player::DrawPrimitives()
 	m_NoteField.Draw();
 	m_GhostArrowRow.Draw();
 
-	if( GAMESTATE->m_PlayerOptions[m_PlayerNumber].m_bEffects[PlayerOptions::EFFECT_SPACE] )
+	if( GAMESTATE->m_CurrentPlayerOptions[m_PlayerNumber].m_fEffects[PlayerOptions::EFFECT_SPACE]==1 )
 	{
 		DISPLAY->ExitPerspective();
 		DISPLAY->PopMatrix();

stepmania/src/PlayerOptions.cpp

@@ -12,21 +12,48 @@
 
 #include "PlayerOptions.h"
 #include "RageUtil.h"
+#include "math.h"
 
 
 void PlayerOptions::Init()
 {
 	m_fScrollSpeed = 1.0f;
-	m_AccelType = ACCEL_OFF;
-	ZERO( m_bEffects );
-	m_AppearanceType = APPEARANCE_VISIBLE;
-	m_TurnType = TURN_NONE;
+	ZERO( m_fAccels );
+	ZERO( m_fEffects );
+	ZERO( m_fAppearances );
+	m_fReverseScroll = 0;
+	m_fDark = 0;
+	m_Turn = TURN_NONE;
 	m_Transform = TRANSFORM_NONE;
-	m_bReverseScroll = false;
 	m_bHoldNotes = true;
-	m_bDark = false;
 }
 
+void FLOAT_APPROACH( float& val, float other_val, float deltaPercent )
+{
+	if( val == other_val )
+		return;
+	float fDelta = other_val - val;
+	float fSign = fDelta / fabsf( fDelta );
+	float fToMove = fSign*deltaPercent;
+	if( fabsf(fToMove) > fabsf(fDelta) )
+		fToMove = fDelta;	// snap
+	val += fToMove;
+}
+
+void PlayerOptions::Approach( const PlayerOptions& other, float fDeltaSeconds )
+{
+	int i;
+
+	FLOAT_APPROACH( m_fScrollSpeed, other.m_fScrollSpeed, fDeltaSeconds*max(m_fScrollSpeed,other.m_fScrollSpeed) );	// make big jumps in scroll speed move faster
+	for( i=0; i<NUM_ACCELS; i++ )
+		FLOAT_APPROACH( m_fAccels[i], other.m_fAccels[i], fDeltaSeconds );
+	for( i=0; i<NUM_EFFECTS; i++ )
+		FLOAT_APPROACH( m_fEffects[i], other.m_fEffects[i], fDeltaSeconds );
+	for( i=0; i<NUM_APPEARANCES; i++ )
+		FLOAT_APPROACH( m_fAppearances[i], other.m_fAppearances[i], fDeltaSeconds );
+	FLOAT_APPROACH( m_fReverseScroll, other.m_fReverseScroll, fDeltaSeconds );
+	FLOAT_APPROACH( m_fDark, other.m_fDark, fDeltaSeconds );
+}
 
 CString PlayerOptions::GetString()
 {
@@ -47,35 +74,30 @@ CString PlayerOptions::GetString()
 		sReturn += s + "X, ";
 	}
 
-	switch( m_AccelType )
-	{
-	case ACCEL_OFF:									break;
-	case ACCEL_BOOST:		sReturn += "Boost, ";	break;
-	case ACCEL_LAND:		sReturn += "Land, ";	break;
-	case ACCEL_WAVE:		sReturn += "Wave, ";	break;
-	case ACCEL_EXPAND:		sReturn += "Expand, ";	break;
-	case ACCEL_BOOMERANG:	sReturn += "Boomerang, ";	break;
-	default:	ASSERT(0);
-	}
+	if( m_fAccels[ACCEL_BOOST]==1 )		sReturn += "Boost, ";
+	if( m_fAccels[ACCEL_LAND]==1 )		sReturn += "Land, ";
+	if( m_fAccels[ACCEL_WAVE]==1 )		sReturn += "Wave, ";
+	if( m_fAccels[ACCEL_EXPAND]==1 )	sReturn += "Expand, ";
+	if( m_fAccels[ACCEL_BOOMERANG]==1 )	sReturn += "Boomerang, ";
 
-	if( m_bEffects[EFFECT_DRUNK] )	sReturn += "Drunk, ";
-	if( m_bEffects[EFFECT_DIZZY] )	sReturn += "Dizzy, ";
-	if( m_bEffects[EFFECT_SPACE] )	sReturn += "Space, ";
-	if( m_bEffects[EFFECT_MINI] )	sReturn += "Mini, ";
-	if( m_bEffects[EFFECT_FLIP] )	sReturn += "Flip, ";
-	if( m_bEffects[EFFECT_TORNADO] )sReturn += "Tornado, ";
+	if( m_fEffects[EFFECT_DRUNK]==1 )	sReturn += "Drunk, ";
+	if( m_fEffects[EFFECT_DIZZY]==1 )	sReturn += "Dizzy, ";
+	if( m_fEffects[EFFECT_SPACE]==1 )	sReturn += "Space, ";
+	if( m_fEffects[EFFECT_MINI]==1 )	sReturn += "Mini, ";
+	if( m_fEffects[EFFECT_FLIP]==1 )	sReturn += "Flip, ";
+	if( m_fEffects[EFFECT_TORNADO]==1 )	sReturn += "Tornado, ";
 
-	switch( m_AppearanceType )
-	{
-	case APPEARANCE_VISIBLE:							break;
-	case APPEARANCE_HIDDEN:		sReturn += "Hidden, ";	break;
-	case APPEARANCE_SUDDEN:		sReturn += "Sudden, ";	break;
-	case APPEARANCE_STEALTH:	sReturn += "Stealth, ";	break;
-	case APPEARANCE_BLINK:		sReturn += "Blink, ";	break;
-	default:	ASSERT(0);	// invalid
-	}
+	if( m_fAppearances[APPEARANCE_HIDDEN]==1 )	sReturn += "Hidden, ";
+	if( m_fAppearances[APPEARANCE_SUDDEN]==1 )	sReturn += "Sudden, ";
+	if( m_fAppearances[APPEARANCE_STEALTH]==1 )	sReturn += "Stealth, ";
+	if( m_fAppearances[APPEARANCE_BLINK]==1 )	sReturn += "Blink, ";
 
-	switch( m_TurnType )
+	if( m_fReverseScroll == 1 )		sReturn += "Reverse, ";
+
+	if( m_fDark == 1)				sReturn += "Dark, ";
+
+
+	switch( m_Turn )
 	{
 	case TURN_NONE:										break;
 	case TURN_MIRROR:		sReturn += "Mirror, ";		break;
@@ -96,14 +118,8 @@ CString PlayerOptions::GetString()
 	default:	ASSERT(0);	// invalid
 	}
 
-	if( m_bReverseScroll )
-		sReturn += "Reverse, ";
+	if( !m_bHoldNotes )		sReturn += "NoHolds, ";
 
-	if( !m_bHoldNotes )
-		sReturn += "NoHolds, ";
-
-	if( m_bDark )
-		sReturn += "Dark, ";
 
 	if( sReturn.GetLength() > 2 )
 		sReturn.erase( sReturn.GetLength()-2 );	// delete the trailing ", "
@@ -134,73 +150,77 @@ void PlayerOptions::FromString( CString sOptions )
 		else if( sBit == "4.0x" )		m_fScrollSpeed = 4.0f;
 		else if( sBit == "5.0x" )		m_fScrollSpeed = 5.0f;
 		else if( sBit == "8.0x" )		m_fScrollSpeed = 8.0f;
-		else if( sBit == "boost" )		m_AccelType = ACCEL_BOOST;
-		else if( sBit == "land" )		m_AccelType = ACCEL_LAND;
-		else if( sBit == "wave" )		m_AccelType = ACCEL_WAVE;
-		else if( sBit == "expand" )		m_AccelType = ACCEL_EXPAND;
-		else if( sBit == "boomerang" )	m_AccelType = ACCEL_BOOMERANG;
-		else if( sBit == "drunk" )		m_bEffects[EFFECT_DRUNK] = true;
-		else if( sBit == "dizzy" )		m_bEffects[EFFECT_DIZZY] = true;
-		else if( sBit == "space" )		m_bEffects[EFFECT_SPACE] = true;
-		else if( sBit == "mini" )		m_bEffects[EFFECT_MINI] = true;
-		else if( sBit == "flip" )		m_bEffects[EFFECT_FLIP] = true;
-		else if( sBit == "tornado" )	m_bEffects[EFFECT_TORNADO] = true;
-		else if( sBit == "hidden" )		m_AppearanceType = APPEARANCE_HIDDEN;
-		else if( sBit == "sudden" )		m_AppearanceType = APPEARANCE_SUDDEN;
-		else if( sBit == "stealth" )	m_AppearanceType = APPEARANCE_STEALTH;
-		else if( sBit == "blink" )		m_AppearanceType = APPEARANCE_BLINK;
-		else if( sBit == "mirror" )		m_TurnType = TURN_MIRROR;
-		else if( sBit == "left" )		m_TurnType = TURN_LEFT;
-		else if( sBit == "right" )		m_TurnType = TURN_RIGHT;
-		else if( sBit == "shuffle" )	m_TurnType = TURN_SHUFFLE;
-		else if( sBit == "supershuffle" )m_TurnType = TURN_SUPER_SHUFFLE;
+		else if( sBit == "boost" )		m_fAccels[ACCEL_BOOST] = 1;
+		else if( sBit == "land" )		m_fAccels[ACCEL_LAND] = 1;
+		else if( sBit == "wave" )		m_fAccels[ACCEL_WAVE] = 1;
+		else if( sBit == "expand" )		m_fAccels[ACCEL_EXPAND] = 1;
+		else if( sBit == "boomerang" )	m_fAccels[ACCEL_BOOMERANG] = 1;
+		else if( sBit == "drunk" )		m_fEffects[EFFECT_DRUNK] = 1;
+		else if( sBit == "dizzy" )		m_fEffects[EFFECT_DIZZY] = 1;
+		else if( sBit == "space" )		m_fEffects[EFFECT_SPACE] = 1;
+		else if( sBit == "mini" )		m_fEffects[EFFECT_MINI] = 1;
+		else if( sBit == "flip" )		m_fEffects[EFFECT_FLIP] = 1;
+		else if( sBit == "tornado" )	m_fEffects[EFFECT_TORNADO] = 1;
+		else if( sBit == "hidden" )		m_fAppearances[APPEARANCE_HIDDEN] = 1;
+		else if( sBit == "sudden" )		m_fAppearances[APPEARANCE_SUDDEN] = 1;
+		else if( sBit == "stealth" )	m_fAppearances[APPEARANCE_STEALTH] = 1;
+		else if( sBit == "blink" )		m_fAppearances[APPEARANCE_BLINK] = 1;
+		else if( sBit == "mirror" )		m_Turn = TURN_MIRROR;
+		else if( sBit == "left" )		m_Turn = TURN_LEFT;
+		else if( sBit == "right" )		m_Turn = TURN_RIGHT;
+		else if( sBit == "shuffle" )	m_Turn = TURN_SHUFFLE;
+		else if( sBit == "supershuffle" )m_Turn = TURN_SUPER_SHUFFLE;
 		else if( sBit == "little" )		m_Transform = TRANSFORM_LITTLE;
 		else if( sBit == "wide" )		m_Transform = TRANSFORM_WIDE;
 		else if( sBit == "big" )		m_Transform = TRANSFORM_BIG;
 		else if( sBit == "quick" )		m_Transform = TRANSFORM_QUICK;
-		else if( sBit == "reverse" )	m_bReverseScroll = true;
+		else if( sBit == "reverse" )	m_fReverseScroll = 1;
 		else if( sBit == "noholds" )	m_bHoldNotes = false;
 		else if( sBit == "nofreeze" )	m_bHoldNotes = false;
-		else if( sBit == "dark" )		m_bDark = true;
+		else if( sBit == "dark" )		m_fDark = 1;
 	}
 }
 
 
+void NextFloat( float fValues[], int size )
+{
+	int index = -1;
+	for( int i=0; i<size; i++ )
+	{
+		if( fValues[i] == 1 )
+		{
+			index = i;
+			break;
+		}
+	}
+
+	memset( fValues, 0, size );
+
+	index++;
+	if( index == size )	// if true, then the last float in the list was selected
+		;	// leave all off
+	else
+		fValues[index] = 1;
+}
+
 void PlayerOptions::NextAccel()
 {
-	m_AccelType = (AccelType) ((m_AccelType+1)%NUM_ACCEL_TYPES);
+	NextFloat( m_fAccels, NUM_ACCELS );
 }
 
 void PlayerOptions::NextEffect()
 {
-	if( m_bEffects[NUM_EFFECT_TYPES-1] )	// last effect is on
-	{
-		ZERO( m_bEffects );
-		return;
-	}
-
-	for( int i=0; i<NUM_EFFECT_TYPES-1; i++ )
-	{
-		if( m_bEffects[i] )
-		{
-			ZERO( m_bEffects );
-			m_bEffects[i+1] = true;
-			return;
-		}
-	}
-
-	// if we get here, no effects are on
-	m_bEffects[0] = true;
+	NextFloat( m_fEffects, NUM_EFFECTS );
 }
 
 void PlayerOptions::NextAppearance()
 {
-	m_AppearanceType = (AppearanceType) ((m_AppearanceType+1)%NUM_APPEARANCE_TYPES);
+	NextFloat( m_fAppearances, NUM_APPEARANCES );
 }
 
 void PlayerOptions::NextTurn()
 {
-	m_TurnType = (TurnType) ((m_TurnType+1)%NUM_TURN_TYPES);
+	m_Turn = (Turn) ((m_Turn+1)%NUM_TURNS);
 }
 
 void PlayerOptions::NextTransform()
@@ -213,18 +233,60 @@ void PlayerOptions::ChooseRandomMofifiers()
 	if( RandomFloat(0,1)>0.8f )
 		m_fScrollSpeed = 1.5f;
 	if( RandomFloat(0,1)>0.8f )
-		m_bReverseScroll = true;
+		m_fReverseScroll = 1;
 	if( RandomFloat(0,1)>0.9f )
-		m_bDark = true;
+		m_fDark = 1;
 	float f;
 	f = RandomFloat(0,1);
 	if( f>0.66f )
-		m_AccelType = (AccelType)(rand()%NUM_ACCEL_TYPES);
+		m_fAccels[rand()%NUM_ACCELS] = 1;
 	else if( f>0.33f )
-		m_bEffects[ rand()%NUM_EFFECT_TYPES ] = true;
+		m_fEffects[rand()%NUM_EFFECTS] = 1;
 	f = RandomFloat(0,1);
 	if( f>0.95f )
-		m_AppearanceType = APPEARANCE_HIDDEN;
+		m_fAppearances[APPEARANCE_HIDDEN] = 1;
 	else if( f>0.9f )
-		m_AppearanceType = APPEARANCE_SUDDEN;
+		m_fAppearances[APPEARANCE_SUDDEN] = 1;
+}
+
+PlayerOptions::Accel PlayerOptions::GetFirstAccel()
+{
+	for( int i=0; i<NUM_ACCELS; i++ )
+		if( m_fAccels[i] == 1.f )
+			return (Accel)i;
+	return (Accel)-1;
+}
+
+PlayerOptions::Effect PlayerOptions::GetFirstEffect()
+{
+	for( int i=0; i<NUM_EFFECTS; i++ )
+		if( m_fEffects[i] == 1.f )
+			return (Effect)i;
+	return (Effect)-1;
+}
+
+PlayerOptions::Appearance PlayerOptions::GetFirstAppearance()
+{
+	for( int i=0; i<NUM_APPEARANCES; i++ )
+		if( m_fAppearances[i] == 1.f )
+			return (Appearance)i;
+	return (Appearance)-1;
+}
+
+void PlayerOptions::SetOneAccel( Accel a )
+{
+	ZERO( m_fAccels );
+	m_fAccels[a] = 1;
+}
+
+void PlayerOptions::SetOneEffect( Effect e )
+{
+	ZERO( m_fEffects );
+	m_fEffects[e] = 1;
+}
+
+void PlayerOptions::SetOneAppearance( Appearance a )
+{
+	ZERO( m_fAppearances );
+	m_fAppearances[a] = 1;
 }

stepmania/src/PlayerOptions.h

@@ -11,49 +11,56 @@
 -----------------------------------------------------------------------------
 */
 
+/* nonstandard extension used : nameless struct/union
+ * It is, in fact, nonstandard.  G++ 3.x can handle it. 2.95.x can not. XXX */
+#if defined(_MSC_VER)
+#pragma warning (push)
+#pragma warning (disable : 4201)
+#endif
+
 struct PlayerOptions
 {
-	float m_fScrollSpeed;
-	enum AccelType {
-		ACCEL_OFF,
+	PlayerOptions() { Init(); };
+	void Init();
+	void Approach( const PlayerOptions& other, float fDeltaSeconds );
+	CString GetString();
+	void FromString( CString sOptions );
+	void ChooseRandomMofifiers();
+
+
+	enum Accel {
 		ACCEL_BOOST,
 		ACCEL_LAND,
 		ACCEL_WAVE,
 		ACCEL_EXPAND,
 		ACCEL_BOOMERANG,
-		NUM_ACCEL_TYPES
-	} m_AccelType;
-	void NextAccel();
-	enum EffectType	{
+		NUM_ACCELS
+	};
+	enum Effect	{
 		EFFECT_DRUNK,
 		EFFECT_DIZZY,
 		EFFECT_SPACE,
 		EFFECT_MINI,
 		EFFECT_FLIP,
 		EFFECT_TORNADO,
-		NUM_EFFECT_TYPES
+		NUM_EFFECTS
 	};
-	bool m_bEffects[NUM_EFFECT_TYPES];	// no effects are mutually exclusive
-	void NextEffect();
-	enum AppearanceType	{
-		APPEARANCE_VISIBLE=0,
+	enum Appearance {
 		APPEARANCE_HIDDEN,
 		APPEARANCE_SUDDEN,
 		APPEARANCE_STEALTH,
 		APPEARANCE_BLINK,
-		NUM_APPEARANCE_TYPES
-	} m_AppearanceType;
-	void NextAppearance();
-	enum TurnType {
+		NUM_APPEARANCES
+	};
+	enum Turn {
 		TURN_NONE=0,
 		TURN_MIRROR,
 		TURN_LEFT,
 		TURN_RIGHT,
 		TURN_SHUFFLE,
 		TURN_SUPER_SHUFFLE,
-		NUM_TURN_TYPES 
-	} m_TurnType;
-	void NextTurn();
+		NUM_TURNS 
+	};
 	enum Transform {
 		TRANSFORM_NONE=0,
 		TRANSFORM_LITTLE,
@@ -61,17 +68,33 @@ struct PlayerOptions
 		TRANSFORM_BIG,
 		TRANSFORM_QUICK,
 		NUM_TRANSFORMS
-	} m_Transform;
-	void NextTransform();
-	bool m_bReverseScroll;
-	bool m_bHoldNotes;
-	bool m_bDark;
+	};
 
-	PlayerOptions() { Init(); };
-	void Init();
-	CString GetString();
-	void FromString( CString sOptions );
-	void ChooseRandomMofifiers();
+	
+	float		m_fScrollSpeed;
+	float		m_fAccels[NUM_ACCELS];
+	float		m_fEffects[NUM_EFFECTS];
+	float		m_fAppearances[NUM_APPEARANCES];
+	float		m_fReverseScroll;
+	float		m_fDark;
+	Turn		m_Turn;
+	Transform	m_Transform;
+	bool		m_bHoldNotes;
+
+
+	void NextAccel();
+	void NextEffect();
+	void NextAppearance();
+	void NextTurn();
+	void NextTransform();
+
+	Accel GetFirstAccel();
+	Effect GetFirstEffect();
+	Appearance GetFirstAppearance();
+
+	void SetOneAccel( Accel a );
+	void SetOneEffect( Effect e );
+	void SetOneAppearance( Appearance a );
 };
 
 #endif

stepmania/src/ScreenDemonstration.cpp

@@ -95,10 +95,10 @@ bool SetUpSongOptions()		// always return true.
 
 			/* Lots and lots of arrows.  This might even bias to arrows a little
 			 * too much. */
-			GAMESTATE->m_PlayerOptions[p] = PlayerOptions();
+			GAMESTATE->m_PlayerOptions[p].Init();
 			GAMESTATE->m_PlayerOptions[p].m_fScrollSpeed = .25f;
-			GAMESTATE->m_PlayerOptions[p].m_bEffects[ PlayerOptions::EFFECT_SPACE ] = true;
-			GAMESTATE->m_PlayerOptions[p].m_bEffects[ PlayerOptions::EFFECT_MINI ] = true;
+			GAMESTATE->m_PlayerOptions[p].m_fEffects[ PlayerOptions::EFFECT_SPACE ] = 1;
+			GAMESTATE->m_PlayerOptions[p].m_fEffects[ PlayerOptions::EFFECT_MINI ] = 1;
 		}
 		GAMESTATE->m_SongOptions.m_LifeType = SongOptions::LIFE_BATTERY;
 		GAMESTATE->m_SongOptions.m_FailType = SongOptions::FAIL_OFF;
@@ -109,7 +109,7 @@ bool SetUpSongOptions()		// always return true.
 		if( !GAMESTATE->IsPlayerEnabled(p) )
 			continue;
 
-		GAMESTATE->m_PlayerOptions[p] = PlayerOptions();
+		GAMESTATE->m_PlayerOptions[p].Init();
 		GAMESTATE->m_PlayerOptions[p].ChooseRandomMofifiers();
 	}
 

stepmania/src/ScreenEdit.cpp

@@ -199,7 +199,6 @@ ScreenEdit::ScreenEdit()
 	SCREENMAN->RefreshCreditsMessages();
 
 	m_iRowLastCrossed = -1;
-	m_fDestinationScrollSpeed = 1;
 
 	m_pSong = GAMESTATE->m_pCurSong;
 
@@ -331,16 +330,6 @@ bool ScreenEdit::PlayTicks() const
 
 void ScreenEdit::Update( float fDeltaTime )
 {
-	// approach destonation scroll speed
-	if( m_fDestinationScrollSpeed != GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed )
-	{
-		float fDelta = m_fDestinationScrollSpeed - GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed;
-		float fSign = fDelta / fabsf(fDelta);
-		float fToMove = fSign * fDeltaTime * 4 * (m_fDestinationScrollSpeed>2 ? 2 : 1);
-		CLAMP( fToMove, -fabsf(fDelta), fabsf(fDelta) );
-		GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed += fToMove;
-	}
-
 	if(m_soundMusic.IsPlaying())
 		GAMESTATE->UpdateSongPosition(m_soundMusic.GetPositionSeconds());
 
@@ -427,7 +416,7 @@ void ScreenEdit::Update( float fDeltaTime )
 	else
 	{
 		float fSign = fDelta / fabsf(fDelta);
-		float fMoveDelta = fSign*fDeltaTime*40 / GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed;
+		float fMoveDelta = fSign*fDeltaTime*40 / GAMESTATE->m_CurrentPlayerOptions[PLAYER_1].m_fScrollSpeed;
 		if( fabsf(fMoveDelta) > fabsf(fDelta) )
 			fMoveDelta = fDelta;
 		m_fTrailingBeat += fMoveDelta;
@@ -610,30 +599,32 @@ void ScreenEdit::InputEdit( const DeviceInput& DeviceI, const InputEventType typ
 			if( INPUTFILTER->IsBeingPressed(DeviceInput(DEVICE_KEYBOARD,SDLK_LCTRL)) ||
 				INPUTFILTER->IsBeingPressed(DeviceInput(DEVICE_KEYBOARD,SDLK_RCTRL)) )
 			{
+				float& fScrollSpeed = GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed;
+
 				if( DeviceI.button == SDLK_UP )
 				{
-					if( m_fDestinationScrollSpeed == 4 )
+					if( fScrollSpeed == 4 )
 					{
-						m_fDestinationScrollSpeed = 2;
+						fScrollSpeed = 2;
 						m_soundMarker.Play();
 					}
-					else if( m_fDestinationScrollSpeed == 2 )
+					else if( fScrollSpeed == 2 )
 					{
-						m_fDestinationScrollSpeed = 1;
+						fScrollSpeed = 1;
 						m_soundMarker.Play();
 					}
 					break;
 				}
 				else if( DeviceI.button == SDLK_DOWN )
 				{
-					if( m_fDestinationScrollSpeed == 2 )
+					if( fScrollSpeed == 2 )
 					{
-						m_fDestinationScrollSpeed = 4;
+						fScrollSpeed = 4;
 						m_soundMarker.Play();
 					}
-					else if( m_fDestinationScrollSpeed == 1 )
+					else if( fScrollSpeed == 1 )
 					{
-						m_fDestinationScrollSpeed = 2;
+						fScrollSpeed = 2;
 						m_soundMarker.Play();
 					}
 					break;
@@ -1048,7 +1039,6 @@ void ScreenEdit::HandleScreenMessage( const ScreenMessage SM )
 		break;
 	case SM_RegainingFocus:
 		// coming back from PlayerOptions or SongOptions
-		m_fDestinationScrollSpeed = GAMESTATE->m_PlayerOptions[PLAYER_1].m_fScrollSpeed;
 		m_soundMusic.SetPlaybackRate( GAMESTATE->m_SongOptions.m_fMusicRate );
 		break;
 	}

stepmania/src/ScreenEdit.h

@@ -73,8 +73,6 @@ protected:
 	 * -1 when shift isn't pressed: */
 	float shiftAnchor;
 
-	float			m_fDestinationScrollSpeed;
-
 	NoteData			m_Clipboard;
 
 	RageSound			m_soundChangeLine;

stepmania/src/ScreenGameplay.cpp

@@ -177,8 +177,8 @@ ScreenGameplay::ScreenGameplay( bool bDemonstration )
 
 	const bool bExtra = GAMESTATE->IsExtraStage() || GAMESTATE->IsExtraStage2();
 	const bool bReverse[NUM_PLAYERS] = { 
-		GAMESTATE->m_PlayerOptions[0].m_bReverseScroll,
-		GAMESTATE->m_PlayerOptions[1].m_bReverseScroll
+		GAMESTATE->m_PlayerOptions[0].m_fReverseScroll == 1,
+		GAMESTATE->m_PlayerOptions[1].m_fReverseScroll == 1
 	};
 
 

stepmania/src/ScreenJukebox.cpp

@@ -90,8 +90,8 @@ bool PrepareForJukebox()		// always return true.
 			 * too much. */
 			GAMESTATE->m_PlayerOptions[p] = PlayerOptions();
 			GAMESTATE->m_PlayerOptions[p].m_fScrollSpeed = .25f;
-			GAMESTATE->m_PlayerOptions[p].m_bEffects[ PlayerOptions::EFFECT_SPACE ] = true;
-			GAMESTATE->m_PlayerOptions[p].m_bEffects[ PlayerOptions::EFFECT_MINI ] = true;
+			GAMESTATE->m_PlayerOptions[p].m_fEffects[ PlayerOptions::EFFECT_SPACE ] = 1;
+			GAMESTATE->m_PlayerOptions[p].m_fEffects[ PlayerOptions::EFFECT_MINI ] = 1;
 		}
 		GAMESTATE->m_SongOptions.m_LifeType = SongOptions::LIFE_BATTERY;
 		GAMESTATE->m_SongOptions.m_FailType = SongOptions::FAIL_OFF;

stepmania/src/ScreenPlayerOptions.cpp

@@ -99,20 +99,14 @@ void ScreenPlayerOptions::ImportOptions()
 		else if( po.m_fScrollSpeed == 5.0f )	m_iSelectedOption[p][PO_SPEED] = 8;
 		else if( po.m_fScrollSpeed == 8.0f )	m_iSelectedOption[p][PO_SPEED] = 9;
 		else if( po.m_fScrollSpeed == 12.0f)	m_iSelectedOption[p][PO_SPEED] = 10;
-		else										m_iSelectedOption[p][PO_SPEED] = 3;
+		else									m_iSelectedOption[p][PO_SPEED] = 3;
 
-		m_iSelectedOption[p][PO_ACCEL]		= po.m_AccelType;
-
-		for( int i=0; i<PlayerOptions::NUM_EFFECT_TYPES; i++ ) 
-		{
-			if( po.m_bEffects[i] )
-				m_iSelectedOption[p][PO_EFFECT] = i+1;
-		}
-
-		m_iSelectedOption[p][PO_APPEAR]		= po.m_AppearanceType;
-		m_iSelectedOption[p][PO_TURN]		= po.m_TurnType;
+		m_iSelectedOption[p][PO_ACCEL]		= po.GetFirstAccel()+1;
+		m_iSelectedOption[p][PO_EFFECT]		= po.GetFirstEffect()+1;
+		m_iSelectedOption[p][PO_APPEAR]		= po.GetFirstAppearance()+1;
+		m_iSelectedOption[p][PO_TURN]		= po.m_Turn;
 		m_iSelectedOption[p][PO_TRANSFORM]	= po.m_Transform;
-		m_iSelectedOption[p][PO_SCROLL]		= po.m_bReverseScroll ? 1 : 0 ;
+		m_iSelectedOption[p][PO_SCROLL]		= po.m_fReverseScroll==1 ? 1 : 0 ;
 
 
 		// highlight currently selected skin
@@ -130,7 +124,10 @@ void ScreenPlayerOptions::ImportOptions()
 
 
 		m_iSelectedOption[p][PO_HOLD_NOTES]	= po.m_bHoldNotes ? 1 : 0;
-		m_iSelectedOption[p][PO_DARK]		= po.m_bDark ? 1 : 0;
+		m_iSelectedOption[p][PO_DARK]		= po.m_fDark==1 ? 1 : 0;
+
+
+		po.Init();
 	}
 }
 
@@ -139,6 +136,7 @@ void ScreenPlayerOptions::ExportOptions()
 	for( int p=0; p<NUM_PLAYERS; p++ )
 	{
 		PlayerOptions &po = GAMESTATE->m_PlayerOptions[p];
+		po.Init();
 
 		switch( m_iSelectedOption[p][PO_SPEED] )
 		{
@@ -155,16 +153,16 @@ void ScreenPlayerOptions::ExportOptions()
 		case 10: po.m_fScrollSpeed = 12.0f;	break;
 		}
 
-		po.m_AccelType	= (PlayerOptions::AccelType)m_iSelectedOption[p][PO_ACCEL];
+		if( m_iSelectedOption[p][PO_ACCEL] != 0 )
+			po.SetOneAccel( (PlayerOptions::Accel)(m_iSelectedOption[p][PO_ACCEL]-1) );
+		if( m_iSelectedOption[p][PO_EFFECT] != 0 )
+			po.SetOneEffect( (PlayerOptions::Effect)(m_iSelectedOption[p][PO_EFFECT]-1) );
+		if( m_iSelectedOption[p][PO_APPEAR] != 0 )
+			po.SetOneAppearance( (PlayerOptions::Appearance)(m_iSelectedOption[p][PO_APPEAR]-1) );
 
-		ZERO( po.m_bEffects );
-		if( m_iSelectedOption[p][PO_EFFECT] > 0 )
-			po.m_bEffects[ m_iSelectedOption[p][PO_EFFECT]-1 ] = true;
-
-		po.m_AppearanceType	= (PlayerOptions::AppearanceType)m_iSelectedOption[p][PO_APPEAR];
-		po.m_TurnType		= (PlayerOptions::TurnType)m_iSelectedOption[p][PO_TURN];
+		po.m_Turn			= (PlayerOptions::Turn)m_iSelectedOption[p][PO_TURN];
 		po.m_Transform		= (PlayerOptions::Transform)m_iSelectedOption[p][PO_TRANSFORM];
-		po.m_bReverseScroll	= (m_iSelectedOption[p][PO_SCROLL] == 1);
+		po.m_fReverseScroll	= (m_iSelectedOption[p][PO_SCROLL] == 1) ? 1.f : 0.f;
 
 
 		int iSelectedSkin = m_iSelectedOption[p][PO_NOTE_SKIN];
@@ -173,7 +171,7 @@ void ScreenPlayerOptions::ExportOptions()
 
 
 		po.m_bHoldNotes		= (m_iSelectedOption[p][PO_HOLD_NOTES] == 1);
-		po.m_bDark			= (m_iSelectedOption[p][PO_DARK] == 1);
+		po.m_fDark			= (m_iSelectedOption[p][PO_DARK] == 1) ? 1.f : 0.f;
 	}
 }
 

stepmania/src/SongManager.cpp

@@ -846,7 +846,7 @@ void SongManager::GetExtraStageInfo( bool bExtra2, CString sPreferredGroup, cons
 
 	po_out.Init();
 	so_out.Init();
-	po_out.m_bReverseScroll = true;
+	po_out.m_fReverseScroll = 1;
 	po_out.m_fScrollSpeed = 1.5f;
 	so_out.m_DrainType = (bExtra2 ? SongOptions::DRAIN_SUDDEN_DEATH : SongOptions::DRAIN_NO_RECOVER);
 
@@ -854,11 +854,11 @@ void SongManager::GetExtraStageInfo( bool bExtra2, CString sPreferredGroup, cons
 	int iSongHash = GetHashForString( pSongOut->GetSongDir() );
 	switch( ((unsigned int)iSongHash) % 5 )
 	{
-	case 0:	po_out.m_bEffects[PlayerOptions::EFFECT_DIZZY] = true;	break;
-	case 1:	po_out.m_bDark = true;									break;
-	case 2:	po_out.m_bEffects[PlayerOptions::EFFECT_DRUNK] = true;	break;
-	case 3:	po_out.m_bEffects[PlayerOptions::EFFECT_MINI] = true;	break;
-	case 4:	po_out.m_bEffects[PlayerOptions::EFFECT_SPACE] = true;	break;
+	case 0:	po_out.m_fEffects[PlayerOptions::EFFECT_DIZZY] = 1;	break;
+	case 1:	po_out.m_fDark = 1;									break;
+	case 2:	po_out.m_fEffects[PlayerOptions::EFFECT_DRUNK] = 1;	break;
+	case 3:	po_out.m_fEffects[PlayerOptions::EFFECT_MINI] = 1;	break;
+	case 4:	po_out.m_fEffects[PlayerOptions::EFFECT_SPACE] = 1;	break;
 	default:	ASSERT(0);
 	}
 }

stepmania/src/StepMania.cpp

@@ -538,22 +538,22 @@ static void GameLoop()
 				DISPLAY->ResolutionChanged(event.resize.w, event.resize.h);
 				break;
 			case SDL_ACTIVEEVENT:
-			{
-				/* We don't care about mouse focus. */
-				if(event.active.state == SDL_APPMOUSEFOCUS)
-					break;
+				{
+					/* We don't care about mouse focus. */
+					if(event.active.state == SDL_APPMOUSEFOCUS)
+						break;
 
-				Uint8 i = SDL_GetAppState();
-				
-				g_bHasFocus = i&SDL_APPINPUTFOCUS && i&SDL_APPACTIVE;
-				LOG->Trace("App %s focus (%i%i)", g_bHasFocus? "has":"doesn't have",
-					i&SDL_APPINPUTFOCUS, i&SDL_APPACTIVE);
+					Uint8 i = SDL_GetAppState();
+					
+					g_bHasFocus = i&SDL_APPINPUTFOCUS && i&SDL_APPACTIVE;
+					LOG->Trace("App %s focus (%i%i)", g_bHasFocus? "has":"doesn't have",
+						i&SDL_APPINPUTFOCUS, i&SDL_APPACTIVE);
 
-				if(g_bHasFocus)
-					BoostAppPri();
-				else
-					RestoreAppPri();
-			}
+					if(g_bHasFocus)
+						BoostAppPri();
+					else
+						RestoreAppPri();
+				}
 			}
 		}
 
@@ -572,8 +572,7 @@ static void GameLoop()
 				fDeltaTime /= 4;
 
 		TEXTUREMAN->Update( fDeltaTime );
-
-
+		GAMESTATE->Update( fDeltaTime );
 		SCREENMAN->Update( fDeltaTime );
 		SOUNDMAN->Update( fDeltaTime );