use sections in SORT_BPM

choose sort from list in MusicWheel

stepmania/Themes/default/metrics.ini

@@ -2056,16 +2056,16 @@ PrevScreenOni=ScreenSelectCourse
 PrevScreenEndless=ScreenSelectCourse
 PrevScreenBattle=ScreenSelectMusic
 PrevScreenRave=ScreenSelectMusic
-NextScreenArcade=ScreenPlayerOptions2
+NextScreenArcade=ScreenSongOptions
-NextScreenNonstop=ScreenPlayerOptions2
+NextScreenNonstop=ScreenSongOptions
-NextScreenOni=ScreenPlayerOptions2
+NextScreenOni=ScreenSongOptions
-NextScreenEndless=ScreenPlayerOptions2
+NextScreenEndless=ScreenSongOptions
-NextScreenBattle=ScreenPlayerOptions2
+NextScreenBattle=ScreenSongOptions
-NextScreenRave=ScreenPlayerOptions2
+NextScreenRave=ScreenSongOptions
 HelpText=&UP; &DOWN; to change line   &LEFT; &RIGHT; to select between options   START to accept changes
 TimerSeconds=30
 
-[ScreenPlayerOptions2]
+[ScreenRaveOptions]
 PrevScreenArcade=ScreenPlayerOptions
 PrevScreenNonstop=ScreenPlayerOptions
 PrevScreenOni=ScreenPlayerOptions
@@ -2077,32 +2077,16 @@ NextScreenNonstop=ScreenSongOptions
 NextScreenOni=ScreenSongOptions
 NextScreenEndless=ScreenSongOptions
 NextScreenBattle=ScreenSongOptions
-NextScreenRave=ScreenRaveOptions
-HelpText=&UP; &DOWN; to change line   &LEFT; &RIGHT; to select between options   START to accept changes
-TimerSeconds=30
-
-[ScreenRaveOptions]
-PrevScreenArcade=ScreenPlayerOptions2
-PrevScreenNonstop=ScreenPlayerOptions2
-PrevScreenOni=ScreenPlayerOptions2
-PrevScreenEndless=ScreenPlayerOptions2
-PrevScreenBattle=ScreenPlayerOptions2
-PrevScreenRave=ScreenPlayerOptions2
-NextScreenArcade=ScreenSongOptions
-NextScreenNonstop=ScreenSongOptions
-NextScreenOni=ScreenSongOptions
-NextScreenEndless=ScreenSongOptions
-NextScreenBattle=ScreenSongOptions
 NextScreenRave=ScreenSongOptions
 HelpText=&UP; &DOWN; to change line   &LEFT; &RIGHT; to select between options   START to accept changes
 TimerSeconds=30
 
 [ScreenSongOptions]
-PrevScreenArcade=ScreenPlayerOptions2
+PrevScreenArcade=ScreenPlayerOptions
-PrevScreenNonstop=ScreenPlayerOptions2
+PrevScreenNonstop=ScreenPlayerOptions
-PrevScreenOni=ScreenPlayerOptions2
+PrevScreenOni=ScreenPlayerOptions
-PrevScreenEndless=ScreenPlayerOptions2
+PrevScreenEndless=ScreenPlayerOptions
-PrevScreenBattle=ScreenPlayerOptions2
+PrevScreenBattle=ScreenPlayerOptions
 PrevScreenRave=ScreenRaveOptions
 NextScreenArcade=ScreenStage
 NextScreenNonstop=ScreenStage

stepmania/src/BPMDisplay.cpp

@@ -181,7 +181,7 @@ void BPMDisplay::SetBPM( const Song* pSong )
 		}
 		break;
 	case Song::DISPLAY_SPECIFIED:
-		SetBPMRange( pSong->m_fDisplayBPMMin, pSong->m_fDisplayBPMMax );
+		SetBPMRange( pSong->m_fSpecifiedBPMMin, pSong->m_fSpecifiedBPMMax );
 		break;
 	case Song::DISPLAY_RANDOM:
 		CycleRandomly();

stepmania/src/GameConstantsAndTypes.cpp

@@ -106,3 +106,18 @@ CString CoinModeToString( CoinMode cm )
 		default:	ASSERT(0);	return "";
 	}
 }
+
+
+CString SongSortOrderToString( SongSortOrder so )
+{
+	CString s[NUM_SORT_ORDERS] = {
+		"PREFERRED",
+		"GROUP", 
+		"TITLE", 
+		"BPM", 
+		"MOST PLAYED", 
+		"SORT"
+		"ROULETTE"
+	};
+	return s[so];
+}

stepmania/src/GameConstantsAndTypes.h

@@ -108,9 +108,14 @@ enum SongSortOrder {
 	SORT_TITLE, 
 	SORT_BPM, 
 	SORT_MOST_PLAYED, 
+	SORT_SORT,
 	SORT_ROULETTE,
-	NUM_SORT_ORDERS
+	NUM_SORT_ORDERS,
+	SORT_INVALID
 };
+const SongSortOrder MAX_SELECTABLE_SORT = (SongSortOrder)(SORT_ROULETTE-1);
+
+CString SongSortOrderToString( SongSortOrder so );
 
 
 //

