[splittiming] Compiles and links.

Not guaranteed to work. Adjustments to GameState
and SongPosition may still be needed.

src/BeginnerHelper.cpp

@@ -191,7 +191,7 @@ void BeginnerHelper::ShowStepCircle( PlayerNumber pn, int CSTEP )
 	m_sStepCircle[pn][isc].StopEffect();
 	m_sStepCircle[pn][isc].SetZoom( 2 );
 	m_sStepCircle[pn][isc].StopTweening();
-	m_sStepCircle[pn][isc].BeginTweening( GAMESTATE->m_fCurBPS/3, TWEEN_LINEAR );
+	m_sStepCircle[pn][isc].BeginTweening( GAMESTATE->m_Position.m_fCurBPS/3, TWEEN_LINEAR );
 	m_sStepCircle[pn][isc].SetZoom( 0 );
 }
 
@@ -318,19 +318,19 @@ void BeginnerHelper::Step( PlayerNumber pn, int CSTEP )
 		ShowStepCircle( pn, ST_DOWN );
 		m_pDancer[pn]->StopTweening();
 		m_pDancer[pn]->PlayAnimation( "Step-JUMPLR", 1.5f );
-		m_pDancer[pn]->BeginTweening( GAMESTATE->m_fCurBPS/8, TWEEN_LINEAR );
+		m_pDancer[pn]->BeginTweening( GAMESTATE->m_Position.m_fCurBPS/8, TWEEN_LINEAR );
 		m_pDancer[pn]->SetRotationY( 90 );
-		m_pDancer[pn]->BeginTweening( 1/(GAMESTATE->m_fCurBPS * 2) ); //sleep between jump-frames
-		m_pDancer[pn]->BeginTweening( GAMESTATE->m_fCurBPS /6, TWEEN_LINEAR );
+		m_pDancer[pn]->BeginTweening( 1/(GAMESTATE->m_Position.m_fCurBPS * 2) ); //sleep between jump-frames
+		m_pDancer[pn]->BeginTweening( GAMESTATE->m_Position.m_fCurBPS /6, TWEEN_LINEAR );
 		m_pDancer[pn]->SetRotationY( 0 );
 		break;
 	}
 
 	m_sFlash.StopEffect();
 	m_sFlash.StopTweening();
-	m_sFlash.Sleep( GAMESTATE->m_fCurBPS/16 );
+	m_sFlash.Sleep( GAMESTATE->m_Position.m_fCurBPS/16 );
 	m_sFlash.SetDiffuseAlpha( 1 );
-	m_sFlash.BeginTweening( 1/GAMESTATE->m_fCurBPS * 0.5f );
+	m_sFlash.BeginTweening( 1/GAMESTATE->m_Position.m_fCurBPS * 0.5f );
 	m_sFlash.SetDiffuseAlpha( 0 );
 }
 
@@ -340,7 +340,7 @@ void BeginnerHelper::Update( float fDeltaTime )
 		return;
 
 	// the row we want to check on this update
