using System;
using System.Collections.Generic;
using Grumpy;
using RoR2.Networking;
using UnityEngine;
using UnityEngine.Networking;

namespace RoR2;

public class BulletAttack
{
	public enum FalloffModel
	{
		None,
		DefaultBullet,
		Buckshot
	}

	public delegate bool HitCallback(BulletAttack bulletAttack, ref BulletHit hitInfo);

	public delegate void ModifyOutgoingDamageCallback(BulletAttack bulletAttack, ref BulletHit hitInfo, DamageInfo damageInfo);

	public delegate bool FilterCallback(BulletAttack bulletAttack, ref BulletHit hitInfo);

	public class BulletHit
	{
		public Vector3 direction;

		public Vector3 point;

		public Vector3 surfaceNormal;

		public float distance;

		public Collider collider;

		public HurtBox hitHurtBox;

		public GameObject entityObject;

		public HurtBox.DamageModifier damageModifier;

		public bool isSniperHit;

		public HurtBox hurtBox;

		public void Reset()
		{
			direction = Vector3.zero;
			point = Vector3.zero;
			surfaceNormal = Vector3.zero;
			distance = 0f;
			collider = null;
			entityObject = null;
			damageModifier = HurtBox.DamageModifier.Normal;
			isSniperHit = false;
			hurtBox = null;
		}
	}

	public class BulletHitPool : GenericPool<BulletHit>
	{
		protected override BulletHit CreateNewObject(bool inPoolEntry = true)
		{
			return new BulletHit();
		}

		public void ReturnAllInUse()
		{
			if (_InUse != null)
			{
				for (int num = _InUse.Count - 1; num >= 0; num--)
				{
					ReturnObject(_InUse[num]);
				}
			}
		}
	}

	private static GameObject sniperTargetHitEffect;

	public GameObject owner;

	public GameObject weapon;

	public float damage = 1f;

	public bool isCrit;

	public float force = 1f;

	public ProcChainMask procChainMask;

	public float procCoefficient = 1f;

	public DamageTypeCombo damageType = DamageType.Generic;

	public DamageColorIndex damageColorIndex;

	public bool sniper;

	public FalloffModel falloffModel = FalloffModel.DefaultBullet;

	public GameObject tracerEffectPrefab;

	public GameObject hitEffectPrefab;

	public string muzzleName = "";

	public bool HitEffectNormal = true;

	public Vector3 origin;

	private Vector3 _aimVector;

	private float _maxDistance = 200f;

	public float radius;

	public uint bulletCount = 1u;

	public float minSpread;

	public float maxSpread;

	public float spreadPitchScale = 1f;

	public float spreadYawScale = 1f;

	public QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore;

	private static readonly LayerMask defaultHitMask = (int)LayerIndex.world.mask | (int)LayerIndex.entityPrecise.mask;

	public LayerMask hitMask = defaultHitMask;

	private static readonly LayerMask defaultStopperMask = defaultHitMask;

	public LayerMask stopperMask = defaultStopperMask;

	public bool smartCollision;

	public bool cheapMultiBullet;

	public float multiBulletOdds = 0.4f;

	public bool allowTrajectoryAimAssist = true;

	public float trajectoryAimAssistMultiplier = 1f;

	public HitCallback hitCallback;

	protected DamageInfo _dmgInfo;

	public static readonly HitCallback defaultHitCallback = DefaultHitCallbackImplementation;

	public ModifyOutgoingDamageCallback modifyOutgoingDamageCallback;

	private static NetworkWriter messageWriter = new NetworkWriter();

	public FilterCallback filterCallback;

	public static readonly FilterCallback defaultFilterCallback = DefaultFilterCallbackImplementation;

	protected static BulletHitPool __BulletHitPool = null;

	protected static List<BulletHit> _BulletHits = new List<BulletHit>();

	protected static List<GameObject> _IgnoreList = new List<GameObject>();

	protected static HashSet<GameObject> _EncounteredEntityObjects = new HashSet<GameObject>();

	protected static bool _UsePools = true;

	protected static EffectData _effectData = null;

	public Vector3 aimVector
	{
		get
		{
			return _aimVector;
		}
		set
		{
			_aimVector = value;
			_aimVector.Normalize();
		}
	}

	public float maxDistance
	{
		get
		{
			return _maxDistance;
		}
		set
		{
			if (!float.IsInfinity(value) && !float.IsNaN(value))
			{
				_maxDistance = value;
				return;
			}
			Debug.LogFormat("BulletAttack.maxDistance was assigned a value other than a finite number. value={0}", value);
		}
	}

