move Song/Steps sorting into Song/StepsUtil.h/cpp
This commit is contained in:
Chris Danford
@@ -0,0 +1,370 @@
|
||||
#include "global.h"
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
Class: SongUtil
|
||||
|
||||
Desc: See header.
|
||||
|
||||
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
||||
Chris Danford
|
||||
Glenn Maynard
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "SongUtil.h"
|
||||
#include "song.h"
|
||||
#include "Steps.h"
|
||||
#include "GameState.h"
|
||||
#include "StyleDef.h"
|
||||
#include "ProfileManager.h"
|
||||
#include "PrefsManager.h"
|
||||
#include "SongManager.h"
|
||||
|
||||
|
||||
/////////////////////////////////////
|
||||
// Sorting
|
||||
/////////////////////////////////////
|
||||
|
||||
/* Just calculating GetNumTimesPlayed within the sort is pretty slow, so let's precompute
|
||||
* it. (This could be generalized with a template.) */
|
||||
map<const Song*, CString> song_sort_val;
|
||||
|
||||
bool CompareSongPointersBySortValueAscending(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
return song_sort_val[pSong1] < song_sort_val[pSong2];
|
||||
}
|
||||
|
||||
bool CompareSongPointersBySortValueDescending(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
return song_sort_val[pSong1] > song_sort_val[pSong2];
|
||||
}
|
||||
|
||||
|
||||
CString SongUtil::MakeSortString( CString s )
|
||||
{
|
||||
s.MakeUpper();
|
||||
|
||||
// Make sure that non-alphanumeric characters are placed at the very end
|
||||
if( s.size() > 0 )
|
||||
{
|
||||
if( s[0] == '.' ) // ".59"
|
||||
s.erase(s.begin());
|
||||
if( (s[0] < 'A' || s[0] > 'Z') && (s[0] < '0' || s[0] > '9') )
|
||||
s = char(126) + s;
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
bool CompareSongPointersByTitle(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
// Prefer transliterations to full titles
|
||||
CString s1 = pSong1->GetTranslitMainTitle();
|
||||
CString s2 = pSong2->GetTranslitMainTitle();
|
||||
if( s1 == s2 )
|
||||
{
|
||||
s1 = pSong1->GetTranslitSubTitle();
|
||||
s2 = pSong2->GetTranslitSubTitle();
|
||||
}
|
||||
|
||||
s1 = SongUtil::MakeSortString(s1);
|
||||
s2 = SongUtil::MakeSortString(s2);
|
||||
|
||||
int ret = s1.CompareNoCase( s2 );
|
||||
if(ret < 0) return true;
|
||||
if(ret > 0) return false;
|
||||
|
||||
/* The titles are the same. Ensure we get a consistent ordering
|
||||
* by comparing the unique SongFilePaths. */
|
||||
return pSong1->GetSongFilePath().CompareNoCase(pSong2->GetSongFilePath()) < 0;
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByTitle( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersByTitle );
|
||||
}
|
||||
|
||||
static int GetSongSortDifficulty(const Song *pSong)
|
||||
{
|
||||
vector<Steps*> aNotes;
|
||||
pSong->GetSteps( aNotes, GAMESTATE->GetCurrentStyleDef()->m_StepsType );
|
||||
|
||||
/* Sort by the first difficulty found in the following order: */
|
||||
const Difficulty d[] = { DIFFICULTY_EASY, DIFFICULTY_MEDIUM, DIFFICULTY_HARD,
|
||||
DIFFICULTY_CHALLENGE, DIFFICULTY_INVALID };
|
||||
|
||||
for(int i = 0; d[i] != DIFFICULTY_INVALID; ++i)
|
||||
{
|
||||
for( unsigned j = 0; j < aNotes.size(); ++j)
|
||||
{
|
||||
if(aNotes[j]->GetDifficulty() != d[i])
|
||||
continue;
|
||||
|
||||
return aNotes[j]->GetMeter();
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByDifficulty( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
for( unsigned i = 0; i < arraySongPointers.size(); ++i )
|
||||
song_sort_val[arraySongPointers[i]] =
|
||||
ssprintf("%9i", GetSongSortDifficulty(arraySongPointers[i]));
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersBySortValueAscending );
|
||||
}
|
||||
|
||||
bool CompareSongPointersByBPM(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
float fMinBPM1, fMaxBPM1, fMinBPM2, fMaxBPM2;
|
||||
pSong1->GetDisplayBPM( fMinBPM1, fMaxBPM1 );
|
||||
pSong2->GetDisplayBPM( fMinBPM2, fMaxBPM2 );
|
||||
|
||||
if( fMaxBPM1 < fMaxBPM2 )
|
||||
return true;
|
||||
if( fMaxBPM1 > fMaxBPM2 )
|
||||
return false;
|
||||
|
||||
return CompareCStringsAsc( pSong1->GetSongFilePath(), pSong2->GetSongFilePath() );
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByBPM( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersByBPM );
|
||||
}
|
||||
|
||||
void AppendOctal( int n, int digits, CString &out )
|
||||
{
|
||||
for( int p = digits-1; p >= 0; --p )
|
||||
{
|
||||
const int shift = p*3;
|
||||
int n2 = (n >> shift) & 0x7;
|
||||
out.insert( out.end(), (char) (n2+'0') );
|
||||
}
|
||||
}
|
||||
|
||||
bool CompDescending( const pair<Song *, CString> &a, const pair<Song *, CString> &b )
|
||||
{ return a.second > b.second; }
|
||||
|
||||
void SongUtil::SortSongPointerArrayByGrade( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
/* Optimize by pre-writing a string to compare, since doing GetNumNotesWithGrade
|
||||
* inside the sort is too slow. */
|
||||
typedef pair< Song *, CString > val;
|
||||
vector<val> vals;
|
||||
vals.reserve( arraySongPointers.size() );
|
||||
|
||||
unsigned i;
|
||||
for( i = 0; i < arraySongPointers.size(); ++i )
|
||||
{
|
||||
Song *pSong = arraySongPointers[i];
|
||||
|
||||
CString foo;
|
||||
foo.reserve(256);
|
||||
for( int g=GRADE_TIER_1; g<=GRADE_NO_DATA; ++g )
|
||||
{
|
||||
int n = pSong->GetNumNotesWithGrade( (Grade)g );
|
||||
AppendOctal( n, 3, foo );
|
||||
}
|
||||
vals.push_back( val(pSong, foo) );
|
||||
}
|
||||
|
||||
sort( vals.begin(), vals.end(), CompDescending );
|
||||
|
||||
for( i = 0; i < arraySongPointers.size(); ++i )
|
||||
arraySongPointers[i] = vals[i].first;
|
||||
}
|
||||
|
||||
|
||||
void SongUtil::SortSongPointerArrayByArtist( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
for( unsigned i = 0; i < arraySongPointers.size(); ++i )
|
||||
song_sort_val[arraySongPointers[i]] = MakeSortString( arraySongPointers[i]->GetTranslitArtist() );
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersBySortValueAscending );
|
||||
}
|
||||
|
||||
static int CompareSongPointersByGroup(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
return pSong1->m_sGroupName < pSong2->m_sGroupName;
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByGroupAndDifficulty( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
SortSongPointerArrayByDifficulty( arraySongPointers );
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersByGroup );
|
||||
}
|
||||
|
||||
int CompareSongPointersByGroupAndTitle(const Song *pSong1, const Song *pSong2)
|
||||
{
|
||||
const CString &sGroup1 = pSong1->m_sGroupName;
|
||||
const CString &sGroup2 = pSong2->m_sGroupName;
|
||||
|
||||
if( sGroup1 < sGroup2 )
|
||||
return true;
|
||||
if( sGroup1 > sGroup2 )
|
||||
return false;
|
||||
|
||||
/* Same group; compare by name. */
|
||||
return CompareSongPointersByTitle( pSong1, pSong2 );
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByGroupAndTitle( vector<Song*> &arraySongPointers )
|
||||
{
|
||||
sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersByGroupAndTitle );
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByNumPlays( vector<Song*> &arraySongPointers, ProfileSlot slot, bool bDescending )
|
||||
{
|
||||
Profile* pProfile = PROFILEMAN->GetProfile(slot);
|
||||
if( pProfile == NULL )
|
||||
return; // nothing to do since we don't have data
|
||||
SortSongPointerArrayByNumPlays( arraySongPointers, pProfile, bDescending );
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByNumPlays( vector<Song*> &arraySongPointers, const Profile* pProfile, bool bDescending )
|
||||
{
|
||||
ASSERT( pProfile );
|
||||
for(unsigned i = 0; i < arraySongPointers.size(); ++i)
|
||||
song_sort_val[arraySongPointers[i]] = ssprintf("%9i", pProfile->GetSongNumTimesPlayed(arraySongPointers[i]));
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), bDescending ? CompareSongPointersBySortValueDescending : CompareSongPointersBySortValueAscending );
|
||||
song_sort_val.clear();
|
||||
}
|
||||
|
||||
CString SongUtil::GetSectionNameFromSongAndSort( const Song* pSong, SortOrder so )
|
||||
{
|
||||
if( pSong == NULL )
|
||||
return "";
|
||||
|
||||
switch( so )
|
||||
{
|
||||
case SORT_PREFERRED:
|
||||
return "";
|
||||
case SORT_GROUP:
|
||||
return pSong->m_sGroupName;
|
||||
case SORT_TITLE:
|
||||
case SORT_ARTIST:
|
||||
{
|
||||
CString s;
|
||||
switch( so )
|
||||
{
|
||||
case SORT_TITLE: s = pSong->GetTranslitMainTitle(); break;
|
||||
case SORT_ARTIST: s = pSong->GetTranslitArtist(); break;
|
||||
default: ASSERT(0);
|
||||
}
|
||||
s = MakeSortString(s); // resulting string will be uppercase
|
||||
|
||||
if( s.empty() )
|
||||
return "";
|
||||
else if( s[0] >= '0' && s[0] <= '9' )
|
||||
return "NUM";
|
||||
else if( s[0] < 'A' || s[0] > 'Z')
|
||||
return "OTHER";
|
||||
else
|
||||
return s.Left(1);
|
||||
}
|
||||
case SORT_BPM:
|
||||
{
|
||||
const int iBPMGroupSize = 20;
|
||||
float fMinBPM, fMaxBPM;
|
||||
pSong->GetDisplayBPM( fMinBPM, fMaxBPM );
|
||||
int iMaxBPM = (int)fMaxBPM;
|
||||
iMaxBPM += iBPMGroupSize - (iMaxBPM%iBPMGroupSize) - 1;
|
||||
return ssprintf("%03d-%03d",iMaxBPM-(iBPMGroupSize-1), iMaxBPM);
|
||||
}
|
||||
case SORT_MOST_PLAYED:
|
||||
return "";
|
||||
case SORT_GRADE:
|
||||
{
|
||||
for( int i=GRADE_TIER_1; i<NUM_GRADES; ++i )
|
||||
{
|
||||
Grade g = (Grade)i;
|
||||
int iCount = pSong->GetNumNotesWithGrade( g );
|
||||
if( iCount > 0 )
|
||||
return ssprintf( "%4s x %d", GradeToThemedString(g).c_str(), iCount );
|
||||
}
|
||||
return GradeToThemedString( GRADE_NO_DATA );
|
||||
}
|
||||
case SORT_EASY_METER:
|
||||
{
|
||||
Steps* pNotes = pSong->GetStepsByDifficulty(GAMESTATE->GetCurrentStyleDef()->m_StepsType,DIFFICULTY_EASY);
|
||||
if( pNotes )
|
||||
return ssprintf("%02d", pNotes->GetMeter() );
|
||||
return "N/A";
|
||||
}
|
||||
case SORT_MEDIUM_METER:
|
||||
{
|
||||
Steps* pNotes = pSong->GetStepsByDifficulty(GAMESTATE->GetCurrentStyleDef()->m_StepsType,DIFFICULTY_MEDIUM);
|
||||
if( pNotes )
|
||||
return ssprintf("%02d", pNotes->GetMeter() );
|
||||
return "N/A";
|
||||
}
|
||||
case SORT_HARD_METER:
|
||||
{
|
||||
Steps* pNotes = pSong->GetStepsByDifficulty(GAMESTATE->GetCurrentStyleDef()->m_StepsType,DIFFICULTY_HARD);
|
||||
if( pNotes )
|
||||
return ssprintf("%02d", pNotes->GetMeter() );
|
||||
return "N/A";
|
||||
}
|
||||
case SORT_CHALLENGE_METER:
|
||||
{
|
||||
Steps* pNotes = pSong->GetStepsByDifficulty(GAMESTATE->GetCurrentStyleDef()->m_StepsType,DIFFICULTY_CHALLENGE);
|
||||
if( pNotes )
|
||||
return ssprintf("%02d", pNotes->GetMeter() );
|
||||
return "N/A";
|
||||
}
|
||||
case SORT_SORT_MENU:
|
||||
case SORT_MODE_MENU:
|
||||
return "";
|
||||
case SORT_ALL_COURSES:
|
||||
case SORT_NONSTOP_COURSES:
|
||||
case SORT_ONI_COURSES:
|
||||
case SORT_ENDLESS_COURSES:
|
||||
default:
|
||||
ASSERT(0);
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayBySectionName( vector<Song*> &arraySongPointers, SortOrder so )
|
||||
{
|
||||
for(unsigned i = 0; i < arraySongPointers.size(); ++i)
|
||||
{
|
||||
CString val = GetSectionNameFromSongAndSort( arraySongPointers[i], so );
|
||||
|
||||
/* Make sure NUM comes first and OTHER comes last. */
|
||||
if( val == "NUM" ) val = "0";
|
||||
else if( val == "OTHER" ) val = "2";
|
||||
else val = "1" + val;
|
||||
|
||||
song_sort_val[arraySongPointers[i]] = val;
|
||||
}
|
||||
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersBySortValueAscending );
|
||||
song_sort_val.clear();
|
||||
}
|
||||
|
||||
void SongUtil::SortSongPointerArrayByMeter( vector<Song*> &arraySongPointers, Difficulty dc )
|
||||
{
|
||||
song_sort_val.clear();
|
||||
for(unsigned i = 0; i < arraySongPointers.size(); ++i)
|
||||
{
|
||||
Steps* pNotes = arraySongPointers[i]->GetStepsByDifficulty( GAMESTATE->GetCurrentStyleDef()->m_StepsType, dc );
|
||||
song_sort_val[arraySongPointers[i]] = ssprintf("%i", pNotes ? pNotes->GetMeter() : 0);
|
||||
}
|
||||
stable_sort( arraySongPointers.begin(), arraySongPointers.end(), CompareSongPointersBySortValueAscending );
|
||||
}
|
||||
|
||||
|
||||
void SongID::FromSong( const Song *p )
|
||||
{
|
||||
if( p )
|
||||
sDir = p->GetSongDir();
|
||||
else
|
||||
sDir = "";
|
||||
}
|
||||
|
||||
Song *SongID::ToSong() const
|
||||
{
|
||||
return SONGMAN->GetSongFromDir( sDir );
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
#ifndef SONGUTIL_H
|
||||
#define SONGUTIL_H
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
Class: SongUtil
|
||||
|
||||
Desc: Utility functions that deal with Song.
|
||||
|
||||
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
||||
Chris Danford
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "GameConstantsAndTypes.h"
|
||||
|
||||
class Song;
|
||||
class Profile;
|
||||
|
||||
namespace SongUtil
|
||||
{
|
||||
CString MakeSortString( CString s );
|
||||
void SortSongPointerArrayByDifficulty( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByTitle( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByBPM( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByGrade( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByArtist( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByGroupAndDifficulty( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByGroupAndTitle( vector<Song*> &arraySongPointers );
|
||||
void SortSongPointerArrayByNumPlays( vector<Song*> &arraySongPointers, ProfileSlot slot, bool bDescending );
|
||||
void SortSongPointerArrayByNumPlays( vector<Song*> &arraySongPointers, const Profile* pProfile, bool bDescending );
|
||||
void SortSongPointerArrayByMeter( vector<Song*> &arraySongPointers, Difficulty dc );
|
||||
CString GetSectionNameFromSongAndSort( const Song* pSong, SortOrder so );
|
||||
void SortSongPointerArrayBySectionName( vector<Song*> &arraySongPointers, SortOrder so );
|
||||
}
|
||||
|
||||
class SongID
|
||||
{
|
||||
CString sDir;
|
||||
|
||||
public:
|
||||
SongID() { FromSong(NULL); }
|
||||
void FromSong( const Song *p );
|
||||
Song *ToSong() const;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,136 @@
|
||||
#include "global.h"
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
Class: StepsUtil
|
||||
|
||||
Desc: See header.
|
||||
|
||||
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
||||
Chris Danford
|
||||
Glenn Maynard
|
||||
David Wilson
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "StepsUtil.h"
|
||||
#include "Steps.h"
|
||||
#include "ProfileManager.h"
|
||||
#include "song.h"
|
||||
|
||||
//
|
||||
// Sorting stuff
|
||||
//
|
||||
map<const Steps*, CString> steps_sort_val;
|
||||
|
||||
bool CompareStepsPointersBySortValueAscending(const Steps *pSteps1, const Steps *pSteps2)
|
||||
{
|
||||
return steps_sort_val[pSteps1] < steps_sort_val[pSteps2];
|
||||
}
|
||||
|
||||
bool CompareStepsPointersBySortValueDescending(const Steps *pSteps1, const Steps *pSteps2)
|
||||
{
|
||||
return steps_sort_val[pSteps1] > steps_sort_val[pSteps2];
|
||||
}
|
||||
|
||||
void StepsUtil::SortStepsPointerArrayByNumPlays( vector<Steps*> &vStepsPointers, ProfileSlot slot, bool bDescending )
|
||||
{
|
||||
Profile* pProfile = PROFILEMAN->GetProfile(slot);
|
||||
if( pProfile == NULL )
|
||||
return; // nothing to do since we don't have data
|
||||
SortStepsPointerArrayByNumPlays( vStepsPointers, pProfile, bDescending );
|
||||
}
|
||||
|
||||
void StepsUtil::SortStepsPointerArrayByNumPlays( vector<Steps*> &vStepsPointers, const Profile* pProfile, bool bDecending )
|
||||
{
|
||||
ASSERT( pProfile );
|
||||
for(unsigned i = 0; i < vStepsPointers.size(); ++i)
|
||||
steps_sort_val[vStepsPointers[i]] = ssprintf("%9i", pProfile->GetStepsNumTimesPlayed(vStepsPointers[i]));
|
||||
stable_sort( vStepsPointers.begin(), vStepsPointers.end(), bDecending ? CompareStepsPointersBySortValueDescending : CompareStepsPointersBySortValueAscending );
|
||||
steps_sort_val.clear();
|
||||
}
|
||||
|
||||
bool StepsUtil::CompareNotesPointersByRadarValues(const Steps* pNotes1, const Steps* pNotes2)
|
||||
{
|
||||
float fScore1 = 0;
|
||||
float fScore2 = 0;
|
||||
|
||||
for( int r=0; r<NUM_RADAR_CATEGORIES; r++ )
|
||||
{
|
||||
fScore1 += pNotes1->GetRadarValues()[r];
|
||||
fScore2 += pNotes2->GetRadarValues()[r];
|
||||
}
|
||||
|
||||
return fScore1 < fScore2;
|
||||
}
|
||||
|
||||
bool StepsUtil::CompareNotesPointersByMeter(const Steps *pNotes1, const Steps* pNotes2)
|
||||
{
|
||||
return pNotes1->GetMeter() < pNotes2->GetMeter();
|
||||
}
|
||||
|
||||
bool StepsUtil::CompareNotesPointersByDifficulty(const Steps *pNotes1, const Steps *pNotes2)
|
||||
{
|
||||
return pNotes1->GetDifficulty() < pNotes2->GetDifficulty();
|
||||
}
|
||||
|
||||
void StepsUtil::SortNotesArrayByDifficulty( vector<Steps*> &arraySteps )
|
||||
{
|
||||
/* Sort in reverse order of priority. */
|
||||
stable_sort( arraySteps.begin(), arraySteps.end(), CompareNotesPointersByRadarValues );
|
||||
stable_sort( arraySteps.begin(), arraySteps.end(), CompareNotesPointersByMeter );
|
||||
stable_sort( arraySteps.begin(), arraySteps.end(), CompareNotesPointersByDifficulty );
|
||||
}
|
||||
|
||||
bool StepsUtil::CompareStepsPointersByTypeAndDifficulty(const Steps *pStep1, const Steps *pStep2)
|
||||
{
|
||||
if( pStep1->m_StepsType < pStep2->m_StepsType )
|
||||
return true;
|
||||
if( pStep1->m_StepsType > pStep2->m_StepsType )
|
||||
return false;
|
||||
return pStep1->GetDifficulty() < pStep2->GetDifficulty();
|
||||
}
|
||||
|
||||
void StepsUtil::SortStepsByTypeAndDifficulty( vector<Steps*> &arraySongPointers )
|
||||
{
|
||||
sort( arraySongPointers.begin(), arraySongPointers.end(), CompareStepsPointersByTypeAndDifficulty );
|
||||
}
|
||||
|
||||
void StepsID::FromSteps( const Steps *p )
|
||||
{
|
||||
if( p == NULL )
|
||||
{
|
||||
st = STEPS_TYPE_INVALID;
|
||||
dc = DIFFICULTY_INVALID;
|
||||
sDescription = "";
|
||||
}
|
||||
else
|
||||
{
|
||||
st = p->m_StepsType;
|
||||
dc = p->GetDifficulty();
|
||||
sDescription = p->GetDescription();
|
||||
}
|
||||
}
|
||||
|
||||
/* XXX: Don't allow duplicate edit descriptions, and don't allow edit descriptions
|
||||
* to be difficulty names (eg. "Hard"). If we do that, this will be completely unambiguous.
|
||||
*
|
||||
* XXX: Unless two memcards are inserted and there's overlap in the names. In that
|
||||
* case, maybe both edits should be renamed to "Pn: foo"; as long as we don't write
|
||||
* them back out (which we don't do except in the editor), it won't be permanent.
|
||||
* We could do this during the actual Steps::GetID() call, instead, but then it'd have
|
||||
* to have access to Song::m_LoadedFromProfile. */
|
||||
Steps *StepsID::ToSteps( const Song *p, bool bAllowNull ) const
|
||||
{
|
||||
if( st == STEPS_TYPE_INVALID || dc == DIFFICULTY_INVALID || sDescription.empty() )
|
||||
return NULL;
|
||||
|
||||
vector<Steps*> vNotes;
|
||||
p->GetSteps( vNotes, st, dc, -1, -1, sDescription, true );
|
||||
if( !vNotes.empty() )
|
||||
return vNotes[0];
|
||||
if( bAllowNull )
|
||||
return NULL;
|
||||
RageException::Throw( "%i, %i, \"%s\"", st, dc, sDescription.c_str() );
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
#ifndef STEPSUTIL_H
|
||||
#define STEPSUTIL_H
|
||||
/*
|
||||
-----------------------------------------------------------------------------
|
||||
Class: StepsUtil
|
||||
|
||||
Desc: Holds note information for a Song. A Song may have one or more Notess.
|
||||
A Steps can be played by one or more Styles. See StyleDef.h for more info on
|
||||
Styles.
|
||||
|
||||
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
||||
Chris Danford
|
||||
-----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#include "GameConstantsAndTypes.h"
|
||||
|
||||
class Steps;
|
||||
class Song;
|
||||
class Profile;
|
||||
|
||||
namespace StepsUtil
|
||||
{
|
||||
bool CompareNotesPointersByRadarValues(const Steps* pNotes1, const Steps* pNotes2);
|
||||
bool CompareNotesPointersByMeter(const Steps *pNotes1, const Steps* pNotes2);
|
||||
bool CompareNotesPointersByDifficulty(const Steps *pNotes1, const Steps *pNotes2);
|
||||
void SortNotesArrayByDifficulty( vector<Steps*> &arrayNotess );
|
||||
bool CompareStepsPointersByTypeAndDifficulty(const Steps *pStep1, const Steps *pStep2);
|
||||
void SortStepsByTypeAndDifficulty( vector<Steps*> &arraySongPointers );
|
||||
void SortStepsPointerArrayByNumPlays( vector<Steps*> &vStepsPointers, ProfileSlot slot, bool bDescending );
|
||||
void SortStepsPointerArrayByNumPlays( vector<Steps*> &vStepsPointers, const Profile* pProfile, bool bDescending );
|
||||
};
|
||||
|
||||
class StepsID
|
||||
{
|
||||
StepsType st;
|
||||
Difficulty dc;
|
||||
CString sDescription;
|
||||
|
||||
public:
|
||||
StepsID() { FromSteps(NULL); }
|
||||
void FromSteps( const Steps *p );
|
||||
Steps *ToSteps( const Song *p, bool bAllowNull ) const;
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user