diff --git a/stepmania/src/Actor.cpp b/stepmania/src/Actor.cpp
index dfc8877f7a..376eb38a01 100644
--- a/stepmania/src/Actor.cpp
+++ b/stepmania/src/Actor.cpp
@@ -18,6 +18,8 @@
 
 Actor::Actor()
 {
+	m_iNumTweenStates = 0;
+
 	m_size									= D3DXVECTOR2( 1, 1 );
 	m_pos			= m_start_pos			= D3DXVECTOR3( 0, 0, 0 );
 	m_rotation		= m_start_rotation		= D3DXVECTOR3( 0, 0, 0 );
@@ -43,6 +45,7 @@ Actor::Actor()
 	m_fShadowLength = 4;
 
 	m_bBlendAdd = false;
+
 }
 
 
@@ -194,9 +197,9 @@ void Actor::Update( float fDeltaTime )
 
 
 	// update tweening
-	if( m_QueuedTweens.GetSize() > 0 )		// we are performing some type of tweening
+	if( m_iNumTweenStates > 0 )		// we are performing a tween
 	{
-		TweenState &TS = m_QueuedTweens[0];
+		TweenState &TS = m_QueuedTweens[0];		// earliest tween
 
 		if( TS.m_fTimeLeftInTween == TS.m_fTweenTime )	// we are just beginning this tween
 		{
@@ -218,7 +221,10 @@ void Actor::Update( float fDeltaTime )
 			for(int i=0; i<4; i++) m_colorDiffuse[i] = TS.m_end_colorDiffuse[i];
 			m_colorAdd		= TS.m_end_colorAdd;
 			
-			m_QueuedTweens.RemoveAt( 0 );
+			// delete the head tween
+			for( int i=0; i<m_iNumTweenStates-1; i++ )
+                m_QueuedTweens[i] = m_QueuedTweens[i+1];
+			m_iNumTweenStates--;
 			return;
 		}
 		else		// in the middle of tweening.  Recalcute the curent position.
@@ -234,7 +240,7 @@ void Actor::Update( float fDeltaTime )
 				fPercentAlongPath = fPercentThroughTween;
 				break;
 			case TWEEN_BIAS_BEGIN:
-				fPercentAlongPath = (float) sqrt( fPercentThroughTween );
+				fPercentAlongPath = 1 - (1-fPercentThroughTween) * (1-fPercentThroughTween);
 				break;
 			case TWEEN_BIAS_END:
 				fPercentAlongPath = fPercentThroughTween * fPercentThroughTween;
@@ -249,7 +255,7 @@ void Actor::Update( float fDeltaTime )
 				fPercentAlongPath = 1 - cosf( fPercentThroughTween*D3DX_PI*2.5f )/(1+fPercentThroughTween*3);
 				break;
 			default:
-				ASSERT( false );
+				ASSERT(0);
 				break;
 			}
 
@@ -267,7 +273,6 @@ void Actor::Update( float fDeltaTime )
 }
 
 
-
 void Actor::BeginTweening( float time, TweenType tt )
 {
 	StopTweening();	// cancel current tweens
@@ -279,13 +284,13 @@ void Actor::BeginTweeningQueued( float time, TweenType tt )
 	ASSERT( time >= 0 );
 
 	// add a new TweenState to the tail, and initialize it
-	m_QueuedTweens.Add( TweenState() );
-	TweenState &TS = m_QueuedTweens[m_QueuedTweens.GetSize()-1];
+	m_iNumTweenStates++;
+	TweenState &TS = m_QueuedTweens[m_iNumTweenStates-1];	// latest tween state
 
-	if( m_QueuedTweens.GetSize() >= 2 )		// if there was already a TS on the stack
+	if( m_iNumTweenStates >= 2 )		// if there was already a TS on the stack
 	{
 		// initialize the new TS from the last TS in the list
-		TS = m_QueuedTweens[m_QueuedTweens.GetSize()-2];
+		TS = m_QueuedTweens[m_iNumTweenStates-2];
 	}
 	else
 	{
@@ -303,6 +308,12 @@ void Actor::BeginTweeningQueued( float time, TweenType tt )
 	TS.m_fTimeLeftInTween = time;
 }
 
+void Actor::StopTweening()
+{
+	m_iNumTweenStates = 0;
+}
+
+
 void Actor::SetTweenX( float x )			{ GetLatestTween().m_end_pos.x = x; } 
 void Actor::SetTweenY( float y )			{ GetLatestTween().m_end_pos.y = y; }
 void Actor::SetTweenZ( float z )			{ GetLatestTween().m_end_pos.z = z; }
diff --git a/stepmania/src/Actor.h b/stepmania/src/Actor.h
index 85183da5bf..ba4cf61922 100644
--- a/stepmania/src/Actor.h
+++ b/stepmania/src/Actor.h
@@ -13,6 +13,8 @@
 #include <d3dx8math.h>
 
 
+const int MAX_TWEEN_STATES = 10;
+
 class Actor
 {
 public:
@@ -92,7 +94,7 @@ public:
 
 	virtual void BeginTweening( float time, TweenType tt = TWEEN_LINEAR );
 	virtual void BeginTweeningQueued( float time, TweenType tt = TWEEN_LINEAR );
-	virtual void StopTweening() { m_QueuedTweens.RemoveAll(); };
+	virtual void StopTweening();
 	virtual void SetTweenX( float x );
 	virtual void SetTweenY( float y );
 	virtual void SetTweenZ( float z );
@@ -206,8 +208,9 @@ protected:
 		};
 	};
 
-	CArray<TweenState, TweenState&> m_QueuedTweens;
-	TweenState& GetLatestTween() { return m_QueuedTweens[m_QueuedTweens.GetSize()-1]; };
+	TweenState	m_QueuedTweens[MAX_TWEEN_STATES];
+	int			m_iNumTweenStates;
+	TweenState& GetLatestTween() { return m_QueuedTweens[m_iNumTweenStates-1]; };
 
 
 	//
diff --git a/stepmania/src/GameConstantsAndTypes.h b/stepmania/src/GameConstantsAndTypes.h
index e64120cb4b..ceeeb61766 100644
--- a/stepmania/src/GameConstantsAndTypes.h
+++ b/stepmania/src/GameConstantsAndTypes.h
@@ -314,6 +314,48 @@ struct PlayerOptions
 	bool m_bHoldNotes;
 	enum DrainType { DRAIN_NORMAL=0, DRAIN_NO_RECOVER, DRAIN_SUDDEN_DEATH };
 	DrainType m_DrainType;
+
+	CString GetString()
+	{
+		CString sReturn;
+		if( m_fArrowScrollSpeed != 1 )
+			sReturn += ssprintf( "%2.1fX, ", m_fArrowScrollSpeed );
+		switch( m_EffectType )
+		{
+		case EFFECT_NONE:							break;
+		case EFFECT_BOOST:	sReturn += "Boost, ";	break;
+		case EFFECT_WAVE:	sReturn += "Wave, ";	break;
+		case EFFECT_DRUNK:	sReturn += "Drunk, ";	break;
+		case EFFECT_DIZZY:	sReturn += "Dizzy, ";	break;
+		case EFFECT_SPACE:	sReturn += "Space, ";	break;
+		default:	ASSERT(0);	// invalid EFFECT
+		}
+		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;
+		default:	ASSERT(0);	// invalid EFFECT
+		}
+		switch( m_TurnType )
+		{
+		case TURN_NONE:								break;
+		case TURN_MIRROR:	sReturn += "Mirror, ";	break;
+		case TURN_LEFT:		sReturn += "Left, ";	break;
+		case TURN_RIGHT:	sReturn += "Right, ";	break;
+		case TURN_SHUFFLE:	sReturn += "Shuffle, ";	break;
+		default:	ASSERT(0);	// invalid EFFECT
+		}
+		if( m_bLittle )
+			sReturn += "Little, ";
+		if( m_bReverseScroll )
+			sReturn += "Reverse, ";
+
+		if( sReturn.GetLength() > 2 )
+			sReturn.Delete( sReturn.GetLength()-2, 2 );	// delete the trailing ", "
+		return sReturn;
+	}
 };
 
 struct SongOptions
@@ -332,8 +374,19 @@ struct SongOptions
 };
 
 
-struct ScoreSummary {
-	ScoreSummary() { perfect=great=good=boo=miss=ok=ng=max_combo=0; score=0; };
+struct ScoreSummary 
+{
 	int perfect, great, good, boo, miss, ok, ng, max_combo;
 	float score;
+
+	float fRadarActual[NUM_RADAR_VALUES];
+	float fRadarPossible[NUM_RADAR_VALUES];
+
+	ScoreSummary() 
+	{ 
+		perfect=great=good=boo=miss=ok=ng=max_combo=0; 
+		score=0;
+		for( int r=0; r<NUM_RADAR_VALUES; r++ )
+			fRadarActual[r] = fRadarPossible[r] = 0;
+	}
 };
diff --git a/stepmania/src/GameManager.cpp b/stepmania/src/GameManager.cpp
index 31f8f77300..ea1e4e54aa 100644
--- a/stepmania/src/GameManager.cpp
+++ b/stepmania/src/GameManager.cpp
@@ -366,6 +366,7 @@ GameDef* GameManager::GetCurrentGameDef()
 
 StyleDef* GameManager::GetCurrentStyleDef()
 {
+	ASSERT( m_CurStyle != STYLE_NONE );
 	return &g_StyleDefs[ m_CurStyle ];
 }
 
diff --git a/stepmania/src/GradeDisplay.cpp b/stepmania/src/GradeDisplay.cpp
index e4d1c574ca..c87e8a745d 100644
--- a/stepmania/src/GradeDisplay.cpp
+++ b/stepmania/src/GradeDisplay.cpp
@@ -18,6 +18,9 @@
 
 
 const float SCROLL_TIME = 5.0f;
+const int NUM_GRADE_FRAMES = 7;
+const float GRADE_FRAME_HEIGHT = 1/(float)NUM_GRADE_FRAMES;
+const float GRADES_TO_SCROLL = NUM_GRADE_FRAMES*4;
 
 
 GradeDisplay::GradeDisplay()
@@ -37,7 +40,14 @@ void GradeDisplay::Update( float fDeltaTime )
 	m_fTimeLeftInScroll -= fDeltaTime;
 	m_fTimeLeftInScroll = max( 0, m_fTimeLeftInScroll );
 
-	const float fPercentIntoScrolling = 1 - (m_fTimeLeftInScroll/SCROLL_TIME);
+	float fPercentIntoScrolling = 1 - (m_fTimeLeftInScroll/SCROLL_TIME);
+	if( fPercentIntoScrolling < 0.75 )
+		fPercentIntoScrolling = (fPercentIntoScrolling/0.75f) * (1 + 1.0f/NUM_GRADE_FRAMES);
+	else if( fPercentIntoScrolling < 0.9 )
+		fPercentIntoScrolling = 1 + 1.0f/NUM_GRADE_FRAMES;
+	else
+		fPercentIntoScrolling = (1 + 1.0f/NUM_GRADE_FRAMES) - ((fPercentIntoScrolling-0.9f)/0.1f) * 1.0f/NUM_GRADE_FRAMES;
+
 	FRECT frectCurrentTextureCoords;
 	frectCurrentTextureCoords.left   = m_frectStartTexCoords.left*(1-fPercentIntoScrolling)   + m_frectDestTexCoords.left*fPercentIntoScrolling;
 	frectCurrentTextureCoords.top    = m_frectStartTexCoords.top*(1-fPercentIntoScrolling)    + m_frectDestTexCoords.top*fPercentIntoScrolling;
@@ -79,9 +89,28 @@ void GradeDisplay::SetGrade( Grade g )
 
 void GradeDisplay::SpinAndSettleOn( Grade g )
 {
+	ASSERT( g != GRADE_NO_DATA );
+	m_Grade = g;
+
 	SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
 
-	m_frectStartTexCoords = *m_pTexture->GetTextureCoordRect( 0 );
-	m_frectDestTexCoords = *m_pTexture->GetTextureCoordRect( 6 );
+	int iFrameNo;
+	switch( g )
+	{
+	case GRADE_AAA:		iFrameNo = 0;	break;
+	case GRADE_AA:		iFrameNo = 1;	break;
+	case GRADE_A:		iFrameNo = 2;	break;
+	case GRADE_B:		iFrameNo = 3;	break;
+	case GRADE_C:		iFrameNo = 4;	break;
+	case GRADE_D:		iFrameNo = 5;	break;
+	case GRADE_E:		iFrameNo = 6;	break;
+	default:	ASSERT(0);
+	}
+
+	m_frectDestTexCoords = *m_pTexture->GetTextureCoordRect( iFrameNo );
+	m_frectStartTexCoords = m_frectDestTexCoords;
+	m_frectStartTexCoords.top += GRADES_TO_SCROLL * GRADE_FRAME_HEIGHT;
+	m_frectStartTexCoords.bottom += GRADES_TO_SCROLL * GRADE_FRAME_HEIGHT;
+
 	m_fTimeLeftInScroll = SCROLL_TIME;
 }
diff --git a/stepmania/src/GradeDisplay.h b/stepmania/src/GradeDisplay.h
index 0f6fd9afee..15c1255c98 100644
--- a/stepmania/src/GradeDisplay.h
+++ b/stepmania/src/GradeDisplay.h
@@ -32,7 +32,6 @@ protected:
 	Grade m_Grade;
 
 	// for scrolling
-	void ScrollToVirtualFrame( int iFrameNo );	// a virtual frame is a tiled state number
 	FRECT m_frectStartTexCoords;
 	FRECT m_frectDestTexCoords;
 	float m_fTimeLeftInScroll;
diff --git a/stepmania/src/InputMapper.cpp b/stepmania/src/InputMapper.cpp
index 6828c2e0a3..65eacf1447 100644
--- a/stepmania/src/InputMapper.cpp
+++ b/stepmania/src/InputMapper.cpp
@@ -196,12 +196,12 @@ struct HardCodedMenuKey
 
 const HardCodedMenuKey g_HardCodedMenuKeys[] =
 {
-	{ DEVICE_KEYBOARD,	DIK_UP,		PLAYER_2, MENU_BUTTON_UP },
-	{ DEVICE_KEYBOARD,	DIK_DOWN,	PLAYER_2, MENU_BUTTON_DOWN },
-	{ DEVICE_KEYBOARD,	DIK_LEFT,	PLAYER_2, MENU_BUTTON_LEFT },
-	{ DEVICE_KEYBOARD,	DIK_RIGHT,	PLAYER_2, MENU_BUTTON_RIGHT },
-	{ DEVICE_KEYBOARD,	DIK_RETURN,	PLAYER_2, MENU_BUTTON_START },
-	{ DEVICE_KEYBOARD,	DIK_ESCAPE,	PLAYER_2, MENU_BUTTON_BACK },
+	{ DEVICE_KEYBOARD,	DIK_UP,		PLAYER_1, MENU_BUTTON_UP },
+	{ DEVICE_KEYBOARD,	DIK_DOWN,	PLAYER_1, MENU_BUTTON_DOWN },
+	{ DEVICE_KEYBOARD,	DIK_LEFT,	PLAYER_1, MENU_BUTTON_LEFT },
+	{ DEVICE_KEYBOARD,	DIK_RIGHT,	PLAYER_1, MENU_BUTTON_RIGHT },
+	{ DEVICE_KEYBOARD,	DIK_RETURN,	PLAYER_1, MENU_BUTTON_START },
+	{ DEVICE_KEYBOARD,	DIK_ESCAPE,	PLAYER_1, MENU_BUTTON_BACK },
 };
 const int NUM_HARD_CODED_MENU_KEYS = sizeof(g_HardCodedMenuKeys) / sizeof(HardCodedMenuKey);
 
diff --git a/stepmania/src/LifeMeterBar.cpp b/stepmania/src/LifeMeterBar.cpp
index 71bb33a9ad..f77b1d72b0 100644
--- a/stepmania/src/LifeMeterBar.cpp
+++ b/stepmania/src/LifeMeterBar.cpp
@@ -33,20 +33,19 @@ void LifeMeterBar::ChangeLife( TapNoteScore score )
 
 	switch( score )
 	{
-	case TNS_PERFECT:	m_fLifePercentage += 0.03f;	break;
+	case TNS_PERFECT:	m_fLifePercentage += 0.02f;	break;
 	case TNS_GREAT:		m_fLifePercentage += 0.01f;	break;
 	case TNS_GOOD:		m_fLifePercentage += 0.00f;	break;
 	case TNS_BOO:		m_fLifePercentage -= 0.05f;	break;
 	case TNS_MISS:		m_fLifePercentage -= 0.10f;	break;
 	}
+	m_fLifePercentage = clamp( m_fLifePercentage, 0, 1 );
 
 	bool bIsDoingGreat = IsDoingGreat();
 
 	if( bWasDoingGreat && !bIsDoingGreat )
 		m_fLifePercentage -= 0.10f;		// make it take a while to get back to "doing great"
 
-	m_fLifePercentage = clamp( m_fLifePercentage, 0, 1 );
-	
 	ResetBarVelocity();
 }
 
