GameLoop.cpp

#include "global.h"
#include "GameLoop.h"
#include "RageLog.h"
#include "RageTextureManager.h"
#include "RageSoundManager.h"
#include "PrefsManager.h"
#include "RageDisplay.h"

#include "arch/ArchHooks/ArchHooks.h"

#include "GameSoundManager.h"
#include "ThemeManager.h"
#include "SongManager.h"
#include "GameState.h"
#include "MemoryCardManager.h"
#include "ScreenManager.h"
#include "InputFilter.h"
#include "InputMapper.h"
#include "RageFileManager.h"
#include "LightsManager.h"
#include "NetworkSyncManager.h"
#include "RageTimer.h"
#include "RageInput.h"

using std::vector;

static RageTimer g_GameplayTimer;

static Preference<bool> g_bNeverBoostAppPriority( "NeverBoostAppPriority", false );

/* experimental: force a specific update rate. This prevents big  animation
 * jumps on frame skips. 0 to disable. */
static Preference<float> g_fConstantUpdateDeltaSeconds( "ConstantUpdateDeltaSeconds", 0 );

void HandleInputEvents( float fDeltaTime );

static float g_fUpdateRate = 1;
void GameLoop::SetUpdateRate( float fUpdateRate )
{
	g_fUpdateRate = fUpdateRate;
}

static void CheckGameLoopTimerSkips( float fDeltaTime )
{
	if( !PREFSMAN->m_bLogSkips )
		return;

	static int iLastFPS = 0;
	int iThisFPS = DISPLAY->GetFPS();

	/* If vsync is on, and we have a solid framerate (vsync == refresh and we've
	 * sustained this for at least one second), we expect the amount of time for
	 * the last frame to be 1/FPS. */
	if( iThisFPS != DISPLAY->GetActualVideoModeParams().rate || iThisFPS != iLastFPS )
	{
		iLastFPS = iThisFPS;
		return;
	}

	const float fExpectedTime = 1.0f / iThisFPS;
	const float fDifference = fDeltaTime - fExpectedTime;
	if( fabsf(fDifference) > 0.002f && fabsf(fDifference) < 0.100f )
		LOG->Trace( "GameLoop timer skip: %i FPS, expected %.3f, got %.3f (%.3f difference)",
			iThisFPS, fExpectedTime, fDeltaTime, fDifference );
}

static bool ChangeAppPri()
{
	if( g_bNeverBoostAppPriority.Get() )
		return false;

	// if using NTPAD don't boost or else input is laggy
#if defined(_WINDOWS)
	{
		vector<InputDeviceInfo> vDevices;

		// This can get called before INPUTMAN is constructed.
		if( INPUTMAN )
		{
			INPUTMAN->GetDevicesAndDescriptions(vDevices);
			for (auto const &d: vDevices)
			{
				if( d.sDesc.find("NTPAD") != std::string::npos )
				{
					LOG->Trace( "Using NTPAD.  Don't boost priority." );
					return false;
				}
			}
		}
	}
#endif

	// If this is a debug build, don't. It makes the VC debugger sluggish.
#if defined(WIN32) && defined(DEBUG)
	return false;
#else
	return true;
#endif
}

static void CheckFocus()
{
	if( !HOOKS->AppFocusChanged() )
		return;

	// If we lose focus, we may lose input events, especially key releases.
	INPUTFILTER->Reset();

	if( ChangeAppPri() )
	{
		if( HOOKS->AppHasFocus() )
			HOOKS->BoostPriority();
		else
			HOOKS->UnBoostPriority();
	}
}

// On the next update, change themes, and load sNewScreen.
static std::string g_NewTheme;
static std::string g_NewGame;
void GameLoop::ChangeTheme(const std::string &sNewTheme)
{
	g_NewTheme = sNewTheme;
}

void GameLoop::ChangeGame(const std::string& new_game, const std::string& new_theme)
{
	g_NewGame= new_game;
	g_NewTheme= new_theme;
}

#include "StepMania.h" // XXX
#include "GameManager.h"
#include "Game.h"
namespace
{
	void DoChangeTheme()
	{
		Rage::safe_delete( SCREENMAN );
		TEXTUREMAN->DoDelayedDelete();

		// In case the previous theme overloaded class bindings, reinitialize them.
		LUA->RegisterTypes();

		// We always need to force the theme to reload because we cleared the lua
		// state by calling RegisterTypes so the scripts in Scripts/ need to run.
		THEME->SwitchThemeAndLanguage( g_NewTheme, THEME->GetCurLanguage(), PREFSMAN->m_bPseudoLocalize, true );
		PREFSMAN->m_sTheme.Set( g_NewTheme );

		// Apply the new window title, icon and aspect ratio.
		StepMania::ApplyGraphicOptions();

		SCREENMAN = new ScreenManager();

		StepMania::ResetGame();
		SCREENMAN->ThemeChanged();
		// The previous system for changing the theme fetched the "NextScreen"
		// metric from the current theme, then changed the theme, then tried to
		// set the new screen to the name that had been fetched.
		// If the new screen didn't exist in the new theme, there would be a
		// crash.
		// So now the correct thing to do is for a theme to specify its entry
		// point after a theme change, ensuring that we are going to a valid
		// screen and not crashing. -Kyz
		std::string new_screen= THEME->GetMetric("Common", "InitialScreen");
		if(THEME->HasMetric("Common", "AfterThemeChangeScreen"))
		{
			std::string after_screen= THEME->GetMetric("Common", "AfterThemeChangeScreen");
			if(SCREENMAN->IsScreenNameValid(after_screen))
			{
				new_screen= after_screen;
			}
		}
		if(!SCREENMAN->IsScreenNameValid(new_screen))
		{
			new_screen= "ScreenInitialScreenIsInvalid";
		}
		SCREENMAN->SetNewScreen(new_screen);

		g_NewTheme = std::string();
	}