	[Obsolete("Use .defaultHitCallback instead.", false)]
	public static HitCallback DefaultHitCallback => defaultHitCallback;

	[Obsolete("Use .defaultFilterCallback instead.", false)]
	public static FilterCallback DefaultFilterCallback => defaultFilterCallback;

	protected static BulletHitPool _BulletHitPool
	{
		get
		{
			if (__BulletHitPool == null)
			{
				__BulletHitPool = new BulletHitPool();
				__BulletHitPool.AlwaysGrowable = true;
				__BulletHitPool.Initialize(20, 10);
			}
			return __BulletHitPool;
		}
	}

	public static bool UsePools => _UsePools;

	public BulletAttack()
	{
		filterCallback = defaultFilterCallback;
		hitCallback = defaultHitCallback;
	}

	[InitDuringStartup]
	private static void Init()
	{
		LegacyResourcesAPI.LoadAsyncCallback("Prefabs/Effects/ImpactEffects/SniperTargetHitEffect", delegate(GameObject operationResult)
		{
			sniperTargetHitEffect = operationResult;
		});
	}

	public void Reset()
	{
		owner = null;
		weapon = null;
		damage = 1f;
		isCrit = false;
		force = 1f;
		procChainMask.mask = 0u;
		procCoefficient = 1f;
		damageType = DamageType.Generic;
		damageColorIndex = DamageColorIndex.Default;
		sniper = false;
		falloffModel = FalloffModel.DefaultBullet;
		tracerEffectPrefab = null;
		hitEffectPrefab = null;
		muzzleName = "";
		HitEffectNormal = true;
		origin = Vector3.zero;
		_aimVector = Vector3.zero;
		_maxDistance = 200f;
		radius = 0f;
		bulletCount = 1u;
		minSpread = 0f;
		maxSpread = 0f;
		spreadPitchScale = 1f;
		spreadYawScale = 1f;
		queryTriggerInteraction = QueryTriggerInteraction.Ignore;
		hitMask = defaultHitMask;
		stopperMask = defaultStopperMask;
		smartCollision = false;
		cheapMultiBullet = false;
		filterCallback = defaultFilterCallback;
		hitCallback = defaultHitCallback;
	}

	private static void PlayHitEffect(BulletAttack bulletAttack, ref BulletHit hitInfo)
	{
		if ((bool)bulletAttack.hitEffectPrefab)
		{
			EffectManager.SimpleImpactEffect(bulletAttack.hitEffectPrefab, hitInfo.point, bulletAttack.HitEffectNormal ? hitInfo.surfaceNormal : (-hitInfo.direction), transmit: true);
		}
		if (hitInfo.isSniperHit && (object)sniperTargetHitEffect != null)
		{
			EffectData effectData = new EffectData
			{
				origin = hitInfo.point,
				rotation = Quaternion.LookRotation(-hitInfo.direction)
			};
			effectData.SetHurtBoxReference(hitInfo.hitHurtBox);
			EffectManager.SpawnEffect(sniperTargetHitEffect, effectData, transmit: true);
		}
		if ((bool)hitInfo.collider)
		{
			SurfaceDef objectSurfaceDef = SurfaceDefProvider.GetObjectSurfaceDef(hitInfo.collider, hitInfo.point);
			if ((bool)objectSurfaceDef && (bool)objectSurfaceDef.impactEffectPrefab)
			{
				EffectData effectData2 = new EffectData
				{
					origin = hitInfo.point,
					rotation = Quaternion.LookRotation(hitInfo.surfaceNormal),
					color = objectSurfaceDef.approximateColor,
					surfaceDefIndex = objectSurfaceDef.surfaceDefIndex
				};
				EffectManager.SpawnEffect(objectSurfaceDef.impactEffectPrefab, effectData2, transmit: true);
			}
		}
	}

