initial commit after moving to new repo

1 files changed, 7554 insertions, 0 deletions

diff --git a/Northstar.Coop/scripts/vscripts/sp/sp_training.nut b/Northstar.Coop/scripts/vscripts/sp/sp_training.nut
new file mode 100644
index 00000000..21a67a40
--- /dev/null
+++ b/Northstar.Coop/scripts/vscripts/sp/sp_training.nut
@@ -0,0 +1,7554 @@
+global function CodeCallback_MapInit
+
+#if DEV
+global function skyboxchange
+global function GetOGPilot
+global function wallruntest
+global function Record_ZenGarden_Wallrun
+global function Record_ZenGarden_Slide
+global function Record_ZenGarden_DoubleJump
+global function shutdownscreentest
+global function SendTrainingGauntletStats
+global function FancyTeleport_EffectsAndSound
+global function Training_WeaponRacks_SetSolidity
+global function setfakeinstalldone
+
+global function Training_EnvArtColorCorrection_SetEnabled
+global function SimpleScreenShake
+global function GetSkitGuyInfo_ByName
+global function NudgeSkitGuy
+#endif
+
+const MARVIN_MODEL 							= $"models/robots/marvin/marvin.mdl"
+const asset FX_POD_LASER 					= $"P_pod_scan_laser_FP"
+const asset FX_POD_GLOWLIGHT 				= $"P_pod_door_glow_FP"
+const asset FX_POD_SCREEN_IN				= $"P_pod_screen_lasers_IN"
+const asset FX_POD_SCREEN_OUT				= $"P_pod_screen_lasers_OUT"
+const asset FX_POD_DLIGHT_CONSOLE1 			= $"P_pod_Dlight_console1"
+const asset FX_POD_DLIGHT_CONSOLE2 			= $"P_pod_Dlight_console2"
+//const asset FX_POD_DLIGHT_BACKLIGHT_SIDE 	= $"P_pod_Dlight_backlight_side"
+//const asset FX_POD_DLIGHT_BACKLIGHT_TOP 	= $"P_pod_Dlight_backlight_top"
+const asset FX_FANCY_TELEPORT_ENV_PULSE 	= $"P_ar_holopulse_CP"
+const asset FX_COCKPIT_LIGHT 				= $"xo_cockpit_dlight"
+const asset OG_PILOT_HELMET_MODEL 			= $"models/Humans/heroes/mlt_hero_anderson_helmet.mdl"
+const asset ANDERSON_PILOT_MODEL 			= $"models/humans/heroes/mlt_hero_anderson.mdl"
+const asset PILOT_MODEL_BAY1 				= $"models/humans/pilots/sp_medium_geist_f.mdl"
+const asset PILOT_MODEL_BAY2 				= $"models/humans/pilots/sp_medium_reaper_m.mdl"
+const asset BUDDY_MODEL_POSED_NO_ANIMS 		= $"models/Titans/buddy/BT_posed.mdl"
+const asset SAFETY_BATON_MODEL 				= $"models/industrial/safety_baton.mdl"
+
+const asset OG_PILOT_MODEL 					= $"models/humans/heroes/mlt_hero_lastimosa.mdl"
+const int OG_PILOT_MODEL_HEAD_IDX_BARE 		= 0
+const int OG_PILOT_MODEL_HEAD_IDX_HELMET 	= 2
+const int OG_PILOT_MODEL_DECAL_IDX 			= 0
+const int OG_PILOT_MODEL_DECAL_IDX_BARE 	= 1
+
+const string OG_WEAPON = "mp_weapon_rspn101"
+
+const string ANIM_OG_STANDING_IDLE 		= "OG_stand_upright_idle"
+const string ANIM_OG_STANDING_TALK 		= "OG_stand_upright_talk"
+const string ANIM_OG_SITTING_IDLE 		= "OG_sit_high_idle"
+const string ANIM_OG_SITTING_TALK 		= "OG_sit_high_talk"
+const string ANIM_OG_LEANING_IDLE 		= "OG_stand_lean_idle"
+const string ANIM_OG_LEANING_TALK 		= "OG_stand_lean_talk"
+
+const int SCRIPTED_PATH_WALK 	= 0
+const int SCRIPTED_PATH_RUN 	= 1
+
+const int MAX_RECREATED_OLD_WEAPONS = 16
+
+const float TITANFALL_NAG_DURATION = 3.0  // extra time compensation for nag line playing when titanfall started
+
+const string TRAINING_PLAYER_SETTINGS = "pilot_solo_training"
+
+struct TrainingPod_dLightMapping
+{
+	string scriptAlias
+	asset fxName
+	string attachName
+	entity fxHandle
+}
+
+struct TrainingPod_LaserEmitter
+{
+	entity ent
+	string attachName
+	vector ogAng
+	bool sweepDone = false
+	entity fxHandle
+}
+
+struct TrainingPod_GlowLightRow
+{
+	array<string> fxSpotsL
+	array<string> fxSpotsR
+}
+
+struct LoudspeakerVO_Info
+{
+	string scriptAlias
+	string soundAlias
+	float duration
+}
+
+struct FiringRangeTarget
+{
+	entity ent
+	entity angleRefEnt
+	entity mover
+	bool wasDamaged
+	vector ogAngles
+}
+
+struct SkitGuyInfo
+{
+	int 	id
+	string 	name
+	string 	skitAnim
+	entity 	guy
+	entity 	skitRef
+}
+
+struct HangarTitanGroup
+{
+	entity 	ref
+
+	entity 	titan
+	entity 	rack
+	entity 	marvin
+	entity 	pilot
+
+	int 	titanSkin = -1
+
+	string 	titanAnim
+	string 	rackAnim
+	string 	marvinAnim
+	string 	pilotAnim
+
+	asset 	pilotModel
+
+	vector 	rack_ogPos
+	vector 	rack_ogAng
+
+	float 	sequenceDuration
+	float 	animInitialTime = 0.0
+
+	bool 	isInited = false
+}
+
+struct TrainingGauntletStats
+{
+	bool didBeatRequiredTime 			= false
+	int numRunsBeforeBeatRequiredTime 	= 0
+	int numChallengeRuns 				= 0
+	int numRestarts 					= 0
+	float bestTime 						= -1.0
+	int recommendedDifficulty 			= 0
+}
+
+struct
+{
+	#if DEV
+	bool fakeInstallDone = false
+	#endif
+
+	bool 	gauntletMode = false
+
+	entity 	player
+	int 	playerInputType
+
+	entity ogPilot
+	entity ogTwin
+	entity anderson
+	entity titanTwin
+	entity ogHelmet
+	entity playerAnimWeapon
+
+	entity ogPathMover
+
+	entity animref_hangar
+	entity animref_leaveGauntlet
+
+	entity trainingPod
+	array<TrainingPod_GlowLightRow> trainingPodGlowLightRows
+	array<entity> trainingPodGlowLightFXHandles
+	array<TrainingPod_dLightMapping> trainingPodDLightMappings
+	array<TrainingPod_LaserEmitter> trainingPodLaserEmitters
+
+	float postWallrunVOEndTime = -1
+
+	float titanfallNagStartTime = -1
+	vector playerTitanCallInPos
+
+	entity envArt_colorCorrectionEnt
+	entity skycam_default
+	entity skycam_glitch
+
+	table<string,LoudspeakerVO_Info> loudspeakerVO = {}
+	entity loudspeaker
+
+	array<FiringRangeTarget> firingRangeTargets = []
+
+	//table<string,SkitGuyInfo> skitguys = {}
+	array<SkitGuyInfo> skitguys = []
+
+	TrainingGauntletStats trainingGauntletStats
+
+	array<entity> scriptCreatedWeaponPickups = []
+	bool weaponPickupsHaveAmmo = false
+
+	bool displayWeaponHUD = true
+} file
+
+void function CodeCallback_MapInit()
+{
+	FlagSet( "FlightPath_TitanDrop" )
+
+	PrecacheParticleSystem( FX_POD_LASER )
+	PrecacheParticleSystem( FX_POD_GLOWLIGHT )
+	PrecacheParticleSystem( FX_POD_SCREEN_IN )
+	PrecacheParticleSystem( FX_POD_SCREEN_OUT )
+	PrecacheParticleSystem( FX_POD_DLIGHT_CONSOLE1 )
+	PrecacheParticleSystem( FX_POD_DLIGHT_CONSOLE2 )
+	//PrecacheParticleSystem( FX_POD_DLIGHT_BACKLIGHT_SIDE )
+	//PrecacheParticleSystem( FX_POD_DLIGHT_BACKLIGHT_TOP )
+	PrecacheParticleSystem( FX_FANCY_TELEPORT_ENV_PULSE )
+	PrecacheParticleSystem( FX_COCKPIT_LIGHT )
+
+	PrecacheModel( OG_PILOT_HELMET_MODEL )
+	PrecacheModel( OG_PILOT_MODEL )
+	PrecacheModel( ANDERSON_PILOT_MODEL )
+	PrecacheModel( PILOT_MODEL_BAY1 )
+	PrecacheModel( PILOT_MODEL_BAY2 )
+	PrecacheModel( BUDDY_MODEL_POSED_NO_ANIMS )
+	PrecacheModel( SAFETY_BATON_MODEL )
+	PrecacheModel( MARVIN_MODEL )
+	PrecacheModel( DATA_KNIFE_MODEL )
+
+	LoudspeakerVO_Setup()
+	Training_SharedInit()
+
+	RegisterSignal( "ButtonPressedJump" )
+	RegisterSignal( "ButtonPressedAttack" )
+	RegisterSignal( "PodIntro_OG_StartPodAnim" )
+	RegisterSignal( "PodInteriorSequenceDone" )
+	RegisterSignal( "FancyTeleportStart" )
+	RegisterSignal( "TargetRotate" )
+	RegisterSignal( "TargetDamaged" )
+	RegisterSignal( "Target_WaitForDamage_Start" )
+	RegisterSignal( "StopRepeatingGhostRecorder" )
+	RegisterSignal( "FiringRange_StopResettingTargets" )
+	RegisterSignal( "Gauntlet_StopTeleportingPlayerAtFinishLine" )
+	RegisterSignal( "FirstRun_OG_Creates_Ghost" )
+	RegisterSignal( "GauntletChallenge_FirstGhostAppear" )
+	RegisterSignal( "PlayerMadeSelection" )
+	RegisterSignal( "TrainingPod_BeginInteriorShutdown" )
+	RegisterSignal( "NPC_NewCommand" )
+	RegisterSignal( "LoudspeakerVO_Stop" )
+	RegisterSignal( "glitch_start" )
+
+	FlagInit( "PlayerPressedUse" )
+	FlagInit( "PlayerReloaded" )
+	FlagInit( "PodIntro_PodDoorsClosed" )
+	FlagInit( "PlayerLookedAtTopTarget" )
+	FlagInit( "PlayerLookedAtBottomTarget" )
+	FlagInit( "PodIntro_InteriorBootSequence_Starting" )
+	FlagInit( "OG_WhyWeFight_VO_Done" )
+	FlagInit( "FiringRange_Approach_OG_Sequence_Done" )
+	FlagInit( "ReloadTraining_PlayerPressedReload" )
+	FlagInit( "PlayerSprinted" )
+	FlagInit( "PlayerADSed" )
+	FlagInit( "FiringRangeWeaponSwapped" )
+	FlagInit( "FiringRange_AllTargetsKilled" )
+	FlagInit( "OG_MovedTo_GauntletEntrance" )
+	FlagInit( "Gauntlet_FirstRun_All_VO_Finished" )
+	FlagInit( "Gauntlet_FirstRun_Done" )
+	FlagInit( "ChallengeIntro_VO_Done" )
+	FlagInit( "Gauntlet_PlayingFeedbackVO" )
+	FlagInit( "PlayerUsedConversationInterface" )
+	FlagInit( "GauntletExitConvo_FinishedResponse" )
+	FlagInit( "TitanfallIntroConvo_FinishedResponse" )
+	FlagInit( "PlayerConfirmedGauntletExit" )
+	FlagInit( "PlayerLeavingGauntlet" )
+	FlagInit( "PlayerStartedTitanfall" )
+	FlagInit( "Titanfall_OG_FallingIn_VO_Start" )
+	FlagInit( "TitanfallGlitchStart" )
+	FlagInit( "PlayerWorldChangeThread" )
+	FlagInit( "Glitch_WorldChanging_Zen" )
+	FlagInit( "Glitch_WorldChanging_NonZen" )
+	FlagInit( "PodOutroStarted" )
+	FlagInit( "SimPodShutdown_LoudspeakerVO_Done" )
+	FlagInit( "MeetOG_StartScene" )
+	FlagInit( "CadillacMoment_MeetOG_Done" )
+	FlagInit( "CadillacMoment_MeetOG_StartFadeOut" )
+	FlagInit( "MeetOG_VO_Done" )
+
+	FlagClear( "AutomaticCheckpointsEnabled" )
+
+	AddClientCommandCallback( "Training_SetInputType", ClientCommand_Training_SetInputType )
+	AddClientCommandCallback( "Training_PlayerPressedUse", ClientCommand_Training_PlayerPressedUse )
+	AddClientCommandCallback( "Training_PlayerReloaded", ClientCommand_Training_PlayerReloaded )
+	AddClientCommandCallback( "topTarget", ClientCommand_LookTarget_Top )
+	AddClientCommandCallback( "bottomTarget", ClientCommand_LookTarget_Bottom )
+
+	AddCallback_EntitiesDidLoad( EntitiesDidLoad )
+	AddPlayerDidLoad( Training_PlayerDidLoad )
+	AddCallback_OnLoadSaveGame( Training_OnLoadSaveGame )
+
+	AddDamageCallback( "func_brush", Training_FuncBrush_OnDamaged )
+
+	TimerInit( "firingRangeNag", 15.0 )
+	TimerInit( "installWaitComment", 60.0 )
+
+	AddStartPoint( "Pod Intro", 			Training_PodIntro, 			null, 								Training_Skipped_PodIntro )
+	AddStartPoint( "Basic Movement", 		Training_BasicMovement, 	Training_Setup_BasicMovement, 		Training_Skipped_BasicMovement )
+	AddStartPoint( "Zen Garden", 			Training_ZenGarden, 		Training_Setup_ZenGarden, 			Training_Skipped_ZenGarden )
+	AddStartPoint( "Firing Range", 			Training_FiringRange, 		Training_Setup_FiringRange, 		Training_Skipped_FiringRange )
+	AddStartPoint( "Gauntlet", 				Training_Gauntlet, 			Training_Setup_Gauntlet, 			Training_Skipped_Gauntlet )
+	AddStartPoint( "Gauntlet Challenge", 	Training_GauntletChallenge, Training_Setup_GauntletChallenge, 	Training_Skipped_GauntletChallenge )
+	AddStartPoint( "Titanfall", 			Training_Titanfall, 		Training_Setup_Titanfall, 			Training_Skipped_Titanfall )
+	AddStartPoint( "Pod Outro", 			Training_PodOutro, 			Training_Setup_PodOutro, 			Training_Skipped_PodOutro )
+	AddStartPoint( "Meet OG", 				Training_MeetOG, 			Training_Setup_MeetOG, 				Training_Skipped_MeetOG )
+	AddStartPoint( "Gauntlet Mode", 		Training_GauntletModeStart, Training_Setup_GauntletMode, 		null 	)
+
+	#if DEV
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_FIRSTRUN", TrainingGauntlet_RecordGhostStart_FirstRun, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_WIP", TrainingGauntlet_RecordGhostStart_Challenge_WIP, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_01", TrainingGauntlet_RecordGhostStart_Challenge_01, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_02", TrainingGauntlet_RecordGhostStart_Challenge_02, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_03", TrainingGauntlet_RecordGhostStart_Challenge_03, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_04", TrainingGauntlet_RecordGhostStart_Challenge_04, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_05", TrainingGauntlet_RecordGhostStart_Challenge_05, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_06", TrainingGauntlet_RecordGhostStart_Challenge_06, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_07", TrainingGauntlet_RecordGhostStart_Challenge_07, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_08", TrainingGauntlet_RecordGhostStart_Challenge_08, null, null )
+	AddStartPoint( "DEV_GHOSTREC_GAUNTLET_CHAL_09", TrainingGauntlet_RecordGhostStart_Challenge_09, null, null )
+
+	AddStartPoint( "Pod Intro DEV", DEV_PodIntro, null, null )
+	AddStartPoint( "Pod Outro DEV", DEV_PodOutro, null, null )
+	#endif
+}
+
+
+void function EntitiesDidLoad()
+{
+	QuickDeathTrigger_SetIsPunitive( false )
+
+	SetupTrainingPod()
+	TrainingPod_GlowLightsArraySetup()
+
+	FiringRangeTargets_Init()
+
+	file.animref_hangar = GetEntByScriptName( "animref_hangar" )
+	file.animref_hangar.DisableHibernation()
+
+	file.skycam_default = GetEnt( "skybox_cam_level" )
+	file.skycam_glitch = GetEnt( "skybox_cam_glitch" )
+}
+
+
+void function Training_PlayerDidLoad( entity player )
+{
+	player.SetNoTarget( true )
+	SetGlobalForcedDialogueOnly( true )
+
+	AddButtonPressedPlayerInputCallback( player, IN_JUMP, Training_ButtonPressedJump )
+	AddButtonPressedPlayerInputCallback( player, IN_ATTACK, Training_ButtonPressedAttack )
+
+	file.envArt_colorCorrectionEnt = GetEnt( "color_correction_1" )
+
+	file.player = player
+
+	EnableDemigod( player )
+
+	player.ForceMPAimassist()  // TODO doublecheck this
+
+	player.SetSkyCamera( file.skycam_default )
+
+	Training_WeaponPickups_Init( player )
+	player.PreventWeaponDestroyNoAmmo()  // makes it so when player swaps empty weapon for another pickup, doesn't destroy empty weapon
+
+	thread Training_PlayerQuickdeathSFX( player )
+
+	DisableFriendlyHighlight()
+}
+
+
+void function Training_OnLoadSaveGame( entity player )
+{
+	thread Training_OnLoadSaveGame_Think( player )
+}
+
+void function Training_OnLoadSaveGame_Think( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	wait 0.5  // HACK have to wait otherwise it doesn't work
+	SetWeaponHUDEnabled( player, file.displayWeaponHUD )
+}
+
+
+void function Training_ButtonPressedJump( entity player )
+{
+	player.Signal( "ButtonPressedJump" )
+}
+
+void function Training_ButtonPressedAttack( entity player )
+{
+	player.Signal( "ButtonPressedAttack" )
+}
+
+void function Training_FuncBrush_OnDamaged( entity ent, var damageInfo )
+{
+	if( !IsValid( ent ) )
+		return
+
+	entity attacker = DamageInfo_GetAttacker( damageInfo )
+
+	if ( ent.GetScriptName() == "firingrange_target" )
+	{
+		if ( IsValid( attacker ) && attacker.IsPlayer() )
+		{
+			table<string,vector> resultTable = {}
+			resultTable["damagePos"] <- DamageInfo_GetDamagePosition( damageInfo )
+			ent.Signal( "TargetDamaged", resultTable )
+		}
+	}
+}
+
+
+// ==============================
+// ========= POD INTRO ==========
+// ==============================
+void function Training_Skipped_PodIntro( entity player )
+{
+	player.SetExtraWeaponMods( [ "low_ammo_disable" ] )
+	SetWeaponHUDEnabled( player, false )
+}
+
+#if DEV
+// bare bones start in pod
+void function DEV_PodIntro( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	TakeAllWeapons( player )
+
+	player.SetExtraWeaponMods( [ "low_ammo_disable" ] )
+	SetWeaponHUDEnabled( player, false )
+
+	Training_EnvArtColorCorrection_SetEnabled( false )
+	SetDoF_Hangar( player )
+
+	thread PodIntro_BackgroundSkits( player )
+
+	entity pod = file.trainingPod
+
+	TrainingPod_PlayerSequence_DoorsOpenIdle( player, false )
+
+	// anim starts at a slightly different spot
+	player.SetOrigin( < 10564, -10235, -6056.9 > )
+	player.SetAngles( < -6, 90, 0 > )
+
+	WaitForever()
+}
+#endif //DEV
+
+
+void function Training_PodIntro( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	player.SetExtraWeaponMods( [ "low_ammo_disable" ] )
+	SetWeaponHUDEnabled( player, false )
+
+	Training_EnvArtColorCorrection_SetEnabled( false )
+
+	entity pod = file.trainingPod
+
+	OnThreadEnd(
+		function() : ( player, pod )
+		{
+			if ( IsValid( player ) )
+			{
+				player.Anim_Stop()
+				ClearPlayerAnimViewEntity( player )
+				player.ClearParent()
+				player.UnforceStand()
+
+				Training_EnvArtColorCorrection_SetEnabled( true )
+			}
+
+			if ( IsValid ( pod ) )
+			{
+				pod.Anim_Stop()
+
+				thread TrainingPod_ResetLaserEmitterRotation( pod )
+				thread TrainingPod_KillLasers( pod )
+				thread TrainingPod_KillGlowFX( pod )
+				TrainingPod_KillInteriorDLights()
+			}
+		}
+	)
+
+	// NORMAL LEVEL START
+	SetDoF_Hangar( player )
+
+	ShowIntroScreen( player )
+
+	thread PodIntro_MeetOG( player )
+
+	TrainingPod_PlayerSequence_DoorsOpenIdle( player )
+
+	FlagWait( "IntroScreenFading" )
+	wait 1.2
+	Remote_CallFunction_Replay( player, "ScriptCallback_LevelIntroText" )
+	wait 4.2  // matches fade time in sp_introscreen data
+
+	thread PodIntro_BackgroundSkits( player )
+
+
+	player.Signal( "PodIntro_OG_StartPodAnim" )
+
+	// time for OG to animate before starting viewmodel anim
+	wait 11.8
+
+	FirstPersonSequenceStruct playerSequence
+	playerSequence.blendTime 			= 0.25
+	playerSequence.attachment 			= "REF"
+	playerSequence.firstPersonAnim 		= "ptpov_trainingpod_doors_close"
+	playerSequence.firstPersonAnimIdle 	= "ptpov_trainingpod_idle"
+	playerSequence.thirdPersonAnim 		= "pt_trainingpod_doors_close"
+	playerSequence.thirdPersonAnimIdle 	= "pt_trainingpod_idle"
+	playerSequence.viewConeFunction 	= TrainingPod_ViewConeLock_SemiStrict
+	playerSequence.renderWithViewModels = true
+
+	FirstPersonSequenceStruct podSequence
+	podSequence.blendTime 				= 0.25
+	podSequence.thirdPersonAnim 		= "trainingpod_doors_close"
+	podSequence.thirdPersonAnimIdle 	= "trainingpod_doors_close_idle"
+	podSequence.renderWithViewModels 	= true
+
+	entity viewmodel = player.GetFirstPersonProxy()
+
+	if ( !HasAnimEvent( viewmodel, "PlaySound_SimPod_DoorShut" ) )
+		AddAnimEvent( viewmodel, "PlaySound_SimPod_DoorShut", PlaySound_SimPod_DoorShut )
+
+	// HACK this should be based on an anim event
+	thread TrainingPod_KillInteriorDLights_Delayed( player, 2.65 )
+
+	thread FirstPersonSequence( podSequence, pod )
+	waitthread FirstPersonSequence( playerSequence, player, pod )
+
+	FlagSet( "PodIntro_PodDoorsClosed" )
+
+	TrainingPod_ViewConeLock_PodClosed( player )
+
+	waitthread LookTraining( player )
+
+	// "Let's see how much you remember from last time."
+	waitthread PlayDialogue( "og_how_much_you_remember", player )
+
+	// "Setting the neural link."
+	waitthread PlayDialogue( "og_neural_link", player )
+
+	// "Not quite the same as a Titan link, but it's similar."
+	waitthread PlayDialogue( "og_neural_link_2", player )
+
+	thread TrainingPod_Interior_BootSequence( player )
+
+	// "To learn new skills, we need to be in the right state of mind."
+	thread PlayDialogue( "og_simulation_starting", player, 2.5 )
+
+	player.WaitSignal( "PodInteriorSequenceDone" )
+	printt( "POD SEQUENCE DONE" )
+
+	wait 2.0  // timed to match the screen effect white screen flash
+
+	SetDoF_Default( player )
+}
+
+void function PlaySound_SimPod_DoorShut( entity playerFirstPersonProxy  ) //Hack, needed for wargames but has unfortunate side effect for Training. 
+{
+	entity player = playerFirstPersonProxy.GetOwner()
+	if ( !IsValid( player ) )
+		return
+
+	EmitSoundOnEntityOnlyToPlayer( player, player, "NPE_Scr_SimPod_DoorShut" )
+
+}
+
+void function PodIntro_MeetOG( entity player )
+{
+	entity animref = file.animref_hangar
+	vector animrefOrigin = animref.GetOrigin()
+	vector animrefAngles = animref.GetAngles()
+	vector btSpawnOrg = <0,0,0>  // to avoid red text errors about BT spawning in solid
+
+	entity animEnt = CreateScriptMover( animrefOrigin, animrefAngles )
+
+	// Spawn scene actors
+	entity og = Training_SpawnOGPilot( animref )
+	Training_OGPilot_SetHelmetOn( og, false )
+	AddAnimEvent( file.ogPilot, "pod_slap", PodIntro_OG_Slaps_Pod )
+
+	TitanLoadoutDef loadout = GetTitanLoadoutForCurrentMap()
+	entity bt = CreateAutoTitanForPlayer_FromTitanLoadout( player, loadout, btSpawnOrg, animrefAngles )
+	SetSpawnOption_AISettings( bt, "npc_titan_buddy" )
+	bt.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID
+	DispatchSpawn( bt )
+	FreeAutoTitan( bt )  // HACK this disables the worldspace BT locator icon
+	TakeAllWeapons( bt )
+
+	array<entity> actors = [ bt, og ]
+
+	asset btWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( "mp_titanweapon_xo16_shorty", "playermodel" )
+	Assert( btWeaponModel != $"" )
+	entity btWeapon = CreatePropDynamic( btWeaponModel )
+	btWeapon.SetParent( bt, "PROPGUN" )
+
+	asset ogWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( OG_WEAPON, "playermodel" )
+	Assert( ogWeaponModel != $"" )
+	entity ogWeapon = CreatePropDynamic( ogWeaponModel )
+	ogWeapon.SetParent( og, "PROPGUN" )
+
+	entity ogHelmet = CreatePropDynamic( OG_PILOT_HELMET_MODEL )
+	ogHelmet.DisableHibernation()
+
+	array<entity> props = [ btWeapon, ogWeapon, ogHelmet ]
+
+	OnThreadEnd(
+	function() : ( actors, props, animEnt )
+		{
+			if ( IsValid( file.ogPilot ) )
+				DeleteAnimEvent( file.ogPilot, "pod_slap" )
+
+			foreach ( weapon in props )
+			{
+				if ( IsValid( weapon ) )
+				{
+					weapon.ClearParent()
+					weapon.Destroy()
+				}
+			}
+
+			foreach ( actor in actors )
+			{
+				if ( !IsValid( actor ) )
+					continue
+
+				actor.ClearParent()
+
+				if ( IsInvincible( actor ) )
+					ClearInvincible( actor )
+
+				if ( !actor.IsPlayer() )
+					actor.Destroy()
+			}
+
+			if ( IsValid( animEnt ) )
+				animEnt.Destroy()
+		}
+	)
+
+	foreach ( guy in actors )
+	{
+		MakeInvincible( guy )
+		guy.SetEfficientMode( true )
+		Highlight_ClearFriendlyHighlight( guy )
+	}
+
+	string anim_og_idle 		= "pt_OG_training_rail_sit_idle"
+	string anim_og_helmet_idle 	= "helmet_intro_scene_OG_idle"
+	string anim_bt_idle 		= "BT_intro_scene_OG_idle"
+
+	string anim_og 				= "pt_pod_setup_OG"
+	string anim_bt 				= "BT_pod_setup_OG"
+
+	thread PlayAnimTeleport( og, anim_og_idle, animEnt )
+	thread PlayAnimTeleport( ogHelmet, anim_og_helmet_idle, animEnt )
+	thread PlayAnimTeleport( bt, anim_bt_idle, animEnt )
+
+	player.WaitSignal( "PodIntro_OG_StartPodAnim" )
+
+	if ( !IsValid( og ) )
+		return
+
+	og.Anim_Stop()
+	thread PlayAnim( og, anim_og, animEnt )
+
+	bt.Anim_Stop()
+	thread PlayAnim( bt, anim_bt, animEnt )
+
+	float animDuration = og.GetSequenceDuration( anim_og )
+	wait animDuration - 0.1
+
+	if ( !IsValid( og ) )
+		return
+
+	og.Anim_Stop()
+	thread PlayAnimTeleport( og, anim_og_idle, animEnt )
+
+	bt.Anim_Stop()
+	thread PlayAnimTeleport( bt, anim_bt_idle, animEnt )
+
+	// wait for look training to get started before killing the scene
+	FlagWaitAny( "PlayerLookedAtTopTarget", "PlayerLookedAtBottomTarget" )
+}
+
+void function PodIntro_OG_Slaps_Pod( entity ogPilot )
+{
+	array<entity> players = GetPlayerArray()
+	if ( !players.len() )
+		return
+
+	entity player = players[0]
+	if ( !IsValid( player ) )
+		return
+
+	float shakeDuration = 0.45
+	float shakeAmplitude = 0.14
+	float screenBlurFrac = 0
+	SimpleScreenShake( player, shakeDuration, shakeAmplitude, screenBlurFrac )
+}
+
+void function LookTraining( entity player )
+{
+	thread LookTraining_StartNag( player, "PlayerLookedAtTopTarget", "PlayerLookedAtBottomTarget" )
+
+	Remote_CallFunction_Replay( player, "ScriptCallback_ShowInvertCrosshair", true )
+
+	// LOOKAT SECTION
+	Remote_CallFunction_Replay( player, "ScriptCallback_SetupLookTargets" )
+	wait 0.5
+	Remote_CallFunction_Replay( player, "ScriptCallback_LookTargets_WaitForLookat" )
+
+	DialogueGroup invertConfirmVO = GetDialogueGroup( "ogInvertConfirm" )
+
+	int numInverts = 0
+	int maxInverts = 2
+	//while ( numInverts < maxInverts )
+	while ( 1 )
+	{
+		Remote_CallFunction_Replay( player, "ScriptCallback_SetupLookTargets" )
+		wait 0.5
+		Remote_CallFunction_Replay( player, "ScriptCallback_LookTargets_WaitForLookat" )
+
+		string hintAlias = "invert_look_at_lights"
+		if ( numInverts > 0 )
+			hintAlias = "invert_look_at_lights_again"
+
+		// only play this VO once
+		if ( numInverts == 1 )
+		{
+			// "You sure?"
+			thread PlayDialogue( "og_invert_confirm_3", player )
+		}
+
+		DisplayOnscreenHint( player, hintAlias )
+
+		printt( "Waiting for player to look at either target" )
+
+		FlagWaitAny( "PlayerLookedAtTopTarget", "PlayerLookedAtBottomTarget" )
+
+		printt( "Player looked at one of the targets" )
+
+		hintAlias = "invert_look_at_lights_1_left"
+		if ( numInverts > 0 )
+			hintAlias = "invert_look_at_lights_again_1_left"
+
+		DisplayOnscreenHint( player, hintAlias )
+
+		FlagWait( "PlayerLookedAtTopTarget" )
+		FlagWait( "PlayerLookedAtBottomTarget" )
+
+		printt( "Player looked at both targets" )
+
+		hintAlias = "invert_look_at_lights_0_left"
+		if ( numInverts > 0 )
+			hintAlias = "invert_look_at_lights_again_0_left"
+
+		DisplayOnscreenHint( player, hintAlias )
+
+		printt( "invert waiting for OG dialogue" )
+
+		// "Does that feel right to you?"
+		// "How about now? Feel alright?"
+		string askAlias = DialogueGroup_GetNextLine( invertConfirmVO )
+		waitthread PlayDialogue( askAlias, player )
+
+		printt( "invert OG dialogue done" )
+
+		ClearOnscreenHint( player )
+
+		string invertConvar = file.playerInputType == 0 ? INVERT_CONVAR_GAMEPAD : INVERT_CONVAR_MOUSE
+		printt( "invertConvar:", invertConvar )
+		bool invertSettingBeforeMenu = GetConVarBool( invertConvar )
+
+		printt( "Opening invert look dialog" )
+
+		// THIS PAUSES THE GAME UNTIL MENU IS CLOSED
+		Remote_CallFunction_UI( player, "ScriptCallback_OpenInvertLookDialog" )
+		wait 0.5  // let the game come back after menu is closed
+
+		// if player didn't change setting, don't repeat
+		invertConvar = file.playerInputType == 0 ? INVERT_CONVAR_GAMEPAD : INVERT_CONVAR_MOUSE
+		printt( "invertConvar:", invertConvar )
+		if ( GetConVarBool( invertConvar ) == invertSettingBeforeMenu )
+		{
+			printt( "player didn't change setting, not repeating" )
+			break
+		}
+
+		printt( "invert- player changed setting, repeating to confirm" )
+
+		numInverts++
+
+		// kill lights and reset flags
+		Remote_CallFunction_Replay( player, "ScriptCallback_LookTargets_KillLights" )
+
+		FlagClear( "PlayerLookedAtTopTarget" )
+		FlagClear( "PlayerLookedAtBottomTarget" )
+	}
+
+	ClearOnscreenHint( player )
+	Remote_CallFunction_Replay( player, "ScriptCallback_ShowInvertCrosshair", false )
+
+	// "Alright, we're good to go."
+	waitthread PlayDialogue( "og_invert_complete", player )
+
+	TrainingPod_ViewConeLock_PodClosed( player )
+
+	TrainingPod_ViewConeLock_SemiStrict( player )  // recenter player view
+	Remote_CallFunction_Replay( player, "ScriptCallback_LookTargets_KillLights" )
+}
+
+void function LookTraining_StartNag( entity player, string flag1, string flag2 )
+{
+	EndSignal( player, "OnDestroy" )
+
+	if ( Flag( flag1 ) || Flag( flag2 ) )
+		return
+
+	FlagEnd( flag1 )
+	FlagEnd( flag2 )
+
+	float nagInterval = 15.0
+	float nextNagTime = Time() + nagInterval
+
+	while( 1 )
+	{
+		wait 1
+
+		if ( Time() < nextNagTime )
+			continue
+
+		// "We have to calibrate the pod. It won't boot up until you look at both of those lights."
+		waitthread PlayDialogue( "og_pod_calibrate", player )
+
+		nextNagTime = Time() + nagInterval
+	}
+}
+
+void function TrainingPod_PlayerSequence_DoorsOpenIdle( entity player, bool doPlayerAnim = true )
+{
+	entity pod = file.trainingPod
+
+	// Have to do this first so the anim starts centered on the ref attachment angles
+	string podAttach = "REF"
+	int attachID = pod.LookupAttachment( podAttach )
+	vector podRefOrg = pod.GetAttachmentOrigin( attachID )
+	vector podRefAng = pod.GetAttachmentAngles( attachID )
+	player.SetOrigin( podRefOrg )
+	player.SetAngles( podRefAng )
+	player.ForceStand()
+
+	player.DisableWeapon()
+
+	// default start anim starts open
+	void functionref( entity ) viewConeFunction_start = TrainingPod_ViewConeLock_PodOpen
+	string podAnim_start = "trainingpod_doors_open_idle"
+
+	// start open idle
+	FirstPersonSequenceStruct playerSequence
+	playerSequence.blendTime 			= 0.0
+	playerSequence.attachment 			= podAttach
+	playerSequence.firstPersonAnimIdle 	= "ptpov_trainingpod_idle"
+	playerSequence.thirdPersonAnimIdle 	= "pt_trainingpod_idle"
+	playerSequence.viewConeFunction 	= viewConeFunction_start
+	playerSequence.renderWithViewModels = true
+
+	FirstPersonSequenceStruct podSequence
+	podSequence.blendTime 				= 0.0
+	podSequence.thirdPersonAnimIdle 	= podAnim_start
+	podSequence.renderWithViewModels 	= true
+
+	thread FirstPersonSequence( podSequence, pod )
+
+	if ( doPlayerAnim )
+		thread FirstPersonSequence( playerSequence, player, pod )
+
+	TrainingPod_TurnOnInteriorDLight( "console1" )
+	TrainingPod_TurnOnInteriorDLight( "console2" )
+	//TrainingPod_TurnOnInteriorDLight( "backlight_side_L" )
+	//TrainingPod_TurnOnInteriorDLight( "backlight_side_R" )
+}
+
+
+
+// ------ POD INTRO BACKGROUND SKITS ------
+void function PodIntro_BackgroundSkits( entity player )
+{
+	string endFlag = "PodIntro_PodDoorsClosed"
+	FlagEnd( endFlag )
+
+	thread PodIntro_LoudspeakerVO( player, "PodIntro_InteriorBootSequence_Starting" )
+
+	thread PodIntro_TitanRacks( endFlag )
+
+	thread PodIntro_Background_WalkingGuys()
+
+	// ---- ANIMATING SKIT GUYS ---
+	// script NudgeSkitGuy( "back_console_supervisor", 0, 5, 0 )
+
+	// guy sitting at console in back center of room
+	SkitGuyInfo backConsoleGuy1 = SpawnSkitGuy( "back_console_sitting", "pt_console_idle", < 10521.1, -9679.33, -6044.1 >, < 0, 88.3541, 0 >, TEAM_MILITIA, "npc_soldier" )
+	SkitGuy_PlayAnim( backConsoleGuy1 )
+	SkitGuyInfo backConsoleGuy2 = SpawnSkitGuy( "back_console_supervisor", "pt_bored_interface_leanback", < 10527.6, -9656.36, -6043.97 >, < 0, -26.564, 0 >, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_g2" )
+	SkitGuy_PlayAnim( backConsoleGuy2 )
+
+	// extra marvins working on titans 1 and 2
+	SkitGuyInfo titanBay1_marvin = SpawnSkitGuy( "bay1_marvin", "mv_idle_weld", < 10711.2, -9781.04, -6080.65 >, < 0, 153.715, 0 > )
+	SkitGuy_PlayAnim( titanBay1_marvin, 3.0 )  // don't play same anim at same time
+	SkitGuyInfo titanBay2_marvin = SpawnSkitGuy( "bay2_marvin", "mv_idle_weld", < 10316.2, -9730.23, -6079.97 >, < 0, -69.965, 0 > )
+	SkitGuy_PlayAnim( titanBay2_marvin )
+
+	// guys looking at console in back left
+	SkitGuyInfo leftConsoleGuy1 = SpawnSkitGuy( "console_lean", "pt_bored_interface_leanin", < 10257.6, -9846.63, -6079.97 >, < 0, 34.5175, 0 >, TEAM_MILITIA, "npc_soldier" )
+	SkitGuy_PlayAnim( leftConsoleGuy1 )
+	SkitGuyInfo leftConsoleGuy2 = SpawnSkitGuy( "console_supervisor", "pt_bored_interface_leanback", < 10260.5, -9874.78, -6079.97 >, < 0, -42.534, 0 >, TEAM_MILITIA, "npc_soldier", "mp_weapon_mastiff" )
+	SkitGuy_PlayAnim( leftConsoleGuy2 )
+
+	OnThreadEnd(
+	function() : ()
+		{
+			DeleteAllSkitGuys()
+		}
+	)
+
+	WaitForever()
+}
+
+void function PodIntro_LoudspeakerVO( entity player, string endFlag )
+{
+	EndSignal( player, "OnDestroy" )
+
+	array<string> aliases
+	// "Inbound to Planet Typhon. Subspace rendezvous in approximately 20 minutes."
+	aliases.append( "intro_0" )
+	// "Reminder to dock personnel: Titan ordnance is a Type 3 Hazardous Material."
+	aliases.append( "intro_2" )
+	// "Running Lifeboat diagnostic test two point one. All Mark Eight lifeboats are in the green."
+	aliases.append( "intro_4" )
+	// "3rd Militia Grenadiers - prep dropship MacAllan 17."
+	aliases.append( "intro_5" )
+	// "Captain Cole to communications."
+	aliases.append( "intro_3" )
+	// "Major Anderson, please report to the briefing room."
+	aliases.append( "intro_1" )
+
+	thread LoopLoudspeakerVO( aliases, endFlag, 1.0, 2.0 )
+}
+
+void function PodIntro_Background_WalkingGuys()
+{
+	// group of guys walking left to right
+	array<Point> path1 = []
+	ScriptedPath_AddPoint( path1, < 10327.9, -10000.28, -6079.97 >, < 0, 0.918, 0 > )
+	ScriptedPath_AddPoint( path1, < 10373.5, -9987.14, -6079.97 >, < 0, 0.093, 0 > )
+	ScriptedPath_AddPoint( path1, < 10688.3, -9973.76, -6079.97 >, < 0, 0, 0 > )
+	ScriptedPath_AddPoint( path1, < 10856.4, -9973.58, -6079.97 >, < 0, 0, 0 > )
+	SkitGuyInfo walkerInfo_1 = SpawnSkitGuy( "walker_1", "", path1[0].origin, path1[0].angles, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_hemlok_smg" )
+	thread ScriptedPath_Walk( walkerInfo_1, path1, 0.75 )
+
+	array<Point> path2 = []
+	ScriptedPath_AddPoint( path2, < 10248.6, -9925.06, -6079.97 >, < 0, 6.36392, 0 > )
+	ScriptedPath_AddPoint( path2, < 10373.5, -9939.14, -6079.97 >, < 0, 0.093, 0 > )
+	ScriptedPath_AddPoint( path2, < 10688.3, -9973.76, -6079.97 >, < 0, 0, 0 > )
+	ScriptedPath_AddPoint( path2, < 10856.4, -9973.58, -6079.97 >, < 0, 0, 0 > )
+	SkitGuyInfo walkerInfo_2 = SpawnSkitGuy( "walker_2", "", path2[0].origin, path2[0].angles, TEAM_MILITIA, "npc_soldier", "mp_weapon_hemlok" )
+	thread ScriptedPath_Walk( walkerInfo_2, path2, 0.85 )
+}
+
+void function PodIntro_TitanRacks( string endFlag )
+{
+	FlagEnd( endFlag )
+
+	array<HangarTitanGroup> titanGroups
+
+	HangarTitanGroup bay1
+	bay1.ref 		= GetEntByScriptName( "animref_drop_hangar_titan_1" )
+	bay1.titan 		= GetEntByScriptName( "hangar_titan_1" )
+	bay1.rack 	 	= GetEntByScriptName( "hangar_titan_rack_1" )
+	bay1.titanAnim 	= "bt_TDay_drop_titan4"
+	bay1.rackAnim 	= "rack_TDay_drop_rack4"
+	bay1.marvinAnim = "mv_TDay_drop_marvin4"
+	HangarTitanGroup_Init( bay1 )
+	titanGroups.append( bay1 )
+
+	// ---  BAY 2 ---
+	HangarTitanGroup bay2
+	bay2.ref 		= GetEntByScriptName( "animref_drop_hangar_titan_2" )
+	bay2.titan 		= GetEntByScriptName( "hangar_titan_2" )
+	bay2.rack 	 	= GetEntByScriptName( "hangar_titan_rack_2" )
+	bay2.titanAnim 	= "bt_TDay_drop_titan3"
+	bay2.rackAnim 	= "rack_TDay_drop_rack3"
+	bay2.marvinAnim = "mv_TDay_drop_marvin3"
+	HangarTitanGroup_Init( bay2 )
+	titanGroups.append( bay2 )
+
+	float wait_earlyEnd = 27.0
+	thread HangarTitanGroup_Animate( bay1, endFlag, wait_earlyEnd )
+	thread HangarTitanGroup_Animate( bay2, endFlag, wait_earlyEnd )
+
+	wait wait_earlyEnd
+	thread PodIntro_TitanRacks( endFlag )
+}
+
+
+
+// ===================================
+// ========= BASIC MOVEMENT ==========
+// ===================================
+void function Training_Setup_BasicMovement( entity player )
+{
+	player.DisableWeapon()
+}
+
+void function Training_Skipped_BasicMovement( entity player )
+{
+	player.SetPlayerSettingsWithMods( TRAINING_PLAYER_SETTINGS, [ "disable_doublejump", "disable_wallrun" ] )
+
+	Objective_SetSilent( "#TRAINING_OBJ_DEFAULT" )
+}
+
+void function Training_BasicMovement( entity player )
+{
+	entity standNearJumpRef = GetEntByScriptName( "basic_movement_og_stand_near_jump" )
+	standNearJumpRef.SetOrigin( OriginToGround( standNearJumpRef.GetOrigin() + <0,0,0.5> ) )  // HACK HACK the ref node is a tiny bit in the geo which causes OG to dip when blending between anims
+	entity ogStart = GetEntByScriptName( "basic_movement_og_start" )
+	entity og = Training_SpawnOGPilot( ogStart )
+
+	player.SetPlayerSettingsWithMods( TRAINING_PLAYER_SETTINGS, [ "disable_doublejump", "disable_wallrun" ] )
+	player.ForceAutoSprintOff()
+
+	entity playerStart = GetEntByScriptName( "startpoint_basic_movement" )
+	waitthread PlayerAndOGTeleport_Fancy( player, playerStart.GetOrigin(), "basic_movement_og_start", playerStart.GetAngles() )
+	Training_OG_Idles_Sitting( ogStart, "OG_base_move_A_idle" )
+
+	thread BasicMovement_DelayedWeaponDeploy( player, 1.5 )
+	Objective_SetSilent( "#TRAINING_OBJ_DEFAULT" )
+
+	// "Ah. Much better."
+	waitthread Training_OG_ScriptedAnim( ogStart, "OG_base_move_A" )
+	thread Training_OG_Idles_Sitting( ogStart, "OG_base_move_B_idle" )
+
+	CheckPoint_Silent()
+
+	thread OnscreenHint_DisplayUntilFlag( player, "move_hint", "BasicMovement_PlayerMovedForward", 10.0 )
+
+	FlagWait( "BasicMovement_PlayerMovedForward" )
+
+	if ( !Flag( "BasicMovement_PlayerJumped" ) )
+	{
+		// "Technically, I'm not supposed to be training you. But in you, I see potential.
+		waitthread Training_OG_ScriptedAnim( ogStart, "OG_base_move_B1")
+	}
+
+	if ( !Flag( "BasicMovement_PlayerJumped" ) )
+	{
+		// "Besides, we're at war. Who's got time for classes, eh?"
+		waitthread Training_OG_ScriptedAnim( ogStart, "OG_base_move_B2")
+		thread Training_OG_Idles_Sitting( ogStart )
+	}
+
+	if ( !Flag( "BasicMovement_PlayerJumped" ) && player.IsOnGround() )
+	{
+		DisplayOnscreenHint( player, "jump_hint" )
+
+		// "Here you go, up and over."
+		waitthread Training_OG_ScriptedAnim( ogStart, "OG_base_move_C" )
+		waitthread Training_OG_Moves( standNearJumpRef )
+	}
+
+	if ( !Flag( "BasicMovement_PlayerJumped" ) )
+	{
+		// "Cmon, schedule's tight today."
+		// "Here you go, up and over."
+		array<string> jumpNags = [ "og_jump_nag_2", "og_jump_nag" ]
+
+		thread Training_OG_NagPlayerUntilFlag( player, jumpNags, 20.0, standNearJumpRef, "BasicMovement_PlayerJumped" )
+	}
+
+	FlagWait( "BasicMovement_PlayerJumped" )
+
+	ClearOnscreenHint( player )
+
+	waitthread BasicMovement_Sprint( player )
+}
+
+void function BasicMovement_Sprint( entity player )
+{
+	thread BasicMovement_Sprint_OG_Moves( player )
+
+	//player.ForceAutoSprintOn()
+
+	FlagClear( "PlayerSprinted" )
+	thread BasicMovement_PlayerSprintDetection( player )
+
+	// "Let's pick up the pace. Enabling jumpkit assist."
+	float endVOTime = Time() + 3.5
+	thread PlayDialogue( "og_autosprint_on", file.ogPilot )
+
+	wait 2.5  // let the VO play a bit before showing the hint
+
+	player.UnforceAutoSprint()
+	thread BasicMovement_SprintHint_Think( player )
+
+	wait endVOTime - Time()
+
+	// HACK- Create a fake VO speaker where OG will eventually move to/from so the lines emit in worldspace for audio
+	entity ref = GetEntByScriptName( "basic_movement_og_mid_hallway" )
+	entity tempSpeaker = CreateScriptMover( ref.GetOrigin(), <0,0,0> )
+	thread HACK_MoveTempSpeaker_WithOGPathMover( player, tempSpeaker )
+
+	// "Jumpkits operate on the principle of relaxed stability."
+	EmitSoundOnEntity( tempSpeaker, "diag_sp_addtional_TR411_53_mcor_og" )  // do this instead of PlayDialogue because it will follow the ent around
+	wait 3.4  // HACK
+
+	// "Once your jumpkit calibrates to your movement style, enhanced mobility becomes second nature."
+	EmitSoundOnEntity( tempSpeaker, "diag_sp_movement_TR121_08_01_mcor_og" )
+	wait 6.0  // HACK
+
+	tempSpeaker.Destroy()
+}
+
+void function HACK_MoveTempSpeaker_WithOGPathMover( entity player, entity tempSpeaker )
+{
+	EndSignal( player, "OnDestroy" )
+	EndSignal( tempSpeaker, "OnDestroy" )
+
+	vector prevOrg = < -1,-1,-1 >
+
+	while ( 1 )
+	{
+		WaitFrame()
+
+		vector newOrg = < -1,-1,-1 >
+
+		// if we are doing a path move, use the pathMover origin- otherwise use OG's origin
+		if ( IsValid( file.ogPathMover ) )
+			newOrg = file.ogPathMover.GetOrigin()
+		else if ( IsValid( file.ogPilot ) )
+			file.ogPilot.GetOrigin()
+
+		if ( newOrg != < -1,-1,-1 > && newOrg != prevOrg )
+		{
+			tempSpeaker.SetOrigin( newOrg )
+			prevOrg = newOrg
+		}
+	}
+}
+
+void function BasicMovement_SprintHint_Think( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	float autosprintHintTime = 10.0
+
+	// player with autosprint on will already be sprinting
+	if ( GetAutosprintEnabled() )
+	{
+		thread DisplayOnscreenHint( player, "autosprint_hint", autosprintHintTime )
+		return
+	}
+
+	// Below this point assume that autosprint is NOT enabled
+	if ( !Flag( "PlayerSprinted" ) )
+	{
+		thread OnscreenHint_DisplayUntilFlag( player, "sprint_button_hint", "PlayerSprinted", 0.0, true )
+		FlagWait( "PlayerSprinted" )
+
+		wait 1.0
+	}
+
+	DisplayOnscreenHint( player, "autosprint_available", autosprintHintTime )
+}
+
+void function BasicMovement_Sprint_OG_Moves( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	entity ogMidHallwayRef = GetEntByScriptName( "basic_movement_og_mid_hallway" )
+	waitthread Training_OG_Moves_ToSitting( ogMidHallwayRef, "", 0.8 )
+
+	FlagWait( "BasicMovement_PlayerReachedMidHallway" )
+
+	entity og_zenGarden_start = GetEntByScriptName( "basic_movement_og_zen_start" )
+	thread Training_OG_Moves( og_zenGarden_start, "OG_Beautiful_idle" )
+}
+
+void function BasicMovement_PlayerSprintDetection( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+	FlagEnd( "BasicMovement_PlayerReachedOpenArea" )
+
+	while ( 1 )
+	{
+		WaitFrame()
+
+		if (  player.IsSprinting() )
+			break
+	}
+
+	FlagSet( "PlayerSprinted" )
+}
+
+void function BasicMovement_DelayedWeaponDeploy( entity player, float delay )
+{
+	player.EndSignal( "OnDestroy" )
+
+	wait delay
+	player.EnableWeaponWithSlowDeploy()
+	thread TakeAmmoFromPlayerASAP( player )
+}
+
+
+// =================================================
+// ========= BASIC MOVEMENT 2: ZEN GARDEN ==========
+// =================================================
+void function Training_Setup_ZenGarden( entity player )
+{
+	entity ogStart = GetEntByScriptName( "basic_movement_og_zen_start" )
+	entity og = Training_SpawnOGPilot( ogStart )
+	Training_OG_Idles( ogStart, "OG_Beautiful_idle" )
+
+	thread TakeAmmoFromPlayerASAP( player )
+
+	TeleportPlayerAndBT( "startpoint_zen_garden" )
+}
+
+void function Training_Skipped_ZenGarden( entity player )
+{
+	player.SetPlayerSettingsWithMods( TRAINING_PLAYER_SETTINGS, [] )
+
+	OpenZenGardenExitDoor()
+}
+
+void function Training_ZenGarden( entity player )
+{
+	entity og = GetOGPilot()
+	Assert( IsValid( og ) )
+
+	entity ref_hillclimbFinish = GetEntByScriptName( "zengarden_hillclimb_finish_idle" )
+	entity ref_exitSpot = GetEntByScriptName( "zengarden_og_exit_ref" )
+
+	OpenZenGardenExitDoor()
+
+	FlagWait( "BasicMovement_PlayerReachedOpenArea" )
+
+	player.SetPlayerSettingsWithMods( TRAINING_PLAYER_SETTINGS, ["disable_doublejump"] )
+
+	CheckPoint_Silent()
+
+	thread ZenGarden_WhyWeFight_VO( player, og )
+
+	waitthread Training_ZenGarden_Wallrun( player )
+
+	waitthread Training_ZenGarden_Crouch( player )
+
+	player.SetPlayerSettingsWithMods( TRAINING_PLAYER_SETTINGS, [] )
+
+	CheckPoint_Silent()
+
+	waitthread Training_ZenGarden_DoubleJump( player )
+
+	waitthread Training_ZenGarden_HillClimb( player, ref_hillclimbFinish, ref_exitSpot )
+
+	if ( IsValid( level ) )
+		Signal( level, "StopRepeatingGhostRecorder" )
+}
+
+// ZEN GARDEN SHARED BETWEEN PATHS
+void function ZenGarden_WhyWeFight_VO( entity player, entity og )
+{
+	entity ogStart = GetEntByScriptName( "basic_movement_og_zen_start" )
+	entity firstRockRef = GetEntByScriptName( "zengarden_og_rock1_ref" )
+	entity pathRef = GetEntByScriptName( "zengarden_og_path_ref" )
+	entity treeRef = GetEntByScriptName( "zengarden_og_tree_ref" )
+
+	string stopFlag = "ZenGarden_PlayerReachedWallrunStart"
+	string setFlag = "OG_WhyWeFight_VO_Done"
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "Beautiful, isn't it?"
+		waitthread Training_OG_ScriptedAnim( ogStart, "OG_Beautiful" )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		waitthread Training_OG_Moves( firstRockRef, "", 0.25 )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "It's inspired by my home planet of Harmony."
+		waitthread Training_OG_ScriptedAnim( firstRockRef, "OG_harmony_A" )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "This is where I grew up."
+		waitthread Training_OG_ScriptedAnim( firstRockRef, "OG_harmony_B" )
+	}
+
+	if ( !Flag( stopFlag ) && !Flag( "ZenGarden_PlayerReachedFirstRock" ) )
+	{
+		waitthread Training_OG_Moves( pathRef )
+	}
+
+	FlagWaitAny( stopFlag, "ZenGarden_PlayerReachedFirstRock" )
+
+	if ( !Flag( stopFlag ) )
+	{
+		waitthread Training_OG_Moves_ToSitting( treeRef, "", 0.5 )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "This is what we're fighting for, Cooper."
+		waitthread Training_OG_ScriptedAnim( treeRef, "OG_freedom_A" )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "A world that's not metal and smoke."
+		waitthread Training_OG_ScriptedAnim( treeRef, "OG_freedom_B" )
+	}
+
+	if ( !Flag( stopFlag ) )
+	{
+		// "The freedom to live in peace and prosperity."
+		waitthread Training_OG_ScriptedAnim( treeRef, "OG_freedom_C" )
+	}
+
+	FlagSet( setFlag )
+}
+
+void function Training_ZenGarden_Wallrun( entity player )
+{
+	entity wallrunRef = GetEntByScriptName( "basic_movement_og_zen_wallrun_idle" )
+	entity recorderRef = GetEntByScriptName( "basic_movement_wallrun_start_ref" )
+
+	FlagWaitAny( "ZenGarden_PlayerReachedWallrunStart", "OG_WhyWeFight_VO_Done" )
+
+	FlagWait( "OG_WhyWeFight_VO_Done" )
+
+	waitthread Training_OG_Moves_ToSitting( wallrunRef, "OG_primed_idle", 0.5 )
+
+	FlagWait( "ZenGarden_PlayerReachedWallrunStart" )
+
+	thread GhostRecorder_RepeatUntilFlag( player, "ZenGarden_PlayerFinishedWallrun", recorderRef, $"anim_recording/training_record_zengarden_wallrun.rpak" )
+
+	if ( !Flag( "ZenGarden_PlayerFinishedWallrun" ) )
+		thread OnscreenHint_DisplayUntilFlag( player, "wallrun_hint", "ZenGarden_PlayerFinishedWallrun" )
+
+	wait 1.0  // wait to see if player starts wallrunning right away
+
+	if ( !Flag( "ZenGarden_PlayerFinishedWallrun" ) && !Flag( "ZenGarden_PlayerTouchingWallrunPanel" ) )
+	{
+		// "Let's make sure your jump kit is primed. Basic wallrun here, give it a try."
+		waitthread Training_OG_ScriptedAnim( wallrunRef, "OG_primed" )
+		thread Training_OG_Idles_Sitting( wallrunRef, "OG_primed_idle" )
+	}
+
+	if ( !Flag( "ZenGarden_PlayerFinishedWallrun" ) && !Flag( "ZenGarden_PlayerTouchingWallrunPanel" ) )
+		wait 1.0
+
+	if ( !Flag( "ZenGarden_PlayerFinishedWallrun" ) && !Flag( "ZenGarden_PlayerTouchingWallrunPanel" ) )
+	{
+		// "Same routine as last time- watch the ghost pilot, and try to follow along."
+		thread PlayDialogue( "og_wallrun_follow_ghost", file.ogPilot )
+		waitthread Training_OG_ScriptedAnim( wallrunRef, "OG_primed_generic" )
+		thread Training_OG_Idles_Sitting( wallrunRef, "OG_primed_idle" )
+	}
+
+	FlagWait( "ZenGarden_PlayerFinishedWallrun" )
+
+	if ( !Flag( "ZenGarden_PlayerReachedCrouchArea" ) )
+	{
+		// "Good! Now you're moving."
+		file.postWallrunVOEndTime = Time() + 3.0
+		thread PlayDialogue( "og_wallrun_done", player )
+		wait 0.3  // min wait after
+	}
+}
+
+void function Training_ZenGarden_Crouch( entity player )
+{
+	entity ogIdle_crouchSpot = GetEntByScriptName( "zengarden_og_slide_idle")
+	entity ref_slideStart = GetEntByScriptName( "zengarden_slide_ref" )
+
+	if ( Flag( "ZenGarden_PlayerCrouched" ) )
+		return
+
+	waitthread Training_OG_Moves_ToSitting( ogIdle_crouchSpot, "OG_low_idle", 0.8 )
+	thread GhostRecorder_RepeatUntilFlag( player, "ZenGarden_PlayerCrouched", ref_slideStart, $"anim_recording/training_record_zengarden_slide.rpak", 1.0 )
+
+	FlagWait( "ZenGarden_PlayerReachedCrouchArea" )
+
+	DisplayOnscreenHint( player, "crouch_hint", 5.0 )
+
+	while ( file.postWallrunVOEndTime > 0 && file.postWallrunVOEndTime - Time() > 0 )
+		wait 0.1
+
+	if ( Flag( "ZenGarden_PlayerCrouched" ) )
+		return
+
+	// "Under here. Stay low."
+	waitthread Training_OG_ScriptedAnim( ogIdle_crouchSpot, "OG_low" )
+	thread Training_OG_Idles_Sitting( ogIdle_crouchSpot, "OG_low_idle", true )
+
+	thread Training_ZenGarden_CrouchHint_WithNags( player, 10.0, ogIdle_crouchSpot, "OG_low_idle" )
+
+	FlagWait( "ZenGarden_PlayerCrouched" )
+
+	ClearOnscreenHint( player )
+}
+
+void function Training_ZenGarden_CrouchHint_WithNags( entity player, float nagInterval, entity idleRef, string ogIdleAnim )
+{
+	player.EndSignal( "OnDestroy" )
+
+	string endFlag = "ZenGarden_PlayerCrouched"
+	string activeFlag = "ZenGarden_PlayerAtCrouchStart"
+
+	// "Crouch underneath, and we'll keep moving."
+	// "You need to get low here."
+	array<string> nags = [ "og_crouch_nag_1", "og_crouch_nag_2" ]
+
+	int nagIdx = 0
+	float nextNagTime = Time() + nagInterval
+
+	bool showingHint = false
+
+	while ( !Flag( endFlag ) )
+	{
+		FlagWait( activeFlag )
+
+		while ( Flag( activeFlag ) )
+		{
+			wait 0.1
+
+			if ( player.IsCrouched() )
+			{
+				if ( showingHint )
+				{
+					showingHint = false
+					ClearOnscreenHint( player )
+				}
+
+				continue
+			}
+
+			if ( !showingHint )
+			{
+				DisplayOnscreenHint( player, "crouch_hint" )
+				showingHint = true
+			}
+
+			if ( Time() - nextNagTime >= nagInterval )
+			{
+				thread Training_OG_Talks_Sitting( nags[nagIdx], idleRef, "", ogIdleAnim )
+				nextNagTime = Time() + nagInterval
+
+				nagIdx++
+				if ( nagIdx >= nags.len() )
+					nagIdx = 0
+			}
+		}
+
+		if ( showingHint )
+		{
+			showingHint = false
+			ClearOnscreenHint( player )
+		}
+	}
+}
+
+void function Training_ZenGarden_DoubleJump( entity player )
+{
+	entity pathRef = GetEntByScriptName( "zengarden_og_postslide_idle" )
+	entity ogIdleRef = GetEntByScriptName( "zengarden_og_doublejump_idle" )
+	entity recordedAnimRef = GetEntByScriptName( "zengarden_doublejump_ref" )
+
+	waitthread Training_OG_Moves( pathRef, "", 0.5 )
+
+	// "Simple double jump. Follow the ghost."
+	waitthread Training_OG_Talks( "og_doublejump_hint", pathRef )
+
+	thread GhostRecorder_RepeatUntilFlag( player, "ZenGarden_PlayerDoubleJumped", recordedAnimRef, $"anim_recording/training_record_zengarden_doublejump.rpak", 1.0 )
+
+	waitthread Training_OG_Moves_ToSitting( ogIdleRef, "OG_doublejump_idle", 0.5 )
+
+	// "We've retaken over a quarter of Frontier space since the Battle of Demeter. The Militia's better organized now. More people join everyday to fight the IMC. People like you."
+	waitthread Training_OG_ScriptedAnim( ogIdleRef, "OG_doublejump_A" )
+	Training_OG_Idles( ogIdleRef, "OG_doublejump_B_idle" )
+
+	FlagWait( "ZenGarden_PlayerReachedDoubleJumpArea" )
+
+	if ( !Flag( "ZenGarden_PlayerDoubleJumped" ) )
+	{
+		DisplayOnscreenHint( player, "doublejump_hint", 5.0 )
+		thread OnscreenHint_NagUntilFlag( player, "doublejump_hint", "ZenGarden_PlayerDoubleJumped", 10.0, 5.0 )
+
+		wait 0.8
+	}
+
+	FlagWait( "ZenGarden_PlayerDoubleJumped" )
+}
+
+void function Training_ZenGarden_HillClimb( entity player, entity ref_hillclimbFinish, entity ref_exitSpot )
+{
+	// "We used to just run and hide from them. But now we chase them."
+	string nextAnim = "OG_doublejump_B"
+
+	if ( !Flag( "ZenGarden_PlayerClimbedHill" ) )
+	{
+		waitthread Training_OG_Moves( ref_hillclimbFinish, "", 0.25 )
+		//waitthread Training_OG_Talks( nextLine, ref_hillclimbFinish )
+		waitthread Training_OG_ScriptedAnim( ref_hillclimbFinish, nextAnim )
+		FlagWait( "ZenGarden_PlayerClimbedHill" )
+		waitthread Training_OG_Moves( ref_exitSpot, ANIM_OG_LEANING_IDLE, 0.5 )
+	}
+	else if ( !Flag( "ZenGarden_PlayerReachedExitArea" ) )
+	{
+		waitthread Training_OG_Moves( ref_exitSpot, ANIM_OG_LEANING_IDLE, 0.5 )
+
+		if ( !Flag( "ZenGarden_PlayerReachedExitArea" ) )
+			waitthread Training_OG_ScriptedAnim( ref_exitSpot, nextAnim )
+
+		if ( !Flag( "ZenGarden_PlayerReachedExitArea" ) )
+			waitthread Training_OG_Moves( ref_exitSpot, ANIM_OG_LEANING_IDLE, 0.5 )
+	}
+
+	FlagWait( "ZenGarden_PlayerReachedExitArea" )
+}
+
+
+// =================================
+// ========= FIRING RANGE ==========
+// =================================
+void function Training_Setup_FiringRange( entity player )
+{
+	entity ogStart = GetEntByScriptName( "firingrange_og_needguns_start_sitting" )
+	entity og = Training_SpawnOGPilot( ogStart )
+	Training_OG_Idles_Sitting( ogStart )
+
+	thread TakeAmmoFromPlayerASAP( player )
+
+	TeleportPlayerAndBT( "startpoint_firing_range" )
+}
+
+void function Training_Skipped_FiringRange( entity player )
+{
+	CloseZenGardenExitDoor()
+	OpenGauntletDoor()
+
+	FlagSet( "ineedguns" )
+	Training_WeaponRacks_SetSolidity( true )
+
+	player.SetExtraWeaponMods( [ "" ] )  // turns off low_ammo_disable
+	SetWeaponHUDEnabled( player, true )
+
+	Training_SetWeaponPickupsFullAmmo()
+}
+
+void function Training_FiringRange( entity player )
+{
+	entity ref_og_needGunsStart = GetEntByScriptName( "firingrange_og_needguns_start_sitting" )
+	entity ref_og_firingRangeSpot = GetEntByScriptName( "firingrange_og_spot" )
+	entity ref_og_firingRangeAttractSpot = GetEntByScriptName( "firingrange_og_attract_spot" )
+
+	float ogMoveTime = -1
+
+	Training_WeaponRacks_SetSolidity( false )
+	Training_SetWeaponPickupsEmptyAmmo()
+
+	thread FiringRange_CloseZenGardenDoor_WhenPlayerReachesRange( player )
+
+	waitthread Training_OG_Moves_ToSitting( ref_og_needGunsStart, "OG_Weapons_idle", ogMoveTime )
+
+	FlagWait( "PlayerApproachingFiringRange" )
+
+	thread FiringRange_DetectWeaponSwitch( player )
+
+	waitthread FiringRange_ApproachAndEntry( player, ref_og_needGunsStart, ref_og_firingRangeAttractSpot, ref_og_firingRangeSpot )
+
+	waitthread FiringRange_TrainReload( player, ref_og_firingRangeSpot )
+
+	Training_WeaponRacks_SetSolidity( true )
+	thread FiringRange_InfiniteAmmo_WhenNearRange( player, "PodOutroStarted" )
+	thread FiringRange_ResetTargets_Think( player )
+
+	thread Training_OG_Idles( ref_og_firingRangeSpot, "OG_firingrange_idle" )
+
+	waitthread FiringRange_TrainADS( player, ref_og_firingRangeSpot )
+
+	waitthread FiringRange_PlayerMustDamageAllTargets( player, ref_og_firingRangeSpot, true, false )
+
+	Training_SetWeaponPickupsFullAmmo()
+
+	if ( !Flag( "FiringRangeWeaponSwapped" ) )
+	{
+		waitthread FiringRange_TrainWeaponSwap( player, ref_og_firingRangeSpot )
+
+		FlagWait( "PlayerNearFiringRange" )  // if player moved away to get a weapon, wait for them to come back
+		wait 0.25  // extra wait for player to see the targets reset
+
+		waitthread FiringRange_PlayerMustDamageAllTargets( player, ref_og_firingRangeSpot, false )
+	}
+
+	OpenGauntletDoor()
+
+	CheckPoint_Silent()
+
+	// "Good. Practice more if you want, then head to the Gauntlet."
+	waitthread Training_OG_ScriptedAnim( ref_og_firingRangeSpot, "OG_firingrange_ending" )
+
+	array<string> moveToGauntletNags = [ "og_moving_to_gauntlet_nag_1", "og_moving_to_gauntlet_nag_2", "og_moving_to_gauntlet_nag_3" ]
+
+	if ( Flag( "PlayerNearFiringRange" ) )
+	{
+		entity ref_og_midway2Gauntlet = GetEntByScriptName( "og_between_firingrange_and_gauntlet" )
+		thread Training_OG_NagPlayerUntilFlag_Sitting( player, moveToGauntletNags, 45.0, ref_og_midway2Gauntlet, "OG_MovedTo_GauntletEntrance" )
+
+		waitthread Training_OG_Moves_ToSitting( ref_og_midway2Gauntlet )
+
+		FlagWaitClear( "PlayerNearFiringRange" )
+	}
+
+	FlagSet( "OG_MovedTo_GauntletEntrance" )
+
+	entity ref_og_gauntletEntrance = GetEntByScriptName( "og_gauntlet_entrance_attract_spot" )
+	thread Training_OG_NagPlayerUntilFlag( player, moveToGauntletNags, 45.0, ref_og_gauntletEntrance, "PlayerInGauntletEntryway" )
+
+	waitthread Training_OG_Moves( ref_og_gauntletEntrance )
+}
+
+void function FiringRange_CloseZenGardenDoor_WhenPlayerReachesRange( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	vector doorFarEdge = < -6368, -952, 48 >  // HACK this is the bottom edge of the door farthest from the firing range
+
+	while ( 1 )
+	{
+		WaitFrame()
+
+		if ( !Flag( "PlayerNearFiringRange" ) )
+			continue
+
+		if ( PlayerCanSeePos( player, doorFarEdge, true, 90 ) )
+			continue
+
+		break
+	}
+
+	CloseZenGardenExitDoor()
+}
+
+void function FiringRange_ApproachAndEntry( entity player, entity ref_og_needGunsStart, entity ref_og_firingRangeAttractSpot, entity ref_og_firingRangeSpot )
+{
+	thread FiringRange_Approach_OG_Sequence( player, ref_og_needGunsStart )
+
+	FlagWait( "FiringRange_Approach_OG_Sequence_Done" )
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+	{
+		// "Time to hit the range."
+		waitthread Training_OG_ScriptedAnim( ref_og_needGunsStart, "OG_Weapons_D" )
+	}
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+	{
+		// "I'm over here at the range, Cooper."
+		thread Training_OG_NagPlayerUntilFlag( player, [ "og_firingrange_attract_nag" ], 40.0, ref_og_firingRangeAttractSpot, "PlayerNearFiringRange" )
+
+		waitthread Training_OG_Moves( ref_og_firingRangeAttractSpot )
+	}
+
+	FlagWait( "PlayerNearFiringRange" )
+
+	waitthread Training_OG_Moves( ref_og_firingRangeSpot, "OG_firingrange_idle" )
+}
+
+void function FiringRange_Approach_OG_Sequence( entity player, entity ref_og_needGunsStart )
+{
+	EndSignal( player, "OnDestroy" )
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+		Training_OG_Idles_Sitting( ref_og_needGunsStart )
+
+	if ( Flag( "PlayerNearFiringRange" ) )
+	{
+		// player is rushing forward
+		FlagSet( "ineedguns" )
+		thread FiringRange_INeedGuns_SFX( player, 0.0 )
+	}
+	else
+	{
+		FlagSetDelayed( "ineedguns", 2.0 )
+		thread FiringRange_INeedGuns_SFX( player, 2.0 )
+	}
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+	{
+		// "In combat, things never go as you expect."
+		waitthread Training_OG_ScriptedAnim( ref_og_needGunsStart, "OG_Weapons_A" )
+	}
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+	{
+		// "You must be ready to use any weapon you can find on the field."
+		waitthread Training_OG_ScriptedAnim( ref_og_needGunsStart, "OG_Weapons_B" )
+	}
+
+	if ( !Flag( "PlayerNearFiringRange" ) )
+	{
+		// "These are just a few of the weapons I've come across out there."
+		waitthread Training_OG_ScriptedAnim( ref_og_needGunsStart, "OG_Weapons_C" )
+	}
+
+	FlagSet( "FiringRange_Approach_OG_Sequence_Done" )
+}
+
+void function FiringRange_INeedGuns_SFX( entity player, float delayTime )
+{
+	EndSignal( player, "OnDestroy" )
+
+
+	entity centerEmitter 		= GetEntByScriptName( "ref_firingrange_rack_sfx_center" )
+	entity backCenterEmitter 	= GetEntByScriptName( "ref_firingrange_rack_sfx_backcenter" )
+	entity leftEmitter 			= GetEntByScriptName( "ref_firingrange_rack_sfx_left" )
+	entity rightEmitter 		= GetEntByScriptName( "ref_firingrange_rack_sfx_right" )
+
+	entity moverCenter 		= CreateScriptMover( centerEmitter.GetOrigin(), centerEmitter.GetAngles() )
+	entity moverBackCenter 	= CreateScriptMover( backCenterEmitter.GetOrigin(), backCenterEmitter.GetAngles() )
+	entity moverLeft 		= CreateScriptMover( leftEmitter.GetOrigin(), leftEmitter.GetAngles() )
+	entity moverRight 		= CreateScriptMover( rightEmitter.GetOrigin(), rightEmitter.GetAngles() )
+	array<entity> movers = [ moverCenter, moverBackCenter, moverLeft, moverRight ]
+
+	OnThreadEnd(
+	function() : ( movers )
+		{
+			foreach ( mover in movers )
+			{
+				if( !IsValid( mover ) )
+					continue
+
+				mover.Destroy()
+			}
+		}
+	)
+
+	if ( delayTime > 0.0 )
+		wait delayTime
+
+	EmitSoundOnEntity( moverCenter, 	"training_scr_center_racks" )
+	EmitSoundOnEntity( moverBackCenter, "training_scr_back_racks" )
+	EmitSoundOnEntity( moverLeft, 		"training_scr_left_racks" )
+	EmitSoundOnEntity( moverRight, 		"training_scr_right_racks" )
+
+	wait 15.0  // wait before cleaning up movers
+}
+
+void function FiringRange_DetectWeaponSwitch( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	entity ogWeapon = WaitForPlayerActiveWeapon( player )
+	string ogWeaponName = ogWeapon.GetWeaponClassName()
+
+	while ( 1 )
+	{
+		entity weapon = WaitForPlayerActiveWeapon( player )
+		string weaponName = weapon.GetWeaponClassName()
+
+		if ( weaponName != "" && weaponName != ogWeaponName )
+		{
+			FlagSet( "FiringRangeWeaponSwapped" )
+			break
+		}
+
+		wait 0.5
+	}
+}
+
+void function FiringRange_TrainReload( entity player, entity ogIdleSpot )
+{
+	FlagClear( "PlayerReloaded" )
+
+	SetWeaponHUDEnabled( player, true )
+
+	player.SetExtraWeaponMods( [ "" ] )  // turns off low_ammo_disable
+	thread TakeAmmoFromPlayerASAP( player )
+
+	thread TrainReload_GivePlayerAmmoAfterButtonPressed( player )
+
+	// "Load your weapon."
+	// "Swap in a fresh mag."
+	array<string> reloadNags = [ "og_reload_hint", "og_reload_nag" ]
+
+	wait 1.1 // let pro players reload before prompting
+
+	int nagIdx = 0
+
+	if ( !Flag( "PlayerReloaded" ) )
+	{
+		thread OnscreenHint_DisplayUntilFlag( player, "reload_hint", "PlayerReloaded" )
+
+		float nagInterval = 15
+		float lastNagTime = -100
+
+		while ( !Flag( "PlayerReloaded" ) )
+		{
+			wait 0.1
+
+			if ( Time() - lastNagTime >= nagInterval )
+			{
+				waitthread Training_OG_Talks( reloadNags[nagIdx], ogIdleSpot, "OG_firingrange_talk", "OG_firingrange_idle", true )
+				lastNagTime = Time()
+
+				nagIdx++
+				if ( nagIdx >= reloadNags.len() )
+					nagIdx = 0
+			}
+		}
+	}
+}
+
+void function TrainReload_GivePlayerAmmoAfterButtonPressed( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	FlagWait( "PlayerReloaded" )
+
+	FlagSet( "ReloadTraining_PlayerPressedReload" )
+
+	player.SetActiveWeaponPrimaryAmmoTotal( 50 )
+}
+
+void function FiringRange_InfiniteAmmo_WhenNearRange( entity player, string endFlag )
+{
+	player.EndSignal( "OnDestroy" )
+	FlagEnd( endFlag )
+
+	while ( 1 )
+	{
+		wait 0.5
+
+		if ( !Flag( "PlayerNearFiringRange" ) )
+			continue
+
+		entity weapon = player.GetActiveWeapon()
+
+		if ( weapon == null )
+			continue
+
+		int currAmmo 		= player.GetWeaponAmmoStockpile( weapon )
+		int magSize 		= weapon.GetWeaponSettingInt( eWeaponVar.ammo_clip_size )
+		int maxAmmo 		= weapon.GetWeaponSettingInt( eWeaponVar.ammo_stockpile_max )
+
+		// let player reload before restocking
+		if ( currAmmo > (maxAmmo-magSize + 1) )
+			continue
+
+		printt( "firing range restock ammo" )
+
+		RestockPlayerAmmo_Silent( player )
+	}
+}
+
+void function FiringRange_TrainADS( entity player, entity ref_og_firingRangeSpot )
+{
+	thread FlagSetWhenPlayerADS( player, "PlayerADSed" )
+
+	FlagWaitWithTimeout( "PlayerADSed", 2.5 )  // give player time to ADS before hinting
+
+	if ( !Flag( "PlayerADSed" ) )
+	{
+		// "Aim down the sights when engaging more distant targets."
+		// "You can focus more tightly on your targets if you aim down the sights."
+		array<string> adsNags = [ "og_ads_nag_1", "og_ads_nag_2" ]
+		thread Training_OG_NagPlayerUntilFlag( player, adsNags, 10.0, ref_og_firingRangeSpot, "PlayerADSed", "OG_firingrange_talk", "OG_firingrange_idle" )
+
+		thread OnscreenHint_DisplayUntilFlag( player, "ads_hint", "PlayerADSed" )
+
+		// "To get more precision, aim down the sights of your weapon."
+		waitthread Training_OG_Talks( "og_ads_hint", ref_og_firingRangeSpot, "OG_firingrange_talk", "OG_firingrange_idle", true )
+	}
+
+	FlagWait( "PlayerADSed" )
+}
+
+void function FiringRange_TrainWeaponSwap( entity player, entity ref_og_firingRangeSpot )
+{
+	Signal( player, "FiringRange_StopResettingTargets" )
+
+	if ( !Flag( "FiringRangeWeaponSwapped" ) )
+	{
+		DisplayOnscreenHint( player, "weapon_pickup_hint", 5.0 )
+		thread OnscreenHint_NagUntilFlag( player, "weapon_pickup_hint", "FiringRangeWeaponSwapped", 10.0, 5.0 )
+
+		// "Use a different weapon this time. Grab another one off the rack."
+		thread Training_OG_Talks( "og_weaponswap_hint", ref_og_firingRangeSpot, "OG_firingrange_talk", "OG_firingrange_idle", true )
+
+		// "Switch to a different weapon."
+		array<string> weaponSwapNags = [ "og_weaponswap_nag" ]
+		waitthread Training_OG_NagPlayerUntilFlag( player, weaponSwapNags, 10.0, ref_og_firingRangeSpot, "FiringRangeWeaponSwapped", "OG_firingrange_talk", "OG_firingrange_idle" )
+	}
+}
+
+void function FiringRange_PlayerMustDamageAllTargets( entity player, entity ref_og_firingRangeSpot, bool firstTime, bool resetTargetsAtStart = true )
+{
+	EndSignal( player, "OnDestroy" )
+
+	FlagClear( "FiringRange_AllTargetsKilled" )
+	thread FiringRange_ResetTargets_Think( player, resetTargetsAtStart )
+
+	thread OnscreenHint_DisplayUntilFlag( player, "firingrange_dmg_targets_hint", "FiringRange_AllTargetsKilled" )
+
+	wait 2.0
+
+	// "Gotta take 'em all out before we can move on."
+	// "Just aim, take a breath, and squeeze the trigger."
+	// "In the real world, the targets don't just stand still. They shoot back."
+	DialogueGroup nags = GetDialogueGroup( "shootTargetsNag" )
+
+	int numTargetsKilled = FiringRange_GetNumDamagedTargets()
+
+	while ( !Flag( "FiringRange_AllTargetsKilled" ) )
+	{
+		wait 1.0
+
+		// don't nag player if they recently damaged a target
+		if ( FiringRange_GetNumDamagedTargets() > numTargetsKilled )
+		{
+			numTargetsKilled = FiringRange_GetNumDamagedTargets()
+			TimerReset( "firingRangeNag" )
+
+			continue
+		}
+
+		if ( !TimerCheck( "firingRangeNag" ) )
+			continue
+
+		string nagLine = DialogueGroup_GetNextLine( nags )
+		waitthread Training_OG_Talks( nagLine, ref_og_firingRangeSpot, "OG_firingrange_talk", "OG_firingrange_idle", true )
+
+		TimerReset( "firingRangeNag" )
+	}
+}
+
+void function FiringRangeTargets_Init()
+{
+	string targetScriptName = "firingrange_target"
+	array<entity> targetEnts = GetEntArrayByScriptName( targetScriptName )
+	Assert( targetEnts.len(), "Couldn't get firing range targets with script_name " + targetScriptName )
+
+	foreach ( ent in targetEnts )
+	{
+		ent.SetTakeDamageType( DAMAGE_EVENTS_ONLY )
+		ent.SetDamageNotifications( true )
+
+		entity angleRefEnt = ent.GetLinkEnt()
+		Assert( IsValid( angleRefEnt ), "Firing range target needs an angle reference entity linked" )
+		angleRefEnt.SetParent( ent )
+
+		FiringRangeTarget target
+		target.ent = ent
+		target.angleRefEnt = angleRefEnt
+		target.ogAngles = ent.GetAngles()
+		target.mover = CreateScriptMover( ent.GetOrigin(), ent.GetAngles() )
+		ent.SetParent( target.mover )
+
+		file.firingRangeTargets.append( target )
+	}
+}
+
+int function FiringRange_GetNumDamagedTargets()
+{
+	int numDamaged = 0
+
+	foreach ( target in file.firingRangeTargets )
+		if ( target.wasDamaged )
+			numDamaged++
+
+	return numDamaged
+}
+
+void function FiringRange_ResetAllTargets()
+{
+	foreach ( target in file.firingRangeTargets )
+		FiringRangeTarget_Reset( target )
+}
+
+void function FiringRangeTarget_Reset( FiringRangeTarget target )
+{
+	if ( !IsValid( target.ent ) )
+		return
+
+	target.wasDamaged = false
+
+	thread FiringRangeTarget_RotateBack( target )
+}
+
+void function FiringRange_ResetTargets_Think( entity player, bool resetTargetsAtStart = true )
+{
+	Signal( player, "FiringRange_StopResettingTargets" )
+	EndSignal( player, "FiringRange_StopResettingTargets" )
+	EndSignal( player, "OnDestroy" )
+
+	FlagEnd( "PodOutroStarted" )
+
+	array<FiringRangeTarget> firingRangeTargets = file.firingRangeTargets
+
+	bool firstLoop = true
+	float targetResetWait = 1.75
+
+	while ( 1 )
+	{
+		bool resetTargets = true
+		if ( firstLoop && !resetTargetsAtStart )
+			resetTargets = false
+
+		if ( resetTargets )
+			FiringRange_ResetAllTargets()
+
+		foreach ( target in firingRangeTargets )
+			thread FiringRangeTarget_WaitForDamage( target )
+
+		// wait for all targets to take damage
+		while ( 1 )
+		{
+			wait 0.2
+
+			bool allDamaged = true
+			foreach ( target in firingRangeTargets )
+			{
+				if ( !target.wasDamaged )
+				{
+					allDamaged = false
+					break
+				}
+			}
+
+			if ( allDamaged )
+				break
+		}
+
+		FlagSet( "FiringRange_AllTargetsKilled" )
+
+		wait targetResetWait
+
+		if ( firstLoop )
+			firstLoop = false
+	}
+}
+
+void function FiringRangeTarget_WaitForDamage( FiringRangeTarget target )
+{
+	Signal( target.ent, "Target_WaitForDamage_Start" )
+	EndSignal( target.ent, "Target_WaitForDamage_Start" )
+	EndSignal( target.ent, "OnDestroy" )
+
+	bool first = true
+	while ( 1 )
+	{
+		table result = WaitSignal( target.ent, "TargetDamaged" )
+		vector damagePos = expect vector( result.damagePos )
+
+		if ( first )
+		{
+			thread FiringRangeTarget_FirstDamage( target, damagePos )
+			first = false
+		}
+	}
+
+	return
+}
+
+string function FiringRangeTarget_GetDamageSide( FiringRangeTarget target, vector damagePos )
+{
+	vector upEntPos = target.angleRefEnt.GetOrigin()
+	vector upEntAngles = target.angleRefEnt.GetAngles()
+
+	vector facingVec = AnglesToForward( upEntAngles )
+	vector vecToDamage = Normalize( damagePos - upEntPos )
+	float dot2Damage = DotProduct( vecToDamage, facingVec )
+	printt( "damage dot product:", dot2Damage )
+
+	#if DEV
+	//float debugDrawTime = 3.0
+	//DebugDrawAngles( damagePos, upEntAngles, debugDrawTime )
+	//DebugDrawLine( upEntPos, upEntPos + (facingVec * 200), 200, 200, 0, true, debugDrawTime )
+	#endif
+
+	vector frontFacingVec = AnglesToRight( upEntAngles )
+	bool isOnLeft = IsPointInFrontofLine( damagePos, upEntPos, frontFacingVec )
+
+	string returnStr = "left"
+	if ( isOnLeft )
+	{
+		printt( "LEFT SIDE" )
+	}
+	else
+	{
+		printt( "RIGHT SIDE" )
+		returnStr = "right"
+	}
+
+	return returnStr
+}
+
+void function FiringRangeTarget_FirstDamage( FiringRangeTarget target, vector damagePos )
+{
+	//Assert( !target.wasDamaged, "Target not expected to be damaged yet" )
+	if ( target.wasDamaged )
+		return
+
+	target.wasDamaged = true
+
+	if ( IsAlive( file.player ) )
+		EmitSoundOnEntity( file.player, "training_scr_hit_target" )
+
+	// rotate left by default
+	float rotateAngY = 179.9
+	if ( FiringRangeTarget_GetDamageSide( target, damagePos ) == "right" )
+		rotateAngY *= -1
+
+	vector newAngles = target.ogAngles + Vector( 0, rotateAngY, 0 )
+	thread FiringRangeTarget_Rotate( target, newAngles )
+}
+
+void function FiringRangeTarget_Rotate( FiringRangeTarget target, vector targetAngles )
+{
+	Signal( target.mover, "TargetRotate" )
+	EndSignal( target.mover, "TargetRotate" )
+	EndSignal( target.mover, "OnDestroy" )
+
+	float rotateTime = 0.14
+	float accelTime = 0
+	float decelTime = 0.1
+	target.mover.NonPhysicsRotateTo( targetAngles, rotateTime, accelTime, decelTime )
+
+	wait rotateTime
+}
+
+void function FiringRangeTarget_RotateBack( FiringRangeTarget target )
+{
+	if ( target.ent.GetAngles() == target.ogAngles )
+		return
+
+	EmitSoundAtPosition( TEAM_UNASSIGNED, target.ent.GetOrigin(), "training_scr_range_target_spin" )
+
+	waitthread FiringRangeTarget_Rotate( target, target.ogAngles )
+}
+
+
+void function FlagSetWhenPlayerADS( entity player, string setFlag )
+{
+	player.EndSignal( "OnDestroy" )
+
+	while ( player.GetZoomFrac() < 0.9 )
+		wait 0.1
+
+	FlagSet( setFlag )
+}
+
+
+
+// =============================
+// ========= GAUNTLET ==========
+// =============================
+void function Training_Setup_Gauntlet( entity player )
+{
+	entity ogStart = GetEntByScriptName( "og_gauntlet_entrance_attract_spot" )
+	entity og = Training_SpawnOGPilot( ogStart )
+	Training_OG_Idles( ogStart )
+
+	TeleportPlayerAndBT( "startpoint_gauntlet_entrance" )
+}
+
+void function Training_Skipped_Gauntlet( entity player )
+{
+	FlagSet( "Gauntlet_FirstRun_Done" )
+	thread TrainingGauntlet_RemindPlayerAboutMobility( player )
+	thread TrainingGauntlet_CrouchHint( player )
+	thread TrainingGauntlet_SetsDifficulty( player )
+}
+
+void function Training_Gauntlet( entity player )
+{
+	entity og = GetOGPilot()
+
+	entity ref_og_gauntletStartPos = GetEntByScriptName( "og_near_gauntlet_start_pos" )
+	GauntletInfo trainingGauntlet = GetTrainingGauntlet()
+
+	// HACK
+	vector resultsBoardCenterPos = < -4899.15, 666.269, 107.187 >
+
+	if ( !Flag( "PlayerInGauntletEntryway" ) && !trainingGauntlet.isActive && !PlayerCanSeePos( player, resultsBoardCenterPos, true, 90 ) )
+		DisableGauntlet( trainingGauntlet )  // let a rushing player start the gauntlet
+
+	if ( !trainingGauntlet.isActive )
+		FlagWait( "PlayerInGauntletEntryway" )
+
+	if ( !trainingGauntlet.isActive )
+		CheckPoint_Silent()
+
+	waitthread Training_OG_Moves( ref_og_gauntletStartPos, ANIM_OG_LEANING_IDLE )
+
+	thread Training_Gauntlet_FirstRunDialogue( player, trainingGauntlet, ref_og_gauntletStartPos )
+	wait 1.0
+
+	EnableGauntlet( trainingGauntlet )
+	thread Training_Gauntlet_FirstRunGhostPlaybackStart( player, trainingGauntlet )
+	thread TrainingGauntlet_TeleportPlayerAtFinishLine( player )
+	thread TrainingGauntlet_RemindPlayerAboutMobility( player, "Gauntlet_FirstRun_All_VO_Finished" )
+	thread TrainingGauntlet_CrouchHint( player )
+	thread TrainingGauntlet_SetsDifficulty( player )
+
+	thread Training_Gauntlet_WaitForRequiredTime( player, ref_og_gauntletStartPos )
+	FlagWait( "Gauntlet_FirstRun_Done" )
+
+	if ( !trainingGauntlet.isActive )
+		CheckPoint_Silent()
+
+	Gauntlet_StopGhostPlayback( trainingGauntlet )
+
+	waitthread Training_Gauntlet_PostFirstRunDialogue( player, trainingGauntlet )
+}
+
+
+void function Training_Gauntlet_FirstRunDialogue( entity player, GauntletInfo gauntlet, entity ogIdleSpot )
+{
+	player.EndSignal( "OnDestroy" )
+
+	if ( !gauntlet.isActive )
+	{
+		// "Alright. Got a new gauntlet for you to run today."
+		waitthread Training_OG_ScriptedAnim( ogIdleSpot, "OG_gauntlet_start_A" )
+	}
+
+	if ( !gauntlet.isActive )
+	{
+		// "Par time is a minute-forty-five."
+		waitthread Training_OG_ScriptedAnim( ogIdleSpot, "OG_gauntlet_start_B" )
+	}
+
+	if ( !gauntlet.isActive )
+	{
+		// "Gotta do better than that to continue."
+		waitthread Training_OG_ScriptedAnim( ogIdleSpot, "OG_gauntlet_start_C" )
+	}
+
+	Objective_Set( "#TRAINING_OBJ_GAUNTLET_FIRSTRUN" )
+
+	//if ( gauntlet.isActive )
+	//	Training_Gauntlet_OG_Creates_FirstRun_Ghost( file.ogPilot )
+
+	AddAnimEvent( file.ogPilot, "create_ghost", Training_Gauntlet_OG_Creates_FirstRun_Ghost )
+
+	// "Follow the ghost, or find your own path."
+	waitthread Training_OG_ScriptedAnim( ogIdleSpot, "OG_gauntlet_start_D" )
+	thread Training_OG_Idles( ogIdleSpot, "OG_gauntlet_start_endidle" )
+
+	DeleteAnimEvent( file.ogPilot, "create_ghost" )
+
+	float minDelayEnd = 5.0 + Time()
+	DialogueGroup firstRunGauntletLore = GetDialogueGroup( "firstRunGauntletLore" )
+	while ( !Flag( "Gauntlet_FirstRun_Done" ) && !firstRunGauntletLore.allPlayed )
+	{
+		wait 1
+
+		if ( !gauntlet.isActive )
+			continue
+
+		if ( Time() < minDelayEnd )
+			continue
+
+		string line = DialogueGroup_GetNextLine( firstRunGauntletLore )
+		PlayDialogue( line, player )
+	}
+
+	FlagSet( "Gauntlet_FirstRun_All_VO_Finished" )
+}
+
+void function Training_Gauntlet_OG_Creates_FirstRun_Ghost( entity og )
+{
+	entity player = file.player
+	if ( !IsValid( player ) )
+		return
+
+	player.Signal( "FirstRun_OG_Creates_Ghost" )
+}
+
+void function TrainingGauntlet_RemindPlayerAboutMobility( entity player, string waitFlag = "" )
+{
+	EndSignal( player, "OnDestroy" )
+	FlagEnd( "PlayerLeavingGauntlet" )
+
+	GauntletInfo trainingGauntlet = GetTrainingGauntlet()
+
+	//if ( waitFlag != "" && !Flag( waitFlag ) )
+	//	FlagWait( waitFlag )
+
+	float nagInterval = 300  // 5 minutes
+	float nextNagTime = -1
+
+	float minSampleTime = 15.0
+	float lowWallrunningFrac = 0.05
+
+	bool hasSprinted = false
+
+	FlagWait( "Gauntlet_FirstRun_All_VO_Finished" )
+
+	while ( !Flag( "PlayerLeavingGauntlet" ) )
+	{
+		if ( !trainingGauntlet.isActive )
+			WaitSignal( player, "Gauntlet_RunStarted" )
+
+		float startTime = Time()
+		float samplePoints = 0
+		float samplesWallrunning = 0
+
+		while ( trainingGauntlet.isActive )
+		{
+			wait 0.1
+
+			if ( player.IsSprinting() && !hasSprinted )
+				hasSprinted = true
+
+			samplePoints++
+			if ( player.IsWallRunning() )
+				samplesWallrunning++
+
+			if ( (Time() - startTime) < minSampleTime )
+				continue
+
+			float wallrunningFrac = samplesWallrunning / samplePoints
+			printt( "wallrunningFrac:", wallrunningFrac )
+
+			// Has player done all the stuff we would want to remind them about?
+			if ( wallrunningFrac >= lowWallrunningFrac && hasSprinted )
+				break
+
+			if ( Time() >= nextNagTime )
+			{
+				if ( !hasSprinted )
+					thread TrainingGauntlet_SprintNag( player )
+				else if ( wallrunningFrac < lowWallrunningFrac )
+					thread TrainingGauntlet_WallrunNag( player, trainingGauntlet )
+
+				nextNagTime = Time() + nagInterval
+			}
+
+			break
+		}
+
+		if ( trainingGauntlet.isActive )
+			WaitSignal( player, "Gauntlet_RunStopped" )
+	}
+}
+
+void function TrainingGauntlet_SprintNag( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	float hintDuration = 10.0
+	float hintEndTime = Time() + hintDuration
+	DisplayOnscreenHint( player, "sprint_button_hint", hintDuration )
+
+	EndSignal( player, "DisplayingOnscreenHint" )
+
+	while ( Time() < hintEndTime && !player.IsSprinting() )
+		WaitFrame()
+
+	ClearOnscreenHint( player )
+}
+
+void function TrainingGauntlet_WallrunNag( entity player, GauntletInfo trainingGauntlet )
+{
+	EndSignal( player, "OnDestroy" )
+
+	//printt( "playing mobility nag" )
+
+	DisplayOnscreenHint( player, "gauntlet_wallrun_hint", 8.0 )
+
+	DialogueGroup gauntletHints_wallrun = GetDialogueGroup( "gauntletHints_wallrun" )
+	string line = DialogueGroup_GetNextLine( gauntletHints_wallrun )
+	waitthread PlayDialogue( line, player )
+
+	if ( !trainingGauntlet.isActive )
+		return
+
+	waitthread PlayDialogue( "og_gauntlet_hint_wallrun_capper", player )
+}
+
+void function TrainingGauntlet_CrouchHint( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	string checkFlag = "Gauntlet_PlayerInCrouchHintZone"
+	string nagTimer = "gauntlet_crouchHint"
+
+	TimerInit( nagTimer, 2.5 )
+
+	float waitTime = 1.0
+	bool hintShowing = false
+
+	while ( 1 )
+	{
+		wait waitTime
+
+		if ( !Flag( checkFlag ) )
+			continue
+
+		TimerReset( nagTimer )
+
+		while ( Flag( checkFlag ) )
+		{
+			wait waitTime
+
+			if ( !TimerCheck( "gauntlet_crouchHint" ) )
+				continue
+
+			if ( !hintShowing )
+			{
+				DisplayOnscreenHint( player, "crouch_hint" )
+				hintShowing = true
+			}
+		}
+
+		if ( hintShowing )
+		{
+			ClearOnscreenHint( player )
+			hintShowing = false
+		}
+	}
+}
+
+void function Training_Gauntlet_PostFirstRunDialogue( entity player, GauntletInfo gauntlet )
+{
+	player.EndSignal( "OnDestroy" )
+	player.EndSignal( "Gauntlet_RunStarted" )
+
+	entity ref_og_gauntletResults = GetEntByScriptName( "og_ref_gauntlet_results_display" )
+
+	Objective_SetSilent( "#TRAINING_OBJ_DEFAULT" )
+
+	waitthread Training_OG_Moves( ref_og_gauntletResults, "", 1.0 )
+
+	AddAnimEvent( file.ogPilot, "highlight_results_board_tip", Gauntlet_PostFirstRun_SetRandomTip )
+
+	// "Nice run! See the results board on the wall? You set a new Best Time."
+	// "Everyone has different strengths and weaknesses, so be sure to run this a few times with different weapons."
+	// "Look at the results board for more tips on how to improve."
+	waitthread Training_OG_ScriptedAnim( ref_og_gauntletResults, "OG_Gauntlet_return" )
+
+	DeleteAnimEvent( file.ogPilot, "highlight_results_board_tip" )
+}
+
+// update tip while OG is talking about the tips
+void function Gauntlet_PostFirstRun_SetRandomTip( entity og )
+{
+	entity player = file.player
+	if ( !IsValid( player ) )
+		return
+
+	GauntletInfo gauntlet = GetTrainingGauntlet()
+	Remote_CallFunction_Replay( player, "ScriptCallback_GauntletResultsDisplay_SetRandomTip", gauntlet.id )
+}
+
+void function Training_Gauntlet_FirstRunGhostPlaybackStart( entity player, GauntletInfo gauntlet )
+{
+	if ( !gauntlet.isActive )
+		WaitSignal( player, "Gauntlet_RunStarted", "FirstRun_OG_Creates_Ghost" )
+
+	thread Gauntlet_StartGhostPlayback( gauntlet, GHOST_NAME_FIRSTRUN, "#GAUNTLET_GHOST_NAME_FIRSTRUN" )
+}
+
+void function Training_Gauntlet_WaitForRequiredTime( entity player, entity ogIdleSpot )
+{
+	player.EndSignal( "OnDestroy" )
+
+	GauntletInfo gauntlet = GetTrainingGauntlet()
+
+	// "The first run of the day is always the toughest."
+	// "Too slow! I know you can do better. Give it another try."
+	DialogueGroup firstRunFailedGroup = GetDialogueGroup( "firstRunFailed" )
+
+	int failCount = 0
+	while ( 1 )
+	{
+		// keep setting this here because by default the gauntlet updates its random tip after each finished run
+		Remote_CallFunction_Replay( player, "ScriptCallback_TrainingGauntlet_ResultsDisplay_SetTip", gauntlet.id, 0 )
+
+		player.WaitSignal( "Gauntlet_RunStopped" )
+
+		wait 0.1  // HACK let the gauntlet struct get updated before checking it
+
+		TrainingGauntletStats_PostRunUpdate( player, gauntlet, 0 )
+
+		if ( !gauntlet.runFinished )
+			continue
+
+		failCount++
+
+		if ( gauntlet.bestTime <= TRAINING_GAUNTLET_MAX_TIME_TO_PROGRESS || failCount == NUM_GAUNTLET_FAILS_BEFORE_FORCED_PROGRESS )
+		{
+			if ( gauntlet.bestTime <= TRAINING_GAUNTLET_MAX_TIME_TO_PROGRESS )
+				printt( "Gauntlet moving on: beat required time" )
+			else if ( failCount == NUM_GAUNTLET_FAILS_BEFORE_FORCED_PROGRESS )
+				printt( "Gauntlet moving on: forced progress after", NUM_GAUNTLET_FAILS_BEFORE_FORCED_PROGRESS, "failures" )
+
+			break
+		}
+
+		wait 0.5  // let player get settled before VO starts
+
+		EmitSoundOnEntityOnlyToPlayer( player, player, "training_scr_gaunlet_fail_01" )
+
+		string firstRunFailedLine = DialogueGroup_GetNextLine( firstRunFailedGroup )
+		thread Training_OG_Talks_Leaning( firstRunFailedLine, ogIdleSpot, "", "", true )
+
+		Objective_Remind()
+		//DisplayOnscreenHint( player, "gauntlet_first_run_progression_hint", 9.0 )
+
+		if ( failCount == 2 )
+			thread DoSprintEnableDialogForGauntletIfNeeded_Thread( player, 3.5 )
+	}
+
+	TrainingGauntletPostRun_TryAchievements( player, gauntlet )
+
+	FlagSet( "Gauntlet_FirstRun_Done" )
+}
+
+void function DoSprintEnableDialogForGauntletIfNeeded_Thread( entity player, float waitTime )
+{
+	EndSignal( player, "OnDestroy" )
+	wait waitTime
+
+	if ( GetAutosprintEnabled() )
+		return
+
+	Remote_CallFunction_UI( player, "ScriptCallback_OpenAutosprintDialogForGauntlet" )
+}
+
+void function TrainingGauntlet_TeleportPlayerAtFinishLine( entity player )
+{
+	Signal( player, "Gauntlet_StopTeleportingPlayerAtFinishLine" )
+	EndSignal( player, "Gauntlet_StopTeleportingPlayerAtFinishLine" )
+	EndSignal( player, "OnDestroy" )
+
+	entity startEnt = GetEntByScriptName( "results_room_teleport_refA" )
+	entity endEnt = GetEntByScriptName( "results_room_teleport_refB" )
+	vector startPos = startEnt.GetOrigin()
+	vector endPos 	= endEnt.GetOrigin()
+
+	while ( 1 )
+	{
+		player.WaitSignal( "Gauntlet_PlayerHitFinishTrig" )
+
+		vector currentPos = player.GetOrigin()
+		float offsetX = currentPos.x - startPos.x
+		float offsetY = currentPos.y - startPos.y
+		float offsetZ = currentPos.z - startPos.z
+
+		float newPosX = endPos.x + offsetX
+		float newPosY = endPos.y + offsetY
+		float newPosZ = endPos.z + offsetZ
+
+		vector newPos = < newPosX, newPosY, newPosZ >
+
+		player.SetOrigin( newPos )
+	}
+}
+
+
+void function TrainingGauntlet_SetsDifficulty( entity player )
+{
+	if ( Flag( "PlayerLeavingGauntlet" ) )
+		return
+
+	FlagEnd( "PlayerLeavingGauntlet" )
+
+	player.EndSignal( "OnDestroy" )
+
+	GauntletInfo gauntlet = GetTrainingGauntlet()
+
+	bool diffSetOnce = false
+
+	while ( 1 )
+	{
+		WaitSignal( player, "Gauntlet_RunStopped" )
+
+		if ( file.gauntletMode )
+			return
+
+		wait 0.2 // HACK let the gauntlet struct and file variables get set up after the run
+
+		// extra wait for player to finish seeing their time, etc.
+		wait 2.0
+
+		if ( !gauntlet.runFinished )
+			continue
+
+		if ( !gauntlet.lastRunBestTime )
+			continue
+
+		int prevDiff = -1
+		if ( diffSetOnce )
+			prevDiff = GetConVarInt( "sp_difficulty" )
+
+		Training_SetDifficultyForGauntletTime( gauntlet.bestTime )
+		if ( GetConVarInt( "sp_difficulty" ) > prevDiff )
+			Training_AnnounceDifficultyForGauntletTime( player, 8.0 )
+
+		if ( !diffSetOnce )
+			diffSetOnce = true
+	}
+}
+
+void function Training_SetDifficultyForGauntletTime( float time )
+{
+	float time = file.trainingGauntletStats.bestTime
+	if ( time == -1 )
+		time = TRAINING_GAUNTLET_MAX_TIME_TO_PROGRESS
+
+	int difficulty = DIFFICULTY_EASY
+	//if ( time <= REC_DIFF_GAUNTLET_TIME_MASTER )
+	//	difficulty = DIFFICULTY_MASTER
+	// else if
+	if ( time <= REC_DIFF_GAUNTLET_TIME_HARD )
+		difficulty = DIFFICULTY_HARD
+	else if ( time <= REC_DIFF_GAUNTLET_TIME_NORMAL )
+		difficulty = DIFFICULTY_NORMAL
+
+	printt( "GetDifficultyForGauntletTime: diff", difficulty, "for time", time )
+
+	file.trainingGauntletStats.recommendedDifficulty = difficulty
+
+	SetConVarInt( "sp_difficulty", difficulty )
+}
+
+void function Training_AnnounceDifficultyForGauntletTime( entity player, float displayTime = 5.0 )
+{
+	string hintAlias = "hint_diff_"
+	hintAlias += file.trainingGauntletStats.recommendedDifficulty.tostring()
+	DisplayOnscreenHint( player, hintAlias, displayTime )
+}
+
+
+// ======================================================
+// ========= GAUNTLET CHALLENGE (post 1st run) ==========
+// ======================================================
+void function Training_Setup_GauntletChallenge( entity player )
+{
+	entity ogStart = GetEntByScriptName( "og_ref_gauntlet_results_display" )
+	entity og = Training_SpawnOGPilot( ogStart )
+	Training_OG_Idles( ogStart )
+
+	TeleportPlayerAndBT( "playerstart_gauntlet_challenge" )
+}
+
+void function Training_Skipped_GauntletChallenge( entity player )
+{
+}
+
+void function Training_GauntletChallenge( entity player )
+{
+	GauntletInfo gauntlet = GetTrainingGauntlet()
+
+	thread TrainingGauntlet_TeleportPlayerAtFinishLine( player )
+
+	entity ref_og_gauntletLeaderboardPos = GetEntByScriptName( "og_near_leaderboard" )
+
+	// in gauntlet mode OG spawns here before player fade finishes, no need to move him
+	if ( !file.gauntletMode )
+		waitthread Training_OG_Moves( ref_og_gauntletLeaderboardPos, "" )
+
+	Gauntlet_ShowLeaderboard( gauntlet )
+
+	thread GauntletChallenge_GhostsThink( player, gauntlet, "GauntletChallenge_FirstGhostAppear", "PlayerLeavingGauntlet" )
+	thread GauntletChallenge_IntroDialogue( player, gauntlet, ref_og_gauntletLeaderboardPos )
+	thread GauntletChallege_RestartGauntletHint( player, gauntlet )
+
+	FlagWait( "ChallengeIntro_VO_Done" )
+
+	bool installRuiStarted = false
+	if ( !Training_IsGameFullyInstalled() )
+		Remote_CallFunction_Replay( player, "ScriptCallback_ShowInstallProgress", true )
+
+	entity ref_og_gauntletExitPos = GetEntByScriptName( "og_gauntlet_exit_pos" )
+	thread Training_GauntletChallenge_DialogueThink( player, gauntlet, ref_og_gauntletExitPos )
+	thread Training_OG_Moves( ref_og_gauntletExitPos, "OG_all_done_idle" )
+
+	wait 1.0
+	thread Training_LeaveGauntletThink( player, ref_og_gauntletExitPos )
+
+	FlagWait( "PlayerConfirmedGauntletExit" )
+
+	Remote_CallFunction_Replay( player, "ScriptCallback_ShowInstallProgress", false )
+
+	Objective_SetSilent( "#TRAINING_OBJ_DEFAULT" )
+
+	DisableGauntlet( gauntlet )
+
+	FlagWait( "PlayerLeavingGauntlet" )
+
+	Signal( player, "Gauntlet_StopTeleportingPlayerAtFinishLine" )
+
+	if ( file.gauntletMode )
+	{
+		thread Training_PodOutro( player )
+		WaitForever()  // stall normal progression
+	}
+	else
+	{
+		thread DisableWeaponDelayed( player, 0.3 )  // disable weapon so crosshairs aren't visible during white screen
+
+		entity destEnt = GetEntByScriptName( "startpoint_titanfall" )
+		waitthread PlayerAndOGTeleport_Fancy( player, destEnt.GetOrigin(), "og_titanfall_start_pos", destEnt.GetAngles() )
+
+		CheckPoint_Silent()
+	}
+}
+
+void function DisableWeaponDelayed( entity player, float delay )
+{
+	EndSignal( player, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	player.DisableWeapon()
+}
+
+void function GauntletChallege_RestartGauntletHint( entity player, GauntletInfo gauntlet )
+{
+	EndSignal( player, "OnDestroy" )
+
+	float displayTime = 5.0
+	float delayTime = 2.5
+
+	const int RUNS_BETWEEN_REMINDERS = 3
+	int runsSinceLastReminder = 3  // do reminder on first run
+
+	while ( 1 )
+	{
+		if ( !gauntlet.isActive )
+			WaitSignal( player, "Gauntlet_RunStarted" )
+
+		float displayEndTime = -1
+
+		// check if we should remind after run starts
+		if ( runsSinceLastReminder >= RUNS_BETWEEN_REMINDERS )
+		{
+			thread OnscreenHint_DisplayAfterDelay( player, "gauntlet_restart_hint", displayTime, delayTime )
+			displayEndTime = Time() + displayTime + delayTime
+		}
+
+		// wait for run to stop
+		table result = WaitSignal( player, "Gauntlet_RunStopped", "Gauntlet_ForceRestart" )
+		string signal = expect string( result.signal )
+
+		// clear initial hint if player cancelled the run before it would auto clear
+		if ( displayEndTime != -1 && Time() < displayEndTime )
+			ClearOnscreenHint( player )
+
+		// player went back through the starting gate?
+		if ( signal == "Gauntlet_RunStopped" && !gauntlet.runFinished )
+		{
+			// Don't care about how many runs between reminders here- if player does this it means they don't really get it yet
+			thread DisplayOnscreenHint( player, "gauntlet_restart_hint", displayTime )
+			runsSinceLastReminder = 0
+		}
+		// player used menu to restart?
+		else if ( signal == "Gauntlet_ForceRestart" )
+		{
+			runsSinceLastReminder = 0  // reset the counter when force restarted
+		}
+
+		if ( runsSinceLastReminder >= RUNS_BETWEEN_REMINDERS )
+			runsSinceLastReminder = 0
+		if ( gauntlet.runFinished )  // player restarted from menu or went back through the gate
+			runsSinceLastReminder++
+	}
+}
+
+void function GauntletChallenge_IntroDialogue( entity player, GauntletInfo gauntlet, entity ogRef )
+{
+	if ( file.gauntletMode )
+	{
+		thread GauntletChallengeModeOnly_IntroDialogue( player, gauntlet, ogRef )
+		return
+	}
+
+	player.EndSignal( "OnDestroy" )
+
+	if ( !gauntlet.isActive )
+	{
+		// "Now that you're warmed up: if you want a REAL challenge, you can race against other Pilot ghosts."
+		waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_A" )
+	}
+
+	player.Signal( "GauntletChallenge_FirstGhostAppear" )
+
+	if ( !gauntlet.isActive )
+	{
+		// "Word of warning, though- the Pilots who recorded these ghosts are the best in the SRS.
+		waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_B" )
+	}
+
+	if ( !gauntlet.isActive )
+	{
+		// "If you can beat them, you'll be halfway to being a real Pilot."
+		waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_C" )
+	}
+
+	if ( !gauntlet.isActive )
+	{
+		// "Go ahead and run the Gauntlet as much as you want."
+		waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_D" )
+	}
+
+	// "When you're done, I've got something special to show you."
+	waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_E" )
+
+	if ( !Training_IsGameFullyInstalled() )
+	{
+		Objective_Set( "#TRAINING_OBJ_GAUNTLET_CHALLENGE_INSTALLING" )
+		thread ChangeGauntletObjective_OnInstallComplete( player )
+	}
+	else
+	{
+		Objective_Set( "#TRAINING_OBJ_GAUNTLET_CHALLENGE" )
+	}
+
+	FlagSet( "ChallengeIntro_VO_Done" )
+}
+
+void function GauntletChallengeModeOnly_IntroDialogue( entity player, GauntletInfo gauntlet, entity ogRef )
+{
+	player.EndSignal( "OnDestroy" )
+
+	SetSignalDelayed( player, "GauntletChallenge_FirstGhostAppear", 0.25 )
+
+	wait 1.5 // let player teleport and fade in before starting to talk
+
+	if ( !gauntlet.isActive )
+	{
+		// "Go ahead and run the Gauntlet as much as you want."
+		waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_D", true )
+	}
+
+	// "When you're done, I've got something special to show you."
+	//waitthread Training_OG_ScriptedAnim( ogRef, "OG_Leaderboard_E" )
+
+	Objective_Set( "#TRAINING_OBJ_GAUNTLET_CHALLENGE" )
+
+	FlagSet( "ChallengeIntro_VO_Done" )
+}
+
+void function ChangeGauntletObjective_OnInstallComplete( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	while ( !Training_IsGameFullyInstalled() )
+		wait 1.0
+
+	Objective_Set( "#TRAINING_OBJ_GAUNTLET_CHALLENGE" )
+}
+
+void function GauntletChallenge_GhostsThink( entity player, GauntletInfo gauntlet, string signalWait, string endFlag )
+{
+	if ( Flag( endFlag ) )
+		return
+
+	player.EndSignal( "OnDestroy" )
+	gauntlet.signalEnt.EndSignal( "OnDestroy" )
+
+	FlagEnd( endFlag )
+
+	if ( !gauntlet.isActive )
+		WaitSignal( player, "Gauntlet_RunStarted", signalWait )
+
+	thread Gauntlet_ChallengeLeaderboardGhosts( player, gauntlet, "PlayerLeavingGauntlet" )
+}
+
+void function Training_GauntletChallenge_DialogueThink( entity player, GauntletInfo gauntlet, entity ogSpot )
+{
+	player.EndSignal( "OnDestroy" )
+
+	FlagWait( "ChallengeIntro_VO_Done" )
+
+	DialogueGroup clearedLeaderboard = GetDialogueGroup( "clearedLeaderboard" )
+	DialogueGroup defeatedGhost = GetDialogueGroup( "defeatedGhost" )
+	DialogueGroup notBestTime = GetDialogueGroup( "notBestTime" )
+	DialogueGroup newBestTime = GetDialogueGroup( "newBestTime" )
+
+	while ( 1 )
+	{
+		FlagClear( "Gauntlet_PlayingFeedbackVO" )
+
+		WaitSignal( player, "Gauntlet_RunStopped" )
+
+		wait 0.1  // HACK let the gauntlet struct get updated before checking
+
+		TrainingGauntletStats_PostRunUpdate( player, gauntlet, 1 )
+
+		if ( !gauntlet.runFinished )
+			continue
+
+		TrainingGauntletPostRun_TryAchievements( player, gauntlet )
+
+		FlagSet( "Gauntlet_PlayingFeedbackVO" )
+
+		string feedbackLine = ""
+
+		// SPECIAL- defeated a Hero Ghost
+		if ( gauntlet.lastRunDefeatedGhost && !gauntlet.allGhostsDefeated )
+		{
+			array<GauntletGhost> leaderboard = Gauntlet_GetLeaderboard( gauntlet )
+			GauntletGhost playerGhost = Gauntlet_GetPlayerGhost( gauntlet )
+
+			array<string> heroFileNames = [ GHOST_NAME_ALIAS_LASTIMOSA, GHOST_NAME_ALIAS_ANDERSON, GHOST_NAME_ALIAS_BRIGGS ]
+
+			GauntletGhost loserGhost
+			foreach ( ghost in leaderboard )
+			{
+				if ( playerGhost.duration <= ghost.duration && heroFileNames.contains( ghost.fileName ) )
+				{
+					loserGhost = ghost
+					break
+				}
+			}
+
+			switch ( loserGhost.fileName )
+			{
+				case GHOST_NAME_ALIAS_LASTIMOSA:
+					// "Hey - that was my best time! I must be getting slow."
+					feedbackLine = "og_gauntlet_unlocked_leaderboard_entry_og"
+					break
+
+				case GHOST_NAME_ALIAS_ANDERSON:
+					// "Heh. Can't wait to tell Anderson about that. Son of a bitch..."
+					feedbackLine = "og_gauntlet_unlocked_leaderboard_entry_anderson"
+					break
+
+				case GHOST_NAME_ALIAS_BRIGGS:
+					// "You just beat Commander Briggs. Might not stay that way for long though, she's very competitive."
+					feedbackLine = "og_gauntlet_unlocked_leaderboard_entry_briggs"
+					break
+			}
+
+			if ( feedbackLine != "" )
+				waitthread Training_OG_Talks( feedbackLine, ogSpot, "OG_all_done_talk", "OG_all_done_idle", true )
+		}
+
+		// SPECIAL - cleared leaderboard
+		if ( gauntlet.allGhostsDefeated && !clearedLeaderboard.allPlayed )
+		{
+			while ( !clearedLeaderboard.allPlayed && !gauntlet.isActive )
+			{
+				feedbackLine = DialogueGroup_GetNextLine( clearedLeaderboard )
+				waitthread Training_OG_Talks( feedbackLine, ogSpot, "OG_all_done_talk", "OG_all_done_idle", true )
+			}
+		}
+
+		// If we played a line by now, it was Special, so we don't want the generic ones below.
+		if ( feedbackLine != "" )
+			continue
+
+		// LAST RUN: DEFEATED GHOST (GENERIC)
+		if ( gauntlet.lastRunDefeatedGhost && !gauntlet.allGhostsDefeated )
+		{
+			feedbackLine = DialogueGroup_GetNextLine( defeatedGhost )
+		}
+		// LAST RUN: BEAT BEST TIME
+		else if ( gauntlet.lastRunBestTime )
+		{
+			feedbackLine = DialogueGroup_GetNextLine( newBestTime )
+		}
+		// LAST RUN: FAILED TO BEAT BEST TIME
+		else
+		{
+			feedbackLine = DialogueGroup_GetNextLine( notBestTime )
+		}
+
+		Assert( feedbackLine != "" )
+		waitthread Training_OG_Talks( feedbackLine, ogSpot, "OG_all_done_talk", "OG_all_done_idle", true )
+	}
+}
+
+void function TrainingGauntletPostRun_TryAchievements( entity player, GauntletInfo gauntlet )
+{
+	Assert( gauntlet.runFinished )
+
+	GauntletGhost andersonGhost = Gauntlet_GetGhostByFileName( gauntlet, GHOST_NAME_ALIAS_ANDERSON )
+	if ( gauntlet.lastRunTime < andersonGhost.duration )
+	{
+		// Achievement - Beat Pilot Anderson's gauntlet ghost recorder time
+		UnlockAchievement( player, achievements.GAUNTLET_BEAT_ANDERSON )
+	}
+
+	GauntletGhost playerGhost = Gauntlet_GetPlayerGhost( gauntlet )
+	int playerLeaderboardPos = Gauntlet_GetLeaderboardPosition_ForGhostID( gauntlet, playerGhost.id )
+	if ( playerLeaderboardPos <= 2 )
+	{
+		// Achievement - Get a top-3 spot on the Gauntlet scoreboard
+		UnlockAchievement( player, achievements.GAUNTLET_TOPTHREE )
+	}
+}
+
+void function Training_LeaveGauntletThink( entity player, entity ogSpot )
+{
+	string gauntletExitConversation = "Gauntlet_Exit"
+	if ( file.gauntletMode )
+		gauntletExitConversation = "Gauntlet_Exit_TechTest"
+
+	GauntletInfo trainingGauntlet = GetTrainingGauntlet()
+
+	// NOTE conversation callbacks need this defined
+	file.animref_leaveGauntlet = ogSpot
+	AddConversationCallback( gauntletExitConversation, ConvoCallback_TrainingExit )
+	AddConversationCallback( "Titanfall_Intro", ConvoCallback_TitanfallIntro)
+
+	int numTimesInitiated = 0
+
+	while ( !Flag( "PlayerConfirmedGauntletExit" ) )
+	{
+		FlagWait( "Gauntlet_PlayerInExitZone" )
+
+		FlagWaitClear( "Gauntlet_PlayingFeedbackVO" )
+
+		if ( !Flag( "Gauntlet_PlayerInExitZone" ) )
+			continue
+
+		if ( !Training_IsGameFullyInstalled() )
+		{
+			waitthread Gauntlet_GameNotFullyInstalled_Response( player, ogSpot )
+			wait 0.1  // HACK make sure we always wait before continuing
+			continue
+		}
+
+		numTimesInitiated++
+
+		// All done with the gauntlet?
+		waitthread Training_OG_ScriptedAnim( ogSpot, "OG_all_done", true )
+		Training_OG_Idles( ogSpot, "OG_all_done_idle", true )
+
+		// if player rushed to the gauntlet during the anim, don't wait for conversation
+		if ( trainingGauntlet.isActive )
+			continue
+
+		// hint if player can't figure out how to conversate
+		bool displayedOnscreenHint = false
+		if ( numTimesInitiated > 1 && !Flag( "PlayerUsedConversationInterface" ) )
+		{
+			thread OnscreenHint_DisplayAfterDelay( player, "conversation_hint", 5.0, 1.5 )
+			displayedOnscreenHint = true
+		}
+
+		// interactive dialogue: Gauntlet Exit
+		FlagClear( "GauntletExitConvo_FinishedResponse" )
+		thread PlayerConversation( gauntletExitConversation, player, file.ogPilot )
+
+		table result = WaitSignal( player, "ConversationEnded", "PlayerMadeSelection", "Gauntlet_RunStarted" )
+		string sig = expect string( result.signal )
+
+		// bug 202299: Also check flag for player confirmed gauntlet exit
+		// - player can confirm exit, but if player starts a gauntlet run just before the response line ends, convo can "cancel" causing a prog break here
+		if ( sig == "Gauntlet_RunStarted" )
+		{
+			// HACK- wait a bit to make sure player didn't confirm exit before the conversation ended due to gauntlet run starting
+			wait 0.5
+
+			if ( !Flag( "PlayerConfirmedGauntletExit" ) )
+			{
+				StopConversationNow( player )
+				continue
+			}
+		}
+
+		/*
+		#if DEV
+		if ( sig == "Gauntlet_RunStarted" && Flag( "PlayerConfirmedGauntletExit" ) )
+			printt( "BUG CONDITION DEFEATED" )
+		#endif
+		*/
+
+		if ( sig == "PlayerMadeSelection" )
+			FlagSet( "PlayerUsedConversationInterface" )
+
+		if ( displayedOnscreenHint )
+			ClearOnscreenHint( player )
+
+		// wait for callback function to finish doing its thing
+		FlagWait( "GauntletExitConvo_FinishedResponse" )
+
+		if ( Flag( "PlayerConfirmedGauntletExit" ) )
+			break
+
+		FlagWaitClear( "Gauntlet_PlayerInExitZone" )
+
+		StopConversationNow( player )
+	}
+
+	if ( file.gauntletMode )
+	{
+		GauntletMode_Finished( player )
+	}
+	else
+	{
+		// interactive dialogue: Titanfall Intro
+		FlagClear( "TitanfallIntroConvo_FinishedResponse" )
+		waitthread PlayerConversation( "Titanfall_Intro", player, file.ogPilot )
+
+		FlagWait( "TitanfallIntroConvo_FinishedResponse" )
+	}
+
+	wait 0.2
+
+	FlagSet( "PlayerLeavingGauntlet" )
+}
+
+void function Gauntlet_GameNotFullyInstalled_Response( entity player, entity ogRef )
+{
+	EndSignal( player, "OnDestroy" )
+
+	float progress = GetGameFullyInstalledProgress()
+	printt( "Game is not fully installed- cannot continue past Gauntlet. Progress:", progress, "/ 1.0" )
+
+	DisplayOnscreenHint( player, "gauntlet_install_hint" )
+
+	OnThreadEnd(
+	function() : ( player )
+		{
+			if ( IsValid( player ) )
+				ClearOnscreenHint( player )
+		}
+	)
+
+	if ( TimerCheck( "installWaitComment" ) )
+	{
+		DialogueGroup installWait = GetDialogueGroup( "installWait" )
+		string line = DialogueGroup_GetNextLine( installWait )
+		waitthread Training_OG_Talks( line, ogRef, "OG_all_done_talk", "OG_all_done_idle", true )
+
+		TimerReset( "installWaitComment" )
+	}
+
+	while ( Flag( "Gauntlet_PlayerInExitZone" ) && !Training_IsGameFullyInstalled() )
+	{
+		wait 0.25
+	}
+}
+
+void function ConvoCallback_TrainingExit( int choice )
+{
+	EndSignal( file.player, "OnDestroy" )
+
+	OnThreadEnd(
+	function() : (  )
+		{
+			if ( IsValid( file.player ) )
+				FlagSet( "GauntletExitConvo_FinishedResponse" )
+		}
+	)
+
+	printt( "TRAINING EXIT CALLBACK: player chose", choice )
+	Assert( choice >= 0 && choice <= 2, "Nothing set up for Training Exit convo choice " + choice )
+
+	// prompt timed out
+	if ( choice == 0 )
+		return
+
+	Signal( file.player, "PlayerMadeSelection" )
+
+	// player chooses to stay
+	if ( choice == 2 )
+	{
+		waitthread Training_OG_ScriptedAnim( file.animref_leaveGauntlet, "OG_all_done_respond", true )
+		Training_OG_Idles( file.animref_leaveGauntlet, "OG_all_done_idle", true )
+		return
+	}
+
+	// player chooses to leave
+	FlagSet( "PlayerConfirmedGauntletExit" )
+	printt( "PLAYER CONFIRMED GAUNTLET EXIT" )
+
+	// Good. You're gonna like this.
+	 // It's time you learned the other half of being a Pilot: the Titan. Let's go call one in.
+	string anim = "OG_gonna_like_this"
+	if ( file.gauntletMode )
+	{
+		// Good. You're gonna like this.
+		// Let's get back to the real world.
+		anim = "OG_gonna_like_this_tech_test_end"
+	}
+
+	waitthread Training_OG_ScriptedAnim( file.animref_leaveGauntlet, anim, true )
+	Training_OG_Idles( file.animref_leaveGauntlet, "OG_gonna_like_this_endidle", true )
+}
+
+void function ConvoCallback_TitanfallIntro( int choice )
+{
+	EndSignal( file.player, "OnDestroy" )
+
+	OnThreadEnd(
+	function() : (  )
+		{
+			if ( IsValid( file.player ) )
+				FlagSet( "TitanfallIntroConvo_FinishedResponse" )
+		}
+	)
+
+	printt( "TITANFALL INTRO CALLBACK: player chose", choice )
+	Assert( choice >= 0 && choice <= 2, "Nothing set up for Titanfall Intro convo choice " + choice )
+
+	// It's only a simulation, Cooper. It's not the real thing.
+	// But first- We're gonna need a little more space
+	string responseAnim = "OG_gonna_like_this_respond_A"
+	if ( choice == 2 )
+	{
+		// That's the spirit.
+		// But first- We're gonna need a little more space
+		responseAnim = "OG_gonna_like_this_respond_B"
+	}
+
+	thread Training_OG_ScriptedAnim( file.animref_leaveGauntlet, responseAnim, true )
+	float duration = GetOGPilot().GetSequenceDuration( responseAnim )
+	wait duration - 1.0
+
+	//Training_OG_Idles( file.animref_leaveGauntlet, "OG_gonna_like_this_endidle", true )
+}
+
+
+// runType: 0 = before beating required time; 1 = in challenge mode
+void function TrainingGauntletStats_PostRunUpdate( entity player, GauntletInfo gauntlet, int runType )
+{
+	Assert( !gauntlet.isActive, "Can't update gauntlet stats reliably while gauntlet is active." )
+
+	// restarted gauntlet from menu
+	if ( !gauntlet.runFinished )
+	{
+		file.trainingGauntletStats.numRestarts++
+		printt( "training gauntlet stats updated: numRestarts", file.trainingGauntletStats.numRestarts )
+
+		SendTrainingGauntletStats( player )
+		return
+	}
+
+	if ( gauntlet.lastRunBestTime )
+	{
+		file.trainingGauntletStats.bestTime = gauntlet.bestTime
+		printt( "training gauntlet stats updated: bestTime", file.trainingGauntletStats.bestTime )
+	}
+
+	if ( runType == 0 )
+	{
+		file.trainingGauntletStats.numRunsBeforeBeatRequiredTime++
+		printt( "training gauntlet stats updated: numRunsBeforeBeatRequiredTime", file.trainingGauntletStats.numRunsBeforeBeatRequiredTime )
+
+		if ( gauntlet.bestTime > TRAINING_GAUNTLET_MAX_TIME_TO_PROGRESS )
+		{
+			// failed to get required time
+			SendTrainingGauntletStats( player )
+			return
+		}
+		else
+		{
+			file.trainingGauntletStats.didBeatRequiredTime = true
+			printt( "training gauntlet stats updated: didBeatRequiredTime", file.trainingGauntletStats.didBeatRequiredTime )
+		}
+	}
+	else if ( runType == 1 )
+	{
+		file.trainingGauntletStats.numChallengeRuns++
+		printt( "training gauntlet stats updated: numChallengeRuns", file.trainingGauntletStats.numChallengeRuns )
+	}
+
+	SendTrainingGauntletStats( player )
+}
+
+
+void function SendTrainingGauntletStats( entity player )
+{
+	printt("======== TRAINING GAUNTLET STATS =========" )
+	printt( "numRestarts:", 					file.trainingGauntletStats.numRestarts )
+	printt( "numRunsBeforeBeatRequiredTime:", 	file.trainingGauntletStats.numRunsBeforeBeatRequiredTime )
+	printt( "didBeatRequiredTime:", 			file.trainingGauntletStats.didBeatRequiredTime )
+	printt( "numChallengeRuns:", 				file.trainingGauntletStats.numChallengeRuns )
+	printt( "bestTime:", 						file.trainingGauntletStats.bestTime )
+	printt("========= END TRAINING GAUNTLET STATS ==========" )
+	SendTrainingGauntletStatsToBackend(
+			player,
+			file.trainingGauntletStats.didBeatRequiredTime ? file.trainingGauntletStats.numRunsBeforeBeatRequiredTime : 0,
+			file.trainingGauntletStats.numChallengeRuns,
+			file.trainingGauntletStats.bestTime
+			)
+}
+
+
+bool function Training_IsGameFullyInstalled()
+{
+	#if DEV
+	if ( INSTALL_DELAY_TEST )
+		return file.fakeInstallDone
+	#endif
+
+	return IsGameFullyInstalled()
+}
+
+#if DEV
+void function setfakeinstalldone( bool isDone )
+{
+	file.fakeInstallDone = isDone
+}
+#endif
+
+
+// ===================================
+// ============ TITANFALL ============
+// ===================================
+void function Training_Setup_Titanfall( entity player )
+{
+	entity ogRef_titanfall = GetEntByScriptName( "og_titanfall_start_pos" )
+	entity og = Training_SpawnOGPilot( ogRef_titanfall )
+	Training_OG_Idles_Sitting( ogRef_titanfall, "OG_first_titan_idle" )
+
+	player.DisableWeapon()  // player weapon is disabled before teleport to Titanfall area starts
+
+	TeleportPlayerAndBT( "startpoint_titanfall" )
+}
+
+void function Training_Skipped_Titanfall( entity player )
+{
+	player.SetExtraWeaponMods( ["training_low_ammo_disable"] )
+	SetWeaponHUDEnabled( player, false )
+}
+
+void function Training_Titanfall( entity player )
+{
+	thread Titanfall_EnableWeaponDelayed( player, 0.9 )
+
+	thread TakeAmmoFromPlayerASAP( player )
+	thread Titanfall_SpecialWeaponRemove( player )
+
+	entity og = GetOGPilot()
+	entity ogRef_titanfall = GetEntByScriptName( "og_titanfall_start_pos" )
+	Training_OG_Idles_Sitting( ogRef_titanfall, "OG_first_titan_idle" )
+
+	vector twinRefSpawnOrg = TitanfallGlitch_WorldChange_GetOtherWorldPos( ogRef_titanfall.GetOrigin(), true )
+	entity ogRef_titanfall_twin = CreateScriptMover( twinRefSpawnOrg, ogRef_titanfall.GetAngles() )
+	entity ogTwin = Training_SpawnOGTwin( ogRef_titanfall_twin )
+	Training_NPC_Idles_Sitting( ogTwin, ogRef_titanfall_twin, "OG_first_titan_idle" )
+
+	OnThreadEnd(
+	function() : ( player, ogTwin, ogRef_titanfall_twin )
+		{
+			if ( IsValid( player ) )
+				player.UnfreezeControlsOnServer()
+
+			if ( IsValid( ogTwin ) )
+				ogTwin.Destroy()
+
+			if ( IsValid( ogRef_titanfall_twin ) )
+				ogRef_titanfall_twin.Destroy()
+		}
+	)
+
+	//testglitch()
+	//wait 1000000
+
+	thread Titanfall_BT_Think( player, 6.5 )
+
+	wait 2.0
+
+	// "That's my partner, BT. He's a Vanguard-class."
+	// "Homegrown Militia technology."
+	// "The first Titan chassis we designed ourselves. One we didn't have to steal from the IMC."
+	waitthread Training_OG_ScriptedAnim( ogRef_titanfall, "OG_Partner_BT", true )
+	Training_OG_Idles_Sitting( ogRef_titanfall, "OG_first_titan_idle", true )
+
+	wait 1.1  // take a breath between lines
+
+	thread Training_EnableTitanfallAndNag( player, ogRef_titanfall, 25.0 )
+
+	// "Go ahead Rifleman, call in your first Titan."
+	Titanfall_ResetHintVOTimer()  // in case player calls in Titan during this line
+	waitthread Training_OG_ScriptedAnim( ogRef_titanfall, "OG_First_Titan", true )
+	Training_OG_Idles_Sitting( ogRef_titanfall, "OG_first_titan_idle", true )
+
+	FlagWait( "PlayerStartedTitanfall" )
+	// Don't start OG's next line until the nag is done, to avoid overlap
+	wait Titanfall_GetHintVORemainingDuration()
+
+	// "Look up, to the sky- there he is."
+	waitthread Training_OG_ScriptedAnim( ogRef_titanfall, "OG_Look_Up", true )
+	Training_OG_Idles_Sitting( ogRef_titanfall, "OG_first_titan_idle", true )
+
+	thread Titanfall_QuickdeathCustomResetPlayerPos( player, file.playerTitanCallInPos, "PodOutroStarted" )
+
+	// wait for titan to appear
+	while ( !GetPlayerTitanInMap( player ) )
+		wait 0.1
+
+	entity titan = GetPlayerTitanInMap( player )
+
+	// "glitch" interrupts titan drop
+	FlagWait( "TitanfallGlitchStart" )
+
+	PlayMusic( "music_training_01_glitch" )
+
+	// Glitch ends when this function ends
+	float totalGlitchTime = 2.9
+	float glitchEndTime = Time() + totalGlitchTime
+
+	wait 1.0
+	player.FreezeControlsOnServer()
+
+	thread Training_OG_ScriptedAnim( ogRef_titanfall, "OG_Pulling_You_Out", true )
+
+	wait glitchEndTime - Time()
+
+	if ( IsValid( titan ) )
+		titan.Destroy()
+
+	if ( IsValid( file.titanTwin ) )
+		file.titanTwin.Destroy()
+}
+
+void function Titanfall_EnableWeaponDelayed( entity player, float delay )
+{
+	EndSignal( player, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	player.EnableWeapon()
+	player.SetExtraWeaponMods( ["training_low_ammo_disable"] )
+	SetWeaponHUDEnabled( player, false )
+}
+
+void function Titanfall_SpecialWeaponRemove( entity player )
+{
+	array<entity> weapons = player.GetMainWeapons()
+	int numWeaponsStart = weapons.len()
+
+	foreach ( equippedWeapon in weapons )
+	{
+		string equippedWeaponClassName = equippedWeapon.GetWeaponClassName()
+		if ( equippedWeaponClassName == "mp_weapon_lstar" )  // LSTAR display blinks annoyingly if ammo is gone
+		{
+			// give player a weapon if we are going to take their only weapon
+			if ( numWeaponsStart <= 1 )
+				player.GiveWeapon( "mp_weapon_semipistol" )
+
+			player.TakeWeapon( equippedWeaponClassName )
+
+			break
+		}
+	}
+}
+
+void function Titanfall_BT_Think( entity player, float getUpDelay = 0.0 )
+{
+	EndSignal( player, "OnDestroy" )
+
+	entity spawnRef = GetEntByScriptName( "titanfall_bt_spawn_ref" )
+	vector spawnOrg = spawnRef.GetOrigin()
+	vector spawnAng = spawnRef.GetAngles()
+
+	// create BT
+	TitanLoadoutDef loadout = GetTitanLoadoutForPlayer( player )
+	entity bt = CreateNPCTitan( loadout.setFile, player.GetTeam(), spawnOrg, spawnAng, loadout.setFileMods )
+	bt.ai.titanSpawnLoadout = loadout
+	bt.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID
+	DispatchSpawn( bt )
+
+	entity animref = CreateScriptMover( spawnOrg, spawnAng )
+
+	OnThreadEnd(
+	function() : ( bt, animref )
+		{
+			if ( IsValid( bt ) )
+				bt.Destroy()
+
+			if ( IsValid( animref ) )
+				animref.Destroy()
+		}
+	)
+
+	bt.EnableNPCFlag( NPC_IGNORE_FRIENDLY_SOUND )
+	bt.SetEfficientMode( true )
+	bt.SetTouchTriggers( false )
+	bt.SetNoTarget( true )
+	bt.UnsetUsable()
+	bt.SetInvulnerable()
+	bt.EnableRenderAlways()
+
+	bt.SetTitle( "#NPC_BT_NAME" )
+	ShowName( bt )
+
+	DisableTitanfallForLifetimeOfEntityNearOrigin( bt, bt.GetOrigin(), TITANHOTDROP_DISABLE_ENEMY_TITANFALL_RADIUS )
+
+	// HACK this anim pops if it's played off of the animref,
+	//  but looks good if played off BT before using the animref for the rest
+	thread PlayAnim( bt, "bt_training_scripted_kneel_idle", bt )
+
+	if ( getUpDelay > 0 )
+		wait getUpDelay
+
+	waitthread PlayAnim( bt, "bt_training_scripted_kneel2stand", animref )
+	thread PlayAnim( bt, "bt_training_scripted_stand_idle", animref )
+
+	FlagWait( "PodOutroStarted" )
+}
+
+void function Titanfall_QuickdeathCustomResetPlayerPos( entity player, vector titanCallInPos, string endFlag )
+{
+	FlagEnd( endFlag )
+
+	entity resetEnt = GetEntByScriptName( "ref_titanfall_quickdeath_reset" )
+	vector resetPos = resetEnt.GetOrigin()
+
+	while ( 1 )
+	{
+		WaitSignal( player, "QuickDeath" )
+
+		vector angToCallInPos = VectorToAngles( titanCallInPos - resetPos )
+		float viewTiltUpAngX = -10.0  // goose the view up a little
+		vector viewAng = <viewTiltUpAngX, angToCallInPos.y, 0>
+
+		player.p.quickDeathOrigin = resetPos
+		player.p.quickDeathAngles = viewAng
+	}
+}
+
+void function Training_EnableTitanfallAndNag( entity player, entity ogRef, float nagDelay )
+{
+	EndSignal( player, "OnDestroy" )
+
+	SetGlobalNetBool( "trainingTitanfallEnabled", true )
+	AddClientCommandCallback( "ClientCommand_TrainingRequestedTitanfall", Training_RequestTitanfall )
+
+	float onscreenHintDisplayTime = nagDelay * 0.5
+	thread OnscreenHint_DisplayAfterDelay( player, "titanfall_hint", onscreenHintDisplayTime, 3.5 )  // extra delay on first screen prompt so pros can call it in
+
+	Objective_SetSilent( "#TRAINING_OBJ_CALL_TITAN" )
+
+	// "Titan's ready. Call it in."
+	// "Titan's ready to drop. On your mark."
+	array<string> titanfallNags = [ "og_titanfall_nag_1", "og_titanfall_nag_2" ]
+
+	DialogueGroup callInTitan = GetDialogueGroup( "callInTitan" )
+	while ( !Flag( "PlayerStartedTitanfall" ) )
+	{
+		FlagWaitWithTimeout( "PlayerStartedTitanfall", nagDelay )
+		if ( Flag( "PlayerStartedTitanfall" ) )
+			break
+
+		thread OnscreenHint_DisplayAfterDelay( player, "titanfall_hint", onscreenHintDisplayTime, 2.5 )
+
+		string line = DialogueGroup_GetNextLine( callInTitan )
+		Titanfall_ResetHintVOTimer()
+		waitthread Training_OG_Talks_Sitting( line, ogRef, "OG_first_titan_talk", "OG_first_titan_idle" )
+	}
+
+	Objective_SetSilent( "#TRAINING_OBJ_DEFAULT" )
+	ClearOnscreenHint( player )
+}
+
+
+// CUSTOM HOTDROP
+bool function Training_RequestTitanfall( entity player, array<string> args )
+{
+	Training_ReplacementTitan( player ) //Separate function because other functions will call ReplacementTitan
+	return true
+}
+
+bool function Training_ReplacementTitan( entity player )
+{
+	Assert( IsAlive( player ) )
+
+	Assert ( !GetPlayerTitanInMap( player ) )
+
+	Point spawnPoint = GetTitanReplacementPoint( player, false )
+	vector origin = spawnPoint.origin
+	vector angles = spawnPoint.angles
+
+	file.playerTitanCallInPos = origin
+
+	FlagSet( "PlayerStartedTitanfall" )
+	SetGlobalNetBool( "trainingTitanfallEnabled", false )
+
+	thread Training_CreateTitanForPlayerAndHotdrop( player, origin, angles )
+
+	return true
+}
+
+#if DEV
+void function testglitch()
+{
+	thread Training_CreateTitanForPlayerAndHotdrop( GetPlayerArray()[0], <2048, -2852, -349>, <0,0,0> )
+}
+#endif
+
+void function Training_CreateTitanForPlayerAndHotdrop( entity player, vector spawnOrg, vector spawnAng )
+{
+	Assert( IsValid( player ) )
+	OnThreadEnd(
+		function() : ( player )
+		{
+			if ( !IsValid( player ) )
+				return
+
+			player.ClearHotDropImpactTime()
+		}
+	)
+
+	player.EndSignal( "OnDestroy" )
+
+	vector origin = spawnOrg
+	vector angles
+	if ( spawnAng != < 0.0, 0.0, 0.0 > )
+		angles = spawnAng
+	else
+		angles = VectorToAngles( FlattenVector( player.GetViewVector() ) * -1 )	// face the player
+
+	printt( "Dropping replacement titan at " + origin + " with angles " + angles )
+
+	player.Signal( "CalledInReplacementTitan" )
+
+	int playerTeam = player.GetTeam()
+
+	// spawn the Titan that will drop
+	TitanLoadoutDef loadout = GetTitanLoadoutForPlayer( player )
+	entity titan = CreateAutoTitanForPlayer_FromTitanLoadout( player, loadout, origin, angles )
+	DispatchSpawn( titan )
+	titan.EndSignal( "OnDeath" )
+
+	titan.SetSkin( 2 )  // "Sarah Briggs" Vanguard skin
+	titan.SetTitle( "#NPC_BT_SPARE_NAME" )
+	HideName( titan )
+	TakeAllWeapons( titan )
+	titan.SetEfficientMode( true )
+	titan.SetTouchTriggers( false )
+	titan.SetNoTarget( true )
+	titan.UnsetUsable() // Disable titan embark
+
+	titan.Hide()
+
+	OnThreadEnd(
+		function() : ( titan )
+		{
+			if ( !IsValid( titan ) )
+				return
+
+			// removed so that model highlight always works for you autotitan
+			//	titan.DisableRenderAlways()
+		}
+	)
+
+	// based on "at_hotdrop_drop_2knee_turbo"
+	string animation = "bt_hotdrop_glitch_descent"
+	string postButtonPressSFX = "training_scr_titan_glitch_button_press"
+	string hotdropToGlitchSFX = "training_anim_glitch_scene"
+
+	EmitSoundOnEntity( player, postButtonPressSFX )
+
+	float hotDropAnimDuration = titan.GetSequenceDuration( animation )
+
+	float extraSpawnDelay = 1.5  // bit of extra padding time for "Look up, to the sky" VO to sink in
+	extraSpawnDelay += Titanfall_GetHintVORemainingDuration()
+
+	// Glitched hotdrop anim created by trimming the end from normal hotdrop anim (glitch starts just before the Titan hits the ground)
+	//  - add this little bit back so the timer looks "correct" (longer than actual anim duration)
+	float arrivalTimerDuration = 0.7
+	arrivalTimerDuration += (hotDropAnimDuration + extraSpawnDelay)  // now add the rest of the normal delays before arrival
+	thread Training_DrawReplacementTitanLocation( player, origin, arrivalTimerDuration )
+
+	wait extraSpawnDelay
+
+	titan.Show()
+	ShowName( titan )
+
+	Attachment result = titan.Anim_GetAttachmentAtTime( animation, "OFFSET", (hotDropAnimDuration - 0.1) )
+	vector maxs = titan.GetBoundingMaxs()
+	vector mins = titan.GetBoundingMins()
+	int mask = titan.GetPhysicsSolidMask()
+	origin = ModifyOriginForDrop( origin, mins, maxs, result.position, mask )
+
+	titan.SetInvulnerable() //Make Titan invulnerable until bubble shield is up. Cleared in OnTitanHotdropImpact
+	titan.EnableRenderAlways()
+
+	int teamNum = TEAM_UNASSIGNED
+	if ( IsValid( player ) )
+		teamNum = player.GetTeam()
+
+	vector fwdToPlayer = player.GetOrigin() - origin
+	vector facingAngles = VectorToAngles( fwdToPlayer )
+	vector facingAngles2D = <facingAngles.x, facingAngles.y, 0>
+	angles = facingAngles2D
+
+	//FadeOutSoundOnEntity( player, postButtonPressSFX, 1.0 )
+	EmitSoundOnEntity( player, hotdropToGlitchSFX )
+
+	thread PlayAnimTeleport( titan, animation, origin, angles )
+	wait hotDropAnimDuration - 0.1
+
+	titan.SetTouchTriggers( true )
+
+	thread TitanfallGlitch( player, titan, origin, angles )
+}
+
+void function Titanfall_ResetHintVOTimer()
+{
+	file.titanfallNagStartTime = Time()
+}
+
+float function Titanfall_GetHintVORemainingDuration()
+{
+	if ( file.titanfallNagStartTime == -1 )
+		return 0
+
+	float duration = TITANFALL_NAG_DURATION - (Time() - file.titanfallNagStartTime)
+	if ( duration < 0 )
+		duration = 0
+
+	return duration
+}
+
+bool function Titanfall_IsHintVOStillPlaying()
+{
+	 return Titanfall_GetHintVORemainingDuration() >= 0
+}
+
+void function TitanfallGlitch( entity player, entity titan, vector origin, vector angles )
+{
+	if ( Flag( "PodOutroStarted" ) )
+		return
+	FlagEnd( "PodOutroStarted" )
+
+	player.EndSignal( "OnDestroy" )
+	titan.EndSignal( "OnDestroy" )
+
+	titan.Signal( "glitch_start" )
+	FlagSet( "TitanfallGlitchStart" )
+
+	if ( IsValid( file.titanTwin ) )
+		file.titanTwin.Destroy()
+
+	entity titanTwin = CreatePropScript( BUDDY_MODEL, titan.GetOrigin(), titan.GetAngles() )
+	file.titanTwin = titanTwin
+	vector twinOrigin = TitanfallGlitch_WorldChange_GetOtherWorldPos( origin, true )
+
+	array<entity> sceneTitans = [ titan, titanTwin ]
+
+	// idle on last frame of descent anim
+	titanTwin.Anim_Stop()
+	titan.Anim_Stop()
+	string endIdleAnim = GetDefaultTitanfallGlitchAnim()
+	thread PlayAnimTeleport( titanTwin, endIdleAnim, twinOrigin, angles )
+	thread PlayAnimTeleport( titan, endIdleAnim, origin, angles )
+
+	// DEPRECATED no more glitchy anims
+	// do this on the hotdropping titan to blend out of the hotdrop better (but makes the proxy on the client out of sync)
+	// - in the future, need to play all the hotdrop anims on the proxy as well, to let it blend the same
+	//thread PlayAnim( titan, endIdleAnim, origin, angles, 0.1 )
+
+	// START GLITCH SEQUENCE
+
+	// setup for client extra flicker
+	titan.Hide()
+	titanTwin.Hide()
+	int eHandle_titan = titan.GetEncodedEHandle()
+	int eHandle_twin = titanTwin.GetEncodedEHandle()
+	Remote_CallFunction_Replay( player, "ScriptCallback_TitanfallGlitch_ExtraFlicker", eHandle_titan )
+	Remote_CallFunction_Replay( player, "ScriptCallback_TitanfallGlitch_ExtraFlicker", eHandle_twin, true )
+	SetGlobalNetBool( "titanGlitch_extraFlicker", true )  // makes him flicker until the world starts changing
+
+	// DEPRECATED Not doing the huge anim moves might work better for the glitch moment, trying it out
+	//thread TitanfallGlitch_CycleTitanGlitchAnims_OnWorldChange( player, titan, titanTwin, origin, twinOrigin, angles )
+
+	float screenFXTime = 4.5
+	float screenFXStartDelay = 0.1
+	thread StartGlitchScreenFX_Delayed( player, screenFXTime, screenFXStartDelay )
+
+	// FIRST IMPACT
+	float firstShakeDuration = 3.0
+
+	float shakeAmplitude = 14.0
+	float screenBlurFrac = 0.25
+	SimpleScreenShake( player, firstShakeDuration, shakeAmplitude, screenBlurFrac )
+
+	// juice it with extra rumble
+	// note- this is not juicing it as much as I would expect... even cranking the amplitude doesn't really work that well
+	float rumbleAmplitude = 50.0
+	float rumbleFrequency = 170
+	float rumbleDuration = 4.5
+	CreateShakeRumbleOnly( player.GetOrigin(), rumbleAmplitude, rumbleFrequency, rumbleDuration )
+
+	// let the titan idle for a moment
+	float postDescentIdleTime = 1.0
+	wait postDescentIdleTime
+
+	float firstShakeDuration_remaining = firstShakeDuration - postDescentIdleTime
+	// DEPRECATED trying without world changes
+	//thread TitanfallGlitch_PlayerWorldChange( player, firstShakeDuration_remaining * 0.9, 0.0 )
+
+	wait firstShakeDuration_remaining
+
+	/* DEPRECATED don't need smaller shakes now that the scene only lasts a short time
+	printt( "FIRST IMPACT DONE")
+
+	// LOOPING SMALLER IMPACTS
+	float shakeDuration_min = 2.5
+	float shakeDuration_max = 3.0
+	shakeAmplitude = 5.5
+	screenBlurFrac = 0.6
+	while ( 1 )
+	{
+		float shakeDuration = RandomFloatRange( shakeDuration_min, shakeDuration_max )
+
+		SimpleScreenShake( player, shakeDuration, shakeAmplitude, screenBlurFrac )
+		thread TitanfallGlitch_PlayerWorldChange( player, shakeDuration * 0.85, shakeDuration * 0.1 )
+
+		wait shakeDuration
+	}
+	*/
+}
+
+void function StartGlitchScreenFX_Delayed( entity player, float screenFXTime, float delay )
+{
+	if ( Flag( "PodOutroStarted" ) )
+		return
+	FlagEnd( "PodOutroStarted" )
+
+	EndSignal( player, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	Remote_CallFunction_Replay( player, "ScriptCallback_PodGlitch_PlayerScreenFX", screenFXTime )
+}
+
+const float GLITCH_WORLD_CHANGE_WAIT_MIN = 0.1
+const float GLITCH_WORLD_CHANGE_WAIT_MAX = 0.35
+const float GLITCH_WORLD_CHANGE_MINWAIT_FOR_EXTRA_FLICKER = 0.25
+
+void function TitanfallGlitch_CycleTitanGlitchAnims_OnWorldChange( entity player, entity mainTitan, entity titanTwin, vector origin, vector twinOrigin, vector angles, float delay = 0.0 )
+{
+	player.EndSignal( "OnDestroy" )
+	mainTitan.EndSignal( "OnDestroy" )
+	titanTwin.EndSignal( "OnDestroy" )
+
+	array<entity> sceneTitans = [ mainTitan, titanTwin ]
+
+	OnThreadEnd(
+	function() : ( player, sceneTitans )
+		{
+			if ( IsValid( player ) )
+			{
+				FlagClear( "PlayerWorldChangeThread" )
+				SetGlobalNetBool( "titanGlitch_extraFlicker", false )
+			}
+
+			foreach ( titan in sceneTitans )
+				if ( IsValid( titan ) )
+					titan.Show()
+		}
+	)
+
+	if ( delay > 0 )
+		wait delay
+
+	array<string> titanAnims = GetTitanfallGlitchAnims()
+	array<string> twinAnims = GetTitanfallGlitchTwinAnims()
+	Assert( titanAnims.len() == twinAnims.len() )
+	int animIdx = GetGlobalNetInt( "titanfallGlitchAnimIdx" )
+
+	while ( 1 )
+	{
+		table result = WaitSignal( player, "Glitch_WorldChanging_Zen", "Glitch_WorldChanging_NonZen" )
+		string signal = expect string( result.signal )
+
+		float worldChangeDuration = expect float( result.postChangeWait )
+
+		//printt( "titan anim:", titanAnims[animIdx] )
+
+		mainTitan.Anim_Stop()
+		titanTwin.Anim_Stop()
+		thread PlayAnimTeleport( mainTitan, titanAnims[animIdx], origin, angles )
+		thread PlayAnimTeleport( titanTwin, twinAnims[animIdx], twinOrigin, angles )
+
+		animIdx++
+		if ( animIdx >= titanAnims.len() )
+			animIdx = 0
+
+		SetGlobalNetInt( "titanfallGlitchAnimIdx", animIdx )
+
+		// update flicker settings & show/hide server versions of the titans
+		if ( signal == "Glitch_WorldChanging_Zen" )
+		{
+			// only do extra flicker if a longer world change pause is happening
+			if ( worldChangeDuration >= GLITCH_WORLD_CHANGE_MINWAIT_FOR_EXTRA_FLICKER )
+			{
+				SetGlobalNetBool( "titanGlitch_extraFlicker", true )
+
+				foreach ( titan in sceneTitans )
+					titan.Hide()
+			}
+		}
+		else if ( signal == "Glitch_WorldChanging_NonZen" )
+		{
+			SetGlobalNetBool( "titanGlitch_extraFlicker", false )
+
+			foreach ( titan in sceneTitans )
+				titan.Show()
+		}
+		else
+		{
+			Assert( false, "Couldn't find signal: " + signal )
+		}
+	}
+}
+
+
+void function TitanfallGlitch_PlayerWorldChange( entity player, float duration, float delay = 0.0 )
+{
+	if ( Flag( "PodOutroStarted" ) )
+		return
+	FlagEnd( "PodOutroStarted" )
+
+	EndSignal( player, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	FlagWaitClear( "PlayerWorldChangeThread" )
+	FlagSet( "PlayerWorldChangeThread" )
+
+	OnThreadEnd(
+	function() : ( player )
+		{
+			if ( IsValid( player ) )
+				FlagClear( "PlayerWorldChangeThread" )
+		}
+	)
+
+	bool isInZenWorld = true
+
+	float endTime = Time() + duration
+
+	float minWait = GLITCH_WORLD_CHANGE_WAIT_MIN
+	float maxWait = GLITCH_WORLD_CHANGE_WAIT_MAX
+
+	while ( 1 )
+	{
+		// at end time, make sure player pos resets back to zen world before breaking
+		if ( Time() >= endTime && isInZenWorld )
+			break
+
+		vector newpos = TitanfallGlitch_WorldChange_GetOtherWorldPos( player.GetOrigin(), isInZenWorld )
+
+		float postChangeWait
+		string changeSignal
+		entity newSkyCam
+
+		if ( isInZenWorld )
+		{
+			// Switch to non zen world
+			changeSignal = "Glitch_WorldChanging_NonZen"
+			postChangeWait = minWait // always wait min time in non zen world
+
+			newSkyCam = file.skycam_glitch
+			isInZenWorld = false
+		}
+		else
+		{
+			// Switch back to zen world
+			postChangeWait = RandomFloatRange( minWait, maxWait )
+			changeSignal = "Glitch_WorldChanging_Zen"
+
+			newSkyCam = file.skycam_default
+			isInZenWorld = true
+		}
+
+		table<string,float> extraInfo = {}
+		extraInfo["postChangeWait"] <- postChangeWait
+		Signal( player, changeSignal, extraInfo )
+
+		player.SetSkyCamera( newSkyCam )
+		player.SetOrigin( newpos )
+
+		wait postChangeWait
+	}
+}
+
+
+vector function TitanfallGlitch_WorldChange_GetOtherWorldPos( vector currentPos, bool startInZenWorld )
+{
+	entity zenEnt 		= GetEntByScriptName( "titan_glitch_swap_ref1" )
+	entity nonZenEnt 	= GetEntByScriptName( "titan_glitch_swap_ref2" )
+	Assert( zenEnt && nonZenEnt )
+	vector zenPos 		= zenEnt.GetOrigin()
+	vector nonZenPos 	= nonZenEnt.GetOrigin()
+
+	float offsetX
+	float offsetY
+	float offsetZ
+	float newPosX
+	float newPosY
+	float newPosZ
+
+	if ( startInZenWorld )
+	{
+		offsetX = currentPos.x - zenPos.x
+		offsetY = currentPos.y - zenPos.y
+		offsetZ = currentPos.z - zenPos.z
+
+		newPosX = nonZenPos.x + offsetX
+		newPosY = nonZenPos.y + offsetY
+		newPosZ = nonZenPos.z + offsetZ
+	}
+	else
+	{
+		offsetX = currentPos.x - nonZenPos.x
+		offsetY = currentPos.y - nonZenPos.y
+		offsetZ = currentPos.z - nonZenPos.z
+
+		newPosX = zenPos.x + offsetX
+		newPosY = zenPos.y + offsetY
+		newPosZ = zenPos.z + offsetZ
+	}
+
+	vector newPos = < newPosX, newPosY, newPosZ >
+	return newPos
+}
+
+
+void function Training_DrawReplacementTitanLocation( entity player, vector origin, float delay )
+{
+	float endTime = Time() + delay
+
+	player.SetHotDropImpactDelay( endTime )
+	Remote_CallFunction_Replay( player, "ServerCallback_ReplacementTitanSpawnpoint", origin.x, origin.y, origin.z, endTime )
+	player.WaitSignal( "OnDeath" )
+}
+
+
+// ===================================
+// ============ POD OUTRO ============
+// ===================================
+void function Training_Setup_PodOutro( entity player )
+{
+}
+
+void function Training_Skipped_PodOutro( entity player )
+{
+	Training_EnvArtColorCorrection_SetEnabled( false )
+	SetDoF_Hangar( player )
+
+	Objective_Clear()
+
+	FlagSet( "PodOutroStarted" )
+	FlagSet( "SimPodShutdown_LoudspeakerVO_Done" )
+}
+
+#if DEV
+// bare bones start in pod
+void function DEV_PodOutro( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	TakeAllWeapons( player )
+
+	player.SetExtraWeaponMods( [ "low_ammo_disable" ] )
+	SetWeaponHUDEnabled( player, false )
+
+	Training_EnvArtColorCorrection_SetEnabled( false )
+	SetDoF_Hangar( player )
+
+	thread MeetOG_BackgroundSkits( player )
+
+	entity pod = file.trainingPod
+
+	TrainingPod_PlayerSequence_DoorsOpenIdle( player, false )
+
+	// anim starts at a slightly different spot
+	player.SetOrigin( < 10564, -10235, -6056.9 > )
+	player.SetAngles( < -6, 90, 0 > )
+
+	WaitForever()
+}
+#endif //DEV
+
+void function Training_PodOutro( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	Objective_Clear()
+	CheckPoint_Silent()
+
+	entity pod = file.trainingPod
+
+	FlagSet( "PodOutroStarted" )
+
+	OnThreadEnd(
+		function() : ( player, pod )
+		{
+			if ( IsValid( player ) )
+			{
+				//StopSoundOnEntity( player, "NPE_Scr_SimPod_End" )
+
+				// Not sure if we need any of this
+				//player.Anim_Stop()
+				//ClearAnimViewEntity( player )
+				//player.ClearParent()
+				//player.UnforceStand()
+			}
+
+			if ( IsValid ( pod ) )
+			{
+				// Not sure if we need any of this
+				//pod.Anim_Stop()
+				//thread TrainingPod_ResetLaserEmitterRotation( pod )
+				//thread TrainingPod_KillLasers( pod )
+				//thread TrainingPod_KillGlowFX( pod )
+				//TrainingPod_KillInteriorDLights()
+			}
+		}
+	)
+
+	// Have to do this first so the anim starts centered on the ref attachment angles
+	string podAttach = "REF"
+	int attachID = pod.LookupAttachment( podAttach )
+	vector podRefOrg = pod.GetAttachmentOrigin( attachID )
+	vector podRefAng = pod.GetAttachmentAngles( attachID )
+	player.SetOrigin( podRefOrg )
+	player.SetAngles( podRefAng )
+
+	player.ForceStand()
+
+	TakeAllWeapons( player )
+
+	// start closed idle
+	FirstPersonSequenceStruct playerSequence
+	playerSequence.blendTime 			= 0.0
+	playerSequence.attachment 			= podAttach
+	playerSequence.firstPersonAnimIdle 	= "ptpov_trainingpod_idle"
+	playerSequence.thirdPersonAnimIdle 	= "pt_trainingpod_idle"
+	playerSequence.viewConeFunction 	= TrainingPod_ViewConeLock_Strict  // so player can't move camera under the pod shutdown screen
+	playerSequence.renderWithViewModels = true
+
+	FirstPersonSequenceStruct podSequence
+	podSequence.blendTime 				= 0.0
+	podSequence.thirdPersonAnimIdle 	= "trainingpod_doors_close_idle"
+	podSequence.renderWithViewModels 	= true
+
+	thread FirstPersonSequence( playerSequence, player, pod )
+	thread FirstPersonSequence( podSequence, pod )
+
+	thread CadillacMoment_MeetOG( player )
+
+	//thread PodOutro_ScreenShake( player )
+
+	Training_EnvArtColorCorrection_SetEnabled( false )
+	SetDoF_Hangar( player )
+
+	// show the "pod shutdown screen"
+	float shutdownScreenWait = 7.0
+	float screenFadeWait = 7.0
+	ScreenFade( player, 0, 0, 0, 255, 0, screenFadeWait, FFADE_OUT | FFADE_STAYOUT )
+	Remote_CallFunction_Replay( player, "ScriptCallback_SimPodShutdownScreen", shutdownScreenWait )
+
+	thread SimPodShutdown_Dialogue( player )
+
+	// HACK, need to wait a bit so player moves into pod before initing shutdown sequence
+	// - otherwise, interior emitter angle setup math vs player eye position will crash the game
+	float waitForPlayerToBeMoved = 1.0
+	wait waitForPlayerToBeMoved
+
+	float shutdownSequence_waitBeforeAnimStart = 10.0
+	thread TrainingPod_Interior_ShutdownSequence( player, shutdownSequence_waitBeforeAnimStart )
+
+	wait screenFadeWait - waitForPlayerToBeMoved
+
+	// HACK reparent the emitters so they look correct, I didn't expect to have to do this
+	TrainingPod_SnapLaserEmittersToAttachPoints()
+
+	// Transition screen FX
+	thread PlayFXOnEntity( FX_POD_SCREEN_OUT, player )
+
+	float fadeInFromShutdownScreenTime = 0.2
+	ScreenFade( player, 0, 0, 0, 255, fadeInFromShutdownScreenTime, 1, FFADE_IN | FFADE_PURGE )
+	wait fadeInFromShutdownScreenTime
+
+	TrainingPod_ViewConeLock_PodClosed( player )
+
+	// start shutdown sequence
+	// HACK- eventually one sound will cover the whole sequence
+	thread HACK_DelayedShutdownSequenceSFX( player, 3.0 )
+
+	player.Signal( "TrainingPod_BeginInteriorShutdown" )
+	wait shutdownSequence_waitBeforeAnimStart
+
+	FirstPersonSequenceStruct playerSequence_podOpens
+	playerSequence_podOpens.blendTime 			= 0.25
+	playerSequence_podOpens.attachment 			= podAttach
+	playerSequence_podOpens.firstPersonAnim 	= "ptpov_trainingpod_doors_open"
+	playerSequence_podOpens.firstPersonAnimIdle = "ptpov_trainingpod_idle"
+	playerSequence_podOpens.thirdPersonAnim 	= "pt_trainingpod_doors_open"
+	playerSequence_podOpens.thirdPersonAnimIdle = "pt_trainingpod_idle"
+	playerSequence_podOpens.viewConeFunction 	= TrainingPod_ViewConeLock_SemiStrict
+	playerSequence_podOpens.renderWithViewModels = true
+
+	FirstPersonSequenceStruct podSequence_podOpens
+	podSequence_podOpens.blendTime 				= 0.25
+	podSequence_podOpens.thirdPersonAnim 		= "trainingpod_doors_open"
+	podSequence_podOpens.thirdPersonAnimIdle 	= "trainingpod_doors_open_idle"
+	podSequence_podOpens.renderWithViewModels 	= true
+
+	thread TrainingPod_TurnOnInteriorDLights_Delayed( player, 1.5 )
+
+	thread FirstPersonSequence( podSequence_podOpens, pod )
+	thread FirstPersonSequence( playerSequence_podOpens, player, pod )
+
+	wait 2.1  // wait until scene starts animating for Meet OG
+}
+
+void function HACK_DelayedShutdownSequenceSFX( entity player, float delayTime )
+{
+	EndSignal( player, "OnDestroy" )
+
+	wait delayTime
+	EmitSoundOnEntityOnlyToPlayerWithSeek( player, player, "NPE_Scr_SimPod_End", 0.7 )
+}
+
+void function PodOutro_ScreenShake( entity player )
+{
+	if ( Flag( "MeetOG_StartScene" ) )
+		return
+	FlagEnd( "MeetOG_StartScene" )
+
+	player.EndSignal( "OnDestroy" )
+
+	float shakeDuration = 2.0
+	float shakeAmplitude = 0.2
+	float screenBlurFrac = 0.0
+	float shakeDelayMin = 1.75
+	float shakeDelayMax = 2.25
+	while ( 1 )
+	{
+		SimpleScreenShake( player, shakeDuration, shakeAmplitude, screenBlurFrac )
+		wait shakeDuration - (shakeDuration * 0.25)  // HACK shake dies down
+		wait RandomFloatRange( shakeDelayMin, shakeDelayMax )
+	}
+}
+
+void function SimPodShutdown_LoudspeakerVO( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	wait 4.0  // wait for "I'm pulling you out"
+
+	// "Powering down all non-essential systems."
+	waitthread PlayLoudspeakerVO( "outro_01_1" )
+
+	// "Prepare for Typhon atmospheric entry in less than three minutes."
+	//waitthread PlayLoudspeakerVO( "outro_01" )
+
+	wait 7.0
+
+	// "All personnel to battle stations."
+	waitthread PlayLoudspeakerVO( "outro_01_2" )
+
+	// "This is not a drill."
+	waitthread PlayLoudspeakerVO( "outro_01_3" )
+
+	FlagSet( "SimPodShutdown_LoudspeakerVO_Done" )
+}
+
+void function SimPodShutdown_Dialogue( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	thread SimPodShutdown_LoudspeakerVO( player )
+
+	Assert( IsValid( file.ogPilot ), "Can't find scene entity ogPilot" )
+
+	// "Alright Rifleman, sounds like it's about to hit the fan."
+	waitthread PlayDialogue( "og_hit_the_fan", file.ogPilot )
+
+	// "I'm pulling you out."
+	waitthread PlayDialogue( "og_pulling_you_out", file.ogPilot )
+
+	wait 2.0
+
+	// "Cooper! Ready up!"
+	waitthread PlayDialogue( "grunt_closed_pod_yell_at_player", file.ogPilot )  // HACK play it off OG until the animation idle is legit
+
+	// "Easy Cole, he just left VR. Needs a minute to decompress. He'll be ready to go... trust me."
+	waitthread PlayDialogue( "og_closed_pod_respond_to_grunt", file.ogPilot )
+
+	// "Yes sir."
+	waitthread PlayDialogue( "grunt_yes_sir", file.ogPilot )
+}
+
+#if DEV
+void function shutdownscreentest( float duration = 5.0 )
+{
+	entity player = file.player
+	EndSignal( player, "OnDestroy" )
+
+	float fadeTime = 0.2
+
+	ScreenFade( player, 0, 0, 0, 255, fadeTime, duration, FFADE_OUT | FFADE_STAYOUT )
+	Remote_CallFunction_Replay( player, "ScriptCallback_SimPodShutdownScreen", duration )
+	wait duration
+	ScreenFade( player, 0,0,0, 255, fadeTime, fadeTime, FFADE_IN | FFADE_PURGE )
+}
+#endif
+
+
+
+// =================================
+// ============ MEET OG ============
+// =================================
+void function Training_Setup_MeetOG( entity player )
+{
+	TakeAllWeapons( player )
+
+	thread CadillacMoment_MeetOG( player )
+	TrainingPod_PlayerSequence_DoorsOpenIdle( player )
+
+	wait 0.2
+}
+
+void function Training_Skipped_MeetOG( entity player )
+{
+	// settings for checkpoints after the normal level progression
+	SetDoF_Default( player )
+	player.SetExtraWeaponMods( [] )  // turn off low_ammo_disable
+	SetWeaponHUDEnabled( player, true )
+}
+
+void function Training_MeetOG( entity player )
+{
+	thread MeetOG_BackgroundSkits( player )
+
+	FlagSet( "MeetOG_StartScene" )
+
+	thread MeetOG_ControllerRumble( player )
+
+	FlagWait( "CadillacMoment_MeetOG_StartFadeOut" )
+
+	UnlockAchievement( player, achievements.COMPLETE_TRAINING )
+
+	// Free SP trial? Load Beacon next.
+	if( Script_IsRunningTrialVersion() )
+	{
+		thread FreeTrial_OutroPopup( player, 2.5 )
+		PickStartPoint( "sp_beacon", "Level Start" )
+	}
+	else
+	{
+		thread OutroDifficultyPopup( player, 2.5 )
+
+		// load next level
+		// NOTE this does a screen fade already
+		PickStartPoint( "sp_crashsite", "LevelStart" )
+	}
+
+	// don't ever progress from here to the dev functions beyond
+	WaitForever()
+}
+
+void function FreeTrial_OutroPopup( entity player, float delay )
+{
+	EndSignal( player, "OnDestroy" )
+	wait delay
+
+	Remote_CallFunction_UI( player, "ScriptCallback_Training_FreeTrialMessage" )
+}
+
+void function OutroDifficultyPopup( entity player, float delay )
+{
+	EndSignal( player, "OnDestroy" )
+	wait delay
+
+	Remote_CallFunction_UI( player, "ScriptCallback_Training_SelectSPDifficulty" )
+}
+
+// can't do screen shake for this part because it looks bad (not connected) when player view is 1P animating while parented to the pod
+void function MeetOG_ControllerRumble( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+	FlagEnd( "CadillacMoment_MeetOG_StartFadeOut" )
+
+	float shakeDuration = 2.8
+	float shakeAmplitudeMin = 13.5
+	float shakeAmplitudeMax = 14.5
+	float frequency = 155
+	float shakeDelayMin = 4.0
+	float shakeDelayMax = 7.0
+	while ( 1 )
+	{
+		float amplitude = RandomFloatRange( shakeAmplitudeMin, shakeAmplitudeMax )
+
+		//vector org, float amplitude = 16, float frequency = 150, float duration = 1.5, float radius = 2048
+		CreateAirShakeRumbleOnly( player.GetOrigin(), amplitude, frequency, shakeDuration )
+		printt( "Shake Rumble:", amplitude )
+		wait shakeDuration * 0.75  // HACK shake dies down pretty early
+
+		wait RandomFloatRange( shakeDelayMin, shakeDelayMax )
+	}
+}
+
+void function CadillacMoment_MeetOG( entity player )
+{
+	thread MeetOG_LoudspeakerVO( player )
+
+	int friendlyTeam = player.GetTeam()
+
+	entity animref = file.animref_hangar
+	vector animrefOrigin = animref.GetOrigin()
+	vector animrefAngles = animref.GetAngles()
+	vector btSpawnOrg = <0,0,0>  // to avoid red text errors about BT spawning in solid
+
+	entity animEnt = CreateScriptMover( animrefOrigin, animrefAngles )
+
+	// Spawn scene actors
+	entity og = Training_SpawnOGPilot( animref )
+	Training_OGPilot_SetHelmetOn( og, false )
+	SetTeam( og, TEAM_SPECTATOR )  // turn off his glowy bits so they're accentuated when helmet turns on later
+
+	entity anderson = CreateSoldier( friendlyTeam, animrefOrigin, animrefAngles )
+	DispatchSpawn( anderson )
+	anderson.SetModel( ANDERSON_PILOT_MODEL )
+	anderson.SetTitle( "#TRAINING_ANDERSON_NAME" )
+	//ShowName( anderson )
+	HideName( anderson )
+
+	entity redshirt = CreateSoldier( friendlyTeam, animrefOrigin, animrefAngles )
+	DispatchSpawn( redshirt )
+	redshirt.SetModel( TEAM_MIL_GRUNT_MODEL_LMG )
+	redshirt.SetTitle( "#CPT_COLE" )
+	//ShowName( redshirt )
+	HideName( redshirt )
+
+	TitanLoadoutDef loadout = GetTitanLoadoutForCurrentMap()
+	entity bt = CreateAutoTitanForPlayer_FromTitanLoadout( player, loadout, btSpawnOrg, animrefAngles )
+	SetSpawnOption_AISettings( bt, "npc_titan_buddy" )
+	bt.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID
+	DispatchSpawn( bt )
+	FreeAutoTitan( bt )  // HACK this disables the worldspace BT locator icon
+	TakeAllWeapons( bt )
+
+	array<entity> actors = [ player, bt, og, anderson, redshirt ]
+
+	// Setup scene props
+
+	entity ogHelmet = CreatePropDynamic( OG_PILOT_HELMET_MODEL )
+	ogHelmet.DisableHibernation()
+	file.ogHelmet = ogHelmet
+
+	string knifeTag = "KNIFE"
+	int knifeTagID = og.LookupAttachment( knifeTag )
+	entity dataKnife = CreatePropScript( DATA_KNIFE_MODEL, og.GetAttachmentOrigin( knifeTagID ), og.GetAttachmentAngles( knifeTagID ) )
+	dataKnife.DisableHibernation()
+  	dataKnife.SetParent( og, knifeTag, false, 0.0 )
+
+	asset btWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( "mp_titanweapon_xo16_shorty", "playermodel" )
+	Assert( btWeaponModel != $"" )
+	entity btWeapon = CreatePropDynamic( btWeaponModel )
+	btWeapon.SetParent( bt, "PROPGUN" )
+
+	string gruntRifleName 		= "mp_weapon_rspn101"
+	string andersonWeaponName 	= "mp_weapon_car"
+	asset gruntRifleModel = GetWeaponInfoFileKeyFieldAsset_Global( gruntRifleName, "playermodel" )
+	asset andersonWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( andersonWeaponName, "playermodel" )
+	asset ogWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( OG_WEAPON, "playermodel" )
+	Assert( gruntRifleModel != $"" )
+	Assert( andersonWeaponModel != $"" )
+	Assert( ogWeaponModel != $"" )
+
+	entity ogWeapon = CreatePropDynamic( ogWeaponModel )
+	ogWeapon.DisableHibernation()
+	ogWeapon.SetParent( og, "PROPGUN" )
+
+	entity andersonWeapon = CreatePropDynamic( andersonWeaponModel )
+	andersonWeapon.DisableHibernation()
+	andersonWeapon.SetParent( anderson, "PROPGUN" )
+
+	entity redshirtWeapon = CreatePropDynamic( gruntRifleModel )
+	redshirtWeapon.DisableHibernation()
+	redshirtWeapon.SetParent( redshirt, "PROPGUN" )
+
+	array<entity> props = [ btWeapon, redshirtWeapon, andersonWeapon, ogWeapon, ogHelmet, dataKnife ]
+
+	OnThreadEnd(
+	function() : ( actors, props, animEnt )
+		{
+			foreach ( weapon in props )
+			{
+				if ( IsValid( weapon ) )
+				{
+					weapon.ClearParent()
+					weapon.Destroy()
+				}
+			}
+
+			foreach ( actor in actors )
+			{
+				if ( IsValid( actor ) )
+					actor.ClearParent()
+
+				if ( IsInvincible( actor ) )
+					ClearInvincible( actor )
+
+				if ( !actor.IsPlayer() )
+					actor.Destroy()
+			}
+
+			if ( IsValid( animEnt ) )
+				animEnt.Destroy()
+		}
+	)
+
+	foreach ( guy in actors )
+	{
+		if ( guy.IsPlayer() )
+			continue
+
+		MakeInvincible( guy )
+		guy.SetEfficientMode( true )
+		Highlight_ClearFriendlyHighlight( guy )
+	}
+
+	string anim_og 				= "pt_intro_scene_OG"
+	string anim_og_helmet 		= "helmet_intro_scene_OG"
+	string anim_bt 				= "BT_intro_scene_OG"
+	string anim_anderson 		= "pt_intro_scene_Anderson"
+	string anim_redshirt 		= "pt_intro_scene_grunt"
+
+	string anim_og_idle 		= "pt_intro_scene_OG_idle"
+	string anim_og_helmet_idle 	= "helmet_intro_scene_OG_idle"
+	string anim_bt_idle 		= "BT_intro_scene_OG_idle"
+	string anim_anderson_idle 	= "pt_intro_scene_Anderson_idle"
+	string anim_redshirt_idle 	= "pt_intro_scene_grunt_idle"
+
+	thread PlayAnimTeleport( og, anim_og_idle, animEnt )
+	thread PlayAnimTeleport( ogHelmet, anim_og_helmet_idle, animEnt )
+	thread PlayAnimTeleport( bt, anim_bt_idle, animEnt )
+	thread PlayAnimTeleport( anderson, anim_anderson_idle, animEnt )
+	thread PlayAnimTeleport( redshirt, anim_redshirt_idle, animEnt )
+
+	FlagWait( "MeetOG_StartScene" )
+	printt( "STARTING ANIMS: MEET OG" )
+
+	foreach ( guy in actors )
+		guy.Anim_Stop()
+
+	AddAnimEvent( og, "helmet_on", AnimEventCallback_MeetOG_HelmetTurnsOn )
+
+	thread PlayAnimTeleport( og, anim_og, animEnt )
+	thread PlayAnimTeleport( ogHelmet, anim_og_helmet, animEnt )
+	thread PlayAnimTeleport( bt, anim_bt, animEnt )
+	thread PlayAnimTeleport( anderson, anim_anderson, animEnt )
+	thread PlayAnimTeleport( redshirt, anim_redshirt, animEnt )
+
+	player.Anim_Stop()
+
+	// give player weapon for the toss moment
+	entity fpProxy = player.GetFirstPersonProxy()
+	int attachID = fpProxy.LookupAttachment( "PROPGUN" )
+	asset playerWeaponModel = GetWeaponInfoFileKeyFieldAsset_Global( "mp_weapon_vinson", "playermodel" )
+	entity playerWeapon = CreatePropDynamic( playerWeaponModel, fpProxy.GetAttachmentOrigin( attachID ), fpProxy.GetAttachmentAngles( attachID ) )
+	file.playerAnimWeapon = playerWeapon
+	playerWeapon.DisableHibernation()
+	playerWeapon.SetParent( fpProxy, "PROPGUN", false, 0.0 )
+
+	AddAnimEvent( player, "gun_catch", AnimEventCallback_MeetOG_PlayerCatchesWeapon )
+
+	FirstPersonSequenceStruct playerSequence_meetOG
+
+	float viewAnimDelay = 4.0
+	//playerSequence_meetOG.setInitialTime 		= viewAnimDelay  // DEPRECATED animators will adjust so start position is good again}
+	playerSequence_meetOG.blendTime 			= 0.0
+	playerSequence_meetOG.teleport 				= false
+	playerSequence_meetOG.attachment 			= "REF"
+	playerSequence_meetOG.firstPersonAnim 		= "pov_intro_scene_player"
+	playerSequence_meetOG.thirdPersonAnim 		= "pt_intro_scene_player"
+	playerSequence_meetOG.viewConeFunction 		= TrainingPod_ViewConeLock_SemiStrict
+	playerSequence_meetOG.renderWithViewModels 	= true
+
+	// HACK delay sequence so it transitions better from previous anim
+	TrainingPod_ViewConeLock_SemiStrict( player )  // set this to cover any time between viewmodel anims
+	thread FirstPersonSequence_Delayed( viewAnimDelay, playerSequence_meetOG, player, animEnt )
+	//thread FirstPersonSequence( playerSequence_meetOG, player, animEnt )
+
+	// gradual DOF racking during the scene
+	RackDoF_NearDepth( player, 0, 22, 12.0 )
+	RackDoF_FarDepth( player, 350, 950, 20.0 )
+
+	// find longest anim duration
+	array<string> sceneAnims = [ anim_og, anim_bt, anim_anderson, anim_redshirt ]//, "pt_intro_scene_player" ]
+	float sceneDuration = -1
+	foreach ( anim in sceneAnims )
+	{
+		entity animActor = og
+		if ( anim.find( "BT_") != null )
+			animActor = bt
+		else if ( anim.find( "_player") != null )
+			animActor = player
+
+		float duration = animActor.GetSequenceDuration( anim )
+		if ( duration > sceneDuration )
+			sceneDuration = duration
+	}
+	Assert( sceneDuration > 0 )
+
+	float fadeTime = SP_LEVEL_TRANSITION_FADETIME
+
+	wait sceneDuration - fadeTime
+	FlagSet( "CadillacMoment_MeetOG_StartFadeOut" )
+
+	wait fadeTime
+	FlagSet( "CadillacMoment_MeetOG_Done" )
+}
+
+void function FirstPersonSequence_Delayed( float delay, FirstPersonSequenceStruct sequence, entity player, entity animEnt )
+{
+	EndSignal( player, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	thread FirstPersonSequence( sequence, player, animEnt )
+}
+
+void function MeetOG_LoudspeakerVO( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+	FlagWait( "SimPodShutdown_LoudspeakerVO_Done" )
+
+	array<string> aliases
+	// "Incoming hostile ship - Designation: IMS Malta. Battle stations."
+	aliases.append( "outro_08" )
+	// "Caution - Fuel leak in Cargo Bay eighty - five. Activating airlock procedures."
+	aliases.append( "outro_12" )
+	// "Titan bays two through five, drop clearance confirmed."
+	aliases.append( "outro_03" )
+	// "All available medical personnel, report to Med Central for tasking."
+	aliases.append( "outro_05" )
+	// "We need all Riflemen to docking bay four. Dropships standing by."
+	aliases.append( "outro_07" )
+	// "Infantry teams Stork three, Elk four, Shark six, Badger one, prepare for emergency atmospheric drop sequence"
+	aliases.append( "outro_04" )
+	// "Titan mech team - Rabbit six, prep the Vanguards."
+	aliases.append( "outro_06" )
+	// "Infantry teams 2nd Militia Fusiliers, Raptor three, target the IMS Malta."
+	aliases.append( "outro_11" )
+	// "Special Recon Squad deploy from Drop Bay thirty-seven - now."
+	aliases.append( "outro_10" )
+
+	thread LoopLoudspeakerVO( aliases )
+}
+
+void function AnimEventCallback_MeetOG_PlayerCatchesWeapon( entity player )
+{
+	Assert( IsValid( file.playerAnimWeapon ) )
+	file.playerAnimWeapon.RenderWithViewModels( true )
+
+	thread MeetOG_PlayerCatchesWeapon_RackNearDOF( player )
+}
+
+void function MeetOG_PlayerCatchesWeapon_RackNearDOF( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	wait 0.7
+
+	RackDOF_NearDepth_ToDefault( player, 1.5 )
+
+	wait 2.0
+
+	RackDoF_NearDepth( player, 0, 22, 1.25 )
+}
+
+
+// ------ OG HELMET TURNING ON ------
+void function AnimEventCallback_MeetOG_HelmetTurnsOn( entity og )
+{
+	thread MeetOG_HelmetTurnsOn( og )
+}
+
+// script MeetOG_HelmetTurnsOn( GetOGPilot() )
+void function MeetOG_HelmetTurnsOn( entity og )
+{
+	entity og 		= file.ogPilot
+	entity ogHelmet = file.ogHelmet
+	EndSignal( og, "OnDestroy" )
+	EndSignal( ogHelmet, "OnDestroy" )
+
+	// setting his team to friendly makes the helmet light up
+	if ( og.GetTeam() == TEAM_MILITIA )
+		SetTeam( og, TEAM_SPECTATOR )
+
+	ogHelmet.Hide()
+	Training_OGPilot_SetHelmetOn( og, true )
+	wait 0.2
+
+	SetTeam( og, TEAM_MILITIA )
+	wait 0.1
+	SetTeam( og, TEAM_SPECTATOR )
+	wait 0.4
+	SetTeam( og, TEAM_MILITIA )
+	wait 0.1
+	SetTeam( og, TEAM_SPECTATOR )
+	wait 0.1
+	SetTeam( og, TEAM_MILITIA )
+}
+
+#if DEV
+void function MeetOG_HelmetTurnsOff( entity og )
+{
+	entity og 		= file.ogPilot
+	entity ogHelmet = file.ogHelmet
+
+	if ( og.GetTeam() == TEAM_SPECTATOR )
+		SetTeam( og, TEAM_MILITIA )
+
+	ogHelmet.Show()
+	Training_OGPilot_SetHelmetOn( og, false )
+}
+#endif
+
+
+// ------ POD OUTRO BACKGROUND SKITS ------
+void function MeetOG_BackgroundSkits( entity player, float delay = 0.0 )
+{
+	string endFlag = "CadillacMoment_MeetOG_Done"
+	FlagEnd( endFlag )
+
+	if ( delay > 0 )
+		wait delay
+
+	printt( "!!!! Pod Outro Background Skits START !!!!" )
+
+	thread PodOutro_TitanRacks( endFlag )
+
+	thread PodOutro_Background_Runners( player )
+	thread PodOutro_Foreground_Runners( player )
+
+	thread PodOutro_Background_ATC_Marvins()
+
+	OnThreadEnd(
+	function() : ()
+		{
+			DeleteAllSkitGuys()
+		}
+	)
+
+	WaitForever()
+}
+
+void function PodOutro_TitanRacks( string endFlag )
+{
+	FlagEnd( endFlag )
+
+	array<HangarTitanGroup> hangarTitanGroups
+
+	OnThreadEnd(
+	function() : ( hangarTitanGroups )
+		{
+			foreach ( group in hangarTitanGroups )
+				HangarTitanGroup_Cleanup( group )
+		}
+	)
+
+	float wait_earlyEnd 	= 24.0
+	bool cleanupAfterAnim 	= false
+
+	// ---  BAY 1 ---
+	HangarTitanGroup bay1
+	entity rack_bay1 	= GetEntByScriptName( "hangar_titan_rack_1" )
+	bay1.ref 			= rack_bay1
+	bay1.rack 	 		= rack_bay1
+	bay1.titan 			= GetEntByScriptName( "hangar_titan_1" )
+	bay1.titanAnim 		= "bt_rack_prep_titan2"
+	bay1.rackAnim 		= "rack_rack_prep_rack2"
+	bay1.marvinAnim 	= "mv_rack_prep_marvin2"
+	bay1.pilotAnim 		= "pt_rack_prep_pilot2"
+	bay1.pilotModel 	= PILOT_MODEL_BAY1
+	HangarTitanGroup_Init( bay1 )
+	hangarTitanGroups.append( bay1 )
+	thread HangarTitanGroup_Animate( bay1, endFlag, -1, cleanupAfterAnim )
+
+
+	// ---  BAY 2 ---
+	//thread PodOutro_TitanBoot( endFlag, 15.0 )
+
+	HangarTitanGroup bay2
+	entity rack_bay2 		= GetEntByScriptName( "hangar_titan_rack_2" )
+	bay2.ref 				= rack_bay2
+	bay2.rack 	 			= rack_bay2
+	bay2.titan 				= GetEntByScriptName( "hangar_titan_2" )
+	bay2.titanAnim 			= "bt_rack_prep_titan1"
+	bay2.rackAnim 			= "rack_rack_prep_rack1"
+	bay2.marvinAnim 		= "mv_rack_prep_marvin1"
+	bay2.pilotAnim 			= "pt_rack_prep_pilot1"
+	bay2.pilotModel 		= PILOT_MODEL_BAY2
+	HangarTitanGroup_Init( bay2 )
+	hangarTitanGroups.append( bay2 )
+	waitthread HangarTitanGroup_Animate( bay2, endFlag, -1, cleanupAfterAnim )
+}
+
+void function PodOutro_TitanBoot( string endFlag, float delay )
+{
+	FlagEnd( endFlag )
+
+	entity refTitan = GetEntByScriptName( "hangar_titan_2" )
+	refTitan.Hide()
+
+	vector refOrg = refTitan.GetOrigin()
+	vector refAng = refTitan.GetAngles()
+	refOrg += < -20, 40, 0> // HACK
+	refOrg = OriginToGround( refOrg )
+
+	entity animref = CreateScriptRef( refOrg, refAng )
+
+	entity titan = CreatePropScript( BUDDY_MODEL, refOrg, refAng )
+	titan.DisableHibernation()
+
+	AddAnimEvent( titan, "hatch_closed", TitanBoot_HatchClosed )
+	entity cockpitLightFX = PlayFXOnEntity( FX_COCKPIT_LIGHT, titan, "HIJACK" )
+
+	SkitGuyInfo titanInfo = AddSkitGuy_Manually( "bootup_titan", titan )
+
+	SkitGuyInfo titanPilotInfo = SpawnSkitGuy( "bootup_pilot", "", animref.GetOrigin(), animref.GetAngles(), TEAM_MILITIA, "npc_soldier" )
+	entity titanPilot = titanPilotInfo.guy
+	titanPilot.SetParent( titan, "HIJACK", false, 0.0 )
+	titanPilot.MarkAsNonMovingAttachment()
+
+	SkitGuyInfo crewInfo = SpawnSkitGuy( "bootup_crew", "", animref.GetOrigin(), animref.GetAngles(), TEAM_MILITIA, "npc_soldier_bish" )
+	entity crew = crewInfo.guy
+
+	OnThreadEnd(
+		function() : ( titanPilotInfo, crewInfo, titanInfo, cockpitLightFX, animref, refTitan )
+		{
+			if ( IsValid_ThisFrame( cockpitLightFX ) )
+			{
+				EntFireByHandle( cockpitLightFX, "Stop", "", 0, null, null )
+				cockpitLightFX.ClearParent()
+				cockpitLightFX.Destroy()
+			}
+
+			if ( IsAlive( titanInfo.guy ) )
+				StopSoundOnEntity( titanInfo.guy, "Wargames_MCOR_TitanActivate" )
+
+			if ( IsValid( animref ) )
+				animref.Destroy()
+
+			DeleteSkitGuy( titanPilotInfo )
+			DeleteSkitGuy( crewInfo )
+			DeleteSkitGuy( titanInfo )
+
+			if ( IsValid( refTitan ) )
+				refTitan.Show()
+		}
+	)
+
+	EmitSoundOnEntity( titan, "Wargames_MCOR_TitanActivate" )
+
+	string pilotAnim 		= "pt_titan_activation_pilot"
+	string pilotAnim_idle 	= "pt_titan_activation_pilot_idle"
+	string titanAnim 		= "at_titan_activation_training_meetOG"
+	string titanAnim_idle 	= "at_titan_activation_idle"
+	string titanAnim_endIdle = "at_titan_activation_training_meetOG_end_idle"
+	string crewAnim 		= "pt_titan_activation_crew"
+	string crewAnim_idle 	= "pt_titan_activation_crew_idle"
+
+	if ( delay > 0 )
+	{
+		thread PlayAnim( crew, crewAnim_idle, animref, null, 0.0 )
+		thread PlayAnim( titan, titanAnim_idle, animref, null, 0.0 )
+		titanPilot.Anim_ScriptedPlay( pilotAnim_idle )
+		titanPilot.Anim_EnableUseAnimatedRefAttachmentInsteadOfRootMotion()
+
+		wait delay
+
+		titanPilot.Anim_Stop()
+		crew.Anim_Stop()
+		titan.Anim_Stop()
+	}
+
+	titanPilot.Anim_ScriptedPlay( pilotAnim )
+	titanPilot.Anim_EnableUseAnimatedRefAttachmentInsteadOfRootMotion()
+	thread PlayAnim( crew, crewAnim, animref, null, DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME )
+	thread PlayAnim( titan, titanAnim, animref, null, DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME )
+
+	// end it early so he doesn't make stomping sounds when the pod is closed
+	//wait 15.0
+	float duration = titan.GetSequenceDuration( titanAnim )
+	wait duration - 0.1
+
+	printt( "Ending titan boot anim" )
+
+	thread PlayAnim( titan, titanAnim_endIdle, animref, null, DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME )
+	crew.Freeze()
+
+	WaitForever()
+}
+
+void function TitanBoot_HatchClosed( entity titan )
+{
+	SkitGuyInfo info = GetSkitGuyInfo_ByName( "bootup_pilot" )
+	DeleteSkitGuy( info )
+}
+
+void function PodOutro_Background_Runners( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	// right to left, across the whole hangar
+	array<Point> path1 = []
+	ScriptedPath_AddPoint( path1, < 11080.5, -10017.2, -6079.97 >, < 0, 177.587, 0 > )
+	ScriptedPath_AddPoint( path1, < 9619.14, -10004.8, -6079.97 >, < 0, 183.021, 0 > )
+
+	// right to left, starts closer to player POV
+	array<Point> path2 = []
+	ScriptedPath_AddPoint( path2, < 11000, -9946.33, -6079.97 >, < 0, 177.587, 0 > )
+	ScriptedPath_AddPoint( path2, < 9619.14, -10004.8, -6079.97 >, < 0, 183.021, 0 > )
+
+	wait 2.0  // wait for OG's first line to be nearly over
+
+	printt( "BACKGROUND RUNNER GROUP 1" )
+
+	thread SpawnSkitGuy_AndRun( "runner_1_1", path2, 0.85, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_hemlok_smg" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_1_2", path2, 0.85, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+
+	wait 6.5  // wait until OG hands the eye to BT
+
+	printt( "BACKGROUND RUNNER GROUP 2" )
+
+	thread SpawnSkitGuy_AndRun( "runner_2_1", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_2_2", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+
+	wait 4.5  // wait until OG is shaking Anderson's hand
+
+	printt( "BACKGROUND RUNNER GROUP 3" )
+
+	thread SpawnSkitGuy_AndRun( "runner_3_1", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_3_2", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_3_3", path2, 0.8, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_hemlok_smg" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_3_4", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+
+	wait 4.5  // wait until OG is mounting up
+
+	printt( "BACKGROUND RUNNER GROUP 4" )
+
+	thread SpawnSkitGuy_AndRun( "runner_4_1", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_4_2", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+
+	wait 6.5  // wait until OG thumbs up
+
+	printt( "BACKGROUND RUNNER GROUP 5" )
+
+	thread SpawnSkitGuy_AndRun( "runner_5_1", path2, 0.85, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_hemlok_smg" )
+	wait 1.2
+	thread SpawnSkitGuy_AndRun( "runner_5_2", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_5_3", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+	wait 1.5
+	thread SpawnSkitGuy_AndRun( "runner_5_4", path2, 0.85, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_5_3", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+	wait 1.5
+	thread SpawnSkitGuy_AndRun( "runner_5_4", path2, 0.85, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+
+	/*
+	wait 5.0
+
+	wait 4.0
+
+	thread SpawnSkitGuy_AndRun( "runner_2_1", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "runner_2_2", path2, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_shotgun" )
+	*/
+}
+
+void function PodOutro_Foreground_Runners( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	// right in front of pod
+	array<Point> pathClose = []
+	ScriptedPath_AddPoint( pathClose, < 10728.2, -10194.2, -6055.97 >, < 0, 178.246, 0 > )
+	ScriptedPath_AddPoint( pathClose, < 10236.8, -10180.3, -6055.97 >, < 0, 178.41, 0 > )
+
+	wait 11.0  // wait for OG to hand eyeball to BT
+
+	thread SpawnSkitGuy_AndRun( "close_runner_1", pathClose, 0.7, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.2
+	thread SpawnSkitGuy_AndRun( "close_runner_2", pathClose, 0.75, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+
+	wait 10.0  // wait for OG to start embarking BT
+
+	thread SpawnSkitGuy_AndRun( "close_runner_4", pathClose, 0.75, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.3
+	thread SpawnSkitGuy_AndRun( "close_runner_5", pathClose, 0.8, TEAM_MILITIA, "npc_soldier_specialist_militia", "mp_weapon_g2" )
+
+	wait 11  // wait for grunt to hand player the weapon
+
+	thread SpawnSkitGuy_AndRun( "close_runner_10", pathClose, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.8
+	thread SpawnSkitGuy_AndRun( "close_runner_11", pathClose, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+	wait 1.0
+	thread SpawnSkitGuy_AndRun( "close_runner_12", pathClose, 0.8, TEAM_MILITIA, "npc_soldier", "mp_weapon_rspn101" )
+}
+
+void function PodOutro_Background_ATC_Marvins()
+{
+	// 1, 2, 3- matches titan bay numbering (right to left)
+	// plain numbers = farther from camera
+	// "a" variants = closer to camera
+	//SkitGuyInfo marvin_1 	= SpawnSkitGuy( "atc_marvin_1", "", < 10600, -9841.5, -6079.97 >, < 0, -20, 0 >, TEAM_MILITIA )
+	//thread ATC_Marvin_Think( marvin_1, 	"mv_trafic_controller_A", 0.0 )
+	//SkitGuyInfo marvin_1a 	= SpawnSkitGuy( "atc_marvin_1a", "", < 10683.8, -10077.7, -6094.65 >, < 0, 20, 0 >, TEAM_MILITIA )
+	//thread ATC_Marvin_Think( marvin_1a, "mv_trafic_controller_B", 0.0 )
+	SkitGuyInfo marvin_2 	= SpawnSkitGuy( "atc_marvin_2", "", < 10460.6, -9861.5, -6079.97 >, < 0, -30, 0 >, TEAM_MILITIA )
+	thread ATC_Marvin_Think( marvin_2, 	"mv_trafic_controller_B", 0.25 )
+	//SkitGuyInfo marvin_2a 	= SpawnSkitGuy( "atc_marvin_2a", "", < 10410.6, -10075.6, -6079.97 >, < 0, 30, 0 >, TEAM_MILITIA )
+	//thread ATC_Marvin_Think( marvin_2a, "mv_trafic_controller_A", 0.25 )
+	SkitGuyInfo marvin_3 	= SpawnSkitGuy( "atc_marvin_3", "", < 10214.8, -9891.5, -6079.97 >, < 0, -10, 0 >, TEAM_MILITIA )
+	thread ATC_Marvin_Think( marvin_3, 	"mv_trafic_controller_A", 0.5 )
+	SkitGuyInfo marvin_3a 	= SpawnSkitGuy( "atc_marvin_3a", "", < 10207.5, -10079.4, -6079.97 >, < 0, 10, 0 >, TEAM_MILITIA )
+	thread ATC_Marvin_Think( marvin_3a, "mv_trafic_controller_B", 0.5 )
+}
+
+void function ATC_Marvin_Think( SkitGuyInfo marvinInfo, string anim, float skipAheadTime = 0.0 )
+{
+	entity marvin = marvinInfo.guy
+
+	EndSignal( marvin, "OnDestroy" )
+
+	entity batonRight = CreatePropDynamic( SAFETY_BATON_MODEL )
+	batonRight.SetOrigin( marvin.GetAttachmentOrigin( marvin.LookupAttachment( "R_HAND" ) ) )
+	// HACK adjust the angles since the tags are different
+	vector angs = marvin.GetAttachmentAngles( marvin.LookupAttachment( "R_HAND" ) ) + Vector( 0, 0, 180 )
+	batonRight.SetAngles( angs )
+	batonRight.SetParent( marvin, "R_HAND", true )
+
+	entity batonLeft = CreatePropDynamic( SAFETY_BATON_MODEL )
+	batonLeft.SetParent( marvin, "L_HAND" )
+
+	marvin.NotSolid() // don't want other NPCs to path around the ATC marvins
+
+	array<entity> cleanupEnts = [ batonRight, batonLeft ]
+
+	OnThreadEnd(
+	function() : ( cleanupEnts )
+		{
+			foreach ( ent in cleanupEnts )
+			{
+				if ( IsValid( ent ) )
+				{
+					ent.ClearParent()
+					ent.Destroy()
+				}
+			}
+		}
+	)
+
+	WaitFrame()
+	marvinInfo.skitAnim = anim
+	/*
+	array<string> anims = [ "mv_trafic_controller_A", "mv_trafic_controller_B" ]
+	while( 1 )
+	{
+		marvin.Anim_Play( anims.getrandom() )
+		marvin.SetPlaybackRate( RandomFloatRange( 0.9, 1.0 ) )
+		waitthread WaittillAnimDone( marvin )
+	}
+	*/
+	marvin.SetPlaybackRate( RandomFloatRange( 0.9, 1.0 ) )
+	SkitGuy_PlayAnim( marvinInfo, skipAheadTime )
+
+	WaitForever()
+}
+
+
+
+// =======================================
+// ============ GAUNTLET MODE ============
+// =======================================
+// Just runs the Gauntlet over and over.
+
+void function Training_Setup_GauntletMode( entity player )
+{
+	Training_EnvArtColorCorrection_SetEnabled( true )
+
+	entity ogStart = GetEntByScriptName( "og_near_leaderboard" )
+	entity og = Training_SpawnOGPilot( ogStart )
+	Training_OG_Idles( ogStart, "OG_Leaderboard_D_idle" )
+
+	//TeleportPlayerAndBT( "playerstart_gauntlet_challenge" )
+	// HACK better start position
+	player.SetOrigin( < -5179, 279.129, 32.0313 > )
+	player.SetAngles( < 0, 80.7242, 0 > )
+}
+
+void function Training_GauntletModeStart( entity player )
+{
+	file.gauntletMode = true
+
+	waitthread Training_GauntletChallenge( player )
+}
+
+void function GauntletMode_Finished( entity player )
+{
+	Assert( file.gauntletMode )
+
+	float fadeTime = 3.0
+	ScreenFade( player, 0, 0, 0, 255, fadeTime, -1, FFADE_OUT | FFADE_STAYOUT )
+	wait fadeTime
+
+	// Dump player back to menu
+	ClientCommand( player, "disconnect" )
+
+	WaitForever()  // defensive- don't want any extra stuff happening right before level transition
+}
+
+
+
+#if DEV
+// ===============================================
+// ============ RECORD GAUNTLET GHOSTS ===========
+// ===============================================
+void function TrainingGauntlet_RecordGhostStart_FirstRun( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_FIRSTRUN )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_WIP( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_WIP )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_01( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_01 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_02( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_02 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_03( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_03 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_04( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_04 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_05( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_05 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_06( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_06 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_07( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_07 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_08( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_08 )
+}
+
+void function TrainingGauntlet_RecordGhostStart_Challenge_09( entity player )
+{
+	TrainingGauntlet_RecordGhost_CommonStart( player, GetTrainingGauntlet(), GHOST_NAME_CHAL_09 )
+}
+
+
+void function TrainingGauntlet_RecordGhost_CommonStart( entity player, GauntletInfo gauntlet, string ghostFileName )
+{
+	thread TrainingGauntlet_TeleportPlayerAtFinishLine( player )
+
+	TeleportPlayerAndBT( "gauntlet_startpoint" )
+
+	Gauntlet_Player_GhostRecordOrPlayback( player, gauntlet, ghostFileName )
+
+	while ( 1 )
+		wait 5
+}
+#endif //DEV
+
+
+
+// ============================================
+// ============ TRAINING POD STUFF ============
+// ============================================
+void function SetupTrainingPod()
+{
+	file.trainingPod = GetEntByScriptName( "training_pod" )
+	file.trainingPod.DisableHibernation()
+
+	TrainingPod_SetupInteriorDLights()
+
+	array<string> laserAttachNames = [ "fx_laser_L", "fx_laser_R" ]
+
+	foreach ( attachName in laserAttachNames )
+	{
+		entity emitterEnt = CreateScriptMover( file.trainingPod.GetOrigin() )
+		int attachID = file.trainingPod.LookupAttachment( attachName )
+		vector attachAng = file.trainingPod.GetAttachmentAngles( attachID )
+
+		TrainingPod_LaserEmitter emitter
+		emitter.ent 		= emitterEnt
+		emitter.attachName 	= attachName
+		emitter.ogAng 		= attachAng
+
+		file.trainingPodLaserEmitters.append( emitter )
+	}
+
+	// HACK we do this later as well to reset the emitter positions, so it's a separate function
+	TrainingPod_SnapLaserEmittersToAttachPoints()
+
+	//file.trainingPod.SetAngles( Vector( 0, 109, 0 ) )  // these angles are a little better for seeing the room
+}
+
+void function TrainingPod_SetupInteriorDLights()
+{
+	entity pod = file.trainingPod
+
+	TrainingPod_dLightMapping m1
+	m1.scriptAlias = "console1"
+	m1.fxName = FX_POD_DLIGHT_CONSOLE1
+	m1.attachName = "light_console1"
+	file.trainingPodDLightMappings.append( m1 )
+
+	TrainingPod_dLightMapping m2
+	m2.scriptAlias = "console2"
+	m2.fxName = FX_POD_DLIGHT_CONSOLE2
+	m2.attachName = "light_console2"
+	file.trainingPodDLightMappings.append( m2 )
+
+	//TrainingPod_dLightMapping m3
+	//m3.scriptAlias = "backlight_side_L"
+	//m3.fxName = FX_POD_DLIGHT_BACKLIGHT_SIDE
+	//m3.attachName = "light_back1"
+	//file.trainingPodDLightMappings.append( m3 )
+
+	//TrainingPod_dLightMapping m4
+	//m4.scriptAlias = "backlight_side_R"
+	//m4.fxName = FX_POD_DLIGHT_BACKLIGHT_SIDE
+	//m4.attachName = "light_back2"
+	//file.trainingPodDLightMappings.append( m4 )
+
+	//TrainingPod_dLightMapping m5
+	//m5.scriptAlias = "backlight_top"
+	//m5.fxName = FX_POD_DLIGHT_BACKLIGHT_TOP
+	//m5.attachName = "light_backtop"
+	//file.trainingPodDLightMappings.append( m5 )
+}
+
+void function TrainingPod_TurnOnInteriorDLights_Delayed( entity player, float delay )
+{
+	player.EndSignal( "OnDestroy" )
+
+	wait delay
+
+	TrainingPod_TurnOnInteriorDLight( "console1" )
+	TrainingPod_TurnOnInteriorDLight( "console2" )
+}
+
+void function TrainingPod_TurnOnInteriorDLight( string scriptAlias )
+{
+	entity pod = file.trainingPod
+
+	int idx
+	TrainingPod_dLightMapping thisMapping
+	foreach ( mappingIdx, mapping in file.trainingPodDLightMappings )
+	{
+		if ( mapping.scriptAlias == scriptAlias )
+		{
+			thisMapping = mapping
+			idx = mappingIdx
+			break
+		}
+	}
+
+	Assert ( thisMapping.scriptAlias != "", "Couldn't find pod dlight mapping for alias " + scriptAlias )
+
+	entity fxHandle = PlayLoopFXOnEntity( thisMapping.fxName, pod, thisMapping.attachName )
+	file.trainingPodDLightMappings[ idx ].fxHandle = fxHandle
+}
+
+void function TrainingPod_KillInteriorDLights_Delayed( entity player, float delay )
+{
+	player.EndSignal( "OnDestroy" )
+
+	wait delay
+
+	TrainingPod_KillInteriorDLights()
+}
+
+void function TrainingPod_KillInteriorDLights()
+{
+	foreach ( idx, mapping in file.trainingPodDLightMappings )
+	{
+		if ( !IsValid_ThisFrame( mapping.fxHandle ) )
+			continue
+
+		KillFX( mapping.fxHandle )
+
+		file.trainingPodDLightMappings[ idx ].fxHandle = null
+	}
+}
+
+void function TrainingPod_SnapLaserEmittersToAttachPoints()
+{
+	foreach ( TrainingPod_LaserEmitter emitter in file.trainingPodLaserEmitters )
+	{
+		int attachID = file.trainingPod.LookupAttachment( emitter.attachName )
+		vector attachOrg = file.trainingPod.GetAttachmentOrigin( attachID )
+		vector attachAng = file.trainingPod.GetAttachmentAngles( attachID )
+
+		emitter.ent.ClearParent()
+		emitter.ent.SetOrigin( attachOrg )  // HACK set this to ANYTHING  (even 0, 0, 0) and the position is correct, otherwise it's offset from the attachpoint when parented
+		emitter.ent.SetParent( file.trainingPod, emitter.attachName )
+	}
+}
+
+void function TrainingPod_Interior_BootSequence( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	entity pod = file.trainingPod
+
+	TrainingPod_InteriorFX_CommonSetup( pod )
+
+	FlagSet( "PodIntro_InteriorBootSequence_Starting" )
+
+	EmitSoundOnEntity( player, "NPE_Scr_SimPod_PowerUp" )
+
+	// Transition screen FX
+	thread PlayFXOnEntity_Delayed( player, FX_POD_SCREEN_IN, player, 2.35 )
+
+	// GLOW LIGHTS
+	TrainingPod_GlowLightsTurnOn()
+
+    // LASERS
+    float longestSweepTime = -1
+	foreach ( emitter in file.trainingPodLaserEmitters )
+	{
+		float sweepTime = RandomFloatRange( 2.9, 3.15 )
+		if ( sweepTime > longestSweepTime )
+			longestSweepTime = sweepTime
+
+		thread LaserSweep( player, sweepTime, emitter, pod, "top" )
+	}
+
+	wait longestSweepTime
+
+    player.Signal( "PodInteriorSequenceDone" )
+}
+
+void function TrainingPod_InteriorFX_CommonSetup( entity pod )
+{
+	if ( file.trainingPodLaserEmitters.len() )
+	{
+		TrainingPod_KillLasers( pod )
+		TrainingPod_ResetLaserEmitterRotation( pod )
+	}
+
+	TrainingPod_KillGlowFX( pod )
+}
+
+// NOTE startPosition is actually inverted from what I think it should be. Tag orientation issue, maybe?
+void function LaserSweep( entity player, float totalTime, TrainingPod_LaserEmitter emitter, entity pod, string startPosition = "bottom" )
+{
+	//float startTime = Time()
+
+	player.EndSignal( "OnDestroy" )
+	emitter.ent.EndSignal( "OnDeath" )
+
+	emitter.sweepDone = false
+
+	//printt( "emitter og angles:", emitter.GetAngles() )
+
+	vector vecToPlayerEye = ( player.EyePosition() + Vector( 0, 0, 7 ) ) - emitter.ent.GetOrigin()  // eye position offset is a HACK, not sure why I need to do that here.
+	vector centerAng = VectorToAngles( vecToPlayerEye )
+	vector topAng = centerAng + Vector( -270, 0, 0 )
+	vector bottomAng = centerAng + Vector( -90, 0, 0 )
+
+	//vector topAng 	= emitter.GetAngles() + < 90, -8, 0 >
+	//vector bottomAng 	= emitter.GetAngles() + < -90, 8, 0 >
+
+	//printt( "==== starting at:", startPosition )
+	//printt( "topAng:", topAng )
+	//printt( "bottomAng:", bottomAng )
+	//printt( "centerAng:", centerAng )
+
+	vector lastBigSweepAng
+
+	if ( startPosition == "bottom")
+	{
+		emitter.ent.SetAbsAngles( bottomAng )
+		lastBigSweepAng = bottomAng
+	}
+	else
+	{
+		emitter.ent.SetAbsAngles( topAng )
+		lastBigSweepAng = topAng
+	}
+	//printt( "setting start angles to:", lastBigSweepAng )
+
+	entity fxHandle = PlayLoopFXOnEntity( FX_POD_LASER, emitter.ent )
+	emitter.fxHandle = fxHandle
+
+	int numBigSweeps = 2
+	float finalCenterTime = totalTime * 0.15
+	float bigSweepTime = ( totalTime - finalCenterTime ) / numBigSweeps
+
+	float bigSweep_AccelTime = 0
+	float bigSweep_DecelTime = bigSweepTime * 0.2
+
+	// do the big sweeps
+	vector nextBigSweepAng
+	for ( int i = 0; i < numBigSweeps; i++ )
+	{
+		nextBigSweepAng = topAng
+		if ( lastBigSweepAng == topAng )
+			nextBigSweepAng = bottomAng
+
+		//printt( "rotating to", nextBigSweepAng )
+
+		emitter.ent.NonPhysicsRotateTo( nextBigSweepAng, bigSweepTime, bigSweep_AccelTime, bigSweep_DecelTime )
+
+		float waitTime = bigSweepTime
+		if ( i < numBigSweeps - 1 )
+			waitTime = bigSweepTime - 0.1
+
+		wait waitTime
+
+		lastBigSweepAng = nextBigSweepAng
+	}
+
+	// finish with centering move
+	//printt( "centering to", centerAng )
+
+	float finalCenter_AccelTime = 0
+	float finalCenter_DecelTime = finalCenterTime * 0.2
+
+	emitter.ent.NonPhysicsRotateTo( centerAng, finalCenterTime, finalCenter_AccelTime, finalCenter_DecelTime )
+	wait finalCenterTime
+
+	emitter.sweepDone = true
+	//printt( "laser sweep done, total time", Time() - startTime, "should have been", totalTime )
+}
+
+void function TrainingPod_KillLasers( entity pod, bool doEndCap = false )
+{
+	foreach ( emitter in file.trainingPodLaserEmitters )
+	{
+		if ( IsValid_ThisFrame( emitter.fxHandle ) )
+		{
+			if ( !doEndCap )
+			{
+				//printt( "killing laser FX", emitter.fxHandle )
+				KillFX( emitter.fxHandle )
+			}
+			else
+			{
+				//printt( "killing laser FX with endcap", emitter.fxHandle )
+				KillFXWithEndcap( emitter.fxHandle )
+			}
+		}
+
+		emitter.fxHandle = null
+	}
+}
+
+void function TrainingPod_ResetLaserEmitterRotation( entity pod )
+{
+	if ( !file.trainingPodLaserEmitters.len() )
+		return
+
+	foreach ( emitter in file.trainingPodLaserEmitters )
+	{
+		//reset to start position
+		emitter.ent.NonPhysicsRotateTo( emitter.ogAng, 0.05, 0.0, 0.0 )
+	}
+}
+
+void function TrainingPod_GlowLightsArraySetup()
+{
+	array<TrainingPod_GlowLightRow> rows
+
+	// rows are set up bottom to top
+	// lights are set up outside to in (in = door close seam; opposite for each side)
+	// process two rows per loop (one for each door side)
+
+	TrainingPod_GlowLightRow row1
+	row1.fxSpotsL = [ "fx_glow_L_door012", "fx_glow_L_door013" ]
+	row1.fxSpotsR = [ "fx_glow_R_door014", "fx_glow_R_door013" ]
+	rows.append( row1 )
+
+	TrainingPod_GlowLightRow row2
+	row2.fxSpotsL = [ "fx_glow_L_door014", "fx_glow_L_door011" ]
+	row2.fxSpotsR = [ "fx_glow_R_door012", "fx_glow_R_door011" ]
+	rows.append( row2 )
+
+	TrainingPod_GlowLightRow row3
+	row3.fxSpotsL = [ "fx_glow_L_door09", "fx_glow_L_door010" ]
+	row3.fxSpotsR = [ "fx_glow_R_door09", "fx_glow_R_door010" ]
+	rows.append( row3 )
+
+	TrainingPod_GlowLightRow row4
+	row4.fxSpotsL = [ "fx_glow_L_door07", "fx_glow_L_door08" ]
+	row4.fxSpotsR = [ "fx_glow_R_door07", "fx_glow_R_door08" ]
+	rows.append( row4 )
+
+	TrainingPod_GlowLightRow row5
+	row5.fxSpotsL = [ "fx_glow_L_door05", "fx_glow_L_door06" ]
+	row5.fxSpotsR = [ "fx_glow_R_door05", "fx_glow_R_door06" ]
+	rows.append( row5 )
+
+	TrainingPod_GlowLightRow row6
+	row6.fxSpotsL = [ "fx_glow_L_door03", "fx_glow_L_door04" ]
+	row6.fxSpotsR = [ "fx_glow_R_door03", "fx_glow_R_door04" ]
+	rows.append( row6 )
+
+	TrainingPod_GlowLightRow row7
+	row7.fxSpotsL = [ "fx_glow_L_door01", "fx_glow_L_door02" ]
+	row7.fxSpotsR = [ "fx_glow_R_door01", "fx_glow_R_door02" ]
+	rows.append( row7 )
+
+	file.trainingPodGlowLightRows = rows
+}
+
+void function TrainingPod_GlowLightsTurnOn( bool instantOn = false )
+{
+	//float startTime = Time()
+
+	entity pod = file.trainingPod
+
+	foreach ( TrainingPod_GlowLightRow row in file.trainingPodGlowLightRows )
+	{
+		float loopTime = Time()
+
+		array<string> group1 = [ row.fxSpotsL[0], row.fxSpotsR[0] ]
+		array<string> group2 = [ row.fxSpotsL[1], row.fxSpotsR[1] ]
+		table< int, array < string > > lightgroups
+		lightgroups[0] <- group1
+		lightgroups[1] <- group2
+
+		foreach ( idx, group in lightgroups )
+		{
+			foreach ( attachName in group )
+			{
+				entity fxHandle = PlayLoopFXOnEntity( FX_POD_GLOWLIGHT, pod, attachName )
+				file.trainingPodGlowLightFXHandles.append( fxHandle )
+			}
+
+			if ( !instantOn )
+				wait 0.1
+		}
+
+		/*
+		// both sides have same number of lights
+		int numLights = 2
+		for ( int i = 0; i < numLights; i++ )
+		{
+			foreach ( var side in row )
+			{
+				string attachName = side[ i ]
+				entity fxHandle = PlayLoopFXOnEntity( FX_POD_GLOWLIGHT, pod, attachName )
+				file.trainingPodGlowLightFXHandles.append( fxHandle )
+			}
+
+			if ( lightWait > 0 )
+				wait lightWait
+		}
+
+		if ( rowWait > 0)
+			wait rowWait
+		*/
+	}
+
+	//printt( "glow lights turn on took", Time() - startTime, "secs" )
+}
+
+void function TrainingPod_KillGlowFX( entity pod )
+{
+	foreach ( fxHandle in file.trainingPodGlowLightFXHandles )
+	{
+		if ( !IsValid_ThisFrame( fxHandle ) )
+			continue
+
+		KillFX( fxHandle )
+	}
+
+	file.trainingPodGlowLightFXHandles = []
+}
+
+void function TrainingPod_Interior_ShutdownSequence( entity player, float shutdownTime )
+{
+	player.EndSignal( "OnDestroy" )
+
+	entity pod = file.trainingPod
+
+	TrainingPod_InteriorFX_CommonSetup( pod )
+
+	// TURN ON GLOW LIGHTS
+	TrainingPod_GlowLightsTurnOn( true )
+
+	// TURN ON LASERS
+	TrainingPod_LasersInstantOn( player, pod )
+
+	player.WaitSignal( "TrainingPod_BeginInteriorShutdown" )
+
+	thread TrainingPod_LasersShutDown( player, pod, shutdownTime * 0.6 )
+	thread TrainingPod_GlowLightsShutDown( player, pod, shutdownTime )
+
+	wait shutdownTime
+	printt( "interior shutdown done" )
+}
+
+void function TrainingPod_LasersInstantOn( entity player, entity pod )
+{
+	foreach ( emitter in file.trainingPodLaserEmitters )
+	{
+		float dist = Distance( player.EyePosition(), emitter.ent.GetOrigin() )
+		Assert( dist <= 30, "player is usually about 20 units away when we try to set the laser angles. If very far away, the math will crash the game. Dist: " + dist )
+
+		vector vecToPlayerEye = ( player.EyePosition() + Vector( 0, 0, 7 ) ) - emitter.ent.GetOrigin()  // eye position offset is a HACK, not sure why I need to do that here.
+		vector centerAng = VectorToAngles( vecToPlayerEye )
+		emitter.ent.NonPhysicsRotateTo( centerAng, 0.1, 0.0, 0.0 )  // SETANGLES DOES NOT WORK! You have to rotate it for the FX to follow.
+
+		emitter.fxHandle = PlayLoopFXOnEntity( FX_POD_LASER, emitter.ent )
+	}
+}
+
+void function TrainingPod_LasersShutDown( entity player, entity pod, float shutdownTime )
+{
+	player.EndSignal( "OnDestroy" )
+
+	foreach ( emitter in file.trainingPodLaserEmitters )
+	{
+		vector vecToPlayerEye = ( player.EyePosition() + Vector( 0, 0, 7 ) ) - emitter.ent.GetOrigin()  // eye position offset is a HACK, not sure why I need to do that here.
+		vector centerAng = VectorToAngles( vecToPlayerEye )
+		emitter.ent.NonPhysicsRotateTo( centerAng, 0.1, 0.0, 0.0 )  // SETANGLES DOES NOT WORK! You have to rotate it for the FX to follow.
+	}
+
+	wait shutdownTime * 0.25
+
+	float moveDownTime = shutdownTime * 0.75
+	float accelTime = moveDownTime * 0.25
+	float decelTime = moveDownTime * 0.1
+
+	foreach ( TrainingPod_LaserEmitter emitter in file.trainingPodLaserEmitters )
+	{
+		vector finalAng = emitter.ent.GetAngles() + Vector( 30, 0, 0 )  // not sure why adding pitch makes them appear to drop down
+		emitter.ent.NonPhysicsRotateTo( finalAng, moveDownTime, accelTime, decelTime )
+	}
+
+	wait moveDownTime
+	TrainingPod_KillLasers( pod, true )
+}
+
+void function TrainingPod_GlowLightsShutDown( entity player, entity pod, float shutdownTime )
+{
+	player.EndSignal( "OnDestroy" )
+
+	float shutdownDelay = shutdownTime * 0.65
+	float finishEarly = shutdownTime * 0.1
+	float glowLightShutDownDuration = shutdownTime - shutdownDelay - finishEarly
+
+	wait shutdownDelay
+
+	Assert( glowLightShutDownDuration > 0.0 )
+
+	float timePerLight = glowLightShutDownDuration / file.trainingPodGlowLightFXHandles.len().tofloat()
+
+	foreach ( entity fxHandle in file.trainingPodGlowLightFXHandles )
+	{
+		if ( !IsValid_ThisFrame( fxHandle ) )
+			continue
+
+		thread KillFXWithEndcap( fxHandle )
+		wait timePerLight
+	}
+
+	file.trainingPodGlowLightFXHandles = []
+}
+
+void function TrainingPod_ViewConeLock_Shared( entity player )
+{
+	player.PlayerCone_FromAnim()
+	player.PlayerCone_SetMinYaw( -25 )
+	player.PlayerCone_SetMaxYaw( 25 )
+	player.PlayerCone_SetMinPitch( -30 )
+}
+
+void function TrainingPod_ViewConeLock_PodOpen( entity player )
+{
+	TrainingPod_ViewConeLock_Shared( player )
+	player.PlayerCone_SetMaxPitch( 35 )
+}
+
+void function TrainingPod_ViewConeLock_PodClosed( entity player )
+{
+	TrainingPod_ViewConeLock_Shared( player )
+	player.PlayerCone_SetMaxPitch( 32 )
+}
+
+void function TrainingPod_ViewConeLock_SemiStrict( entity player )
+{
+	player.PlayerCone_FromAnim()
+	player.PlayerCone_SetMinYaw( -10 )
+	player.PlayerCone_SetMaxYaw( 10 )
+	player.PlayerCone_SetMinPitch( -10 )
+	player.PlayerCone_SetMaxPitch( 10 )
+}
+
+void function TrainingPod_ViewConeLock_Strict( entity player )
+{
+	player.PlayerCone_FromAnim()
+	player.PlayerCone_SetMinYaw( 0 )
+	player.PlayerCone_SetMaxYaw( 0 )
+	player.PlayerCone_SetMinPitch( 0 )
+	player.PlayerCone_SetMaxPitch( 0 )
+}
+
+
+// ==================================================
+// ============ CLIENT COMMAND CALLBACKS ============
+// ==================================================
+
+bool function ClientCommand_Training_SetInputType( entity player, array<string> args )
+{
+	int inputType = args[0].tointeger()
+
+	Assert( inputType == INPUT_TYPE_CONTROLLER || inputType == INPUT_TYPE_KBM )
+	//printt( "Training- client input type updated:", inputType )
+	file.playerInputType = inputType
+	return true
+}
+
+bool function ClientCommand_Training_PlayerPressedUse( entity player, array<string> args )
+{
+	FlagSet( "PlayerPressedUse" )
+	return true
+}
+
+bool function ClientCommand_Training_PlayerReloaded( entity player, array<string> args )
+{
+	FlagSet( "PlayerReloaded" )
+	return true
+}
+
+bool function ClientCommand_LookTarget_Top( entity player, array<string> args )
+{
+	player.ResetIdleTimer()
+	printt( "ClientCommand_LookTarget_Top" )
+	FlagSet( "PlayerLookedAtTopTarget" )
+	return true
+}
+
+bool function ClientCommand_LookTarget_Bottom( entity player, array<string> args )
+{
+	player.ResetIdleTimer()
+	printt( "ClientCommand_LookTarget_Bottom" )
+	FlagSet( "PlayerLookedAtBottomTarget" )
+	return true
+}
+
+
+
+// ===============================
+// ============ DOORS ============
+// ===============================
+void function DoorOpenFast( string doorEntName )
+{
+	entity door = GetEntByScriptName( doorEntName )
+	door.Hide()
+	door.NotSolid()
+
+	entity navBlocker = door.GetLinkEnt()
+	navBlocker.NotSolid()
+	ToggleNPCPathsForEntity( navBlocker, true )
+}
+
+void function DoorCloseFast( string doorEntName )
+{
+	entity door = GetEntByScriptName( doorEntName )
+	door.Show()
+	door.Solid()
+
+	entity navBlocker = door.GetLinkEnt()
+	navBlocker.Solid()
+	ToggleNPCPathsForEntity( navBlocker, false )
+}
+
+
+void function OpenZenGardenExitDoor()
+{
+	DoorOpenFast( "zengarden_door" )
+}
+
+void function CloseZenGardenExitDoor()
+{
+	DoorCloseFast( "zengarden_door" )
+}
+
+void function OpenGauntletDoor()
+{
+	DoorOpenFast( "gauntlet_door" )
+}
+
+
+
+// ===================================
+// ========= LOUDSPEAKER VO ==========
+// ===================================
+void function LoudspeakerVO_Setup()
+{
+	vector loudspeakerPos = <10524, -9660, -5896>  // HACK
+	file.loudspeaker = CreateScriptMover( loudspeakerPos, <0,0,0> )
+
+	// ======= PA ANNOUNCEMENTS: POD INTRO =======
+	// "Inbound to Planet Typhon. Subspace rendezvous in approximately 20 minutes."
+	RegisterLoudspeakerVO( "intro_0", "diag_sp_addtional_TR411_01_mcor_shipPA", 8.0 )
+
+	// "Major Anderson, please report to the briefing room."
+	RegisterLoudspeakerVO( "intro_1", "diag_sp_addtional_TR411_02_mcor_grunt1", 3.0 )
+
+	// "Reminder to dock personnel: Titan ordnance is a Type 3 Hazardous Material."
+	RegisterLoudspeakerVO( "intro_2", "diag_sp_addtional_TR411_03_mcor_shipPA", 6.0 )
+
+	// "Captain Cole to communications."
+	RegisterLoudspeakerVO( "intro_3", "diag_sp_addtional_TR411_04_mcor_grunt1", 3.0 )
+
+	// "Running Lifeboat diagnostic test two point one. All Mark Eight lifeboats are in the green."
+	RegisterLoudspeakerVO( "intro_4", "diag_sp_addtional_TR411_05_mcor_shipPA", 6.0 )
+
+	// "3rd Militia Grenadiers - prep dropship MacAllan 17."
+	RegisterLoudspeakerVO( "intro_5", "diag_sp_addtional_TR411_06_mcor_grunt1", 4.0 )
+
+
+	// ======= PA ANNOUNCEMENTS: MEET OG =======
+	// "Prepare for Typhon atmospheric entry in less than three minutes."
+	RegisterLoudspeakerVO( "outro_01", "diag_sp_addtional_TR411_07_mcor_shipPA", 7.0 )
+
+	// "Powering down all non-essential systems."
+	RegisterLoudspeakerVO( "outro_01_1", "diag_sp_outro_TR171_01_01_mcor_shipPA", 4.0 )
+
+	// "All personnel to battle stations."
+	RegisterLoudspeakerVO( "outro_01_2", "diag_sp_outro_TR171_02_01_mcor_shipPA", 3.0 )
+
+	// "This is not a drill."
+	RegisterLoudspeakerVO( "outro_01_3", "diag_sp_outro_TR171_03_01_mcor_shipPA", 3.0 )
+
+	// "Titan bays two through five, drop clearance confirmed."
+	RegisterLoudspeakerVO( "outro_03", "diag_sp_addtional_TR411_09_mcor_shipPA", 5.0 )
+
+	// "Infantry teams Stork three, Elk four, Shark six, Badger one, prepare for emergency atmospheric drop sequence"
+	RegisterLoudspeakerVO( "outro_04", "diag_sp_addtional_TR411_10_mcor_grunt1", 7.0 )
+
+	// "All available medical personnel, report to Med Central for tasking."
+	RegisterLoudspeakerVO( "outro_05", "diag_sp_addtional_TR411_11_mcor_grunt2", 5.0 )
+
+	// "Titan mech team - Rabbit six, prep the Vanguards."
+	RegisterLoudspeakerVO( "outro_06", "diag_sp_addtional_TR411_12_mcor_grunt3", 4.0 )
+
+	// "We need all Riflemen to docking bay four. Dropships standing by."
+	RegisterLoudspeakerVO( "outro_07", "diag_sp_addtional_TR411_13_mcor_grunt1", 5.0 )
+
+	// "Incoming hostile ship - Designation: IMS Malta. Battle stations."
+	RegisterLoudspeakerVO( "outro_08", "diag_sp_addtional_TR411_14_mcor_shipPA", 6.0 )
+
+	// "Special Recon Squad deploy from Drop Bay thirty-seven - now."
+	RegisterLoudspeakerVO( "outro_10", "diag_sp_addtional_TR411_16_mcor_grunt2", 5.0 )
+
+	// "Infantry teams 2nd Militia Fusiliers, Raptor three, target the IMS Malta."
+	RegisterLoudspeakerVO( "outro_11", "diag_sp_addtional_TR411_17_mcor_grunt3", 6.0 )
+
+	// "Caution - Fuel leak in Cargo Bay eighty - five. Decompressing for fire suppression."
+	RegisterLoudspeakerVO( "outro_12", "diag_sp_addtional_TR411_18_mcor_shipPA", 6.0 )
+}
+
+void function RegisterLoudspeakerVO( string scriptAlias, string soundAlias, float duration = 6.0 )
+{
+	Assert( !( scriptAlias in file.loudspeakerVO ), "duplicate scriptAlias " + scriptAlias )
+
+	LoudspeakerVO_Info voInfo
+	voInfo.scriptAlias = scriptAlias
+	voInfo.soundAlias = soundAlias
+	voInfo.duration = duration
+
+	file.loudspeakerVO[ scriptAlias ] <- voInfo
+}
+
+void function PlayLoudspeakerVO( string scriptAlias, float delay = 0.0 )
+{
+	Assert( scriptAlias in file.loudspeakerVO )
+	LoudspeakerVO_Info voInfo = file.loudspeakerVO[ scriptAlias ]
+
+	string soundAlias = voInfo.soundAlias
+
+	if ( delay > 0 )
+		wait delay
+
+	entity emitter = file.loudspeaker
+	emitter.Signal( "LoudspeakerVO_Stop" )
+	emitter.EndSignal( "LoudspeakerVO_Stop" )
+
+	OnThreadEnd(
+	function() : ( emitter, soundAlias )
+		{
+			if ( IsValid( emitter ) )
+				FadeOutSoundOnEntity( emitter, soundAlias, 2.0 )
+		}
+	)
+
+	//printt( "playing loudspeaker VO", scriptAlias, "/", soundAlias )
+	EmitSoundOnEntity( emitter, soundAlias )
+	wait voInfo.duration
+}
+
+void function LoopLoudspeakerVO( array<string> scriptAliases, string endFlag = "", float minPause = -1, float maxPause = -1 )
+{
+	if ( endFlag != "" )
+	{
+		if ( Flag( endFlag ) )
+			return
+
+		FlagEnd( endFlag )
+	}
+
+	while ( 1 )
+	{
+		foreach ( scriptAlias in scriptAliases )
+		{
+			waitthread PlayLoudspeakerVO( scriptAlias )
+
+			if ( minPause > 0 && maxPause >= minPause )
+				wait RandomFloatRange( minPause, maxPause )
+		}
+	}
+}
+
+
+
+// ==============================
+// ============ MISC ============
+// ==============================
+
+entity function Training_SpawnAnOG( entity startSpot )
+{
+	entity og = CreateSoldier( TEAM_MILITIA, startSpot.GetOrigin(), startSpot.GetAngles() )
+	og.kv.spawnflags = SF_NPC_ALLOW_SPAWN_SOLID
+	DispatchSpawn( og )
+
+	TakeAllWeapons( og )
+
+	og.SetModel( OG_PILOT_MODEL )
+
+	og.SetTitle( "#TRAINING_OG_PILOT_NAME" )
+	ShowName( og )
+
+	Training_OGPilot_SetHelmetOn( og, true )
+
+	og.DisableHibernation()
+	og.SetNoTarget( true )
+	og.UseSequenceBounds( true )
+	MakeInvincible( og )
+	og.kv.scriptedAnimForceInterrupt = true
+
+	og.DisableNPCFlag( NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+	og.SetHologram()
+
+	return og
+}
+
+void function Training_OGPilot_SetHelmetOn( entity og, bool setOn )
+{
+	int headIdx = og.FindBodyGroup( "head" )
+
+	int submodelIdx = OG_PILOT_MODEL_HEAD_IDX_BARE
+	if ( setOn )
+		submodelIdx = OG_PILOT_MODEL_HEAD_IDX_HELMET
+
+	og.SetBodygroup( headIdx, submodelIdx )
+
+	/*
+	int decalIdx = og.FindBodyGroup( "decal" )
+	if ( decalIdx == -1 )
+		return
+
+	submodelIdx = OG_PILOT_MODEL_DECAL_IDX_BARE
+	if ( setOn )
+		submodelIdx = OG_PILOT_MODEL_DECAL_IDX
+
+	og.SetBodygroup( decalIdx, submodelIdx )
+	*/
+}
+
+entity function Training_SpawnOGPilot( entity startSpot )
+{
+	if ( IsValid( file.ogPilot ) )
+		file.ogPilot.Destroy()
+
+	entity og = Training_SpawnAnOG( startSpot )
+	file.ogPilot = og
+
+	return og
+	}
+
+entity function Training_SpawnOGTwin( entity startSpot )
+{
+	if ( IsValid( file.ogTwin ) )
+		file.ogTwin.Destroy()
+
+	entity ogTwin = Training_SpawnAnOG( startSpot )
+	file.ogTwin = ogTwin
+
+	return ogTwin
+}
+
+entity function GetOGPilot()
+{
+	Assert( IsValid( file.ogPilot ) )
+	return file.ogPilot
+}
+
+entity function GetOGTwin()
+{
+	if ( !IsValid( file.ogTwin ) )
+		return null
+
+	return file.ogTwin
+}
+
+
+void function Training_OG_NagPlayerUntilFlag_Sitting( entity player, array<string> nagAliases, float nagInterval, entity idleRef, string endFlag, string talkAnim = "", string idleAnim = "" )
+{
+	entity og = GetOGPilot()
+	Training_NPC_NagPlayerUntilFlag_Sitting( og, player, nagAliases, nagInterval, idleRef, endFlag, talkAnim, idleAnim )
+}
+
+void function Training_OG_NagPlayerUntilFlag( entity player, array<string> nagAliases, float nagInterval, entity idleRef, string endFlag, string talkAnim = "", string idleAnim = "" )
+{
+	entity og = GetOGPilot()
+	Training_NPC_NagPlayerUntilFlag( og, player, nagAliases, nagInterval, idleRef, endFlag, talkAnim, idleAnim )
+}
+
+void function Training_NPC_NagPlayerUntilFlag_Sitting( entity npc, entity player, array<string> nagAliases, float nagInterval, entity idleRef, string endFlag, string talkAnim = "", string idleAnim = "" )
+{
+	if ( talkAnim == "" )
+		talkAnim = ANIM_OG_SITTING_TALK
+
+	if ( idleAnim == "" )
+		idleAnim = ANIM_OG_SITTING_IDLE
+
+	Training_OG_NagPlayerUntilFlag( player, nagAliases, nagInterval, idleRef, endFlag, talkAnim, idleAnim )
+}
+
+void function Training_NPC_NagPlayerUntilFlag( entity npc, entity player, array<string> nagAliases, float nagInterval, entity idleRef, string endFlag, string talkAnim = "", string idleAnim = "" )
+{
+	player.EndSignal( "OnDestroy" )
+
+	if ( talkAnim == "" )
+		talkAnim = ANIM_OG_STANDING_TALK
+
+	if ( idleAnim == "" )
+		idleAnim = ANIM_OG_STANDING_IDLE
+
+	int nagIdx = 0
+	float nextNagTime = Time() + nagInterval
+
+	while ( !Flag( endFlag ) )
+	{
+		if ( Time() > nextNagTime )
+		{
+			waitthread Training_OG_Talks( nagAliases[nagIdx], idleRef, talkAnim, idleAnim, true )
+			nextNagTime = Time() + nagInterval
+
+			nagIdx++
+			if ( nagIdx >= nagAliases.len() )
+				nagIdx = 0
+		}
+
+		wait 0.1
+	}
+}
+
+void function Training_OG_Talks_Sitting( string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Talks_Sitting( og, voScriptAlias, idleRef, talkAnim, idleAnim, useBlend )
+}
+
+void function Training_OG_Talks_Leaning( string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Talks_Leaning( og, voScriptAlias, idleRef, talkAnim, idleAnim, useBlend )
+}
+
+void function Training_OG_Talks( string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Talks( og, voScriptAlias, idleRef, talkAnim, idleAnim, useBlend )
+}
+
+void function Training_OG_Idles_Sitting( entity idleRef, string anim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Idles_Sitting( og, idleRef, anim, useBlend )
+}
+
+void function Training_OG_Idles_SittingAndTalking( entity idleRef, string anim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Idles_SittingAndTalking( og, idleRef, anim, useBlend )
+}
+
+void function Training_OG_Idles_Talking( entity idleRef, string anim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_Idles_Talking( og, idleRef, anim, useBlend )
+}
+
+void function Training_OG_Idles( entity idleRef, string anim = "", bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	thread Training_NPC_Idles( og, idleRef, anim, useBlend )
+}
+
+void function Training_OG_ScriptedAnim( entity idleRef, string anim, bool useBlend = false )
+{
+	entity og = GetOGPilot()
+	Training_NPC_ScriptedAnim( og, idleRef, anim, useBlend )
+}
+
+
+void function Training_NPC_Talks_Sitting( entity npc, string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	if ( talkAnim == "" )
+		talkAnim = ANIM_OG_SITTING_TALK
+
+	if ( idleAnim == "" )
+		idleAnim = ANIM_OG_SITTING_IDLE
+
+	Training_NPC_Talks( npc, voScriptAlias, idleRef, talkAnim, idleAnim, useBlend )
+}
+
+void function Training_NPC_Talks_Leaning( entity npc, string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	if ( talkAnim == "" )
+		talkAnim = ANIM_OG_LEANING_TALK
+
+	if ( idleAnim == "" )
+		idleAnim = ANIM_OG_LEANING_IDLE
+
+	Training_NPC_Talks( npc, voScriptAlias, idleRef, talkAnim, idleAnim, useBlend )
+}
+
+void function Training_NPC_Talks( entity npc, string voScriptAlias, entity idleRef, string talkAnim = "", string idleAnim = "", bool useBlend = false )
+{
+	npc.EndSignal( "OnDestroy" )
+	npc.EndSignal( "NPC_NewCommand" )
+
+	if ( talkAnim == "" )
+		talkAnim = ANIM_OG_STANDING_TALK
+
+	if ( idleAnim == "" )
+		idleAnim = ANIM_OG_STANDING_IDLE
+
+	npc.Anim_Stop()
+	if ( useBlend )
+		thread PlayAnim( npc, talkAnim, idleRef )
+	else
+		thread PlayAnim( npc, talkAnim, idleRef, null, 0.0 )
+
+	OnThreadEnd(
+	function() : ( npc, idleRef, idleAnim, useBlend )
+		{
+			if ( IsValid( npc ) )
+				Training_NPC_Idles( npc, idleRef, idleAnim, useBlend )
+		}
+	)
+
+	waitthread PlayDialogue( voScriptAlias, npc )
+}
+
+void function Training_NPC_Idles_Sitting( entity npc, entity idleRef, string anim = "", bool useBlend = false )
+{
+	if ( anim == "" )
+		anim = ANIM_OG_SITTING_IDLE
+
+	Training_NPC_Idles( npc, idleRef, anim, useBlend )
+}
+
+void function Training_NPC_Idles_SittingAndTalking( entity npc, entity idleRef, string anim = "", bool useBlend = false )
+{
+	if ( anim == "" )
+		anim = ANIM_OG_SITTING_TALK
+
+	Training_NPC_Idles( npc, idleRef, anim, useBlend )
+}
+
+void function Training_NPC_Idles_Talking( entity npc, entity idleRef, string anim = "", bool useBlend = false )
+{
+	if ( anim == "" )
+		anim = ANIM_OG_STANDING_TALK
+
+	thread Training_NPC_Idles( npc, idleRef, anim, useBlend )
+}
+
+void function Training_NPC_Idles( entity npc, entity idleRef, string anim = "", bool useBlend = false )
+{
+	npc.Signal( "NPC_NewCommand" )
+
+	if ( anim == "" )
+		anim = ANIM_OG_STANDING_IDLE
+
+	npc.Anim_Stop()
+
+	if ( useBlend )
+		thread PlayAnim( npc, anim, idleRef )
+	else
+		thread PlayAnim( npc, anim, idleRef, null, 0.0 )
+}
+
+void function Training_NPC_ScriptedAnim( entity npc, entity idleRef, string anim, bool useBlend = false )
+{
+	npc.Signal( "NPC_NewCommand" )
+
+	npc.Anim_Stop()
+
+	if ( useBlend )
+		PlayAnim( npc, anim, idleRef )
+	else
+		PlayAnim( npc, anim, idleRef, null, 0.0 )
+}
+
+void function Training_OG_Moves_ToSitting( entity moveToRef, string destAnim = "", float moveTimeOverride = -1 )
+{
+	if ( destAnim == "" )
+		destAnim = ANIM_OG_SITTING_IDLE
+
+	Training_OG_Moves( moveToRef, destAnim, moveTimeOverride, true )
+}
+
+void function Training_OG_Moves( entity moveToRef, string destAnim = "", float moveTimeOverride = -1, bool destAnim_isSitting = false )
+{
+	entity og = GetOGPilot()
+	og.Signal( "NPC_NewCommand" )
+
+	int ogAttachIdx = og.LookupAttachment( "CHESTFOCUS" )
+	vector startOrigin = og.GetAttachmentOrigin( ogAttachIdx )
+
+	const vector standingOffset = <0, 0, 42>
+	const vector sittingOffset = <0, 0, 20>
+	vector destHeightOffset 	= destAnim_isSitting ? sittingOffset : standingOffset
+	vector endOrigin = moveToRef.GetOrigin() + destHeightOffset
+
+	og.Freeze()
+
+	file.ogPilot = null
+
+	if ( IsValid( og ) )
+	{
+		og.NotSolid()
+		DissolveGhost( og )
+	}
+
+	entity newOG = Training_SpawnOGPilot( moveToRef )
+	newOG.Hide()
+
+	entity mover = CreateScriptMover( startOrigin, <0,0,0> )
+	int moverAttachIdx = mover.LookupAttachment( "REF" )
+	EmitSoundOnEntity( mover, "og_dissolve_trail" )
+	file.ogPathMover = mover
+
+	newOG.EndSignal( "OnDestroy" )
+	mover.EndSignal( "OnDestroy" )
+
+	OnThreadEnd(
+	function() : ( mover, newOG, moveToRef, destAnim_isSitting, destAnim, ogAttachIdx )
+		{
+			if ( IsValid( mover ) )
+			{
+				StopSoundOnEntity( mover, "og_dissolve_trail" )
+				mover.Destroy()
+				file.ogPathMover = null
+			}
+
+			if ( IsValid( newOG ) )
+			{
+				StartParticleEffectOnEntity( newOG, GetParticleSystemIndex( GHOST_FLASH_EFFECT ), FX_PATTACH_POINT, ogAttachIdx )
+				newOG.Show()
+
+				if ( destAnim_isSitting )
+					Training_OG_Idles_Sitting( moveToRef, destAnim )
+				else
+					Training_OG_Idles( moveToRef, destAnim )
+			}
+		}
+	)
+
+	StartParticleEffectOnEntity( mover, GetParticleSystemIndex( GHOST_TRAIL_EFFECT ), FX_PATTACH_POINT_FOLLOW, moverAttachIdx )
+	StartParticleEffectOnEntity( mover, GetParticleSystemIndex( GHOST_FLASH_EFFECT ), FX_PATTACH_POINT, moverAttachIdx )
+	wait 0.5
+
+	float moveSpeed = 1350.0
+	float moveDist = Distance( startOrigin, endOrigin )
+	float moveTime = moveDist / moveSpeed
+	if ( moveTimeOverride > 0 )
+		moveTime = moveTimeOverride
+
+	float accel = moveTime * 0.1
+	float decel = moveTime * 0.1
+	mover.NonPhysicsMoveTo( endOrigin, moveTime, accel, decel )
+	wait moveTime - 0.1
+
+	EmitSoundAtPosition( TEAM_UNASSIGNED, endOrigin, "PathHologram_Materialized_training" )
+	StartParticleEffectOnEntity( mover, GetParticleSystemIndex( GHOST_FLASH_EFFECT ), FX_PATTACH_POINT, moverAttachIdx )
+	wait 0.1
+}
+
+entity function TeleportOG( string entName )
+{
+	Assert( IsValid( file.ogPilot ) )
+
+	file.ogPilot.Signal( "NPC_NewCommand" )
+	file.ogPilot.Anim_Stop()
+
+	entity teleportSpot = GetEntByScriptName( entName )
+
+	vector org = teleportSpot.GetOrigin()
+	vector ang = teleportSpot.GetAngles()
+	file.ogPilot.SetOrigin( org )
+	file.ogPilot.SetAngles( ang )
+
+	return teleportSpot
+}
+
+void function NPC_DisableArrivals( entity npc )
+{
+	printt( "disabling arrivals" )
+	npc.EnableNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+}
+
+void function NPC_EnableArrivals( entity npc )
+{
+	printt( "enabling arrivals" )
+	npc.DisableNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+}
+
+
+void function PlayerAndOGTeleport_Fancy( entity player, vector destPos, string ogTeleportSpotName, vector destAng = < -1, -1, -1 > )
+{
+	EndSignal( player, "OnDeath" )
+	thread FancyTeleport_EffectsAndSound( player, destPos )
+
+	player.WaitSignal( "FancyTeleportStart" )
+
+	entity ogTeleportSpot = TeleportOG( ogTeleportSpotName )
+	Training_OG_Idles_Sitting( ogTeleportSpot )
+
+	MakeInvincible( player )
+	WaitEndFrame() // player will take damage from random hazard triggers otherwise
+
+	player.SetOrigin( destPos )
+	if ( destAng != < -1, -1, -1 > )
+		player.SetAngles( destAng )
+
+	ClearInvincible( player )
+}
+
+void function FancyTeleport_EffectsAndSound( entity player, vector teleportPos )
+{
+	EndSignal( player, "OnDeath" )
+
+	float statusEffect_severity = 2.5
+	float statusEffect_totalDuration = 0.8
+	float statusEffect_easeOutTime = 0.1
+	StatusEffect_AddTimed( player, eStatusEffect.timeshift_visual_effect, statusEffect_severity, statusEffect_totalDuration, statusEffect_easeOutTime )
+
+	wait 0.1
+
+	Remote_CallFunction_Replay( player, "ScriptCallback_PodTransition_PlayerScreenFX" )
+
+	EmitSoundOnEntity( player, "Timeshift_Scr_DeviceShift2Present" )
+
+	wait 0.25  // let screen FX fade screen
+
+	player.Signal( "FancyTeleportStart" )
+
+	//wait holdTime - 0.1
+
+	wait 0.5  // let white screen fade
+
+	EmitSoundOnEntity( player, "training_scr_zen_player_fall" )
+
+	wait 0.2  // let screen clear before pulsing
+
+	entity pulseFXHandle = PlayFX( FX_FANCY_TELEPORT_ENV_PULSE, teleportPos, <0,0,0> )
+	EffectSetControlPointVector( pulseFXHandle, 1, <2.5,50,0> )
+	thread KillFX_Delayed( pulseFXHandle, 0.5 )
+}
+
+entity function WaitForPlayerActiveWeapon( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	entity weapon = null
+	while ( !weapon )
+	{
+		WaitFrame()
+		weapon = player.GetActiveWeapon()
+	}
+
+	return weapon
+}
+
+
+void function GhostRecorder_RepeatUntilFlag( entity player, string endFlag, entity animRef, asset recordedAnim, float extraRepeatDelay = 0.0, bool silentDissolve = false )
+{
+	EndSignal( player, "OnDestroy" )
+	EndSignal( level, "StopRepeatingGhostRecorder" )
+
+	if ( Flag( endFlag ) )
+		return
+	FlagEnd( endFlag )
+
+	string dissolveSFX = "object_dissolve_training"
+	if ( silentDissolve )
+		dissolveSFX = ""
+
+	table<int,entity> t = {}
+	t[0] <- null
+
+	OnThreadEnd(
+	function() : ( t, dissolveSFX )
+		{
+			if ( !t.len() )
+				return
+
+			entity ghost = t[0]
+
+			if ( IsValid( ghost ) )
+			{
+				StopSoundOnEntity( ghost, "PathHologram_Sustain_Loop_3P" )
+				DissolveGhost( ghost, dissolveSFX )
+			}
+		}
+	)
+
+	var rec = LoadRecordedAnimation( recordedAnim )
+	float duration = GetRecordedAnimationDuration( rec )
+
+	const float ghostFadeTime = 1.2
+
+	while ( 1 )
+	{
+		entity ghost = CreateGhost( animRef.GetOrigin() )
+		t[0] = ghost
+
+		EmitSoundOnEntity( ghost, "PathHologram_Sustain_Loop_3P" )
+
+		ghost.PlayRecordedAnimation( rec, <0,0,0>, <0,0,0>, DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME, animRef )
+		wait duration - ghostFadeTime
+
+		DissolveGhost( ghost, dissolveSFX )
+
+		wait ghostFadeTime
+		wait extraRepeatDelay
+	}
+}
+
+void function Training_TeleportEffect( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	player.MovementDisable()
+
+	OnThreadEnd(
+	function() : ( player )
+		{
+			if ( IsValid( player ) )
+				player.MovementEnable()
+		}
+	)
+
+	float fadeTime = 0.3
+	float holdTime = 0.5
+
+	ScreenFade( player, 255, 255, 255, 254, fadeTime, holdTime, FFADE_IN | FFADE_PURGE )
+	EmitSoundOnEntity( player, "NPE_VisualImpair" )
+	wait fadeTime
+	wait holdTime
+	FadeOutSoundOnEntity( player, "NPE_VisualImpair", fadeTime )
+}
+
+void function TakeAmmoFromPlayerASAP( entity player )
+{
+	player.EndSignal( "OnDestroy" )
+
+	entity weapon = WaitForPlayerActiveWeapon( player )
+
+	array<entity> weapons = player.GetMainWeapons()
+
+	foreach ( weapon in weapons )
+	{
+		weapon.SetWeaponPrimaryAmmoCount( 0 )
+		weapon.SetWeaponPrimaryClipCount( 0 )
+	}
+
+	// take offhand weapons player may have collected
+	array<entity> offhands = player.GetOffhandWeapons()
+	foreach ( index, weapon in clone offhands )
+		player.TakeOffhandWeapon( index )
+}
+
+void function Training_WeaponPickups_Init( entity player )
+{
+	Assert( Flag( "EntitiesDidLoad" ) )
+
+	LeveledScriptedWeapons leveledScriptedWeapons = GetAllLeveledScriptWeapons()
+
+	foreach ( ent in leveledScriptedWeapons.infoTargets )
+		thread Training_RecreateWeaponPickup_Think( ent, player )
+}
+
+void function Training_SetWeaponPickupsEmptyAmmo()
+{
+	file.weaponPickupsHaveAmmo = false
+
+	LeveledScriptedWeapons leveledScriptedWeapons = GetAllLeveledScriptWeapons()
+	foreach ( ent in leveledScriptedWeapons.infoTargets )
+	{
+		// fix for player picking up a weapon right before calling this- attachedEnt is empty because it hasn't been recreated yet
+		// - actual fix is to thread, wait for attachedEnts to get the recreated weapon again, and timeout, but going with less risk for now
+		if ( !ent.e.attachedEnts.len() )
+			continue
+
+		entity weaponEnt = ent.e.attachedEnts[0]
+		if ( !IsValid( weaponEnt ) )
+			continue
+
+		weaponEnt.SetWeaponPrimaryAmmoCount( 0 )
+		weaponEnt.SetWeaponPrimaryClipCount( 0 )
+	}
+}
+
+void function Training_SetWeaponPickupsFullAmmo()
+{
+	file.weaponPickupsHaveAmmo = true
+
+	LeveledScriptedWeapons leveledScriptedWeapons = GetAllLeveledScriptWeapons()
+	foreach ( ent in leveledScriptedWeapons.infoTargets )
+	{
+		// fix for player picking up a weapon right before calling this- attachedEnt is empty because it hasn't been recreated yet
+		// - actual fix is to thread, wait for attachedEnts to get the recreated weapon again, and timeout, but going with less risk for now
+		if ( !ent.e.attachedEnts.len() )
+			continue
+
+		entity weaponEnt = ent.e.attachedEnts[0]
+		if( !IsValid( weaponEnt ) )
+			continue
+
+		string weaponClass = weaponEnt.GetWeaponClassName()
+		int defaultTotal 	= GetWeaponInfoFileKeyField_GlobalInt( weaponClass, "ammo_default_total" )
+		int defaultMag 		= GetWeaponInfoFileKeyField_GlobalInt( weaponClass, "ammo_clip_size" )
+
+		weaponEnt.SetWeaponPrimaryAmmoCount( defaultTotal )
+	}
+}
+
+void function Training_RecreateWeaponPickup_Think( entity ent, entity player )
+{
+	EndSignal( player, "OnDestroy" )
+	EndSignal( ent, "OnDestroy" )
+
+	const float MATCHING_PICKUP_DIST = 0.5
+	const float NEARBY_SIMILAR_DIST = 200.0
+
+	string pickupEntWeaponClass = ent.GetValueForKey( "script_weapon" )
+
+	while ( ent.e.attachedEnts.len() && IsValid( ent.e.attachedEnts[0] ) )
+	{
+		entity weaponEnt = ent.e.attachedEnts[0]
+
+		while ( IsValid( weaponEnt ) && !weaponEnt.GetOwner() )
+			wait 0.1
+
+		// this is the most reliable way to get a good push vector for if we need to kick another weapon out (pickup ent angles are often not optimal)
+		vector playerPos_onPickup = player.GetOrigin()
+		vector vecToPlayer_whenPickedUp = Normalize( playerPos_onPickup - ent.GetOrigin() )
+
+		ent.e.attachedEnts.remove( 0 )
+
+		wait 2.2  // don't respawn it right away
+
+		bool oldWeapon_similarPickupNearby = false
+		bool pickupEnt_similarPickupNearby = false
+
+		// previous player weapon may be here after swapping
+		array<entity> allPickups = GetWeaponArray( true )
+		entity oldWeapon
+		foreach ( pickup in allPickups )
+		{
+			float distToThisPickup = Distance( pickup.GetOrigin(), ent.GetOrigin() )
+			if ( distToThisPickup <= MATCHING_PICKUP_DIST )
+			{
+				oldWeapon = pickup
+				break
+			}
+		}
+
+		if ( IsValid( oldWeapon ) )
+		{
+			foreach ( pickup in allPickups )
+			{
+				if ( oldWeapon == pickup )
+					continue
+
+				float distToThisPickup = Distance( pickup.GetOrigin(), ent.GetOrigin() )
+				if ( distToThisPickup <= NEARBY_SIMILAR_DIST )
+				{
+					string pickupWeaponClass = pickup.GetWeaponClassName()
+
+					if ( pickupWeaponClass == oldWeapon.GetWeaponClassName() && !oldWeapon_similarPickupNearby )
+					{
+						//printt( "found similar pickup nearby to one the player dropped:", pickupWeaponClass )
+						oldWeapon_similarPickupNearby = true
+					}
+
+					if ( pickupWeaponClass == pickupEntWeaponClass && !pickupEnt_similarPickupNearby )
+					{
+						//printt( "found similar pickup nearby to one that would be recreated:", pickupWeaponClass )
+						pickupEnt_similarPickupNearby = true
+					}
+				}
+			}
+		}
+
+		bool recreatePickup = true
+		bool destroyOldWeapon = false
+		if ( IsValid( oldWeapon ) )
+		{
+			if ( oldWeapon.GetWeaponClassName() == pickupEntWeaponClass )
+			{
+				printt( "old weapon that is here is the same kind of weapon as we would spawn, so don't recreate:", pickupEntWeaponClass )
+				recreatePickup = false  // old weapon that is here is the same kind of weapon as we would spawn, so don't recreate
+			}
+
+			if ( oldWeapon_similarPickupNearby )
+			{
+				printt( "Old weapon can be destroyed, because a similar pickup is nearby:", oldWeapon.GetWeaponClassName() )
+				destroyOldWeapon = true
+			}
+
+			if ( !oldWeapon_similarPickupNearby && pickupEnt_similarPickupNearby )
+			{
+				printt( "old weapon is unique to this area and pickup ent has a similar pickup nearby, so don't recreate pickup ent. Old weapon:", oldWeapon.GetWeaponClassName(), "/ pickup ent class:", pickupEntWeaponClass )
+				recreatePickup = false
+			}
+		}
+
+		if ( recreatePickup )
+		{
+			if ( IsValid( oldWeapon ) )
+			{
+				if ( destroyOldWeapon )
+				{
+					printt( "destroying old weapon because similar pickup is nearby:", oldWeapon.GetWeaponClassName() )
+					oldWeapon.Destroy()
+				}
+				else
+				{
+					MoveOldWeapon( ent, oldWeapon, vecToPlayer_whenPickedUp )  // kick the old weapon out of this spot
+				}
+			}
+
+			// cover respawn with a flash effect
+			EmitSoundAtPosition( TEAM_UNASSIGNED, ent.GetOrigin(), "training_scr_rack_weapon_appear" )
+			StartParticleEffectInWorld( GetParticleSystemIndex( GHOST_FLASH_EFFECT ), ent.GetOrigin(), ent.GetAngles() )
+			CreateScriptWeapon( ent )
+
+			// defensive checks
+			if ( !ent.e.attachedEnts.len() || !IsValid( ent.e.attachedEnts[0] ) )
+			{
+				printt( "WARNING! Recreated script pickup FAILED to recreate:", pickupEntWeaponClass, "on ent", ent )
+				continue
+			}
+
+			entity recreatedPickup = ent.e.attachedEnts[0]
+			printt( "training: recreated weapon pickup:", pickupEntWeaponClass, "by spawning:", recreatedPickup )
+
+			if ( !file.weaponPickupsHaveAmmo )
+			{
+				recreatedPickup.SetWeaponPrimaryAmmoCount( 0 )
+				recreatedPickup.SetWeaponPrimaryClipCount( 0 )
+			}
+		}
+		else
+		{
+			if ( IsValid( oldWeapon ) )
+				ent.e.attachedEnts.append( oldWeapon )
+		}
+	}
+
+	printt( "WARNING- Stopping think on pickupEntWeapon:", pickupEntWeaponClass )
+}
+
+void function MoveOldWeapon( entity pickupEnt, entity oldWeapon, vector pushVec = <0,0,0> )
+{
+	// recreate weapon as unconstrained so we can physics push it
+	entity recreatedOldWeapon = Training_RecreatePlayerWeaponPickup( oldWeapon )
+	string recreatedClassName = recreatedOldWeapon.GetWeaponClassName()
+
+	float velocityScalar = 300.0
+
+	var hasSubClass = GetWeaponInfoFileKeyField_Global( recreatedClassName, "weaponSubClass" )
+	if ( hasSubClass )
+	{
+		string weaponSubClass = GetWeaponInfoFileKeyField_GlobalString( recreatedClassName, "weaponSubClass" )
+
+		switch ( weaponSubClass )
+		{
+			case "offhand":
+			case "pistol":
+				velocityScalar = 200
+				break
+
+			case "smg":
+				velocityScalar = 300
+				break
+
+			case "rifle":
+				velocityScalar = 400
+				break
+
+			case "lmg":
+			case "at":
+				velocityScalar = 500
+				break
+		}
+	}
+
+	if ( pushVec == <0,0,0> )
+		pushVec = AnglesToForward( pickupEnt.GetAngles() )
+
+	//vector pushAng = VectorToAngles( pushVec )
+	//vector addVec = AnglesToUp( pushAng ) * (velocityScalar * 0.2)
+	//pushVec += addVec
+	pushVec += <0,0,1>
+
+	printt( "moving old weapon:", oldWeapon.GetWeaponClassName(), "with velocity scalar:", velocityScalar )
+	recreatedOldWeapon.SetVelocity( pushVec * velocityScalar )
+}
+
+entity function Training_RecreatePlayerWeaponPickup( entity oldWeapon )
+{
+	if ( file.scriptCreatedWeaponPickups.len() >= MAX_RECREATED_OLD_WEAPONS )
+	{
+		entity cleanupWeapon = file.scriptCreatedWeaponPickups[0]
+
+		if ( IsValid( cleanupWeapon ) )
+			cleanupWeapon.Destroy()
+
+		file.scriptCreatedWeaponPickups.remove( 0 )
+	}
+
+	string oldWeaponClass = oldWeapon.GetWeaponClassName()
+
+	entity weapon = CreateWeaponEntityByNameWithPhysics( oldWeaponClass, oldWeapon.GetOrigin(), oldWeapon.GetAngles() )
+	weapon.SetVelocity( <0,0,0> )
+
+	SetTargetName( weapon, "_old_player_weapon_" + oldWeaponClass )
+	weapon.kv.fadedist = -1
+
+	array<string> existingMods = oldWeapon.GetMods()
+	weapon.SetMods( existingMods )
+
+	bool doMarkAsLoadoutPickup = false
+	if ( doMarkAsLoadoutPickup )
+		weapon.MarkAsLoadoutPickup()
+
+	HighlightWeapon( weapon )
+
+	oldWeapon.Destroy()
+
+	file.scriptCreatedWeaponPickups.append( weapon )
+
+	return weapon
+}
+
+
+void function Training_WeaponRacks_SetSolidity( bool doSolid )
+{
+	array<entity> racks = GetEntArrayByScriptName( "ineedguns_racks" )
+
+	foreach ( rack in racks )
+	{
+		if ( doSolid )
+			rack.Solid()
+		else
+			rack.NotSolid()
+	}
+}
+
+
+bool function GetAutosprintEnabled()
+{
+	int autosprintSetting = GetConVarInt( AUTOSPRINT_CONVAR_NAME )
+	bool autoSprintEnabled = autosprintSetting > 0 && autosprintSetting < 3  // 0 = none, 3 = titans only
+	return autoSprintEnabled
+}
+
+
+void function EmitSoundOnEntity_Delayed( entity ent, string alias, float delay )
+{
+	ent.EndSignal( "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	EmitSoundOnEntity( ent, alias )
+}
+
+void function PlayFXOnEntity_Delayed( entity player, asset fxAsset, entity ent, float delay )
+{
+	player.EndSignal( "OnDestroy" )
+	ent.EndSignal( "OnDeath" )
+
+	wait delay
+
+	PlayFXOnEntity( fxAsset, ent )
+}
+
+void function KillFX_Delayed( entity fxHandle, float delay )
+{
+	fxHandle.EndSignal( "OnDestroy" )
+
+	if ( delay > 0.0 )
+		wait delay
+
+	KillFX( fxHandle )
+}
+
+void function KillFX( entity fxHandle )
+{
+	if ( !IsValid_ThisFrame( fxHandle ) )
+		return
+
+	fxHandle.SetStopType( "DestroyImmediately" )
+	fxHandle.ClearParent()
+	fxHandle.Destroy()
+}
+
+void function KillFXWithEndcap( entity fxHandle, float killDelay = 1.0 )
+{
+	if ( !IsValid_ThisFrame( fxHandle ) )
+		return
+
+	EffectStop( fxHandle )
+	wait killDelay
+
+	if ( !IsValid_ThisFrame( fxHandle ) )
+		return
+
+	fxHandle.ClearParent()
+	fxHandle.Destroy()
+}
+
+
+void function FlagSetDelayed( string setFlag, float delay )
+{
+	thread FlagSetDelayed_Think( setFlag, delay )
+}
+
+void function FlagSetDelayed_Think( string setFlag, float delay )
+{
+	EndSignal( level, "OnDestroy" )
+
+	if ( delay > 0 )
+		wait delay
+
+	FlagSet( setFlag )
+}
+
+
+void function Training_PlayerQuickdeathSFX( entity player )
+{
+	EndSignal( player, "OnDestroy" )
+
+	while ( 1 )
+	{
+		WaitSignal( player, "QuickDeath" )
+		EmitSoundOnEntity( player, "training_scr_zen_player_fall" )
+	}
+}
+
+
+void function Training_EnvArtColorCorrection_SetEnabled( bool isEnabled )
+{
+	Assert( IsValid( file.envArt_colorCorrectionEnt ), "Called too early?" )
+
+	string setEnabledStr = "Disable"
+	if ( isEnabled)
+		setEnabledStr = "Enable"
+
+	EntFireByHandle( file.envArt_colorCorrectionEnt, setEnabledStr, "", 0, null, null )
+}
+
+
+void function SetDoF_Hangar( entity player )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetNearDepth", 	0, 18 )
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetFarDepth", 	450, 1250 )
+}
+
+void function SetDoF_Default( entity player )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetNearDepthToDefault" )
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetFarDepthToDefault" )
+}
+
+void function RackDoF_NearDepth( entity player, float nearDepthStart, float nearDepthEnd, float rackTime )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetNearDepth", 	nearDepthStart, nearDepthEnd, rackTime )
+}
+
+void function RackDOF_NearDepth_ToDefault( entity player, float duration )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetNearDepthToDefault", duration )
+}
+
+void function RackDoF_FarDepth( entity player, float farDepthStart, float farDepthEnd, float rackTime )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_DoF_SetFarDepth", 	farDepthStart, farDepthEnd, rackTime )
+}
+
+void function SimpleScreenShake( entity player, float duration, float amplitude, float blurMaxIntensity = 0.75 )
+{
+	Remote_CallFunction_Replay( player, "ScriptCallback_SimpleScreenShake", duration, amplitude, blurMaxIntensity )
+}
+
+void function SetWeaponHUDEnabled( entity player, bool setEnabled )
+{
+	file.displayWeaponHUD = setEnabled
+	Remote_CallFunction_Replay( player, "ScriptCallback_SetWeaponHUDEnabled", setEnabled )
+}
+
+
+
+// ---------------------
+// ----- SKIT GUYS -----
+// ---------------------
+SkitGuyInfo function AddSkitGuy_Manually( string name, entity guy )
+{
+	if ( SkitGuyExists( name ) )
+		DeleteSkitGuy( GetSkitGuyInfo_ByName( name ) )
+
+	SkitGuyInfo info
+	info.id 		= file.skitguys.len()
+	info.guy 		= guy
+	info.name 		= name
+
+	file.skitguys.append( info )
+
+	return info
+}
+
+SkitGuyInfo function SpawnSkitGuy( string name, string anim, vector origin, vector angles, int team = TEAM_IMC, string aiSettings = "", string weapon = "mp_weapon_semipistol", bool isRunner = false )
+{
+	if ( SkitGuyExists( name ) )
+		DeleteSkitGuy( GetSkitGuyInfo_ByName( name ) )
+
+	string guyType = "grunt"
+	if ( name.find( "marvin" ) != null )
+		guyType = "marvin"
+
+	// spawn the guy
+	entity guy
+	if ( guyType == "marvin" )
+	{
+		Assert( !isRunner, "Marvins don't run!" )
+
+		guy = CreateEntity( "npc_marvin" )
+
+		DispatchSpawn( guy )
+
+		SetTeam( guy, TEAM_SPECTATOR )
+		guy.SetNPCMoveSpeedScale( 0.6 )
+
+		//TakeAllJobs( guy )
+	}
+	else
+	{
+		guy = CreateSoldier( team, <0,0,0>, <0,0,0> )  // spawn the guy at worldspawn to avoid "npc spawned in solid" red text`
+		SetSpawnOption_Weapon( guy, weapon )
+		if ( aiSettings != "" )
+			SetSpawnOption_AISettings( guy, aiSettings )
+
+		if ( isRunner )
+			guy.kv.alwaysAlert = 1
+
+		DispatchSpawn( guy )
+	}
+
+	guy.SetTitle( "" )
+
+	entity ref = CreateOwnedScriptMover( guy )
+	ref.SetOrigin( origin )
+	ref.SetAngles( angles )
+
+	guy.SetOrigin( ref.GetOrigin() )
+	guy.SetAngles( ref.GetAngles() )
+
+	MakeInvincible( guy )
+	guy.SetEfficientMode( true )
+	guy.EnableNPCFlag( NPC_IGNORE_ALL | NPC_DISABLE_SENSING )
+	guy.DisableNPCFlag( NPC_ALLOW_PATROL | NPC_ALLOW_INVESTIGATE | NPC_ALLOW_FLEE | NPC_ALLOW_HAND_SIGNALS )
+
+	SkitGuyInfo info
+	info.id 		= file.skitguys.len()
+	info.guy 		= guy
+	info.skitRef 	= ref
+	info.skitAnim 	= anim
+	info.name 		= name
+
+	file.skitguys.append( info )
+
+	return info
+}
+
+void function SpawnSkitGuy_AndRun( string name, array<Point> path, float moveSpeedScale, int team, string aiSettings = "", string weaponName = "" )
+{
+	SkitGuyInfo runnerInfo
+	runnerInfo = SpawnSkitGuy( name, "", path[0].origin, path[0].angles, team, aiSettings, weaponName, true )
+
+	entity runner = runnerInfo.guy
+	EndSignal( runner, "OnDestroy" )
+
+	OnThreadEnd(
+	function() : ( runnerInfo )
+		{
+			DeleteSkitGuy( runnerInfo )
+		}
+	)
+
+	waitthread ScriptedPath_Run( runnerInfo, path, moveSpeedScale )
+}
+
+void function SpawnSkitGuy_AndRunForever( string name, array<Point> path, float moveSpeedScale, int team, string aiSettings = "", string weaponName = "" )
+{
+	SkitGuyInfo runnerInfo
+	while ( 1 )
+	{
+		runnerInfo = SpawnSkitGuy( name, "", path[0].origin, path[0].angles, team, aiSettings, weaponName )
+		waitthread ScriptedPath_Run( runnerInfo, path, moveSpeedScale )
+	}
+}
+
+void function SkitGuy_PlayAnim( SkitGuyInfo info, float skipAheadTime = 0 )
+{
+	Assert( info.skitAnim != "" )
+	Assert( IsValid( info.skitRef ) )
+
+	entity guy = info.guy
+
+	thread PlayAnim( guy, info.skitAnim, info.skitRef, null, 0.0, skipAheadTime )
+}
+
+bool function SkitGuyExists( string name )
+{
+	foreach ( info in file.skitguys )
+	{
+		if ( info.name == name )
+			return true
+	}
+
+	return false
+}
+
+SkitGuyInfo function GetSkitGuyInfo_ByName( string guyName )
+{
+	SkitGuyInfo thisInfo
+	foreach ( info in file.skitguys )
+	{
+		if ( info.name == guyName )
+		{
+			thisInfo = info
+			return thisInfo
+		}
+	}
+
+	Assert( false, "couldn't find skit guy info by name: " + guyName )
+	unreachable
+}
+
+void function DeleteAllSkitGuys()
+{
+	array<string> deleteNames = []
+
+	foreach ( skitInfo in file.skitguys )
+		deleteNames.append( skitInfo.name )
+
+	foreach ( name in deleteNames )
+	{
+		if ( !SkitGuyExists( name ) )
+			continue
+
+		SkitGuyInfo deleteInfo = GetSkitGuyInfo_ByName( name )
+		DeleteSkitGuy( deleteInfo )
+	}
+}
+
+void function DeleteSkitGuy( SkitGuyInfo info )
+{
+	KillSkitGuy( info )
+
+	int removeIdx = -1
+	foreach ( idx, guyInfo in file.skitguys )
+	{
+		if ( guyInfo.id == info.id )
+		{
+			removeIdx = idx
+			break
+		}
+	}
+
+	if ( removeIdx == -1 )
+	{
+		printt( "WARNING: SkitGuy was already deleted!" )
+		return
+	}
+
+
+	file.skitguys.remove( removeIdx )
+}
+
+void function KillSkitGuy( SkitGuyInfo info )
+{
+	entity guy = info.guy
+	entity skitRef = info.skitRef
+
+	if ( IsValid( skitRef ) )
+		skitRef.Destroy()
+
+	info.skitRef = null
+
+	if ( IsAlive( guy ) )
+	{
+		guy.Anim_Stop()
+		ClearInvincible( guy )
+	}
+
+	if ( IsValid( guy ) )
+		guy.Destroy()
+
+	info.guy = null
+}
+
+#if DEV
+string function NudgeSkitGuy( string name, float offsetX, float offsetY = 0.0, float offsetZ = 0.0 )
+{
+	if ( !SkitGuyExists( name ) )
+	{
+		return "WARNING: SKIT GUY NAME NOT RECOGNIZED: " + name
+	}
+
+	SkitGuyInfo info = GetSkitGuyInfo_ByName( name )
+	entity guy = info.guy
+	entity skitRef 	= info.skitRef
+	string name 	= info.name
+
+	vector offset = <offsetX, offsetY, offsetZ>
+
+	if ( IsValid( skitRef ) )
+		skitRef.SetOrigin( skitRef.GetOrigin() + offset )
+	else
+		guy.SetOrigin( guy.GetOrigin() + offset )
+
+	if ( info.skitAnim != "" )
+		SkitGuy_PlayAnim( info )
+
+	printt( "NUDGED:")
+	return PrintSkitGuy( info )
+}
+
+string function PrintSkitGuy( SkitGuyInfo info )
+{
+	entity guy 		= info.guy
+	entity skitRef 	= info.skitRef
+	string name 	= info.name
+
+	string returnStr = name + " origin/angles: " + CreateOriginAnglesString( guy.GetOrigin(), guy.GetAngles() )
+	if ( IsValid( skitRef ) )
+		returnStr = name + " ref origin/angles: " + CreateOriginAnglesString( skitRef.GetOrigin(), skitRef.GetAngles() )
+
+	return returnStr
+}
+#endif //DEV
+
+
+
+// ------------------------------
+// ----- SCRIPTED NPC PATHS -----
+// ------------------------------
+void function ScriptedPath_AddPoint( array<Point> pathpoints, vector origin, vector angles )
+{
+	Point pathpoint
+	pathpoint.origin = origin
+	pathpoint.angles = angles
+
+	pathpoints.append( pathpoint )
+}
+
+void function ScriptedPath_Walk( SkitGuyInfo info, array<Point> path, float moveSpeedScale = 0.8, string idleAnim = "" )
+{
+	NPC_ScriptedPath( SCRIPTED_PATH_WALK, info, path, moveSpeedScale, idleAnim )
+}
+
+void function ScriptedPath_Run( SkitGuyInfo info, array<Point> path, float moveSpeedScale = 1.0, string idleAnim = "" )
+{
+	NPC_ScriptedPath( SCRIPTED_PATH_RUN, info, path, moveSpeedScale, idleAnim )
+}
+
+void function NPC_ScriptedPath( int pathFollowType, SkitGuyInfo info, array<Point> path, float moveSpeedScale = 1.0, string idleAnim = "" )
+{
+	entity guy = info.guy
+
+	guy.EndSignal( "OnDestroy" )
+
+	guy.Anim_Stop()
+
+	guy.EnableNPCMoveFlag( NPCMF_DISABLE_MOVE_TRANSITIONS )
+	guy.EnableNPCMoveFlag( NPCMF_DISABLE_ARRIVALS )
+	guy.SetNPCMoveSpeedScale( moveSpeedScale )
+
+	if ( pathFollowType == SCRIPTED_PATH_RUN )
+		guy.SetAlert()  // change his alert state so he will run
+
+	if ( pathFollowType == SCRIPTED_PATH_WALK )
+		guy.SetMoveAnim( "patrol_walk_bored" )
+
+	string waitSignal = "OnEnterGoalRadius" //"OnFinishedAssault"
+	float pathfindingFailTimeout = 20.0
+
+	guy.SetOrigin( path[0].origin )
+	guy.SetAngles( path[0].angles )
+
+	for ( int i = 1; i < path.len(); i++ )
+	{
+		Point pathpoint = path[i]
+		float goalradius = 64.0  // MINIMUM
+		//guy.DisableArrivalOnce( true )  // always want arrivals disabled because they are blended from run anim, not walking
+
+		guy.AssaultPoint( pathpoint.origin )
+		guy.AssaultSetGoalRadius( goalradius )
+
+		WaitSignalTimeout( guy, pathfindingFailTimeout, waitSignal )
+
+		if ( Distance( guy.GetOrigin(), pathpoint.origin ) >= goalradius )
+		{
+			printt( guy, " scripted pathfinding stopped, quitting." )
+			break
+		}
+	}
+
+	if ( idleAnim != "" )
+	{
+		guy.DisableBehavior( "Assault" )
+
+		while ( !guy.IsInterruptable() )
+			wait 0.1
+
+		entity ref = CreateOwnedScriptMover( guy )
+		thread PlayAnim( guy, idleAnim, ref, null, 0.4 )
+
+		WaitForever()
+	}
+	else
+	{
+		DeleteSkitGuy( info )
+	}
+}
+
+
+
+// -----------------------------
+// ----- TITAN GROUP SKITS -----
+// -----------------------------
+void function HangarTitanGroup_Init( HangarTitanGroup group )
+{
+	group.rack_ogPos = group.rack.GetOrigin()
+	group.rack_ogAng = group.rack.GetAngles()
+
+	if ( IsValid( group.titan ) )
+	{
+		if ( group.titanSkin == -1 )
+			group.titanSkin = 1
+	}
+
+	if ( group.marvinAnim != "" )
+	{
+		group.marvin = CreatePropDynamic( MARVIN_MODEL )
+		group.marvin.DisableHibernation()
+	}
+
+	if ( group.pilotAnim != "" )
+	{
+		group.pilot = CreatePropDynamic( group.pilotModel )
+		group.pilot.DisableHibernation()
+	}
+
+	HangarTitanGroup_SetMaxSequenceDuration( group )
+
+	group.isInited = true
+}
+
+void function HangarTitanGroup_SetMaxSequenceDuration( HangarTitanGroup group )
+{
+	table<string,entity> sceneActors = {}
+	sceneActors[ group.titanAnim ] <- group.titan
+	sceneActors[ group.rackAnim ] <- group.rack
+	sceneActors[ group.marvinAnim ] <- group.marvin
+
+	if ( IsValid( group.titan ) )
+	{
+		// set titan to use non posed model
+		group.titan.SetModel( BUDDY_MODEL )
+		group.titan.SetSkin( group.titanSkin )
+	}
+
+	float maxDuration = 0
+	foreach ( anim, actor in sceneActors )
+	{
+		if ( !IsValid( actor ) )
+			continue
+
+		float animDuration = actor.GetSequenceDuration( anim )
+		if ( animDuration > maxDuration )
+			maxDuration = animDuration
+	}
+
+	group.sequenceDuration = maxDuration
+
+	if ( IsValid( group.titan ) )
+	{
+		// set titan back to posed anim
+		group.titan.SetModel( BUDDY_MODEL_POSED_NO_ANIMS )
+		//group.titan.SetSkin( group.titanSkin )
+	}
+}
+
+void function HangarTitanGroup_Animate( HangarTitanGroup group, string endFlag = "", float duration = -1, bool doCleanup = true )
+{
+	if ( endFlag != "" )
+		FlagEnd( endFlag )
+
+	Assert( group.isInited, "Need to call HangarTitanGroup_Init on this group before using" )
+
+	entity ref 				= group.ref
+	entity titan 			= group.titan
+	entity rack 			= group.rack
+	entity marvin 			= group.marvin
+	entity pilot 			= group.pilot
+	string titanAnim 		= group.titanAnim
+	string rackAnim 		= group.rackAnim
+	string marvinAnim 		= group.marvinAnim
+	string pilotAnim 		= group.pilotAnim
+	float animInitialTime 	= group.animInitialTime
+
+	EndSignal( rack, "OnDestroy" )
+
+	if ( IsValid( marvin ) )
+		EndSignal( marvin, "OnDestroy")
+
+	if ( IsValid( titan ) )
+	{
+		EndSignal( titan, "OnDestroy" )
+
+		// set titan to use non posed model
+		titan.SetModel( BUDDY_MODEL )
+		titan.SetSkin( group.titanSkin )
+	}
+
+	OnThreadEnd(
+	function() : ( doCleanup, group )
+		{
+			if ( doCleanup )
+				HangarTitanGroup_Cleanup( group )
+		}
+	)
+
+	if ( duration == -1 || group.sequenceDuration < duration )
+		duration = group.sequenceDuration
+
+	thread PlayAnim( rack, rackAnim, ref, null, 0.0, animInitialTime )
+
+	if ( IsValid( titan) )
+		thread PlayAnim( titan, titanAnim, ref, null, 0.0, animInitialTime )
+
+	if ( IsValid( marvin ) )
+		thread PlayAnim( marvin, marvinAnim, ref, null, 0.0, animInitialTime )
+
+	if ( IsValid( pilot ) )
+		thread PlayAnim( pilot, pilotAnim, ref, null, 0.0, animInitialTime )
+
+	wait duration
+}
+
+void function HangarTitanGroup_Cleanup( HangarTitanGroup group )
+{
+	HangarTitanGroup_Reset( group )
+
+	if ( IsValid( group.marvin ) )
+		group.marvin.Destroy()
+
+	if ( IsValid( group.pilot ) )
+		group.pilot.Destroy()
+}
+
+void function HangarTitanGroup_Reset( HangarTitanGroup group )
+{
+	entity titan = group.titan
+	entity rack = group.rack
+
+	if ( IsValid( titan ) )
+	{
+		titan.Anim_Stop()
+		titan.SetModel( BUDDY_MODEL_POSED_NO_ANIMS )
+		//titan.SetSkin( group.titanSkin )
+	}
+
+	if ( IsValid( rack ) )
+	{
+		rack.Anim_Stop()
+		rack.SetOrigin( group.rack_ogPos )
+		rack.SetAngles( group.rack_ogAng )
+	}
+}
+
+
+
+#if DEV
+void function skyboxchange( string tName )
+{
+	entity cam = GetEnt( tName )
+	GetPlayerArray()[0].SetSkyCamera( cam )
+}
+
+
+// ======================================================
+// ============ GHOST RECORDER DEV FUNCTIONS ============
+// ======================================================
+void function wallruntest()
+{
+	entity preWallrunRef = GetEntByScriptName( "basic_movement_wallrun_start_ref" )
+	var rec = LoadRecordedAnimation( $"anim_recording/training_record_zengarden_wallrun.rpak" )
+	file.ogPilot.Anim_Stop()
+	file.ogPilot.PlayRecordedAnimation( rec, <0,0,0>, <0,0,0>, DEFAULT_SCRIPTED_ANIMATION_BLEND_TIME, preWallrunRef )
+}
+
+void function Record_ZenGarden_Wallrun()
+{
+	thread RecordAnimation_Think( "training_record_zengarden_wallrun", "basic_movement_wallrun_start_ref" )
+}
+
+void function Record_ZenGarden_Slide()
+{
+	thread RecordAnimation_Think( "training_record_zengarden_slide", "zengarden_slide_ref" )
+}
+
+void function Record_ZenGarden_DoubleJump()
+{
+	thread RecordAnimation_Think( "training_record_zengarden_doublejump", "zengarden_doublejump_ref" )
+}
+
+void function RecordAnimation_Think( string filename, string refName )
+{
+	entity player = file.player
+	player.Signal( "RecordAnimation_Start" )
+	player.EndSignal( "RecordAnimation_Start" )
+
+	TeleportPlayerAndBT( refName )
+
+	player.EndSignal( "OnDestroy" )
+
+	entity ref = GetEntByScriptName( refName )
+
+	printt( "READY TO RECORD: " + filename )
+
+	//start recording
+	player.WaitSignal( "ButtonPressedAttack" )
+	printt( "RECORDING STARTED" )
+
+	player.StartRecordingAnimation( ref.GetOrigin(), ref.GetAngles() )
+
+	//stop
+	player.WaitSignal( "ButtonPressedAttack" )
+
+	var recording = player.StopRecordingAnimation()
+
+#if PC_PROG
+	SaveRecordedAnimation( recording, filename )
+#endif
+	printt( "STOP RECORD player org/ang:", player.GetOrigin(), player.GetAngles() )
+}
+#endif //DEV