@@ -60,7 +59,7 @@ void LifeMeterBar::ResetBarVelocity()
 
 bool LifeMeterBar::IsDoingGreat() 
 { 
-	return m_fLifePercentage == 1; 
+	return m_fLifePercentage >= 1; 
 }
 
 bool LifeMeterBar::IsAboutToFail() 
@@ -77,15 +76,16 @@ void LifeMeterBar::Update( float fDeltaTime )
 {
 	m_fLifeVelocity *= 1-fDeltaTime*2;	// dampen
 
-	if( fabsf(m_fLifeVelocity) < 0.01f )
+	// there are some cases where we want to snap the meter
+	bool bSnap = m_fTrailingLifePercentage >= 1;
+
+	if( bSnap )
 	{
-		// snap
 		m_fTrailingLifePercentage = m_fLifePercentage;
 		m_fLifeVelocity = 0;
 	}
 	else
 	{
-
 		m_fTrailingLifePercentage += m_fLifeVelocity * fDeltaTime;
 		m_fTrailingLifePercentage = clamp( m_fTrailingLifePercentage, 0, 1 );
 	}
diff --git a/stepmania/src/MenuElements.cpp b/stepmania/src/MenuElements.cpp
index 8673f291a1..63ccd0d4cc 100644
--- a/stepmania/src/MenuElements.cpp
+++ b/stepmania/src/MenuElements.cpp
@@ -19,19 +19,21 @@
 #include "GameConstantsAndTypes.h"
 #include "ThemeManager.h"
 #include "RageLog.h"
+#include "RageLog.h"
+#include "GameManager.h"
 
 
 const float HELP_X		=	CENTER_X;
-const float HELP_Y		=	SCREEN_HEIGHT-28;
+const float HELP_Y		=	SCREEN_BOTTOM-28;
 
-const float STYLE_LOCAL_X	=	160;
-const float STYLE_LOCAL_Y	=	6;
+const float STYLE_ICON_LOCAL_X	=	130;
+const float STYLE_ICON_LOCAL_Y	=	6;
 
 const float TIMER_LOCAL_X	=	270;
 const float TIMER_LOCAL_Y	=	0;
 
 const float CREDIT_X[NUM_PLAYERS]	=	{160,480};
-const float CREDIT_Y[NUM_PLAYERS]	=	{SCREEN_BOTTOM-20, SCREEN_BOTTOM-20};
+const float CREDIT_Y[NUM_PLAYERS]	=	{SCREEN_BOTTOM-8, SCREEN_BOTTOM-8};
 
 
 MenuElements::MenuElements()
@@ -47,7 +49,15 @@ MenuElements::MenuElements()
 	this->AddActor( &m_frameBottomBar );
 	this->AddActor( &m_textHelp );
 	for( int p=0; p<NUM_PLAYERS; p++ )
-		this->AddActor( &m_sprCreditInfo[p] );
+		this->AddActor( &m_textCreditInfo[p] );
+
+	m_KeepAlive.SetZ( -2 );
+	m_KeepAlive.SetOpened();
+	this->AddActor( &m_KeepAlive );
+
+	m_Wipe.SetZ( -2 );
+	m_Wipe.SetOpened();
+	this->AddActor( &m_Wipe );
 }
 
 void MenuElements::Load( CString sBackgroundPath, CString sTopEdgePath, CString sHelpText )
@@ -66,8 +76,12 @@ void MenuElements::Load( CString sBackgroundPath, CString sTopEdgePath, CString
 	
 	m_sprStyleIcon.Load( THEME->GetPathTo(GRAPHIC_MENU_STYLE_ICONS) );
 	m_sprStyleIcon.StopAnimating();
-	m_sprStyleIcon.SetXY( STYLE_LOCAL_X, STYLE_LOCAL_Y );
+	m_sprStyleIcon.SetXY( STYLE_ICON_LOCAL_X, STYLE_ICON_LOCAL_Y );
 	m_sprStyleIcon.SetZ( -1 );
+	if( GAMEMAN->m_CurStyle == STYLE_NONE )
+		m_sprStyleIcon.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
+	else
+		m_sprStyleIcon.SetState( GAMEMAN->m_CurStyle );
 
 	m_MenuTimer.SetXY( TIMER_LOCAL_X, TIMER_LOCAL_Y );
 	m_MenuTimer.SetZ( -1 );
@@ -83,58 +97,76 @@ void MenuElements::Load( CString sBackgroundPath, CString sTopEdgePath, CString
 	m_textHelp.SetText( sHelpText );
 	m_textHelp.SetZoom( 0.5f );
 	m_textHelp.SetEffectBlinking();
-	m_textHelp.SetShadowLength( 2 );
+	m_textHelp.TurnShadowOff();
 
 	for( int p=0; p<NUM_PLAYERS; p++ )
 	{
-		m_sprCreditInfo[p].Load( THEME->GetPathTo(FONT_NORMAL) );
-		m_sprCreditInfo[p].SetXY( CREDIT_X[p], CREDIT_Y[p] );
-		m_sprCreditInfo[p].SetZ( -1 );
-		m_sprCreditInfo[p].SetText( "FREE PLAY" );
-		m_sprCreditInfo[p].SetZoom( 0.5f );
-		m_sprCreditInfo[p].TurnShadowOff();
+		m_textCreditInfo[p].Load( THEME->GetPathTo(FONT_NORMAL) );
+		m_textCreditInfo[p].SetXY( CREDIT_X[p], CREDIT_Y[p] );
+		m_textCreditInfo[p].SetZ( -1 );
+
+		if( GAMEMAN->m_CurStyle == STYLE_NONE )
+			m_textCreditInfo[p].SetText( "PRESS START" );
+		else if( GAMEMAN->IsPlayerEnabled( (PlayerNumber)p ) )
+			m_textCreditInfo[p].SetText( "PRESENT" );
+		else	// not enabled
+			m_textCreditInfo[p].SetText( "CREDIT(S):  0 / 0" );
+
+
+		m_textCreditInfo[p].SetZoom( 0.5f );
+		m_textCreditInfo[p].SetDiffuseColor( D3DXCOLOR(0,0,0,1) );
+		m_textCreditInfo[p].TurnShadowOff();
 	}
 	
 	m_soundSwoosh.Load( THEME->GetPathTo(SOUND_MENU_SWOOSH) );
 	m_soundBack.Load( THEME->GetPathTo(SOUND_MENU_BACK) );
 
 
-	SetTopEdgeOnScreen();
-	SetBackgroundOnScreen();
+
+	m_frameTopBar.SetXY( CENTER_X, m_sprTopEdge.GetZoomedHeight()/2 );
+
+	m_frameBottomBar.SetXY( CENTER_X, SCREEN_HEIGHT - m_sprBottomEdge.GetZoomedHeight()/2 );
 }
 
-
-void MenuElements::TweenTopEdgeOnScreen()
+void MenuElements::TweenTopLayerOnScreen()
 {
-	SetTopEdgeOffScreen();
-
+	m_frameTopBar.SetXY( CENTER_X+SCREEN_WIDTH, m_sprTopEdge.GetZoomedHeight()/2 );
 	m_frameTopBar.BeginTweening( MENU_ELEMENTS_TWEEN_TIME*2, TWEEN_SPRING );
 	m_frameTopBar.SetTweenX( CENTER_X );
 
-	float fOriginalZoomY = m_textHelp.GetZoomY();
+	float fOriginalZoom = m_textHelp.GetZoomY();
 	m_textHelp.SetZoomY( 0 );
 	m_textHelp.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
-	m_textHelp.SetTweenZoomY( fOriginalZoomY );
+	m_textHelp.SetTweenZoomY( fOriginalZoom );
+}
 
+void MenuElements::TweenOnScreenFromMenu( ScreenMessage smSendWhenDone )
+{
+	TweenTopLayerOnScreen();
+	m_KeepAlive.OpenWipingRight( smSendWhenDone );
 	m_soundSwoosh.Play();
 }
 
-void MenuElements::TweenTopEdgeOffScreen()
+void MenuElements::TweenTopLayerOffScreen()
 {
 	m_frameTopBar.BeginTweening( MENU_ELEMENTS_TWEEN_TIME*2, TWEEN_BIAS_END );
 	m_frameTopBar.SetTweenX( SCREEN_WIDTH*1.5f );
 
-
 	m_textHelp.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_textHelp.SetTweenZoomY( 0 );
+}
 
+void MenuElements::TweenOffScreenToMenu( ScreenMessage smSendWhenDone )
+{
+	TweenTopLayerOffScreen();
+	m_KeepAlive.CloseWipingRight( smSendWhenDone );
 	m_soundSwoosh.Play();
 }
 
-void MenuElements::TweenBackgroundOnScreen()
-{
-	SetBackgroundOffScreen();
 
+void MenuElements::TweenBottomLayerOnScreen()
+{
+	m_frameBottomBar.SetXY( CENTER_X, SCREEN_HEIGHT + m_sprBottomEdge.GetZoomedHeight()/2 );
 	m_frameBottomBar.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_frameBottomBar.SetTweenY( SCREEN_HEIGHT - m_sprBottomEdge.GetZoomedHeight()/2 );
 
@@ -142,10 +174,9 @@ void MenuElements::TweenBackgroundOnScreen()
 	m_sprBG.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_sprBG.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
 
-	m_soundSwoosh.Play();
 }
 
-void MenuElements::TweenBackgroundOffScreen()
+void MenuElements::TweenBottomLayerOffScreen()
 {
 	m_frameBottomBar.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_frameBottomBar.SetTweenY( SCREEN_HEIGHT + m_sprTopEdge.GetZoomedHeight() );
@@ -153,43 +184,28 @@ void MenuElements::TweenBackgroundOffScreen()
 	m_sprBG.SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
 	m_sprBG.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_sprBG.SetTweenDiffuseColor( D3DXCOLOR(0,0,0,1) );
-
-	m_soundBack.Play();
 }
 
-void MenuElements::TweenAllOnScreen()
+void MenuElements::TweenOnScreenFromBlack( ScreenMessage smSendWhenDone )
 {
-	TweenTopEdgeOnScreen();
-	TweenBackgroundOnScreen();
+	TweenTopLayerOnScreen();
+	TweenBottomLayerOnScreen();
+	m_Wipe.OpenWipingRight( smSendWhenDone );
+	m_soundSwoosh.Play();
 }
 
-void MenuElements::TweenAllOffScreen()
+void MenuElements::TweenOffScreenToBlack( ScreenMessage smSendWhenDone, bool bPlayBackSound )
 {
-	TweenTopEdgeOffScreen();
-	TweenBackgroundOffScreen();
+	if( !bPlayBackSound )
+	{
+		TweenTopLayerOffScreen();
+		TweenBottomLayerOffScreen();
+	}
+	m_Wipe.CloseWipingRight( smSendWhenDone );
+	if( bPlayBackSound )
+		m_soundBack.Play();
 }
 
-void MenuElements::SetBackgroundOnScreen()
-{
-	m_frameBottomBar.SetXY( CENTER_X, SCREEN_HEIGHT - m_sprBottomEdge.GetZoomedHeight()/2 );
-}
-
-void MenuElements::SetBackgroundOffScreen()
-{
-	m_frameBottomBar.SetXY( CENTER_X, SCREEN_HEIGHT + m_sprBottomEdge.GetZoomedHeight()/2 );
-}
-
-void MenuElements::SetTopEdgeOnScreen()
-{
-	m_frameTopBar.SetXY( CENTER_X, m_sprTopEdge.GetZoomedHeight()/2 );
-}
-
-void MenuElements::SetTopEdgeOffScreen()
-{
-	m_frameTopBar.SetXY( CENTER_X+SCREEN_WIDTH, m_sprTopEdge.GetZoomedHeight()/2 );
-}
-
-
 void MenuElements::DrawPrimitives()
 {
 	// do nothing.  Call DrawBottomLayer() and DrawTopLayer() instead.
@@ -200,6 +216,11 @@ void MenuElements::DrawTopLayer()
 	m_frameTopBar.Draw();
 	m_frameBottomBar.Draw();
 	m_textHelp.Draw();
+	for( int p=0; p<NUM_PLAYERS; p++ )
+		m_textCreditInfo[p].Draw();
+
+	m_KeepAlive.Draw();
+	m_Wipe.Draw();
 }
 
 void MenuElements::DrawBottomLayer()
diff --git a/stepmania/src/MenuElements.h b/stepmania/src/MenuElements.h
index 62c5d9bde7..eb9913b8f4 100644
--- a/stepmania/src/MenuElements.h
+++ b/stepmania/src/MenuElements.h
@@ -18,6 +18,8 @@
 #include "RandomSample.h"
 #include "TransitionFade.h"
 #include "MenuTimer.h"
+#include "TransitionFadeWipe.h"
+#include "TransitionKeepAlive.h"
 
 
 const float MENU_ELEMENTS_TWEEN_TIME	=	0.30f;
@@ -35,21 +37,20 @@ public:
 	void DrawTopLayer();
 	void DrawBottomLayer();
 
-	void TweenTopEdgeOnScreen();
-	void TweenTopEdgeOffScreen();
+	void TweenOnScreenFromMenu( ScreenMessage smSendWhenDone );
+	void TweenOffScreenToMenu( ScreenMessage smSendWhenDone );
 
-	void TweenAllOnScreen();	// tween top edge + background
-	void TweenAllOffScreen();
+	void TweenOnScreenFromBlack( ScreenMessage smSendWhenDone );
+	void TweenOffScreenToBlack( ScreenMessage smSendWhenDone, bool bPlayBackSound );
+
+	bool IsClosing() { return m_Wipe.IsClosing() || m_KeepAlive.IsClosing(); };
 
 protected:
-	void TweenBackgroundOnScreen();
-	void TweenBackgroundOffScreen();
+	void TweenTopLayerOnScreen();
+	void TweenTopLayerOffScreen();
 
-	void SetBackgroundOnScreen();
-	void SetBackgroundOffScreen();
-
-	void SetTopEdgeOnScreen();
-	void SetTopEdgeOffScreen();
+	void TweenBottomLayerOnScreen();
+	void TweenBottomLayerOffScreen();
 
 
 	// stuff in the top bar
@@ -65,8 +66,10 @@ protected:
 	// stuff in the main frame
 	Sprite		m_sprBG;
 	BitmapText	m_textHelp;
-	BitmapText	m_sprCreditInfo[NUM_PLAYERS];
+	BitmapText	m_textCreditInfo[NUM_PLAYERS];
 
+	TransitionFadeWipe	m_Wipe;
+	TransitionKeepAlive	m_KeepAlive;
 
 	RageSoundSample m_soundSwoosh;
 	RageSoundSample m_soundBack;
diff --git a/stepmania/src/MenuTimer.cpp b/stepmania/src/MenuTimer.cpp
index eb4f551887..43dc55f3df 100644
--- a/stepmania/src/MenuTimer.cpp
+++ b/stepmania/src/MenuTimer.cpp
@@ -24,13 +24,15 @@ MenuTimer::MenuTimer()
 
 	m_textDigit1.Load( THEME->GetPathTo(FONT_TIMER_NUMBERS) );
 	m_textDigit1.TurnShadowOff();
-	m_textDigit1.SetXY( -20, 0 );
+	m_textDigit1.SetXY( -18, 0 );
 	this->AddActor( &m_textDigit1 );
 
 	m_textDigit2.Load( THEME->GetPathTo(FONT_TIMER_NUMBERS) );
 	m_textDigit2.TurnShadowOff();
-	m_textDigit2.SetXY( +20, 0 );
+	m_textDigit2.SetXY( +18, 0 );
 	this->AddActor( &m_textDigit2 );
+
+	m_soundBeep.Load( THEME->GetPathTo(SOUND_MENU_TIMER) );
 }
 
 
@@ -45,17 +47,24 @@ void MenuTimer::Update( float fDeltaTime )
 	{
 		m_textDigit1.SetEffectGlowing( 10, D3DXCOLOR(1,0,0,0), D3DXCOLOR(1,0,0,1) );
 		m_textDigit2.SetEffectGlowing( 10, D3DXCOLOR(1,0,0,0), D3DXCOLOR(1,0,0,1) );
+		m_soundBeep.Play();
 	}
+	else if( fOldSecondsLeft > 4  &&  fNewSecondsLeft < 4 )	// transition to below 4
+		m_soundBeep.Play();
+	else if( fOldSecondsLeft > 3  &&  fNewSecondsLeft < 3 )	// transition to below 3
+		m_soundBeep.Play();
+	else if( fOldSecondsLeft > 2  &&  fNewSecondsLeft < 2 )	// transition to below 2
+		m_soundBeep.Play();
+	else if( fOldSecondsLeft > 1  &&  fNewSecondsLeft < 1 )	// transition to below 1
+		m_soundBeep.Play();
 	else if( fOldSecondsLeft > 0  &&  fNewSecondsLeft < 0 )	// transition to below 0
-	{
 		SCREENMAN->SendMessageToTopScreen( SM_MenuTimer, 0 );
-	}
 
 	m_fSecondsLeft = fNewSecondsLeft;
 	m_fSecondsLeft = max( 0, m_fSecondsLeft );
 
-	m_textDigit1.SetText( ssprintf("%d", ((int)m_fSecondsLeft)/10) ); 
-	m_textDigit2.SetText( ssprintf("%d", ((int)m_fSecondsLeft)%10) ); 
+	m_textDigit1.SetText( ssprintf("%d", ((int)m_fSecondsLeft+1)/10) ); 
+	m_textDigit2.SetText( ssprintf("%d", ((int)m_fSecondsLeft+1)%10) ); 
 
 	// "flip" the numbers
 	float fRemainder = m_fSecondsLeft - (int)m_fSecondsLeft;
diff --git a/stepmania/src/MenuTimer.h b/stepmania/src/MenuTimer.h
index be75cd72da..02b8677f53 100644
--- a/stepmania/src/MenuTimer.h
+++ b/stepmania/src/MenuTimer.h
@@ -14,7 +14,7 @@
 #include "Song.h"
 #include "ActorFrame.h"
 #include "BitmapText.h"
-#include "Quad.h"
+#include "RageSoundSample.h"
 
 
 class MenuTimer : public ActorFrame
@@ -31,4 +31,6 @@ protected:
 
 	BitmapText m_textDigit1;
 	BitmapText m_textDigit2;
+
+	RageSoundSample	m_soundBeep;
 };