	private static bool DefaultHitCallbackImplementation(BulletAttack bulletAttack, ref BulletHit hitInfo)
	{
		bool result = false;
		if ((bool)hitInfo.collider)
		{
			result = ((1 << hitInfo.collider.gameObject.layer) & (int)bulletAttack.stopperMask) == 0;
		}
		PlayHitEffect(bulletAttack, ref hitInfo);
		GameObject entityObject = hitInfo.entityObject;
		if ((bool)entityObject)
		{
			float num = CalcFalloffFactor(bulletAttack.falloffModel, hitInfo.distance);
			DamageInfo damageInfo = new DamageInfo();
			damageInfo.damage = bulletAttack.damage * num;
			damageInfo.crit = bulletAttack.isCrit;
			damageInfo.attacker = bulletAttack.owner;
			damageInfo.inflictor = bulletAttack.weapon;
			damageInfo.position = hitInfo.point;
			damageInfo.force = hitInfo.direction * (bulletAttack.force * num);
			damageInfo.procChainMask = bulletAttack.procChainMask;
			damageInfo.procCoefficient = bulletAttack.procCoefficient;
			damageInfo.damageType = bulletAttack.damageType;
			damageInfo.damageColorIndex = bulletAttack.damageColorIndex;
			damageInfo.ModifyDamageInfo(hitInfo.damageModifier);
			if (hitInfo.isSniperHit)
			{
				damageInfo.crit = true;
				damageInfo.damageColorIndex = DamageColorIndex.Sniper;
			}
			bulletAttack.modifyOutgoingDamageCallback?.Invoke(bulletAttack, ref hitInfo, damageInfo);
			TeamIndex attackerTeamIndex = TeamIndex.None;
			if ((bool)bulletAttack.owner)
			{
				TeamComponent component = bulletAttack.owner.GetComponent<TeamComponent>();
				if ((bool)component)
				{
					attackerTeamIndex = component.teamIndex;
				}
			}
			HealthComponent healthComponent = null;
			if ((bool)hitInfo.hitHurtBox)
			{
				healthComponent = hitInfo.hitHurtBox.healthComponent;
			}
			bool flag = (bool)healthComponent && FriendlyFireManager.ShouldDirectHitProceed(healthComponent, attackerTeamIndex);
			if (NetworkServer.active)
			{
				if (flag)
				{
					healthComponent.TakeDamage(damageInfo);
					GlobalEventManager.instance.OnHitEnemy(damageInfo, hitInfo.entityObject);
				}
				GlobalEventManager.instance.OnHitAll(damageInfo, hitInfo.entityObject);
			}
			else if (ClientScene.ready)
			{
				messageWriter.StartMessage(53);
				int currentLogLevel = LogFilter.currentLogLevel;
				LogFilter.currentLogLevel = 4;
				messageWriter.Write(entityObject);
				LogFilter.currentLogLevel = currentLogLevel;
				messageWriter.Write(damageInfo);
				messageWriter.Write(flag);
				messageWriter.FinishMessage();
				ClientScene.readyConnection.SendWriter(messageWriter, QosChannelIndex.defaultReliable.intVal);
			}
		}
		return result;
	}

	private static float CalcFalloffFactor(FalloffModel falloffModel, float distance)
	{
		return falloffModel switch
		{
			FalloffModel.DefaultBullet => 0.5f + Mathf.Clamp01(Mathf.InverseLerp(60f, 25f, distance)) * 0.5f, 
			FalloffModel.Buckshot => 0.25f + Mathf.Clamp01(Mathf.InverseLerp(25f, 7f, distance)) * 0.75f, 
			_ => 1f, 
		};
	}

	private static bool DefaultFilterCallbackImplementation(BulletAttack bulletAttack, ref BulletHit hitInfo)
	{
		HurtBox component = hitInfo.collider.GetComponent<HurtBox>();
		if ((bool)component && (bool)component.healthComponent && component.healthComponent.gameObject == bulletAttack.weapon)
		{
			return false;
		}
		return hitInfo.entityObject != bulletAttack.weapon;
	}

	private void InitBulletHitFromOriginHit(ref BulletHit bulletHit, Vector3 direction, Collider hitCollider)
	{
		bulletHit.direction = direction;
		bulletHit.point = origin;
		bulletHit.surfaceNormal = -direction;
		bulletHit.distance = 0f;
		bulletHit.collider = hitCollider;
		HurtBox component = bulletHit.collider.GetComponent<HurtBox>();
		bulletHit.hitHurtBox = component;
		bulletHit.entityObject = (((bool)component && (bool)component.healthComponent) ? component.healthComponent.gameObject : bulletHit.collider.gameObject);
		bulletHit.damageModifier = (component ? component.damageModifier : HurtBox.DamageModifier.Normal);
	}

	private void InitBulletHitFromRaycastHit(ref BulletHit bulletHit, Vector3 origin, Vector3 direction, ref RaycastHit raycastHit)
	{
		bulletHit.direction = direction;
		bulletHit.surfaceNormal = raycastHit.normal;
		bulletHit.distance = raycastHit.distance;
		bulletHit.collider = raycastHit.collider;
		bulletHit.point = ((bulletHit.distance == 0f) ? origin : raycastHit.point);
		HurtBox component = bulletHit.collider.GetComponent<HurtBox>();
		bulletHit.hitHurtBox = component;
		bulletHit.entityObject = (((bool)component && (bool)component.healthComponent) ? component.healthComponent.gameObject : bulletHit.collider.gameObject);
		bulletHit.damageModifier = (component ? component.damageModifier : HurtBox.DamageModifier.Normal);
	}