stepmania/src/MusicSortDisplay.cpp

@@ -21,7 +21,7 @@
 
 MusicSortDisplay::MusicSortDisplay()
 {
-	Load( THEME->GetPathToG("MusicSortDisplay icons 1x5") );
+	Load( THEME->GetPathToG(ssprintf("MusicSortDisplay icons 1x%d",NUM_SORT_ORDERS)) );
 	StopAnimating();
 }
 
@@ -34,6 +34,7 @@ void MusicSortDisplay::Set( SongSortOrder so )
 	case SORT_TITLE:
 	case SORT_BPM:
 	case SORT_MOST_PLAYED:
+	case SORT_SORT:
 		SetState( so );
 		break;
 	default:

stepmania/src/MusicWheel.cpp

@@ -51,30 +51,7 @@ CachedThemeMetricB	USE_3D			("MusicWheel","Use3D");
 
 const int MAX_WHEEL_SOUND_SPEED = 15;
 
-static const SongSortOrder MaxSelectableSort = SORT_MOST_PLAYED;
 
-static inline RageColor GetNextSectionColor()
-{
-	static int i=0;
-	i = i % NUM_SECTION_COLORS;
-	return SECTION_COLORS(i++);
-}
-
-
-static SongSortOrder NextSongSortOrder(SongSortOrder so)
-{
-	so = SongSortOrder( so+1 );
-	if(so > MaxSelectableSort)
-		so = SongSortOrder(0);
-
-	/* Disable SORT_PREFERRED for now, until it's implemented; right now it's not
-	 * very different than SORT_GROUP.  Once it's implemented, enable it only
-	 * when no group is selected. */
-	if(so == SORT_PREFERRED)
-		so = SORT_GROUP;
-
-	return so;
-}
 
 MusicWheel::MusicWheel() 
 { 
@@ -118,6 +95,7 @@ MusicWheel::MusicWheel()
 
 	
 	m_iSelection = 0;
+	m_LastSongSortOrder = SORT_INVALID;
 
 	m_WheelState = STATE_SELECTING_MUSIC;
 	m_fTimeLeftInState = 0;
@@ -268,6 +246,35 @@ bool MusicWheel::SelectCourse( const Course *p )
 	return true;
 }
 
