void ScoreKeeperNormal::HandleTapNoteScoreInternal( TapNoteScore tns, TapNoteScore maximum, int row )
{
// Update dance points.
if( !m_pPlayerStageStats->m_bFailed )
m_pPlayerStageStats->m_iActualDancePoints += TapNoteScoreToDancePoints( tns );
// update judged row totals. Respect Combo segments here.
TimingData &td = *GAMESTATE->m_pCurSteps[m_pPlayerState->m_PlayerNumber]->GetTimingData();
ComboSegment *cs = td.GetComboSegmentAtRow(row);
if (tns == TNS_CheckpointHit || tns >= m_MinScoreToContinueCombo)
{
m_pPlayerStageStats->m_iTapNoteScores[tns] += cs->GetCombo();
}
else if (tns == TNS_CheckpointMiss || tns < m_MinScoreToMaintainCombo)
{
m_pPlayerStageStats->m_iTapNoteScores[tns] += cs->GetMissCombo();
}
else
{
m_pPlayerStageStats->m_iTapNoteScores[tns] += 1;
}
// increment the current total possible dance score
m_pPlayerStageStats->m_iCurPossibleDancePoints += TapNoteScoreToDancePoints( maximum );
}
void ScoreKeeperNormal::HandleTapScore( const TapNote &tn )
{
TapNoteScore tns = tn.result.tns;
if( tn.type == TapNoteType_Mine )
{
if( tns == TNS_HitMine )
{
if( !m_pPlayerStageStats->m_bFailed )
m_pPlayerStageStats->m_iActualDancePoints += TapNoteScoreToDancePoints( TNS_HitMine );
m_pPlayerStageStats->m_iTapNoteScores[TNS_HitMine] += 1;
if( m_MineHitIncrementsMissCombo )
HandleComboInternal( 0, 0, 1 );
}
if( tns == TNS_AvoidMine && m_AvoidMineIncrementsCombo )
HandleComboInternal( 1, 0, 0 );
NSMAN->ReportScore(
m_pPlayerState->m_PlayerNumber,
tns,
m_pPlayerStageStats->m_iScore,
m_pPlayerStageStats->m_iCurCombo,
tn.result.fTapNoteOffset
);
Message msg( "ScoreChanged" );
msg.SetParam( "PlayerNumber", m_pPlayerState->m_PlayerNumber );
msg.SetParam( "MultiPlayer", m_pPlayerState->m_mp );
MESSAGEMAN->Broadcast( msg );
}
AddTapScore( tns );
}
void ScoreKeeperMAX2::HandleTapScore( TapNoteScore score )
{
if( score == TNS_HIT_MINE )
{
if( !m_pPlayerStageStats->bFailed )
m_pPlayerStageStats->iActualDancePoints += TapNoteScoreToDancePoints( TNS_HIT_MINE );
m_pPlayerStageStats->iTapNoteScores[TNS_HIT_MINE] += 1;
}
}
int ScoreKeeperMAX2::GetPossibleDancePoints( const RadarValues& radars )
{
/* Note that, if Marvelous timing is disabled or not active (not course mode),
* PERFECT will be used instead. */
int NumTaps = int(radars[RADAR_NUM_TAPS_AND_HOLDS]);
int NumHolds = int(radars[RADAR_NUM_HOLDS]);
int NumRolls = int(radars[RADAR_NUM_ROLLS]);
return
NumTaps*TapNoteScoreToDancePoints(TNS_MARVELOUS, false)+
NumHolds*HoldNoteScoreToDancePoints(HNS_OK, false) +
NumRolls*HoldNoteScoreToDancePoints(HNS_OK, false);
}
int ScoreKeeperNormal::GetPossibleDancePoints( NoteData* nd, const TimingData* td, float fSongSeconds )
{
/* Note: If W1 timing is disabled or not active (not course mode),
* W2 will be used instead. */
// XXX: That's not actually implemented!
RadarValues radars;
NoteDataUtil::CalculateRadarValues( *nd, fSongSeconds, radars );
int ret = 0;
ret += int(radars[RadarCategory_TapsAndHolds]) * TapNoteScoreToDancePoints(TNS_W1, false);
if( GAMESTATE->GetCurrentGame()->m_bTickHolds ) ret += NoteDataUtil::GetTotalHoldTicks( nd, td ) * g_iPercentScoreWeight.GetValue(SE_CheckpointHit);
ret += int(radars[RadarCategory_Holds]) * HoldNoteScoreToDancePoints(HNS_Held, false);
ret += int(radars[RadarCategory_Rolls]) * HoldNoteScoreToDancePoints(HNS_Held, false);
return ret;
}
int ScoreKeeperNormal::TapNoteScoreToDancePoints( TapNoteScore tns ) const
{
return TapNoteScoreToDancePoints( tns, m_bIsBeginner );
}
void ScoreKeeperMAX2::HandleTapRowScore( TapNoteScore scoreOfLastTap, int iNumTapsInRow )
{
ASSERT( iNumTapsInRow >= 1 );
// Update dance points.
if( !m_pPlayerStageStats->bFailed )
m_pPlayerStageStats->iActualDancePoints += TapNoteScoreToDancePoints( scoreOfLastTap );
m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_MARVELOUS );
// update judged row totals
m_pPlayerStageStats->iTapNoteScores[scoreOfLastTap] += 1;
// increment the current total possible dance score
m_pPlayerStageStats->iCurPossibleDancePoints += TapNoteScoreToDancePoints( TNS_MARVELOUS );
//
// Regular combo
//
const int iComboCountIfHit = m_bComboIsPerRow? 1: iNumTapsInRow;
if( scoreOfLastTap >= m_MinScoreToContinueCombo )
m_pPlayerStageStats->iCurCombo += iComboCountIfHit;
else
if( scoreOfLastTap < m_MinScoreToMaintainCombo )
m_pPlayerStageStats->iCurCombo = 0;
AddScore( scoreOfLastTap ); // only score once per row
//
// handle combo logic
//
#ifndef DEBUG
if( PREFSMAN->m_AutoPlay != PC_HUMAN && !GAMESTATE->m_bDemonstrationOrJukebox ) // cheaters never prosper
{
m_iCurToastyCombo = 0;
return;
}
#endif //DEBUG
//
// Toasty combo
//
switch( scoreOfLastTap )
{
case TNS_MARVELOUS:
case TNS_PERFECT:
m_iCurToastyCombo += iNumTapsInRow;
if( m_iCurToastyCombo >= 250 &&
m_iCurToastyCombo - iNumTapsInRow < 250 &&
!GAMESTATE->m_bDemonstrationOrJukebox )
{
SCREENMAN->PostMessageToTopScreen( SM_PlayToasty, 0 );
// TODO: keep a pointer to the Profile. Don't index with m_PlayerNumber
PROFILEMAN->IncrementToastiesCount( m_pPlayerState->m_PlayerNumber );
}
break;
default:
m_iCurToastyCombo = 0;
break;
}
// TODO: Remove indexing with PlayerNumber
PlayerNumber pn = m_pPlayerState->m_PlayerNumber;
NSMAN->ReportScore(pn, scoreOfLastTap,
m_pPlayerStageStats->iScore,
m_pPlayerStageStats->iCurCombo);
}