	private bool ProcessHit(ref BulletHit hitInfo)
	{
		if (!filterCallback(this, ref hitInfo))
		{
			return true;
		}
		if (sniper)
		{
			hitInfo.isSniperHit = IsSniperTargetHit(in hitInfo);
		}
		return hitCallback(this, ref hitInfo);
	}

	private static bool IsSniperTargetHit(in BulletHit hitInfo)
	{
		if ((bool)hitInfo.hitHurtBox && (bool)hitInfo.hitHurtBox.hurtBoxGroup)
		{
			HurtBox[] hurtBoxes = hitInfo.hitHurtBox.hurtBoxGroup.hurtBoxes;
			foreach (HurtBox hurtBox in hurtBoxes)
			{
				if ((bool)hurtBox && hurtBox.isSniperTarget && Vector3.ProjectOnPlane(hitInfo.point - hurtBox.transform.position, hitInfo.direction).sqrMagnitude <= HurtBox.sniperTargetRadiusSqr)
				{
					return true;
				}
			}
		}
		return false;
	}

	private GameObject ProcessHitList(List<BulletHit> hits, ref Vector3 endPosition, List<GameObject> ignoreList)
	{
		int count = hits.Count;
		int[] array = new int[count];
		for (int i = 0; i < count; i++)
		{
			array[i] = i;
		}
		for (int j = 0; j < count; j++)
		{
			float distance = maxDistance;
			int num = j;
			for (int k = j; k < count; k++)
			{
				int index = array[k];
				if (hits[index].distance < distance)
				{
					distance = hits[index].distance;
					num = k;
				}
			}
			GameObject entityObject = hits[array[num]].entityObject;
			if (!ignoreList.Contains(entityObject))
			{
				ignoreList.Add(entityObject);
				BulletHit hitInfo = hits[array[num]];
				if (!ProcessHit(ref hitInfo))
				{
					endPosition = hits[array[num]].point;
					return entityObject;
				}
			}
			array[num] = array[j];
		}
		return null;
	}

	private static GameObject LookUpColliderEntityObject(Collider collider)
	{
		HurtBox component = collider.GetComponent<HurtBox>();
		if (!component || !component.healthComponent)
		{
			return collider.gameObject;
		}
		return component.healthComponent.gameObject;
	}

	private static Collider[] PhysicsOverlapPoint(Vector3 point, int layerMask = -1, QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore)
	{
		return Physics.OverlapBox(point, Vector3.zero, Quaternion.identity, layerMask, queryTriggerInteraction);
	}

	public void Fire()
	{
		if (allowTrajectoryAimAssist)
		{
			aimVector = TrajectoryAimAssist.ApplyTrajectoryAimAssist(aimVector, origin, maxDistance, owner, weapon, trajectoryAimAssistMultiplier);
		}
		Vector3[] array = new Vector3[bulletCount];
		Vector3 up = Vector3.up;
		Vector3 axis = Vector3.Cross(up, aimVector);
		for (int i = 0; i < bulletCount; i++)
		{
			float x = UnityEngine.Random.Range(minSpread, maxSpread);
			float z = UnityEngine.Random.Range(0f, 360f);
			Vector3 vector = Quaternion.Euler(0f, 0f, z) * (Quaternion.Euler(x, 0f, 0f) * Vector3.forward);
			float y = vector.y;
			vector.y = 0f;
			float angle = (Mathf.Atan2(vector.z, vector.x) * 57.29578f - 90f) * spreadYawScale;
			float angle2 = Mathf.Atan2(y, vector.magnitude) * 57.29578f * spreadPitchScale;
			array[i] = Quaternion.AngleAxis(angle, up) * (Quaternion.AngleAxis(angle2, axis) * aimVector);
		}
		int muzzleIndex = -1;
		if (!weapon)
		{
			weapon = owner;
		}
		if ((bool)weapon)
		{
			ModelLocator component = weapon.GetComponent<ModelLocator>();
			if ((bool)component && (bool)component.modelTransform)
			{
				ChildLocator component2 = component.modelTransform.GetComponent<ChildLocator>();
				if ((bool)component2)
				{
					muzzleIndex = component2.FindChildIndex(muzzleName);
				}
			}
		}
		Vector3 axis2 = Vector3.Cross(Vector3.up, aimVector);
		Vector3 forward = Vector3.forward;
		if (cheapMultiBullet)
		{
			float x2 = UnityEngine.Random.Range(minSpread, maxSpread);
			float z2 = UnityEngine.Random.Range(0f, 360f);
			Vector3 vector2 = Quaternion.Euler(0f, 0f, z2) * (Quaternion.Euler(x2, 0f, 0f) * Vector3.forward);
			float y2 = vector2.y;
			vector2.y = 0f;
			float angle3 = (Mathf.Atan2(vector2.z, vector2.x) * 57.29578f - 90f) * spreadYawScale;
			float angle4 = Mathf.Atan2(y2, vector2.magnitude) * 57.29578f * spreadPitchScale;
			forward = Quaternion.AngleAxis(angle3, Vector3.up) * (Quaternion.AngleAxis(angle4, axis2) * aimVector);
			FireMulti(forward, muzzleIndex);
			return;
		}
		for (int j = 0; j < bulletCount; j++)
		{
			float x3 = UnityEngine.Random.Range(minSpread, maxSpread);
			float z3 = UnityEngine.Random.Range(0f, 360f);
			Vector3 vector3 = Quaternion.Euler(0f, 0f, z3) * (Quaternion.Euler(x3, 0f, 0f) * Vector3.forward);
			float y3 = vector3.y;
			vector3.y = 0f;
			float angle5 = (Mathf.Atan2(vector3.z, vector3.x) * 57.29578f - 90f) * spreadYawScale;
			float angle6 = Mathf.Atan2(y3, vector3.magnitude) * 57.29578f * spreadPitchScale;
			forward = Quaternion.AngleAxis(angle5, Vector3.up) * (Quaternion.AngleAxis(angle6, axis2) * aimVector);
			FireSingle(forward, muzzleIndex);
		}
	}