diff --git a/stepmania/src/MusicWheel.cpp b/stepmania/src/MusicWheel.cpp
index e4c0a0bd0f..3c3f693f79 100644
--- a/stepmania/src/MusicWheel.cpp
+++ b/stepmania/src/MusicWheel.cpp
@@ -21,6 +21,7 @@
 #include "GameConstantsAndTypes.h"
 
 
+const float FADE_TIME	=	1.0f;
 
 const float SWITCH_MUSIC_TIME	=	0.3f;
 
@@ -190,6 +191,8 @@ void WheelItemDisplay::RefreshGrades()
 
 void WheelItemDisplay::Update( float fDeltaTime )
 {
+	Actor::Update( fDeltaTime );
+
 	switch( m_WheelItemType )
 	{
 	case TYPE_SECTION:
@@ -238,6 +241,12 @@ MusicWheel::MusicWheel()
 { 
 	LOG->WriteLine( "MusicWheel::MusicWheel()" );
 
+	
+	// for debugging
+	if( GAMEMAN->m_CurStyle == STYLE_NONE )
+		GAMEMAN->m_CurStyle = STYLE_DANCE_SINGLE;
+
+
 	for( int p=0; p<NUM_PLAYERS; p++ )
 	{
 		m_sprHighScoreFrame[p].Load( THEME->GetPathTo(GRAPHIC_SELECT_MUSIC_SCORE_FRAME) );
@@ -515,44 +524,6 @@ float MusicWheel::GetBannerX( float fPosOffsetsFromMiddle )
 {	
 	float fX = (1-cosf((fPosOffsetsFromMiddle)/3))*95.0f;
 	
-	float fPercentOffScreen = 0;
-	switch( m_WheelState )
-	{
-	case STATE_FLYING_OFF_BEFORE_NEXT_SORT:
-	case STATE_TWEENING_OFF_SCREEN:
-		fPercentOffScreen = 1 - (m_fTimeLeftInState / FADE_TIME);
-		break;
-	case STATE_FLYING_ON_AFTER_NEXT_SORT:
-	case STATE_TWEENING_ON_SCREEN:
-		fPercentOffScreen = m_fTimeLeftInState / FADE_TIME;
-		break;
-	default:
-		fPercentOffScreen = 1;
-		break;
-	}
-
-	switch( m_WheelState )
-	{
-	case STATE_FLYING_OFF_BEFORE_NEXT_SORT:
-	case STATE_TWEENING_OFF_SCREEN:
-	case STATE_FLYING_ON_AFTER_NEXT_SORT:
-	case STATE_TWEENING_ON_SCREEN:
-		{
-		/*
-		float fDistFromCenter = fabsf( fPosOffsetsFromMiddle );
-		float fPercentOffScreen = 1- (m_fTimeLeftInState / FADE_TIME);
-		float fXLogicalOffset = max( 0, fPercentOffScreen - 1 + (fDistFromCenter+3)/6 );
-		fXLogicalOffset = powf( fXLogicalOffset, 1.7f );	// accelerate 
-		float fXPixelOffset = fXLogicalOffset * 600;
-		fX += fXPixelOffset;
-		*/
-		const float fShift = fPosOffsetsFromMiddle/NUM_WHEEL_ITEMS_TO_DRAW - 0.5f;	// this is always < 0
-		const float fXTween = fShift * 800 + fPercentOffScreen * 1200;
-		fX = max( fX, fXTween );
-		}
-		break;
-	}
-
 	return (float)roundf( fX );
 }
 
@@ -622,19 +593,23 @@ void MusicWheel::DrawPrimitives()
 	{
 		WheelItemDisplay& display = m_WheelItemDisplays[i];
 
-		float fThisBannerPositionOffsetFromSelection = i - NUM_WHEEL_ITEMS_TO_DRAW/2 + m_fPositionOffsetFromSelection;
+		switch( m_WheelState )
+		{
+		case STATE_IDLE:
+		case STATE_SWITCHING_MUSIC:
+			{
+				float fThisBannerPositionOffsetFromSelection = i - NUM_WHEEL_ITEMS_TO_DRAW/2 + m_fPositionOffsetFromSelection;
 
-		float fY = GetBannerY( fThisBannerPositionOffsetFromSelection );
-		if( fY < -SCREEN_HEIGHT/2  ||  fY > SCREEN_HEIGHT/2 )
-			continue; // skip
+				float fY = GetBannerY( fThisBannerPositionOffsetFromSelection );
+				if( fY < -SCREEN_HEIGHT/2  ||  fY > SCREEN_HEIGHT/2 )
+					continue; // skip
 
-		float fX = GetBannerX( fThisBannerPositionOffsetFromSelection );
-		display.SetXY( fX, fY );
+				float fX = GetBannerX( fThisBannerPositionOffsetFromSelection );
+				display.SetXY( fX, fY );
+			}
+			break;
+		};
 
-		float fBrightness = GetBannerBrightness( m_fPositionOffsetFromSelection );
-		float fAlpha = GetBannerAlpha( m_fPositionOffsetFromSelection );
-
-		display.SetDiffuseColor( D3DXCOLOR(fBrightness, fBrightness, fBrightness, fAlpha) );
 		display.Draw();
 	}
 
@@ -717,6 +692,8 @@ void MusicWheel::Update( float fDeltaTime )
 
 			RebuildWheelItemDisplays();
 
+			TweenOnScreen();
+
 			}
 			break;
 		case STATE_FLYING_ON_AFTER_NEXT_SORT:
@@ -840,6 +817,8 @@ void MusicWheel::NextSort()
 	m_MusicSortDisplay.BeginTweening( FADE_TIME, TWEEN_BIAS_END );
 	m_MusicSortDisplay.SetTweenXY( SORT_ICON_OFF_SCREEN_X, SORT_ICON_OFF_SCREEN_Y );
 
+	TweenOffScreen();
+
 	m_WheelState = STATE_FLYING_OFF_BEFORE_NEXT_SORT;
 	m_fTimeLeftInState = FADE_TIME;
 }
@@ -892,23 +871,83 @@ void MusicWheel::TweenOnScreen()
 	m_WheelState = STATE_TWEENING_ON_SCREEN;
 	m_fTimeLeftInState = FADE_TIME; 
 
-	float fOriginalZoomY;
-	fOriginalZoomY = m_sprSelectionOverlay.GetZoomY();
-	m_sprSelectionOverlay.SetZoomY( 0 );
-	m_sprSelectionOverlay.BeginTweening( FADE_TIME );
-	m_sprSelectionOverlay.SetTweenZoomY( fOriginalZoomY );
 
+	m_MusicSortDisplay.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
+	m_MusicSortDisplay.BeginTweening( FADE_TIME );
+	m_MusicSortDisplay.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
+
+
+	for( int p=0; p<NUM_PLAYERS; p++ )
+	{
+		float fOriginalX = m_HighScore[p].GetX();
+		m_HighScore[p].SetX( fOriginalX+320 );
+		m_HighScore[p].BeginTweening( 0.2f, Actor::TWEEN_BIAS_END );
+		m_HighScore[p].SetTweenX( fOriginalX );
+	}
+
+
+	float fX = GetBannerX(0);
+	float fY = GetBannerY(0);
+	m_sprSelectionOverlay.SetXY( fX+320, fY );
+	m_sprSelectionOverlay.BeginTweeningQueued( 0.5f );	// sleep
+	m_sprSelectionOverlay.BeginTweeningQueued( 0.2f, Actor::TWEEN_BIAS_BEGIN );
+	m_sprSelectionOverlay.SetTweenX( fX );
+
+
+	for( int i=0; i<NUM_WHEEL_ITEMS_TO_DRAW; i++ )
+	{
+		WheelItemDisplay& display = m_WheelItemDisplays[i];
+		float fThisBannerPositionOffsetFromSelection = i - NUM_WHEEL_ITEMS_TO_DRAW/2 + m_fPositionOffsetFromSelection;
+
+		float fX = GetBannerX(fThisBannerPositionOffsetFromSelection);
+		float fY = GetBannerY(fThisBannerPositionOffsetFromSelection);
+		display.SetXY( fX+320, fY );
+		display.BeginTweeningQueued( 0.04f*i );	// sleep
+		display.BeginTweeningQueued( 0.2f, Actor::TWEEN_BIAS_BEGIN );
+		display.SetTweenX( fX );
+	}
 }
 						   
-						   
 void MusicWheel::TweenOffScreen()
 {
 	m_WheelState = STATE_TWEENING_OFF_SCREEN;
 	m_fTimeLeftInState = FADE_TIME;
 
-	m_sprSelectionOverlay.BeginTweening( FADE_TIME );
-	m_sprSelectionOverlay.SetTweenZoomY( 0 );
+	
+	m_MusicSortDisplay.SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
+	m_MusicSortDisplay.SetEffectNone();
+	m_MusicSortDisplay.BeginTweening( FADE_TIME );
+	m_MusicSortDisplay.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
+
+
+	for( int p=0; p<NUM_PLAYERS; p++ )
+	{
+		m_HighScore[p].BeginTweening( 0.2f, Actor::TWEEN_BIAS_END );
+		m_HighScore[p].SetTweenX( m_HighScore[p].GetX()+320 );
+	}
+
+
+	float fX = GetBannerX(0);
+	float fY = GetBannerY(0);
+	m_sprSelectionOverlay.SetXY( fX, fY );
+	m_sprSelectionOverlay.BeginTweeningQueued( 0 );	// sleep
+	m_sprSelectionOverlay.BeginTweeningQueued( 0.2f, Actor::TWEEN_BIAS_END );
+	m_sprSelectionOverlay.SetTweenX( fX+320 );
+
+
+	for( int i=0; i<NUM_WHEEL_ITEMS_TO_DRAW; i++ )
+	{
+		WheelItemDisplay& display = m_WheelItemDisplays[i];
+		float fThisBannerPositionOffsetFromSelection = i - NUM_WHEEL_ITEMS_TO_DRAW/2 + m_fPositionOffsetFromSelection;
+
+		float fX = GetBannerX(fThisBannerPositionOffsetFromSelection);
+		float fY = GetBannerY(fThisBannerPositionOffsetFromSelection);
+		display.SetXY( fX, fY );
+		display.BeginTweeningQueued( 0.04f*i );	// sleep
+		display.BeginTweeningQueued( 0.2f, Actor::TWEEN_BIAS_END );
+		display.SetTweenX( fX+320 );
+	}
+
+
 
-	m_MusicSortDisplay.BeginTweening( FADE_TIME, TWEEN_BIAS_END );
-	m_MusicSortDisplay.SetTweenXY( SORT_ICON_OFF_SCREEN_X, SORT_ICON_OFF_SCREEN_Y );
 }
\ No newline at end of file
diff --git a/stepmania/src/MusicWheel.h b/stepmania/src/MusicWheel.h
index 1b72ba52d9..7461c3b5f8 100644
--- a/stepmania/src/MusicWheel.h
+++ b/stepmania/src/MusicWheel.h
@@ -29,7 +29,6 @@
 
 const int NUM_WHEEL_ITEMS_TO_DRAW	=	13;
 
-const float FADE_TIME	=	0.7f;
 
 const ScreenMessage	SM_SongChanged		=	ScreenMessage(SM_User+47);	// this should be unique!
 const ScreenMessage SM_PlaySongSample	=	ScreenMessage(SM_User+48);	
@@ -102,15 +101,15 @@ public:
 	void NextSort();
 	void NotesChanged( PlayerNumber pn );	// update grade graphics and top score
 
+	float GetBannerX( float fPosOffsetsFromMiddle );
 	float GetBannerY( float fPosOffsetsFromMiddle );
 	float GetBannerBrightness( float fPosOffsetsFromMiddle );
 	float GetBannerAlpha( float fPosOffsetsFromMiddle );
-	float GetBannerX( float fPosOffsetsFromMiddle );
 
 	bool Select();	// return true if the selected item is a music, otherwise false
-	WheelItemType GetSelectedType()	{ return GetCurWheelItemDatas()[m_iSelection].m_WheelItemType; };
-	Song* GetSelectedSong()			{ return GetCurWheelItemDatas()[m_iSelection].m_pSong; };
-	CString GetSelectedSection()	{ return GetCurWheelItemDatas()[m_iSelection].m_sSectionName; };
+	WheelItemType	GetSelectedType()	{ return GetCurWheelItemDatas()[m_iSelection].m_WheelItemType; };
+	Song*			GetSelectedSong()	{ return GetCurWheelItemDatas()[m_iSelection].m_pSong; };
+	CString			GetSelectedSection(){ return GetCurWheelItemDatas()[m_iSelection].m_sSectionName; };
 
 
 protected:
@@ -127,15 +126,15 @@ protected:
 	Sprite				m_sprHighScoreFrame[NUM_PLAYERS];
 	ScoreDisplayRolling	m_HighScore[NUM_PLAYERS];
 
-	SongSortOrder m_SortOrder;
+	SongSortOrder		m_SortOrder;
 
 	CArray<WheelItemData, WheelItemData&> m_WheelItemDatas[NUM_SORT_ORDERS];
 	CArray<WheelItemData, WheelItemData&> &GetCurWheelItemDatas() { return m_WheelItemDatas[m_SortOrder]; };
 	
-	WheelItemDisplay m_WheelItemDisplays[NUM_WHEEL_ITEMS_TO_DRAW];
+	WheelItemDisplay	m_WheelItemDisplays[NUM_WHEEL_ITEMS_TO_DRAW];
 	
-	int	m_iSelection;		// index into GetCurWheelItemDatas()
-	CString m_sExpandedSectionName;
+	int					m_iSelection;		// index into GetCurWheelItemDatas()
+	CString				m_sExpandedSectionName;
 
 
 	enum WheelState { 
@@ -147,9 +146,9 @@ protected:
 		STATE_TWEENING_OFF_SCREEN, 
 		STATE_WAITING_OFF_SCREEN
 	};
-	WheelState m_WheelState;
-	float m_fTimeLeftInState;
-	float m_fPositionOffsetFromSelection;
+	WheelState			m_WheelState;
+	float				m_fTimeLeftInState;
+	float				m_fPositionOffsetFromSelection;
 
 
 	// having sounds here causes a crash in Bass.  What the heck!?!?!
diff --git a/stepmania/src/Notes.cpp b/stepmania/src/Notes.cpp
index be62d57f85..b48f7b335e 100644
--- a/stepmania/src/Notes.cpp
+++ b/stepmania/src/Notes.cpp
@@ -496,7 +496,7 @@ bool Notes::LoadFromDWITokens(
 		mapDanceNoteToNoteDataColumn[DANCE_NOTE_PAD1_RIGHT] = 5;
 	}
 	else
-		ASSERT( false );
+		ASSERT(0);
 
 	m_sDescription = sDescription;
 
@@ -623,6 +623,8 @@ bool Notes::LoadFromDWITokens(
 
 	m_pNoteData->Convert2sAnd3sToHoldNotes();	// this will expand the HoldNote begin markers we wrote into actual HoldNotes
 
+	ASSERT( m_pNoteData->m_iNumTracks > 0 );
+
 	return true;
 }
 
diff --git a/stepmania/src/PrefsManager.cpp b/stepmania/src/PrefsManager.cpp
index ab997348f8..2f3dd31d8e 100644
--- a/stepmania/src/PrefsManager.cpp
+++ b/stepmania/src/PrefsManager.cpp
@@ -20,7 +20,7 @@ PrefsManager*	PREFSMAN = NULL;	// global and accessable from anywhere in our pro
 
 PrefsManager::PrefsManager()
 {
-	m_WindowMode = WINDOW_MODE_FULLSCREEN;
+	m_bWindowed = false;
 	m_bHighDetail = true;
 	m_bHighTextureDetail = true;
 	m_bIgnoreJoyAxes = false;
@@ -52,7 +52,7 @@ void PrefsManager::ReadPrefsFromDisk()
 	if( !ini.ReadFile() )
 		return;		// could not read config file, load nothing
 
-	ini.GetValueI( "Options", "WindowMode",			(int&)m_WindowMode );
+	ini.GetValueB( "Options", "Windowed",			m_bWindowed );
 	ini.GetValueB( "Options", "HighDetail",			m_bHighDetail );
 	ini.GetValueB( "Options", "HighTextureDetail",	m_bHighTextureDetail );
 	ini.GetValueB( "Options", "IgnoreJoyAxes",		m_bIgnoreJoyAxes );
@@ -70,7 +70,7 @@ void PrefsManager::SavePrefsToDisk()
 	IniFile ini;
 	ini.SetPath( "StepMania.ini" );
 
-	ini.SetValueI( "Options", "WindowMode",			(int)m_WindowMode );
+	ini.SetValueB( "Options", "Windowed",			m_bWindowed );
 	ini.SetValueB( "Options", "HighDetail",			m_bHighDetail );
 	ini.GetValueB( "Options", "HighTextureDetail",	m_bHighTextureDetail );
 	ini.SetValueB( "Options", "IgnoreJoyAxes",		m_bIgnoreJoyAxes );
diff --git a/stepmania/src/PrefsManager.h b/stepmania/src/PrefsManager.h
index 84703c3f51..4291cc8c26 100644
--- a/stepmania/src/PrefsManager.h
+++ b/stepmania/src/PrefsManager.h
@@ -16,7 +16,7 @@
 
 
 const int NUM_PAD_TO_DEVICE_SLOTS	= 3;	// three device inputs may map to one pad input
-
+const int MAX_NUM_STAGES = 10;
 
 class PrefsManager
 {
@@ -25,17 +25,16 @@ public:
 	~PrefsManager();
 
 	// Options that ARE saved between sessions
-	enum WindowMode{ WINDOW_MODE_FULLSCREEN, WINDOW_MODE_WINDOWED, WINDOW_MODE_MAXIMIZED, NUM_WINDOW_MODES };
-	WindowMode		m_WindowMode;
-	bool			m_bHighDetail;
-	bool			m_bHighTextureDetail;
-	bool			m_bIgnoreJoyAxes;
-	bool			m_bShowFPS;
-	bool			m_bUseRandomVis;
-	bool			m_bAnnouncer;
-	bool			m_bEventMode;
-	int				m_iNumArcadeStages;
-	int				m_iDifficulty;
+	bool	m_bWindowed;
+	bool	m_bHighDetail;
+	bool	m_bHighTextureDetail;
+	bool	m_bIgnoreJoyAxes;
+	bool	m_bShowFPS;
+	bool	m_bUseRandomVis;
+	bool	m_bAnnouncer;
+	bool	m_bEventMode;
+	int		m_iNumArcadeStages;
+	int		m_iDifficulty;
 
 	void ReadPrefsFromDisk();
 	void SavePrefsToDisk();
@@ -55,9 +54,7 @@ public:
 	PlayerOptions	m_PlayerOptions[NUM_PLAYERS];
 	SongOptions		m_SongOptions;
 
-	ScoreSummary	m_ScoreSummary[NUM_PLAYERS];	// for passing from Dancing to Results
-
-
+	ScoreSummary	m_ScoreSummary[NUM_PLAYERS][MAX_NUM_STAGES];	// for passing from Dancing to Results
 };
 
 
diff --git a/stepmania/src/RageDisplay.cpp b/stepmania/src/RageDisplay.cpp
index a892b8066e..44a5036f27 100644
--- a/stepmania/src/RageDisplay.cpp
+++ b/stepmania/src/RageDisplay.cpp
@@ -327,8 +327,9 @@ HRESULT RageDisplay::BeginFrame()
 	m_pd3dDevice->SetRenderState( D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA );
 	m_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
 
-	m_pd3dDevice->SetRenderState( D3DRS_ZENABLE,      TRUE );
-	m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
+	m_pd3dDevice->SetRenderState( D3DRS_ZENABLE,      FALSE );
+//	m_pd3dDevice->SetRenderState( D3DRS_ZENABLE,      TRUE );
+//	m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
 
 
     m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
diff --git a/stepmania/src/RageSound.cpp b/stepmania/src/RageSound.cpp
index 64a3dce970..4bfc329715 100644
--- a/stepmania/src/RageSound.cpp
+++ b/stepmania/src/RageSound.cpp
@@ -72,6 +72,7 @@ RageSound::RageSound( HWND hWnd )
 
 RageSound::~RageSound()
 {
+	BASS_Stop();
 	BASS_Free();
 }
 
diff --git a/stepmania/src/RageTexture.cpp b/stepmania/src/RageTexture.cpp
index 795d5ab8d8..14a70a5262 100644
--- a/stepmania/src/RageTexture.cpp
+++ b/stepmania/src/RageTexture.cpp
@@ -61,7 +61,9 @@ void RageTexture::CreateFrameRects()
 	///////////////////////////////////
 	// Fill in the m_FrameRects with the bounds of each frame in the animation.
 	///////////////////////////////////
+	m_TextureCoordRects.SetSize( 1, 10 );	// most textures will have only one frame
 	m_TextureCoordRects.RemoveAll();
+
 	for( int j=0; j<m_iFramesHigh; j++ )		// traverse along Y
 	{
 		for( int i=0; i<m_iFramesWide; i++ )	// traverse along X (important that this is the inner loop)
diff --git a/stepmania/src/Screen.h b/stepmania/src/Screen.h
index 7bf802b9bc..6170e793e7 100644
--- a/stepmania/src/Screen.h
+++ b/stepmania/src/Screen.h
@@ -50,12 +50,12 @@ protected:
 public:
 
 	// let subclass override if they want
-	virtual void MenuUp(	const PlayerNumber p, const InputEventType type )	{ MenuUp(p); };
-	virtual void MenuDown(	const PlayerNumber p, const InputEventType type )	{ MenuDown(p); };
-	virtual void MenuLeft(	const PlayerNumber p, const InputEventType type )	{ MenuLeft(p); };
-	virtual void MenuRight( const PlayerNumber p, const InputEventType type )	{ MenuRight(p); };
-	virtual void MenuStart( const PlayerNumber p, const InputEventType type )	{ MenuStart(p); };
-	virtual void MenuBack(	const PlayerNumber p, const InputEventType type )	{ MenuBack(p); };
+	virtual void MenuUp(	const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuUp(p); };
+	virtual void MenuDown(	const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuDown(p); };
+	virtual void MenuLeft(	const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuLeft(p); };
+	virtual void MenuRight( const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuRight(p); };
+	virtual void MenuStart( const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuStart(p); };
+	virtual void MenuBack(	const PlayerNumber p, const InputEventType type )	{ if( type==IET_FIRST_PRESS) MenuBack(p); };
 
 	virtual void MenuUp(	const PlayerNumber p )	{};
 	virtual void MenuDown(	const PlayerNumber p )	{};
diff --git a/stepmania/src/ScreenEditMenu.cpp b/stepmania/src/ScreenEditMenu.cpp
index 2cb36fdc02..e7e2a714f6 100644
--- a/stepmania/src/ScreenEditMenu.cpp
+++ b/stepmania/src/ScreenEditMenu.cpp
@@ -95,7 +95,7 @@ ScreenEditMenu::ScreenEditMenu()
 
 	m_Menu.Load( 
 		THEME->GetPathTo(GRAPHIC_EDIT_BACKGROUND), 
-		THEME->GetPathTo(GRAPHIC_SELECT_MUSIC_TOP_EDGE),
+		THEME->GetPathTo(GRAPHIC_EDIT_TOP_EDGE),
 		ssprintf("%s %s change music    NEXT to continue", CString(char(1)), CString(char(2)) )
 		);
 	this->AddActor( &m_Menu );
@@ -112,7 +112,7 @@ ScreenEditMenu::ScreenEditMenu()
 	MUSIC->Play( true );
 
 
-	m_Menu.TweenAllOnScreen();
+	m_Menu.TweenOnScreenFromBlack( SM_None );
 }
 
 
@@ -306,7 +306,7 @@ void ScreenEditMenu::MenuRight( const PlayerNumber p )
 
 void ScreenEditMenu::MenuStart( const PlayerNumber p )
 {
-	m_Menu.TweenAllOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_None, false );
 
 	MUSIC->Stop();
 
@@ -321,7 +321,7 @@ void ScreenEditMenu::MenuStart( const PlayerNumber p )
 
 void ScreenEditMenu::MenuBack( const PlayerNumber p )
 {	
-	m_Menu.TweenAllOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_None, true );
 
 
 	MUSIC->Stop();
diff --git a/stepmania/src/ScreenGameOver.cpp b/stepmania/src/ScreenGameOver.cpp
index 3fd46417b1..0cc86c0f6a 100644
--- a/stepmania/src/ScreenGameOver.cpp
+++ b/stepmania/src/ScreenGameOver.cpp
@@ -18,38 +18,48 @@
 #include "AnnouncerManager.h"
 #include "ScreenManager.h"
 #include "ScreenTitleMenu.h"
+#include "AnnouncerManager.h"
 
 const ScreenMessage SM_StartFadingOut	=	ScreenMessage(SM_User + 1);
 const ScreenMessage SM_GoToNextState	=	ScreenMessage(SM_User + 2);
+const ScreenMessage SM_PlayAnnouncer	=	ScreenMessage(SM_User + 3);
 
 
 ScreenGameOver::ScreenGameOver()
 {
-	m_psprGameOver = new Sprite;
-	m_psprGameOver->Load( THEME->GetPathTo(GRAPHIC_GAME_OVER) );
-	m_psprGameOver->SetXY( CENTER_X, CENTER_Y );
-	this->AddActor( m_psprGameOver );
+	m_sprGameOver.Load( THEME->GetPathTo(GRAPHIC_GAME_OVER) );
+	m_sprGameOver.SetXY( CENTER_X, CENTER_Y );
+	this->AddActor( &m_sprGameOver );
 
-	m_pWipe = new TransitionFadeWipe;
-	m_pWipe->OpenWipingRight();
+	// tween game over
+	m_sprGameOver.SetAddColor( D3DXCOLOR(1,1,1,0) );
+	m_sprGameOver.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
 
+	m_sprGameOver.BeginTweeningQueued( 0.5f );		// fade to white
+	m_sprGameOver.SetTweenAddColor( D3DXCOLOR(1,1,1,1) );
+
+	m_sprGameOver.BeginTweeningQueued( 0.01f );		// turn color on
+	m_sprGameOver.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
+
+	m_sprGameOver.BeginTweeningQueued( 0.5f );		// fade to color
+	m_sprGameOver.SetTweenAddColor( D3DXCOLOR(1,1,1,0) );
+
+
+	this->SendScreenMessage( SM_PlayAnnouncer, 0.5 );
 	this->SendScreenMessage( SM_StartFadingOut, 5 );
 }
 
 
-ScreenGameOver::~ScreenGameOver()
-{
-	delete m_psprGameOver;
-	delete m_pWipe;
-}	
-
 void ScreenGameOver::HandleScreenMessage( const ScreenMessage SM )
 {
 	switch( SM )
 	{
+	case SM_PlayAnnouncer:
+		SOUND->PlayOnceStreamedFromDir( ANNOUNCER->GetPathTo(ANNOUNCER_GAME_OVER) );
+		break;
 	case SM_StartFadingOut:
-		m_psprGameOver->BeginTweening( 0.8f );
-		m_psprGameOver->SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
+		m_sprGameOver.BeginTweening( 0.8f );
+		m_sprGameOver.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
 		this->SendScreenMessage( SM_GoToNextState, 0.8f );
 		break;
 	case SM_GoToNextState:
@@ -58,3 +68,8 @@ void ScreenGameOver::HandleScreenMessage( const ScreenMessage SM )
 	}
 }
 
+void ScreenGameOver::MenuStart( PlayerNumber p )
+{
+	this->ClearMessageQueue();
+	this->SendScreenMessage( SM_StartFadingOut, 0 );
+}
diff --git a/stepmania/src/ScreenGameOver.h b/stepmania/src/ScreenGameOver.h
index 944cf71763..31a0ffca52 100644
--- a/stepmania/src/ScreenGameOver.h
+++ b/stepmania/src/ScreenGameOver.h
@@ -10,9 +10,7 @@
 */
 
 #include "Screen.h"
-
-class Sprite;
-class TransitionFadeWipe;
+#include "Sprite.h"
 
 
 class ScreenGameOver : public Screen
@@ -20,15 +18,12 @@ class ScreenGameOver : public Screen
 public:
 	ScreenGameOver();
 
-	~ScreenGameOver();
-
 	virtual void HandleScreenMessage( const ScreenMessage SM );
 
-private:
-	
-	Sprite*			m_psprGameOver;
+	virtual void MenuStart( const PlayerNumber p );
 
-	TransitionFadeWipe*		m_pWipe;
+private:
+	Sprite			m_sprGameOver;
 };
 
 
diff --git a/stepmania/src/ScreenGameplay.cpp b/stepmania/src/ScreenGameplay.cpp
index 21952ce051..def86bcf30 100644
--- a/stepmania/src/ScreenGameplay.cpp
+++ b/stepmania/src/ScreenGameplay.cpp
@@ -34,7 +34,10 @@ const float LIFE_Y				= SCREEN_TOP+28;
 const float SCORE_X[NUM_PLAYERS] = { CENTER_X-214, CENTER_X+214 };
 const float SCORE_Y				 = SCREEN_BOTTOM-38;
 
-const float DIFFICULTY_X[NUM_PLAYERS]	= { SCREEN_LEFT+50, SCREEN_RIGHT-50 };
+const float PLAYER_OPTIONS_X[NUM_PLAYERS]	= { CENTER_X-214, CENTER_X+214 };
+const float PLAYER_OPTIONS_Y[NUM_PLAYERS]	= { SCREEN_BOTTOM-60, SCREEN_BOTTOM-40 };
+
+const float DIFFICULTY_X[NUM_PLAYERS]	= { SCREEN_LEFT+70, SCREEN_RIGHT-70 };
 const float DIFFICULTY_Y				= SCREEN_BOTTOM-80;
 
 const float MAX_SECONDS_CAN_BE_OFF_BY	=	0.20f;
@@ -106,6 +109,7 @@ ScreenGameplay::ScreenGameplay()
 			&m_LifeMeter[p],
 			&m_ScoreDisplay[p]
 		);
