Chris Danford
513 lines
14 KiB
C++
513 lines
14 KiB
C++
#include "stdafx.h"
|
|
/*
|
|
-----------------------------------------------------------------------------
|
|
Class: ScreenGameplay
|
|
|
|
Desc: See header.
|
|
|
|
Copyright (c) 2001-2002 by the person(s) listed below. All rights reserved.
|
|
Chris Danford
|
|
-----------------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "ScreenGameplay.h"
|
|
#include "SongManager.h"
|
|
#include "ScreenManager.h"
|
|
|
|
#include "ScreenSelectMusic.h"
|
|
#include "ScreenResults.h"
|
|
#include "GameConstantsAndTypes.h"
|
|
#include "ThemeManager.h"
|
|
#include "GameManager.h"
|
|
#include "SongManager.h"
|
|
#include "RageLog.h"
|
|
#include "AnnouncerManager.h"
|
|
#include "ScreenGameOver.h"
|
|
|
|
//
|
|
// Defines specific to GameScreenTitleMenu
|
|
//
|
|
|
|
const float LIFE_X[NUM_PLAYERS] = { CENTER_X-180, CENTER_X+180 };
|
|
const float LIFE_Y = SCREEN_TOP+28;
|
|
|
|
const float SCORE_X[NUM_PLAYERS] = { CENTER_X-214, CENTER_X+214 };
|
|
const float SCORE_Y = SCREEN_BOTTOM-38;
|
|
|
|
const float DIFFICULTY_X[NUM_PLAYERS] = { SCREEN_LEFT+50, SCREEN_RIGHT-50 };
|
|
const float DIFFICULTY_Y = SCREEN_BOTTOM-80;
|
|
|
|
const float MAX_SECONDS_CAN_BE_OFF_BY = 0.20f;
|
|
|
|
const float TIME_BETWEEN_DANCING_COMMENTS = 15;
|
|
|
|
|
|
// received while STATE_DANCING
|
|
const ScreenMessage SM_SongEnded = ScreenMessage(SM_User+102);
|
|
const ScreenMessage SM_LifeIs0 = ScreenMessage(SM_User+103);
|
|
|
|
|
|
// received while STATE_OUTRO
|
|
const ScreenMessage SM_ShowCleared = ScreenMessage(SM_User+111);
|
|
const ScreenMessage SM_HideCleared = ScreenMessage(SM_User+112);
|
|
const ScreenMessage SM_GoToResults = ScreenMessage(SM_User+113);
|
|
|
|
const ScreenMessage SM_BeginFailed = ScreenMessage(SM_User+121);
|
|
const ScreenMessage SM_ShowFailed = ScreenMessage(SM_User+122);
|
|
const ScreenMessage SM_PlayFailComment = ScreenMessage(SM_User+123);
|
|
const ScreenMessage SM_HideFailed = ScreenMessage(SM_User+124);
|
|
const ScreenMessage SM_GoToScreenAfterFail = ScreenMessage(SM_User+125);
|
|
|
|
|
|
|
|
ScreenGameplay::ScreenGameplay()
|
|
{
|
|
LOG->WriteLine( "ScreenGameplay::ScreenGameplay()" );
|
|
|
|
m_DancingState = STATE_INTRO;
|
|
m_fTimeLeftBeforeDancingComment = TIME_BETWEEN_DANCING_COMMENTS;
|
|
|
|
m_bHasFailed = false;
|
|
m_pSong = SONGMAN->m_pCurSong;
|
|
|
|
|
|
m_Background.LoadFromSong( SONGMAN->m_pCurSong );
|
|
m_Background.SetDiffuseColor( D3DXCOLOR(0.4f,0.4f,0.4f,1) );
|
|
this->AddActor( &m_Background );
|
|
|
|
|
|
// Get the current StyleDef definition (used below)
|
|
StyleDef* pStyleDef = GAMEMAN->GetCurrentStyleDef();
|
|
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
|
|
continue;
|
|
|
|
float fDifficultyY = DIFFICULTY_Y;
|
|
if( PREFSMAN->m_PlayerOptions[p].m_bReverseScroll )
|
|
fDifficultyY = SCREEN_HEIGHT - DIFFICULTY_Y;
|
|
m_DifficultyBanner[p].SetXY( DIFFICULTY_X[p], fDifficultyY );
|
|
m_DifficultyBanner[p].SetFromNotes( SONGMAN->m_pCurNotes[p] );
|
|
this->AddActor( &m_DifficultyBanner[p] );
|
|
|
|
|
|
NoteData* pOriginalNoteData = SONGMAN->m_pCurNotes[p]->GetNoteData();
|
|
|
|
NoteData newNoteData;
|
|
GAMEMAN->GetCurrentStyleDef()->GetTransformedNoteDataForStyle( (PlayerNumber)p, pOriginalNoteData, newNoteData );
|
|
|
|
m_Player[p].SetX( (float) GAMEMAN->GetCurrentStyleDef()->m_iCenterX[p] );
|
|
m_Player[p].Load(
|
|
(PlayerNumber)p,
|
|
GAMEMAN->GetCurrentStyleDef(),
|
|
&newNoteData,
|
|
PREFSMAN->m_PlayerOptions[p],
|
|
&m_LifeMeter[p],
|
|
&m_ScoreDisplay[p]
|
|
);
|
|
|
|
this->AddActor( &m_Player[p] );
|
|
}
|
|
|
|
|
|
for( p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
|
|
continue;
|
|
|
|
m_LifeMeter[p].SetPlayerOptions( PREFSMAN->m_PlayerOptions[p] );
|
|
m_LifeMeter[p].SetXY( LIFE_X[p], LIFE_Y );
|
|
m_LifeMeter[p].SetZoomX( 256 );
|
|
m_LifeMeter[p].SetZoomY( 20 );
|
|
this->AddActor( &m_LifeMeter[p] );
|
|
}
|
|
|
|
m_sprTopFrame.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_TOP_FRAME) );
|
|
m_sprTopFrame.SetXY( CENTER_X, SCREEN_TOP + m_sprTopFrame.GetZoomedHeight()/2 );
|
|
this->AddActor( &m_sprTopFrame );
|
|
|
|
m_sprBottomFrame.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_BOTTOM_FRAME) );
|
|
m_sprBottomFrame.SetXY( CENTER_X, SCREEN_BOTTOM - m_sprBottomFrame.GetZoomedHeight()/2 );
|
|
this->AddActor( &m_sprBottomFrame );
|
|
|
|
m_textSmallStage.Load( THEME->GetPathTo(FONT_HEADER1) );
|
|
m_textSmallStage.TurnShadowOff();
|
|
m_textSmallStage.SetXY( CENTER_X, 60 );
|
|
m_textSmallStage.SetDiffuseColor( D3DXCOLOR(0.3f,1,1,1) );
|
|
m_textSmallStage.SetText( PREFSMAN->GetStageText() );
|
|
this->AddActor( &m_textSmallStage );
|
|
|
|
|
|
for( p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
|
|
continue;
|
|
|
|
m_ScoreDisplay[p].SetXY( SCORE_X[p], SCORE_Y );
|
|
m_ScoreDisplay[p].SetZoom( 0.8f );
|
|
this->AddActor( &m_ScoreDisplay[p] );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
m_StarWipe.SetClosed();
|
|
this->AddActor( &m_StarWipe );
|
|
|
|
m_sprReady.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_READY) );
|
|
m_sprReady.SetXY( CENTER_X, CENTER_Y );
|
|
m_sprReady.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
this->AddActor( &m_sprReady );
|
|
|
|
m_sprHereWeGo.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_HERE_WE_GO) );
|
|
m_sprHereWeGo.SetXY( CENTER_X, CENTER_Y );
|
|
m_sprHereWeGo.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
this->AddActor( &m_sprHereWeGo );
|
|
|
|
m_sprCleared.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_CLEARED) );
|
|
m_sprCleared.SetXY( CENTER_X, CENTER_Y );
|
|
m_sprCleared.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
this->AddActor( &m_sprCleared );
|
|
|
|
m_sprFailed.Load( THEME->GetPathTo(GRAPHIC_GAMEPLAY_FAILED) );
|
|
m_sprFailed.SetXY( CENTER_X, CENTER_Y );
|
|
m_sprFailed.SetDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
this->AddActor( &m_sprFailed );
|
|
|
|
|
|
m_soundMusic.Load( m_pSong->GetMusicPath() );
|
|
|
|
m_soundFail.Load( THEME->GetPathTo(SOUND_GAMEPLAY_FAILED) );
|
|
m_announcerReady.Load( ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_READY) );
|
|
m_announcerHereWeGo.Load( ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_HERE_WE_GO_NORMAL) );
|
|
m_announcerGood.Load( ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_COMMENT_GOOD) );
|
|
m_announcerBad.Load( ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_COMMENT_BAD) );
|
|
m_announcerCleared.Load( ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_CLEARED) );
|
|
m_announcerFailComment.Load(ANNOUNCER->GetPathTo(ANNOUNCER_GAMEPLAY_FAILED) );
|
|
|
|
m_soundAssistTick.Load( THEME->GetPathTo(SOUND_GAMEPLAY_ASSIST_TICK) );
|
|
|
|
|
|
// Send some messages every have second to we can get the introduction rolling
|
|
for( int i=0; i<30; i++ )
|
|
this->SendScreenMessage( ScreenMessage(SM_User+i), i/2.0f );
|
|
|
|
|
|
m_StarWipe.SetClosed();
|
|
}
|
|
|
|
ScreenGameplay::~ScreenGameplay()
|
|
{
|
|
LOG->WriteLine( "ScreenGameplay::~ScreenGameplay()" );
|
|
m_soundMusic.Stop();
|
|
}
|
|
|
|
|
|
void ScreenGameplay::Update( float fDeltaTime )
|
|
{
|
|
//LOG->WriteLine( "ScreenGameplay::Update(%f)", fDeltaTime );
|
|
Screen::Update( fDeltaTime );
|
|
|
|
|
|
float fSongBeat, fBPS;
|
|
float fPositionSeconds = m_soundMusic.GetPositionSeconds();
|
|
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( fPositionSeconds, fSongBeat, fBPS );
|
|
|
|
|
|
|
|
|
|
//LOG->WriteLine( "m_fOffsetInBeats = %f, m_fBeatsPerSecond = %f, m_Music.GetPositionSeconds = %f", m_fOffsetInBeats, m_fBeatsPerSecond, m_Music.GetPositionSeconds() );
|
|
|
|
float fMaxBeatDifference = fBPS*MAX_SECONDS_CAN_BE_OFF_BY;
|
|
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
|
|
continue;
|
|
m_Player[p].Update( fDeltaTime, fSongBeat, fMaxBeatDifference );
|
|
}
|
|
|
|
// check for fail
|
|
switch( PREFSMAN->m_SongOptions.m_FailType )
|
|
{
|
|
case SongOptions::FAIL_ARCADE:
|
|
case SongOptions::FAIL_END_OF_SONG:
|
|
|
|
if( m_bHasFailed )
|
|
break; // if they have already failed, don't bother checking again
|
|
|
|
{
|
|
// check for both players fail
|
|
bool bAllAboutToFail = true;
|
|
bool bAllFailed = true;
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled(PlayerNumber(p)) )
|
|
continue;
|
|
|
|
if( !m_LifeMeter[p].IsAboutToFail() )
|
|
{
|
|
bAllAboutToFail = false;
|
|
bAllFailed = false;
|
|
}
|
|
else if( !m_LifeMeter[p].HasFailed() )
|
|
{
|
|
bAllFailed = false;
|
|
}
|
|
break;
|
|
}
|
|
if( bAllAboutToFail ) m_Background.TurnDangerOn();
|
|
else m_Background.TurnDangerOff();
|
|
|
|
if( bAllFailed )
|
|
{
|
|
m_bHasFailed = true;
|
|
SCREENMAN->SendMessageToTopScreen( SM_LifeIs0, 0 );
|
|
}
|
|
}
|
|
break;
|
|
case SongOptions::FAIL_OFF:
|
|
break;
|
|
}
|
|
|
|
|
|
switch( m_DancingState )
|
|
{
|
|
case STATE_DANCING:
|
|
|
|
// Check for end of song
|
|
if( m_DancingState == STATE_DANCING &&
|
|
m_soundMusic.GetLengthSeconds() - m_soundMusic.GetPositionSeconds() < 2 )
|
|
this->SendScreenMessage( SM_SongEnded, 1 );
|
|
|
|
// Check to see if it's time to play a gameplay comment
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
{
|
|
m_fTimeLeftBeforeDancingComment -= fDeltaTime;
|
|
if( m_fTimeLeftBeforeDancingComment <= 0 )
|
|
{
|
|
m_fTimeLeftBeforeDancingComment = TIME_BETWEEN_DANCING_COMMENTS; // reset for the next comment
|
|
|
|
if( m_Background.IsDangerOn() )
|
|
m_announcerBad.PlayRandom();
|
|
else
|
|
m_announcerGood.PlayRandom();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
if( PREFSMAN->m_SongOptions.m_AssistType == SongOptions::ASSIST_TICK )
|
|
{
|
|
//
|
|
// play assist ticks
|
|
//
|
|
// Sound cards have a latency between when a sample is Play()ed and when the sound
|
|
// will start coming out the speaker. Compensate for this by boosting
|
|
// fPositionSeconds ahead
|
|
fPositionSeconds += (SOUND->GetPlayLatency()+0.06f) * m_soundMusic.GetPlaybackRate(); // HACK: Add 0.06 seconds to make them play a tiny bit earlier
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( fPositionSeconds, fSongBeat, fBPS );
|
|
|
|
int iIndexNow = BeatToNoteIndexNotRounded( fSongBeat );
|
|
static int iIndexLastCrossed = 0;
|
|
|
|
bool bAnyoneHasANote = false; // set this to true if any player has a note at one of the indicies we crossed
|
|
|
|
for( int i=iIndexLastCrossed+1; i<=iIndexNow; i++ ) // for each index we crossed since the last update
|
|
{
|
|
for( int p=0; p<NUM_PLAYERS; p++ )
|
|
{
|
|
if( !GAMEMAN->IsPlayerEnabled( (PlayerNumber)p ) )
|
|
continue; // skip
|
|
|
|
bAnyoneHasANote |= m_Player[p].IsThereANoteAtIndex( i );
|
|
break; // this will only play the tick for the first player that is joined
|
|
}
|
|
}
|
|
|
|
if( bAnyoneHasANote )
|
|
m_soundAssistTick.PlayRandom();
|
|
|
|
|
|
iIndexLastCrossed = iIndexNow;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void ScreenGameplay::DrawPrimitives()
|
|
{
|
|
Screen::DrawPrimitives();
|
|
}
|
|
|
|
|
|
void ScreenGameplay::Input( const DeviceInput& DeviceI, const InputEventType type, const GameInput &GameI, const MenuInput &MenuI, const StyleInput &StyleI )
|
|
{
|
|
//LOG->WriteLine( "ScreenGameplay::Input()" );
|
|
|
|
float fSongBeat, fBPS;
|
|
m_pSong->GetBeatAndBPSFromElapsedTime( m_soundMusic.GetPositionSeconds(), fSongBeat, fBPS );
|
|
|
|
|
|
if( MenuI.IsValid() )
|
|
{
|
|
switch( MenuI.button )
|
|
{
|
|
case MENU_BUTTON_BACK:
|
|
if( m_DancingState == STATE_DANCING
|
|
&& !m_bHasFailed )
|
|
{
|
|
m_bHasFailed = true;
|
|
SCREENMAN->SendMessageToTopScreen( SM_BeginFailed, 0 );
|
|
}
|
|
else
|
|
; // do not let user go back!
|
|
break;
|
|
}
|
|
}
|
|
|
|
float fMaxBeatsCanBeOffBy = MAX_SECONDS_CAN_BE_OFF_BY * fBPS;
|
|
|
|
if( type == IET_FIRST_PRESS )
|
|
{
|
|
if( StyleI.IsValid() )
|
|
{
|
|
m_Player[StyleI.player].HandlePlayerStep( fSongBeat, StyleI.col, fMaxBeatsCanBeOffBy );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScreenGameplay::HandleScreenMessage( const ScreenMessage SM )
|
|
{
|
|
switch( SM )
|
|
{
|
|
// received while STATE_INTRO
|
|
case SM_User+0:
|
|
m_StarWipe.OpenWipingRight(SM_None);
|
|
break;
|
|
case SM_User+1:
|
|
break;
|
|
case SM_User+2:
|
|
m_sprReady.StartFocusing();
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
m_announcerReady.PlayRandom();
|
|
break;
|
|
case SM_User+3:
|
|
break;
|
|
case SM_User+4:
|
|
m_sprReady.StartBlurring();
|
|
break;
|
|
case SM_User+5:
|
|
m_sprHereWeGo.StartFocusing();
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
m_announcerHereWeGo.PlayRandom();
|
|
m_Background.SetDiffuseColor( D3DXCOLOR(0.8f,0.8f,0.8f,1) );
|
|
m_soundMusic.Play();
|
|
m_soundMusic.SetPlaybackRate( PREFSMAN->m_SongOptions.m_fMusicRate );
|
|
break;
|
|
case SM_User+6:
|
|
break;
|
|
case SM_User+7:
|
|
break;
|
|
case SM_User+8:
|
|
m_sprHereWeGo.StartBlurring();
|
|
m_DancingState = STATE_DANCING; // STATE CHANGE! Now the user is allowed to press Back
|
|
break;
|
|
case SM_User+9:
|
|
break;
|
|
|
|
// received while STATE_DANCING
|
|
case SM_LifeIs0:
|
|
if( PREFSMAN->m_SongOptions.m_FailType == SongOptions::FAIL_ARCADE ) // fail them now!
|
|
this->SendScreenMessage( SM_BeginFailed, 0 );
|
|
m_DancingState = STATE_OUTRO;
|
|
break;
|
|
case SM_SongEnded:
|
|
if( m_DancingState == STATE_OUTRO ) // gameplay already ended
|
|
return; // ignore
|
|
|
|
if( m_bHasFailed ) // fail them
|
|
{
|
|
this->SendScreenMessage( SM_BeginFailed, 0 );
|
|
}
|
|
else // cleared
|
|
{
|
|
m_StarWipe.CloseWipingRight( SM_ShowCleared );
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
m_announcerCleared.PlayRandom(); // crowd cheer
|
|
}
|
|
m_DancingState = STATE_OUTRO;
|
|
break;
|
|
|
|
// received while STATE_OUTRO
|
|
case SM_ShowCleared:
|
|
m_sprCleared.StartFocusing();
|
|
SCREENMAN->SendMessageToTopScreen( SM_HideCleared, 2.5 );
|
|
break;
|
|
case SM_HideCleared:
|
|
m_sprCleared.StartBlurring();
|
|
SCREENMAN->SendMessageToTopScreen( SM_GoToResults, 1 );
|
|
break;
|
|
case SM_GoToResults:
|
|
// send score summaries to the PREFSMAN object so ScreenResults can grab it.
|
|
PREFSMAN->m_ScoreSummary[PLAYER_1] = m_Player[PLAYER_1].GetScoreSummary();
|
|
PREFSMAN->m_ScoreSummary[PLAYER_2] = m_Player[PLAYER_2].GetScoreSummary();
|
|
SCREENMAN->SetNewScreen( new ScreenResults );
|
|
break;
|
|
|
|
|
|
case SM_BeginFailed:
|
|
m_DancingState = STATE_OUTRO;
|
|
m_soundMusic.Pause();
|
|
m_StarWipe.CloseWipingRight( SM_None );
|
|
this->SendScreenMessage( SM_ShowFailed, 0.2f );
|
|
break;
|
|
case SM_ShowFailed:
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
m_soundFail.PlayRandom();
|
|
|
|
// make the background invisible so we don't waste mem bandwidth drawing it
|
|
m_Background.BeginTweening( 1 );
|
|
m_Background.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
|
|
m_sprFailed.SetZoom( 4 );
|
|
m_sprFailed.BeginBlurredTweening( 0.8f, TWEEN_BIAS_END );
|
|
m_sprFailed.SetTweenZoom( 0.5f ); // zoom out
|
|
m_sprFailed.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0.7f) ); // and fade in
|
|
m_sprFailed.BeginTweeningQueued( 0.3f );
|
|
m_sprFailed.SetTweenZoom( 1.1f ); // bounce
|
|
m_sprFailed.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0.7f) ); // and fade in
|
|
m_sprFailed.BeginTweeningQueued( 0.2f );
|
|
m_sprFailed.SetTweenZoom( 1.0f ); // come to rest
|
|
m_sprFailed.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0.7f) ); // and fade in
|
|
|
|
SCREENMAN->SendMessageToTopScreen( SM_PlayFailComment, 1.5f );
|
|
SCREENMAN->SendMessageToTopScreen( SM_HideFailed, 3.0f );
|
|
break;
|
|
case SM_PlayFailComment:
|
|
if( PREFSMAN->m_bAnnouncer )
|
|
m_announcerFailComment.PlayRandom();
|
|
break;
|
|
case SM_HideFailed:
|
|
m_sprFailed.StopTweening();
|
|
m_sprFailed.BeginTweening(1.0f);
|
|
m_sprFailed.SetTweenDiffuseColor( D3DXCOLOR(1,1,1,0) );
|
|
|
|
SCREENMAN->SendMessageToTopScreen( SM_GoToScreenAfterFail, 1.5f );
|
|
break;
|
|
case SM_GoToScreenAfterFail:
|
|
if( PREFSMAN->m_bEventMode )
|
|
SCREENMAN->SetNewScreen( new ScreenSelectMusic );
|
|
else
|
|
SCREENMAN->SetNewScreen( new ScreenGameOver );
|
|
break;
|
|
}
|
|
|
|
|
|
}
|