itgmania212121/stepmania/src/Player.cpp

#include "stdafx.h"
/*
-----------------------------------------------------------------------------
 File: Player.cpp

 Desc: Object that accepts pad input, knocks down ColorArrows that were stepped on, 
		and keeps score for the player.

 Copyright (c) 2001 Chris Danford.  All rights reserved.
-----------------------------------------------------------------------------
*/

#include "ScreenDimensions.h"
#include "Math.h" // for fabs()
#include "Player.h"
#include "RageUtil.h"
#include "ThemeManager.h"
#include "GameTypes.h"
#include "ArrowEffects.h"


const float JUDGEMENT_Y			= CENTER_Y;
const float ARROWS_Y			= SCREEN_TOP + ARROW_SIZE * 1.5f;
const float HOLD_JUDGEMENT_Y	= ARROWS_Y + 80;
const float LIFEMETER_Y			= SCREEN_TOP + 30;
const float COMBO_Y				= CENTER_Y + 60;
const float SCORE_Y				= SCREEN_HEIGHT - 40;

const float HOLD_ARROW_NG_TIME	=	0.27f;


Player::Player()
{

	m_fSongBeat = 0;
	m_PlayerNumber = PLAYER_NONE;

	// init step elements
	for( int i=0; i<MAX_TAP_STEP_ELEMENTS; i++ )
	{
		m_TapStepsOriginal[i] = STEP_NONE;
		m_TapStepsRemaining[i] = STEP_NONE;
		m_TapStepScores[i] = TSS_NONE;
	}
	m_iNumHoldSteps = 0;


	this->AddActor( &m_GrayArrows );
	this->AddActor( &m_ColorArrowField );
	this->AddActor( &m_GhostArrows );
	this->AddActor( &m_Judgement );
	for( int c=0; c<MAX_NUM_COLUMNS; c++ )
		this->AddActor( &m_HoldJudgement[c] );
	this->AddActor( &m_Combo );
	this->AddActor( &m_LifeMeter );
	this->AddActor( &m_Score );
}


void Player::Load( const Style& style, PlayerNumber player_no, const Steps& steps, const PlayerOptions& po )
{
	//RageLog( "Player::Load()", );

	m_Style = style;
	m_PlayerNumber = player_no;
	m_PlayerOptions = po;

	Steps steps2 = steps;

	if( !po.m_bAllowFreezeArrows )
		steps2.RemoveHoldSteps();

	steps2.Turn( po.m_TurnType );

	if( po.m_bLittle )
		steps2.MakeLittle();

	m_ColorArrowField.Load( style, steps2, po, 2, 10 );
	m_GrayArrows.Load( po, style );
	m_GhostArrows.Load( po, style );

	// load step elements
	for( int i=0; i<MAX_TAP_STEP_ELEMENTS; i++ )
	{
		m_TapStepsOriginal[i] = steps2.m_TapSteps[i];
		m_TapStepsRemaining[i] = steps2.m_TapSteps[i];
	}
	for( i=0; i<steps2.m_iNumHoldSteps; i++ )
	{
		m_HoldSteps[i] = steps2.m_HoldSteps[i];
	}
	m_iNumHoldSteps = steps2.m_iNumHoldSteps;


	m_Combo.SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - COMBO_Y : COMBO_Y );
	m_LifeMeter.SetY( LIFEMETER_Y );
	m_Judgement.SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - JUDGEMENT_Y : JUDGEMENT_Y );
	for( int c=0; c<MAX_NUM_COLUMNS; c++ )
		m_HoldJudgement[c].SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - HOLD_JUDGEMENT_Y : HOLD_JUDGEMENT_Y );
	m_Score.SetY( SCORE_Y );	

	m_ColorArrowField.SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - ARROWS_Y : ARROWS_Y );
	m_GrayArrows.SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - ARROWS_Y : ARROWS_Y );
	m_GhostArrows.SetY( po.m_bReverseScroll ? SCREEN_HEIGHT - ARROWS_Y : ARROWS_Y );
	

}