+		
 
 		this->AddActor( &m_Player[p] );
 	}
@@ -113,13 +117,19 @@ ScreenGameplay::ScreenGameplay()
 
 	for( p=0; p<NUM_PLAYERS; p++ )
 	{
+		m_quadLifeMeterBG[p].SetXY( LIFE_X[p], LIFE_Y );
+		m_quadLifeMeterBG[p].SetDiffuseColor( D3DXCOLOR(0,0,0,1) );
+		m_quadLifeMeterBG[p].SetZoomX( 256 );
+		m_quadLifeMeterBG[p].SetZoomY( (p==PLAYER_1) ? 20.0f : -20.0f );
+		this->AddActor( &m_quadLifeMeterBG[p] );
+
 		if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
 			continue;
 
 		m_LifeMeter[p].SetPlayerOptions( PREFSMAN->m_PlayerOptions[p] );
 		m_LifeMeter[p].SetXY( LIFE_X[p], LIFE_Y );
 		m_LifeMeter[p].SetZoomX( 256 );
-		m_LifeMeter[p].SetZoomY( 20 );
+		m_LifeMeter[p].SetZoomY( (p==PLAYER_1) ? 20.0f : -20.0f );
 		this->AddActor( &m_LifeMeter[p] );
 	}
 
@@ -131,12 +141,12 @@ ScreenGameplay::ScreenGameplay()
 	m_sprBottomFrame.SetXY( CENTER_X, SCREEN_BOTTOM - m_sprBottomFrame.GetZoomedHeight()/2 );
 	this->AddActor( &m_sprBottomFrame );
 
