Add cl_damage_indicator.gnut from englishclient_mp_common

1 files changed, 951 insertions, 0 deletions

diff --git a/Northstar.Client/mod/scripts/vscripts/client/cl_damage_indicator.gnut b/Northstar.Client/mod/scripts/vscripts/client/cl_damage_indicator.gnut
new file mode 100644
index 00000000..4857c109
--- /dev/null
+++ b/Northstar.Client/mod/scripts/vscripts/client/cl_damage_indicator.gnut
@@ -0,0 +1,951 @@
+untyped
+
+global function ClDamageIndicator_Init
+global function Create_DamageIndicatorHUD
+global function DamageIndicators
+global function GrenadeArrowThink
+global function RumbleForTitanDamage
+
+global function ServerCallback_TitanTookDamage
+global function ServerCallback_PilotTookDamage
+//global function ClientCodeCallback_OnMissileCreation
+global function ClientCodeCallback_CreateGrenadeIndicator
+
+global function DamageIndicatorRui
+
+global function ShowGrenadeArrow
+
+global function SCB_AddGrenadeIndicatorForEntity
+
+const DAMAGEARROW_FADEANIM = "damage_fade"
+const DAMAGEARROW_DURATION = 2.5
+const DAMAGEARROW_SMALL = 0
+const DAMAGEARROW_MEDIUM = 1
+const DAMAGEARROW_LARGE = 2
+
+const float DAMAGEHUD_GRENADE_DEBOUNCE_TIME = 0.4
+const float DAMAGEHUD_GRENADE_DEBOUNCE_TIME_LOWSPEED = 0.15
+const float DAMAGEHUD_GRENADE_DEBOUNCE_TIME_LOWSPEED_VELOCITYCUTOFF = 500.0
+
+
+struct {
+	array<table> damageArrows
+	int currentDamageArrow = 0
+	int numDamageArrows = 16
+	float damageArrowFadeDuration = 1.0
+	float damageArrowTime = 0.0
+	vector damageArrowAngles = < 0.0, 0.0, 0.0 >
+	vector damageArrowPointCenter = < 0.0, 0.0, 0.0 >
+
+	table whizByFX = {
+		small = null,
+		large = null,
+		titan = null,
+	}
+
+	array<table> arrowIncomingAnims = [
+		{ anim = "damage_incoming_small", duration = 1.5 },
+		{ anim = "damage_incoming", duration = 1.75 },
+		{ anim = "damage_incoming_large", duration = 2.00 },
+	]
+
+	int damageIndicatorCount = 0
+} file
+
+function ClDamageIndicator_Init()
+{
+	RegisterSignal( "CriticalHitReceived" )
+
+	AddCreateCallback( "titan_cockpit", DamageArrow_CockpitInit )
+
+	PrecacheParticleSystem( $"P_wpn_grenade_frag_icon" )
+	PrecacheParticleSystem( $"P_wpn_grenade_frag_blue_icon" )
+	PrecacheParticleSystem( $"P_wpn_grenade_smoke_icon" )
+
+	if ( !IsLobby() )
+		AddCallback_EntitiesDidLoad( InitDamageArrows )
+}
+
+function ServerCallback_TitanTookDamage( damage, x, y, z, damageType, damageSourceId, attackerEHandle, eModId, doomedNow, doomedDamage )
+{
+	expect float( damage )
+	expect int( damageType )
+	expect int( damageSourceId )
+	expect bool( doomedNow )
+	expect int( doomedDamage )
+
+	if ( IsWatchingThirdPersonKillReplay() )
+		return
+
+	if ( DebugVictimClientDamageFeedbackIsEnabled() && (damage > 0.0) )
+	{
+		entity attacker = attackerEHandle ? GetHeavyWeightEntityFromEncodedEHandle( attackerEHandle ) : null
+		entity localViewPlayer = GetLocalViewPlayer()
+		bool isHeadShot = (damageType & DF_HEADSHOT) ? true : false
+		bool isKillShot = (damageType & DF_KILLSHOT) ? true : false
+		bool isCritical = (damageType & DF_CRITICAL) ? true : false
+		bool isDoomProtected = (damageType & DF_DOOM_PROTECTED) ? true : false
+		bool isDoomFatality = (damageType & DF_DOOM_FATALITY) ? true : false
+
+		local weaponMods = []
+		if ( eModId != null && eModId in modNameStrings )
+			weaponMods.append( modNameStrings[eModId] )
+
+		string modDesc = ((eModId != null && eModId in modNameStrings) ? (expect string( modNameStrings[eModId] )) : "")
+		DebugTookDamagePrint( localViewPlayer, attacker, damage, damageSourceId, modDesc, isHeadShot, isKillShot, isCritical, doomedNow, doomedDamage, isDoomProtected, isDoomFatality )
+	}
+
+	// It appears to be faster here to create a new thread so other functions called can wait until the frame ends before running.
+	thread TitanTookDamageThread( damage, x, y, z, damageType, damageSourceId, attackerEHandle, eModId, doomedNow, doomedDamage )
+
+	vector damageOrigin = < x, y, z >
+	entity attacker = attackerEHandle ? GetHeavyWeightEntityFromEncodedEHandle( attackerEHandle ) : null
+
+	if ( damageSourceId in clGlobal.onLocalPlayerTookDamageCallback )
+	{
+		foreach ( callback in clGlobal.onLocalPlayerTookDamageCallback[ damageSourceId ] )
+			callback( damage, damageOrigin, damageType, damageSourceId, attacker )
+	}
+}
+
+function TitanTookDamageThread( float damage, x, y, z, int damageType, int damageSourceId, attackerEHandle, eModId, bool doomedNow, int doomedDamage )
+{
+	WaitEndFrame()
+
+	entity attacker = attackerEHandle ? GetHeavyWeightEntityFromEncodedEHandle( attackerEHandle ) : null
+	entity localViewPlayer = GetLocalViewPlayer()
+	entity cockpit = localViewPlayer.GetCockpit()
+
+	if ( cockpit && IsTitanCockpitModelName( cockpit.GetModelName() ) )
+		TitanCockpit_DamageFeedback( localViewPlayer, cockpit, damage, damageType, < x, y, z >, damageSourceId, doomedNow, doomedDamage )
+
+	if ( damage >= DAMAGE_BREAK_MELEE_ASSIST )
+		localViewPlayer.Lunge_ClearTarget()
+
+	if ( damageSourceId != eDamageSourceId.bubble_shield  ) //Don't play Betty OS dialogue if we took damage by bubble shield. We don't have appropriate dialogue for it.
+		Tracker_PlayerAttackedByTarget( localViewPlayer, attacker )
+
+	array<string> weaponMods
+	if ( eModId != null && eModId in modNameStrings )
+		weaponMods.append( expect string( modNameStrings[ eModId ] ) )
+
+	if ( (damage > 0.0) || doomedDamage )
+	{
+		vector damageOrigin = < x, y, z >
+		DamageHistoryStruct damageHistory = StoreDamageHistoryAndUpdate( localViewPlayer, MAX_DAMAGE_HISTORY_TIME, damage, damageOrigin, damageType, damageSourceId, attacker, weaponMods )
+		DamageIndicators( damageHistory, true )
+	}
+
+	entity soul = localViewPlayer.GetTitanSoul()
+	if ( PlayerHasPassive( localViewPlayer, ePassives.PAS_AUTO_EJECT ) ) //TODO: Handle nuclear eject if we ever allow nuclear + auto eject combo again
+	{
+		if ( ShouldPlayAutoEjectAnim( localViewPlayer, soul, doomedNow )  )
+			thread PlayerEjects( localViewPlayer, cockpit )
+
+	}
+
+	if ( damageType & DF_CRITICAL )
+	{
+		localViewPlayer.Signal( "CriticalHitReceived" )
+		EmitSoundOnEntity( localViewPlayer, "titan_damage_crit_3p_vs_1p" )
+	}
+}
+
+bool function ShouldPlayAutoEjectAnim( entity player, entity titanSoul, bool doomedNow )
+{
+	if ( !titanSoul.IsDoomed() )
+		return false
+
+	if ( player.ContextAction_IsActive() && !player.ContextAction_IsBusy() ) //Some other context action, e.g. melee instead of eject. Then again
+		return false
+
+	return true
+}
+
+string function DevBuildAttackerDesc( entity localViewPlayer, entity ent )
+{
+	if ( ent == null )
+		return "<null>"
+
+	if ( localViewPlayer == ent )
+		return ("<self>")
+
+	if ( ent.IsPlayer() )
+		return ("'" + ent.GetPlayerName() + "' " + ent.GetPlayerSettings())
+
+	entity bossPlayer = ent.GetBossPlayer()
+	string ownerString = ((bossPlayer != null) ? (bossPlayer.GetPlayerName() + "'s ") : "")
+
+	var sigName = ent.GetSignifierName()
+	string debugName = (sigName != null) ? expect string( sigName ) : ent.GetClassName()
+	return (ownerString + debugName)
+}
+
+void function DebugTookDamagePrint( entity ornull localViewPlayer, entity attacker, float damage, int damageSourceId, string modDesc, bool isHeadShot, bool isKillShot, bool isCritical, bool isDoomShot, int doomShotDamage, bool isDoomProtected, bool isDoomFatality )
+{
+	Assert( localViewPlayer )
+	string attackerDesc = DevBuildAttackerDesc( expect entity( localViewPlayer ), attacker )
+	string timePrint = format( "%d:%.2f", FrameCount(), PlatformTime() )
+	printt(
+				"{"+timePrint+"} TOOK DAMAGE: " + damage +
+						(isHeadShot ? " (headshot)" : "") +
+						(isCritical ? " (critical)" : "") +
+						(isKillShot ? " (KILLED)" : "") +
+						(isDoomShot ? " (DOOMED dmg:" + doomShotDamage + ")" : "") +
+						(isDoomProtected ? " (DOOM PROTECTION)" : "") +
+						(isDoomFatality ? " (DOOM FATALITY)" : "") +
+				"   " + attackerDesc +
+				"  w/ " + GetObitFromDamageSourceID( damageSourceId ) + modDesc
+	)
+}
+
+void function PlayVictimHeadshotConfirmation( bool isKillShot )
+{
+	entity localViewPlayer = GetLocalViewPlayer()
+	if ( localViewPlayer == null )
+		return
+
+	if ( isKillShot )
+		EmitSoundOnEntity( localViewPlayer, "Player.Hitbeep_headshot.Kill.Human_3P_vs_1P" )
+	else
+		EmitSoundOnEntity( localViewPlayer, "Player.Hitbeep_headshot.Human_3P_vs_1P" )
+}
+
+void function RumbleForPilotDamage( float damageAmount )
+{
+	Rumble_Play( "rumble_pilot_hurt", {} )
+}
+
+void function RumbleForTitanDamage( float damageAmount )
+{
+	string rumbleName;
+	if ( damageAmount < 500 )
+		rumbleName = "titan_damaged_small"
+	else if ( damageAmount < 1000 )
+		rumbleName = "titan_damaged_med"
+	else
+		rumbleName = "titan_damaged_big"
+
+	Rumble_Play( rumbleName, {} )
+}
+
+function ServerCallback_PilotTookDamage( damage, x, y, z, damageType, damageSourceId, attackerEHandle, eModId )
+{
+	expect float( damage )
+	expect int( damageType )
+	expect int( damageSourceId )
+
+	if ( IsWatchingThirdPersonKillReplay() )
+		return
+
+	entity attacker = attackerEHandle ? GetHeavyWeightEntityFromEncodedEHandle( attackerEHandle ) : null
+	entity localViewPlayer = GetLocalViewPlayer()
+	vector damageOrigin = < x, y, z >
+
+	bool isHeadShot = (damageType & DF_HEADSHOT) ? true : false
+	bool isKillShot = (damageType & DF_KILLSHOT) ? true : false
+
+	if ( isHeadShot )
+		PlayVictimHeadshotConfirmation( isKillShot );
+
+	//Jolt view if player is getting meleed
+	if ( damageSourceId == eDamageSourceId.human_melee )
+	{
+		vector joltDir = Normalize( localViewPlayer.CameraPosition() - damageOrigin )
+		//clear melee assist when you get meleed
+		localViewPlayer.Lunge_ClearTarget()
+	}
+
+	array<string> weaponMods
+	if ( eModId != null && eModId in modNameStrings )
+		weaponMods.append( expect string( modNameStrings[ eModId ] ) )
+
+	if ( DebugVictimClientDamageFeedbackIsEnabled() && !IsWatchingReplay() )
+	{
+		string modDesc = (weaponMods.len() > 0 ? (" +" + weaponMods[0]) : "")
+		bool isCritical = (damageType & DF_CRITICAL) ? true : false
+
+		DebugTookDamagePrint( localViewPlayer, attacker, damage, damageSourceId, modDesc, isHeadShot, isKillShot, isCritical, false, 0, false, false )
+	}
+
+	RumbleForPilotDamage( damage )
+
+	DamageHistoryStruct damageTable = StoreDamageHistoryAndUpdate( localViewPlayer, MAX_DAMAGE_HISTORY_TIME, damage, damageOrigin, damageType, damageSourceId, attacker, weaponMods )
+
+	DamageIndicators( damageTable, false )
+
+	if ( damageSourceId in clGlobal.onLocalPlayerTookDamageCallback )
+	{
+		foreach ( callback in clGlobal.onLocalPlayerTookDamageCallback[ damageSourceId ] )
+			callback( damage, damageOrigin, damageType, damageSourceId, attacker )
+	}
+}
+
+/*
+void function ClientCodeCallback_OnMissileCreation( entity missileEnt, string weaponName, bool firstTime )
+{
+
+}
+*/
+
+void function ClientCodeCallback_CreateGrenadeIndicator( entity missileEnt, string weaponName )
+{
+	if ( !IsValid( missileEnt ) )
+		return
+
+	//Called for all projectiles, not just missiles.
+	TryAddGrenadeIndicator( missileEnt, weaponName )
+}
+
+
+void function DamageIndicators( DamageHistoryStruct damageHistory, bool playerIsTitan )
+{
+	if ( damageHistory.damageType & DF_NO_INDICATOR )
+		return
+	if ( !level.clientScriptInitialized )
+		return
+	if ( IsWatchingThirdPersonKillReplay() )
+		return
+
+	entity localViewPlayer = GetLocalViewPlayer()
+
+	int arrowType = DAMAGEARROW_MEDIUM
+
+	if ( IsValid( damageHistory.attacker ) )
+	{
+		if ( damageHistory.attacker == localViewPlayer )
+			return
+
+		if ( damageHistory.attacker.IsTitan() )
+			arrowType = DAMAGEARROW_MEDIUM
+		else if ( damageHistory.attacker.IsPlayer() )
+			arrowType = DAMAGEARROW_SMALL
+		else
+			arrowType = DAMAGEARROW_SMALL
+
+			//if ( damageHistory.attacker.IsTitan() )
+			//	arrowType = DAMAGEARROW_LARGE
+			//else if ( damageHistory.attacker.IsPlayer() )
+			//	arrowType = DAMAGEARROW_MEDIUM
+			//else
+			//	arrowType = DAMAGEARROW_SMALL
+	}
+
+	if ( playerIsTitan )
+	{
+		entity cockpit = localViewPlayer.GetCockpit()
+
+		if ( !cockpit )
+			return
+
+		vector dirToDamage = damageHistory.origin - localViewPlayer.GetOrigin()
+		dirToDamage.z = 0
+		dirToDamage = Normalize( dirToDamage )
+
+		vector playerViewForward = localViewPlayer.GetViewVector()
+		playerViewForward.z = 0.0
+		playerViewForward = Normalize( playerViewForward )
+
+		float damageFrontDot = DotProduct( dirToDamage, playerViewForward )
+
+		if ( damageFrontDot >= 0.707107 )
+			cockpit.AddToTitanHudDamageHistory( COCKPIT_PANEL_TOP, damageHistory.damage )
+		else if ( damageFrontDot <= -0.707107 )
+			cockpit.AddToTitanHudDamageHistory( COCKPIT_PANEL_BOTTOM, damageHistory.damage )
+		else
+		{
+			vector playerViewRight = localViewPlayer.GetViewRight()
+			playerViewRight.z = 0.0
+			playerViewRight = Normalize( playerViewRight )
+
+			float damageRightDot = DotProduct( dirToDamage, playerViewRight )
+
+			if ( damageRightDot >= 0.707107 )
+				cockpit.AddToTitanHudDamageHistory( COCKPIT_PANEL_RIGHT, damageHistory.damage )
+			else
+				cockpit.AddToTitanHudDamageHistory( COCKPIT_PANEL_LEFT, damageHistory.damage )
+		}
+
+		if ( damageHistory.attacker && damageHistory.attacker.GetParent() == localViewPlayer )
+		{
+			damageHistory.rodeoDamage = true
+			return
+		}
+	}
+
+	#if SP
+		if ( IsValid( damageHistory.attacker ) && damageHistory.attacker.IsTitan() )
+			arrowType = DAMAGEARROW_LARGE
+		else if ( playerIsTitan && damageHistory.damage < 50 )
+			return
+		else if ( !playerIsTitan && damageHistory.damage < 15 )
+			arrowType = DAMAGEARROW_SMALL
+		else
+			arrowType = DAMAGEARROW_MEDIUM
+
+		thread DamageIndicatorRui( damageHistory.origin, arrowType, playerIsTitan )
+	#else
+		bool show2DIndicator = true
+		bool show3DIndicator = false
+
+		const int DAMAGE_INDICATOR_STYLE_2D_ONLY = 0
+		const int DAMAGE_INDICATOR_STYLE_BOTH = 1
+		const int DAMAGE_INDICATOR_STYLE_3D_ONLY = 2
+
+		if ( playerIsTitan )
+		{
+			show2DIndicator = GetConVarInt( "damage_indicator_style_titan" ) != DAMAGE_INDICATOR_STYLE_3D_ONLY
+			show3DIndicator = GetConVarInt( "damage_indicator_style_titan" ) != DAMAGE_INDICATOR_STYLE_2D_ONLY
+		}
+		else
+		{
+			show2DIndicator = GetConVarInt( "damage_indicator_style_pilot" ) != DAMAGE_INDICATOR_STYLE_3D_ONLY
+			show3DIndicator = GetConVarInt( "damage_indicator_style_pilot" ) != DAMAGE_INDICATOR_STYLE_2D_ONLY
+		}
+
+		if ( show2DIndicator )
+			thread DamageIndicatorRui( damageHistory.origin, arrowType, playerIsTitan )
+
+		if ( show3DIndicator )
+			ShowDamageArrow( localViewPlayer, damageHistory.origin, arrowType, playerIsTitan, damageHistory.attacker )
+	#endif
+}
+
+const float DAMAGE_INDICATOR_DURATION = 4.0
+
+void function DamageIndicatorRui( vector damageOrigin, int arrowType, bool playerIsTitan )
+{
+	clGlobal.levelEnt.EndSignal( "KillReplayStarted" )
+	clGlobal.levelEnt.EndSignal( "KillReplayEnded" )
+
+	// slop
+	float distance = Length( damageOrigin - GetLocalViewPlayer().CameraPosition() )
+	float randomRange = GraphCapped( distance, 0.0, 2048, 0.0, 256.0 )
+	damageOrigin = <damageOrigin.x + RandomFloatRange( randomRange, -randomRange ), damageOrigin.y + RandomFloatRange( randomRange, -randomRange ), damageOrigin.z>
+
+	float startTime = Time()
+
+	var rui = RuiCreate( $"ui/damage_indicator.rpak", clGlobal.topoFullScreen, RUI_DRAW_HUD, 0 )
+	RuiSetResolutionToScreenSize( rui )
+	RuiSetGameTime( rui, "startTime", startTime )
+	RuiSetFloat( rui, "duration", DAMAGE_INDICATOR_DURATION )
+	RuiSetInt( rui, "attackerType", arrowType )
+
+	file.damageIndicatorCount++
+	int damageIndicatorThreshold = file.damageIndicatorCount + 8
+
+	OnThreadEnd(
+		function() : ( rui )
+		{
+			RuiDestroy( rui )
+		}
+	)
+
+	while ( Time() - startTime < DAMAGE_INDICATOR_DURATION && file.damageIndicatorCount < damageIndicatorThreshold )
+	{
+		vector vecToDamage = damageOrigin - GetLocalViewPlayer().CameraPosition()
+		vecToDamage.z = 0
+		vecToDamage = Normalize( vecToDamage )
+		RuiSetFloat3( rui, "vecToDamage2D", vecToDamage )
+		RuiSetFloat3( rui, "camVec2D", Normalize( AnglesToForward( < 0, GetLocalViewPlayer().CameraAngles().y, 0 > ) ) )
+		RuiSetFloat( rui, "sideDot", vecToDamage.Dot( CrossProduct( <0, 0, 1>, Normalize( AnglesToForward( < 0, GetLocalViewPlayer().CameraAngles().y, 0 > ) ) ) ) )
+		WaitFrame()
+	}
+}
+
+void function ShowGrenadeArrow( entity player, entity grenade, float damageRadius, float startDelay, bool requireLos = true )
+{
+	thread GrenadeArrowThink( player, grenade, damageRadius, startDelay, requireLos )
+}
+
+vector function GetRandomOriginWithinBounds( entity ent )
+{
+	vector boundingMins = ent.GetBoundingMins()
+	vector boundingMaxs = ent.GetBoundingMaxs()
+
+	vector randomOffset = < RandomFloatRange( boundingMins.x, boundingMaxs.x ), RandomFloatRange( boundingMins.y, boundingMaxs.y ), RandomFloatRange( boundingMins.z, boundingMaxs.z ) >
+
+	return ent.GetOrigin() + randomOffset
+}
+
+void function GrenadeArrowThink( entity player, entity grenade, float damageRadius, float startDelay, bool requireLos, string requiredPlayerState = "any" )
+{
+	EndSignal( grenade, "OnDeath" ) //On death added primarily for frag_drones
+	EndSignal( grenade, "OnDestroy" )
+	EndSignal( player, "OnDeath" )
+
+	wait startDelay
+
+	asset grenadeModel = GRENADE_INDICATOR_FRAG_MODEL
+	vector grenadeOffset = < -5, 0, 0 >
+	if ( grenade instanceof C_Projectile )
+	{
+		if ( grenade.ProjectileGetWeaponClassName() == "mp_weapon_grenade_sonar" )
+		{
+			grenadeModel = GRENADE_INDICATOR_SONAR_MODEL
+			grenadeOffset = < -5, 0, 0 >
+			requireLos = false
+		}
+	}
+	else if ( grenade.IsNPC() )
+	{
+		switch ( grenade.GetSignifierName() )
+		{
+			#if MP
+			case "npc_stalker":
+				grenadeModel = GRENADE_INDICATOR_STALKER_MODEL
+				break
+			#endif
+
+			case "npc_frag_drone":
+				grenadeModel = GRENADE_INDICATOR_TICK_MODEL
+				break
+		}
+	}
+
+	entity arrow = CreateClientSidePropDynamic( < 0, 0, 0 >, < 0, 0, 0 >, GRENADE_INDICATOR_ARROW_MODEL )
+	entity mdl = CreateClientSidePropDynamic( < 0, 0, 0 >, < 0, 0, 0 >, grenadeModel )
+
+	OnThreadEnd(
+		function() : ( arrow, mdl )
+		{
+			if ( IsValid( arrow ) )
+				arrow.Destroy()
+			if ( IsValid( mdl ) )
+				mdl.Destroy()
+		}
+	)
+
+	entity cockpit = player.GetCockpit()
+	if ( !cockpit )
+		return
+
+	EndSignal( cockpit, "OnDestroy" )
+
+	arrow.SetParent( cockpit, "CAMERA_BASE" )
+	arrow.SetAttachOffsetOrigin( < 25.0, 0.0, -4.0 > )
+
+	mdl.SetParent( arrow, "BACK" )
+	mdl.SetAttachOffsetOrigin( grenadeOffset )
+
+	float lastVisibleTime = 0
+	bool shouldBeVisible = true
+
+	while ( true )
+	{
+		cockpit = player.GetCockpit()
+
+		switch ( requiredPlayerState )
+		{
+			case "any":
+				shouldBeVisible = true
+				break
+			case "pilot":
+				shouldBeVisible = !player.IsTitan()
+				break
+			case "titan":
+				shouldBeVisible = player.IsTitan()
+				break
+			default:
+				Assert( false, "Invalid player state! Allower states: 'any' 'pilot' 'titan'" )
+
+		}
+
+		if ( shouldBeVisible )
+		{
+			if ( Distance( player.GetOrigin(), grenade.GetOrigin() ) > damageRadius || !cockpit )
+			{
+				shouldBeVisible = false
+			}
+			else
+			{
+				bool tracePassed = false
+
+				if ( requireLos )
+				{
+					TraceResults result = TraceLine( grenade.GetOrigin(), GetRandomOriginWithinBounds( player ), grenade, TRACE_MASK_SHOT, TRACE_COLLISION_GROUP_NONE )
+
+					if ( result.fraction == 1.0 )
+						tracePassed = true
+				}
+
+				if ( requireLos && !tracePassed )
+				{
+					shouldBeVisible = false
+				}
+				else
+				{
+					shouldBeVisible = true
+					lastVisibleTime = Time()
+				}
+			}
+		}
+
+		if ( shouldBeVisible || Time() - lastVisibleTime < 0.25 )
+		{
+			arrow.EnableDraw()
+			mdl.EnableDraw()
+
+			arrow.DisableRenderWithViewModelsNoZoom()
+			arrow.EnableRenderWithCockpit()
+			arrow.EnableRenderWithHud()
+			mdl.DisableRenderWithViewModelsNoZoom()
+			mdl.EnableRenderWithCockpit()
+			mdl.EnableRenderWithHud()
+
+			vector damageArrowAngles = AnglesInverse( player.EyeAngles() )
+			vector vecToDamage = grenade.GetOrigin() - (player.EyePosition() + (player.GetViewVector() * 20.0))
+
+			// reparent for embark/disembark
+			if ( arrow.GetParent() == null )
+				arrow.SetParent( cockpit, "CAMERA_BASE", true )
+
+			arrow.SetAttachOffsetAngles( damageArrowAngles.AnglesCompose( vecToDamage.VectorToAngles() ) )
+		}
+		else
+		{
+			mdl.DisableDraw()
+			arrow.DisableDraw()
+		}
+
+		WaitFrame()
+	}
+
+}
+
+
+function Create_DamageIndicatorHUD()
+{
+}
+
+
+void function SCB_AddGrenadeIndicatorForEntity( int team, int ownerHandle, int eHandle, float damageRadius )
+{
+	if ( !level.grenadeIndicatorEnabled )
+		return
+
+	#if DEV
+		if ( !level.clientScriptInitialized )
+			return
+	#endif
+
+	entity player = GetLocalViewPlayer()
+	entity owner = GetEntityFromEncodedEHandle( ownerHandle )
+
+	entity ent = GetEntityFromEncodedEHandle( eHandle )
+	if ( !IsValid( ent ) )
+		return
+
+	if ( team == player.GetTeam() && owner != player )
+		return
+
+	//TryAddGrenadeIndicator( ent, "" ) // TODO: make function handle non-grenade ents
+}
+
+
+function TryAddGrenadeIndicator( grenade, weaponName )
+{
+	#if DEV
+		if ( !level.clientScriptInitialized )
+			return
+	#endif
+
+	if ( !level.grenadeIndicatorEnabled )
+		return
+
+	expect entity( grenade )
+	entity player = GetLocalViewPlayer()
+
+	// view player may be null when dead
+	if ( !IsValid( player ) )
+		return
+
+	var className = grenade.GetClassName()
+	float damageRadius = 0.0
+
+	if ( className == "grenade" )
+	{
+		damageRadius = grenade.GetDamageRadius()
+	}
+	else if ( grenade.ProjectileGetWeaponClassName() == "mp_titanweapon_arc_ball" )
+	{
+		// arc ball doesn't arc to pilots so no need to show the warning
+		if ( !player.IsTitan() )
+			return
+
+		damageRadius = BALL_LIGHTNING_ZAP_RADIUS
+	}
+	else
+	{
+		return
+	}
+
+	float radius = grenade.GetExplosionRadius()
+
+	if ( player.IsPhaseShifted() )
+		return
+
+
+	float startDelay = 0.0
+	if ( grenade.GetOwner() == player )
+	{
+		if ( !grenade.GetProjectileWeaponSettingBool( eWeaponVar.projectile_damages_owner ) && !grenade.GetProjectileWeaponSettingBool( eWeaponVar.explosion_damages_owner ) )
+			return
+
+		float relVelocity = Length( grenade.GetVelocity() - player.GetVelocity() )
+		if ( relVelocity < DAMAGEHUD_GRENADE_DEBOUNCE_TIME_LOWSPEED_VELOCITYCUTOFF )
+			startDelay = DAMAGEHUD_GRENADE_DEBOUNCE_TIME_LOWSPEED
+		else
+			startDelay = DAMAGEHUD_GRENADE_DEBOUNCE_TIME
+	}
+	else if ( grenade.GetTeam() == player.GetTeam() )
+	{
+		return
+	}
+
+	float padding = player.IsTitan() ? 204.0 : 65.0
+
+	//AddGrenadeIndicator( grenade, radius + padding, startDelay, false )
+	ShowGrenadeArrow( player, grenade, radius + padding, startDelay )
+
+	//thread ShowRuiGrenadeThreatIndicator( grenade, float( radius ) + padding )
+}
+
+void function ShowRuiGrenadeThreatIndicator( entity grenade, float radius )
+{
+	var rui = RuiCreate( $"ui/grenade_threat_indicator.rpak", clGlobal.topoCockpitHudPermanent, RUI_DRAW_COCKPIT, 0 )
+	//var rui = CreateCockpitRui( $"ui/grenade_threat_indicator.rpak", 0 )
+	RuiSetGameTime( rui, "startTime", Time() )
+	RuiSetFloat( rui, "damageRadius", radius )
+	//RuiTrackFloat3( rui, "pos", grenade, RUI_TRACK_ABSORIGIN_FOLLOW )`
+	RuiTrackFloat3( rui, "pos", grenade, RUI_TRACK_POINT_FOLLOW, grenade.LookupAttachment( "BACK" ) )
+
+	OnThreadEnd(
+		function() : ( rui )
+		{
+			RuiDestroy( rui )
+		}
+	)
+
+	grenade.WaitSignal( "OnDestroy" )
+}
+
+
+
+void function InitDamageArrows()
+{
+	for ( int i = 0; i < file.numDamageArrows; i++ )
+	{
+		table arrowData = {
+			grenade = null
+			grenadeRadius = 0.0
+			damageOrigin = < 0.0, 0.0, 0.0 >,
+			damageDirection = < 0.0, 0.0, 0.0 >,
+			endTime = -99.0 + DAMAGEARROW_DURATION,
+			startTime = -99.0,
+			isDying = false,
+			isVisible = false,
+			whizby = false, // hack until we get a new model/shader for the whizby indicator - Roger
+			attacker = null,
+			randomAngle = 0 // Repeated shots from the same attacker randomize the angle of the arrow.
+		}
+
+		entity arrow = CreateClientSidePropDynamic( < 0, 0, 0 >, < 0, 0, 0 >, DAMAGEARROW_MODEL )
+		arrow.SetCanCloak( false )
+		arrow.SetVisibleForLocalPlayer( 0 )
+		arrow.DisableDraw()
+
+		arrowData.arrow <- arrow
+		arrow.s.arrowData <- arrowData
+
+		file.damageArrows.append( arrowData )
+	}
+
+	entity arrow = CreateClientSidePropDynamic( < 0, 0, 0 >, < 0, 0, 0 >, DAMAGEARROW_MODEL )
+	file.damageArrowFadeDuration = arrow.GetSequenceDuration( DAMAGEARROW_FADEANIM ) // 0.266
+	arrow.Destroy()
+}
+
+
+void function DamageArrow_CockpitInit( entity cockpit )
+{
+	entity localViewPlayer = GetLocalViewPlayer()
+	thread UpdateDamageArrows( localViewPlayer, cockpit )
+}
+
+function RefreshExistingDamageArrow( entity player, arrowData, int arrowType, damageOrigin )
+{
+	//Hack - 10 tick rate is making damage feedback bunch up. If we improve that then shouldn't be threaded.
+	player.EndSignal( "OnDestroy" )
+	entity cockpit = player.GetCockpit()
+	if ( IsValid( cockpit ) )
+		cockpit.EndSignal( "OnDestroy" )
+
+	float time = Time()
+
+	if ( arrowData.startTime == time )
+		wait 0.05
+
+	if ( !arrowData.isVisible || arrowData.isDying )
+		return
+
+	time = Time()
+	arrowData.endTime = time + file.arrowIncomingAnims[ arrowType ].duration
+	arrowData.startTime = time
+	arrowData.damageOrigin = damageOrigin
+	arrowData.randomAngle = RandomIntRange( -3, 3 )
+	PulseDamageArrow( expect entity( arrowData.arrow ), arrowType )
+	UpdateDamageArrowVars( player )
+	UpdateDamageArrowAngle( arrowData )
+}
+
+function ShowDamageArrow( entity player, damageOrigin, int arrowType, playerIsTitan, attacker )
+{
+	if ( file.damageArrows.len() == 0 ) // not yet initialized
+		return
+
+	table arrowData = file.damageArrows[file.currentDamageArrow]
+	entity arrow = expect entity( arrowData.arrow )
+
+	file.currentDamageArrow++
+	if ( file.currentDamageArrow >= file.numDamageArrows )
+		file.currentDamageArrow = 0
+
+	float time = Time()
+
+	arrow.s.arrowData.damageOrigin = damageOrigin
+	arrow.s.arrowData.grenade = null
+	arrow.s.arrowData.grenadeRadius = 0.0
+	arrow.s.arrowData.endTime = time + file.arrowIncomingAnims[ arrowType ].duration
+	arrow.s.arrowData.startTime = time
+	arrow.s.arrowData.isDying = false
+	arrow.s.arrowData.whizby = false	//	hack until we get a new model/shader for the whizby indicator
+	arrow.s.arrowData.attacker = attacker
+
+	if ( !arrow.s.arrowData.isVisible )
+	{
+		entity cockpit = player.GetCockpit()
+
+		if ( !cockpit )
+			return
+
+		arrow.s.arrowData.isVisible = true
+		arrow.EnableDraw()
+
+		arrow.DisableRenderWithViewModelsNoZoom()
+		arrow.EnableRenderWithCockpit()
+
+		arrow.EnableRenderWithHud()
+
+		arrow.SetParent( cockpit, "CAMERA_BASE" )
+		arrow.SetAttachOffsetOrigin( < 20.0, 0.0, -2.0 > )
+	}
+
+
+	PulseDamageArrow( arrow, arrowType )
+	UpdateDamageArrowVars( player )
+	UpdateDamageArrowAngle( arrowData )
+}
+
+
+function PulseDamageArrow( entity arrow, int arrowType )
+{
+	arrow.Anim_NonScriptedPlay( file.arrowIncomingAnims[ arrowType ].anim )
+}
+
+function UpdateDamageArrowVars( entity localViewPlayer )
+{
+	file.damageArrowTime = Time()
+	file.damageArrowAngles = AnglesInverse( localViewPlayer.EyeAngles() )
+	file.damageArrowPointCenter = localViewPlayer.EyePosition() + ( localViewPlayer.GetViewVector() * 20.0 )
+}
+
+function UpdateDamageArrowAngle( arrowData )
+{
+	if ( IsValid( arrowData.grenade ) )
+		arrowData.damageOrigin = arrowData.grenade.GetOrigin()
+
+	vector vecToDamage = expect vector( arrowData.damageOrigin ) - file.damageArrowPointCenter
+	vector anglesToDamage = VectorToAngles( vecToDamage )
+	vector eyeAngles = GetLocalViewPlayer().EyeAngles()
+
+	float roll = sin( DegToRad( eyeAngles.y - anglesToDamage.y ) )
+
+	arrowData.arrow.SetAttachOffsetAngles( AnglesCompose( file.damageArrowAngles, anglesToDamage ) + < arrowData.randomAngle, 0, roll * 90.0 > )
+	arrowData.damageDirection = Normalize( vecToDamage )
+}
+
+function UpdateDamageArrows( entity localViewPlayer, entity cockpit )
+{
+	localViewPlayer.EndSignal( "OnDestroy" )
+	cockpit.EndSignal( "OnDestroy" )
+
+	OnThreadEnd(
+		function() : ( localViewPlayer )
+		{
+			foreach ( arrowData in file.damageArrows )
+			{
+				if ( IsValid( arrowData.arrow ) )
+				{
+					arrowData.arrow.DisableDraw()
+					arrowData.arrow.ClearParent()
+					arrowData.attacker = null
+					arrowData.isVisible = false
+					arrowData.randomAngle = 0
+				}
+			}
+		}
+	)
+
+	bool varsUpdated = false
+
+	while ( true )
+	{
+		WaitEndFrame()
+
+		vector playerOrigin = localViewPlayer.GetOrigin()
+
+		varsUpdated = false
+		bool inPhaseShift = localViewPlayer.IsPhaseShifted()
+
+		foreach ( arrowData in file.damageArrows )
+		{
+			if ( !arrowData.isVisible )
+			{
+				continue
+			}
+
+			if ( arrowData.grenade != null )
+			{
+				if ( !IsValid( arrowData.grenade ) )
+					arrowData.endTime = 0.0
+			}
+
+			if ( (file.damageArrowTime >= arrowData.endTime) || inPhaseShift )
+			{
+				arrowData.arrow.DisableDraw()
+				arrowData.arrow.ClearParent()
+				arrowData.attacker = null
+				arrowData.isVisible = false
+				arrowData.randomAngle = 0
+				continue
+			}
+
+			if ( !varsUpdated ) // only call UpdateDamageArrowVars if one or more of the file.damageArrows is visible
+			{
+				varsUpdated = true
+				UpdateDamageArrowVars( localViewPlayer )
+			}
+
+			UpdateDamageArrowAngle( arrowData )
+
+			if ( !arrowData.isDying && ( ( arrowData.endTime - file.damageArrowTime ) <= file.damageArrowFadeDuration ) )
+			{
+				arrowData.isDying = true
+				arrowData.arrow.Anim_NonScriptedPlay( DAMAGEARROW_FADEANIM )
+			}
+		}
+
+		wait( 0.0 )
+	}
+}