	void DoChangeGame()
	{
		const Game* g= GAMEMAN->StringToGame(g_NewGame);
		ASSERT(g != nullptr);
		GAMESTATE->SetCurGame(g);

		bool theme_changing= false;
		// The prefs allow specifying a different default theme to use for each
		// game type.  So if a theme name isn't passed in, fetch from the prefs.
		if(g_NewTheme.empty())
		{
			g_NewTheme= PREFSMAN->m_sTheme.Get();
		}
		if(g_NewTheme != THEME->GetCurThemeName() && THEME->IsThemeSelectable(g_NewTheme))
		{
			theme_changing= true;
		}

		if(theme_changing)
		{
			Rage::safe_delete(SCREENMAN);
			TEXTUREMAN->DoDelayedDelete();
			LUA->RegisterTypes();
			THEME->SwitchThemeAndLanguage(g_NewTheme, THEME->GetCurLanguage(),
				PREFSMAN->m_bPseudoLocalize);
			PREFSMAN->m_sTheme.Set(g_NewTheme);
			StepMania::ApplyGraphicOptions();
			SCREENMAN= new ScreenManager();
		}
		StepMania::ResetGame();
		std::string new_screen= THEME->GetMetric("Common", "InitialScreen");
		std::string after_screen;
		if(theme_changing)
		{
			SCREENMAN->ThemeChanged();
			if(THEME->HasMetric("Common", "AfterGameAndThemeChangeScreen"))
			{
				after_screen= THEME->GetMetric("Common", "AfterGameAndThemeChangeScreen");
			}
		}
		else
		{
			if(THEME->HasMetric("Common", "AfterGameChangeScreen"))
			{
				after_screen= THEME->GetMetric("Common", "AfterGameChangeScreen");
			}
		}
		if(SCREENMAN->IsScreenNameValid(after_screen))
		{
			new_screen= after_screen;
		}
		SCREENMAN->SetNewScreen(new_screen);

		// Set the input scheme for the new game, and load keymaps.
		if( INPUTMAPPER )
		{
			INPUTMAPPER->SetInputScheme(&g->m_InputScheme);
			INPUTMAPPER->ReadMappingsFromDisk();
		}
		// aj's comment transplanted from ScreenOptionsMasterPrefs.cpp:GameSel. -Kyz
		/* Reload metrics to force a refresh of CommonMetrics::DIFFICULTIES_TO_SHOW,
		 * mainly if we're not switching themes. I'm not sure if this was the
		 * case going from theme to theme, but if it was, it should be fixed
		 * now. There's probably be a better way to do it, but I'm not sure
		 * what it'd be. -aj */
		THEME->UpdateLuaGlobals();
		THEME->ReloadMetrics();
		g_NewGame= std::string();
		g_NewTheme= std::string();
	}
}

void GameLoop::RunGameLoop()
{
	/* People may want to do something else while songs are loading, so do
	 * this after loading songs. */
	if( ChangeAppPri() )
		HOOKS->BoostPriority();

	while( !ArchHooks::UserQuit() )
	{
		if(!g_NewGame.empty())
		{
			DoChangeGame();
		}
		if(!g_NewTheme.empty())
		{
			DoChangeTheme();
		}

		// Update
		float fDeltaTime = g_GameplayTimer.GetDeltaTime();

		if( g_fConstantUpdateDeltaSeconds > 0 )
			fDeltaTime = g_fConstantUpdateDeltaSeconds;

		CheckGameLoopTimerSkips( fDeltaTime );

		fDeltaTime *= g_fUpdateRate;

		CheckFocus();

		// Update SOUNDMAN early (before any RageSound::GetPosition calls), to flush position data.
		SOUNDMAN->Update();

		/* Update song beat information -before- calling update on all the classes that
		 * depend on it. If you don't do this first, the classes are all acting on old
		 * information and will lag. (but no longer fatally, due to timestamping -glenn) */
		SOUND->Update( fDeltaTime );
		TEXTUREMAN->Update( fDeltaTime );
		GAMESTATE->Update( fDeltaTime );
		SCREENMAN->Update( fDeltaTime );
		MEMCARDMAN->Update();
		NSMAN->Update( fDeltaTime );

		/* Important: Process input AFTER updating game logic, or input will be
		 * acting on song beat from last frame */
		HandleInputEvents( fDeltaTime );

		if( INPUTMAN->DevicesChanged() )
		{
			INPUTFILTER->Reset();	// fix "buttons stuck" if button held while unplugged
			INPUTMAN->LoadDrivers();
			std::string sMessage;
			if( INPUTMAPPER->CheckForChangedInputDevicesAndRemap(sMessage) )
				SCREENMAN->SystemMessage( sMessage );
		}

		LIGHTSMAN->Update( fDeltaTime );

		// Render
		SCREENMAN->Draw();
	}

	// If we ended mid-game, finish up.
	GAMESTATE->SaveLocalData();

	if( ChangeAppPri() )
		HOOKS->UnBoostPriority();
}

/*
 * (c) 2001-2005 Chris Danford, Glenn Maynard
 * 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.
 */