+bool MusicWheel::SelectSort( SongSortOrder so )
+{
+	if(so == SORT_INVALID)
+		return false;
+
+	unsigned i;
+	vector<WheelItemData> &from = m_WheelItemDatas[GAMESTATE->m_SongSortOrder];
+	for( i=0; i<from.size(); i++ )
+	{
+		if( from[i].m_SongSortOrder == so )
+		{
+			// make its group the currently expanded group
+			SetOpenGroup(from[i].m_sSectionName);
+			break;
+		}
+	}
+
+	if(i == from.size())
+		return false;
+
+	for( i=0; i<m_CurWheelItemData.size(); i++ )
+	{
+		if( m_CurWheelItemData[i]->m_SongSortOrder == so )
+			m_iSelection = i;		// select it
+	}
+
+	return true;
+}
+
 void MusicWheel::GetSongList(vector<Song*> &arraySongs, SongSortOrder so, CString sPreferredGroup )
 {
 	vector<Song*> apAllSongs;
@@ -332,29 +339,23 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 {
 	unsigned i;
 
-	// Roulette isn't a choice when selecting a course
-	/* Do we really need to do this?  Seems like an optimization that
-	 * doesn't win anything.  (And the other sort orders aren't used,
-	 * either ...) -glenn */
-	if( so == SongSortOrder(SORT_ROULETTE) )
-	{
-		switch( GAMESTATE->m_PlayMode )
-		{
-		case PLAY_MODE_NONSTOP:
-		case PLAY_MODE_ONI:
-		case PLAY_MODE_ENDLESS:
-            return;
-		default:
-			break;
-		}
-	}
-
 	switch( GAMESTATE->m_PlayMode )
 	{
 	case PLAY_MODE_ARCADE:
 	case PLAY_MODE_BATTLE:
 	case PLAY_MODE_RAVE:
 		{
+			if( so == SORT_SORT )
+			{
+				arrayWheelItemDatas.clear();	// clear out the previous wheel items 
+				for( i=0; i<MAX_SELECTABLE_SORT; i++ )
+				{
+					RageColor c = RageColor(1,1,0,1);
+					arrayWheelItemDatas.push_back( WheelItemData(TYPE_SORT, NULL, "", NULL, c, (SongSortOrder)i) );
+				}
+				break;
+			}
+
 			///////////////////////////////////
 			// Make an array of Song*, then sort them
 			///////////////////////////////////
@@ -398,7 +399,7 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 			{
 			case SORT_PREFERRED:	bUseSections = false;	break;
 			case SORT_MOST_PLAYED:	bUseSections = false;	break;
-			case SORT_BPM:			bUseSections = false;	break;
+			case SORT_BPM:			bUseSections = true;	break;
 			case SORT_GROUP:		bUseSections = GAMESTATE->m_sPreferredGroup == GROUP_ALL_MUSIC;	break;
 			case SORT_TITLE:		bUseSections = true;	break;
 			case SORT_ROULETTE:		bUseSections = false;	break;
@@ -428,11 +429,11 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 					{
 						colorSection = (so==SORT_GROUP) ? SONGMAN->GetGroupColor(pSong->m_sGroupName) : SECTION_COLORS(iSectionColorIndex);
 						iSectionColorIndex = (iSectionColorIndex+1) % NUM_SECTION_COLORS;
-						arrayWheelItemDatas.push_back( WheelItemData(TYPE_SECTION, NULL, sThisSection, NULL, colorSection) );
+						arrayWheelItemDatas.push_back( WheelItemData(TYPE_SECTION, NULL, sThisSection, NULL, colorSection, SORT_INVALID) );
 						sLastSection = sThisSection;
 					}
 
-					arrayWheelItemDatas.push_back( WheelItemData( TYPE_SONG, pSong, sThisSection, NULL, SONGMAN->GetSongColor(pSong)) );
+					arrayWheelItemDatas.push_back( WheelItemData( TYPE_SONG, pSong, sThisSection, NULL, SONGMAN->GetSongColor(pSong), SORT_INVALID) );
 				}
 			}
 			else
@@ -440,16 +441,16 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 				for( unsigned i=0; i<arraySongs.size(); i++ )
 				{
 					Song* pSong = arraySongs[i];
-					arrayWheelItemDatas.push_back( WheelItemData(TYPE_SONG, pSong, "", NULL, SONGMAN->GetSongColor(pSong)) );
+					arrayWheelItemDatas.push_back( WheelItemData(TYPE_SONG, pSong, "", NULL, SONGMAN->GetSongColor(pSong), SORT_INVALID) );
 				}
 			}
 
 			if( so != SORT_ROULETTE )
 			{
 				if( SHOW_ROULETTE )
-					arrayWheelItemDatas.push_back( WheelItemData(TYPE_ROULETTE, NULL, "", NULL, RageColor(1,0,0,1)) );
+					arrayWheelItemDatas.push_back( WheelItemData(TYPE_ROULETTE, NULL, "", NULL, RageColor(1,0,0,1), SORT_INVALID) );
 				if( SHOW_RANDOM )
-					arrayWheelItemDatas.push_back( WheelItemData(TYPE_RANDOM, NULL, "", NULL, RageColor(1,0,0,1)) );
+					arrayWheelItemDatas.push_back( WheelItemData(TYPE_RANDOM, NULL, "", NULL, RageColor(1,0,0,1), SORT_INVALID) );
 			}
 
 			// HACK:  Add extra stage item if it isn't already present on the music wheel
@@ -475,7 +476,7 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 				}
 
 				if( !bFoundExtraSong )
-					arrayWheelItemDatas.push_back( WheelItemData(TYPE_SONG, pSong, "", NULL, SONG_REAL_EXTRA_COLOR) );
+					arrayWheelItemDatas.push_back( WheelItemData(TYPE_SONG, pSong, "", NULL, SONG_REAL_EXTRA_COLOR, SORT_INVALID) );
 			}
 		}
 		break;
@@ -483,6 +484,10 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 	case PLAY_MODE_ONI:
 	case PLAY_MODE_ENDLESS:
 		{
+			// We only use SORT_PREFERRED when selecting a course
+			if( so != SongSortOrder(SORT_PREFERRED) )
+				break;
+			
 			vector<Course*> apCourses;
 			switch( GAMESTATE->m_PlayMode )
 			{
@@ -500,9 +505,8 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 
 				// check that this course has at least one song playable in the current style
 				if( pCourse->IsPlayableIn(GAMESTATE->GetCurrentStyleDef()->m_NotesType) )
-                    arrayWheelItemDatas.push_back( WheelItemData(TYPE_COURSE, NULL, "", pCourse, pCourse->GetColor()) );
+                    arrayWheelItemDatas.push_back( WheelItemData(TYPE_COURSE, NULL, "", pCourse, pCourse->GetColor(), SORT_INVALID) );
 			}
-
 		}
 		break;
 	default:
@@ -545,7 +549,7 @@ void MusicWheel::BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItemDatas
 
 	if( arrayWheelItemDatas.empty() )
 	{
-		arrayWheelItemDatas.push_back( WheelItemData(TYPE_SECTION, NULL, "- EMPTY -", NULL, RageColor(1,0,0,1)) );
+		arrayWheelItemDatas.push_back( WheelItemData(TYPE_SECTION, NULL, "- EMPTY -", NULL, RageColor(1,0,0,1), SORT_INVALID) );
 	}
 }
 