void Player::Update( float fDeltaTime, float fSongBeat, float fMaxBeatDifference )
{
	//RageLog( "Player::Update(%f, %f, %f)", fDeltaTime, fSongBeat, fMaxBeatDifference );


	//
	// Check for TapStep misses
	//
	int iNumMisses = UpdateStepsMissedOlderThan( m_fSongBeat-fMaxBeatDifference );
	if( iNumMisses > 0 )
	{
		m_Judgement.SetJudgement( TSS_MISS );
		m_Combo.EndCombo();
		for( int i=0; i<iNumMisses; i++ )
			m_LifeMeter.ChangeLife( TSS_MISS );
	}


	//
	// update HoldSteps logic
	//
	for( int i=0; i<m_iNumHoldSteps; i++ )		// for each HoldStep
	{
		HoldStep &hs = m_HoldSteps[i];
		HoldStepScore &hss = m_HoldStepScores[i];

		if( hss.m_Result != HSR_NONE )	// if this HoldStep already has a result
			continue;	// we don't need to update the logic for this one

		float fStartBeat = StepIndexToBeat( (float)hs.m_iStartIndex );
		float fEndBeat = StepIndexToBeat( (float)hs.m_iEndIndex );


		// update the life
		if( fStartBeat < m_fSongBeat && m_fSongBeat < fEndBeat )	// if the song beat is in the range of this hold
		{
			PlayerInput PlayerI( m_PlayerNumber, hs.m_TapStep );
			bool bIsHoldingButton = PREFS->IsButtonDown( PlayerI );
			if( bIsHoldingButton )
			{
				hss.m_fLife += fDeltaTime/HOLD_ARROW_NG_TIME;
				hss.m_fLife = min( hss.m_fLife, 1 );	// clamp
				int iCol = m_Style.TapStepToColumnNumber( hs.m_TapStep );
				m_GhostArrows.HoldStep( iCol );		// update the "electric ghost" effect
			}
			else	// !bIsHoldingButton
			{
				hss.m_fLife -= fDeltaTime/HOLD_ARROW_NG_TIME;
				hss.m_fLife = max( hss.m_fLife, 0 );	// clamp
			}
			m_ColorArrowField.SetHoldStepLife( i, hss.m_fLife );	// update the ColorArrowField display
		}

		// check for NG
		if( hss.m_fLife == 0 )	// the player has not pressed the button for a long time!
		{
			hss.m_Result = HSR_NG;
			int iCol = m_Style.TapStepToColumnNumber( hs.m_TapStep );
			m_HoldJudgement[iCol].SetHoldJudgement( HSR_NG );
		}

		// check for OK
		if( m_fSongBeat > fEndBeat )	// if this HoldStep is in the past
		{
			// this implies that hss.m_fLife > 0, or else we would have marked it NG above
			hss.m_fLife = 1;
			hss.m_Result = HSR_OK;
			int iCol = m_Style.TapStepToColumnNumber( hs.m_TapStep );
			m_HoldJudgement[iCol].SetHoldJudgement( HSR_OK );
			m_ColorArrowField.SetHoldStepLife( i, hss.m_fLife );	// update the ColorArrowField display
		}
	}



	ActorFrame::Update( fDeltaTime );

	m_LifeMeter.SetBeat( fSongBeat );

	m_GrayArrows.Update( fDeltaTime, fSongBeat );
	m_ColorArrowField.Update( fDeltaTime, fSongBeat );
	m_GhostArrows.Update( fDeltaTime, fSongBeat );

	m_fSongBeat = fSongBeat;	// save song beat

}