-	m_textSmallStage.Load( THEME->GetPathTo(FONT_HEADER1) );
-	m_textSmallStage.TurnShadowOff();
-	m_textSmallStage.SetXY( CENTER_X, 60 );
-	m_textSmallStage.SetDiffuseColor( D3DXCOLOR(0.3f,1,1,1) );
-	m_textSmallStage.SetText( PREFSMAN->GetStageText() );
-	this->AddActor( &m_textSmallStage );
+	m_textStageNumber.Load( THEME->GetPathTo(FONT_HEADER1) );
+	m_textStageNumber.TurnShadowOff();
+	m_textStageNumber.SetXY( CENTER_X, 60 );
+	m_textStageNumber.SetDiffuseColor( D3DXCOLOR(0.3f,1,1,1) );
+	m_textStageNumber.SetText( PREFSMAN->GetStageText() );
+	this->AddActor( &m_textStageNumber );
 
 
 	for( p=0; p<NUM_PLAYERS; p++ )
@@ -147,6 +157,14 @@ ScreenGameplay::ScreenGameplay()
 		m_ScoreDisplay[p].SetXY( SCORE_X[p], SCORE_Y );
 		m_ScoreDisplay[p].SetZoom( 0.8f );
 		this->AddActor( &m_ScoreDisplay[p] );
+
+		m_textPlayerOptions[p].Load( THEME->GetPathTo(FONT_NORMAL) );
+		m_textPlayerOptions[p].TurnShadowOff();
+		m_textPlayerOptions[p].SetXY( PLAYER_OPTIONS_X[p], PLAYER_OPTIONS_Y[p] );
+		m_textPlayerOptions[p].SetZoom( 0.5f );
+		m_textPlayerOptions[p].SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
+		m_textPlayerOptions[p].SetText( PREFSMAN->m_PlayerOptions[p].GetString() );
+		this->AddActor( &m_textPlayerOptions[p] );
 	}
 
 	
@@ -377,7 +395,8 @@ void ScreenGameplay::Input( const DeviceInput& DeviceI, const InputEventType typ
 	{
 		if( StyleI.IsValid() )
 		{
-			m_Player[StyleI.player].HandlePlayerStep( fSongBeat, StyleI.col, fMaxBeatsCanBeOffBy ); 
+			if( GAMEMAN->IsPlayerEnabled( StyleI.player ) )
+				m_Player[StyleI.player].HandlePlayerStep( fSongBeat, StyleI.col, fMaxBeatsCanBeOffBy ); 
 		}
 	}
 }
@@ -455,9 +474,9 @@ void ScreenGameplay::HandleScreenMessage( const ScreenMessage SM )
 		break;
 	case SM_GoToResults:
 		// send score summaries to the PREFSMAN object so ScreenResults can grab it.
-		PREFSMAN->m_ScoreSummary[PLAYER_1] = m_Player[PLAYER_1].GetScoreSummary();
-		PREFSMAN->m_ScoreSummary[PLAYER_2] = m_Player[PLAYER_2].GetScoreSummary();
-		SCREENMAN->SetNewScreen( new ScreenResults );
+		PREFSMAN->m_ScoreSummary[PLAYER_1][PREFSMAN->m_iNumArcadeStages-1] = m_Player[PLAYER_1].GetScoreSummary();
+		PREFSMAN->m_ScoreSummary[PLAYER_2][PREFSMAN->m_iNumArcadeStages-1] = m_Player[PLAYER_2].GetScoreSummary();
+		SCREENMAN->SetNewScreen( new ScreenResults(false) );
 		break;
 
 
diff --git a/stepmania/src/ScreenGameplay.h b/stepmania/src/ScreenGameplay.h
index 77f602f143..de210002eb 100644
--- a/stepmania/src/ScreenGameplay.h
+++ b/stepmania/src/ScreenGameplay.h
@@ -55,15 +55,17 @@ private:
 
 	Background		m_Background;
 
+	Quad			m_quadLifeMeterBG[NUM_PLAYERS];
 	LifeMeterBar	m_LifeMeter[NUM_PLAYERS];
 
 	Sprite			m_sprTopFrame;
 	Sprite			m_sprBottomFrame;
+	BitmapText		m_textPlayerOptions[NUM_PLAYERS];
 
 	ScoreDisplayRolling		m_ScoreDisplay[NUM_PLAYERS];
 
 
-	BitmapText			m_textSmallStage;
+	BitmapText			m_textStageNumber;
 
 	TransitionStarWipe	m_StarWipe;
 
diff --git a/stepmania/src/ScreenMusicScroll.cpp b/stepmania/src/ScreenMusicScroll.cpp
index 2b151697c4..dca544b138 100644
--- a/stepmania/src/ScreenMusicScroll.cpp
+++ b/stepmania/src/ScreenMusicScroll.cpp
@@ -38,13 +38,6 @@ const CString CREDIT_LINES[] =
 	"",
 	"",
 	"",
-	"CREDITS",
-	"",
-	"",
-	"",
-	"",
-	"",
-	"",
 	"",
 	"",
 	"GRAPHICS:",
@@ -52,12 +45,16 @@ const CString CREDIT_LINES[] =
 	"Brian 'Bork' Bugh",
 	"DJ McFox (Ryan McKanna)",
 	"",
+	"",
+	"",
 	"WEB DESIGN:",
 	"Brian 'Bork' Bugh",
 	"",
+	"",
+	"",
 	"PROGRAMMING:",
 	"Parasyte (Chris Gomez)",
-	"Frieza (Andrew Livy)",
+	"Lord Frieza (Andrew Livy)",
 	"Ben Nordstrom",
 	"Chris Danford",
 	"angedelamort (Sauleil Lamarre)",
@@ -75,6 +72,8 @@ const CString CREDIT_LINES[] =
 	"WarriorBob (David H)",
 	"Mike Waltson",
 	"",
+	"",
+	"",
 	"SPECIAL THANKS TO:",
 	"SimWolf",
 	"Dance With Intensity",
@@ -102,8 +101,11 @@ const CString CREDIT_LINES[] =
 	"",
 	"",
 	"",
-	"If your name is missing from this list,"
-	"                   I apologize!  -Chris"
+	"If your name is missing from this list,",
+	"",
+	"                I apologize!",
+	"",
+	"                      -Chris"
 };
 const int NUM_CREDIT_LINES = sizeof(CREDIT_LINES) / sizeof(CString);
 
diff --git a/stepmania/src/ScreenOptions.cpp b/stepmania/src/ScreenOptions.cpp
index 845baf2fa5..0660824679 100644
--- a/stepmania/src/ScreenOptions.cpp
+++ b/stepmania/src/ScreenOptions.cpp
@@ -51,7 +51,7 @@ ScreenOptions::ScreenOptions( CString sBackgroundPath, CString sTopEdgePath )
 		ssprintf("%s %s to change line   %s %s to select between options      then press NEXT", CString(char(3)), CString(char(4)), CString(char(1)), CString(char(2)) )
 		);
 	this->AddActor( &m_Menu );
-	m_Menu.TweenAllOnScreen();
+	m_Menu.TweenOnScreenFromBlack( SM_None );
 
 	// init row numbers and element colors
 	for( int p=0; p<NUM_PLAYERS; p++ )
@@ -297,7 +297,7 @@ void ScreenOptions::MenuBack( const PlayerNumber p )
 {
 	Screen::MenuBack( p );
 
-	m_Menu.TweenAllOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_None, true );
 
 	m_Wipe.CloseWipingLeft( SM_GoToPrevState );
 }
@@ -307,7 +307,7 @@ void ScreenOptions::MenuStart( const PlayerNumber p )
 {
 	Screen::MenuStart( p );
 
-	m_Menu.TweenAllOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_None, false );
 
 	m_SoundNext.PlayRandom();
 	m_Wipe.CloseWipingRight( SM_GoToNextState );
diff --git a/stepmania/src/ScreenSelectDifficulty.cpp b/stepmania/src/ScreenSelectDifficulty.cpp
index be7df4103d..7b9c6bc839 100644
--- a/stepmania/src/ScreenSelectDifficulty.cpp
+++ b/stepmania/src/ScreenSelectDifficulty.cpp
@@ -100,6 +100,9 @@ ScreenSelectDifficulty::ScreenSelectDifficulty()
 
 	for( int p=0; p<NUM_PLAYERS; p++ )
 	{
+		m_iSelection[p] = 0;
+		m_bChosen[p] = false;
+
 		if( !GAMEMAN->IsPlayerEnabled((PlayerNumber)p) )
 			continue;
 
@@ -123,15 +126,9 @@ ScreenSelectDifficulty::ScreenSelectDifficulty()
 
 		m_sprOK[p].Load( THEME->GetPathTo(GRAPHIC_SELECT_DIFFICULTY_OK) );
 		this->AddActor( &m_sprOK[p] );
-
-		m_iSelection[p] = 0;
-		m_bChosen[p] = false;
 	}
 	
 
-	m_Fade.SetZ( -2 );
-	this->AddActor( &m_Fade );
-
 	m_soundChange.Load( THEME->GetPathTo(SOUND_SELECT_DIFFICULTY_CHANGE) );
 	m_soundSelect.Load( THEME->GetPathTo(SOUND_MENU_START) );
 	
@@ -145,7 +142,7 @@ ScreenSelectDifficulty::ScreenSelectDifficulty()
         MUSIC->Play( true );
 	}
 
-	m_Fade.OpenWipingRight();
+	m_Menu.TweenOnScreenFromMenu( SM_None );
 	TweenOnScreen();
 }
 
@@ -161,7 +158,7 @@ void ScreenSelectDifficulty::Input( const DeviceInput& DeviceI, const InputEvent
 {
 	LOG->WriteLine( "ScreenSelectDifficulty::Input()" );
 
-	if( m_Fade.IsClosing() )
+	if( m_Menu.IsClosing() )
 		return;
 
 	Screen::Input( DeviceI, type, GameI, MenuI, StyleI );	// default input handler
@@ -195,7 +192,7 @@ void ScreenSelectDifficulty::HandleScreenMessage( const ScreenMessage SM )
 		this->SendScreenMessage( SM_StartFadingOut, 0.8f );
 		break;
 	case SM_StartFadingOut:
-		m_Fade.CloseWipingRight( SM_GoToNextState );
+		m_Menu.TweenOffScreenToMenu( SM_GoToNextState );
 		break;
 	}
 }
@@ -279,7 +276,7 @@ void ScreenSelectDifficulty::MenuStart( PlayerNumber pn )
 	// check to see if everyone has chosen
 	for( int p=0; p<NUM_PLAYERS; p++ )
 	{
-		if( m_bChosen[p] == false )
+		if( GAMEMAN->IsPlayerEnabled((PlayerNumber)p)  &&  m_bChosen[p] == false )
 			return;
 	}
 	this->SendScreenMessage( SM_StartTweeningOffScreen, 0.7f );
@@ -287,15 +284,11 @@ void ScreenSelectDifficulty::MenuStart( PlayerNumber pn )
 
 void ScreenSelectDifficulty::MenuBack( const PlayerNumber p )
 {
-	m_Fade.CloseWipingLeft( SM_GoToPrevState );
-
-	TweenOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_GoToPrevState, true );
 }
 
 void ScreenSelectDifficulty::TweenOffScreen()
 {
-	m_Menu.TweenTopEdgeOffScreen();
-
 	m_sprExplanation.SetXY( EXPLANATION_X, EXPLANATION_Y );
 	m_sprExplanation.BeginTweening( 0.5, Actor::TWEEN_BOUNCE_BEGIN );
 	m_sprExplanation.SetTweenXY( EXPLANATION_X-400, EXPLANATION_Y );
@@ -341,7 +334,7 @@ void ScreenSelectDifficulty::TweenOffScreen()
 
 void ScreenSelectDifficulty::TweenOnScreen() 
 {
-	m_Menu.TweenTopEdgeOnScreen();
+	m_Menu.TweenOnScreenFromMenu( SM_None );
 
 	m_sprExplanation.SetXY( EXPLANATION_X-400, EXPLANATION_Y );
 	m_sprExplanation.BeginTweening( 0.3f, Actor::TWEEN_BOUNCE_END );
diff --git a/stepmania/src/ScreenSelectDifficulty.h b/stepmania/src/ScreenSelectDifficulty.h
index fb7e3781ac..829402122a 100644
--- a/stepmania/src/ScreenSelectDifficulty.h
+++ b/stepmania/src/ScreenSelectDifficulty.h
@@ -10,7 +10,6 @@
 
 #include "Screen.h"
 #include "Sprite.h"
-#include "TransitionKeepAlive.h"
 #include "RandomSample.h"
 #include "Screen.h"
 #include "Quad.h"
@@ -52,8 +51,6 @@ private:
 
 	int m_iSelection[NUM_PLAYERS];
 	bool m_bChosen[NUM_PLAYERS];
-
-	TransitionKeepAlive m_Fade;
 };
 
 
diff --git a/stepmania/src/ScreenSelectGroup.cpp b/stepmania/src/ScreenSelectGroup.cpp
index 4f3c58f5fe..06ff011abe 100644
--- a/stepmania/src/ScreenSelectGroup.cpp
+++ b/stepmania/src/ScreenSelectGroup.cpp
@@ -112,9 +112,6 @@ ScreenSelectGroup::ScreenSelectGroup()
 	}
 
 
-	m_Fade.SetZ( -2 );
-	this->AddActor( &m_Fade );
-
 	m_soundChange.Load( THEME->GetPathTo(SOUND_SELECT_GROUP_CHANGE) );
 	m_soundSelect.Load( THEME->GetPathTo(SOUND_MENU_START) );
 
@@ -127,7 +124,7 @@ ScreenSelectGroup::ScreenSelectGroup()
         MUSIC->Play( true );
 	}
 
-	m_Fade.OpenWipingRight();
+	m_Menu.TweenOnScreenFromMenu( SM_None );
 	TweenOnScreen();
 	AfterChange();
 }
@@ -144,7 +141,7 @@ void ScreenSelectGroup::Input( const DeviceInput& DeviceI, const InputEventType
 {
 	LOG->WriteLine( "ScreenSelectGroup::Input()" );
 
-	if( m_Fade.IsClosing()  ||  m_bChosen )
+	if( m_Menu.IsClosing()  ||  m_bChosen )
 		return;
 
 	Screen::Input( DeviceI, type, GameI, MenuI, StyleI );	// default input handler
@@ -171,7 +168,7 @@ void ScreenSelectGroup::HandleScreenMessage( const ScreenMessage SM )
 		SCREENMAN->SetNewScreen( new ScreenSelectMusic );
 		break;
 	case SM_StartFadingOut:
-		m_Fade.CloseWipingRight( SM_GoToNextState );
+		m_Menu.TweenOffScreenToMenu( SM_GoToNextState );
 		break;
 	}
 }
@@ -293,20 +290,17 @@ void ScreenSelectGroup::MenuStart( const PlayerNumber p )
 
 
 	TweenOffScreen();