@@ -732,44 +736,32 @@ void MusicWheel::Update( float fDeltaTime )
 		case STATE_FLYING_OFF_BEFORE_NEXT_SORT:
 			{
 				Song* pPrevSelectedSong = m_CurWheelItemData[m_iSelection]->m_pSong;
-				CString sPrevSelectedSection = m_CurWheelItemData[m_iSelection]->m_sSectionName;
-
-				/* Change the sort order. */
-				GAMESTATE->m_SongSortOrder = NextSongSortOrder(GAMESTATE->m_SongSortOrder);
 
 				SCREENMAN->PostMessageToTopScreen( SM_SortOrderChanged, 0 );
-				SetOpenGroup(GetSectionNameFromSongAndSort( pPrevSelectedSong, GAMESTATE->m_SongSortOrder ));
 				
-				//RebuildWheelItems();
+				SetOpenGroup(GetSectionNameFromSongAndSort( pPrevSelectedSong, GAMESTATE->m_SongSortOrder ));
 
 				m_iSelection = 0;
 
-				if( pPrevSelectedSong != NULL )		// the previous selected item was a song
+				switch( GAMESTATE->m_SongSortOrder )
-					SelectSong(pPrevSelectedSong);
-				else	// the previously selected item was a section
 				{
-					// find the previously selected song, and select it
+				case SORT_PREFERRED:
-					for( i=0; i<m_CurWheelItemData.size(); i++ )
+				case SORT_GROUP:
-					{
+				case SORT_TITLE:
-						if( m_CurWheelItemData[i]->m_sSectionName == sPrevSelectedSection )
+				case SORT_BPM:
-						{
+				case SORT_MOST_PLAYED:
-							m_iSelection = i;
+				case SORT_ROULETTE:
+					// Look for the last selected song or course
+					if( GAMESTATE->m_pCurCourse )
+						SelectCourse( GAMESTATE->m_pCurCourse );
+					if( GAMESTATE->m_pCurSong )
+						SelectSong( GAMESTATE->m_pCurSong );
 					break;
-						}
+				case SORT_SORT:
-					}
+					SelectSort( m_LastSongSortOrder );
-				}
-
-				// If changed sort to "BEST", put selection on most popular song
-				if( GAMESTATE->m_SongSortOrder == SORT_MOST_PLAYED )
-				{
-					for( i=0; i<m_CurWheelItemData.size(); i++ )
-					{
-						if( m_CurWheelItemData[i]->m_pSong != NULL )
-						{
-							m_iSelection = i;
 					break;
-						}
+				default:
-					}
+					ASSERT(0);
 				}
 
 				SCREENMAN->PostMessageToTopScreen( SM_SongChanged, 0 );
@@ -951,12 +943,7 @@ void MusicWheel::ChangeMusic(int dist)
 		m_soundChangeMusic.Play();
 }
 
-bool MusicWheel::PrevSort()
+bool MusicWheel::ChangeSort( SongSortOrder new_so )	// return true if change successful
-{
-	return NextSort();
-}
-
-bool MusicWheel::NextSort()
 {
 	switch( m_WheelState )
 	{
@@ -971,10 +958,29 @@ bool MusicWheel::NextSort()
 
 	TweenOffScreen(true);
 
+	m_LastSongSortOrder = GAMESTATE->m_SongSortOrder;
+	GAMESTATE->m_SongSortOrder = new_so;
+
 	m_WheelState = STATE_FLYING_OFF_BEFORE_NEXT_SORT;
 	return true;
 }
-bool MusicWheel::Select()	// return true of a playable item was chosen
+
+bool MusicWheel::NextSort()		// return true if change successful
+{
+	SongSortOrder so = SongSortOrder( GAMESTATE->m_SongSortOrder+1 );
+	if(so > MAX_SELECTABLE_SORT)
+		so = SongSortOrder(0);
+
+	/* Disable SORT_PREFERRED for now, until it's implemented; right now it's not
+	 * very different than SORT_GROUP.  Once it's implemented, enable it only
+	 * when no group is selected. */
+	if(so == SORT_PREFERRED)
+		so = SORT_GROUP;
+
+	return ChangeSort( so );
+}
+
+bool MusicWheel::Select()	// return true if this selection ends the screen
 {
 	LOG->Trace( "MusicWheel::Select()" );
 
@@ -1015,22 +1021,6 @@ bool MusicWheel::Select()	// return true of a playable item was chosen
 			m_soundExpand.Play();
 
 			SetOpenGroup(m_sExpandedSectionName);
-	
-		RebuildMusicWheelItems();
-
-
-		m_iSelection = 0;	// reset in case we can't find the last selected song
-		// find the section header and select it
-		for( unsigned  i=0; i<m_CurWheelItemData.size(); i++ )
-		{
-			if( m_CurWheelItemData[i]->m_Type == TYPE_SECTION  
-				&&  m_CurWheelItemData[i]->m_sSectionName == sThisItemSectionName )
-			{
-				m_iSelection = i;
-				break;
-			}
-		}
-
 		}
 		return false;
 	case TYPE_ROULETTE:
@@ -1039,11 +1029,15 @@ bool MusicWheel::Select()	// return true of a playable item was chosen
 	case TYPE_RANDOM:
 		StartRandom();
 		return false;
-
 	case TYPE_SONG:
-	default:
+	case TYPE_COURSE:
-		
 		return true;
+	case TYPE_SORT:
+		ChangeSort( m_CurWheelItemData[m_iSelection]->m_SongSortOrder );
+		return false;
+	default:
+		ASSERT(0);
+		return false;
 	}
 }
 