void Player::RenderPrimitives()
{
	D3DXMATRIX matOldView, matOldProj;

	if( m_PlayerOptions.m_EffectType == PlayerOptions::EFFECT_SPACE )
	{
		// turn off Z Buffering
		SCREEN->GetDevice()->SetRenderState( D3DRS_ZENABLE,      FALSE );
		SCREEN->GetDevice()->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );

		// save old view and projection
		SCREEN->GetDevice()->GetTransform( D3DTS_VIEW, &matOldView );
		SCREEN->GetDevice()->GetTransform( D3DTS_PROJECTION, &matOldProj );


		// construct view and project matrix
		D3DXMATRIX matNewView;
		D3DXMatrixLookAtLH( &matNewView, &D3DXVECTOR3( CENTER_X, GetY()+800.0f, 300.0f ), 
										 &D3DXVECTOR3( CENTER_X
										 , GetY()+400.0f,   0.0f ), 
										 &D3DXVECTOR3(          0.0f,         -1.0f,   0.0f ) );
		SCREEN->GetDevice()->SetTransform( D3DTS_VIEW, &matNewView );

		D3DXMATRIX matNewProj;
		D3DXMatrixPerspectiveFovLH( &matNewProj, D3DX_PI/4.0f, SCREEN_WIDTH/(float)SCREEN_HEIGHT, 0.0f, 1000.0f );
		SCREEN->GetDevice()->SetTransform( D3DTS_PROJECTION, &matNewProj );
	}

	m_GrayArrows.Draw();
	m_ColorArrowField.Draw();
	m_GhostArrows.Draw();

	if( m_PlayerOptions.m_EffectType == PlayerOptions::EFFECT_SPACE )
	{
		// restire old view and projection
		SCREEN->GetDevice()->SetTransform( D3DTS_VIEW, &matOldView );
		SCREEN->GetDevice()->SetTransform( D3DTS_PROJECTION, &matOldProj );

		// turn Z Buffering back on
		SCREEN->GetDevice()->SetRenderState( D3DRS_ZENABLE,      TRUE );
		SCREEN->GetDevice()->SetRenderState( D3DRS_ZWRITEENABLE, TRUE );
	}


	m_Judgement.Draw();
	for( int c=0; c<m_Style.m_iNumColumns; c++ )
		m_HoldJudgement[c].Draw();
	m_Combo.Draw();
	m_LifeMeter.Draw();
	m_Score.Draw();


}

bool Player::IsThereANoteAtIndex( int iIndex )
{
	if( m_TapStepsOriginal[iIndex] != STEP_NONE )
		return true;

	for( int i=0; i<m_iNumHoldSteps; i++ )	// for each HoldStep
	{
		if( m_HoldSteps[i].m_iStartIndex == iIndex )
			return true;
	}

	return false;
}




void Player::HandlePlayerStep( float fSongBeat, TapStep player_step, float fMaxBeatDiff )
{
	//RageLog( "Player::HandlePlayerStep()" );

	int iColumnNum = m_Style.TapStepToColumnNumber( player_step );
	if( iColumnNum == -1 )	// if this TapStep is not used in the current Style
		return;		// ignore the step

	m_GrayArrows.Step( iColumnNum );

	CheckForCompleteStep( fSongBeat, player_step, fMaxBeatDiff );

	//
	// check if we stepped on the TapStep part of a HoldStep
	//
	for( int i=0; i<m_iNumHoldSteps; i++ )	// for each HoldStep
	{
		HoldStep& hs		= m_HoldSteps[i];
		HoldStepScore& hss	= m_HoldStepScores[i];

		if( hss.m_Result != HSR_NONE )	// if this note already has a score
			continue;	// we don't need to update its logic

		if( hss.m_TapStepScore != TSS_NONE )	// the TapStep already has a score
			continue;	// no need to continue;
			
		if( player_step == m_HoldSteps[i].m_TapStep ) // the player's step is the same as this HoldStep
		{
			float fBeatDifference = fabsf( StepIndexToBeat(hs.m_iStartIndex) - fSongBeat );
			
			if( fBeatDifference <= fMaxBeatDiff )
			{
				float fBeatsUntilStep = StepIndexToBeat( (float)hs.m_iStartIndex ) - fSongBeat;
				float fPercentFromPerfect = fabsf( fBeatsUntilStep / fMaxBeatDiff );

				//RageLog( "fBeatsUntilStep: %f, fPercentFromPerfect: %f", 
				//		 fBeatsUntilStep, fPercentFromPerfect );

				// compute what the score should be for the note we stepped on
				TapStepScore &score = hss.m_TapStepScore;
				if(		 fPercentFromPerfect < 0.25f )	score = TSS_PERFECT;
				else if( fPercentFromPerfect < 0.50f )	score = TSS_GREAT;
				else if( fPercentFromPerfect < 0.75f )	score = TSS_GOOD;
				else									score = TSS_BOO;

				// update the judgement, score, and life
				m_Judgement.SetJudgement( score );
				m_Score.AddToScore( score, m_Combo.GetCurrentCombo() );
				m_LifeMeter.ChangeLife( score );

				// show the gray arrow ghost
				int iColNum = m_Style.TapStepToColumnNumber( player_step );
				m_GhostArrows.TapStep( iColNum, score, m_Combo.GetCurrentCombo() > 100 );

				// update the combo display
				switch( score )
				{
				case TSS_PERFECT:
				case TSS_GREAT:
					m_Combo.ContinueCombo();
					break;
				case TSS_GOOD:
				case TSS_BOO:
					m_Combo.EndCombo();
					break;
				}


			}
		}
	}

}