+
 	this->SendScreenMessage( SM_StartFadingOut, 0.8f );
 }
 
 void ScreenSelectGroup::MenuBack( const PlayerNumber p )
 {
-	m_Fade.CloseWipingLeft( SM_GoToPrevState );
-
-	TweenOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_GoToPrevState, true );
 }
 
 void ScreenSelectGroup::TweenOffScreen()
 {
-	m_Menu.TweenTopEdgeOffScreen();
-
 	m_sprExplanation.BeginTweeningQueued( 0.8f );
 	m_sprExplanation.BeginTweeningQueued( 0.5f, TWEEN_BOUNCE_BEGIN );
 	m_sprExplanation.SetTweenX( EXPLANATION_X-400 );
@@ -349,7 +343,7 @@ void ScreenSelectGroup::TweenOffScreen()
 
 void ScreenSelectGroup::TweenOnScreen() 
 {
-	m_Menu.TweenTopEdgeOnScreen();
+	m_Menu.TweenOnScreenFromMenu( SM_None );
 
 	m_sprExplanation.SetX( EXPLANATION_X-400 );
 	m_sprExplanation.BeginTweening( 0.5f, TWEEN_BOUNCE_END );
diff --git a/stepmania/src/ScreenSelectGroup.h b/stepmania/src/ScreenSelectGroup.h
index ca4f303167..b1ed1e5782 100644
--- a/stepmania/src/ScreenSelectGroup.h
+++ b/stepmania/src/ScreenSelectGroup.h
@@ -11,7 +11,6 @@
 
 #include "Screen.h"
 #include "Sprite.h"
-#include "TransitionKeepAlive.h"
 #include "RandomSample.h"
 #include "Screen.h"
 #include "Quad.h"
@@ -63,8 +62,6 @@ private:
 	CStringArray m_arrayGroupNames;
 	int m_iSelection;
 	bool m_bChosen;
-
-	TransitionKeepAlive m_Fade;
 };
 
 
diff --git a/stepmania/src/ScreenSelectMusic.cpp b/stepmania/src/ScreenSelectMusic.cpp
index cc70c802c7..02bab8d5bb 100644
--- a/stepmania/src/ScreenSelectMusic.cpp
+++ b/stepmania/src/ScreenSelectMusic.cpp
@@ -63,6 +63,10 @@ ScreenSelectMusic::ScreenSelectMusic()
 {
 	LOG->WriteLine( "ScreenSelectMusic::ScreenSelectMusic()" );
 
+	// for debugging
+	if( GAMEMAN->m_CurStyle == STYLE_NONE )
+		GAMEMAN->m_CurStyle = STYLE_DANCE_SINGLE;
+
 	int p;
 
 	m_Menu.Load(
@@ -104,18 +108,13 @@ ScreenSelectMusic::ScreenSelectMusic()
 	m_MusicWheel.SetXY( WHEEL_X, WHEEL_Y );
 	this->AddActor( &m_MusicWheel );
 
-	m_Wipe.SetZ( -2 );
-	this->AddActor( &m_Wipe );
-
-	m_Fade.SetZ( -2 );
-	this->AddActor( &m_Fade );
-
 	m_textHoldForOptions.Load( THEME->GetPathTo(FONT_STAGE) );
 	m_textHoldForOptions.SetXY( CENTER_X, CENTER_Y );
 	m_textHoldForOptions.SetText( "hold NEXT for options" );
 	m_textHoldForOptions.SetZoom( 1 );
 	m_textHoldForOptions.SetZoomY( 0 );
 	m_textHoldForOptions.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
+	m_textHoldForOptions.SetZ( -4 );
 	this->AddActor( &m_textHoldForOptions );
 
 
@@ -127,7 +126,7 @@ ScreenSelectMusic::ScreenSelectMusic()
 
 	AfterMusicChange();
 	TweenOnScreen();
-	m_Wipe.OpenWipingRight();
+	m_Menu.TweenOnScreenFromMenu( SM_None );
 }
 
 
@@ -146,8 +145,6 @@ void ScreenSelectMusic::DrawPrimitives()
 
 void ScreenSelectMusic::TweenOnScreen()
 {
-	m_Menu.TweenTopEdgeOnScreen();
-
 	float fOriginalZoomY;
 
 	m_SongInfoFrame.SetXY( SONG_INFO_FRAME_X - 400, SONG_INFO_FRAME_Y );
@@ -181,8 +178,6 @@ void ScreenSelectMusic::TweenOnScreen()
 
 void ScreenSelectMusic::TweenOffScreen()
 {
-	m_Menu.TweenAllOffScreen();
-
 	m_SongInfoFrame.BeginTweening( TWEEN_TIME, Actor::TWEEN_BOUNCE_END );
 	m_SongInfoFrame.SetTweenXY( SONG_INFO_FRAME_X - 400, SONG_INFO_FRAME_Y );
 
@@ -219,7 +214,7 @@ void ScreenSelectMusic::Input( const DeviceInput& DeviceI, const InputEventType
 {
 	LOG->WriteLine( "ScreenSelectMusic::Input()" );
 
-	if( m_Wipe.IsClosing()  ||  m_Fade.IsClosing() )
+	if( m_Menu.IsClosing() )
 		return;		// ignore
 
 	if( MenuI.player == PLAYER_NONE )
@@ -323,7 +318,7 @@ void ScreenSelectMusic::HandleScreenMessage( const ScreenMessage SM )
 	}
 }
 
-void ScreenSelectMusic::MenuLeft( const PlayerNumber p )
+void ScreenSelectMusic::MenuLeft( const PlayerNumber p, const InputEventType type )
 {
 	m_MusicWheel.PrevMusic();
 	
@@ -331,7 +326,7 @@ void ScreenSelectMusic::MenuLeft( const PlayerNumber p )
 }
 
 
-void ScreenSelectMusic::MenuRight( const PlayerNumber p )
+void ScreenSelectMusic::MenuRight( const PlayerNumber p, const InputEventType type )
 {
 	m_MusicWheel.NextMusic();
 
@@ -354,6 +349,8 @@ void ScreenSelectMusic::MenuStart( const PlayerNumber p )
 			}
 
 			TweenOffScreen();
+			m_Menu.TweenOffScreenToBlack( SM_None, false );
+
 			m_soundSelect.PlayRandom();
 
 			bool bIsNew = m_MusicWheel.GetSelectedSong()->IsNew();
@@ -362,7 +359,7 @@ void ScreenSelectMusic::MenuStart( const PlayerNumber p )
 			{
 				if( !GAMEMAN->IsPlayerEnabled( (PlayerNumber)p ) )
 					continue;	// skip
-				if( SONGMAN->m_pCurNotes[p]->m_iMeter >= 9 )
+				if( SONGMAN->m_pCurNotes[p]  &&  SONGMAN->m_pCurNotes[p]->m_iMeter >= 9 )
 					bIsHard = true;
 			}
 
@@ -376,16 +373,17 @@ void ScreenSelectMusic::MenuStart( const PlayerNumber p )
 			;
 
 			// show "hold NEXT for options"
+			m_textHoldForOptions.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
 			m_textHoldForOptions.BeginTweeningQueued( 0.25f );	// fade in
-			m_textHoldForOptions.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
 			m_textHoldForOptions.SetTweenZoomY( 1 );
-			m_textHoldForOptions.BeginTweeningQueued( 1.0f );	// sleep
+			m_textHoldForOptions.BeginTweeningQueued( 2.0f );	// sleep
 			m_textHoldForOptions.BeginTweeningQueued( 0.25f );	// fade out
 			m_textHoldForOptions.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
 			m_textHoldForOptions.SetTweenZoomY( 0 );
 
-			m_Fade.SetTransitionTime( 1.5f );	// give enough time for m_textHoldForOptions to complete its tweens
-			m_Fade.CloseWipingRight( SM_GoToNextState );
+			m_Menu.TweenOffScreenToBlack( SM_None, false );
+
+			this->SendScreenMessage( SM_GoToNextState, 2.5f );
 		}
 		break;
 	case TYPE_SECTION:
@@ -400,13 +398,9 @@ void ScreenSelectMusic::MenuStart( const PlayerNumber p )
 
 void ScreenSelectMusic::MenuBack( const PlayerNumber p )
 {
-	Screen::MenuBack( p );
-
 	MUSIC->Stop();
 
-	m_Wipe.CloseWipingLeft( SM_GoToPrevState );
-
-	TweenOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_GoToPrevState, true );
 }
 
 void ScreenSelectMusic::AfterNotesChange( const PlayerNumber p )
diff --git a/stepmania/src/ScreenSelectMusic.h b/stepmania/src/ScreenSelectMusic.h
index f17094ef2b..e11859e257 100644
--- a/stepmania/src/ScreenSelectMusic.h
+++ b/stepmania/src/ScreenSelectMusic.h
@@ -15,7 +15,6 @@
 #include "GameConstantsAndTypes.h"
 #include "MusicWheel.h"
 #include "Banner.h"
-#include "TransitionKeepAlive.h"
 #include "SongInfoFrame.h"
 #include "MenuElements.h"
 #include "GrooveRadar.h"
@@ -37,14 +36,15 @@ public:
 	void TweenOnScreen();
 	void TweenOffScreen();
 
-	void MenuLeft( const PlayerNumber p );
-	void MenuRight( const PlayerNumber p );
-	void EasierDifficulty( const PlayerNumber p );
-	void HarderDifficulty( const PlayerNumber p );
+	void MenuLeft( const PlayerNumber p, const InputEventType type );
+	void MenuRight( const PlayerNumber p, const InputEventType type );
 	void MenuStart( const PlayerNumber p );
 	void MenuBack( const PlayerNumber p );
 
 protected:
+	void EasierDifficulty( const PlayerNumber p );
+	void HarderDifficulty( const PlayerNumber p );
+
 	void AfterNotesChange( const PlayerNumber p );
 	void AfterMusicChange();
 	void PlayMusicSample();
@@ -66,9 +66,6 @@ protected:
 
 	RandomSample m_soundSelect;
 	RandomSample m_soundChangeNotes;
-
-	TransitionKeepAlive m_Wipe;
-	TransitionFade		m_Fade;
 };
 
 
diff --git a/stepmania/src/ScreenSelectStyle.cpp b/stepmania/src/ScreenSelectStyle.cpp
index 7ad40ec467..4a391a3075 100644
--- a/stepmania/src/ScreenSelectStyle.cpp
+++ b/stepmania/src/ScreenSelectStyle.cpp
@@ -30,10 +30,10 @@ const float ICONS_SPACING_X	= 76;
 const float ICON_Y			= SCREEN_TOP + 100;
 
 const float EXPLANATION_X	= SCREEN_RIGHT - 160;
-const float EXPLANATION_Y	= CENTER_Y;
+const float EXPLANATION_Y	= CENTER_Y-70;
 
 const float INFO_X			= SCREEN_RIGHT - 160;
-const float INFO_Y			= CENTER_Y+200;
+const float INFO_Y			= CENTER_Y+40;
 
 const float PREVIEW_X		= SCREEN_LEFT + 160;
 const float PREVIEW_Y		= CENTER_Y;
@@ -83,9 +83,6 @@ ScreenSelectStyle::ScreenSelectStyle()
 		);
 	this->AddActor( &m_Menu );
 
-	m_Fade.SetZ( -2 );
-	this->AddActor( &m_Fade );
-
 	m_soundChange.Load( THEME->GetPathTo(SOUND_SELECT_STYLE_CHANGE) );
 	m_soundSelect.Load( THEME->GetPathTo(SOUND_MENU_START) );
 
@@ -99,10 +96,9 @@ ScreenSelectStyle::ScreenSelectStyle()
         MUSIC->Play( true );
 	}
 
-	m_soundChange.PlayRandom();
 	AfterChange();
 	TweenOnScreen();
-	m_Menu.TweenAllOnScreen();
+	m_Menu.TweenOnScreenFromBlack( SM_None );
 }
 
 
@@ -122,7 +118,7 @@ void ScreenSelectStyle::Input( const DeviceInput& DeviceI, const InputEventType
 {
 	LOG->WriteLine( "ScreenSelectStyle::Input()" );
 
-	if( m_Fade.IsClosing() )
+	if( m_Menu.IsClosing() )
 		return;
 
 	Screen::Input( DeviceI, type, GameI, MenuI, StyleI );	// default input handler
@@ -135,7 +131,7 @@ void ScreenSelectStyle::HandleScreenMessage( const ScreenMessage SM )
 	switch( SM )
 	{
 	case SM_MenuTimer:
-		MenuStart(PLAYER_1);
+		MenuStart(PLAYER_NONE);
 		break;
 	case SM_GoToPrevState:
 		MUSIC->Stop();
@@ -158,16 +154,34 @@ void ScreenSelectStyle::AfterChange()
 
 	ThemeElement te;
 
+	// Tween Preview
 	te = (ThemeElement)(GRAPHIC_SELECT_STYLE_PREVIEW_0+GetSelectedStyle());
 	m_sprPreview.Load( THEME->GetPathTo(te) );
-	m_sprPreview.SetZoomX( 0 );
-	m_sprPreview.BeginTweening( 0.3f, Actor::TWEEN_BOUNCE_END );
-	m_sprPreview.SetTweenZoomX( 1 );
 
+	m_sprPreview.StopTweening();
+	m_sprPreview.SetAddColor( D3DXCOLOR(1,1,1,0) );
+	m_sprPreview.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
+
+	m_sprPreview.BeginTweeningQueued( 0.25f );			// sleep
+
+	m_sprPreview.BeginTweeningQueued( 0.2f );			// fade to white
+	m_sprPreview.SetTweenAddColor( D3DXCOLOR(1,1,1,1) );
+	m_sprPreview.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
+
+	m_sprPreview.BeginTweeningQueued( 0.01f );			// turn color on
+	m_sprPreview.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
+
+	m_sprPreview.BeginTweeningQueued( 0.2f );			// fade to color
+	m_sprPreview.SetTweenAddColor( D3DXCOLOR(1,1,1,0) );
+	m_sprPreview.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
+
+
+	// Tween Info
 	te = (ThemeElement)(GRAPHIC_SELECT_STYLE_INFO_0+GetSelectedStyle());
 	m_sprInfo.Load( THEME->GetPathTo(te) );
+	m_sprInfo.StopTweening();
 	m_sprInfo.SetZoomY( 0 );
-	m_sprInfo.BeginTweening( 0.3f, Actor::TWEEN_BOUNCE_END );
+	m_sprInfo.BeginTweeningQueued( 0.5f, Actor::TWEEN_BOUNCE_END );
 	m_sprInfo.SetTweenZoomY( 1 );
 }
 
@@ -196,7 +210,8 @@ void ScreenSelectStyle::MenuRight( const PlayerNumber p )
 
 void ScreenSelectStyle::MenuStart( const PlayerNumber p )
 {
-	GAMEMAN->m_sMasterPlayerNumber = p;
+	if( p != PLAYER_NONE )
+		GAMEMAN->m_sMasterPlayerNumber = p;
 	GAMEMAN->m_CurStyle = GetSelectedStyle();
 
 	AnnouncerElement ae;
@@ -214,12 +229,10 @@ void ScreenSelectStyle::MenuStart( const PlayerNumber p )
 	}
 	SOUND->PlayOnceStreamedFromDir( ANNOUNCER->GetPathTo(ae) );
 
-	m_Menu.TweenTopEdgeOffScreen();
+	m_Menu.TweenOffScreenToMenu( SM_GoToNextState );
 
 	m_soundSelect.PlayRandom();
 
-	m_Fade.CloseWipingRight( SM_GoToNextState );
-
 	TweenOffScreen();
 }
 
@@ -227,11 +240,11 @@ void ScreenSelectStyle::MenuBack( const PlayerNumber p )
 {
 	MUSIC->Stop();
 
-	m_Menu.TweenAllOffScreen();
+	m_Menu.TweenOffScreenToBlack( SM_GoToPrevState, true );
 
-	m_Fade.CloseWipingLeft( SM_GoToPrevState );
+//	m_Fade.CloseWipingLeft( SM_GoToPrevState );
 
-	TweenOffScreen();
+//	TweenOffScreen();
 }
 
 
@@ -271,6 +284,9 @@ void ScreenSelectStyle::TweenOnScreen()
 	m_sprExplanation.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_sprExplanation.SetTweenZoomY( fOriginalZoom );
 
+
+	// let AfterChange tween Preview and Info
+	/*	
 	fOriginalZoom = m_sprPreview.GetZoomY();
 	m_sprPreview.SetZoomY( 0 );
 	m_sprPreview.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
@@ -280,4 +296,5 @@ void ScreenSelectStyle::TweenOnScreen()
 	m_sprInfo.SetZoomY( 0 );
 	m_sprInfo.BeginTweening( MENU_ELEMENTS_TWEEN_TIME );
 	m_sprInfo.SetTweenZoomY( fOriginalZoom );
+	*/
 }