@@ -1077,7 +1071,7 @@ void MusicWheel::StartRandom()
 
 void MusicWheel::SetOpenGroup(CString group, SongSortOrder so)
 {
-	if(so == NUM_SORT_ORDERS)
+	if( so == SORT_INVALID)
 		so = GAMESTATE->m_SongSortOrder;
 
 	m_sExpandedSectionName = group;
@@ -1105,11 +1099,19 @@ void MusicWheel::SetOpenGroup(CString group, SongSortOrder so)
 			TEXTUREMAN->CacheTexture( Banner::BannerTex(from[i].GetBanner()) );
 	}
 
+
+	//
+	// Try to select the item that was selected before chaning groups
+	//
 	m_iSelection = 0;
-	for(i = 0; i < m_CurWheelItemData.size(); ++i)
+
+	for( i=0; i<m_CurWheelItemData.size(); i++ )
 	{
 		if( m_CurWheelItemData[i] == old )
+		{
 			m_iSelection=i;
+			break;
+		}
 	}
 
 	RebuildMusicWheelItems();
@@ -1257,6 +1259,14 @@ CString MusicWheel::GetSectionNameFromSongAndSort( const Song* pSong, SongSortOr
 		sTemp = sTemp[0];
 		return sTemp;
 	case SORT_BPM:
+		{
+			const int iBPMGroupSize = 20;
+			float fMinBPM, fMaxBPM;
+			pSong->GetDisplayBPM( fMinBPM, fMaxBPM );
+			int iMaxBPM = (int)fMaxBPM;
+			iMaxBPM += iBPMGroupSize - (iMaxBPM%iBPMGroupSize);
+			return ssprintf("%03d-%03d",iMaxBPM-(iBPMGroupSize-1), iMaxBPM);
+		}
 	case SORT_MOST_PLAYED:
 	default:
 		return "";

stepmania/src/MusicWheel.h

@@ -52,8 +52,8 @@ public:
 	virtual void TweenOffScreen() { TweenOffScreen(false); }
 
 	void Move(int n);
-	bool PrevSort();
+	bool ChangeSort( SongSortOrder new_so );	// return true if change successful
-	bool NextSort();
+	bool NextSort();		// return true if change successful
 	void StartRoulette();
 	void StartRandom();
 	bool IsRouletting() const;
@@ -64,7 +64,7 @@ public:
 
 	void GetItemPosition( float fPosOffsetsFromMiddle, float& fX_out, float& fY_out, float& fZ_out, float& fRotationX_out );
 
-	bool Select();	// return true if the selected item is a music, otherwise false
+	bool Select();	// return true if this selection ends the screen
 	WheelItemType	GetSelectedType()	{ return m_CurWheelItemData[m_iSelection]->m_Type; };
 	Song*			GetSelectedSong()	{ return m_CurWheelItemData[m_iSelection]->m_pSong; };
 	Course*			GetSelectedCourse()	{ return m_CurWheelItemData[m_iSelection]->m_pCourse; };
@@ -76,9 +76,10 @@ public:
 protected:
 	void GetSongList(vector<Song*> &arraySongs, SongSortOrder so, CString sPreferredGroup );
 	void BuildWheelItemDatas( vector<WheelItemData> &arrayWheelItems, SongSortOrder so );
-	void SetOpenGroup(CString group, SongSortOrder so = NUM_SORT_ORDERS);
+	void SetOpenGroup(CString group, SongSortOrder so = SORT_INVALID);
 	bool SelectSong(const Song *p);
 	bool SelectCourse(const Course *p);
+	bool SelectSort( SongSortOrder so );
 	void ChangeMusic(int dist); /* +1 or -1 */
 
 	ScrollBar			m_ScrollBar;
@@ -91,6 +92,7 @@ protected:
 	
 	int					m_iSelection;		// index into m_CurWheelItemData
 	CString				m_sExpandedSectionName;
+ 	SongSortOrder		m_LastSongSortOrder;
 
 	int					m_iSwitchesLeftInSpinDown;		
 	float				m_fLockedWheelVelocity;

stepmania/src/MusicWheelItem.cpp

@@ -42,7 +42,7 @@
 
 
 
-WheelItemData::WheelItemData( WheelItemType wit, Song* pSong, CString sSectionName, Course* pCourse, RageColor color )
+WheelItemData::WheelItemData( WheelItemType wit, Song* pSong, CString sSectionName, Course* pCourse, RageColor color, SongSortOrder so )
 {
 	m_Type = wit;
 	m_pSong = pSong;
@@ -50,6 +50,7 @@ WheelItemData::WheelItemData( WheelItemType wit, Song* pSong, CString sSectionNa
 	m_pCourse = pCourse;
 	m_color = color;
 	m_Flags = WheelNotifyIcon::Flags();
+	m_SongSortOrder = so;
 }
 
 
@@ -94,6 +95,12 @@ MusicWheelItem::MusicWheelItem()
 	m_textCourse.SetZoom( COURSE_ZOOM );
 	m_textCourse.SetHorizAlign( align_left );
 	m_textCourse.SetXY( COURSE_X, 0 );
+
+	m_textSort.LoadFromFont( THEME->GetPathToF("MusicWheelItem sort") );
+	m_textSort.EnableShadow( false );
+	m_textSort.SetZoom( COURSE_ZOOM );
+	m_textSort.SetHorizAlign( align_left );
+	m_textSort.SetXY( COURSE_X, 0 );
 }
 
 
@@ -119,19 +126,26 @@ void MusicWheelItem::LoadFromWheelItemData( WheelItemData* pWID )
 	{
 	case TYPE_SECTION:
 	case TYPE_COURSE:
+	case TYPE_SORT:
 		{
 			CString sDisplayName;
 			BitmapText *bt;
-			if(pWID->m_Type == TYPE_SECTION)
+			switch( pWID->m_Type )
 			{
+				case TYPE_SECTION:
 					sDisplayName = SONGMAN->ShortenGroupName(data->m_sSectionName);
 					bt = &m_textSectionName;
-			}
+					break;
-			else
+				case TYPE_COURSE:
-			{
 					sDisplayName = data->m_pCourse->m_sName;
 					bt = &m_textCourse;
+					break;
+				case TYPE_SORT:
+					sDisplayName = SongSortOrderToString(data->m_SongSortOrder);
+					bt = &m_textSort;
+					break;
 			}
+
 			bt->SetZoom( 1 );
 			bt->SetText( sDisplayName );
 			bt->SetDiffuse( data->m_color );
@@ -217,6 +231,10 @@ void MusicWheelItem::Update( float fDeltaTime )
 		m_sprSongBar.Update( fDeltaTime );
 		m_textCourse.Update( fDeltaTime );
 		break;
+	case TYPE_SORT:
+		m_sprSectionBar.Update( fDeltaTime );
+		m_textSort.Update( fDeltaTime );
+		break;
 	default:
 		ASSERT(0);
 	}
@@ -229,9 +247,14 @@ void MusicWheelItem::DrawPrimitives()
 	{
 	case TYPE_SECTION: 
 	case TYPE_ROULETTE:
-	case TYPE_RANDOM: bar = &m_sprSectionBar; break;
+	case TYPE_RANDOM:
+	case TYPE_SORT:
+		bar = &m_sprSectionBar; 
+		break;
 	case TYPE_SONG:		
-	case TYPE_COURSE: bar = &m_sprSongBar; break;
+	case TYPE_COURSE:
+		bar = &m_sprSongBar; 
+		break;
 	default: ASSERT(0);
 	}
 	
@@ -256,6 +279,9 @@ void MusicWheelItem::DrawPrimitives()
 	case TYPE_COURSE:
 		m_textCourse.Draw();
 		break;
+	case TYPE_SORT:
+		m_textSort.Draw();
+		break;
 	default:
 		ASSERT(0);
 	}
@@ -283,6 +309,7 @@ bool WheelItemData::HasBanner() const
 	/* XXX: These are special cases. */
 	case TYPE_ROULETTE:
 	case TYPE_RANDOM:
+	case TYPE_SORT:
 		return false;
 		
 	default: ASSERT(0); return false; // "";

stepmania/src/MusicWheelItem.h

@@ -16,6 +16,7 @@
 #include "BitmapText.h"
 #include "WheelNotifyIcon.h"
 #include "TextBanner.h"
+#include "GameConstantsAndTypes.h"
 class Course;
 class Song;
 
@@ -50,14 +51,17 @@ public:
 
 	// for TYPE_COURSE
 	BitmapText			m_textCourse;
+
+	// for TYPE_SORT
+	BitmapText			m_textSort;
 };
 
