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