diff --git a/stepmania/src/ScreenSelectStyle.h b/stepmania/src/ScreenSelectStyle.h
index 5d78f476f7..a1f5a5476d 100644
--- a/stepmania/src/ScreenSelectStyle.h
+++ b/stepmania/src/ScreenSelectStyle.h
@@ -15,7 +15,6 @@
 #include "Quad.h"
 #include "RandomSample.h"
 #include "Quad.h"
-#include "TransitionKeepAlive.h"
 #include "MenuElements.h"
 
 
@@ -54,8 +53,6 @@ private:
 	CArray<Style,Style>	m_aPossibleStyles;
 
 	Style	GetSelectedStyle() { return m_aPossibleStyles[m_iSelection]; };
-
-	TransitionKeepAlive m_Fade;
 };
 
 
diff --git a/stepmania/src/ScreenStage.cpp b/stepmania/src/ScreenStage.cpp
index f1440d61a6..25d1d8f99b 100644
--- a/stepmania/src/ScreenStage.cpp
+++ b/stepmania/src/ScreenStage.cpp
@@ -26,24 +26,19 @@
 #include "AnnouncerManager.h"
 
 const ScreenMessage SM_StartFadingOut	=	ScreenMessage(SM_User + 1);
-const ScreenMessage SM_LoadNoteData		=	ScreenMessage(SM_User + 2);	// this is a super-hack.  We'll load the note data from cache while the message is displaying
 const ScreenMessage SM_GoToNextState	=	ScreenMessage(SM_User + 3);
 
-const float BASE_X		= CENTER_X;
-const float BASE_Y		= CENTER_Y + 36;
-const float BASE_HEIGHT = 6;
 
 ScreenStage::ScreenStage( bool bTryExtraStage )
 {
 	m_bTryExtraStage = false;
 
-	m_ptextStage = new BitmapText();
-	m_ptextStage->Load( THEME->GetPathTo(FONT_STAGE) );
-	m_ptextStage->TurnShadowOff();
+	m_textStage.Load( THEME->GetPathTo(FONT_STAGE) );
+	m_textStage.TurnShadowOff();
 	if( bTryExtraStage )
 	{
-		m_ptextStage->SetText( "Try Extra Stage!" );
-		m_ptextStage->SetDiffuseColor( D3DXCOLOR(1,0.1f,0.1f,1) );
+		m_textStage.SetText( "Try Extra Stage!" );
+		m_textStage.SetDiffuseColor( D3DXCOLOR(1,0.1f,0.1f,1) );
 		SOUND->PlayOnceStreamedFromDir( ANNOUNCER->GetPathTo(ANNOUNCER_STAGE_EXTRA) );
 	}
 	else // !bTryExtraStage
@@ -52,8 +47,8 @@ ScreenStage::ScreenStage( bool bTryExtraStage )
 		bool bFinal = PREFSMAN->IsFinalStage();
 
 		CString sStagePrefix = PREFSMAN->GetStageText();
-		m_ptextStage->SetText( sStagePrefix + " Stage" );
-		m_ptextStage->SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
+		m_textStage.SetText( sStagePrefix + " Stage" );
+		m_textStage.SetDiffuseColor( D3DXCOLOR(1,1,1,1) );
 
 		if( bFinal )
 			SOUND->PlayOnceStreamedFromDir( ANNOUNCER->GetPathTo(ANNOUNCER_STAGE_FINAL) );
@@ -69,61 +64,31 @@ ScreenStage::ScreenStage( bool bTryExtraStage )
 			}
 		}
 	}
-	m_ptextStage->SetXY( BASE_X, BASE_Y );
-	m_ptextStage->SetVertAlign( Actor::align_top );
-	m_ptextStage->SetZoomX( 2 );
-	m_ptextStage->SetZoomY( 0 );
-	m_ptextStage->BeginTweeningQueued( 0.6f );	// sleep
-	m_ptextStage->BeginTweeningQueued( 0.3f );	// sleep
-	m_ptextStage->SetTweenZoom( 2 );
-	m_ptextStage->SetTweenXY( CENTER_X, CENTER_Y );
-	this->AddActor( m_ptextStage );
+	m_textStage.SetXY( CENTER_X, CENTER_Y );
+	m_textStage.SetZoomX( 2 );
+	m_textStage.SetZoomY( 0 );
+	m_textStage.SetDiffuseColor( D3DXCOLOR(0,0,0,1) );
+	m_textStage.BeginTweening( 0.5f );
+	m_textStage.SetTweenZoom( 2 );
+	m_textStage.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,1) );
+	this->AddActor( &m_textStage );
 
-
-	m_psprUnderscore = new Sprite;
-	m_psprUnderscore->Load( THEME->GetPathTo(GRAPHIC_STAGE_UNDERSCORE) );
-	m_psprUnderscore->SetXY( BASE_X, BASE_Y );
-	m_psprUnderscore->SetZoomX( 0 );
-	m_psprUnderscore->SetDiffuseColor( bTryExtraStage ? D3DXCOLOR(1,0.1f,0.1f,1) : D3DXCOLOR(1,1,1,1) );
-	m_psprUnderscore->BeginTweeningQueued( 0.4f );	// open
-	float fDestZoom = m_ptextStage->GetWidestLineWidthInSourcePixels() * m_ptextStage->GetZoomX() / m_psprUnderscore->GetUnzoomedWidth();
-	m_psprUnderscore->SetTweenZoomX( fDestZoom );
-	m_psprUnderscore->BeginTweeningQueued( 0.3f );	// sleep
-	m_psprUnderscore->BeginTweeningQueued( 0.4f );	// close
-	m_psprUnderscore->SetTweenZoomX( 0 );
-	this->AddActor( m_psprUnderscore );
-
-
-	m_pWipe = new TransitionFadeWipe;
-	m_pWipe->OpenWipingRight();
-	this->AddActor( m_ptextStage );
-
-	this->SendScreenMessage( SM_LoadNoteData, 1 );
 	this->SendScreenMessage( SM_StartFadingOut, 3 );
 }
 
 
-ScreenStage::~ScreenStage()
-{
-	delete m_ptextStage;
-	delete m_pWipe;
-}	
-
 void ScreenStage::HandleScreenMessage( const ScreenMessage SM )
 {
 	switch( SM )
 	{
 	case SM_StartFadingOut:
-		m_ptextStage->BeginTweening( 0.8f );
-		m_ptextStage->SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
+		m_textStage.BeginTweening( 0.8f );
+		m_textStage.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
 		this->SendScreenMessage( SM_GoToNextState, 0.8f );
 		break;
 	case SM_GoToNextState:
 		SCREENMAN->SetNewScreen( new ScreenGameplay );
 		break;
-	case SM_LoadNoteData:
-		SONGMAN->m_pCurSong->LoadFromCacheFile( true );	// load note data
-		break;
 	}
 }
 
diff --git a/stepmania/src/ScreenStage.h b/stepmania/src/ScreenStage.h
index c035813292..9d5f3bb75c 100644
--- a/stepmania/src/ScreenStage.h
+++ b/stepmania/src/ScreenStage.h
@@ -10,10 +10,7 @@
 */
 
 #include "Screen.h"
-
-class BitmapText;
-class Sprite;
-class TransitionFadeWipe;
+#include "BitmapText.h"
 
 
 class ScreenStage : public Screen
@@ -21,18 +18,13 @@ class ScreenStage : public Screen
 public:
 	ScreenStage();
 	ScreenStage( bool bTryExtraStage );
-	~ScreenStage();
 
 	virtual void HandleScreenMessage( const ScreenMessage SM );
 
 private:
 	bool			m_bTryExtraStage;
 
-	BitmapText*		m_ptextStage;
-	
-	Sprite*			m_psprUnderscore;
-
-	TransitionFadeWipe*		m_pWipe;
+	BitmapText		m_textStage;
 };
 
 
diff --git a/stepmania/src/ScreenTitleMenu.cpp b/stepmania/src/ScreenTitleMenu.cpp
index 12f999f5c5..56b16ff573 100644
--- a/stepmania/src/ScreenTitleMenu.cpp
+++ b/stepmania/src/ScreenTitleMenu.cpp
@@ -1,11 +1,12 @@
 #include "stdafx.h"
 /*
 -----------------------------------------------------------------------------
- File: ScreenTitleMenu.h
+ Class: ScreenTitleMenu
 
- Desc: The main title screen and menu.
+ Desc: See header.
 
  Copyright (c) 2001-2002 by the person(s) listed below.  All rights reserved.
+	Chris Danford
 -----------------------------------------------------------------------------
 */
 
@@ -27,6 +28,7 @@
 #include "SongManager.h"
 #include "AnnouncerManager.h"
 #include "ErrorCatcher/ErrorCatcher.h"
+#include "GameManager.h"
 
 
 //
