Chris Danford
566 lines
18 KiB
C++
566 lines
18 KiB
C++
#include "global.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: ScreenPlayerOptions
|
|
|
|
Desc: Select a song.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "ScreenPlayerOptions.h"
|
|
#include "RageUtil.h"
|
|
#include "ScreenManager.h"
|
|
#include "RageLog.h"
|
|
#include "GameState.h"
|
|
#include "ThemeManager.h"
|
|
#include "AnnouncerManager.h"
|
|
#include "RageSounds.h"
|
|
#include "NoteSkinManager.h"
|
|
#include "NoteFieldPositioning.h"
|
|
#include "ScreenSongOptions.h"
|
|
#include "Character.h"
|
|
#include "Steps.h"
|
|
#include "Course.h"
|
|
|
|
#define PREV_SCREEN( play_mode ) THEME->GetMetric ("ScreenPlayerOptions","PrevScreen"+Capitalize(PlayModeToString(play_mode)))
|
|
#define NEXT_SCREEN( play_mode ) THEME->GetMetric ("ScreenPlayerOptions","NextScreen"+Capitalize(PlayModeToString(play_mode)))
|
|
#define BEGINNER_DESCRIPTION THEME->GetMetric ("ScreenPlayerOptions","Beginner")
|
|
#define EASY_DESCRIPTION THEME->GetMetric ("ScreenPlayerOptions","Easy")
|
|
#define MEDIUM_DESCRIPTION THEME->GetMetric ("ScreenPlayerOptions","Medium")
|
|
#define HARD_DESCRIPTION THEME->GetMetric ("ScreenPlayerOptions","Hard")
|
|
#define CHALLENGE_DESCRIPTION THEME->GetMetric ("ScreenPlayerOptions","Challenge")
|
|
|
|
|
|
enum {
|
|
PO_SPEED = 0,
|
|
PO_ACCEL,
|
|
PO_EFFECT,
|
|
PO_APPEAR,
|
|
PO_TURN,
|
|
PO_TRANSFORM,
|
|
PO_SCROLL,
|
|
PO_NOTE_SKIN,
|
|
PO_HOLD_NOTES,
|
|
PO_HIDE,
|
|
PO_PERSPECTIVE,
|
|
PO_STEP,
|
|
PO_CHARACTER,
|
|
|
|
NUM_PLAYER_OPTIONS_LINES
|
|
};
|
|
OptionRow g_PlayerOptionsLines[NUM_PLAYER_OPTIONS_LINES] = {
|
|
OptionRow( "Speed", false, "x0.25","x0.5","x0.75","x1","x1.5","x2","x3","x5","x8","C200", "?" ),
|
|
OptionRow( "Acceler\n-ation", false, "OFF","BOOST","BRAKE","WAVE","EXPAND","BOOMERANG" ),
|
|
OptionRow( "Effect", false, "OFF","DRUNK","DIZZY","MINI","FLIP","TORNADO","TIPSY" ),
|
|
OptionRow( "Appear\n-ance", false, "VISIBLE","HIDDEN","SUDDEN","STEALTH","BLINK", "R.VANISH" ),
|
|
OptionRow( "Turn", false, "OFF","MIRROR","LEFT","RIGHT","SHUFFLE","S.SHUFFLE" ),
|
|
OptionRow( "Trans\n-form", false, "OFF","LITTLE","WIDE","BIG","QUICK","SKIPPY","MINES" ),
|
|
OptionRow( "Scroll", false, "STANDARD","REVERSE","SPLIT","ALTERNATE" ),
|
|
OptionRow( "Note\nSkin", false, "" ),
|
|
OptionRow( "Holds", false, "OFF","ON" ),
|
|
OptionRow( "Hide", false, "OFF","DARK","BLIND"),
|
|
OptionRow( "Perspec\n-tive", false, "" ),
|
|
OptionRow( "Step", false, "" ),
|
|
OptionRow( "Charac\n-ter", false, "" ),
|
|
};
|
|
|
|
static const PlayerOptions::Effect ChoosableEffects[] =
|
|
{
|
|
PlayerOptions::EFFECT_DRUNK,
|
|
PlayerOptions::EFFECT_DIZZY,
|
|
PlayerOptions::EFFECT_MINI,
|
|
PlayerOptions::EFFECT_FLIP,
|
|
PlayerOptions::EFFECT_TORNADO,
|
|
PlayerOptions::EFFECT_TIPSY,
|
|
PlayerOptions::NUM_EFFECTS
|
|
};
|
|
|
|
ScreenPlayerOptions::ScreenPlayerOptions() :
|
|
ScreenOptions("ScreenPlayerOptions",true)
|
|
{
|
|
LOG->Trace( "ScreenPlayerOptions::ScreenPlayerOptions()" );
|
|
|
|
Init(
|
|
INPUTMODE_INDIVIDUAL,
|
|
g_PlayerOptionsLines,
|
|
NUM_PLAYER_OPTIONS_LINES,
|
|
false );
|
|
|
|
/* If we're going to "press start for more options" or skipping options
|
|
* entirely, we need a different fade out. XXX: this is a hack */
|
|
if(PREFSMAN->m_ShowSongOptions == PrefsManager::NO)
|
|
m_Menu.m_Out.Load( THEME->GetPathToB("ScreenPlayerOptions direct out") ); /* direct to stage */
|
|
else if(PREFSMAN->m_ShowSongOptions == PrefsManager::ASK)
|
|
m_Menu.m_Out.Load( THEME->GetPathToB("ScreenPlayerOptions option out") ); /* optional song options */
|
|
|
|
m_sprOptionsMessage.Load( THEME->GetPathToG("ScreenPlayerOptions options") );
|
|
m_sprOptionsMessage.StopAnimating();
|
|
m_sprOptionsMessage.SetXY( CENTER_X, CENTER_Y );
|
|
m_sprOptionsMessage.SetZoom( 1 );
|
|
m_sprOptionsMessage.SetDiffuse( RageColor(1,1,1,0) );
|
|
//this->AddChild( &m_sprOptionsMessage ); // we have to draw this manually over the top of transitions
|
|
|
|
m_bAcceptedChoices = false;
|
|
m_bGoToOptions = ( PREFSMAN->m_ShowSongOptions == PrefsManager::YES );
|
|
|
|
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("player options intro") );
|
|
}
|
|
|
|
|
|
void ScreenPlayerOptions::ImportOptions()
|
|
{
|
|
// fill in difficulty names
|
|
m_OptionRow[PO_STEP].choices.clear();
|
|
if( GAMESTATE->m_bEditing )
|
|
{
|
|
m_OptionRow[PO_STEP].choices.push_back( "" );
|
|
}
|
|
else if( GAMESTATE->m_pCurCourse ) // playing a course
|
|
{
|
|
m_OptionRow[PO_STEP].choices.push_back( "REGULAR" );
|
|
if( GAMESTATE->m_pCurCourse->HasDifficult( GAMESTATE->GetCurrentStyleDef()->m_StepsType ) )
|
|
m_OptionRow[PO_STEP].choices.push_back( "DIFFICULT" );
|
|
}
|
|
else if( GAMESTATE->m_pCurSong ) // playing a song
|
|
{
|
|
vector<Steps*> vNotes;
|
|
GAMESTATE->m_pCurSong->GetSteps( vNotes, GAMESTATE->GetCurrentStyleDef()->m_StepsType );
|
|
SortNotesArrayByDifficulty( vNotes );
|
|
for( unsigned i=0; i<vNotes.size(); i++ )
|
|
{
|
|
CString s = vNotes[i]->GetDescription();
|
|
s.MakeUpper();
|
|
|
|
// convert to theme-defined values
|
|
s = ConvertParamToThemeDifficulty(s);
|
|
|
|
m_OptionRow[PO_STEP].choices.push_back( s );
|
|
}
|
|
}
|
|
|
|
//
|
|
// fill in skin names
|
|
//
|
|
CStringArray arraySkinNames;
|
|
NOTESKIN->GetNoteSkinNames( arraySkinNames );
|
|
|
|
m_OptionRow[PO_NOTE_SKIN].choices.clear();
|
|
|
|
unsigned i;
|
|
for( i=0; i<arraySkinNames.size(); i++ )
|
|
{
|
|
arraySkinNames[i].MakeUpper();
|
|
m_OptionRow[PO_NOTE_SKIN].choices.push_back( arraySkinNames[i] );
|
|
}
|
|
|
|
m_OptionRow[PO_PERSPECTIVE].choices.clear();
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( "INCOMING" );
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( "OVERHEAD" );
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( "SPACE" );
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( "HALLWAY" );
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( "DISTANT" );
|
|
|
|
CStringArray arrayPosNames;
|
|
GAMESTATE->m_pPosition->GetNamesForCurrentGame(arrayPosNames);
|
|
for( i=0; i<arrayPosNames.size(); i++ )
|
|
{
|
|
arrayPosNames[i].MakeUpper();
|
|
m_OptionRow[PO_PERSPECTIVE].choices.push_back( arrayPosNames[i] );
|
|
}
|
|
|
|
//
|
|
// fill in character names
|
|
//
|
|
m_OptionRow[PO_CHARACTER].choices.clear();
|
|
m_OptionRow[PO_CHARACTER].choices.push_back( "OFF" );
|
|
vector<Character*> apCharacters;
|
|
GAMESTATE->GetCharacters( apCharacters );
|
|
for( i=0; i<apCharacters.size(); i++ )
|
|
{
|
|
CString s = apCharacters[i]->m_sName;
|
|
s.MakeUpper();
|
|
m_OptionRow[PO_CHARACTER].choices.push_back( s );
|
|
}
|
|
|
|
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
PlayerOptions &po = GAMESTATE->m_PlayerOptions[p];
|
|
|
|
if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 0.25f ) m_iSelectedOption[p][PO_SPEED] = 0;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 0.5f ) m_iSelectedOption[p][PO_SPEED] = 1;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 0.75f ) m_iSelectedOption[p][PO_SPEED] = 2;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 1.0f ) m_iSelectedOption[p][PO_SPEED] = 3;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 1.5f ) m_iSelectedOption[p][PO_SPEED] = 4;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 2.0f ) m_iSelectedOption[p][PO_SPEED] = 5;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 3.0f ) m_iSelectedOption[p][PO_SPEED] = 6;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 5.0f ) m_iSelectedOption[p][PO_SPEED] = 7;
|
|
else if( !po.m_bTimeSpacing && po.m_fScrollSpeed == 8.0f ) m_iSelectedOption[p][PO_SPEED] = 8;
|
|
else if( po.m_bTimeSpacing && po.m_fScrollBPM == 200 ) m_iSelectedOption[p][PO_SPEED] = 9;
|
|
|
|
// removed so all of them still fit on line
|
|
// else if( po.m_bTimeSpacing && po.m_fScrollBPM == 300 ) m_iSelectedOption[p][PO_SPEED] = 10;
|
|
|
|
else if( po.m_bTimeSpacing == IsModTimeSpacing( PREFSMAN->m_sCustomSpeedMod )
|
|
&& (po.m_fScrollBPM == ConvertModToNumber( PREFSMAN->m_sCustomSpeedMod)
|
|
|| po.m_fScrollSpeed == ConvertModToNumber( PREFSMAN->m_sCustomSpeedMod ) ) )
|
|
m_iSelectedOption[p][PO_SPEED] = 10;
|
|
else m_iSelectedOption[p][PO_SPEED] = 3;
|
|
|
|
m_iSelectedOption[p][PO_ACCEL] = po.GetFirstAccel()+1;
|
|
|
|
const PlayerOptions::Effect e = po.GetFirstEffect();
|
|
m_iSelectedOption[p][PO_EFFECT] = 0;
|
|
for( i = 0; ChoosableEffects[i] != PlayerOptions::NUM_EFFECTS; ++i )
|
|
if( ChoosableEffects[i] == e )
|
|
m_iSelectedOption[p][PO_EFFECT] = i+1;
|
|
|
|
// m_iSelectedOption[p][PO_EFFECT] = po.GetFirstEffect()+1;
|
|
m_iSelectedOption[p][PO_APPEAR] = po.GetFirstAppearance()+1;
|
|
m_iSelectedOption[p][PO_TURN] = po.m_Turn;
|
|
m_iSelectedOption[p][PO_TRANSFORM] = po.m_Transform;
|
|
m_iSelectedOption[p][PO_SCROLL] = po.GetFirstScroll()+1;
|
|
|
|
|
|
// highlight currently selected skin
|
|
m_iSelectedOption[p][PO_NOTE_SKIN] = -1;
|
|
for( unsigned j=0; j<m_OptionRow[PO_NOTE_SKIN].choices.size(); j++ )
|
|
{
|
|
if( 0==stricmp(m_OptionRow[PO_NOTE_SKIN].choices[j], po.m_sNoteSkin) )
|
|
{
|
|
m_iSelectedOption[p][PO_NOTE_SKIN] = j;
|
|
break;
|
|
}
|
|
}
|
|
if( m_iSelectedOption[p][PO_NOTE_SKIN] == -1 )
|
|
m_iSelectedOption[p][PO_NOTE_SKIN] = 0;
|
|
|
|
|
|
m_iSelectedOption[p][PO_HOLD_NOTES] = po.m_bHoldNotes ? 1 : 0;
|
|
m_iSelectedOption[p][PO_HIDE] = po.m_fBlind ? 2 : (po.m_fDark ? 1 : 0);
|
|
|
|
|
|
if( GAMESTATE->m_bEditing )
|
|
{
|
|
m_iSelectedOption[p][PO_STEP] = 0;
|
|
}
|
|
else if( GAMESTATE->m_pCurCourse ) // playing a course
|
|
{
|
|
// support for difficult on one side and normal on other is not supported
|
|
// force same choice on both sides
|
|
g_PlayerOptionsLines[PO_STEP].bOneChoiceForAllPlayers = true;
|
|
|
|
if( GAMESTATE->m_bDifficultCourses &&
|
|
GAMESTATE->m_pCurCourse->HasDifficult( GAMESTATE->GetCurrentStyleDef()->m_StepsType ) )
|
|
m_iSelectedOption[p][PO_STEP] = 1;
|
|
else
|
|
m_iSelectedOption[p][PO_STEP] = 0;
|
|
}
|
|
else if( GAMESTATE->m_pCurSong ) // playing a song
|
|
{
|
|
vector<Steps*> vNotes;
|
|
GAMESTATE->m_pCurSong->GetSteps( vNotes, GAMESTATE->GetCurrentStyleDef()->m_StepsType );
|
|
SortNotesArrayByDifficulty( vNotes );
|
|
for( unsigned i=0; i<vNotes.size(); i++ )
|
|
{
|
|
if( GAMESTATE->m_pCurNotes[p] == vNotes[i] )
|
|
m_iSelectedOption[p][PO_STEP] = i;
|
|
}
|
|
}
|
|
|
|
// initialize custom speed mod text
|
|
if (PREFSMAN->m_sCustomSpeedMod != "")
|
|
m_OptionRow[PO_SPEED].choices[10] = PREFSMAN->m_sCustomSpeedMod;
|
|
else
|
|
m_OptionRow[PO_SPEED].choices.pop_back();
|
|
|
|
/* Default: */
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = 1;
|
|
if( po.m_fSkew==1 && po.m_fPerspectiveTilt==-1 )
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = 0;
|
|
else if( po.m_fSkew==1 && po.m_fPerspectiveTilt==1 )
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = 2;
|
|
else if( po.m_fSkew==0 && po.m_fPerspectiveTilt==-1 )
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = 3;
|
|
else if( po.m_fSkew==0 && po.m_fPerspectiveTilt==1 )
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = 4;
|
|
else /* po.m_fPerspectiveTilt == 0 */
|
|
{
|
|
vector<CString> &choices = m_OptionRow[PO_PERSPECTIVE].choices;
|
|
for(unsigned n = 3; n < choices.size(); ++n)
|
|
if(!choices[n].CompareNoCase(GAMESTATE->m_PlayerOptions[p].m_sPositioning))
|
|
m_iSelectedOption[p][PO_PERSPECTIVE] = n;
|
|
}
|
|
|
|
vector<Character*> apCharacters;
|
|
GAMESTATE->GetCharacters( apCharacters );
|
|
for( i=0; i<apCharacters.size(); i++ )
|
|
if( GAMESTATE->m_pCurCharacters[p] == apCharacters[i] )
|
|
m_iSelectedOption[p][PO_CHARACTER] = i+1;
|
|
|
|
/* Why do this? We don't want to erase if we back out. */
|
|
// po.Init();
|
|
}
|
|
}
|
|
|
|
void ScreenPlayerOptions::ExportOptions()
|
|
{
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
PlayerOptions &po = GAMESTATE->m_PlayerOptions[p];
|
|
/* Why do this? We don't necessarily set everything in po, so we shouldn't
|
|
* erase everything. */
|
|
// po.Init();
|
|
|
|
// if player isn't enabled, don't bother parsing options
|
|
// **very important for nonstop difficulties**
|
|
if (!GAMESTATE->IsPlayerEnabled(p))
|
|
continue;
|
|
|
|
switch( m_iSelectedOption[p][PO_SPEED] )
|
|
{
|
|
case 0: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 0.25f; break;
|
|
case 1: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 0.5f; break;
|
|
case 2: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 0.75f; break;
|
|
case 3: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 1.0f; break;
|
|
case 4: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 1.5f; break;
|
|
case 5: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 2.0f; break;
|
|
case 6: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 3.0f; break;
|
|
case 7: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 5.0f; break;
|
|
case 8: po.m_bTimeSpacing = false; po.m_fScrollSpeed = 8.0f; break;
|
|
case 9: po.m_bTimeSpacing = true; po.m_fScrollSpeed = 1.0f; po.m_fScrollBPM = 200; break;
|
|
|
|
// case 10:po.m_bTimeSpacing = true; po.m_fScrollSpeed = 1.0f; po.m_fScrollBPM = 300; break;
|
|
case 10:
|
|
po.m_bTimeSpacing = IsModTimeSpacing( PREFSMAN->m_sCustomSpeedMod );
|
|
|
|
if (po.m_bTimeSpacing)
|
|
{
|
|
po.m_fScrollSpeed = 1.0f;
|
|
po.m_fScrollBPM = ConvertModToNumber( PREFSMAN->m_sCustomSpeedMod );
|
|
}
|
|
else
|
|
{
|
|
po.m_fScrollSpeed = ConvertModToNumber( PREFSMAN->m_sCustomSpeedMod );
|
|
po.m_fScrollBPM = ConvertModToNumber( PREFSMAN->m_sCustomSpeedMod );
|
|
}
|
|
break;
|
|
default: ASSERT(0);
|
|
}
|
|
|
|
ZERO( po.m_fAccels );
|
|
if( m_iSelectedOption[p][PO_ACCEL] != 0 )
|
|
po.SetOneAccel( (PlayerOptions::Accel)(m_iSelectedOption[p][PO_ACCEL]-1) );
|
|
|
|
/* Don't change effects that aren't displayed. */
|
|
for( int i = 0; ChoosableEffects[i] != PlayerOptions::NUM_EFFECTS; ++i )
|
|
{
|
|
const bool on = (i+1 == m_iSelectedOption[p][PO_EFFECT]);
|
|
const PlayerOptions::Effect e = ChoosableEffects[i];
|
|
|
|
po.m_fEffects[e] = on? 1.0f:0.0f;
|
|
}
|
|
|
|
ZERO( po.m_fAppearances );
|
|
if( m_iSelectedOption[p][PO_APPEAR] != 0 )
|
|
po.SetOneAppearance( (PlayerOptions::Appearance)(m_iSelectedOption[p][PO_APPEAR]-1) );
|
|
|
|
po.m_Turn = (PlayerOptions::Turn)m_iSelectedOption[p][PO_TURN];
|
|
po.m_Transform = (PlayerOptions::Transform)m_iSelectedOption[p][PO_TRANSFORM];
|
|
|
|
ZERO( po.m_fScrolls );
|
|
if( m_iSelectedOption[p][PO_SCROLL] != 0 )
|
|
po.SetOneScroll( (PlayerOptions::Scroll)(m_iSelectedOption[p][PO_SCROLL]-1) );
|
|
|
|
|
|
int iSelectedSkin = m_iSelectedOption[p][PO_NOTE_SKIN];
|
|
CString sNewSkin = m_OptionRow[PO_NOTE_SKIN].choices[iSelectedSkin];
|
|
po.m_sNoteSkin = sNewSkin;
|
|
|
|
|
|
po.m_bHoldNotes = (m_iSelectedOption[p][PO_HOLD_NOTES] == 1);
|
|
po.m_fDark = (m_iSelectedOption[p][PO_HIDE] == 1) ? 1.f : 0.f;
|
|
po.m_fBlind = (m_iSelectedOption[p][PO_HIDE] == 2) ? 1.f : 0.f;
|
|
|
|
switch(m_iSelectedOption[p][PO_PERSPECTIVE])
|
|
{
|
|
case 0: po.m_fSkew = 1; po.m_fPerspectiveTilt = -1; break;
|
|
case 1: po.m_fSkew = 0; po.m_fPerspectiveTilt = 0; break;
|
|
case 2: po.m_fSkew = 1; po.m_fPerspectiveTilt = 1; break;
|
|
case 3: po.m_fSkew = 0; po.m_fPerspectiveTilt = -1; break;
|
|
case 4: po.m_fSkew = 0; po.m_fPerspectiveTilt = 1; break;
|
|
default:
|
|
ASSERT(0);
|
|
}
|
|
if(m_iSelectedOption[p][PO_PERSPECTIVE] > 4)
|
|
{
|
|
const int choice = m_iSelectedOption[p][PO_PERSPECTIVE];
|
|
GAMESTATE->m_PlayerOptions[p].m_sPositioning = m_OptionRow[PO_PERSPECTIVE].choices[choice];
|
|
}
|
|
|
|
//
|
|
// apply difficulty selection
|
|
//
|
|
if( GAMESTATE->m_bEditing )
|
|
{
|
|
// do nothing
|
|
}
|
|
else if( GAMESTATE->m_pCurCourse ) // playing a course
|
|
{
|
|
if( m_iSelectedOption[p][PO_STEP] == 1 )
|
|
{
|
|
GAMESTATE->m_bDifficultCourses = true;
|
|
LOG->Trace("ScreenPlayerOptions: Using difficult course");
|
|
}
|
|
else
|
|
{
|
|
GAMESTATE->m_bDifficultCourses = false;
|
|
LOG->Trace("ScreenPlayerOptions: Using normal course");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vector<Steps*> vNotes;
|
|
GAMESTATE->m_pCurSong->GetSteps( vNotes, GAMESTATE->GetCurrentStyleDef()->m_StepsType );
|
|
SortNotesArrayByDifficulty( vNotes );
|
|
GAMESTATE->m_pCurNotes[p] = vNotes[ m_iSelectedOption[p][PO_STEP] ];
|
|
}
|
|
|
|
if( m_iSelectedOption[p][PO_CHARACTER] == 0 )
|
|
GAMESTATE->m_pCurCharacters[p] = NULL;
|
|
else
|
|
{
|
|
int choice = m_iSelectedOption[p][PO_CHARACTER] - 1;
|
|
vector<Character*> apCharacters;
|
|
GAMESTATE->GetCharacters( apCharacters );
|
|
GAMESTATE->m_pCurCharacters[p] = apCharacters[choice];
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScreenPlayerOptions::GoToPrevState()
|
|
{
|
|
if( GAMESTATE->m_bEditing )
|
|
SCREENMAN->PopTopScreen();
|
|
else
|
|
SCREENMAN->SetNewScreen( PREV_SCREEN(GAMESTATE->m_PlayMode) );
|
|
}
|
|
|
|
void ScreenPlayerOptions::GoToNextState()
|
|
{
|
|
if( GAMESTATE->m_bEditing )
|
|
{
|
|
SCREENMAN->PopTopScreen();
|
|
}
|
|
else
|
|
{
|
|
GAMESTATE->AdjustFailType();
|
|
|
|
if( m_bGoToOptions )
|
|
SCREENMAN->SetNewScreen( NEXT_SCREEN(GAMESTATE->m_PlayMode) );
|
|
else
|
|
SCREENMAN->SetNewScreen( ScreenSongOptions::GetNextScreen() );
|
|
}
|
|
}
|
|
|
|
|
|
void ScreenPlayerOptions::Update( float fDelta )
|
|
{
|
|
ScreenOptions::Update( fDelta );
|
|
m_sprOptionsMessage.Update( fDelta );
|
|
}
|
|
|
|
void ScreenPlayerOptions::DrawPrimitives()
|
|
{
|
|
ScreenOptions::DrawPrimitives();
|
|
m_sprOptionsMessage.Draw();
|
|
}
|
|
|
|
|
|
void ScreenPlayerOptions::Input( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
if( !GAMESTATE->m_bEditing &&
|
|
type == IET_FIRST_PRESS &&
|
|
!m_Menu.m_In.IsTransitioning() &&
|
|
MenuI.IsValid() &&
|
|
MenuI.button == MENU_BUTTON_START &&
|
|
PREFSMAN->m_ShowSongOptions == PrefsManager::ASK )
|
|
{
|
|
if( m_bAcceptedChoices && !m_bGoToOptions )
|
|
{
|
|
m_bGoToOptions = true;
|
|
m_sprOptionsMessage.SetState( 1 );
|
|
SOUND->PlayOnce( THEME->GetPathToS("Common start") );
|
|
}
|
|
}
|
|
|
|
ScreenOptions::Input( DeviceI, type, GameI, MenuI, StyleI );
|
|
}
|
|
|
|
void ScreenPlayerOptions::HandleScreenMessage( const ScreenMessage SM )
|
|
{
|
|
if( PREFSMAN->m_ShowSongOptions == PrefsManager::ASK )
|
|
{
|
|
switch( SM )
|
|
{
|
|
case SM_BeginFadingOut: // when the user accepts the page of options
|
|
{
|
|
m_bAcceptedChoices = true;
|
|
|
|
float fShowSeconds = m_Menu.m_Out.GetLengthSeconds();
|
|
|
|
// show "hold START for options"
|
|
m_sprOptionsMessage.SetDiffuse( RageColor(1,1,1,0) );
|
|
m_sprOptionsMessage.BeginTweening( 0.15f ); // fade in
|
|
m_sprOptionsMessage.SetZoomY( 1 );
|
|
m_sprOptionsMessage.SetDiffuse( RageColor(1,1,1,1) );
|
|
m_sprOptionsMessage.BeginTweening( fShowSeconds-0.3f ); // sleep
|
|
m_sprOptionsMessage.BeginTweening( 0.15f ); // fade out
|
|
m_sprOptionsMessage.SetDiffuse( RageColor(1,1,1,0) );
|
|
m_sprOptionsMessage.SetZoomY( 0 );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
ScreenOptions::HandleScreenMessage( SM );
|
|
}
|
|
|
|
CString ScreenPlayerOptions::ConvertParamToThemeDifficulty( const CString &in ) const
|
|
{
|
|
switch( StringToDifficulty(in) )
|
|
{
|
|
case DIFFICULTY_BEGINNER: return BEGINNER_DESCRIPTION;
|
|
case DIFFICULTY_EASY: return EASY_DESCRIPTION;
|
|
case DIFFICULTY_MEDIUM: return MEDIUM_DESCRIPTION;
|
|
case DIFFICULTY_HARD: return HARD_DESCRIPTION;
|
|
case DIFFICULTY_CHALLENGE: return CHALLENGE_DESCRIPTION;
|
|
default: return in; // something else
|
|
}
|
|
}
|
|
|
|
float ScreenPlayerOptions::ConvertModToNumber(CString value)
|
|
{
|
|
if (IsModTimeSpacing(value))
|
|
{
|
|
return (float) atof(value.c_str() + 1 );
|
|
}
|
|
else
|
|
{
|
|
return (float) atof(value.c_str() );
|
|
}
|
|
}
|
|
|
|
bool ScreenPlayerOptions::IsModTimeSpacing(CString value)
|
|
{
|
|
ASSERT( value.GetLength() );
|
|
|
|
if (value[0] == 'C')
|
|
return true;
|
|
|
|
return false;
|
|
}
|