actions/itgmania212121
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
12fde5d55c42b6c2c6d1670250c7fc1eba24bc41
itgmania212121/stepmania/src/ScreenEvaluation.cpp
T
Chris Danford 12fde5d55c move PlayerName texts out of code and into BGAnimations
2005-02-13 01:16:17 +00:00

1502 lines
46 KiB
C++
Raw Blame History

#include "global.h"
#include "ScreenEvaluation.h"
#include "SongManager.h"
#include "ScreenManager.h"
#include "GameManager.h"
#include "RageUtil.h"
#include "GameConstantsAndTypes.h"
#include "Steps.h"
#include "PrefsManager.h"
#include "RageLog.h"
#include "AnnouncerManager.h"
#include "GameState.h"
#include "GrooveRadar.h"
#include "ThemeManager.h"
#include "GameSoundManager.h"
#include "ActorUtil.h"
#include "RageTimer.h"
#include "UnlockSystem.h"
#include "Course.h"
#include "LightsManager.h"
#include "ProfileManager.h"
#include "song.h"
#include "StageStats.h"
#include "Grade.h"
#include "CodeDetector.h"
#include "RageDisplay.h"
#include "StepMania.h"
#include "CryptManager.h"
#include "Style.h"
#include "MemoryCardManager.h"
#include "PlayerState.h"
#include "Command.h"
#include "CommonMetrics.h"
const int NUM_SCORE_DIGITS = 9;
// metrics that are common to all ScreenEvaluation classes
#define BANNER_WIDTH THEME->GetMetricF(m_sName,"BannerWidth")
#define BANNER_HEIGHT THEME->GetMetricF(m_sName,"BannerHeight")
const char* JUDGE_STRING[NUM_JUDGE_LINES] =
{
"Marvelous", "Perfect", "Great", "Good", "Boo", "Miss", "OK", "MaxCombo", "TotalError"
};
const char* STATS_STRING[NUM_STATS_LINES] =
{
"Jumps", "Holds", "Mines", "Hands"
};
#define SPIN_GRADES THEME->GetMetricB(m_sName,"SpinGrades")
#define CHEER_DELAY_SECONDS THEME->GetMetricF(m_sName,"CheerDelaySeconds")
#define BAR_ACTUAL_MAX_COMMAND THEME->GetMetricA(m_sName,"BarActualMaxCommand")
// metrics that are specific to classes derived from ScreenEvaluation
#define FAILED_SCREEN THEME->GetMetric (m_sName, "FailedScreen")
#define NEXT_SCREEN THEME->GetMetric (m_sName,"NextScreen")
#define END_SCREEN THEME->GetMetric (m_sName,"EndScreen")
#define SHOW_BANNER_AREA THEME->GetMetricB(m_sName,"ShowBannerArea")
#define SHOW_GRADE_AREA THEME->GetMetricB(m_sName,"ShowGradeArea")
#define SHOW_POINTS_AREA THEME->GetMetricB(m_sName,"ShowPointsArea")
#define SHOW_BONUS_AREA THEME->GetMetricB(m_sName,"ShowBonusArea")
#define SHOW_SURVIVED_AREA THEME->GetMetricB(m_sName,"ShowSurvivedArea")
#define SHOW_WIN_AREA THEME->GetMetricB(m_sName,"ShowWinArea")
#define SHOW_JUDGMENT( l ) THEME->GetMetricB(m_sName,ssprintf("Show%s",JUDGE_STRING[l]))
#define SHOW_STAT( s ) THEME->GetMetricB(m_sName,ssprintf("Show%s",STATS_STRING[l]))
#define SHOW_SCORE_AREA THEME->GetMetricB(m_sName,"ShowScoreArea")
#define SHOW_TOTAL_SCORE_AREA THEME->GetMetricB(m_sName,"ShowTotalScoreArea")
#define SHOW_TIME_AREA THEME->GetMetricB(m_sName,"ShowTimeArea")
#define SHOW_GRAPH_AREA THEME->GetMetricB(m_sName,"ShowGraphArea")
#define SHOW_COMBO_AREA THEME->GetMetricB(m_sName,"ShowComboArea")
#define SHOW_PER_DIFFICULTY_AWARD THEME->GetMetricB(m_sName,"ShowPerDifficultyAward")
#define SHOW_PEAK_COMBO_AWARD THEME->GetMetricB(m_sName,"ShowPeakComboAward")
#define GRAPH_START_HEIGHT THEME->GetMetricF(m_sName,"GraphStartHeight")
#define TYPE THEME->GetMetric (m_sName,"Type")
#define PASSED_SOUND_TIME THEME->GetMetricF(m_sName,"PassedSoundTime")
#define FAILED_SOUND_TIME THEME->GetMetricF(m_sName,"FailedSoundTime")
#define NUM_SEQUENCE_SOUNDS THEME->GetMetricI(m_sName,"NumSequenceSounds")
#define SOUNDSEQ_TIME( i ) THEME->GetMetricF(m_sName,ssprintf("SoundSeqTime%d", i+1))
#define SOUNDSEQ_NAME( i ) THEME->GetMetric (m_sName,ssprintf("SoundSeqName%d", i+1))
#define MAX_COMBO_NUM_DIGITS THEME->GetMetricI(m_sName,"MaxComboNumDigits")
#define PLAYER_OPTIONS_SEPARATOR THEME->GetMetric (m_sName,"PlayerOptionsSeparator")
static const int NUM_SHOWN_RADAR_CATEGORIES = 5;
const ScreenMessage SM_PlayCheer = ScreenMessage(SM_User+6);
REGISTER_SCREEN_CLASS( ScreenEvaluation );
ScreenEvaluation::ScreenEvaluation( CString sClassName ) : ScreenWithMenuElements(sClassName)
{
LOG->Trace( "ScreenEvaluation::ScreenEvaluation" );
}
void ScreenEvaluation::Init()
{
Screen::Init();
//
// debugging
//
if( PREFSMAN->m_bScreenTestMode )
{
PROFILEMAN->LoadFirstAvailableProfile(PLAYER_1);
PROFILEMAN->LoadFirstAvailableProfile(PLAYER_2);
GAMESTATE->m_PlayMode = PLAY_MODE_REGULAR;
GAMESTATE->m_pCurStyle = GAMEMAN->GameAndStringToStyle( GAMEMAN->GetDefaultGame(), "versus" );
GAMESTATE->m_bSideIsJoined[PLAYER_1] = true;
GAMESTATE->m_bSideIsJoined[PLAYER_2] = true;
GAMESTATE->m_MasterPlayerNumber = PLAYER_1;
GAMESTATE->m_pCurSong = SONGMAN->GetRandomSong();
GAMESTATE->m_pCurCourse = SONGMAN->GetRandomCourse();
GAMESTATE->m_pCurSteps[PLAYER_1] = GAMESTATE->m_pCurSong->GetAllSteps()[0];
GAMESTATE->m_pCurSteps[PLAYER_2] = GAMESTATE->m_pCurSong->GetAllSteps()[0];
g_CurStageStats.m_player[PLAYER_1].vpSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_1] );
g_CurStageStats.m_player[PLAYER_2].vpSteps.push_back( GAMESTATE->m_pCurSteps[PLAYER_2] );
GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_fScrollSpeed = 2;
GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.m_fScrollSpeed = 2;
GAMESTATE->m_iCurrentStageIndex = 0;
GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.ChooseRandomMofifiers();
GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.ChooseRandomMofifiers();
if( rand() % 2 )
GAMESTATE->m_pPlayerState[PLAYER_1]->m_PlayerOptions.m_bTransforms[PlayerOptions::TRANSFORM_ECHO] = true; // show "disqualified"
if( rand() % 2 )
GAMESTATE->m_pPlayerState[PLAYER_2]->m_PlayerOptions.m_bTransforms[PlayerOptions::TRANSFORM_ECHO] = true; // show "disqualified"
for( float f = 0; f < 100.0f; f += 1.0f )
{
float fP1 = fmodf(f/100*4+.3f,1);
g_CurStageStats.m_player[PLAYER_1].SetLifeRecordAt( fP1, f );
g_CurStageStats.m_player[PLAYER_2].SetLifeRecordAt( 1-fP1, f );
}
g_CurStageStats.m_player[PLAYER_1].iActualDancePoints = rand()%3;
g_CurStageStats.m_player[PLAYER_1].iPossibleDancePoints = 2;
g_CurStageStats.m_player[PLAYER_2].iActualDancePoints = rand()%2;
g_CurStageStats.m_player[PLAYER_2].iPossibleDancePoints = 1;
g_CurStageStats.m_player[PLAYER_1].iCurCombo = 0;
g_CurStageStats.m_player[PLAYER_1].UpdateComboList( 0, false );
g_CurStageStats.m_player[PLAYER_1].iCurCombo = 1;
g_CurStageStats.m_player[PLAYER_1].UpdateComboList( 1, false );
g_CurStageStats.m_player[PLAYER_1].iCurCombo = 50;
g_CurStageStats.m_player[PLAYER_1].UpdateComboList( 25, false );
g_CurStageStats.m_player[PLAYER_1].iCurCombo = 250;
g_CurStageStats.m_player[PLAYER_1].UpdateComboList( 100, false );
if( rand()%2 )
{
g_CurStageStats.m_player[PLAYER_1].iCurCombo = rand()%11000;
g_CurStageStats.m_player[PLAYER_1].UpdateComboList( 110, false );
}
if( rand()%5 == 0 )
{
g_CurStageStats.m_player[PLAYER_1].bFailedEarlier = true;
g_CurStageStats.m_player[PLAYER_2].bFailedEarlier = true;
}
g_CurStageStats.m_player[PLAYER_2].iCurCombo = 0;
g_CurStageStats.m_player[PLAYER_2].UpdateComboList( 0, false );
g_CurStageStats.m_player[PLAYER_2].iCurCombo = 1;
g_CurStageStats.m_player[PLAYER_2].UpdateComboList( 1, false );
g_CurStageStats.m_player[PLAYER_2].iCurCombo = 50;
g_CurStageStats.m_player[PLAYER_2].UpdateComboList( 25, false );
g_CurStageStats.m_player[PLAYER_2].iCurCombo = 250;
g_CurStageStats.m_player[PLAYER_2].UpdateComboList( 100, false );
if( rand()%2 )
{
g_CurStageStats.m_player[PLAYER_2].iCurCombo = rand()%11000;
g_CurStageStats.m_player[PLAYER_2].UpdateComboList( 110, false );
}
g_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_MARVELOUS] = rand()%3;
g_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_PERFECT] = rand()%3;
g_CurStageStats.m_player[PLAYER_1].iTapNoteScores[TNS_GREAT] = rand()%3;
g_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_MARVELOUS] = rand()%3;
g_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_PERFECT] = rand()%3;
g_CurStageStats.m_player[PLAYER_2].iTapNoteScores[TNS_GREAT] = rand()%3;
g_vPlayedStageStats.clear();
}
LOG->Trace( "ScreenEvaluation::ScreenEvaluation()" );
LIGHTSMAN->SetLightsMode( LIGHTSMODE_MENU );
m_bFailed = g_CurStageStats.AllFailed();
ZERO( m_bSavedScreenshot );
CString sType = TYPE;
if( !sType.CompareNoCase("stage") )
m_Type = stage;
else if( !sType.CompareNoCase("summary") )
m_Type = summary;
else if( !sType.CompareNoCase("course") )
m_Type = course;
else
RageException::Throw("Unknown evaluation type \"%s\"", TYPE.c_str() );
//
// Figure out which statistics and songs we're going to display
//
StageStats stageStats;
switch( m_Type )
{
case summary:
GAMESTATE->GetFinalEvalStats( stageStats );
break;
case stage:
case course:
stageStats = g_CurStageStats;
break;
default:
ASSERT(0);
}
LOG->Trace( "total error: %i, %i", stageStats.m_player[PLAYER_1].iTotalError, stageStats.m_player[PLAYER_2].iTotalError );
/*
//
// Debugging
//
{
FOREACH_PlayerNumber( p ) // foreach line
for( int r=0; r<NUM_RADAR_CATEGORIES; r++ ) // foreach line
{
stageStats.radarPossible[p][r] = 0.5f + r/10.0f;
stageStats.radarActual[p][r] = 0.5f + r/10.0f;
}
}
*/
//
// Calculate grades
//
Grade grade[NUM_PLAYERS];
FOREACH_PlayerNumber( p )
{
if( GAMESTATE->IsPlayerEnabled(p) )
grade[p] = stageStats.m_player[p].GetGrade();
else
grade[p] = GRADE_FAILED;
if( PREFSMAN->m_iScoringType == PrefsManager::SCORING_5TH )
{
const int ScoreBonuses[] = { 10000000, 10000000, 1000000, 100000, 10000, 1000, 100 };
if( grade[p] < (int) ARRAYSIZE(ScoreBonuses) )
{
g_CurStageStats.m_player[p].iBonus += ScoreBonuses[(int)grade[p] ];
stageStats.m_player[p].iBonus += ScoreBonuses[(int)grade[p] ];
}
}
}
//
// update persistent statistics
//
int iPersonalHighScoreIndex[NUM_PLAYERS];
int iMachineHighScoreIndex[NUM_PLAYERS];
RankingCategory rc[NUM_PLAYERS];;
PerDifficultyAward pdaToShow[NUM_PLAYERS];
PeakComboAward pcaToShow[NUM_PLAYERS];
CommitScores( stageStats, iPersonalHighScoreIndex, iMachineHighScoreIndex, rc, pdaToShow, pcaToShow );
m_bTryExtraStage =
GAMESTATE->HasEarnedExtraStage() &&
m_Type==stage;
//
// load pass/fail sound
//
for( int snd=0; snd < NUM_SEQUENCE_SOUNDS; ++snd ) // grab in any sound sequence the user may want to throw onto this screen
{
EvalSoundSequence temp;
temp.fTime = SOUNDSEQ_TIME(snd);
temp.sSound.Load( THEME->GetPathToS(SOUNDSEQ_NAME(snd)) );
m_SoundSequences.push_back(temp);
}
m_bPassFailTriggered = false; // the sound hasn't been triggered yet
if( m_bFailed )
m_sndPassFail.Load( THEME->GetPathS(m_sName, "failed") );
else
m_sndPassFail.Load( THEME->GetPathS(m_sName, "passed") );
m_sndPassFail.Play();
m_bgCondBga.Load(m_sName);
//
// load other sounds
//
m_soundStart.Load( THEME->GetPathS("ScreenEvaluation","start") );
//
// init banner area
//
if( SHOW_BANNER_AREA )
{
switch( m_Type )
{
case stage:
{
m_LargeBanner.LoadFromSong( GAMESTATE->m_pCurSong );
m_LargeBanner.ScaleToClipped( BANNER_WIDTH, BANNER_HEIGHT );
m_LargeBanner.SetName( "LargeBanner" );
SET_XY_AND_ON_COMMAND( m_LargeBanner );
this->AddChild( &m_LargeBanner );
m_sprLargeBannerFrame.Load( THEME->GetPathG("ScreenEvaluation","banner frame") );
m_sprLargeBannerFrame->SetName( "LargeBannerFrame" );
SET_XY_AND_ON_COMMAND( m_sprLargeBannerFrame );
this->AddChild( m_sprLargeBannerFrame );
m_sprStage.Load( THEME->GetPathG("ScreenEvaluation","stage "+GAMESTATE->GetStageText()) );
m_sprStage->SetName( "Stage" );
SET_XY_AND_ON_COMMAND( m_sprStage );
this->AddChild( m_sprStage );
}
break;
case summary:
{
for( unsigned i=0; i<stageStats.vpSongs.size(); i++ )
{
Song *pSong = stageStats.vpSongs[i];
m_SmallBanner[i].LoadFromSong( pSong );
m_SmallBanner[i].ScaleToClipped( BANNER_WIDTH, BANNER_HEIGHT );
m_SmallBanner[i].SetName( ssprintf("SmallBanner%d",i+1) );
SET_XY_AND_ON_COMMAND( m_SmallBanner[i] );
this->AddChild( &m_SmallBanner[i] );
m_sprSmallBannerFrame[i].Load( THEME->GetPathG("ScreenEvaluation","banner frame") );
m_sprSmallBannerFrame[i]->SetName( ssprintf("SmallBanner%d",i+1) );
SET_XY_AND_ON_COMMAND( m_sprSmallBannerFrame[i] );
this->AddChild( m_sprSmallBannerFrame[i] );
}
}
break;
case course:
{
m_LargeBanner.LoadFromCourse( GAMESTATE->m_pCurCourse );
m_LargeBanner.ScaleToClipped( BANNER_WIDTH, BANNER_HEIGHT );
m_LargeBanner.SetName( "LargeBanner" );
SET_XY_AND_ON_COMMAND( m_LargeBanner );
this->AddChild( &m_LargeBanner );
m_sprLargeBannerFrame.Load( THEME->GetPathG("ScreenEvaluation","banner frame") );
m_sprLargeBannerFrame->SetName( "LargeBannerFrame" );
SET_XY_AND_ON_COMMAND( m_sprLargeBannerFrame );
this->AddChild( m_sprLargeBannerFrame );
}
break;
default:
ASSERT(0);
}
switch( m_Type )
{
case stage:
case course:
{
FOREACH_EnabledPlayer( p )
{
m_DifficultyIcon[p].Load( THEME->GetPathG("ScreenEvaluation","difficulty icons") );
switch( m_Type )
{
case stage:
m_DifficultyIcon[p].SetFromSteps( p, GAMESTATE->m_pCurSteps[p] );
break;
case course:
m_DifficultyIcon[p].SetFromTrail( p, GAMESTATE->m_pCurTrail[p] );
break;
default:
ASSERT(0);
}
m_DifficultyIcon[p].SetName( ssprintf("DifficultyIconP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_DifficultyIcon[p] );
this->AddChild( &m_DifficultyIcon[p] );
m_DifficultyMeter[p].SetName( ssprintf("ScreenEvaluation DifficultyMeterP%d",p+1) );
m_DifficultyMeter[p].Load();
switch( m_Type )
{
case stage:
m_DifficultyMeter[p].SetFromSteps( GAMESTATE->m_pCurSteps[p] );
break;
case course:
m_DifficultyMeter[p].SetFromTrail( GAMESTATE->m_pCurTrail[p] );
break;
default:
ASSERT(0);
}
m_DifficultyMeter[p].SetName( ssprintf("DifficultyMeterP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_DifficultyMeter[p] );
this->AddChild( &m_DifficultyMeter[p] );
m_textPlayerOptions[p].LoadFromFont( THEME->GetPathF("Common","normal") );
CString sPO = GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetThemedString();
sPO.Replace( ", ", PLAYER_OPTIONS_SEPARATOR );
m_textPlayerOptions[p].SetName( ssprintf("PlayerOptionsP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_textPlayerOptions[p] );
m_textPlayerOptions[p].SetText( sPO );
this->AddChild( &m_textPlayerOptions[p] );
if( GAMESTATE->IsDisqualified(p) )
{
m_sprDisqualified[p].Load( THEME->GetPathG("ScreenEvaluation","disqualified") );
m_sprDisqualified[p]->SetName( ssprintf("DisqualifiedP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprDisqualified[p] );
this->AddChild( m_sprDisqualified[p] );
}
}
}
break;
case summary:
break;
default:
ASSERT(0);
}
}
//
// init graph area
//
if( SHOW_GRAPH_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprGraphFrame[p].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("graph frame p%d",p+1)) );
m_sprGraphFrame[p]->SetName( ssprintf("GraphFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprGraphFrame[p] );
this->AddChild( m_sprGraphFrame[p] );
m_Graph[p].SetName( ssprintf("GraphP%i",p+1) );
m_Graph[p].Load( THEME->GetPathG(m_sName,ssprintf("graph p%i", p+1)), GRAPH_START_HEIGHT );
m_Graph[p].LoadFromStageStats( stageStats.m_player[p] );
SET_XY_AND_ON_COMMAND( m_Graph[p] );
this->AddChild( &m_Graph[p] );
}
}
if( SHOW_COMBO_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_Combo[p].SetName( m_sName, ssprintf("ComboP%i",p+1) );
m_Combo[p].Load( ssprintf("ScreenEvaluationStage combo p%i", p+1), stageStats, p );
SET_XY_AND_ON_COMMAND( m_Combo[p] );
this->AddChild( &m_Combo[p] );
}
}
//
// init grade area
//
if( SHOW_GRADE_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprGradeFrame[p].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("grade frame p%d",p+1)) );
m_sprGradeFrame[p]->SetName( ssprintf("GradeFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprGradeFrame[p] );
this->AddChild( m_sprGradeFrame[p] );
m_Grades[p].Load( THEME->GetPathG("ScreenEvaluation","grades") );
m_Grades[p].SetGrade( p, grade[p] );
m_Grades[p].SetName( ssprintf("GradeP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_Grades[p] );
if( SPIN_GRADES )
m_Grades[p].Spin();
this->AddChild( &m_Grades[p] );
m_sprGrade[p].Load( THEME->GetPathG("ScreenEvaluation","grade "+GradeToString(grade[p])) );
m_sprGrade[p]->SetName( ssprintf("GradeP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprGrade[p] );
this->AddChild( m_sprGrade[p] );
}
}
//
// init points area
//
if( SHOW_POINTS_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprPercentFrame[p].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("percent frame p%d",p+1)) );
m_sprPercentFrame[p]->SetName( ssprintf("PercentFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprPercentFrame[p] );
this->AddChild( m_sprPercentFrame[p] );
/* Use "ScreenEvaluation Percent" for the [metric set], but position and
* tween it with "PercentP1X", etc. */
m_Percent[p].SetName( "ScreenEvaluation Percent" );
m_Percent[p].Load( p, &g_CurStageStats.m_player[p], true );
m_Percent[p].SetXY( THEME->GetMetricF(m_sName, ssprintf("PercentP%dX",p+1)),
THEME->GetMetricF(m_sName,ssprintf("PercentP%dY",p+1)) );
m_Percent[p].RunCommands( THEME->GetMetricA(m_sName,ssprintf("PercentP%dOnCommand",p+1)) );
this->AddChild( &m_Percent[p] );
}
}
//
// init bonus area
//
if( SHOW_BONUS_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprBonusFrame[p].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("bonus frame p%d",p+1)) );
m_sprBonusFrame[p]->SetName( ssprintf("BonusFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprBonusFrame[p] );
this->AddChild( m_sprBonusFrame[p] );
for( int r=0; r<NUM_SHOWN_RADAR_CATEGORIES; r++ ) // foreach line
{
m_sprPossibleBar[p][r].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("bar possible p%d",p+1)) );
m_sprPossibleBar[p][r].SetWidth( m_sprPossibleBar[p][r].GetUnzoomedWidth() * stageStats.m_player[p].radarPossible[r] );
m_sprPossibleBar[p][r].SetName( ssprintf("BarPossible%dP%d",r+1,p+1) );
SET_XY_AND_ON_COMMAND( m_sprPossibleBar[p][r] );
this->AddChild( &m_sprPossibleBar[p][r] );
m_sprActualBar[p][r].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("bar actual p%d",p+1)) );
// should be out of the possible bar, not actual (whatever value that is at)
m_sprActualBar[p][r].SetWidth( m_sprPossibleBar[p][r].GetUnzoomedWidth() * stageStats.m_player[p].radarActual[r] );
float value = (float)100 * m_sprActualBar[p][r].GetUnzoomedWidth() / m_sprPossibleBar[p][r].GetUnzoomedWidth();
LOG->Trace("Radar bar %d of 5 - %f percent", r, value);
m_sprActualBar[p][r].SetName( ssprintf("BarActual%dP%d",r+1,p+1) );
SET_XY_AND_ON_COMMAND( m_sprActualBar[p][r] );
// .99999 is fairly close to 1.00, so we use that
if( stageStats.m_player[p].radarActual[r] > 0.99999f )
m_sprActualBar[p][r].RunCommands( BAR_ACTUAL_MAX_COMMAND );
this->AddChild( &m_sprActualBar[p][r] );
}
}
}
//
// init survived area
//
if( SHOW_SURVIVED_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprSurvivedFrame[p].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("survived frame p%d",p+1)) );
m_sprSurvivedFrame[p]->SetName( ssprintf("SurvivedFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprSurvivedFrame[p] );
this->AddChild( m_sprSurvivedFrame[p] );
m_textSurvivedNumber[p].LoadFromFont( THEME->GetPathF(m_sName, "stage") );
m_textSurvivedNumber[p].SetShadowLength( 0 );
// curewater: edited the "# stages cleared" text so it deducts one if you failed.
// Should be accurate, but I'm not sure if its "standard" that (bool)true = 1. (assumption)
m_textSurvivedNumber[p].SetText( ssprintf("%02d", stageStats.m_player[p].iSongsPlayed - (int)stageStats.m_player[p].bFailed) );
m_textSurvivedNumber[p].SetName( ssprintf("SurvivedNumberP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_textSurvivedNumber[p] );
this->AddChild( &m_textSurvivedNumber[p] );
}
}
//
// init win area
//
if( SHOW_WIN_AREA )
{
FOREACH_EnabledPlayer( p )
{
m_sprWinFrame[p].Load( THEME->GetPathG(m_sName,ssprintf("win frame p%d",p+1)) );
m_sprWinFrame[p]->SetName( ssprintf("WinFrameP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprWinFrame[p] );
this->AddChild( m_sprWinFrame[p] );
m_sprWin[p].Load( THEME->GetPathG(m_sName,ssprintf("win p%d 1x3",p+1)) );
m_sprWin[p].StopAnimating();
int iFrame = GAMESTATE->GetStageResult( p );
m_sprWin[p].SetState( iFrame );
m_sprWin[p].SetName( ssprintf("WinP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_sprWin[p] );
this->AddChild( &m_sprWin[p] );
}
}
//
// init judgment area
//
int l;
for( l=0; l<NUM_JUDGE_LINES; l++ )
{
if( l == 0 && !GAMESTATE->ShowMarvelous() )
continue; // skip
if( SHOW_JUDGMENT(l) )
{
m_sprJudgeLabels[l].Load( THEME->GetPathG("ScreenEvaluation","judge labels") );
m_sprJudgeLabels[l].StopAnimating();
m_sprJudgeLabels[l].SetState( l );
m_sprJudgeLabels[l].SetName( ssprintf("%sLabel",JUDGE_STRING[l]) );
SET_XY_AND_ON_COMMAND( m_sprJudgeLabels[l] );
this->AddChild( &m_sprJudgeLabels[l] );
FOREACH_EnabledPlayer( p )
{
m_textJudgeNumbers[l][p].LoadFromFont( THEME->GetPathF(m_sName, "judge") );
m_textJudgeNumbers[l][p].SetShadowLength( 0 );
m_textJudgeNumbers[l][p].SetDiffuse( PLAYER_COLOR.GetValue(p) );
m_textJudgeNumbers[l][p].SetName( ssprintf("%sNumberP%d",JUDGE_STRING[l],p+1) );
SET_XY_AND_ON_COMMAND( m_textJudgeNumbers[l][p] );
this->AddChild( &m_textJudgeNumbers[l][p] );
int iValue;
switch( l )
{
case marvelous: iValue = stageStats.m_player[p].iTapNoteScores[TNS_MARVELOUS]; break;
case perfect: iValue = stageStats.m_player[p].iTapNoteScores[TNS_PERFECT]; break;
case great: iValue = stageStats.m_player[p].iTapNoteScores[TNS_GREAT]; break;
case good: iValue = stageStats.m_player[p].iTapNoteScores[TNS_GOOD]; break;
case boo: iValue = stageStats.m_player[p].iTapNoteScores[TNS_BOO]; break;
case miss: iValue = stageStats.m_player[p].iTapNoteScores[TNS_MISS]; break;
case ok: iValue = stageStats.m_player[p].iHoldNoteScores[HNS_OK]; break;
case max_combo: iValue = stageStats.m_player[p].GetMaxCombo().cnt; break;
case error: iValue = stageStats.m_player[p].iTotalError; break;
default: iValue = 0; ASSERT(0);
}
// UGLY... generalize this
int iNumDigits = (l==max_combo) ? MAX_COMBO_NUM_DIGITS : 4;
m_textJudgeNumbers[l][p].SetText( ssprintf("%*d",iNumDigits,iValue) );
}
}
}
for( l=0; l<NUM_STATS_LINES; l++ )
{
if( !SHOW_STAT(l) )
continue;
m_sprStatsLabel[l].Load( THEME->GetPathG("ScreenEvaluation",ssprintf("label %s", STATS_STRING[l])) );
m_sprStatsLabel[l]->StopAnimating();
m_sprStatsLabel[l]->SetName( ssprintf("%sLabel",STATS_STRING[l]) );
SET_XY_AND_ON_COMMAND( m_sprStatsLabel[l] );
this->AddChild( m_sprStatsLabel[l] );
FOREACH_EnabledPlayer( p )
{
m_textStatsText[l][p].LoadFromFont( THEME->GetPathF("ScreenEvaluation","stats") );
m_textStatsText[l][p].SetDiffuse( PLAYER_COLOR.GetValue(p) );
m_textStatsText[l][p].SetName( ssprintf("%sTextP%d",STATS_STRING[l],p+1) );
SET_XY_AND_ON_COMMAND( m_textStatsText[l][p] );
this->AddChild( &m_textStatsText[l][p] );
const int indeces[NUM_STATS_LINES] =
{
RADAR_NUM_JUMPS, RADAR_NUM_HOLDS, RADAR_NUM_MINES, RADAR_NUM_HANDS
};
const int ind = indeces[l];
const int iActual = (int) roundf(stageStats.m_player[p].radarActual[ind]);
const int iPossible = (int) roundf(stageStats.m_player[p].radarPossible[ind]);
m_textStatsText[l][p].SetText( ssprintf("%3d/%3d",iActual,iPossible) );
}
}
//
// init score area
//
if( SHOW_SCORE_AREA )
{
m_sprScoreLabel.Load( THEME->GetPathG("ScreenEvaluation","score label") );
m_sprScoreLabel->SetName( "ScoreLabel" );
SET_XY_AND_ON_COMMAND( m_sprScoreLabel );
this->AddChild( m_sprScoreLabel );
FOREACH_EnabledPlayer( p )
{
m_textScore[p].LoadFromFont( THEME->GetPathF(m_sName, "score") );
m_textScore[p].SetShadowLength( 0 );
m_textScore[p].SetDiffuse( PLAYER_COLOR.GetValue(p) );
m_textScore[p].SetName( ssprintf("ScoreNumberP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_textScore[p] );
m_textScore[p].SetText( ssprintf("%*.0i", NUM_SCORE_DIGITS, stageStats.m_player[p].iScore) );
this->AddChild( &m_textScore[p] );
}
}
if( SHOW_TOTAL_SCORE_AREA )
{
m_sprTotalScoreLabel.Load( THEME->GetPathG("ScreenEvaluation","totalscore label") );
m_sprTotalScoreLabel->SetName( "TotalScoreLabel" );
SET_XY_AND_ON_COMMAND( m_sprTotalScoreLabel );
this->AddChild( m_sprTotalScoreLabel );
FOREACH_EnabledPlayer( p )
{
int iTotalScore=0;
for( unsigned i=0; i<g_vPlayedStageStats.size(); i++ )
iTotalScore += g_vPlayedStageStats[i].m_player[p].iScore;
//iTotalScore += stageStats.m_player[p].iScore;
m_textTotalScore[p].LoadFromFont( THEME->GetPathF(m_sName, "totalscore") );
m_textTotalScore[p].SetShadowLength( 0 );
m_textTotalScore[p].SetDiffuse( PLAYER_COLOR.GetValue(p) );
m_textTotalScore[p].SetName( ssprintf("TotalScoreNumberP%d",p+1) );
m_textTotalScore[p].SetText( ssprintf("%*.0i", NUM_SCORE_DIGITS+2, iTotalScore) );
SET_XY_AND_ON_COMMAND( m_textTotalScore[p] );
this->AddChild( &m_textTotalScore[p] );
}
}
//
// init time area
//
if( SHOW_TIME_AREA )
{
m_sprTimeLabel.Load( THEME->GetPathG("ScreenEvaluation","time label") );
m_sprTimeLabel->SetName( "TimeLabel" );
SET_XY_AND_ON_COMMAND( m_sprTimeLabel );
this->AddChild( m_sprTimeLabel );
FOREACH_EnabledPlayer( p )
{
m_textTime[p].LoadFromFont( THEME->GetPathF(m_sName, "time") );
m_textTime[p].SetShadowLength( 0 );
m_textTime[p].SetDiffuse( PLAYER_COLOR.GetValue(p) );
m_textTime[p].SetName( ssprintf("TimeNumberP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_textTime[p] );
m_textTime[p].SetText( SecondsToMMSSMsMs(stageStats.m_player[p].fAliveSeconds) );
this->AddChild( &m_textTime[p] );
}
}
//
// init extra area
//
FOREACH_PlayerNumber( p )
{
if( iMachineHighScoreIndex[p] != -1 )
{
m_sprMachineRecord[p].Load( THEME->GetPathG( "ScreenEvaluation", ssprintf("MachineRecord %02d",iMachineHighScoreIndex[p]+1) ) );
m_sprMachineRecord[p]->SetName( ssprintf("MachineRecordP%d",p+1) );
m_sprMachineRecord[p]->StopAnimating();
SET_XY_AND_ON_COMMAND( m_sprMachineRecord[p] );
this->AddChild( m_sprMachineRecord[p] );
}
if( iPersonalHighScoreIndex[p] != -1 )
{
m_sprPersonalRecord[p].Load( THEME->GetPathG( "ScreenEvaluation", ssprintf("PersonalRecord %02d",iPersonalHighScoreIndex[p]+1) ) );
m_sprPersonalRecord[p]->SetName( ssprintf("PersonalRecordP%d",p+1) );
m_sprPersonalRecord[p]->StopAnimating();
SET_XY_AND_ON_COMMAND( m_sprPersonalRecord[p] );
this->AddChild( m_sprPersonalRecord[p] );
}
if( SHOW_PER_DIFFICULTY_AWARD && pdaToShow[p]!=PER_DIFFICULTY_AWARD_INVALID )
{
CString sAward = PerDifficultyAwardToString( pdaToShow[p] );
m_PerDifficultyAward[p].Load( THEME->GetPathG(m_sName,"PerDifficultyAward "+sAward) );
m_PerDifficultyAward[p]->SetName( ssprintf("PerDifficultyAwardP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_PerDifficultyAward[p] );
this->AddChild( m_PerDifficultyAward[p] );
}
if( SHOW_PEAK_COMBO_AWARD && pcaToShow[p]!=PEAK_COMBO_AWARD_INVALID )
{
CString sAward = PeakComboAwardToString( pcaToShow[p] );
m_PeakComboAward[p].Load( THEME->GetPathG(m_sName,"PeakComboAward "+sAward) );
m_PeakComboAward[p]->SetName( ssprintf("PeakComboAwardP%d",p+1) );
SET_XY_AND_ON_COMMAND( m_PeakComboAward[p] );
this->AddChild( m_PeakComboAward[p] );
}
}
bool bOneHasNewTopRecord = false;
FOREACH_PlayerNumber( p )
if( GAMESTATE->IsPlayerEnabled(p) && (iMachineHighScoreIndex[p] != -1 || iPersonalHighScoreIndex[p] != -1) )
bOneHasNewTopRecord = true;
Grade best_grade = GRADE_NO_DATA;
FOREACH_PlayerNumber( p )
best_grade = min( best_grade, grade[p] );
if( PREFSMAN->m_bAllowExtraStage && m_bTryExtraStage )
{
m_sprTryExtraStage.Load( THEME->GetPathG("ScreenEvaluation",GAMESTATE->IsExtraStage()?"try extra2":"try extra1") );
m_sprTryExtraStage->SetName( "TryExtraStage" );
SET_XY_AND_ON_COMMAND( m_sprTryExtraStage );
this->AddChild( m_sprTryExtraStage );
if( GAMESTATE->IsExtraStage() )
SOUND->PlayOnce( THEME->GetPathS("ScreenEvaluation","try extra2") );
else
SOUND->PlayOnce( THEME->GetPathS("ScreenEvaluation","try extra1") );
}
else if( bOneHasNewTopRecord && ANNOUNCER->HasSoundsFor("evaluation new record") )
{
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation new record") );
}
else
{
switch( m_Type )
{
case stage:
switch( GAMESTATE->m_PlayMode )
{
case PLAY_MODE_BATTLE:
{
bool bWon = GAMESTATE->GetStageResult(GAMESTATE->m_MasterPlayerNumber) == RESULT_WIN;
if( bWon )
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation win") );
else
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation lose") );
}
break;
default:
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation "+GradeToOldString(best_grade)) );
break;
}
break;
case course:
case summary:
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation final "+GradeToOldString(best_grade)) );
break;
default:
ASSERT(0);
}
}
switch( best_grade )
{
case GRADE_TIER_1:
case GRADE_TIER_2:
case GRADE_TIER_3:
this->PostScreenMessage( SM_PlayCheer, CHEER_DELAY_SECONDS );
break;
}
this->SortByDrawOrder();
SOUND->PlayMusic( THEME->GetPathS("ScreenEvaluation","music") );
m_timerSoundSequences.SetZero(); // zero the sound sequence timer
m_timerSoundSequences.Touch(); // set the timer going :]
m_fScreenCreateTime = RageTimer::GetTimeSinceStart();
}
void ScreenEvaluation::CommitScores(
const StageStats &stageStats,
int iPersonalHighScoreIndexOut[NUM_PLAYERS],
int iMachineHighScoreIndexOut[NUM_PLAYERS],
RankingCategory rcOut[NUM_PLAYERS],
PerDifficultyAward pdaToShowOut[NUM_PLAYERS],
PeakComboAward pcaToShowOut[NUM_PLAYERS] )
{
{
FOREACH_PlayerNumber( pn )
{
iPersonalHighScoreIndexOut[pn] = -1;
iMachineHighScoreIndexOut[pn] = -1;
rcOut[pn] = RANKING_INVALID;
pdaToShowOut[pn] = PER_DIFFICULTY_AWARD_INVALID;
pcaToShowOut[pn] = PEAK_COMBO_AWARD_INVALID;
}
}
switch( GAMESTATE->m_PlayMode )
{
case PLAY_MODE_BATTLE:
case PLAY_MODE_RAVE:
return; /* don't save scores in battle */
}
if( PREFSMAN->m_bScreenTestMode )
{
FOREACH_PlayerNumber( pn )
{
iPersonalHighScoreIndexOut[pn] = 0;
iMachineHighScoreIndexOut[pn] = 0;
}
}
// don't save scores if the player chose not to
if( !GAMESTATE->m_SongOptions.m_bSaveScore )
return;
LOG->Trace( "saving stats and high scores" );
{
FOREACH_HumanPlayer( p )
{
// don't save scores if the player is disqualified
if( GAMESTATE->IsDisqualified(p) )
continue;
Song* pSong = GAMESTATE->m_pCurSong;
Steps* pSteps = GAMESTATE->m_pCurSteps[p];
// whether or not to save scores when the stage was failed
// depends on if this is a course or not ... it's handled
// below in the switch
HighScore &hs = m_HighScore[p];
hs.sName = RANKING_TO_FILL_IN_MARKER[p];
hs.grade = stageStats.m_player[p].GetGrade();
hs.iScore = stageStats.m_player[p].iScore;
hs.fPercentDP = stageStats.m_player[p].GetPercentDancePoints();
hs.fSurviveSeconds = stageStats.m_player[p].fAliveSeconds;
hs.sModifiers = GAMESTATE->m_pPlayerState[p]->m_PlayerOptions.GetString();
hs.dateTime = DateTime::GetNowDateTime();
hs.sPlayerGuid = PROFILEMAN->IsUsingProfile(p) ? PROFILEMAN->GetProfile(p)->m_sGuid : CString("");
hs.sMachineGuid = PROFILEMAN->GetMachineProfile()->m_sGuid;
hs.iProductID = PREFSMAN->m_iProductID;
memcpy( hs.iTapNoteScores, stageStats.m_player[p].iTapNoteScores, sizeof(hs.iTapNoteScores) );
memcpy( hs.iHoldNoteScores, stageStats.m_player[p].iHoldNoteScores, sizeof(hs.iHoldNoteScores) );
hs.radarValues = stageStats.m_player[p].radarActual;
StepsType st = GAMESTATE->GetCurrentStyle()->m_StepsType;
switch( m_Type )
{
case stage:
{
// don't save scores for a failed song
if( stageStats.m_player[p].bFailed )
continue;
ASSERT( pSteps );
PROFILEMAN->AddStepsScore( pSong, pSteps, p, hs, iPersonalHighScoreIndexOut[p], iMachineHighScoreIndexOut[p] );
}
break;
case summary:
{
// don't save scores if any stage was failed
if( stageStats.m_player[p].bFailed )
continue;
int iAverageMeter = stageStats.GetAverageMeter(p);
rcOut[p] = AverageMeterToRankingCategory( iAverageMeter );
PROFILEMAN->AddCategoryScore( st, rcOut[p], p, hs, iPersonalHighScoreIndexOut[p], iMachineHighScoreIndexOut[p] );
// TRICKY: Increment play count here, and not on ScreenGameplay like the others.
PROFILEMAN->IncrementCategoryPlayCount( st, rcOut[p], p );
}
break;
case course:
{
Course* pCourse = GAMESTATE->m_pCurCourse;
ASSERT( pCourse );
Trail* pTrail = GAMESTATE->m_pCurTrail[p];
PROFILEMAN->AddCourseScore( pCourse, pTrail, p, hs, iPersonalHighScoreIndexOut[p], iMachineHighScoreIndexOut[p] );
}
break;
default:
ASSERT(0);
}
}
}
LOG->Trace( "done saving stats and high scores" );
// If both players get a machine high score in the same HighScoreList,
// then one player's score may have bumped the other player. Look in
// the HighScoreList and re-get the high score index.
{
FOREACH_HumanPlayer( p )
{
if( iMachineHighScoreIndexOut[p] == -1 ) // no record
continue; // skip
HighScore &hs = m_HighScore[p];
Profile* pProfile = PROFILEMAN->GetMachineProfile();
StepsType st = GAMESTATE->GetCurrentStyle()->m_StepsType;
const HighScoreList *pHSL = NULL;
switch( m_Type )
{
case stage:
{
Song* pSong = GAMESTATE->m_pCurSong;
Steps* pSteps = GAMESTATE->m_pCurSteps[p];
pHSL = &pProfile->GetStepsHighScoreList( pSong, pSteps );
}
break;
case summary:
{
pHSL = &pProfile->GetCategoryHighScoreList( st, rcOut[p] );
}
break;
case course:
{
Course* pCourse = GAMESTATE->m_pCurCourse;
ASSERT( pCourse );
Trail *pTrail = GAMESTATE->m_pCurTrail[p];
ASSERT( pTrail );
pHSL = &pProfile->GetCourseHighScoreList( pCourse, pTrail );
}
break;
default:
ASSERT(0);
}
vector<HighScore>::const_iterator iter = find( pHSL->vHighScores.begin(), pHSL->vHighScores.end(), hs );
if( iter == pHSL->vHighScores.end() )
iMachineHighScoreIndexOut[p] = -1;
else
iMachineHighScoreIndexOut[p] = iter - pHSL->vHighScores.begin();
}
}
LOG->Trace( "hand out awards" );
{
FOREACH_HumanPlayer( p )
{
deque<PerDifficultyAward> &vPdas = GAMESTATE->m_vLastPerDifficultyAwards[p];
LOG->Trace( "per difficulty awards" );
// per-difficulty awards
switch( m_Type )
{
case stage:
// don't give per-difficutly awards if using easy mods
if( !GAMESTATE->IsDisqualified(p) )
{
if( stageStats.m_player[p].FullComboOfScore( TNS_GREAT ) )
vPdas.push_back( AWARD_FULL_COMBO_GREATS );
if( stageStats.m_player[p].SingleDigitsOfScore( TNS_GREAT ) )
vPdas.push_back( AWARD_SINGLE_DIGIT_GREATS );
if( stageStats.m_player[p].FullComboOfScore( TNS_PERFECT ) )
vPdas.push_back( AWARD_FULL_COMBO_PERFECTS );
if( stageStats.m_player[p].SingleDigitsOfScore( TNS_PERFECT ) )
vPdas.push_back( AWARD_SINGLE_DIGIT_PERFECTS );
if( stageStats.m_player[p].FullComboOfScore( TNS_MARVELOUS ) )
vPdas.push_back( AWARD_FULL_COMBO_MARVELOUSES );
if( stageStats.m_player[p].OneOfScore( TNS_GREAT ) )
vPdas.push_back( AWARD_ONE_GREAT );
if( stageStats.m_player[p].OneOfScore( TNS_PERFECT ) )
vPdas.push_back( AWARD_ONE_PERFECT );
float fPercentGreats = stageStats.m_player[p].GetPercentageOfTaps( TNS_GREAT );
if( fPercentGreats >= 0.8f )
vPdas.push_back( AWARD_GREATS_80_PERCENT );
if( fPercentGreats >= 0.9f )
vPdas.push_back( AWARD_GREATS_90_PERCENT );
if( fPercentGreats >= 1.f )
vPdas.push_back( AWARD_GREATS_100_PERCENT );
}
}
// Max one PDA per stage
if( !vPdas.empty() )
vPdas.erase( vPdas.begin(), vPdas.end()-1 );
if( !vPdas.empty() )
pdaToShowOut[p] = vPdas.back();
LOG->Trace( "done with per difficulty awards" );
// DO give peak combo awards if using easy mods
int iComboAtStartOfStage = stageStats.m_player[p].GetComboAtStartOfStage();
int iPeakCombo = stageStats.m_player[p].GetMaxCombo().cnt;
FOREACH_PeakComboAward( pca )
{
int iLevel = 1000 * (pca+1);
bool bCrossedLevel = iComboAtStartOfStage < iLevel && iPeakCombo >= iLevel;
LOG->Trace( "pca = %d, iLevel = %d, bCrossedLevel = %d", pca, iLevel, bCrossedLevel );
if( bCrossedLevel )
{
GAMESTATE->m_vLastPeakComboAwards[p].push_back( pca );
}
}
if( !GAMESTATE->m_vLastPeakComboAwards[p].empty() )
pcaToShowOut[p] = GAMESTATE->m_vLastPeakComboAwards[p].back();
LOG->Trace( "done with per combo awards" );
}
}
LOG->Trace( "done handing out awards." );
}
void ScreenEvaluation::TweenOffScreen()
{
// large banner area
OFF_COMMAND( m_LargeBanner );
OFF_COMMAND( m_sprLargeBannerFrame );
OFF_COMMAND( m_sprStage );
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_DifficultyIcon[p] );
OFF_COMMAND( m_DifficultyMeter[p] );
OFF_COMMAND( m_textPlayerOptions[p] );
OFF_COMMAND( m_sprDisqualified[p] );
}
// small banner area
for( int i=0; i<MAX_SONGS_TO_SHOW; i++ )
{
OFF_COMMAND( m_SmallBanner[i] );
OFF_COMMAND( m_sprSmallBannerFrame[i] );
}
// grade area
if( SHOW_GRADE_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprGradeFrame[p] );
OFF_COMMAND( m_Grades[p] );
OFF_COMMAND( m_sprGrade[p] );
}
}
if( SHOW_GRAPH_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprGraphFrame[p] );
OFF_COMMAND( m_Graph[p] );
}
}
if( SHOW_COMBO_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_Combo[p] );
}
}
// points area
if( SHOW_POINTS_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprPercentFrame[p] );
m_Percent[p].RunCommands( THEME->GetMetricA(m_sName,ssprintf("PercentP%dOffCommand",p+1)) );
m_Percent[p].TweenOffScreen();
}
}
// bonus area
if( SHOW_BONUS_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprBonusFrame[p] );
for( int r=0; r<NUM_SHOWN_RADAR_CATEGORIES; r++ ) // foreach line
{
OFF_COMMAND( m_sprPossibleBar[p][r] );
OFF_COMMAND( m_sprActualBar[p][r] );
}
}
}
// survived area
if( SHOW_SURVIVED_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprSurvivedFrame[p] );
OFF_COMMAND( m_textSurvivedNumber[p] );
}
}
// win area
if( SHOW_WIN_AREA )
{
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprWinFrame[p] );
OFF_COMMAND( m_sprWin[p] );
}
}
// judgement area
for( int l=0; l<NUM_JUDGE_LINES; l++ )
{
if( !SHOW_JUDGMENT(l) )
continue;
OFF_COMMAND( m_sprJudgeLabels[l] );
FOREACH_EnabledPlayer( p )
OFF_COMMAND( m_textJudgeNumbers[l][p] );
}
// stats area
for( int l=0; l<NUM_STATS_LINES; l++ )
{
if( !SHOW_STAT(l) )
continue;
OFF_COMMAND( m_sprStatsLabel[l] );
FOREACH_EnabledPlayer( p )
OFF_COMMAND( m_textStatsText[l][p] );
}
// score area
if( SHOW_SCORE_AREA )
{
OFF_COMMAND( m_sprScoreLabel );
FOREACH_EnabledPlayer( p )
OFF_COMMAND( m_textScore[p] );
}
// total score area
if( SHOW_TOTAL_SCORE_AREA )
{
OFF_COMMAND( m_sprTotalScoreLabel );
FOREACH_EnabledPlayer( p )
OFF_COMMAND( m_textTotalScore[p] );
}
// time area
if( SHOW_TIME_AREA )
{
OFF_COMMAND( m_sprTimeLabel );
FOREACH_EnabledPlayer( p )
OFF_COMMAND( m_textTime[p] );
}
// extra area
FOREACH_EnabledPlayer( p )
{
OFF_COMMAND( m_sprMachineRecord[p] );
OFF_COMMAND( m_sprPersonalRecord[p] );
if( m_PerDifficultyAward[p].IsLoaded() )
OFF_COMMAND( m_PerDifficultyAward[p] );
if( m_PeakComboAward[p].IsLoaded() )
OFF_COMMAND( m_PeakComboAward[p] );
}
OFF_COMMAND( m_sprTryExtraStage );
}
void ScreenEvaluation::Update( float fDeltaTime )
{
Screen::Update( fDeltaTime );
m_bgCondBga.Update(fDeltaTime);
if( !m_bPassFailTriggered )
{
float fTime = m_bFailed? FAILED_SOUND_TIME:PASSED_SOUND_TIME;
if( m_timerSoundSequences.Ago() > fTime )
{
if( !m_sndPassFail.IsPlaying() )
m_sndPassFail.Play();
m_bPassFailTriggered = true;
}
}
for( unsigned snd=0; snd<m_SoundSequences.size(); snd++ )
{
if(m_SoundSequences[snd].fTime != -1) // already played? skip...
{
if(m_timerSoundSequences.Ago() > m_SoundSequences[snd].fTime )
{
m_SoundSequences[snd].fTime = -1; // -1 indicates already started playing
m_SoundSequences[snd].sSound.Play();
}
}
}
FOREACH_EnabledPlayer( p )
{
if( g_CurStageStats.m_player[p].iBonus == 0 )
continue;
if( GAMESTATE->IsCourseMode() )
continue;
// wait a few seconds before adding bonus
if( RageTimer::GetTimeSinceStart() - m_fScreenCreateTime < 1.5f )
continue;
int increment = g_CurStageStats.m_player[p].iBonus/10;
/* XXX: What's this supposed to do? If i < 1, then min(i, 1024) is i ... */
if( increment < 1 )
increment = min( 1024, g_CurStageStats.m_player[p].iBonus );
g_CurStageStats.m_player[p].iBonus -= increment;
g_CurStageStats.m_player[p].iScore += increment;
if( SHOW_SCORE_AREA )
m_textScore[p].SetText( ssprintf("%*.0i", NUM_SCORE_DIGITS, g_CurStageStats.m_player[p].iScore) );
}
}
void ScreenEvaluation::DrawPrimitives()
{
m_bgCondBga.DrawPrimitives();
Screen::DrawPrimitives();
}
void ScreenEvaluation::Input( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
{
// LOG->Trace( "ScreenEvaluation::Input()" );
if( IsTransitioning() )
return;
if( GameI.IsValid() )
{
PlayerNumber pn = GAMESTATE->GetCurrentStyle()->ControllerToPlayerNumber( GameI.controller );
HighScore &hs = m_HighScore[pn];
if( CodeDetector::EnteredCode(GameI.controller, CodeDetector::CODE_SAVE_SCREENSHOT) )
{
if( !m_bSavedScreenshot[pn] && // only allow one screenshot
PROFILEMAN->IsUsingProfile(pn) )
{
if( PROFILEMAN->ProfileWasLoadedFromMemoryCard(pn) )
MEMCARDMAN->MountCard( pn );
Profile* pProfile = PROFILEMAN->GetProfile(pn);
CString sDir = PROFILEMAN->GetProfileDir((ProfileSlot)pn) + "Screenshots/";
int iScreenshotIndex = pProfile->GetNextScreenshotIndex();
CString sFileName = SaveScreenshot( sDir, true, true, iScreenshotIndex );
CString sPath = sDir+sFileName;
if( PROFILEMAN->ProfileWasLoadedFromMemoryCard(pn) )
MEMCARDMAN->UnmountCard( pn );
if( !sFileName.empty() )
{
Screenshot screenshot;
screenshot.sFileName = sFileName;
screenshot.sMD5 = CRYPTMAN->GetMD5( sPath );
screenshot.highScore = hs;
pProfile->AddScreenshot( screenshot );
}
m_bSavedScreenshot[pn] = true;
return; // handled
}
}
}
Screen::Input( DeviceI, type, GameI, MenuI, StyleI );
}
void ScreenEvaluation::HandleScreenMessage( const ScreenMessage SM )
{
switch( SM )
{
case SM_MenuTimer:
EndScreen();
break;
case SM_GoToNextScreen:
{
if( PREFSMAN->m_bEventMode )
SCREENMAN->SetNewScreen( NEXT_SCREEN );
else
{
/* Go to FAILED_SCREEN if we failed a non-extra stage. */
bool bReallyFailed = m_bFailed && !(GAMESTATE->IsExtraStage() || GAMESTATE->IsExtraStage2());
// If failed and not in event mode, go to the game over screen.
if( bReallyFailed )
{
SCREENMAN->SetNewScreen( FAILED_SCREEN );
break;
}
/* We passed. If we have another stage to play, go to NEXT_SCREEN. */
switch( m_Type )
{
case stage:
if( m_bTryExtraStage || !(GAMESTATE->IsFinalStage() || GAMESTATE->IsExtraStage() || GAMESTATE->IsExtraStage2() ) )
{
/* Finish the stage before moving on, so the stage counter will be correct
* for ScreenSelectMusic code which is called before the ctor. Grab NEXT_SCREEN
* first, NEXT_SCREEN is a Lua script that depends on the stage counter. */
CString sNextScreen = NEXT_SCREEN;
GAMESTATE->FinishStage();
SCREENMAN->SetNewScreen( sNextScreen );
break;
}
case summary:
case course:
SCREENMAN->SetNewScreen( END_SCREEN );
break;
}
}
if( m_sndPassFail.IsPlaying() )
m_sndPassFail.Stop();
break;
}
case SM_PlayCheer:
SOUND->PlayOnceFromDir( ANNOUNCER->GetPathTo("evaluation cheer") );
break;
}
}
void ScreenEvaluation::MenuLeft( PlayerNumber pn )
{
// What is the purpose of this? I keep my feet on the pads and
// was wondering why the grades weren't spinning. -Chris
// To be able to see the grade without having to wait for it to
// stop spinning. (I was hitting left repeatedly and wondering
// why it kept spinning ...)
//m_Grades[pn].SettleQuickly();
}
void ScreenEvaluation::MenuRight( PlayerNumber pn )
{
// What is the purpose of this? I keep my feet on the pads and
// was wondering why the grades weren't spinning. -Chris
//m_Grades[pn].SettleQuickly();
}
void ScreenEvaluation::MenuBack( PlayerNumber pn )
{
MenuStart( pn );
}
void ScreenEvaluation::MenuStart( PlayerNumber pn )
{
m_soundStart.Play();
EndScreen();
}
void ScreenEvaluation::EndScreen()
{
TweenOffScreen();
FOREACH_PlayerNumber( p )
m_Grades[p].SettleImmediately();
if( !PREFSMAN->m_bEventMode )
{
switch( m_Type )
{
case stage:
if( !m_bTryExtraStage && (GAMESTATE->IsFinalStage() || GAMESTATE->IsExtraStage() || GAMESTATE->IsExtraStage2()) )
{
/* Tween the screen out, but leave the MenuElements where they are.
* Play the "swoosh" sound manually (would normally be played by the ME
* tween out). */
TweenOffScreen();
}
break;
}
}
StartTransitioning( SM_GoToNextScreen );
}
/*
* (c) 2001-2004 Chris Danford
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, and/or sell copies of the Software, and to permit persons to
* whom the Software is furnished to do so, provided that the above
* copyright notice(s) and this permission notice appear in all copies of
* the Software and that both the above copyright notice(s) and this
* permission notice appear in supporting documentation.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
* THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
* INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
* OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
Reference in New Issue View Git Blame Copy Permalink