@@ -34,10 +36,7 @@
 //
 
 const CString CHOICE_TEXT[ScreenTitleMenu::NUM_TITLE_MENU_CHOICES] = {
-	"GAME MODE",
-	"NONSTOP MODE",
-	"ENDLESS MODE",
-	"ONI MODE",
+	"GAME START",
 	"SWITCH GAME",
 	"CONFIG INSTRUMENTS",
 	"GAME OPTIONS",
@@ -46,8 +45,8 @@ const CString CHOICE_TEXT[ScreenTitleMenu::NUM_TITLE_MENU_CHOICES] = {
 	"EXIT",
 };
 
-const float CHOICES_START_Y		= 52;
-const float CHOICES_GAP_Y		= 38;
+const float CHOICES_START_Y		= 66;
+const float CHOICES_GAP_Y		= 50;
 
 const float HELP_X				= CENTER_X;
 const float HELP_Y				= SCREEN_HEIGHT-55;
@@ -136,28 +135,9 @@ ScreenTitleMenu::ScreenTitleMenu()
 		this->SendScreenMessage( SM_PlayAttract, (float)15+i*15 );
 
 
-	m_TitleMenuChoice = CHOICE_GAME_MODE;
+	m_TitleMenuChoice = CHOICE_GAME_START;
 	GainFocus( m_TitleMenuChoice );
 
-/*
-	MUSIC->Stop();
-	
-	// find a random song and play it
-	if( GAMEINFO->m_pSongs.GetSize() > 0 )
-	{
-		for( i=0; i<50; i++ )	// try 50 times to find a song with music
-		{
-			int iRandomSongIndex = rand() % GAMEINFO->m_pSongs.GetSize();
-			Song* pSong = GAMEINFO->m_pSongs[iRandomSongIndex];
-			if( pSong->HasMusic() )
-			{
-				MUSIC->Load( pSong->GetMusicPath() );
-				MUSIC->Play();
-				break;
-			}
-		}
-	}
-*/
 
 	MUSIC->Stop();
 
@@ -265,10 +245,11 @@ void ScreenTitleMenu::MenuDown( const PlayerNumber p )
 
 void ScreenTitleMenu::MenuStart( const PlayerNumber p )
 {	
+	GAMEMAN->m_sMasterPlayerNumber = p;
 
 	switch( m_TitleMenuChoice )
 	{
-	case CHOICE_GAME_MODE:
+	case CHOICE_GAME_START:
 		m_soundSelect.PlayRandom();
 		m_Fade.CloseWipingRight( SM_GoToCaution );
 		return;
@@ -288,11 +269,6 @@ void ScreenTitleMenu::MenuStart( const PlayerNumber p )
 		m_soundSelect.PlayRandom();
 		m_Fade.CloseWipingRight( SM_GoToSynchronize );
 		return;
-	case CHOICE_NONSTOP_MODE:
-	case CHOICE_ENDLESS_MODE:
-	case CHOICE_ONI_MODE:
-		m_soundInvalid.PlayRandom();
-		return;
 	case CHOICE_EDIT:
 		m_soundSelect.PlayRandom();
 		m_Fade.CloseWipingRight( SM_GoToEdit );
diff --git a/stepmania/src/ScreenTitleMenu.h b/stepmania/src/ScreenTitleMenu.h
index 35d4d6dcd7..b88563d69a 100644
--- a/stepmania/src/ScreenTitleMenu.h
+++ b/stepmania/src/ScreenTitleMenu.h
@@ -1,10 +1,11 @@
 /*
 -----------------------------------------------------------------------------
- File: ScreenTitleMenu.h
+ Class: ScreenTitleMenu
 
  Desc: The main title screen and menu.
 
  Copyright (c) 2001-2002 by the person(s) listed below.  All rights reserved.
+	Chris Danford
 -----------------------------------------------------------------------------
 */
 
@@ -28,10 +29,7 @@ public:
 	virtual void HandleScreenMessage( const ScreenMessage SM );
 
 	enum TitleMenuChoice {
-		CHOICE_GAME_MODE = 0,
-		CHOICE_NONSTOP_MODE,
-		CHOICE_ENDLESS_MODE,
-		CHOICE_ONI_MODE,
+		CHOICE_GAME_START = 0,
 		CHOICE_SELECT_GAME,
 		CHOICE_MAP_INSTRUMENTS,
 		CHOICE_GAME_OPTIONS,
diff --git a/stepmania/src/Song.cpp b/stepmania/src/Song.cpp
index 5f6ab65d71..655e55784f 100644
--- a/stepmania/src/Song.cpp
+++ b/stepmania/src/Song.cpp
@@ -215,8 +215,8 @@ bool Song::LoadFromSongDir( CString sDir )
 	//
 	// First look in the cache for this song (without loading NoteData)
 	//
-	if( LoadFromCacheFile(false) )
-		return true;
+	//if( LoadFromCacheFile(false) )
+	//	return true;
 
 
 	//
@@ -255,8 +255,8 @@ bool Song::LoadFromSongDir( CString sDir )
 	// In order to save memory, we're going to save the file back to the cache, 
 	// then unload all the large NoteData. 
 	//
-	SaveToCacheFile();
-	LoadFromCacheFile( false );
+	//SaveToCacheFile();
+	//LoadFromCacheFile( false );
 
 	return true;
 }
@@ -454,41 +454,16 @@ bool Song::LoadFromDWIFile( CString sPath )
 
 	// get group name
 	sDir.MakeLower();
-	if( sDir.Find( "dwi support" ) != -1 )	// loading from DWI support
-	{
-		int iIndexOfFirstBackslash = sDir.Find('\\');
-		int iIndexOfSecondBackslash = sDir.Find('\\', iIndexOfFirstBackslash+1);
-		int iIndexOfThirdBackslash = sDir.Find('\\', iIndexOfSecondBackslash+1);
-		m_sGroupName = sDir.Mid( iIndexOfSecondBackslash+1, iIndexOfThirdBackslash-iIndexOfSecondBackslash-1 );
-	}
-	else
-	{
-		// get group name
-		CStringArray sDirectoryParts;
-		split( m_sSongDir, "\\", sDirectoryParts, true );
-		m_sGroupName = sDirectoryParts[1];
-	}
+	CStringArray sDirectoryParts;
+	split( m_sSongDir, "\\", sDirectoryParts, true );
+	m_sGroupName = sDirectoryParts[1];
 
-	// save probable image paths
-	m_sBackgroundPath = ssprintf(".\\DWI Support\\Backgrounds\\%s\\%s.avi", m_sGroupName, sFName);
-	if( !DoesFileExist( GetBackgroundPath() ) )
-		m_sBackgroundPath = ssprintf(".\\DWI Support\\Backgrounds\\%s\\%s.mpg", m_sGroupName, sFName);
-	if( !DoesFileExist( GetBackgroundPath() ) )
-		m_sBackgroundPath = ssprintf(".\\DWI Support\\Backgrounds\\%s\\%s.mpeg", m_sGroupName, sFName);
-	if( !DoesFileExist( GetBackgroundPath() ) )
-		m_sBackgroundPath = ssprintf(".\\DWI Support\\Backgrounds\\%s\\%s.png", m_sGroupName, sFName);
-	
-	m_sBannerPath = ssprintf(".\\DWI Support\\Banners\\%s\\%s.png", m_sGroupName, sFName);
 
-	
 	CStdioFile file;	
 	if( !file.Open( GetSongFilePath(), CFile::modeRead|CFile::shareDenyNone ) )
 		FatalError( ssprintf("Error opening DWI file '%s'.", GetSongFilePath()) );
 
 
-//	MessageBox( NULL, sFName, sFName, MB_OK );
-
-
 	// read the whole file into a sFileText
 	CString sFileText;
 	CString buffer;
@@ -518,12 +493,11 @@ bool Song::LoadFromDWIFile( CString sPath )
 
 		// handle the data
 		if( sValueName == "#FILE" )
-			m_sMusicPath = CString("DWI Support\\") + arrayValueTokens[1];
+			m_sMusicPath = arrayValueTokens[1];
 
 		else if( sValueName == "#TITLE" )
-		{
 			GetMainAndSubTitlesFromFullTitle( arrayValueTokens[1], m_sMainTitle, m_sSubTitle );
-		}
+
 		else if( sValueName == "#ARTIST" )
 			m_sArtist = arrayValueTokens[1];
 
diff --git a/stepmania/src/StepMania.cpp b/stepmania/src/StepMania.cpp
index 798fd7270d..505a20f6c0 100644
--- a/stepmania/src/StepMania.cpp
+++ b/stepmania/src/StepMania.cpp
@@ -416,9 +416,7 @@ LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
             switch( LOWORD(wParam) )
             {
 				case IDM_TOGGLEFULLSCREEN:
-					PREFSMAN->m_WindowMode = PrefsManager::WindowMode( PREFSMAN->m_WindowMode+1 );
-					if( PREFSMAN->m_WindowMode >= PrefsManager::NUM_WINDOW_MODES )
-						PREFSMAN->m_WindowMode = PrefsManager::WindowMode( 0 );
+					PREFSMAN->m_bWindowed = !PREFSMAN->m_bWindowed;
 					ApplyGraphicOptions();
 					return 0;
 				case IDM_CHANGEDETAIL:
@@ -516,15 +514,14 @@ HRESULT CreateObjects( HWND hWnd )
 	TEXTUREMAN	= new RageTextureManager( DISPLAY );
 
 	// These things depend on the TextureManager, so do them last!
-	FONT	= new FontManager;
-	SCREENMAN		= new ScreenManager;
+	FONT		= new FontManager;
+	SCREENMAN	= new ScreenManager;
 
-//	SCREENMAN->SystemMessage( ssprintf("Found %d songs.", SONGMAN->m_pSongs.GetSize()) );
 
 
 	//SCREENMAN->SetNewScreen( new ScreenLoading );
 	//SCREENMAN->SetNewScreen( new ScreenSandbox );
-	//SCREENMAN->SetNewScreen( new ScreenResults );
+	//SCREENMAN->SetNewScreen( new ScreenResults(false) );
 	//SCREENMAN->SetNewScreen( new ScreenPlayerOptions );
 	//SCREENMAN->SetNewScreen( new ScreenTitleMenu );
 	//SCREENMAN->SetNewScreen( new ScreenGameplay );
@@ -575,7 +572,7 @@ HRESULT RestoreObjects()
 	/////////////////////
 	// Restore the window
 	/////////////////////
-	
+
     // Set window size
     RECT rcWnd;
 	if( DISPLAY->IsWindowed() )
@@ -598,6 +595,7 @@ HRESULT RestoreObjects()
                   0 );
 
 
+
 	///////////////////////////
 	// Restore all game objects
 	///////////////////////////
@@ -756,8 +754,7 @@ void ApplyGraphicOptions()
 {
 	InvalidateObjects();
 
-	bool bWindowed			= PREFSMAN->m_WindowMode != PrefsManager::WINDOW_MODE_FULLSCREEN;
-	bool bMaximized			= PREFSMAN->m_WindowMode == PrefsManager::WINDOW_MODE_MAXIMIZED;
+	bool bWindowed			= PREFSMAN->m_bWindowed;
 	CString sProfileName	= PREFSMAN->m_bHighDetail ? "High Detail" : "Low Detail";
 	DWORD dwWidth			= PREFSMAN->m_bHighDetail ? 640 : 320;
 	DWORD dwHeight			= PREFSMAN->m_bHighDetail ? 480 : 240;
diff --git a/stepmania/src/StepMania.dsp b/stepmania/src/StepMania.dsp
index 1bac636174..5a071457eb 100644
--- a/stepmania/src/StepMania.dsp
+++ b/stepmania/src/StepMania.dsp
@@ -400,14 +400,6 @@ SOURCE=.\TransitionRectWipe.h
 # End Source File
 # Begin Source File
 
-SOURCE=.\TransitionStarburst.cpp
-# End Source File
-# Begin Source File
-
-SOURCE=.\TransitionStarburst.h
-# End Source File
-# Begin Source File
-
 SOURCE=.\TransitionStarWipe.cpp
 # End Source File
 # Begin Source File
diff --git a/stepmania/src/StepMania.vcproj b/stepmania/src/StepMania.vcproj
index d730ddf1e2..072499cdfe 100644
--- a/stepmania/src/StepMania.vcproj
+++ b/stepmania/src/StepMania.vcproj
@@ -471,12 +471,6 @@
 			<File
 				RelativePath=".\TransitionStarWipe.h">
 			</File>
-			<File
-				RelativePath=".\TransitionStarburst.cpp">
-			</File>
-			<File
-				RelativePath=".\TransitionStarburst.h">
-			</File>
 		</Filter>
 		<Filter
 			Name="Actors used in Menus"
diff --git a/stepmania/src/ThemeManager.cpp b/stepmania/src/ThemeManager.cpp
index 10d2372eac..a96c405a63 100644
--- a/stepmania/src/ThemeManager.cpp
+++ b/stepmania/src/ThemeManager.cpp
@@ -90,6 +90,7 @@ CString ThemeManager::GetPathTo( ThemeElement te )
 		case GRAPHIC_DANCER_P2:							sAssetPrefix = "Graphics\\dancer p2";						break;
 		case GRAPHIC_DIFFICULTY_ICONS:					sAssetPrefix = "Graphics\\select music difficulty icons";	break;
 		case GRAPHIC_EDIT_BACKGROUND:					sAssetPrefix = "Graphics\\edit background";					break;
+		case GRAPHIC_EDIT_TOP_EDGE:						sAssetPrefix = "Graphics\\edit top edge";					break;
 		case GRAPHIC_EDIT_SNAP_INDICATOR:				sAssetPrefix = "Graphics\\edit snap indicator";				break;
 		case GRAPHIC_FALLBACK_BACKGROUND:				sAssetPrefix = "Graphics\\Fallback Background";				break;
 		case GRAPHIC_FALLBACK_BANNER:					sAssetPrefix = "Graphics\\Fallback Banner";					break;
@@ -110,8 +111,6 @@ CString ThemeManager::GetPathTo( ThemeElement te )
 		case GRAPHIC_GAMEPLAY_OPENING_STAR:				sAssetPrefix = "Graphics\\gameplay opening star";			break;
 		case GRAPHIC_GAMEPLAY_READY:					sAssetPrefix = "Graphics\\gameplay Ready";					break;
 		case GRAPHIC_GAMEPLAY_TOP_FRAME:				sAssetPrefix = "Graphics\\gameplay top frame";				break;
-		case GRAPHIC_GRAPHIC_OPTIONS_BACKGROUND:		sAssetPrefix = "Graphics\\graphic options background";		break;
-		case GRAPHIC_GRAPHIC_OPTIONS_TOP_EDGE:			sAssetPrefix = "Graphics\\graphic options top edge";		break;
 		case GRAPHIC_KEEP_ALIVE:						sAssetPrefix = "Graphics\\keep alive";						break;
 		case GRAPHIC_LIFEMETER_FRAME:					sAssetPrefix = "Graphics\\Life Meter Frame";				break;
 		case GRAPHIC_LIFEMETER_PILLS:					sAssetPrefix = "Graphics\\life meter pills 17x1";			break;
@@ -133,6 +132,7 @@ CString ThemeManager::GetPathTo( ThemeElement te )
 		case GRAPHIC_RESULTS_GRADES:					sAssetPrefix = "Graphics\\results grades 1x7";				break;
 		case GRAPHIC_RESULTS_JUDGE_LABELS:				sAssetPrefix = "Graphics\\results judge labels 1x6";		break;
 		case GRAPHIC_RESULTS_SCORE_LABELS:				sAssetPrefix = "Graphics\\results score labels 1x2";		break;
+		case GRAPHIC_RESULTS_SUMMARY_TOP_EDGE:			sAssetPrefix = "Graphics\\results summary top edge";			break;
 		case GRAPHIC_RESULTS_TOP_EDGE:					sAssetPrefix = "Graphics\\results top edge";				break;
 		case GRAPHIC_SELECT_DIFFICULTY_ARROW_P1:		sAssetPrefix = "Graphics\\select difficulty arrow p1";		break;
 		case GRAPHIC_SELECT_DIFFICULTY_ARROW_P2:		sAssetPrefix = "Graphics\\select difficulty arrow p2";		break;
@@ -210,6 +210,7 @@ CString ThemeManager::GetPathTo( ThemeElement te )
 		case SOUND_MENU_PROMPT:					sAssetPrefix = "Sounds\\menu prompt";					break;
 		case SOUND_MENU_START:					sAssetPrefix = "Sounds\\menu start";					break;
 		case SOUND_MENU_SWOOSH:					sAssetPrefix = "Sounds\\menu swoosh";					break;
+		case SOUND_MENU_TIMER:					sAssetPrefix = "Sounds\\menu timer";					break;
 		case SOUND_MUSIC_SCROLL_MUSIC:			sAssetPrefix = "Sounds\\music scroll music";			break;
 		case SOUND_OPTION_CHANGE_COL:			sAssetPrefix = "Sounds\\option change col";				break;
 		case SOUND_OPTION_CHANGE_ROW:			sAssetPrefix = "Sounds\\option change row";				break;
diff --git a/stepmania/src/ThemeManager.h b/stepmania/src/ThemeManager.h
index be4366543a..97e55ceb5e 100644
--- a/stepmania/src/ThemeManager.h
+++ b/stepmania/src/ThemeManager.h
@@ -27,6 +27,7 @@ enum ThemeElement {
 	GRAPHIC_GAMEPLAY_TOP_FRAME,
 	GRAPHIC_DIFFICULTY_ICONS,
 	GRAPHIC_EDIT_BACKGROUND,
+	GRAPHIC_EDIT_TOP_EDGE,
 	GRAPHIC_EDIT_SNAP_INDICATOR,
 	GRAPHIC_MUSIC_SCROLL_BACKGROUND,
 	GRAPHIC_FALLBACK_BACKGROUND,
@@ -42,8 +43,6 @@ enum ThemeElement {
 	GRAPHIC_GAMEPLAY_FAILED,	
 	GRAPHIC_GAMEPLAY_JUDGEMENT,	
 	GRAPHIC_GAMEPLAY_READY,	
-	GRAPHIC_GRAPHIC_OPTIONS_BACKGROUND,
-	GRAPHIC_GRAPHIC_OPTIONS_TOP_EDGE,
 	GRAPHIC_GAMEPLAY_HERE_WE_GO,	
 	GRAPHIC_KEEP_ALIVE,	
 	GRAPHIC_LIFEMETER_FRAME,
@@ -66,6 +65,7 @@ enum ThemeElement {
 	GRAPHIC_RESULTS_GRADES,	
 	GRAPHIC_RESULTS_JUDGE_LABELS,
 	GRAPHIC_RESULTS_SCORE_LABELS,
+	GRAPHIC_RESULTS_SUMMARY_TOP_EDGE,
 	GRAPHIC_RESULTS_TOP_EDGE,
 	GRAPHIC_SELECT_DIFFICULTY_ARROW_P1,
 	GRAPHIC_SELECT_DIFFICULTY_ARROW_P2,
@@ -143,6 +143,7 @@ enum ThemeElement {
 	SOUND_MENU_PROMPT,	
 	SOUND_MENU_START,	
 	SOUND_MENU_SWOOSH,
+	SOUND_MENU_TIMER,
 	SOUND_MUSIC_SCROLL_MUSIC,
 	SOUND_OPTION_CHANGE_COL,	
 	SOUND_OPTION_CHANGE_ROW,	
diff --git a/stepmania/src/Transition.h b/stepmania/src/Transition.h
index c155cdffb6..c81d2b0da3 100644
--- a/stepmania/src/Transition.h
+++ b/stepmania/src/Transition.h
@@ -73,11 +73,11 @@ protected:
 			return m_fPercentThroughTransition;
 		case closing_right:
 		case closing_left:
-			return 1.0f - m_fPercentThroughTransition;
+			return 1 - m_fPercentThroughTransition;
 		case opened:
-			return 0;
-		case closed:
 			return 1;
+		case closed:
+			return 0;
 		default:
 			ASSERT( false );
 			return 0;
diff --git a/stepmania/src/TransitionFadeWipe.cpp b/stepmania/src/TransitionFadeWipe.cpp
index 7cceb35fef..88bc903e9a 100644
--- a/stepmania/src/TransitionFadeWipe.cpp
+++ b/stepmania/src/TransitionFadeWipe.cpp
@@ -15,9 +15,6 @@
 #include "GameConstantsAndTypes.h"
 #include "ThemeManager.h"
 
-//#define RECTANGLE_WIDTH	20
-//#define NUM_RECTANGLES	(SCREEN_WIDTH/RECTANGLE_WIDTH)
-//#define FADE_RECTS_WIDE	(NUM_RECTANGLES/4)	// number of rects from fade start to fade end
 const float FADE_RECT_WIDTH		=	SCREEN_WIDTH/2;
 
 
diff --git a/stepmania/src/TransitionKeepAlive.cpp b/stepmania/src/TransitionKeepAlive.cpp
index f9df52782a..f62afaa0d5 100644
--- a/stepmania/src/TransitionKeepAlive.cpp
+++ b/stepmania/src/TransitionKeepAlive.cpp
@@ -38,32 +38,17 @@ void TransitionKeepAlive::Update( float fDeltaTime )
 
 void TransitionKeepAlive::DrawPrimitives()
 {
-	if( m_TransitionState == closing_left )	// we're going back
-	{
-		// Draw a fade
+	// draw keep alive graphic
 
-		const float fPercentageOpaque = 1 - GetPercentageOpen();
-		if( fPercentageOpaque == 0 )
-			return;	// draw nothing
+	float fPercentClosed = 1 - this->GetPercentageOpen();
+	fPercentClosed = min( 1, fPercentClosed*2 );
+	const float fPercentColor = fPercentClosed;
+	const float fPercentAlpha = min( fPercentClosed * 2, 1 );
 
-		D3DXCOLOR colorTemp = m_Color * fPercentageOpaque;
-		m_rect.SetDiffuseColor( colorTemp );
-		m_rect.Draw();
-	}
-	else	// we're going forward
-	{
-		// draw keep alive graphic
-
-		float fPercentClosed = 1 - this->GetPercentageOpen();
-		fPercentClosed = min( 1, fPercentClosed*2 );
-		const float fPercentColor = fPercentClosed;
-		const float fPercentAlpha = min( fPercentClosed * 2, 1 );
-
-		m_sprLogo.SetDiffuseColor( D3DXCOLOR(fPercentColor,fPercentColor,fPercentColor,fPercentAlpha) );
-		m_sprLogo.SetZoomY( fPercentClosed );
-		if( fPercentClosed > 0 )
-			m_sprLogo.Draw();
-	}
+	m_sprLogo.SetDiffuseColor( D3DXCOLOR(fPercentColor,fPercentColor,fPercentColor,fPercentAlpha) );
+	m_sprLogo.SetZoomY( fPercentClosed );
+	if( fPercentClosed > 0 )
+		m_sprLogo.Draw();
 }
 
 
diff --git a/stepmania/src/TransitionStarWipe.cpp b/stepmania/src/TransitionStarWipe.cpp
index 8f120e644c..c47885b5e4 100644
--- a/stepmania/src/TransitionStarWipe.cpp
+++ b/stepmania/src/TransitionStarWipe.cpp
@@ -37,20 +37,7 @@ void TransitionStarWipe::DrawPrimitives()
 		return;
 	}
 
-	float fPercentOpen = 1-GetPercentageOpen();
-	/*
-	switch( m_TransitionState )
-	{
-	case opening_right:
-	case opening_left:
-		fPercentOpen = (1.0f - m_fPercentThroughTransition);
-		break;
-	case closing_right:
-	case closing_left:
-		fPercentOpen = m_fPercentThroughTransition;
-		break;
-	}
-	*/
+	float fPercentClosed = 1 - GetPercentageOpen();
 
 
 	int iNumStars = SCREEN_HEIGHT/m_iStarHeight + 1;
@@ -76,7 +63,7 @@ void TransitionStarWipe::DrawPrimitives()
 			x_tilt = 0;
 		}
 
-		int x_offset = (int)(fPercentOpen*(SCREEN_WIDTH+SCREEN_HEIGHT+m_iStarWidth));
+		int x_offset = (int)(fPercentClosed*(SCREEN_WIDTH+SCREEN_HEIGHT+m_iStarWidth));
 
 		int x = bIsAnEvenRow ?
 			-SCREEN_HEIGHT/2			 + x_offset + x_tilt :