-enum WheelItemType { TYPE_SECTION, TYPE_SONG, TYPE_ROULETTE, TYPE_RANDOM, TYPE_COURSE };
+enum WheelItemType { TYPE_SECTION, TYPE_SONG, TYPE_ROULETTE, TYPE_RANDOM, TYPE_COURSE, TYPE_SORT };
 
 struct WheelItemData
 {
 	WheelItemData() {}
-	WheelItemData( WheelItemType wit, Song* pSong, CString sSectionName, Course* pCourse, RageColor color );
+	WheelItemData( WheelItemType wit, Song* pSong, CString sSectionName, Course* pCourse, RageColor color, SongSortOrder so );
 
 	bool HasBanner() const;
 	CString GetBanner() const;
@@ -68,6 +72,7 @@ struct WheelItemData
 	Song*			m_pSong;
 	RageColor		m_color;	// either text color or section background color
 	WheelNotifyIcon::Flags  m_Flags;
+	SongSortOrder	m_SongSortOrder;
 };
 
 #endif

stepmania/src/NotesLoaderDWI.cpp

@@ -323,13 +323,13 @@ bool DWILoader::LoadFromDWIFile( CString sPath, Song &out )
 		    if( sscanf( sParams[1], "%i..%i", &iMin, &iMax ) == 2 )
 			{
 				out.m_DisplayBPMType = Song::DISPLAY_SPECIFIED;
-				out.m_fDisplayBPMMin = (float) iMin;
+				out.m_fSpecifiedBPMMin = (float) iMin;
-				out.m_fDisplayBPMMax = (float) iMax;
+				out.m_fSpecifiedBPMMax = (float) iMax;
 			}
 			else if( sscanf( sParams[1], "%i", &iMin ) == 1 )
 			{
 				out.m_DisplayBPMType = Song::DISPLAY_SPECIFIED;
-				out.m_fDisplayBPMMin = out.m_fDisplayBPMMax = (float) iMin;
+				out.m_fSpecifiedBPMMin = out.m_fSpecifiedBPMMax = (float) iMin;
 			}
 			else
 			{

stepmania/src/NotesLoaderSM.cpp

@@ -155,11 +155,11 @@ bool SMLoader::LoadFromSMFile( CString sPath, Song &out )
 			else 
 			{
 				out.m_DisplayBPMType = Song::DISPLAY_SPECIFIED;
-				out.m_fDisplayBPMMin = (float)atof( sParams[1] );
+				out.m_fSpecifiedBPMMin = (float)atof( sParams[1] );
 				if( sParams[2].empty() )
-					out.m_fDisplayBPMMax = out.m_fDisplayBPMMin;
+					out.m_fSpecifiedBPMMax = out.m_fSpecifiedBPMMin;
 				else
-					out.m_fDisplayBPMMax = (float)atof( sParams[2] );
+					out.m_fSpecifiedBPMMax = (float)atof( sParams[2] );
 			}
 		}
 