void Player::CheckForCompleteStep( float fSongBeat, TapStep player_step, float fMaxBeatDiff )
{
	//RageLog( "Player::CheckForCompleteStep()" );

	// look for the closest matching step
	int iIndexStartLookingAt = BeatToStepIndex( fSongBeat );
	int iNumElementsToExamine = BeatToStepIndex( fMaxBeatDiff );	// number of elements to examine on either end of iIndexStartLookingAt
	
	//RageLog( "iIndexStartLookingAt = %d, iNumElementsToExamine = %d", iIndexStartLookingAt, iNumElementsToExamine );

	// Start at iIndexStartLookingAt and search outward.  The first one that overlaps the player's step is the closest match.
	for( int delta=0; delta <= iNumElementsToExamine; delta++ )
	{
		int iCurrentIndexEarlier = iIndexStartLookingAt - delta;
		int iCurrentIndexLater   = iIndexStartLookingAt + delta;

		// silly check to make sure we don't go out of bounds
		iCurrentIndexEarlier	= clamp( iCurrentIndexEarlier, 0, MAX_TAP_STEP_ELEMENTS-1 );
		iCurrentIndexLater		= clamp( iCurrentIndexLater,   0, MAX_TAP_STEP_ELEMENTS-1 );

		////////////////////////////
		// check the step to the left of iIndexStartLookingAt
		////////////////////////////
		//RageLog( "Checking steps[%d]", iCurrentIndexEarlier );
		if( m_TapStepsRemaining[iCurrentIndexEarlier] & player_step )	// these steps overlap
		{
			m_TapStepsRemaining[iCurrentIndexEarlier] &= ~player_step;	// subtract player_step
			if( m_TapStepsRemaining[iCurrentIndexEarlier] == 0 )	{		// did this complete the step?
				OnCompleteStep( fSongBeat, player_step, fMaxBeatDiff, iCurrentIndexEarlier );
				return;
			}
		}

		////////////////////////////
		// check the step to the right of iIndexStartLookingAt
		////////////////////////////
		//RageLog( "Checking steps[%d]", iCurrentIndexLater );
		if( m_TapStepsRemaining[iCurrentIndexLater] & player_step )		// these steps overlap
		{
			m_TapStepsRemaining[iCurrentIndexLater] &= ~player_step;		// subtract player_step
			if( m_TapStepsRemaining[iCurrentIndexLater] == 0 ) {			// did this complete the step?
				OnCompleteStep( fSongBeat, player_step, fMaxBeatDiff, iCurrentIndexLater );
				return;
			}
		}
	}
}