	public Vector3 Fire_ReturnHit()
	{
		int muzzleIndex = -1;
		_ = origin;
		if (!weapon)
		{
			weapon = owner;
		}
		if ((bool)weapon)
		{
			ModelLocator component = weapon.GetComponent<ModelLocator>();
			if ((bool)component && (bool)component.modelTransform)
			{
				ChildLocator component2 = component.modelTransform.GetComponent<ChildLocator>();
				if ((bool)component2)
				{
					muzzleIndex = component2.FindChildIndex(muzzleName);
				}
			}
		}
		Vector3 axis = Vector3.Cross(Vector3.up, aimVector);
		Vector3 forward = Vector3.forward;
		Vector3 result = Vector3.zero;
		for (int i = 0; i < bulletCount; i++)
		{
			float x = UnityEngine.Random.Range(minSpread, maxSpread);
			float z = UnityEngine.Random.Range(0f, 360f);
			Vector3 vector = Quaternion.Euler(0f, 0f, z) * (Quaternion.Euler(x, 0f, 0f) * Vector3.forward);
			float y = vector.y;
			vector.y = 0f;
			float angle = (Mathf.Atan2(vector.z, vector.x) * 57.29578f - 90f) * spreadYawScale;
			float angle2 = Mathf.Atan2(y, vector.magnitude) * 57.29578f * spreadPitchScale;
			forward = Quaternion.AngleAxis(angle, Vector3.up) * (Quaternion.AngleAxis(angle2, axis) * aimVector);
			result = FireSingle_ReturnHit(forward, muzzleIndex);
		}
		return result;
	}

	public static void TogglePooling()
	{
		_UsePools = !_UsePools;
		Debug.LogFormat("BulletAttack pooling {0}", _UsePools ? "ENABLED" : "DISABLED");
	}

	public static void DumpPools()
	{
		Debug.LogFormat("BulletAttack Pool: Pooled {0}, InUse {1}", _BulletHitPool.PoolCount(), _BulletHitPool.InUseCount());
	}

	protected static BulletHit GetBulletHit()
	{
		BulletHit @object = _BulletHitPool.GetObject();
		@object.Reset();
		return @object;
	}