stepmania/src/NotesWriterDWI.cpp

@@ -235,10 +235,10 @@ bool NotesWriterDWI::Write( CString sPath, const Song &out )
 		// write nothing
 		break;
 	case Song::DISPLAY_SPECIFIED:
-		if( out.m_fDisplayBPMMin == out.m_fDisplayBPMMax )
+		if( out.m_fSpecifiedBPMMin == out.m_fSpecifiedBPMMax )
-			fprintf( fp, "#DISPLAYBPM:%i;\n", (int) out.m_fDisplayBPMMin );
+			fprintf( fp, "#DISPLAYBPM:%i;\n", (int) out.m_fSpecifiedBPMMin );
 		else
-			fprintf( fp, "#DISPLAYBPM:%i..%i;\n", (int) out.m_fDisplayBPMMin, (int) out.m_fDisplayBPMMax );
+			fprintf( fp, "#DISPLAYBPM:%i..%i;\n", (int) out.m_fSpecifiedBPMMin, (int) out.m_fSpecifiedBPMMax );
 		break;
 	case Song::DISPLAY_RANDOM:
 		fprintf( fp, "#DISPLAYBPM:*" );

stepmania/src/NotesWriterSM.cpp

@@ -42,10 +42,10 @@ void NotesWriterSM::WriteGlobalTags(FILE *fp, const Song &out)
 		// write nothing
 		break;
 	case Song::DISPLAY_SPECIFIED:
-		if( out.m_fDisplayBPMMin == out.m_fDisplayBPMMax )
+		if( out.m_fSpecifiedBPMMin == out.m_fSpecifiedBPMMax )
-			fprintf( fp, "#DISPLAYBPM:%.3f;\n", out.m_fDisplayBPMMin );
+			fprintf( fp, "#DISPLAYBPM:%.3f;\n", out.m_fSpecifiedBPMMin );
 		else
-			fprintf( fp, "#DISPLAYBPM:%.3f:%.3f;\n", out.m_fDisplayBPMMin, out.m_fDisplayBPMMax );
+			fprintf( fp, "#DISPLAYBPM:%.3f:%.3f;\n", out.m_fSpecifiedBPMMin, out.m_fSpecifiedBPMMax );
 		break;
 	case Song::DISPLAY_RANDOM:
 		fprintf( fp, "#DISPLAYBPM:*;\n" );

stepmania/src/ScreenPlayerOptions.h

@@ -31,6 +31,10 @@ private:
 
 	void GoToNextState();
 	void GoToPrevState();
+
+	bool            m_bAcceptedChoices;
+	bool            m_bGoToOptions;
+	Sprite          m_sprOptionsMessage;
 };
 
 

stepmania/src/ScreenSelectMusic.cpp

@@ -442,14 +442,12 @@ void ScreenSelectMusic::Input( const DeviceInput& DeviceI, InputEventType type,
 		if( ( GAMESTATE->IsExtraStage() && !PREFSMAN->m_bPickExtraStage ) || GAMESTATE->IsExtraStage2() )
 			m_soundLocked.Play();
 		else
-			if( m_MusicWheel.NextSort() )
+			m_MusicWheel.ChangeSort( SORT_SORT );
-			{
+//			if( m_MusicWheel.NextSort() )
-				SOUNDMAN->StopMusic();
+//			{
-
+//				SOUNDMAN->StopMusic();
-//				m_MusicSortDisplay.FadeOff( 0, "fade", TWEEN_TIME );
+//				TweenScoreOnAndOffAfterChangeSort();
-
+//			}
-				TweenScoreOnAndOffAfterChangeSort();
-			}
 		return;
 	}
 	if( !GAMESTATE->IsExtraStage() && !GAMESTATE->IsExtraStage2() && CodeDetector::DetectAndAdjustMusicOptions(GameI.controller) )
@@ -767,6 +765,7 @@ void ScreenSelectMusic::AfterMusicChange()
 	m_Menu.m_MenuTimer.Stall();
 
 	Song* pSong = m_MusicWheel.GetSelectedSong();
