Add _arc_cannon.nut from englishclient_mp_common

1 files changed, 1006 insertions, 0 deletions

diff --git a/Northstar.Custom/mod/scripts/vscripts/weapons/_arc_cannon.nut b/Northstar.Custom/mod/scripts/vscripts/weapons/_arc_cannon.nut
new file mode 100644
index 00000000..4268422e
--- /dev/null
+++ b/Northstar.Custom/mod/scripts/vscripts/weapons/_arc_cannon.nut
@@ -0,0 +1,1006 @@
+
+// Aiming & Range
+const DEFAULT_ARC_CANNON_FOVDOT				= 0.98		// First target must be within this dot to be zapped and start a chain
+const DEFAULT_ARC_CANNON_FOVDOT_MISSILE		= 0.95		// First target must be within this dot to be zapped and start a chain ( if it's a missile, we allow more leaniency )
+const ARC_CANNON_RANGE_CHAIN				= 400		// Max distance we can arc from one target to another
+const ARC_CANNON_TITAN_RANGE_CHAIN			= 900		// Max distance we can arc from one target to another
+const ARC_CANNON_CHAIN_COUNT_MIN			= 5			// Max number of chains at no charge
+const ARC_CANNON_CHAIN_COUNT_MAX			= 5			// Max number of chains at full charge
+const ARC_CANNON_CHAIN_COUNT_NPC			= 2			// Number of chains when an NPC fires the weapon
+const ARC_CANNON_FORK_COUNT_MAX				= 1			// Number of forks that can come out of one target to other targets
+const ARC_CANNON_FORK_DELAY					= 0.1
+
+const ARC_CANNON_RANGE_CHAIN_BURN			= 400
+const ARC_CANNON_TITAN_RANGE_CHAIN_BURN		= 900
+const ARC_CANNON_CHAIN_COUNT_MIN_BURN		= 100		// Max number of chains at no charge
+const ARC_CANNON_CHAIN_COUNT_MAX_BURN		= 100		// Max number of chains at full charge
+const ARC_CANNON_CHAIN_COUNT_NPC_BURN		= 10		// Number of chains when an NPC fires the weapon
+const ARC_CANNON_FORK_COUNT_MAX_BURN		= 10		// Number of forks that can come out of one target to other targets
+const ARC_CANNON_BEAM_LIFETIME_BURN			= 1
+
+// Visual settings
+const ARC_CANNON_BOLT_RADIUS_MIN 			= 32		// Bolt radius at no charge ( not actually sure what this does to the beam lol )
+const ARC_CANNON_BOLT_RADIUS_MAX 			= 640		// Bold radius at full charge ( not actually sure what this does to the beam lol )
+const ARC_CANNON_BOLT_WIDTH_MIN 			= 1			// Bolt width at no charge
+const ARC_CANNON_BOLT_WIDTH_MAX 			= 26		// Bolt width at full charge
+const ARC_CANNON_BOLT_WIDTH_NPC				= 8			// Bolt width when used by NPC
+const ARC_CANNON_BEAM_COLOR					= "150 190 255"
+const ARC_CANNON_BEAM_LIFETIME				= 0.75
+
+// Player Effects
+const ARC_CANNON_TITAN_SCREEN_SFX 		= "Weapon_R1_LaserMine.Activate"
+const ARC_CANNON_PILOT_SCREEN_SFX 		= "Weapon_R1_LaserMine.Activate"
+const ARC_CANNON_EMP_DURATION_MIN 		= 0.1
+const ARC_CANNON_EMP_DURATION_MAX		= 1.8
+const ARC_CANNON_EMP_FADEOUT_DURATION	= 0.4
+const ARC_CANNON_SCREEN_EFFECTS_MIN 	= 0.025
+const ARC_CANNON_SCREEN_EFFECTS_MAX 	= 0.075
+const ARC_CANNON_SCREEN_THRESHOLD		= 0.3385
+const ARC_CANNON_SLOW_SCALE_MIN 		= 0.8
+const ARC_CANNON_SLOW_SCALE_MAX 		= 0.7
+const ARC_CANNON_3RD_PERSON_EFFECT_MIN_DURATION = 0.2
+
+// Rumble
+const ARC_CANNON_RUMBLE_CHARGE_MIN			= 5
+const ARC_CANNON_RUMBLE_CHARGE_MAX			= 50
+const ARC_CANNON_RUMBLE_TYPE_INDEX			= 14		// These are defined in code, 14 = RUMBLE_FLAT_BOTH
+
+// Damage
+const ARC_CANNON_DAMAGE_FALLOFF_SCALER		= 0.75		// Amount of damage carried on to the next target in the chain lightning. If 0.75, then a target that would normally take 100 damage will take 75 damage if they are one chain deep, or 56 damage if 2 levels deep
+const ARC_CANNON_DAMAGE_CHARGE_RATIO		= 0.85		// What amount of charge is required for full damage.
+const ARC_CANNON_DAMAGE_CHARGE_RATIO_BURN	= 0.676		// What amount of charge is required for full damage.
+const ARC_CANNON_CAPACITOR_CHARGE_RATIO		= 1.0
+
+// Options
+const ARC_CANNON_TARGETS_MISSILES 			= 1			// 1 = arc cannon zaps missiles that are active, 0 = missiles are ignored by arc cannon
+
+//Mods
+const OVERCHARGE_MAX_SHIELD_DECAY       	= 0.2
+const OVERCHARGE_SHIELD_DECAY_MULTIPLIER 	= 0.04
+const OVERCHARGE_BONUS_CHARGE_FRACTION		= 0.05
+
+const SPLITTER_DAMAGE_FALLOFF_SCALER		= 0.6
+const SPLITTER_FORK_COUNT_MAX				= 10
+
+const ARC_CANNON_SIGNAL_DEACTIVATED	= "ArcCannonDeactivated"
+RegisterSignal( ARC_CANNON_SIGNAL_DEACTIVATED )
+
+const ARC_CANNON_SIGNAL_CHARGEEND = "ArcCannonChargeEnd"
+RegisterSignal( ARC_CANNON_SIGNAL_CHARGEEND )
+
+const ARC_CANNON_BEAM_EFFECT = "wpn_arc_cannon_beam"
+PrecacheParticleSystem( ARC_CANNON_BEAM_EFFECT )
+
+const ARC_CANNON_BEAM_EFFECT_MOD = "wpn_arc_cannon_beam_mod"
+PrecacheParticleSystem( ARC_CANNON_BEAM_EFFECT_MOD )
+
+const ARC_CANNON_FX_TABLE = "exp_arc_cannon"
+PrecacheImpactEffectTable( ARC_CANNON_FX_TABLE )
+
+if ( !reloadingScripts )
+{
+	// Valid Arc Cannon Target Classnames
+	level.arcCannonTargetClassnames <- {}
+	level.arcCannonTargetClassnames[ "npc_turret_floor" ] 	<- true
+	level.arcCannonTargetClassnames[ "npc_spectre" ] 		<- true
+	level.arcCannonTargetClassnames[ "npc_soldier_shield" ] <- true
+	level.arcCannonTargetClassnames[ "npc_soldier_heavy" ] 	<- true
+	level.arcCannonTargetClassnames[ "npc_soldier" ] 		<- true
+	level.arcCannonTargetClassnames[ "npc_cscanner" ] 		<- true
+	level.arcCannonTargetClassnames[ "npc_titan" ] 			<- true
+	level.arcCannonTargetClassnames[ "npc_marvin" ] 		<- true
+	level.arcCannonTargetClassnames[ "player" ] 			<- true
+	level.arcCannonTargetClassnames[ "script_mover" ] 		<- true
+	level.arcCannonTargetClassnames[ "npc_grenade_frag" ] 	<- true
+	level.arcCannonTargetClassnames[ "rpg_missile" ] 		<- true
+	level.arcCannonTargetClassnames[ "npc_turret_mega" ]	<- true
+	level.arcCannonTargetClassnames[ "npc_turret_sentry" ] 	<- true
+	level.arcCannonTargetClassnames[ "npc_dropship" ] 		<- true
+	level.arcCannonTargetClassnames[ "prop_dynamic" ] 		<- true
+}
+
+function main()
+{
+	Globalize( ArcCannon_PrecacheFX )
+	Globalize( ArcCannon_Start )
+	Globalize( ArcCannon_Stop )
+	Globalize( ArcCannon_ChargeBegin )
+	Globalize( ArcCannon_ChargeEnd )
+	Globalize( FireArcCannon )
+	Globalize( ArcCannon_HideIdleEffect )
+	Globalize( AddToArcCannonTargets )
+	Globalize( ConvertTitanShieldIntoBonusCharge )
+	Globalize( GetArcCannonChargeFraction )
+	Globalize( StopChargeEffects )
+
+	if( IsClient() )
+	{
+		AddDestroyCallback( "mp_titanweapon_arc_cannon", ClientDestroyCallback_ArcCannon_Stop )
+	}
+	else
+	{
+		level._arcCannonTargetsArrayID <- CreateScriptManagedEntArray()
+	}
+
+	PrecacheParticleSystem( "impact_arc_cannon_titan" )
+}
+
+function ArcCannon_PrecacheFX( weapon )
+{
+	if ( WeaponIsPrecached( weapon ) )
+		return
+
+	PrecacheParticleSystem( "wpn_arc_cannon_electricity_fp" )
+	PrecacheParticleSystem( "wpn_arc_cannon_electricity" )
+
+	PrecacheParticleSystem( "wpn_ARC_knob_FP" )
+	PrecacheParticleSystem( "wpn_ARC_knob" )
+
+	PrecacheParticleSystem( "wpn_arc_cannon_charge_fp" )
+	PrecacheParticleSystem( "wpn_arc_cannon_charge" )
+
+	PrecacheParticleSystem( "wpn_arc_cannon_charge_fp" )
+	PrecacheParticleSystem( "wpn_arc_cannon_charge" )
+
+	PrecacheParticleSystem( "wpn_muzzleflash_arc_cannon_fp" )
+	PrecacheParticleSystem( "wpn_muzzleflash_arc_cannon" )
+}
+
+function ArcCannon_Start( weapon )
+{
+	weapon.PlayWeaponEffectNoCull( "wpn_arc_cannon_electricity_fp", "wpn_arc_cannon_electricity", "muzzle_flash" )
+	weapon.EmitWeaponSound( "arc_cannon_charged_loop" )
+}
+
+function ArcCannon_Stop( weapon, player = null )
+{
+	weapon.Signal( ARC_CANNON_SIGNAL_DEACTIVATED )
+	StopChargeEffects( weapon, player )
+
+	weapon.StopWeaponEffect( "wpn_arc_cannon_electricity_fp", "wpn_arc_cannon_electricity" )
+	weapon.StopWeaponSound( "arc_cannon_charged_loop" )
+	weapon.StopWeaponSound( "arc_cannon_charge" )
+}
+
+function ArcCannon_ChargeBegin( weapon )
+{
+	local weaponOwner = weapon.GetWeaponOwner()
+	local weaponScriptScope = weapon.GetScriptScope()
+	local useNormalChargeSounds = true
+	if( weapon.HasMod( "overcharge" ) )
+	{
+		if ( weaponOwner.IsTitan() )
+		{
+			local soul = weaponOwner.GetTitanSoul()
+			if ( soul.GetShieldHealth() > 0 )
+			{
+				weapon.EmitWeaponSound( "arc_cannon_fastcharge" )
+				useNormalChargeSounds = false
+			}
+			if ( IsServer() )
+				thread ConvertTitanShieldIntoBonusCharge( soul, weapon )
+		}
+	}
+
+	if ( useNormalChargeSounds )
+	{
+		weapon.EmitWeaponSound( "arc_cannon_charge" )
+	}
+
+	if( !("maxChargeTime" in weapon.s) )
+		weapon.s.maxChargeTime <- weapon.GetWeaponModSetting( "charge_time" )
+
+	weapon.PlayWeaponEffectNoCull( "wpn_arc_cannon_charge_fp", "wpn_arc_cannon_charge", "muzzle_flash" )
+	local chargeTime = weapon.GetWeaponChargeTime()
+
+	if ( IsClient() )
+	{
+		if ( !weapon.ShouldPredictProjectiles() )
+			return
+
+		if ( weaponOwner.IsPlayer() )
+			weaponOwner.StartArcCannon();
+
+		local handle = weapon.AllocateHandleForViewmodelEffect( "wpn_arc_cannon_charge_fp" )
+		if ( handle )
+			EffectSkipForwardToTime( handle, chargeTime )
+
+		thread cl_ChargeRumble( weapon, ARC_CANNON_RUMBLE_TYPE_INDEX, ARC_CANNON_RUMBLE_CHARGE_MIN, ARC_CANNON_RUMBLE_CHARGE_MAX, ARC_CANNON_SIGNAL_CHARGEEND )
+	}
+	thread ChargeEffects( weapon )
+}
+
+function ArcCannon_ChargeEnd( weapon, player = null )
+{
+	if ( IsClient() && weapon.GetWeaponOwner() == GetLocalViewPlayer() )
+	{
+		local weaponOwner
+		if ( player != null )
+			weaponOwner = player
+		else
+			weaponOwner = weapon.GetWeaponOwner()
+
+		if ( IsValid( weaponOwner ) && weaponOwner.IsPlayer() )
+			weaponOwner.StopArcCannon()
+	}
+	if( IsValid( weapon ) )
+		StopChargeEffects( weapon )
+}
+
+function StopChargeEffects( weapon, player = null )
+{
+	weapon.Signal( ARC_CANNON_SIGNAL_CHARGEEND )
+
+	local weaponScriptScope = weapon.GetScriptScope()
+	weapon.StopWeaponSound( "arc_cannon_charge" )
+	weapon.StopWeaponEffect( "wpn_arc_cannon_charge_fp", "wpn_arc_cannon_charge" )
+	weapon.StopWeaponSound( "arc_cannon_fastcharge" )
+	//weapon.StopWeaponEffect( "wpn_arc_cannon_charge_fp", "wpn_arc_cannon_charge" )
+	weapon.StopWeaponEffect( "wpn_ARC_knob_FP", "wpn_ARC_knob" )
+}
+
+function ChargeEffects( weapon )
+{
+	weapon.EndSignal( ARC_CANNON_SIGNAL_CHARGEEND )
+	weapon.EndSignal( "OnDestroy" )
+
+	local player = weapon.GetWeaponOwner()
+
+	wait ( weapon.s.maxChargeTime * GetArcCannonChargeFraction( weapon ) )
+
+	weapon.PlayWeaponEffectNoCull( "wpn_ARC_knob_FP", "wpn_ARC_knob", "SPINNING_KNOB" )
+}
+
+function ConvertTitanShieldIntoBonusCharge( soul, weapon )
+{
+	weapon.EndSignal( ARC_CANNON_SIGNAL_CHARGEEND )
+	weapon.EndSignal( "OnDestroy" )
+
+	local maxShieldDecay = OVERCHARGE_MAX_SHIELD_DECAY
+	local bonusChargeFraction = OVERCHARGE_BONUS_CHARGE_FRACTION
+	local shieldDecayMultiplier = OVERCHARGE_SHIELD_DECAY_MULTIPLIER
+	local shieldHealthMax = soul.GetShieldHealthMax()
+	local chargeRatio = GetArcCannonChargeFraction( weapon )
+
+	while( 1 )
+	{
+		if( !IsValid( soul ) || !IsValid( weapon ) )
+			break
+
+		local baseCharge = weapon.GetWeaponChargeFraction() // + GetOverchargeBonusChargeFraction()
+		local charge = clamp ( baseCharge * ( 1 / chargeRatio ), 0.0, 1.0 )
+		if( charge < 1.0 || maxShieldDecay > 0)
+		{
+			local shieldHealth = soul.GetShieldHealth()
+
+			//Slight inconsistency in server updates, this ensures it never takes too much.
+			if ( shieldDecayMultiplier > maxShieldDecay )
+				shieldDecayMultiplier = maxShieldDecay
+			maxShieldDecay -= shieldDecayMultiplier
+
+			local shieldDecayAmount = shieldHealthMax * shieldDecayMultiplier
+			local newShieldAmount = shieldHealth - shieldDecayAmount
+			soul.SetShieldHealth( max( newShieldAmount, 0 ) )
+			soul.s.nextRegenTime = Time() + TITAN_SHIELD_REGEN_DELAY
+
+			if( shieldDecayAmount > shieldHealth )
+				bonusChargeFraction = bonusChargeFraction * ( shieldHealth / shieldDecayAmount )
+			weapon.SetWeaponChargeFraction( baseCharge + bonusChargeFraction )
+		}
+		wait 0.1
+	}
+}
+
+function FireArcCannon( weapon, attackParams )
+{
+	local weaponScriptScope = weapon.GetScriptScope()
+	local owner = weapon.GetWeaponOwner()
+
+	local baseCharge = weapon.GetWeaponChargeFraction() // + GetOverchargeBonusChargeFraction()
+	local charge = clamp ( baseCharge * ( 1 / GetArcCannonChargeFraction( weapon ) ), 0.0, 1.0 )
+	local newVolume = GraphCapped( charge, 0.25, 1.0, 0.0, 1.0 )
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+	{
+		weapon.EmitWeaponSound( "arc_cannon_fire_SmallShot_Amped" )
+		weaponScriptScope.PlayWeaponSoundWithVolume( "arc_cannon_fire_BigShot_Amped", newVolume )
+	}
+	else
+	{
+		weapon.EmitWeaponSound( "arc_cannon_fire_SmallShot" )
+		weaponScriptScope.PlayWeaponSoundWithVolume( "arc_cannon_Fire_BigShot", newVolume )
+	}
+
+	weapon.StopWeaponSound( "arc_cannon_charged_loop" )
+
+	weapon.EmitWeaponNpcSound( LOUD_WEAPON_AI_SOUND_RADIUS_MP, 0.2 )
+
+	weapon.PlayWeaponEffect( "wpn_muzzleflash_arc_cannon_fp", "wpn_muzzleflash_arc_cannon", "muzzle_flash" )
+
+	StopChargeEffects( weapon )
+
+	local attachmentName = "muzzle_flash"
+	local attachmentIndex = weapon.LookupAttachment( attachmentName )
+	Assert( attachmentIndex >= 0 )
+	local muzzleOrigin = weapon.GetAttachmentOrigin( attachmentIndex )
+
+	//printt( "-------- FIRING ARC CANNON --------" )
+
+	local firstTargetInfo = GetFirstArcCannonTarget( weapon, attackParams )
+	if ( !IsValid( firstTargetInfo.target ) )
+		FireArcNoTargets( weapon, attackParams, muzzleOrigin )
+	else
+		FireArcWithTargets( weapon, firstTargetInfo, attackParams, muzzleOrigin )
+
+	return 1
+}
+
+function GetFirstArcCannonTarget( weapon, attackParams )
+{
+	local owner 				= weapon.GetWeaponOwner()
+	local coneHeight 			= weapon.GetMaxDamageFarDist()
+
+	local angleToAxis 			= 8  // set this too high and auto-titans using it will error on GetVisibleEntitiesInCone
+	local ignoredEntities 		= [ owner, weapon ]
+	local traceMask 			= TRACE_MASK_SHOT
+	local flags					= VIS_CONE_ENTS_TEST_HITBOXES  // | VIS_CONE_ENTS_IGNORE_VORTEX
+	local antilagPlayer			= null
+	if ( owner.IsPlayer() )
+	{
+		angleToAxis = owner.GetAttackSpreadAngle() * 0.095
+		antilagPlayer = owner
+	}
+
+	local results
+	local ownerTeam = owner.GetTeam()
+
+	// Get a missile target and a non-missile target in the cone that the player can zap
+	// We do this in a separate check so we can use a wider cone to be more forgiving for targeting missiles
+	local firstTargetInfo = {}
+	firstTargetInfo.target <- null
+	firstTargetInfo.hitLocation <- null
+	for ( local i = 0 ; i < 2 ; i++ )
+	{
+		local missileCheck = i == 0
+		local coneAngle = angleToAxis
+		if ( missileCheck )
+			coneAngle *= 3.0
+
+		results = GetVisibleEntitiesInCone( attackParams.pos, attackParams.dir, coneHeight, coneAngle, ignoredEntities, traceMask, flags, antilagPlayer, false, false )
+		foreach( result in results )
+		{
+			local visibleEnt = result.entity
+
+			if ( !IsValid( visibleEnt ) )
+				continue
+
+			local classname = IsServer() ? visibleEnt.GetClassname() : visibleEnt.GetSignifierName()
+
+			if ( !( classname in level.arcCannonTargetClassnames ) )
+				continue
+
+			if ( "GetTeam" in visibleEnt )
+			{
+				local visibleEntTeam = visibleEnt.GetTeam()
+				if ( visibleEntTeam == ownerTeam )
+					continue
+				if ( IsEntANeutralMegaTurret( visibleEnt, ownerTeam ) )
+					continue
+			}
+
+			if ( missileCheck && classname != "rpg_missile" )
+				continue
+
+			if ( !missileCheck && classname == "rpg_missile" )
+				continue
+
+			firstTargetInfo.target = visibleEnt
+			firstTargetInfo.hitLocation = result.visiblePosition
+			break
+		}
+	}
+	//Creating a whiz-by sound.
+	weapon.FireWeaponBullet_Special( attackParams.pos, attackParams.dir, 1, 0, true, true, true, true )
+
+	return firstTargetInfo
+}
+
+function FireArcNoTargets( weapon, attackParams, muzzleOrigin )
+{
+	Assert( IsValid( weapon ) )
+	local player = weapon.GetWeaponOwner()
+	local chargeFrac = weapon.GetWeaponChargeFraction()
+	local beamVec = attackParams.dir * weapon.GetMaxDamageFarDist()
+	local playerEyePos = player.EyePosition()
+	local traceResults = TraceLineHighDetail( playerEyePos, (playerEyePos + beamVec), weapon, (TRACE_MASK_PLAYERSOLID_BRUSHONLY | TRACE_MASK_BLOCKLOS), TRACE_COLLISION_GROUP_NONE )
+	local beamEnd = traceResults.endPos
+
+	local vortexHit = VortexBulletHitCheck( player, playerEyePos, beamEnd )
+	if ( vortexHit )
+	{
+		if( IsServer() )
+		{
+			local vortexWeapon = vortexHit.vortex.GetOwnerWeapon()
+			if( vortexWeapon && vortexWeapon.GetClassname() == "mp_titanweapon_vortex_shield" )
+				VortexDrainedByImpact( vortexWeapon, weapon, null, null )
+		}
+		beamEnd = vortexHit.hitPos
+	}
+
+	local radius = Graph( chargeFrac, 0, 1, ARC_CANNON_BOLT_RADIUS_MIN, ARC_CANNON_BOLT_RADIUS_MAX )
+	local boltWidth = Graph( chargeFrac, 0, 1, ARC_CANNON_BOLT_WIDTH_MIN, ARC_CANNON_BOLT_WIDTH_MAX )
+	if ( player.IsNPC() )
+		boltWidth = ARC_CANNON_BOLT_WIDTH_NPC
+	thread CreateArcCannonBeam( weapon, null, muzzleOrigin, beamEnd, player, ARC_CANNON_BEAM_LIFETIME, radius, boltWidth, 2, false, true )
+	if( IsServer() )
+		CreateExplosion( beamEnd, 0, 0, 1, 1, player, 0, null, -1, false, ARC_CANNON_FX_TABLE )
+}
+
+function FireArcWithTargets( weapon, firstTargetInfo, attackParams, muzzleOrigin )
+{
+	local beamStart = muzzleOrigin
+	local beamEnd
+	local player = weapon.GetWeaponOwner()
+	local chargeFrac = weapon.GetWeaponChargeFraction()
+	local radius = Graph( chargeFrac, 0, 1, ARC_CANNON_BOLT_RADIUS_MIN, ARC_CANNON_BOLT_RADIUS_MAX )
+	local boltWidth = Graph( chargeFrac, 0, 1, ARC_CANNON_BOLT_WIDTH_MIN, ARC_CANNON_BOLT_WIDTH_MAX )
+	local maxChains
+	local minChains
+
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+	{
+		if ( player.IsNPC() )
+			maxChains = ARC_CANNON_CHAIN_COUNT_NPC_BURN
+		else
+			maxChains = ARC_CANNON_CHAIN_COUNT_MAX_BURN
+
+		minChains = ARC_CANNON_CHAIN_COUNT_MIN_BURN
+	}
+	else
+	{
+		if ( player.IsNPC() )
+			maxChains = ARC_CANNON_CHAIN_COUNT_NPC
+		else
+			maxChains = ARC_CANNON_CHAIN_COUNT_MAX
+
+		minChains = ARC_CANNON_CHAIN_COUNT_MIN
+	}
+
+	if ( !player.IsNPC() )
+		maxChains = Graph( chargeFrac, 0, 1, minChains, maxChains )
+
+	local zapInfo = {}
+	zapInfo.weapon 			<- weapon
+	zapInfo.player 			<- player
+	zapInfo.muzzleOrigin	<- muzzleOrigin
+	zapInfo.radius			<- radius
+	zapInfo.boltWidth		<- boltWidth
+	zapInfo.maxChains		<- maxChains
+	zapInfo.chargeFrac		<- chargeFrac
+	zapInfo.zappedTargets 	<- {}
+	zapInfo.zappedTargets[ firstTargetInfo.target ] <- true
+	local chainNum = 1
+	thread ZapTargetRecursive( firstTargetInfo.target, zapInfo, zapInfo.muzzleOrigin, firstTargetInfo.hitLocation, chainNum )
+}
+
+function ZapTargetRecursive( target, zapInfo, beamStartPos, firstTargetBeamEndPos = null, chainNum = 1 )
+{
+	if ( !IsValid( target ) )
+		return
+
+	if ( !IsValid( zapInfo.weapon ) )
+		return
+
+	Assert( target in zapInfo.zappedTargets )
+	if ( chainNum > zapInfo.maxChains )
+		return
+	local beamEndPos
+	if ( firstTargetBeamEndPos == null )
+		beamEndPos = target.GetWorldSpaceCenter()
+	else
+		beamEndPos = firstTargetBeamEndPos
+
+	waitthread ZapTarget( zapInfo, target, beamStartPos, beamEndPos, chainNum )
+
+	// Get other nearby targets we can chain to
+	if ( IsServer() )
+	{
+	    if ( !IsValid( target ) )
+		    return
+
+	    if ( !IsValid( zapInfo.weapon ) )
+		    return
+
+		local chainTargets = GetArcCannonChainTargets( beamEndPos, target, zapInfo )
+		foreach( chainTarget in chainTargets )
+		{
+			local newChainNum = chainNum
+			if( !chainTarget.GetClassname() != "rpg_missile" )
+				newChainNum++
+			zapInfo.zappedTargets[ chainTarget ] <- true
+			thread ZapTargetRecursive( chainTarget, zapInfo, beamEndPos, null, newChainNum )
+		}
+
+		if ( IsValid( zapInfo.player ) && zapInfo.player.IsPlayer() && zapInfo.zappedTargets.len() >= 5 )
+		{
+			if ( PlayerProgressionAllowed( zapInfo.player ) )
+				zapInfo.player.SetPersistentVar( "ach_multikillArcRifle", true )
+			if ( chainNum == 5 )
+				UpdatePlayerStat( zapInfo.player, "misc_stats", "arcCannonMultiKills", 1 )
+		}
+	}
+}
+
+function ZapTarget( zapInfo, target, beamStartPos, beamEndPos, chainNum = 1 )
+{
+	//DebugDrawLine( beamStartPos, beamEndPos, 255, 0, 0, true, 5.0 )
+	local boltWidth = zapInfo.boltWidth
+	if ( zapInfo.player.IsNPC() )
+		boltWidth = ARC_CANNON_BOLT_WIDTH_NPC
+	local firstBeam = ( chainNum == 1 )
+	if( firstBeam && IsServer() )
+		CreateExplosion( beamEndPos, 0, 0, 1, 1, zapInfo.player, 0, null, -1, false, ARC_CANNON_FX_TABLE )
+	thread CreateArcCannonBeam( zapInfo.weapon, target, beamStartPos, beamEndPos, zapInfo.player, ARC_CANNON_BEAM_LIFETIME, zapInfo.radius, boltWidth, 5, true, firstBeam )
+
+	if ( IsClient() )
+		return
+
+	local isMissile = ( target.GetClassname() == "rpg_missile" )
+	if( !isMissile )
+		wait ARC_CANNON_FORK_DELAY
+	else
+		wait 0.05
+
+	local deathPackage = damageTypes.ArcCannon
+
+	local damageAmount
+	local damageMin
+	local damageMax
+
+	if ( IsValid( target ) && IsValid( zapInfo.player ) )
+	{
+		if ( target.GetArmorType() == ARMOR_TYPE_HEAVY )
+		{
+			if ( IsValid( zapInfo.weapon ) )
+			{
+				damageMin = zapInfo.weapon.GetWeaponModSetting( "damage_far_value_titanarmor" )
+				damageMax = zapInfo.weapon.GetWeaponModSetting( "damage_near_value_titanarmor" )
+			}
+			else
+			{
+				damageMin = GetWeaponInfoFileKeyField_Global( "mp_titanweapon_arc_cannon", "damage_far_value_titanarmor" )
+				damageMax = GetWeaponInfoFileKeyField_Global( "mp_titanweapon_arc_cannon", "damage_near_value_titanarmor" )
+			}
+
+			// Due to auto-titans not charging, they do very little damage with this weapon against one another.
+			if ( zapInfo.player.IsNPC() )
+			{
+				damageMin *= 7.0
+				damageMax *= 7.0
+			}
+
+			// HACK; temp fix for non titan heavy armor targets (e.g. mega turret)
+		}
+		else
+		{
+			if ( IsValid( zapInfo.weapon ) )
+			{
+				damageMin = zapInfo.weapon.GetWeaponModSetting( "damage_far_value" )
+				damageMax = zapInfo.weapon.GetWeaponModSetting( "damage_near_value" )
+			}
+			else
+			{
+				damageMin = GetWeaponInfoFileKeyField_Global( "mp_titanweapon_arc_cannon", "damage_far_value" )
+				damageMax = GetWeaponInfoFileKeyField_Global( "mp_titanweapon_arc_cannon", "damage_near_value" )
+			}
+
+			if ( target.IsNPC() )
+			{
+				damageMin *= 3.0	// more powerful against NPC humans so they die easy
+				damageMax *= 3.0
+			}
+		}
+
+
+		// Scale damage amount based on how many chains deep we are
+		local chargeRatio = GetArcCannonChargeFraction( zapInfo.weapon )
+		damageAmount = GraphCapped( zapInfo.chargeFrac, 0, chargeRatio, damageMin, damageMax )
+		local damageFalloff = ARC_CANNON_DAMAGE_FALLOFF_SCALER
+		if( IsValid( zapInfo.weapon ) && zapInfo.weapon.HasMod( "splitter" ) )
+			damageFalloff = SPLITTER_DAMAGE_FALLOFF_SCALER
+		damageAmount *= pow( damageFalloff, chainNum - 1 )
+
+		local dmgSourceID = eDamageSourceId.mp_titanweapon_arc_cannon
+
+		// Update Later - This shouldn't be done here, this is not where we determine if damage actually happened to the target
+		// move to Damaged callback instead
+		if( damageAmount > 0 )
+		{
+			local empDuration = GraphCapped( zapInfo.chargeFrac, 0, chargeRatio, ARC_CANNON_EMP_DURATION_MIN, ARC_CANNON_EMP_DURATION_MAX )
+
+			if ( target.IsPlayer() )
+			{
+				local empViewStrength = GraphCapped( zapInfo.chargeFrac, 0, chargeRatio, ARC_CANNON_SCREEN_EFFECTS_MIN, ARC_CANNON_SCREEN_EFFECTS_MAX )
+
+				if ( target.IsTitan() && zapInfo.chargeFrac >= ARC_CANNON_SCREEN_THRESHOLD )
+				{
+					Remote.CallFunction_Replay( target, "ServerCallback_TitanEMP", empViewStrength, empDuration, ARC_CANNON_EMP_FADEOUT_DURATION )
+					EmitSoundOnEntityOnlyToPlayer( target, target, ARC_CANNON_TITAN_SCREEN_SFX )
+
+					local scale = GraphCapped( zapInfo.chargeFrac, 0, chargeRatio, ARC_CANNON_SLOW_SCALE_MIN, ARC_CANNON_SLOW_SCALE_MAX )
+					thread EMP_SlowPlayer( target, scale, empDuration )
+				}
+				else if ( zapInfo.chargeFrac >= ARC_CANNON_SCREEN_THRESHOLD )
+				{
+					Remote.CallFunction_Replay( target, "ServerCallback_PilotEMP", empViewStrength, empDuration, ARC_CANNON_EMP_FADEOUT_DURATION )
+					EmitSoundOnEntityOnlyToPlayer( target, target, ARC_CANNON_PILOT_SCREEN_SFX )
+				}
+			}
+
+			// Do 3rd person effect on the body
+			local effect = null
+			local tag = null
+			target.TakeDamage( damageAmount, zapInfo.player, zapInfo.player, { origin = zapInfo.player.GetOrigin(), force = Vector(0,0,0), scriptType = deathPackage, weapon = zapInfo.weapon, damageSourceId = dmgSourceID } )
+
+			if ( zapInfo.chargeFrac < ARC_CANNON_SCREEN_THRESHOLD )
+				empDuration = ARC_CANNON_3RD_PERSON_EFFECT_MIN_DURATION
+			else
+				empDuration += ARC_CANNON_EMP_FADEOUT_DURATION
+
+			if ( target.GetArmorType() == ARMOR_TYPE_HEAVY )
+			{
+				effect = "impact_arc_cannon_titan"
+				tag = "exp_torso_front"
+			}
+			else
+			{
+				effect = "P_emp_body_human"
+				tag = "CHESTFOCUS"
+			}
+
+			if ( target.IsPlayer() && effect != null && tag != null )
+			{
+				if ( target.LookupAttachment( tag ) != 0 )
+					ClientStylePlayFXOnEntity( effect, target, tag, empDuration )
+			}
+
+			if ( target.IsPlayer() )
+				EmitSoundOnEntityExceptToPlayer( target, target, "Titan_Blue_Electricity_Cloud" )
+			else
+				EmitSoundOnEntity( target, "Titan_Blue_Electricity_Cloud" )
+
+			thread FadeOutSoundOnEntityAfterDelay( target, "Titan_Blue_Electricity_Cloud", empDuration * 0.6666, empDuration * 0.3333 )
+		}
+		else
+		{
+			//Don't bounce if the beam is set to do 0 damage.
+			chainNum = zapInfo.maxChains
+		}
+
+		if ( isMissile )
+		{
+			if ( IsValid ( zapInfo.player ) )
+				target.SetOwner( zapInfo.player )
+			target.Explode()
+		}
+	}
+}
+
+
+function FadeOutSoundOnEntityAfterDelay( entity, soundAlias, delay, fadeTime )
+{
+
+	if ( !IsValid( entity ) )
+		return
+
+	entity.EndSignal( "OnDestroy" )
+	wait delay
+	FadeOutSoundOnEntity( entity, soundAlias, fadeTime )
+}
+
+
+function GetArcCannonChainTargets( fromOrigin, fromTarget, zapInfo )
+{
+	Assert( IsServer() )
+
+	local results = []
+	if ( !IsValid( zapInfo.player ) )
+		return results
+
+	local playerTeam = zapInfo.player.GetTeam()
+	local allTargets = GetArcCannonTargetsInRange( fromOrigin, playerTeam, zapInfo.weapon )
+	allTargets = ArrayClosest( allTargets, fromOrigin )
+
+	local viewVector
+	if ( zapInfo.player.IsPlayer() )
+		viewVector = zapInfo.player.GetViewVector()
+	else
+		viewVector = zapInfo.player.EyeAngles().AnglesToForward()
+
+	local eyePosition = zapInfo.player.EyePosition()
+
+	foreach( ent in allTargets )
+	{
+		local forkCount = ARC_CANNON_FORK_COUNT_MAX
+		if ( zapInfo.weapon.HasMod( "splitter" ) )
+			forkCount = SPLITTER_FORK_COUNT_MAX
+		else if ( zapInfo.weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+			forkCount = ARC_CANNON_FORK_COUNT_MAX_BURN
+
+		if ( results.len() >= forkCount )
+			break
+
+		if ( ent.IsPlayer() )
+		{
+			if ( ent.GetPlayerClass() == "operator" )
+				continue
+
+			if ( ent.GetPlayerClass() == "dronecontroller" )
+				continue
+
+			// Ignore players that are passing damage to their parent. This is to address zapping a friendly rodeo player
+			local entParent = ent.GetParent()
+			if ( IsValid( entParent ) && ent.kv.PassDamageToParent.tointeger() )
+				continue
+		}
+
+		if ( ent.GetClassname() == "script_mover" )
+			continue
+
+		if ( IsEntANeutralMegaTurret( ent, playerTeam ) )
+			continue
+
+		if ( !IsAlive( ent ) )
+			continue
+
+		// Don't consider targets that already got zapped
+		if ( ent in zapInfo.zappedTargets )
+			continue
+
+		//Preventing the arc-cannon from firing behind.
+		local vecToEnt = ( ent.GetWorldSpaceCenter() - eyePosition )
+		vecToEnt.Norm()
+		local dotVal = vecToEnt.Dot( viewVector )
+		if ( dotVal < 0 )
+			continue
+
+		// Check if we can see them, they aren't behind a wall or something
+		local ignoreEnts = []
+		ignoreEnts.append( zapInfo.player )
+		ignoreEnts.append( ent )
+
+		foreach( zappedTarget, val in zapInfo.zappedTargets )
+		{
+			if ( IsValid( zappedTarget ) )
+				ignoreEnts.append( zappedTarget )
+		}
+
+		local traceResult = TraceLineHighDetail( fromOrigin, ent.GetWorldSpaceCenter(), ignoreEnts, (TRACE_MASK_PLAYERSOLID_BRUSHONLY | TRACE_MASK_BLOCKLOS), TRACE_COLLISION_GROUP_NONE )
+
+		// Trace failed, lets try an eye to eye trace
+		if ( traceResult.fraction < 1 && IsValid( fromTarget ) )
+			traceResult = TraceLineHighDetail( fromTarget.EyePosition(), ent.EyePosition(), ignoreEnts, (TRACE_MASK_PLAYERSOLID_BRUSHONLY | TRACE_MASK_BLOCKLOS), TRACE_COLLISION_GROUP_NONE )
+
+		if ( traceResult.fraction < 1 )
+			continue
+
+		// Enemy is in visible, and within range.
+		if ( !IsValueInArray( results, ent ) )
+			results.append( ent )
+	}
+
+	//printt( "NEARBY TARGETS VALID AND VISIBLE:", results.len() )
+
+	return results
+}
+Globalize( GetArcCannonChainTargets )
+
+
+function IsEntANeutralMegaTurret( ent, playerTeam )
+{
+	if ( ent.GetClassname() != "npc_turret_mega" )
+		return false
+	local entTeam = ent.GetTeam()
+	if ( entTeam == playerTeam )
+		return false
+	if ( entTeam != GetOtherTeam( playerTeam ) )
+		return true
+
+	return false
+}
+Globalize( IsEntANeutralMegaTurret )
+
+function ArcCannon_HideIdleEffect( weapon, delay )
+{
+	//printt( "HideIdleEffect" )
+	weapon.EndSignal( ARC_CANNON_SIGNAL_DEACTIVATED )
+	weapon.StopWeaponEffect( "wpn_arc_cannon_electricity_fp", "wpn_arc_cannon_electricity" )
+	wait delay
+
+	if( !IsValid( weapon ) )
+		return
+
+	local weaponOwner = weapon.GetWeaponOwner()
+	//The weapon can be valid, but the player isn't a Titan during melee execute.
+	// JFS: threads with waits should just end on "OnDestroy"
+	if ( !IsValid(weaponOwner) )
+		return
+
+	if (  !weapon.GetWeaponOwner().IsTitan() || weapon != weaponOwner.GetActiveWeapon() )
+		return
+
+	weapon.PlayWeaponEffectNoCull( "wpn_arc_cannon_electricity_fp", "wpn_arc_cannon_electricity", "muzzle_flash" )
+	weapon.EmitWeaponSound( "arc_cannon_charged_loop" )
+}
+
+function AddToArcCannonTargets( ent )
+{
+	AddToScriptManagedEntArray( level._arcCannonTargetsArrayID, ent );
+}
+
+function GetArcCannonTargets( origin, team )
+{
+	local targets = GetScriptManagedEntArrayWithinCenter( level._arcCannonTargetsArrayID, team, origin, ARC_CANNON_TITAN_RANGE_CHAIN )
+
+	if ( ARC_CANNON_TARGETS_MISSILES )
+	{
+		local enemyTeam = GetEnemyTeam( team )
+		targets.extend( GetProjectileArrayEx( "rpg_missile", enemyTeam, origin, ARC_CANNON_TITAN_RANGE_CHAIN ) )
+	}
+
+	return targets
+}
+Globalize( GetArcCannonTargets )
+
+function GetArcCannonTargetsInRange( origin, team, weapon )
+{
+	local allTargets = GetArcCannonTargets( origin, team )
+	local targetsInRange = []
+
+	local titanDistSq
+	local distSq
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+	{
+		titanDistSq = ARC_CANNON_TITAN_RANGE_CHAIN_BURN * ARC_CANNON_TITAN_RANGE_CHAIN_BURN
+		distSq = ARC_CANNON_RANGE_CHAIN_BURN * ARC_CANNON_RANGE_CHAIN_BURN
+	}
+	else
+	{
+		titanDistSq = ARC_CANNON_TITAN_RANGE_CHAIN * ARC_CANNON_TITAN_RANGE_CHAIN
+		distSq = ARC_CANNON_RANGE_CHAIN * ARC_CANNON_RANGE_CHAIN
+	}
+
+	foreach( target in allTargets )
+	{
+		local d = DistanceSqr( target.GetOrigin(), origin )
+		local validDist = target.IsTitan() ? titanDistSq : distSq
+		if ( d <= validDist )
+			targetsInRange.append( target )
+	}
+
+	return targetsInRange
+}
+
+function SortArcCannonTargets( weapon, targets )
+{
+	Assert( targets.len() > 0 )
+	local originalTargetCount = targets.len()
+	//printt( "    sorting", originalTargetCount, "targets" )
+
+	local sortedTargets = []
+	local lastEnt = weapon.GetWeaponOwner()
+	local closestIndex = null
+	local closestEnt = null
+
+	while( targets.len() > 0 )
+	{
+		closestEnt = null
+		closestIndex = null
+
+		closestIndex = GetClosestIndex( targets, lastEnt.GetOrigin() )
+		Assert( closestIndex != null )
+		closestEnt = targets[ closestIndex ]
+		Assert( closestEnt != null )
+
+		sortedTargets.append( closestEnt )
+		targets.remove( closestIndex )
+
+		lastEnt = closestEnt
+	}
+
+	Assert( sortedTargets.len() == originalTargetCount )
+	return sortedTargets
+}
+
+function CreateArcCannonBeam( weapon, target, startPos, endPos, player, lifeDuration = ARC_CANNON_BEAM_LIFETIME, radius = 256, boltWidth = 4, noiseAmplitude = 5, hasTarget = true, firstBeam = false )
+{
+	Assert( startPos )
+	Assert( endPos )
+
+	//**************************
+	// 	LIGHTNING BEAM EFFECT
+	//**************************
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+		lifeDuration = ARC_CANNON_BEAM_LIFETIME_BURN
+	// If it's the first beam and on client we do a special beam so it's lined up with the muzzle origin
+	if ( IsClient() && firstBeam )
+		thread CreateClientArcBeam( weapon, endPos, lifeDuration, target )
+
+	if ( IsClient() )
+		return
+
+	// Control point sets the end position of the effect
+	local cpEnd = CreateEntity( "info_placement_helper" )
+	cpEnd.SetName( UniqueString( "arc_cannon_beam_cpEnd" ) )
+	cpEnd.SetOrigin( endPos )
+	DispatchSpawn( cpEnd, false )
+
+	local zapBeam = CreateEntity( "info_particle_system" )
+	zapBeam.kv.cpoint1 = cpEnd.GetName()
+
+	zapBeam.kv.effect_name = GetBeamEffect( weapon )
+
+	zapBeam.kv.start_active = 0
+	zapBeam.SetOwner( player )
+	zapBeam.SetOrigin( startPos )
+	if ( firstBeam )
+	{
+		zapBeam.kv.VisibilityFlags = 6	// everyone but owner
+		zapBeam.SetParent( player.GetActiveWeapon(), "muzzle_flash", false, 0.0 )
+	}
+	DispatchSpawn( zapBeam )
+
+	zapBeam.Fire( "Start" )
+	zapBeam.Fire( "StopPlayEndCap", "", lifeDuration )
+	zapBeam.Kill( lifeDuration )
+	cpEnd.Kill( lifeDuration )
+}
+
+function GetBeamEffect( weapon )
+{
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+		return ARC_CANNON_BEAM_EFFECT_MOD
+
+	return ARC_CANNON_BEAM_EFFECT
+}
+
+function CreateClientArcBeam( weapon, endPos, lifeDuration, target )
+{
+	Assert( IsClient() )
+
+	local beamEffect = GetBeamEffect( weapon )
+
+	weapon.PlayWeaponEffect( beamEffect, null, "muzzle_flash" )
+	local handle = weapon.AllocateHandleForViewmodelEffect( beamEffect )
+	if ( !EffectDoesExist( handle ) )
+		return
+
+	EffectSetControlPointVector( handle, 1, endPos )
+
+	if ( weapon.HasMod( "burn_mod_titan_arc_cannon" ) )
+		lifeDuration = ARC_CANNON_BEAM_LIFETIME_BURN
+
+	wait( lifeDuration )
+
+	if ( IsValid( weapon ) )
+		weapon.StopWeaponEffect( beamEffect, null )
+}
+
+function ClientDestroyCallback_ArcCannon_Stop( entity )
+{
+	ArcCannon_Stop( entity )
+}
+
+function GetArcCannonChargeFraction( weapon )
+{
+	if ( IsValid( weapon ) )
+	{
+		local chargeRatio = ARC_CANNON_DAMAGE_CHARGE_RATIO
+		if( weapon.HasModDefined( "capacitor" ) && weapon.HasMod( "capacitor" ) )
+			chargeRatio = ARC_CANNON_CAPACITOR_CHARGE_RATIO
+		if( weapon.GetWeaponModSetting( "is_burn_mod" ) )
+			chargeRatio = ARC_CANNON_DAMAGE_CHARGE_RATIO_BURN
+		return chargeRatio
+	}
+
+	return 0
+}
\ No newline at end of file