-	int iCurRow = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat + 0.4f );
+	int iCurRow = BeatToNoteRowNotRounded( GAMESTATE->m_Position.m_fSongBeat + 0.4f );
 	FOREACH_EnabledPlayer( pn )
 	{
 		for( int iRow=m_iLastRowChecked; iRow<iCurRow; iRow++ )
@@ -369,7 +369,7 @@ void BeginnerHelper::Update( float fDeltaTime )
 	m_pDancePad->Update( fDeltaTime );
 	m_sFlash.Update( fDeltaTime );
 
-	float beat = fDeltaTime*GAMESTATE->m_fCurBPS;
+	float beat = fDeltaTime*GAMESTATE->m_Position.m_fCurBPS;
 	// If this is not a human player, the dancer is not shown
 	FOREACH_HumanPlayer( pu )
 	{

src/GameSoundManager.cpp

@@ -201,7 +201,7 @@ static void StartMusic( MusicToPlay &ToPlay )
 	{
 		/* This song has no real timing data.  The offset is arbitrary.  Change it so
 		 * the beat will line up to where we are now, so we don't have to delay. */
-		float fDestBeat = fmodfp( GAMESTATE->m_fSongBeatNoOffset, 1 );
+		float fDestBeat = fmodfp( GAMESTATE->m_Position.m_fSongBeatNoOffset, 1 );
 		float fTime = NewMusic->m_NewTiming.GetElapsedTimeFromBeatNoOffset( fDestBeat );
 
 		NewMusic->m_NewTiming.m_fBeat0OffsetInSeconds = fTime;
@@ -223,7 +223,7 @@ static void StartMusic( MusicToPlay &ToPlay )
 		 * common when starting a precached sound, but our sound isn't, so it'll
 		 * probably take a little longer.  Nudge the latency up. */
 		const float fPresumedLatency = SOUNDMAN->GetPlayLatency() + 0.040f;
-		const float fCurSecond = GAMESTATE->m_fMusicSeconds + fPresumedLatency;
+		const float fCurSecond = GAMESTATE->m_Position.m_fMusicSeconds + fPresumedLatency;
 		const float fCurBeat = g_Playing->m_Timing.GetBeatFromElapsedTimeNoOffset( fCurSecond );
 
 		/* The beat that the new sound will start on. */
@@ -236,9 +236,9 @@ static void StartMusic( MusicToPlay &ToPlay )
 
 		const float fSecondToStartOn = g_Playing->m_Timing.GetElapsedTimeFromBeatNoOffset( fCurBeatToStartOn );
 		const float fMaximumDistance = 2;
-		const float fDistance = min( fSecondToStartOn - GAMESTATE->m_fMusicSeconds, fMaximumDistance );
+		const float fDistance = min( fSecondToStartOn - GAMESTATE->m_Position.m_fMusicSeconds, fMaximumDistance );
 
-		when = GAMESTATE->m_LastBeatUpdate + fDistance;
+		when = GAMESTATE->m_Position.m_LastBeatUpdate + fDistance;
 	}
 
 	/* Important: don't hold the mutex while we load and seek the actual sound. */
@@ -552,8 +552,8 @@ void GameSoundManager::Update( float fDeltaTime )
 	if( !g_Playing->m_Music->IsPlaying() )
 	{
 		/* There's no song playing.  Fake it. */
-		CHECKPOINT_M( ssprintf("%f, delta %f", GAMESTATE->m_fMusicSeconds, fDeltaTime) );
-		GAMESTATE->UpdateSongPosition( GAMESTATE->m_fMusicSeconds + fDeltaTime, g_Playing->m_Timing );
+		CHECKPOINT_M( ssprintf("%f, delta %f", GAMESTATE->m_Position.m_fMusicSeconds, fDeltaTime) );
+		GAMESTATE->UpdateSongPosition( GAMESTATE->m_Position.m_fMusicSeconds + fDeltaTime, g_Playing->m_Timing );
 		return;
 	}
 
@@ -570,8 +570,8 @@ void GameSoundManager::Update( float fDeltaTime )
 	//
 	if( PREFSMAN->m_bLogSkips && !g_Playing->m_bTimingDelayed )
 	{
-		const float fExpectedTimePassed = (tm - GAMESTATE->m_LastBeatUpdate) * g_Playing->m_Music->GetPlaybackRate();
-		const float fSoundTimePassed = fSeconds - GAMESTATE->m_fMusicSeconds;
+		const float fExpectedTimePassed = (tm - GAMESTATE->m_Position.m_LastBeatUpdate) * g_Playing->m_Music->GetPlaybackRate();
+		const float fSoundTimePassed = fSeconds - GAMESTATE->m_Position.m_fMusicSeconds;
 		const float fDiff = fExpectedTimePassed - fSoundTimePassed;
 
 		static RString sLastFile = "";
@@ -580,7 +580,7 @@ void GameSoundManager::Update( float fDeltaTime )
 		/* If fSoundTimePassed < 0, the sound has probably looped. */
 		if( sLastFile == ThisFile && fSoundTimePassed >= 0 && fabsf(fDiff) > 0.003f )
 			LOG->Trace("Song position skip in %s: expected %.3f, got %.3f (cur %f, prev %f) (%.3f difference)",
-				Basename(ThisFile).c_str(), fExpectedTimePassed, fSoundTimePassed, fSeconds, GAMESTATE->m_fMusicSeconds, fDiff );
+				Basename(ThisFile).c_str(), fExpectedTimePassed, fSoundTimePassed, fSeconds, GAMESTATE->m_Position.m_fMusicSeconds, fDiff );
 		sLastFile = ThisFile;
 	}
 
@@ -599,7 +599,7 @@ void GameSoundManager::Update( float fDeltaTime )
 	{
 		/* We're still waiting for the new sound to start playing, so keep using the
 		 * old timing data and fake the time. */
-		GAMESTATE->UpdateSongPosition( GAMESTATE->m_fMusicSeconds + fDeltaTime, g_Playing->m_Timing );
+		GAMESTATE->UpdateSongPosition( GAMESTATE->m_Position.m_fMusicSeconds + fDeltaTime, g_Playing->m_Timing );
 	}
 	else
 	{
@@ -614,7 +614,7 @@ void GameSoundManager::Update( float fDeltaTime )
 	{
 		static int iBeatLastCrossed = 0;
 
-		float fSongBeat = GAMESTATE->m_fSongBeat;
+		float fSongBeat = GAMESTATE->m_Position.m_fSongBeat;
 
 		int iRowNow = BeatToNoteRowNotRounded( fSongBeat );
 		iRowNow = max( 0, iRowNow );
@@ -638,7 +638,7 @@ void GameSoundManager::Update( float fDeltaTime )
 	NoteData &lights = g_Playing->m_Lights;
 	if( lights.GetNumTracks() > 0 )	// lights data was loaded
 	{
-		const float fSongBeat = GAMESTATE->m_fLightSongBeat;
+		const float fSongBeat = GAMESTATE->m_Position.m_fLightSongBeat;
 		const int iSongRow = BeatToNoteRowNotRounded( fSongBeat );
 
 		static int iRowLastCrossed = 0;

src/GameState.cpp

@@ -958,7 +958,7 @@ void GameState::UpdateSongPosition( float fPositionSeconds, const TimingData &ti
 	int iThrowAway;
 	timing.GetBeatAndBPSFromElapsedTime( m_fMusicSecondsVisible, m_fSongBeatVisible, fThrowAway, bThrowAway, bThrowAway, iThrowAway, fThrowAway2 );
 
-	Actor::SetBGMTime( m_Position.m_fMusicSecondsVisible, m_Position.m_fSongBeatVisible, fPositionSeconds, m_Position.m_fSongBeatNoOffset );
+	Actor::SetBGMTime( GAMESTATE->m_fMusicSecondsVisible, GAMESTATE->m_fSongBeatVisible, fPositionSeconds, GAMESTATE->m_Position.m_fSongBeatNoOffset );
 //	LOG->Trace( "m_fMusicSeconds = %f, m_fSongBeat = %f, m_fCurBPS = %f, m_bFreeze = %f", m_fMusicSeconds, m_fSongBeat, m_fCurBPS, m_bFreeze );
 }
 
@@ -2252,11 +2252,11 @@ public:
 	DEFINE_METHOD( GetHardestStepsDifficulty,	GetHardestStepsDifficulty() )
 	DEFINE_METHOD( IsEventMode,			IsEventMode() )
 	DEFINE_METHOD( GetNumPlayersEnabled,		GetNumPlayersEnabled() )
-	DEFINE_METHOD( GetSongBeat,			m_fSongBeat )
+	DEFINE_METHOD( GetSongBeat,			m_Position.m_fSongBeat )
 	DEFINE_METHOD( GetSongBeatVisible,		m_fSongBeatVisible )
-	DEFINE_METHOD( GetSongBPS,			m_fCurBPS )
-	DEFINE_METHOD( GetSongFreeze,			m_bFreeze )
-	DEFINE_METHOD( GetSongDelay,			m_bDelay )
+	DEFINE_METHOD( GetSongBPS,			m_Position.m_fCurBPS )
+	DEFINE_METHOD( GetSongFreeze,			m_Position.m_bFreeze )
+	DEFINE_METHOD( GetSongDelay,			m_Position.m_bDelay )
 	DEFINE_METHOD( GetGameplayLeadIn,		m_bGameplayLeadIn )
 	DEFINE_METHOD( GetCoins,			m_iCoins )
 	DEFINE_METHOD( IsSideJoined,			m_bSideIsJoined[Enum::Check<PlayerNumber>(L, 1)] )
@@ -2395,7 +2395,7 @@ public:
 	static int JoinPlayer( T* p, lua_State *L )				{ p->JoinPlayer(Enum::Check<PlayerNumber>(L, 1)); return 0; }
 	static int UnjoinPlayer( T* p, lua_State *L )				{ p->UnjoinPlayer(Enum::Check<PlayerNumber>(L, 1)); return 0; }
 	static int GetSongPercent( T* p, lua_State *L )				{ lua_pushnumber(L, p->GetSongPercent(FArg(1))); return 1; }
-	DEFINE_METHOD( GetCurMusicSeconds,	m_fMusicSeconds )
+	DEFINE_METHOD( GetCurMusicSeconds,	m_Position.m_fMusicSeconds )
 
 	DEFINE_METHOD( GetWorkoutGoalComplete,		m_bWorkoutGoalComplete )
 	static int GetCharacter( T* p, lua_State *L )				{ p->m_pCurCharacters[Enum::Check<PlayerNumber>(L, 1)]->PushSelf(L); return 1; }

src/GameplayAssist.cpp

@@ -25,7 +25,7 @@ void GameplayAssist::PlayTicks( const NoteData &nd )
 	 * will start coming out the speaker.  Compensate for this by boosting fPositionSeconds
 	 * ahead.  This is just to make sure that we request the sound early enough for it to
 	 * come out on time; the actual precise timing is handled by SetStartTime. */
-	float fPositionSeconds = GAMESTATE->m_fMusicSeconds;
+	float fPositionSeconds = GAMESTATE->m_Position.m_fMusicSeconds;
 	fPositionSeconds += SOUNDMAN->GetPlayLatency() + (float)CommonMetrics::TICK_EARLY_SECONDS + 0.250f;
 	const TimingData &timing = GAMESTATE->m_pCurSong->m_SongTiming;
 	const float fSongBeat = timing.GetBeatFromElapsedTimeNoOffset( fPositionSeconds );
@@ -47,11 +47,11 @@ void GameplayAssist::PlayTicks( const NoteData &nd )
 		{
 			const float fTickBeat = NoteRowToBeat( iClapRow );
 			const float fTickSecond = timing.GetElapsedTimeFromBeatNoOffset( fTickBeat );
-			float fSecondsUntil = fTickSecond - GAMESTATE->m_fMusicSeconds;
+			float fSecondsUntil = fTickSecond - GAMESTATE->m_Position.m_fMusicSeconds;
 			fSecondsUntil /= GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate; /* 2x music rate means the time until the tick is halved */
 
 			RageSoundParams p;
-			p.m_StartTime = GAMESTATE->m_LastBeatUpdate  + (fSecondsUntil - (float)CommonMetrics::TICK_EARLY_SECONDS);
+			p.m_StartTime = GAMESTATE->m_Position.m_LastBeatUpdate  + (fSecondsUntil - (float)CommonMetrics::TICK_EARLY_SECONDS);
 			m_soundAssistClap.Play( &p );
 		}
 	}
@@ -83,11 +83,11 @@ void GameplayAssist::PlayTicks( const NoteData &nd )
 		{
 			const float fTickBeat = NoteRowToBeat( iMetronomeRow );
 			const float fTickSecond = timing.GetElapsedTimeFromBeatNoOffset( fTickBeat );
-			float fSecondsUntil = fTickSecond - GAMESTATE->m_fMusicSeconds;
+			float fSecondsUntil = fTickSecond - GAMESTATE->m_Position.m_fMusicSeconds;
 			fSecondsUntil /= GAMESTATE->m_SongOptions.GetCurrent().m_fMusicRate; /* 2x music rate means the time until the tick is halved */
 
 			RageSoundParams p;
-			p.m_StartTime = GAMESTATE->m_LastBeatUpdate  + (fSecondsUntil - (float)CommonMetrics::TICK_EARLY_SECONDS);
+			p.m_StartTime = GAMESTATE->m_Position.m_LastBeatUpdate  + (fSecondsUntil - (float)CommonMetrics::TICK_EARLY_SECONDS);
 			if( bIsMeasure )
 				m_soundAssistMetronomeMeasure.Play( &p );
 			else

src/ScreenGameplay.cpp

@@ -1347,10 +1347,10 @@ void ScreenGameplay::StartPlayingSong( float fMinTimeToNotes, float fMinTimeToMu
 		m_pSoundMusic->Pause( true );
 
 	/* Make sure GAMESTATE->m_fMusicSeconds is set up. */
-	GAMESTATE->m_fMusicSeconds = -5000;
+	GAMESTATE->m_Position.m_fMusicSeconds = -5000;
 	UpdateSongPosition(0);
 
-	ASSERT( GAMESTATE->m_fMusicSeconds > -4000 ); /* make sure the "fake timer" code doesn't trigger */
+	ASSERT( GAMESTATE->m_Position.m_fMusicSeconds > -4000 ); /* make sure the "fake timer" code doesn't trigger */
 }
 
 
@@ -1405,7 +1405,7 @@ void ScreenGameplay::PlayAnnouncer( RString type, float fSeconds )
 	if( m_DancingState != STATE_DANCING )
 		return;
 	if( GAMESTATE->m_pCurSong == NULL  ||	// this will be true on ScreenDemonstration sometimes
-		GAMESTATE->m_fSongBeat < GAMESTATE->m_pCurSong->m_fFirstBeat )
+		GAMESTATE->m_Position.m_fSongBeat < GAMESTATE->m_pCurSong->m_fFirstBeat )
 		return;
 
 	if( m_fTimeSinceLastDancingComment < fSeconds )
@@ -1687,7 +1687,7 @@ void ScreenGameplay::Update( float fDeltaTime )
 
 		// update fGameplaySeconds
 		STATSMAN->m_CurStageStats.m_fGameplaySeconds += fUnscaledDeltaTime;
-		if( GAMESTATE->m_fSongBeat >= GAMESTATE->m_pCurSong->m_fFirstBeat && GAMESTATE->m_fSongBeat < GAMESTATE->m_pCurSong->m_fLastBeat )
+		if( GAMESTATE->m_Position.m_fSongBeat >= GAMESTATE->m_pCurSong->m_fFirstBeat && GAMESTATE->m_Position.m_fSongBeat < GAMESTATE->m_pCurSong->m_fLastBeat )
 		{
 			STATSMAN->m_CurStageStats.m_fStepsSeconds += fUnscaledDeltaTime;
 
@@ -1707,7 +1707,7 @@ void ScreenGameplay::Update( float fDeltaTime )
 			if( bAllReallyFailed )
 				fSecondsToStartTransitioningOut += BEGIN_FAILED_DELAY;
 
-			if( GAMESTATE->m_fMusicSeconds >= fSecondsToStartTransitioningOut && !m_NextSong.IsTransitioning() )
+			if( GAMESTATE->m_Position.m_fMusicSeconds >= fSecondsToStartTransitioningOut && !m_NextSong.IsTransitioning() )
 				this->PostScreenMessage( SM_NotesEnded, 0 );
 		}
 
@@ -1843,8 +1843,8 @@ void ScreenGameplay::Update( float fDeltaTime )
 
 float ScreenGameplay::GetHasteRate()
 {
-	if( GAMESTATE->m_fMusicSeconds < GAMESTATE->m_fLastHasteUpdateMusicSeconds || // new song
-		GAMESTATE->m_fMusicSeconds > GAMESTATE->m_fLastHasteUpdateMusicSeconds + 4 )
+	if( GAMESTATE->m_Position.m_fMusicSeconds < GAMESTATE->m_fLastHasteUpdateMusicSeconds || // new song
+		GAMESTATE->m_Position.m_fMusicSeconds > GAMESTATE->m_fLastHasteUpdateMusicSeconds + 4 )
 	{
 		bool bAnyPlayerHitAllNotes = false;
 		FOREACH_EnabledPlayerInfo( m_vPlayerInfo, pi )
@@ -1865,7 +1865,7 @@ float ScreenGameplay::GetHasteRate()
 			GAMESTATE->m_fHasteRate += 0.1f;
 		CLAMP( GAMESTATE->m_fHasteRate, -1.0f, +1.0f );
 
-		GAMESTATE->m_fLastHasteUpdateMusicSeconds = GAMESTATE->m_fMusicSeconds;
+		GAMESTATE->m_fLastHasteUpdateMusicSeconds = GAMESTATE->m_Position.m_fMusicSeconds;
 	}
 
 	/* If the life meter is less than half full, push the haste rate down to let
@@ -1914,7 +1914,7 @@ void ScreenGameplay::UpdateLights()
 	ZERO( bBlinkGameButton );
 	bool bCrossedABeat = false;
 	{
-		const float fSongBeat = GAMESTATE->m_fLightSongBeat;
+		const float fSongBeat = GAMESTATE->m_Position.m_fLightSongBeat;
 		const int iSongRow = BeatToNoteRowNotRounded( fSongBeat );
 
 		static int iRowLastCrossed = 0;
@@ -1968,7 +1968,7 @@ void ScreenGameplay::UpdateLights()
 	}
 
 	// Before the first beat of the song, all cabinet lights solid on (except for menu buttons).
-	bool bOverrideCabinetBlink = (GAMESTATE->m_fSongBeat < GAMESTATE->m_pCurSong->m_fFirstBeat);
+	bool bOverrideCabinetBlink = (GAMESTATE->m_Position.m_fSongBeat < GAMESTATE->m_pCurSong->m_fFirstBeat);
 	FOREACH_CabinetLight( cl )
 		bBlinkCabinetLight[cl] |= bOverrideCabinetBlink;
 
@@ -1994,7 +1994,7 @@ void ScreenGameplay::SendCrossedMessages()
 	{
 		static int iRowLastCrossed = 0;
 
-		float fPositionSeconds = GAMESTATE->m_fMusicSeconds;
+		float fPositionSeconds = GAMESTATE->m_Position.m_fMusicSeconds;
 		float fSongBeat = GAMESTATE->m_pCurSong->m_SongTiming.GetBeatFromElapsedTime( fPositionSeconds );
 
 		int iRowNow = BeatToNoteRowNotRounded( fSongBeat );
@@ -2032,7 +2032,7 @@ void ScreenGameplay::SendCrossedMessages()
 		{
 			float fNoteWillCrossInSeconds = MESSAGE_SPACING_SECONDS * i;
 
-			float fPositionSeconds = GAMESTATE->m_fMusicSeconds + fNoteWillCrossInSeconds;
+			float fPositionSeconds = GAMESTATE->m_Position.m_fMusicSeconds + fNoteWillCrossInSeconds;
 			float fSongBeat = GAMESTATE->m_pCurSong->m_SongTiming.GetBeatFromElapsedTime( fPositionSeconds );
 
 			int iRowNow = BeatToNoteRowNotRounded( fSongBeat );

src/ScreenHowToPlay.cpp

@@ -209,7 +209,7 @@ void ScreenHowToPlay::Step()
 #define ST_JUMPUD	(ST_UP | ST_DOWN)
 
 	int iStep = 0;
-	const int iNoteRow = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat + 0.6f );
+	const int iNoteRow = BeatToNoteRowNotRounded( GAMESTATE->m_Position.m_fSongBeat + 0.6f );
 	// if we want to miss from here on out, don't process steps.
 	if( m_iW2s < m_iNumW2s && m_NoteData.IsThereATapAtRow( iNoteRow ) )
 	{
@@ -230,10 +230,10 @@ void ScreenHowToPlay::Step()
 			m_pmCharacter->PlayAnimation( "Step-JUMPLR", 1.8f );
 
 			m_pmCharacter->StopTweening();
-			m_pmCharacter->BeginTweening( GAMESTATE->m_fCurBPS /8, TWEEN_LINEAR );
+			m_pmCharacter->BeginTweening( GAMESTATE->m_Position.m_fCurBPS /8, TWEEN_LINEAR );
 			m_pmCharacter->SetRotationY( 90 );
-			m_pmCharacter->BeginTweening( (1/(GAMESTATE->m_fCurBPS * 2) ) ); //sleep between jump-frames
-			m_pmCharacter->BeginTweening( GAMESTATE->m_fCurBPS /6, TWEEN_LINEAR );
+			m_pmCharacter->BeginTweening( (1/(GAMESTATE->m_Position.m_fCurBPS * 2) ) ); //sleep between jump-frames
+			m_pmCharacter->BeginTweening( GAMESTATE->m_Position.m_fCurBPS /6, TWEEN_LINEAR );
 			m_pmCharacter->SetRotationY( 0 );
 			break;
 		}
@@ -248,7 +248,7 @@ void ScreenHowToPlay::Update( float fDelta )
 		m_fFakeSecondsIntoSong += fDelta;
 
 		static int iLastNoteRowCounted = 0;
-		int iCurNoteRow = BeatToNoteRowNotRounded( GAMESTATE->m_fSongBeat );
+		int iCurNoteRow = BeatToNoteRowNotRounded( GAMESTATE->m_Position.m_fSongBeat );
 
 		if( iCurNoteRow != iLastNoteRowCounted &&m_NoteData.IsThereATapAtRow(iCurNoteRow) )
 		{