+	if( pSong )
 		GAMESTATE->m_pCurSong = pSong;
 
 	m_sprStage.Load( THEME->GetPathToG("ScreenSelectMusic stage "+GAMESTATE->GetStageText()) );
@@ -788,6 +787,7 @@ void ScreenSelectMusic::AfterMusicChange()
 	switch( m_MusicWheel.GetSelectedType() )
 	{
 	case TYPE_SECTION:
+	case TYPE_SORT:
 		{	
 			CString sGroup = m_MusicWheel.GetSelectedSection();
 			for( int p=0; p<NUM_PLAYERS; p++ )
@@ -805,7 +805,8 @@ void ScreenSelectMusic::AfterMusicChange()
 		break;
 	case TYPE_SONG:
 		{
-			SOUNDMAN->StopMusic();
+			// Don't stop music if it's already playing the right file.
+//			SOUNDMAN->StopMusic();
 			m_fPlaySampleCountdown = SAMPLE_MUSIC_DELAY;
 			m_sSampleMusicToPlay = pSong->GetMusicPath();
 			m_fSampleStartSeconds = pSong->m_fMusicSampleStartSeconds;
@@ -879,6 +880,7 @@ void ScreenSelectMusic::AfterMusicChange()
 		}
 		break;
 	case TYPE_ROULETTE:
+	case TYPE_RANDOM:
 		if(!no_banner_change)
 			m_Banner.LoadRoulette();
 		m_BPMDisplay.NoBPM();
@@ -887,23 +889,18 @@ void ScreenSelectMusic::AfterMusicChange()
 
 		SOUNDMAN->StopMusic();
 		m_fPlaySampleCountdown = SAMPLE_MUSIC_DELAY;
+		switch( m_MusicWheel.GetSelectedType() )
+		{
+		case TYPE_ROULETTE:
 			m_sSampleMusicToPlay = THEME->GetPathToS("ScreenSelectMusic roulette music");
-		m_fSampleStartSeconds = -1;
-		m_fSampleLengthSeconds = -1;
-
-		m_sprBalloon.StopTweening();
-		OFF_COMMAND( m_sprBalloon );
 			break;
 		case TYPE_RANDOM:
-		if(!no_banner_change)
-			m_Banner.LoadRandom();
-		m_BPMDisplay.NoBPM();
-		m_sprCDTitleFront.UnloadTexture();
-		m_sprCDTitleBack.UnloadTexture();
-
-		SOUNDMAN->StopMusic();
-		m_fPlaySampleCountdown = SAMPLE_MUSIC_DELAY;
 			m_sSampleMusicToPlay = THEME->GetPathToS("ScreenSelectMusic random music");
+			break;
+		default:
+			ASSERT(0);
+		}
+
 		m_fSampleStartSeconds = -1;
 		m_fSampleLengthSeconds = -1;
 

stepmania/src/Song.cpp

@@ -93,8 +93,8 @@ Song::Song()
 	m_fLastBeat = -1;
 	m_SelectionDisplay = SHOW_ALWAYS;
 	m_DisplayBPMType = DISPLAY_ACTUAL;
-	m_fDisplayBPMMin = 0;
+	m_fSpecifiedBPMMin = 0;
-	m_fDisplayBPMMax = 0;
+	m_fSpecifiedBPMMax = 0;
 }
 
 Song::~Song()

stepmania/src/StepMania.vcproj

@@ -373,12 +373,6 @@ cl /Zl /nologo /c verstub.cpp /Fo"$(IntDir)"\
 			<File
 				RelativePath="ScreenPlayerOptions.h">
 			</File>
-			<File
-				RelativePath="ScreenPlayerOptions2.cpp">
-			</File>
-			<File
-				RelativePath="ScreenPlayerOptions2.h">
-			</File>
 			<File
 				RelativePath="ScreenPrompt.cpp">
 			</File>

stepmania/src/song.h

@@ -142,8 +142,8 @@ public:
 	float	m_fMusicSampleStartSeconds;
 	float	m_fMusicSampleLengthSeconds;
 	enum { DISPLAY_ACTUAL, DISPLAY_SPECIFIED, DISPLAY_RANDOM } m_DisplayBPMType;
-	float		m_fDisplayBPMMin;
+	float		m_fSpecifiedBPMMin;
-	float		m_fDisplayBPMMax;	// if a range, then Min != Max
+	float		m_fSpecifiedBPMMax;	// if a range, then Min != Max
 
 	float GetMusicStartBeat() const;
 
@@ -178,6 +178,18 @@ public:
 	void AddBackgroundChange( BackgroundChange seg );
 	void AddLyricSegment( LyricSegment seg );
 
+	void GetDisplayBPM( float &fMinBPMOut, float &fMaxBPMOut ) const
+	{
+		if( m_DisplayBPMType == DISPLAY_SPECIFIED )
+		{
+			fMinBPMOut = m_fSpecifiedBPMMin;
+			fMaxBPMOut = m_fSpecifiedBPMMax;
+		}
+		else
+		{
+			GetActualBPM( fMinBPMOut, fMaxBPMOut );
+		}
+	}
 	void GetActualBPM( float &fMinBPMOut, float &fMaxBPMOut ) const
 	{
 		fMaxBPMOut = 0;