initial commit after moving to new repo

1 files changed, 860 insertions, 0 deletions

diff --git a/Northstar.Coop/scripts/vscripts/sp/_savegame.gnut b/Northstar.Coop/scripts/vscripts/sp/_savegame.gnut
new file mode 100644
index 00000000..f4f29003
--- /dev/null
+++ b/Northstar.Coop/scripts/vscripts/sp/_savegame.gnut
@@ -0,0 +1,860 @@
+global function AddCallback_OnLoadSaveGame
+global function CheckPoint
+global function CheckPoint_Forced
+global function CheckPoint_ForcedSilent
+global function CheckPoint_Silent
+global function RestartFromLevelTransition
+global function CodeCallback_IsSaveGameSafeToCommit
+global function CodeCallback_OnLoadSaveGame
+global function CodeCallback_OnSavedSaveGame
+global function InitSaveGame
+global function LoadSaveTimeDamageMultiplier
+global function ReloadForMissionFailure
+global function GetLastCheckPointLoadTime
+global function SafeForCheckPoint
+global function SafeToSpawnAtOrigin
+global function JustLoadedFromCheckpoint
+global function GetFirstPlayer
+
+const float LAST_SAVE_DEBOUNCE = 4.0
+const float TITAN_SAFE_DIST = 1200
+const SAVE_DEBUG = true
+global const SAVE_NEW = false
+global const MAX_SAFELOCATION_DIST = 5000
+global const float SAVE_SPAWN_VOFFSET = 2.0
+
+global struct CheckPointData
+{
+	float searchTime = 5.0
+	bool onGroundRequired = true
+	array<entity> safeLocations
+	bool forced
+	bool skipDelayedIsAliveCheck
+	bool skipSaveToActualPlayerLocation
+	bool functionref( entity ) ornull additionalCheck = null
+}
+
+struct
+{
+	bool nextSaveSilent
+	table signalDummy
+	float loadSaveTime
+
+	float lastSaveTime
+
+	array<StoredWeapon> saveStoredWeapons
+	string storedTitanWeapon
+
+	vector saveOrigin
+	vector saveAngles
+	bool saveRestoreResetsPlayer
+
+} file
+
+void function InitSaveGame()
+{
+	Assert( MAX_SAFELOCATION_DIST < TIME_ZOFFSET * 0.8 )
+
+	RegisterSignal( "StopSearchingForSafeSave" )
+	RegisterSignal( "RespawnNow" )
+
+	FlagInit( "OnLoadSaveGame_PlayerRecoveryEnabled", true )
+	FlagInit( "SaveRequires_PlayerIsTitan" )
+	AddClientCommandCallback( "RestartFromLevelTransition", RestartFromLevelTransition )
+	AddClientCommandCallback( "RespawnNowSP", RespawnNowSP )
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// GLOBAL COMMANDS
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void function CheckPoint_Silent( CheckPointData ornull checkPointData = null )
+{
+	CheckPointData data = GetCheckPointDataOrDefaults( checkPointData )
+	CheckPoint_Silent_FromData( data )
+}
+
+void function CheckPoint_Silent_FromData( CheckPointData checkPointData )
+{
+	file.nextSaveSilent = true
+	CheckPoint( checkPointData )
+}
+
+void function CheckPoint_ForcedSilent()
+{
+	file.nextSaveSilent = true
+	CheckPoint_Forced()
+}
+
+void function CheckPoint_Forced()
+{
+	CheckPointData checkPointData
+	checkPointData.forced = true
+	CheckPoint_FromData( checkPointData )
+}
+
+void function CheckPoint( CheckPointData ornull checkPointData = null )
+{
+	CheckPointData data = GetCheckPointDataOrDefaults( checkPointData )
+	thread CheckPoint_FromData( data )
+}
+
+void function CheckPoint_FromData( CheckPointData checkPointData )
+{
+	printt( "SAVEGAME: New save attempt (8/3/2016)" )
+
+	float searchTime = checkPointData.searchTime
+	bool onGroundRequired = checkPointData.onGroundRequired
+	bool skipDelayedIsAliveCheck = checkPointData.skipDelayedIsAliveCheck
+	bool skipSaveToActualPlayerLocation = checkPointData.skipSaveToActualPlayerLocation
+	bool forced = checkPointData.forced
+	array<entity> safeLocations = checkPointData.safeLocations
+	bool functionref( entity ) ornull additionalCheck = checkPointData.additionalCheck
+
+	if ( !Flag( "SaveGame_Enabled" ) )
+	{
+		printt( "SAVEGAME: failed: Saves are disabled" )
+		return
+	}
+
+	entity player = GetFirstPlayer()
+	entity safeLocation
+
+	if ( forced )
+	{
+		printt( "SAVEGAME: creating: Forced" )
+	}
+	else
+	{
+		if ( Flag( "SaveRequires_PlayerIsTitan" ) && !player.IsTitan() )
+		{
+			printt( "SAVEGAME: failed: Flag SaveRequires_PlayerIsTitan and player is not a Titan" )
+			return
+		}
+
+		printt( "SAVEGAME: creating: Safe for check point?" )
+		EndSignal( file.signalDummy, "StopSearchingForSafeSave" )
+
+		bool regularSafetyCheck = GetBugReproNum() != 184641 // respawned with no UI
+		bool functionref( entity ) safeCheck
+		if ( onGroundRequired )
+			safeCheck = SafeForCheckPoint_OnGround
+		else
+			safeCheck = SafeForCheckPoint
+
+
+		if ( skipSaveToActualPlayerLocation )
+		{
+			printt( "SAVEGAME: skipSaveToActualPlayerLocation." )
+		}
+		else
+		{
+			float rate = 0.333
+			int reps = int( searchTime / rate )
+
+			if ( regularSafetyCheck )
+			{
+				// wait a few seconds until it is safe to save
+				for ( int i = 0; i < reps; i++ )
+				{
+					if ( safeCheck( player ) )
+						break
+
+					wait rate
+				}
+			}
+			else
+			{
+				printt( "SAVEGAME: regularSafetyCheck disabled for bug repro" )
+			}
+		}
+
+		if ( !regularSafetyCheck || skipSaveToActualPlayerLocation || !safeCheck( player ) )
+		{
+			printt( "SAVEGAME: Not safe to save actual player position." )
+			if ( !safeLocations.len() )
+			{
+				printt( "SAVEGAME: failed: no alternate safe locations." )
+				return
+			}
+
+			// titan cores do funky stuff with weapons and make it hard to resume to a new position safely
+			if ( !IsTitanCoreFiring( player ) )
+				safeLocation = GetBestSaveLocationEnt( safeLocations )
+
+			if ( safeLocation == null )
+			{
+				printt( "SAVEGAME: failed: couldn't find a safe location from those provided." )
+				return
+			}
+
+			printt( "SAVEGAME: Found safe location " + safeLocation.GetOrigin() )
+		}
+		else
+		{
+			printt( "SAVEGAME: Safe to save at actual player location: " + player.GetOrigin() )
+		}
+
+		if ( Time() - file.lastSaveTime < 3 )
+		{
+			printt( "SAVEGAME: failed: last save was too recent." )
+			return
+		}
+
+		if ( additionalCheck != null )
+		{
+			expect bool functionref(entity)( additionalCheck )
+			if ( !additionalCheck( player ) )
+			{
+				printt( "SAVEGAME: failed: custom check failed." )
+				return
+			}
+		}
+	}
+
+	if ( IsValid( safeLocation ) )
+	{
+		printt( "SAVEGAME: saveRestoreResetsPlayer = true" )
+		WriteRestoreLocationFromEntity( safeLocation )
+		file.saveRestoreResetsPlayer = true
+	}
+	else
+	{
+		printt( "SAVEGAME: saveRestoreResetsPlayer = false" )
+		file.saveRestoreResetsPlayer = false
+	}
+
+	int startPointIndex = GetCurrentStartPointIndex()
+
+	if ( !IsAlive( player ) )
+	{
+		printt( "SAVEGAME: failed: Tried to save while player was dead" )
+		return
+	}
+
+	if ( skipDelayedIsAliveCheck || forced )
+	{
+		printt( "SAVEGAME: SaveGame_Create" )
+		file.lastSaveTime = Time()
+		SaveGame_Create( GetSaveName(), SAVEGAME_VERSION, startPointIndex )
+	}
+	else
+	{
+		printt( "SAVEGAME: SaveGame_CreateWithCommitDelay" )
+		file.lastSaveTime = Time()
+		SaveGame_CreateWithCommitDelay( GetSaveName(), SAVEGAME_VERSION, 3.5, 1, startPointIndex )
+	}
+
+	// kill any ongoing attempts to save. Note this also may end this thread, so it is called last.
+	Signal( file.signalDummy, "StopSearchingForSafeSave" )
+}
+
+CheckPointData function GetCheckPointDataOrDefaults( CheckPointData ornull checkPointData = null )
+{
+	if ( checkPointData != null )
+		return expect CheckPointData( checkPointData )
+
+	CheckPointData data
+	return data
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// CODE CALLBACKS
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool function CodeCallback_IsSaveGameSafeToCommit()
+{
+	if ( !Flag( "SaveGame_Enabled" ) )
+		return false
+
+	foreach ( player in GetPlayerArray() )
+	{
+		if ( !IsAlive( player ) )
+			return false
+	}
+
+	return true
+}
+
+
+void function ClearPlayerVelocityOnContext( entity player )
+{
+	if ( player.IsTitan() )
+		return
+
+	switch ( GetCurrentStartPoint() )
+	{
+		case "Rising World Jump":
+			return
+	}
+
+	player.SetVelocity( <0,0,0> )
+}
+
+
+void function CodeCallback_OnLoadSaveGame()
+{
+	printt( "SaveGame: OnLoadSaveGame" )
+	file.loadSaveTime = Time()
+
+	UpdateCollectiblesAfterLoadSaveGame()
+	array<entity> players = GetPlayerArray()
+
+	Assert( players.len() == 1 )
+	entity player = players[0]
+
+	// restore health on load from save
+	if ( !IsAlive( player ) )
+		return
+
+	ClearPlayerVelocityOnContext( player )
+
+	thread UpdateUI( player.IsTitan(), player )
+
+	// run on load save game callbacks
+	foreach ( callbackFunc in svGlobalSP.onLoadSaveGameCallbacks )
+	{
+		callbackFunc( player )
+	}
+
+	thread DelayedOnLoadSetup( player )
+}
+
+void function DelayedOnLoadSetup( entity player )
+{
+	player.EndSignal( "OnDeath" )
+
+	WaitFrame() // fixes crash bug, also can't issue a remote call on this codecallback until waiting a frame.
+
+	Remote_CallFunction_UI( player, "ServerCallback_GetObjectiveReminderOnLoad" ) // show objective reminder
+
+	bool forceStanding = file.saveRestoreResetsPlayer
+	if ( file.saveRestoreResetsPlayer )
+	{
+		file.saveRestoreResetsPlayer = false
+
+		printt( "SAVEGAME: Restoring player to safe location " + file.saveOrigin )
+		player.SetOrigin( file.saveOrigin )
+		player.SetAngles( file.saveAngles )
+		player.SetVelocity( <0,0,0> )
+
+		TakeAllWeapons( player )
+
+		player.ForceStand()
+
+		if ( IsPilot( player ) )
+		{
+			GiveWeaponsFromStoredArray( player, file.saveStoredWeapons )
+		}
+		else
+		{
+			player.GiveWeapon( file.storedTitanWeapon )
+		}
+	}
+
+	if ( Flag( "OnLoadSaveGame_PlayerRecoveryEnabled" ) )
+	{
+		if ( player.IsTitan() )
+		{
+			RestoreTitan( player )
+
+			int index = GetConVarInt( "sp_titanLoadoutCurrent" )
+			if ( index > -1 && IsBTLoadoutUnlocked( index ) )
+			{
+				string weapon = GetTitanWeaponFromIndex( index )
+				TakeAllWeapons( player )
+				player.GiveWeapon( weapon )
+			}
+		}
+		else
+		{
+			player.SetHealth( player.GetMaxHealth() )
+			entity offhand = player.GetOffhandWeapon( OFFHAND_SPECIAL )
+			if ( IsValid( offhand ) )
+			{
+				// restore offhand, so for example, cloak will be ready to use
+				int max = offhand.GetWeaponPrimaryClipCountMax()
+				offhand.SetWeaponPrimaryClipCount(max)
+			}
+
+			entity petTitan = player.GetPetTitan()
+			if ( IsAlive( petTitan ) )
+			{
+				RestoreTitan( petTitan )
+			}
+		}
+	}
+
+	WaitFrame()
+
+	if ( forceStanding )
+		player.UnforceStand()
+
+}
+
+void function CodeCallback_OnSavedSaveGame( bool saved )
+{
+	printt( "SAVEGAME: Success (OnSavedSaveGame)" )
+
+	// failed to save
+	if ( !saved )
+		return
+
+	// tell clients about the save
+	foreach ( player in GetPlayerArray() )
+	{
+		Remote_CallFunction_UI( player, "ServerCallback_ClearObjectiveReminderOnLoad" ) // dont need objective reminder again on load
+	}
+
+	BroadcastCheckpointMessage()
+}
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// SAVE UTILITIES
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+
+
+entity function GetFirstPlayer()
+{
+	foreach ( player in GetPlayerArray() )
+	{
+		return player
+	}
+
+	unreachable
+}
+
+bool function SafeToSpawnAtOrigin( entity player, vector origin )
+{
+	if ( player.IsTitan() )
+	{
+		array<entity> titans = GetNPCArrayEx( "npc_titan", TEAM_ANY, TEAM_MILITIA, origin, TITAN_SAFE_DIST )
+		if ( titans.len() > 0 )
+			return false
+
+		array<entity> superSpectres = GetNPCArrayEx( "npc_super_spectre", TEAM_ANY, TEAM_MILITIA, origin, TITAN_SAFE_DIST )
+		if ( superSpectres.len() > 0 )
+			return false
+	}
+	else
+	{
+		array<entity> enemies = GetNPCArrayEx( "any", TEAM_ANY, TEAM_MILITIA, origin, 300 )
+		if ( enemies.len() > 0 )
+			return false
+	}
+
+	return IsPlayerSafeFromProjectiles( player, origin )
+}
+
+entity function GetBestSaveLocationEnt( array<entity> safeLocations )
+{
+	entity player = GetFirstPlayer()
+	vector mins = player.GetBoundingMins()
+	vector maxs = player.GetBoundingMaxs()
+
+	vector playerOrg = player.GetOrigin()
+	array<entity> orderedLocations = ArrayClosest( safeLocations, player.GetOrigin() )
+	foreach ( ent in orderedLocations )
+	{
+		vector org = ent.GetOrigin() + <0,0,SAVE_SPAWN_VOFFSET>
+
+		// too far to spawn
+		if ( Distance( playerOrg, org ) > MAX_SAFELOCATION_DIST )
+			break
+
+		if ( !SafeToSpawnAtOrigin( player, ent.GetOrigin() ) )
+			continue
+
+		// blocked at that origin?
+		TraceResults result = TraceHull( org, org + Vector( 0, 0, 1), mins, maxs, [ player ], TRACE_MASK_PLAYERSOLID, TRACE_COLLISION_GROUP_PLAYER )
+		if ( result.startSolid )
+			continue
+		if ( result.fraction != 1.0 )
+			continue
+
+		return ent
+	}
+
+	return null
+}
+
+void function WriteRestoreLocationFromEntity( entity safeLocation )
+{
+	Assert( safeLocation != null )
+	entity player = GetFirstPlayer()
+	Assert( IsAlive( player ), "Tried to save while player was dead" )
+
+	if ( IsPilot( player ) )
+	{
+		file.saveStoredWeapons = StoreWeapons( player )
+	}
+	else
+	{
+		array<entity> weapons = player.GetMainWeapons()
+		Assert( weapons.len() == 1, "Player had multiple titan weapons" )
+		file.storedTitanWeapon = weapons[0].GetWeaponClassName()
+	}
+
+	file.saveOrigin = safeLocation.GetOrigin() + <0,0,SAVE_SPAWN_VOFFSET>
+	file.saveAngles = safeLocation.GetAngles()
+}
+
+bool function RestartFromLevelTransition( entity player, array<string> args )
+{
+	thread ReloadFromLevelStart()
+
+	return true
+}
+
+void function ReloadForMissionFailure( float extraDelay = 0 )
+{
+	// prevent automatic restarts
+	//thread ReloadForMissionFailure_Thread( extraDelay )
+}
+
+void function ReloadForMissionFailure_Thread( float extraDelay )
+{
+	FlagClear( "SaveGame_Enabled" ) // no more saving, you have lost
+	FlagSet( "MissionFailed" )
+
+	Signal( file.signalDummy, "StopSearchingForSafeSave" )
+
+	entity player = GetFirstPlayer()
+	if ( IsValid( player ) )
+		EmitSoundOnEntityOnlyToPlayer( player, player, "4_second_fadeout" )
+
+	wait 1
+
+	waitthread WaitForRespawnNowOrTimePass( player, 2.8 + extraDelay )
+
+	ReloadFromSave_RestartFallback()
+}
+
+void function WaitForRespawnNowOrTimePass( entity player, float delay )
+{
+	player.EndSignal( "RespawnNow" )
+	wait delay
+}
+
+void function SkipReloadDelay_Thread( entity player )
+{
+	EmitSoundOnEntityOnlyToPlayer( player, player, "1_second_fadeout" )
+	ScreenFadeToBlackForever( player, 0.5 )
+	wait 1.0
+	player.Signal( "RespawnNow" )
+}
+
+bool function RespawnNowSP( entity player, array<string> args )
+{
+	// this clientcommand is always bound now so we need to make sure it isn't called while player is alive
+	if ( IsAlive( player ))
+		return true
+		
+	// wait a few seconds before we allow respawns
+	if ( player.nv.nextRespawnTime > Time() )
+		return true
+
+	//thread SkipReloadDelay_Thread( player )
+		
+	// do our respawning code
+	entity ornull respawningOn = GetPlayerToSpawnOn()
+	
+	if ( respawningOn == null )
+	{
+		// todo: logic for restarting level without dropping clients
+		print( "everyone is dead! restarting from last checkpoint..." )
+		RestartWithoutDroppingPlayers()
+	}
+	else
+	{
+		expect entity( respawningOn )
+		// HACK: compiler has a fit if we directly call player.RespawnPlayer in this file
+		// 		 so we need to make a functionref in another file that does it
+		
+		hackRespawnPlayerFunc( player, respawningOn )
+		// honestly unsure if the respawningOn arg works with players so manually set pos too
+		thread TeleportToEntitySafe( player, respawningOn )
+	}
+
+	
+	return true
+}
+
+void function ReloadFromSave_RestartFallback()
+{
+	if ( LoadedFromSave() )
+		return
+
+	ReloadFromLevelStart()
+}
+
+void function ReloadFromLevelStart()
+{
+	array<entity> players = GetPlayerArray()
+	Assert( players.len() == 1 )
+	entity player = players[0]
+	ServerRestartMission( player )
+}
+
+bool function SafeForCheckPoint_OnGround( entity player )
+{
+	Assert( player.IsPlayer() )
+
+	if ( !player.IsOnGround() )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: !player.IsOnGround()" )
+		#endif
+		return false
+	}
+
+	if ( player.IsWallRunning() )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: player.IsWallRunning()" )
+		#endif
+		return false
+	}
+
+	return SafeForCheckPoint( player )
+}
+
+bool function SafeForCheckPoint( entity player )
+{
+	Assert( player.IsPlayer() )
+
+	if ( Flag( "CheckPointDisabled" ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: Flag( \"CheckPointDisabled\" )" )
+		#endif
+		return false
+	}
+
+	if ( !IsAlive( player ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: !IsAlive( player )" )
+		#endif
+		return false
+	}
+
+	if ( IsPlayerEmbarking( player ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: IsPlayerEmbarking( player )" )
+		#endif
+		return false
+	}
+
+	if ( IsPlayerDisembarking( player ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: IsPlayerDisembarking( player )" )
+		#endif
+		return false
+	}
+
+	if ( player.p.doingQuickDeath )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: player.p.doingQuickDeath" )
+		#endif
+		return false
+	}
+
+	if ( EntityIsOutOfBounds( player ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: EntityIsOutOfBounds( player )" )
+		#endif
+		return false
+	}
+
+
+	float range = 300
+	if ( player.IsTitan() )
+	{
+		range = 1000
+
+		// awkward to resume into a core-in-progress
+		if ( IsTitanCoreFiring( player ) )
+		{
+			#if SAVE_DEBUG
+			printt( "SaveGame: Failed: IsTitanCoreFiring( player )" )
+			#endif
+			return false
+		}
+	}
+	else
+	{
+		entity weapon = player.GetActiveWeapon()
+		if ( IsValid( weapon ) )
+		{
+			// cooking grenade?
+			if ( player.GetOffhandWeapon( OFFHAND_ORDNANCE ) == weapon )
+			{
+				#if SAVE_DEBUG
+				printt( "SaveGame: Failed: Cooking grenade" )
+				#endif
+				return false
+			}
+		}
+
+		if ( player.IsPhaseShifted() )
+		{
+			#if SAVE_DEBUG
+			printt( "SaveGame: Failed: player.IsPhaseShifted()" )
+			#endif
+			return false
+		}
+	}
+
+	array<entity> enemies = GetNPCArrayEx( "any", TEAM_ANY, TEAM_MILITIA, player.GetOrigin(), range )
+	if ( enemies.len() > 0 )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: Enemy within " + range + " units" )
+		#endif
+		return false
+	}
+
+	if ( player.IsTitan() )
+	{
+
+		array<entity> titans = GetNPCArrayEx( "npc_titan", TEAM_ANY, TEAM_MILITIA, player.GetOrigin(), 3000 )
+		foreach ( titan in titans )
+		{
+			if ( titan.GetEnemy() == player )
+			{
+				#if SAVE_DEBUG
+				printt( "SaveGame: Failed: Enemy Titan within 3000 units" )
+				#endif
+				return false
+			}
+		}
+	}
+
+	if ( !IsPlayerSafeFromNPCs( player ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: !IsPlayerSafeFromNPCs( player )" )
+		#endif
+		return false
+	}
+
+	if ( !IsPlayerSafeFromProjectiles( player, player.GetOrigin() ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: !IsPlayerSafeFromProjectiles( player )" )
+		#endif
+		return false
+	}
+
+	if ( WasRecentlyHitByDamageSourceId( player, eDamageSourceId.toxic_sludge, 3.0 ) )
+	{
+		#if SAVE_DEBUG
+		printt( "SaveGame: Failed: WasRecentlyHitByDamageSourceId( player, eDamageSourceId.toxic_sludge, 3.0 )" )
+		#endif
+		return false
+	}
+
+	return true
+}
+
+void function BroadcastCheckpointMessage()
+{
+	if ( file.nextSaveSilent )
+	{
+		file.nextSaveSilent = false
+		return
+	}
+
+	// tell clients about the save
+	foreach ( player in GetPlayerArray() )
+	{
+		if ( !IsAlive( player ) )
+			continue
+
+		Remote_CallFunction_NonReplay( player, "SCB_CheckPoint" )
+	}
+}
+
+
+void function AddCallback_OnLoadSaveGame( void functionref( entity ) callbackFunc )
+{
+	Assert( !svGlobalSP.onLoadSaveGameCallbacks.contains( callbackFunc ), "Already added " + string( callbackFunc ) + " with AddCallback_OnLoadSaveGame" )
+	svGlobalSP.onLoadSaveGameCallbacks.append( callbackFunc )
+}
+
+// Why does this need to be threaded?? I don't know!  But it doesn't work if I don't wait a bit.
+void function UpdateUI( bool isTitan, entity player )
+{
+	if ( !IsValid( player ) )
+		return
+
+	player.EndSignal( "OnDeath" )
+
+	wait 0.1
+
+	UpdatePauseMenuMissionLog( player )
+
+	if ( isTitan )
+	{
+		UI_NotifySPTitanLoadoutChange( player )
+		NotifyUI_ShowTitanLoadout( player, null )
+	}
+	else
+	{
+		NotifyUI_HideTitanLoadout( player, null )
+	}
+}
+
+float function LoadSaveTimeDamageMultiplier()
+{
+	return GraphCapped( Time() - file.loadSaveTime, 2.5, 4.0, 0.0, 1.0 )
+}
+
+float function GetLastCheckPointLoadTime()
+{
+	return file.loadSaveTime
+}
+
+bool function JustLoadedFromCheckpoint()
+{
+	return Time() - file.loadSaveTime < 1.0
+}
+
+bool function LoadedFromSave()
+{
+	printt( "SAVEGAME: Trying to load saveName" )
+	if ( !HasValidSaveGame() )
+	{
+		printt( "SAVEGAME: !HasValidSaveGame" )
+		return false
+	}
+
+	string saveName = GetSaveName()
+	printt( "SAVEGAME: Did load " + saveName )
+
+	// set the correct loadscreen
+	string mapName = SaveGame_GetMapName( saveName )
+	int startPointIndex = SaveGame_GetStartPoint( saveName )
+
+	array<string> clientCommands = GetLoadingClientCommands( mapName, startPointIndex, DETENT_FORCE_DISABLE, false )
+	ExecuteClientCommands( clientCommands )
+
+	if ( GetBugReproNum() != 196356 )
+	{
+		printt( "LOADPROGRESS" )
+		ClientCommand( GetFirstPlayer(), "show_loading_progress" )
+		WaitFrame()
+	}
+
+	SaveGame_LoadWithStartPointFallback()
+	return true
+}