void Player::OnCompleteStep( float fSongBeat, TapStep player_step, float fMaxBeatDiff, int iIndexThatWasSteppedOn )
{
	float fStepBeat = StepIndexToBeat( (float)iIndexThatWasSteppedOn );

 
	float fBeatsUntilStep = fStepBeat - fSongBeat;
	float fPercentFromPerfect = fabsf( fBeatsUntilStep / fMaxBeatDiff );

	//RageLog( "fBeatsUntilStep: %f, fPercentFromPerfect: %f", 
	//		 fBeatsUntilStep, fPercentFromPerfect );

	// compute what the score should be for the note we stepped on
	TapStepScore &score = m_TapStepScores[iIndexThatWasSteppedOn];

	if(		 fPercentFromPerfect < 0.25f )	score = TSS_PERFECT;
	else if( fPercentFromPerfect < 0.50f )	score = TSS_GREAT;
	else if( fPercentFromPerfect < 0.75f )	score = TSS_GOOD;
	else									score = TSS_BOO;

	// update the judgement, score, and life
	m_Judgement.SetJudgement( score );
	m_Score.AddToScore( score, m_Combo.GetCurrentCombo() );
	m_LifeMeter.ChangeLife( score );


	// remove this row from the ColorArrowField
	m_ColorArrowField.RemoveTapStepRow( iIndexThatWasSteppedOn );

	// check to see if this completes a row of notes
	for( int c=0; c<m_Style.m_iNumColumns; c++ )	// for each column
	{
		if( m_TapStepsOriginal[iIndexThatWasSteppedOn] & m_Style.m_ColumnToTapStep[c] )	// if this colum was part of the original step
			m_GhostArrows.TapStep( c, score, m_Combo.GetCurrentCombo()>100 );	// show the ghost arrow for this column
	}

	// update the combo display
	switch( score )
	{
	case TSS_PERFECT:
	case TSS_GREAT:
		m_Combo.ContinueCombo();
		break;
	case TSS_GOOD:
	case TSS_BOO:
		m_Combo.EndCombo();
		break;
	}
}


ScoreSummary Player::GetScoreSummary()
{
	ScoreSummary scoreSummary;

	for( int i=0; i<MAX_TAP_STEP_ELEMENTS; i++ ) 
	{
		switch( m_TapStepScores[i] )
		{
		case TSS_PERFECT:	scoreSummary.perfect++;		break;
		case TSS_GREAT:		scoreSummary.great++;		break;
		case TSS_GOOD:		scoreSummary.good++;		break;
		case TSS_BOO:		scoreSummary.boo++;			break;
		case TSS_MISS:		scoreSummary.miss++;		break;
		case TSS_NONE:									break;
		default:		ASSERT( false );
		}
	}
	for( i=0; i<m_iNumHoldSteps; i++ ) 
	{
		switch( m_HoldStepScores[i].m_TapStepScore )
		{
		case TSS_PERFECT:	scoreSummary.perfect++;		break;
		case TSS_GREAT:		scoreSummary.great++;		break;
		case TSS_GOOD:		scoreSummary.good++;		break;
		case TSS_BOO:		scoreSummary.boo++;			break;
		case TSS_MISS:		scoreSummary.miss++;		break;
		case TSS_NONE:									break;
		default:		ASSERT( false );
		}
		switch( m_HoldStepScores[i].m_Result )
		{
		case HSR_NG:		scoreSummary.ng++;		break;
		case HSR_OK:		scoreSummary.ok++;		break;
		case HSR_NONE:								break;
		default:		ASSERT( false );
		}
	}
	scoreSummary.max_combo = m_Combo.GetMaxCombo();
	scoreSummary.score = m_Score.GetScore();
	
	return scoreSummary;
}


int Player::UpdateStepsMissedOlderThan( float fMissIfOlderThanThisBeat )
{
	//RageLog( "Steps::UpdateStepsMissedOlderThan(%f)", fMissIfOlderThanThisBeat );

	int iMissIfOlderThanThisIndex = BeatToStepIndex( fMissIfOlderThanThisBeat );

	int iNumMissesFound = 0;
	// Since this is being called frame, let's not check the whole array every time.
	// Instead, only check 10 elements back.  Even 10 is overkill.
	int iStartCheckingAt = max( 0, iMissIfOlderThanThisIndex-10 );

	//RageLog( "iStartCheckingAt: %d   iMissIfOlderThanThisIndex:  %d", iStartCheckingAt, iMissIfOlderThanThisIndex );
	for( int i=iStartCheckingAt; i<iMissIfOlderThanThisIndex; i++ )
	{
		//RageLog( "Checking for miss:  %d: lefttostepon == %d, score == %d", i, m_LeftToStepOn[i], m_StepScore[i] );
		if( m_TapStepsRemaining[i] != 0  &&  m_TapStepScores[i] != TSS_MISS )
		{
			m_TapStepScores[i] = TSS_MISS;
			iNumMissesFound++;
			m_LifeMeter.ChangeLife( TSS_MISS );
		}
	}

	return iNumMissesFound;
}