	private void FireSingle(Vector3 normal, int muzzleIndex)
	{
		if (_UsePools)
		{
			float distance = maxDistance;
			Vector3 endPosition = origin + normal * maxDistance;
			_BulletHits.Clear();
			bool num = radius == 0f || smartCollision;
			bool flag = radius != 0f;
			if (smartCollision)
			{
				_EncounteredEntityObjects.Clear();
			}
			if (num)
			{
				int num2 = 0;
				num2 = HGPhysics.RaycastAll(out var hits, origin, normal, distance, hitMask, queryTriggerInteraction);
				for (int i = 0; i < num2; i++)
				{
					BulletHit bulletHit = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit, origin, normal, ref hits[i]);
					_BulletHits.Add(bulletHit);
					if (smartCollision)
					{
						_EncounteredEntityObjects.Add(bulletHit.entityObject);
					}
					if (bulletHit.distance < distance)
					{
						distance = bulletHit.distance;
					}
				}
				HGPhysics.ReturnResults(hits);
			}
			if (flag)
			{
				LayerMask layerMask = hitMask;
				if (smartCollision)
				{
					layerMask = (int)layerMask & ~(int)LayerIndex.world.mask;
				}
				int num3 = 0;
				num3 = HGPhysics.SphereCastAll(out var hits2, origin, radius, normal, distance, layerMask, queryTriggerInteraction);
				for (int j = 0; j < num3; j++)
				{
					BulletHit bulletHit2 = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit2, origin, normal, ref hits2[j]);
					if (!smartCollision || !_EncounteredEntityObjects.Contains(bulletHit2.entityObject))
					{
						_BulletHits.Add(bulletHit2);
					}
				}
				HGPhysics.ReturnResults(hits2);
			}
			_IgnoreList.Clear();
			ProcessHitList(_BulletHits, ref endPosition, _IgnoreList);
			if ((bool)tracerEffectPrefab)
			{
				if (_effectData == null)
				{
					_effectData = new EffectData();
				}
				_effectData.Reset();
				_effectData.origin = endPosition;
				_effectData.start = origin;
				_effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
				EffectManager.SpawnEffect(tracerEffectPrefab, _effectData, transmit: true);
			}
			_BulletHitPool.ReturnAllInUse();
			_EncounteredEntityObjects.Clear();
			return;
		}
		float distance2 = maxDistance;
		Vector3 endPosition2 = origin + normal * maxDistance;
		List<BulletHit> list = new List<BulletHit>();
		bool num4 = radius == 0f || smartCollision;
		bool flag2 = radius != 0f;
		HashSet<GameObject> hashSet = null;
		if (smartCollision)
		{
			hashSet = new HashSet<GameObject>();
		}
		if (num4)
		{
			int num5 = 0;
			num5 = HGPhysics.RaycastAll(out var hits3, origin, normal, distance2, hitMask, queryTriggerInteraction);
			for (int k = 0; k < num5; k++)
			{
				BulletHit bulletHit3 = new BulletHit();
				InitBulletHitFromRaycastHit(ref bulletHit3, origin, normal, ref hits3[k]);
				list.Add(bulletHit3);
				if (smartCollision)
				{
					hashSet.Add(bulletHit3.entityObject);
				}
				if (bulletHit3.distance < distance2)
				{
					distance2 = bulletHit3.distance;
				}
			}
			HGPhysics.ReturnResults(hits3);
		}
		if (flag2)
		{
			LayerMask layerMask2 = hitMask;
			if (smartCollision)
			{
				layerMask2 = (int)layerMask2 & ~(int)LayerIndex.world.mask;
			}
			int num6 = 0;
			num6 = HGPhysics.SphereCastAll(out var hits4, origin, radius, normal, distance2, layerMask2, queryTriggerInteraction);
			for (int l = 0; l < num6; l++)
			{
				BulletHit bulletHit4 = new BulletHit();
				InitBulletHitFromRaycastHit(ref bulletHit4, origin, normal, ref hits4[l]);
				if (!smartCollision || !hashSet.Contains(bulletHit4.entityObject))
				{
					list.Add(bulletHit4);
				}
			}
			HGPhysics.ReturnResults(hits4);
		}
		ProcessHitList(list, ref endPosition2, new List<GameObject>());
		if ((bool)tracerEffectPrefab)
		{
			EffectData effectData = new EffectData
			{
				origin = endPosition2,
				start = origin
			};
			effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
			EffectManager.SpawnEffect(tracerEffectPrefab, effectData, transmit: true);
		}
	}

	private void FireMulti(Vector3 normal, int muzzleIndex)
	{
		if (_UsePools)
		{
			float distance = maxDistance;
			Vector3 endPosition = origin + normal * maxDistance;
			_BulletHits.Clear();
			bool num = radius == 0f || smartCollision;
			bool flag = radius != 0f;
			if (smartCollision)
			{
				_EncounteredEntityObjects.Clear();
			}
			if (num)
			{
				int num2 = 0;
				num2 = HGPhysics.RaycastAll(out var hits, origin, normal, distance, hitMask, queryTriggerInteraction);
				for (int i = 0; i < num2; i++)
				{
					BulletHit bulletHit = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit, origin, normal, ref hits[i]);
					_BulletHits.Add(bulletHit);
					if (smartCollision)
					{
						_EncounteredEntityObjects.Add(bulletHit.entityObject);
					}
					if (bulletHit.distance < distance)
					{
						distance = bulletHit.distance;
					}
				}
				HGPhysics.ReturnResults(hits);
			}
			if (flag)
			{
				LayerMask layerMask = hitMask;
				if (smartCollision)
				{
					layerMask = (int)layerMask & ~(int)LayerIndex.world.mask;
				}
				int num3 = 0;
				num3 = HGPhysics.SphereCastAll(out var hits2, origin, radius, normal, distance, layerMask, queryTriggerInteraction);
				for (int j = 0; j < num3; j++)
				{
					BulletHit bulletHit2 = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit2, origin, normal, ref hits2[j]);
					if (!smartCollision || !_EncounteredEntityObjects.Contains(bulletHit2.entityObject))
					{
						_BulletHits.Add(bulletHit2);
					}
				}
				HGPhysics.ReturnResults(hits2);
			}
			_IgnoreList.Clear();
			ProcessHitList(_BulletHits, ref endPosition, _IgnoreList);
			if ((bool)tracerEffectPrefab)
			{
				if (_effectData == null)
				{
					_effectData = new EffectData();
				}
				_effectData.Reset();
				_effectData.origin = endPosition;
				_effectData.start = origin;
				_effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
				EffectManager.SpawnEffect(tracerEffectPrefab, _effectData, transmit: true);
			}
			_BulletHitPool.ReturnAllInUse();
			_EncounteredEntityObjects.Clear();
			return;
		}
		float distance2 = maxDistance;
		Vector3 endPosition2 = origin + normal * maxDistance;
		List<BulletHit> list = new List<BulletHit>();
		bool num4 = radius == 0f || smartCollision;
		bool flag2 = radius != 0f;
		HashSet<GameObject> hashSet = null;
		if (smartCollision)
		{
			hashSet = new HashSet<GameObject>();
		}
		if (num4)
		{
			int num5 = 0;
			num5 = HGPhysics.RaycastAll(out var hits3, origin, normal, distance2, hitMask, queryTriggerInteraction);
			for (int k = 0; k < num5; k++)
			{
				BulletHit bulletHit3 = new BulletHit();
				InitBulletHitFromRaycastHit(ref bulletHit3, origin, normal, ref hits3[k]);
				list.Add(bulletHit3);
				if (smartCollision)
				{
					hashSet.Add(bulletHit3.entityObject);
				}
				if (bulletHit3.distance < distance2)
				{
					distance2 = bulletHit3.distance;
				}
			}
			HGPhysics.ReturnResults(hits3);
		}
		if (flag2)
		{
			LayerMask layerMask2 = hitMask;
			if (smartCollision)
			{
				layerMask2 = (int)layerMask2 & ~(int)LayerIndex.world.mask;
			}
			int num6 = 0;
			num6 = HGPhysics.SphereCastAll(out var hits4, origin, radius, normal, distance2, layerMask2, queryTriggerInteraction);
			for (int l = 0; l < num6; l++)
			{
				BulletHit bulletHit4 = new BulletHit();
				InitBulletHitFromRaycastHit(ref bulletHit4, origin, normal, ref hits4[l]);
				if (!smartCollision || !hashSet.Contains(bulletHit4.entityObject))
				{
					list.Add(bulletHit4);
				}
			}
			HGPhysics.ReturnResults(hits4);
		}
		ProcessHitList(list, ref endPosition2, new List<GameObject>());
		if ((bool)tracerEffectPrefab)
		{
			EffectData effectData = new EffectData
			{
				origin = endPosition2,
				start = origin
			};
			effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
			EffectManager.SpawnEffect(tracerEffectPrefab, effectData, transmit: true);
		}
	}

	private Vector3 FireSingle_ReturnHit(Vector3 normal, int muzzleIndex)
	{
		Vector3 endPosition;
		if (_UsePools)
		{
			float distance = maxDistance;
			endPosition = origin + normal * maxDistance;
			_BulletHits.Clear();
			bool num = radius == 0f || smartCollision;
			bool flag = radius != 0f;
			if (smartCollision)
			{
				_EncounteredEntityObjects.Clear();
			}
			if (num)
			{
				int num2 = 0;
				num2 = HGPhysics.RaycastAll(out var hits, origin, normal, distance, hitMask, queryTriggerInteraction);
				for (int i = 0; i < num2; i++)
				{
					BulletHit bulletHit = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit, origin, normal, ref hits[i]);
					_BulletHits.Add(bulletHit);
					if (smartCollision)
					{
						_EncounteredEntityObjects.Add(bulletHit.entityObject);
					}
					if (bulletHit.distance < distance)
					{
						distance = bulletHit.distance;
					}
				}
				HGPhysics.ReturnResults(hits);
			}
			if (flag)
			{
				LayerMask layerMask = hitMask;
				if (smartCollision)
				{
					layerMask = (int)layerMask & ~(int)LayerIndex.world.mask;
				}
				int num3 = 0;
				num3 = HGPhysics.SphereCastAll(out var hits2, origin, radius, normal, distance, layerMask, queryTriggerInteraction);
				for (int j = 0; j < num3; j++)
				{
					BulletHit bulletHit2 = GetBulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit2, origin, normal, ref hits2[j]);
					if (!smartCollision || !_EncounteredEntityObjects.Contains(bulletHit2.entityObject))
					{
						_BulletHits.Add(bulletHit2);
					}
				}
				HGPhysics.ReturnResults(hits2);
			}
			_IgnoreList.Clear();
			ProcessHitList(_BulletHits, ref endPosition, _IgnoreList);
			if ((bool)tracerEffectPrefab)
			{
				if (_effectData == null)
				{
					_effectData = new EffectData();
				}
				_effectData.Reset();
				_effectData.origin = endPosition;
				_effectData.start = origin;
				_effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
				EffectManager.SpawnEffect(tracerEffectPrefab, _effectData, transmit: true);
			}
			_BulletHitPool.ReturnAllInUse();
			_EncounteredEntityObjects.Clear();
		}
		else
		{
			float distance2 = maxDistance;
			endPosition = origin + normal * maxDistance;
			List<BulletHit> list = new List<BulletHit>();
			bool num4 = radius == 0f || smartCollision;
			bool flag2 = radius != 0f;
			HashSet<GameObject> hashSet = null;
			if (smartCollision)
			{
				hashSet = new HashSet<GameObject>();
			}
			if (num4)
			{
				int num5 = 0;
				num5 = HGPhysics.RaycastAll(out var hits3, origin, normal, distance2, hitMask, queryTriggerInteraction);
				for (int k = 0; k < num5; k++)
				{
					BulletHit bulletHit3 = new BulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit3, origin, normal, ref hits3[k]);
					list.Add(bulletHit3);
					if (smartCollision)
					{
						hashSet.Add(bulletHit3.entityObject);
					}
					if (bulletHit3.distance < distance2)
					{
						distance2 = bulletHit3.distance;
					}
				}
				HGPhysics.ReturnResults(hits3);
			}
			if (flag2)
			{
				LayerMask layerMask2 = hitMask;
				if (smartCollision)
				{
					layerMask2 = (int)layerMask2 & ~(int)LayerIndex.world.mask;
				}
				int num6 = 0;
				num6 = HGPhysics.SphereCastAll(out var hits4, origin, radius, normal, distance2, layerMask2, queryTriggerInteraction);
				for (int l = 0; l < num6; l++)
				{
					BulletHit bulletHit4 = new BulletHit();
					InitBulletHitFromRaycastHit(ref bulletHit4, origin, normal, ref hits4[l]);
					if (!smartCollision || !hashSet.Contains(bulletHit4.entityObject))
					{
						list.Add(bulletHit4);
					}
				}
				HGPhysics.ReturnResults(hits4);
			}
			ProcessHitList(list, ref endPosition, new List<GameObject>());
			if ((bool)tracerEffectPrefab)
			{
				EffectData effectData = new EffectData
				{
					origin = endPosition,
					start = origin
				};
				effectData.SetChildLocatorTransformReference(weapon, muzzleIndex);
				EffectManager.SpawnEffect(tracerEffectPrefab, effectData, transmit: true);
			}
		}
		return endPosition;
	}

	[NetworkMessageHandler(msgType = 53, server = true)]
	private static void HandleBulletDamage(NetworkMessage netMsg)
	{
		NetworkReader reader = netMsg.reader;
		GameObject gameObject = reader.ReadGameObject();
		DamageInfo damageInfo = reader.ReadDamageInfo();
		if (reader.ReadBoolean() && (bool)gameObject)
		{
			HealthComponent component = gameObject.GetComponent<HealthComponent>();
			if ((bool)component)
			{
				component.TakeDamage(damageInfo);
			}
			GlobalEventManager.instance.OnHitEnemy(damageInfo, gameObject);
		}
		GlobalEventManager.instance.OnHitAll(damageInfo, gameObject);
	}
}