using System;
using System.Collections.Generic;
using UnityEngine;
using XUpdater;
using XUtliPoolLib;

namespace XMainClient
{
	internal class XBullet
	{
		public XBulletCore BulletCore
		{
			get
			{
				return this._data;
			}
		}

		public ulong ID
		{
			get
			{
				return this._id;
			}
		}

		public ulong ExtraID
		{
			get
			{
				return this._extra_id;
			}
			set
			{
				this._extra_id = value;
			}
		}

		private ulong _id = 0UL;

		private ulong _extra_id = 0UL;

		private bool _active = true;

		private bool _effectual = true;

		private bool _pingpong = false;

		private bool _hit_triggered = false;

		private int _tail_results = 0;

		private uint _tail_results_token = 0u;

		private float _elapsed = 0f;

		private XFx _bullet = null;

		private XBulletCore _data;

		private Vector3 _origin = Vector3.zero;

		private SmallBuffer<XBullet.XBulletTarget> _hurt_target;

		private IXFmod _iFmod;

		public struct XBulletTarget
		{
			public ulong TargetID;

			public uint TimerToken;

			public bool Hurtable;

			public int HurtCount;
		}

		public XBullet(ulong id, XBulletCore data)
		{
			this.Init(id, data);
		}

		public void Deny()
		{
			this._effectual = false;
		}

		private void LoadFinish(UnityEngine.Object obj, object cbOjb)
		{
			bool flag = this._iFmod != null;
			if (flag)
			{
				this._iFmod.Destroy();
				XSingleton<XUpdater.XUpdater>.singleton.XPlatform.ReturnClass(EClassType.ERuntimeFMOD, this._iFmod);
				this._iFmod = null;
			}
			bool flag2 = !string.IsNullOrEmpty(this._data.Result.LongAttackData.Audio);
			if (flag2)
			{
				this._iFmod = (XSingleton<XUpdater.XUpdater>.singleton.XPlatform.CreateClass(EClassType.ERuntimeFMOD) as IXFmod);
				Rigidbody rigidbody = null;
				GameObject gameObject = obj as GameObject;
				bool flag3 = gameObject != null;
				if (flag3)
				{
					rigidbody = gameObject.GetComponent<Rigidbody>();
				}
				bool flag4 = this._iFmod != null;
				if (flag4)
				{
					this._iFmod.Init(gameObject, rigidbody);
					XSingleton<XAudioMgr>.singleton.PlaySound(this._iFmod, AudioChannel.Motion, this._data.Result.LongAttackData.Audio);
				}
			}
		}

		private XFx FilterFx(string path)
		{
			bool flag = string.IsNullOrEmpty(path);
			XFx result;
			if (flag)
			{
				result = XSingleton<XFxMgr>.singleton.CreateFx("", new LoadCallBack(this.LoadFinish), true);
			}
			else
			{
				bool flag2 = XSingleton<XScene>.singleton.FilterFx && (this._data.Firer == null || (!this._data.Firer.IsPlayer && !this._data.Firer.IsBoss && !(this._data.Firer is XDummy))) && (this._data.Target == null || !this._data.Target.IsPlayer);
				if (flag2)
				{
					Vector3 position = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position;
					Vector3 origin = this._data.BulletRay.origin;
					float num = XFxMgr.FilterFxDis4;
					float num2 = (origin.x - position.x) * (origin.x - position.x) + (origin.z - position.z) * (origin.z - position.z);
					bool flag3 = this._data.Result != null && this._data.Result.LongAttackData != null;
					if (flag3)
					{
						num = this._data.Result.LongAttackData.Velocity * this._data.Result.LongAttackData.Runningtime;
					}
					bool flag4 = num2 < XFxMgr.FilterFxDis4 || num2 < num * num;
					if (flag4)
					{
						result = XSingleton<XFxMgr>.singleton.CreateFx(this._data.Prefab, new LoadCallBack(this.LoadFinish), true);
					}
					else
					{
						result = XSingleton<XFxMgr>.singleton.CreateFx("", new LoadCallBack(this.LoadFinish), true);
					}
				}
				else
				{
					result = XSingleton<XFxMgr>.singleton.CreateFx(path, null, true);
				}
			}
			return result;
		}

		public void Init(ulong id, XBulletCore data)
		{
			this._id = id;
			this._extra_id = 0UL;
			this._active = true;
			this._effectual = true;
			this._tail_results = 0;
			this._pingpong = false;
			this._hit_triggered = false;
			this._elapsed = 0f;
			this._data = data;
			this._origin = Vector3.zero;
			string path = XSingleton<XGlobalConfig>.singleton.PreFilterPrefab(this._data.Prefab);
			this._bullet = this.FilterFx(path);
			this._bullet.Play(this._data.BulletRay.origin, (this._data.Velocity > 0f) ? Quaternion.LookRotation(this._data.BulletRay.direction) : Quaternion.LookRotation(this._data.Firer.EngineObject.Forward), Vector3.one, 1f);
			this._hurt_target.debugName = "XBullet._hurt_target";
			XSingleton<XBulletMgr>.singleton.GetSmallBuffer(ref this._hurt_target, 4);
		}

		private void OnRefined(object o)
		{
			ulong num = (ulong)o;
			int i = 0;
			int count = this._hurt_target.Count;
			while (i < count)
			{
				XBullet.XBulletTarget xbulletTarget = this._hurt_target[i];
				bool flag = xbulletTarget.TargetID == num && xbulletTarget.HurtCount < this._data.Result.LongAttackData.Refine_Count;
				if (flag)
				{
					xbulletTarget.Hurtable = true;
					this._hurt_target[i] = xbulletTarget;
					break;
				}
				i++;
			}
		}

		private void OnRefined()
		{
			int i = 0;
			int count = this._hurt_target.Count;
			while (i < count)
			{
				XBullet.XBulletTarget xbulletTarget = this._hurt_target[i];
				xbulletTarget.Hurtable = true;
				xbulletTarget.HurtCount = 0;
				XSingleton<XTimerMgr>.singleton.KillTimer(xbulletTarget.TimerToken);
				this._hurt_target[i] = xbulletTarget;
				i++;
			}
		}

		private void OnPingPong()
		{
			this._pingpong = true;
			bool autoRefine_at_Half = this._data.Result.LongAttackData.AutoRefine_at_Half;
			if (autoRefine_at_Half)
			{
				this.OnRefined();
			}
		}

		public void Expire()
		{
			this._active = false;
			bool flag = this._tail_results != 0;
			if (flag)
			{
				XSingleton<XTimerMgr>.singleton.KillTimer(this._tail_results_token);
				this._tail_results = this._data.Result.LongAttackData.TriggerAtEnd_Count;
			}
		}

		public bool IsExpired()
		{
			bool flag = !this._effectual || (!this._data.Demonstration && !XEntity.ValideEntity(this._data.Firer));
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				bool flag2 = this._tail_results != 0;
				if (flag2)
				{
					bool flag3 = this._tail_results >= this._data.Result.LongAttackData.TriggerAtEnd_Count;
					result = flag3;
				}
				else
				{
					bool flag4 = this._data.Result.LongAttackData.IsPingPong && !this._pingpong;
					if (flag4)
					{
						bool flag5 = XSingleton<XCommon>.singleton.IsGreater(this._elapsed, this._data.Life);
						if (flag5)
						{
							this.OnPingPong();
						}
					}
					bool flag6 = !this._active || (!this._pingpong && XSingleton<XCommon>.singleton.IsGreater(this._elapsed, this._data.Life));
					bool flag7 = this._data.Result.LongAttackData.TriggerAtEnd_Count <= 0;
					if (flag7)
					{
						result = flag6;
					}
					else
					{
						bool flag8 = flag6;
						if (flag8)
						{
							this._active = false;
							this.OnTailResult(null);
							result = false;
						}
						else
						{
							result = flag6;
						}
					}
				}
			}
			return result;
		}

		private void OnTailResult(object o)
		{
			bool flag = o == null;
			if (flag)
			{
				this._tail_results = 0;
				this.FakeDestroyBulletObject();
			}
			bool flag2 = this._tail_results < this._data.Result.LongAttackData.TriggerAtEnd_Count;
			if (flag2)
			{
				this._tail_results++;
				this.TailResult(this._tail_results == 1);
				XSingleton<XTimerMgr>.singleton.KillTimer(this._tail_results_token);
				this._tail_results_token = XSingleton<XTimerMgr>.singleton.SetTimer(this._data.Result.LongAttackData.TriggerAtEnd_Cycle, new XTimerMgr.ElapsedEventHandler(this.OnTailResult), this);
			}
		}

		public bool IsHurtEntity(ulong id)
		{
			int i = 0;
			int count = this._hurt_target.Count;
			while (i < count)
			{
				XBullet.XBulletTarget xbulletTarget = this._hurt_target[i];
				bool flag = xbulletTarget.TargetID == id;
				if (flag)
				{
					return !xbulletTarget.Hurtable;
				}
				i++;
			}
			return false;
		}

		private void TailResult(bool present)
		{
			bool triggerAtEnd = this._data.Result.LongAttackData.TriggerAtEnd;
			if (triggerAtEnd)
			{
				bool warning = this._data.Warning;
				if (warning)
				{
					this._bullet.Position = this._data.WarningPos;
				}
				bool flag = !this._data.Demonstration && !XSingleton<XGame>.singleton.SyncMode;
				if (flag)
				{
					this.Result(null, this._data.Result.LongAttackData.TriggerAtEnd_Count == 0);
				}
			}
			bool flag2 = !present;
			if (!flag2)
			{
				bool flag3 = !string.IsNullOrEmpty(this._data.Result.LongAttackData.End_Fx);
				if (flag3)
				{
					Vector3 position = this._bullet.Position;
					float num = 0f;
					bool flag4 = this._data.Demonstration || XSingleton<XScene>.singleton.TryGetTerrainY(position, out num);
					if (flag4)
					{
						XFx xfx = XSingleton<XFxMgr>.singleton.CreateFx(this._data.Result.LongAttackData.End_Fx, null, true);
						xfx.DelayDestroy = this._data.Result.LongAttackData.EndFx_LifeTime;
						Quaternion rotation = this._bullet.Rotation;
						bool endFx_Ground = this._data.Result.LongAttackData.EndFx_Ground;
						if (endFx_Ground)
						{
							position.y = (this._data.Demonstration ? this._bullet.Position.y : num);
							rotation = (this._data.Demonstration ? Quaternion.identity : XSingleton<XCommon>.singleton.RotateToGround(position, this._bullet.Forward));
						}
						xfx.Play(position, rotation, Vector3.one, 1f);
						XSingleton<XBulletMgr>.singleton.LogEndFx(xfx);
						XSingleton<XFxMgr>.singleton.DestroyFx(xfx, false);
					}
				}
				bool flag5 = !string.IsNullOrEmpty(this._data.Result.LongAttackData.End_Audio);
				if (flag5)
				{
					XSingleton<XAudioMgr>.singleton.PlaySound(this._data.Firer, AudioChannel.Motion, this._data.Result.LongAttackData.End_Audio, this._bullet.Position);
				}
			}
		}

		private void FakeDestroyBulletObject()
		{
			bool flag = this._bullet != null;
			if (flag)
			{
				Vector3 position = this._bullet.Position;
				Quaternion rotation = this._bullet.Rotation;
				bool flag2 = this._iFmod != null;
				if (flag2)
				{
					XSingleton<XAudioMgr>.singleton.StopSound(this._iFmod);
					this._iFmod.Destroy();
					XSingleton<XUpdater.XUpdater>.singleton.XPlatform.ReturnClass(EClassType.ERuntimeFMOD, this._iFmod);
					this._iFmod = null;
				}
				XSingleton<XFxMgr>.singleton.DestroyFx(this._bullet, true);
				this._bullet = null;
				this._bullet = XSingleton<XFxMgr>.singleton.CreateFx("", null, true);
				this._bullet.Position = position;
				this._bullet.Rotation = rotation;
				this._bullet.SetActive(true);
			}
		}

		public void Destroy(bool leave = false)
		{
			XSingleton<XTimerMgr>.singleton.KillTimer(this._tail_results_token);
			bool flag = !leave && this._data.Result.LongAttackData.TriggerAtEnd_Count == 0 && (this._data.Demonstration || XEntity.ValideEntity(this._data.Firer));
			if (flag)
			{
				this.TailResult(true);
			}
			bool flag2 = this._bullet != null;
			if (flag2)
			{
				bool flag3 = this._iFmod != null;
				if (flag3)
				{
					XSingleton<XAudioMgr>.singleton.StopSound(this._iFmod);
					this._iFmod.Destroy();
					XSingleton<XUpdater.XUpdater>.singleton.XPlatform.ReturnClass(EClassType.ERuntimeFMOD, this._iFmod);
					this._iFmod = null;
				}
				XSingleton<XFxMgr>.singleton.DestroyFx(this._bullet, true);
				this._bullet = null;
			}
			bool flag4 = this._data.Result.LongAttackData.Refine_Cycle > 0f;
			if (flag4)
			{
				int i = 0;
				int count = this._hurt_target.Count;
				while (i < count)
				{
					XBullet.XBulletTarget xbulletTarget = this._hurt_target[i];
					XSingleton<XTimerMgr>.singleton.KillTimer(xbulletTarget.TimerToken);
					i++;
				}
			}
			XSingleton<XBulletMgr>.singleton.ReturnSmallBuffer(ref this._hurt_target);
		}

		public void OnResult(XEntity target)
		{
			bool flag = XEntity.ValideEntity(target);
			if (flag)
			{
				XBullet.XBulletTarget xbulletTarget;
				xbulletTarget.HurtCount = 0;
				xbulletTarget.TimerToken = 0u;
				xbulletTarget.TargetID = 0UL;
				int num = -1;
				int i = 0;
				int count = this._hurt_target.Count;
				while (i < count)
				{
					xbulletTarget = this._hurt_target[i];
					bool flag2 = xbulletTarget.TargetID == target.ID;
					if (flag2)
					{
						num = i;
						break;
					}
					i++;
				}
				bool flag3 = num < 0;
				if (flag3)
				{
					xbulletTarget = default(XBullet.XBulletTarget);
					xbulletTarget.TargetID = target.ID;
					num = this._hurt_target.Count;
					this._hurt_target.Add(xbulletTarget);
				}
				XSingleton<XTimerMgr>.singleton.KillTimer(xbulletTarget.TimerToken);
				xbulletTarget.Hurtable = false;
				xbulletTarget.HurtCount++;
				xbulletTarget.TimerToken = ((this._data.Result.LongAttackData.Refine_Cycle > 0f) ? XSingleton<XTimerMgr>.singleton.SetTimer(this._data.Result.LongAttackData.Refine_Cycle, new XTimerMgr.ElapsedEventHandler(this.OnRefined), target.ID) : 0u);
				this._hurt_target[num] = xbulletTarget;
				bool flag4 = this._data.TriggerMove && XEntity.ValideEntity(this._data.Firer);
				if (flag4)
				{
					Vector3 vector = (this._data.Firer.EngineObject.Position - target.EngineObject.Position).normalized * target.RealEntity.Radius;
					this._data.Firer.CorrectMe(target.EngineObject.Position + vector, this._data.Firer.EngineObject.Forward, false, false);
				}
			}
			bool triggerOnce = this._data.Result.LongAttackData.TriggerOnce;
			if (triggerOnce)
			{
				this.OnOnceTriggered();
			}
		}

		private void OnOnceTriggered()
		{
			bool triggerOnce = this._data.Result.LongAttackData.TriggerOnce;
			if (triggerOnce)
			{
				bool isPingPong = this._data.Result.LongAttackData.IsPingPong;
				if (isPingPong)
				{
					this.OnPingPong();
				}
				else
				{
					this._active = false;
				}
			}
		}

		private void Result(XEntity target, bool cycle = true)
		{
			bool demonstration = this._data.Demonstration;
			if (!demonstration)
			{
				bool flag = target == null;
				if (flag)
				{
					XSkill.SkillResult(this, this._bullet.Forward, this._bullet.Position, cycle);
				}
				else
				{
					bool flag2 = !this._data.Result.Attack_Only_Target || target == this._data.Target;
					if (flag2)
					{
						bool syncMode = XSingleton<XGame>.singleton.SyncMode;
						if (syncMode)
						{
							bool triggerOnce = this._data.Result.LongAttackData.TriggerOnce;
							if (triggerOnce)
							{
								this.OnOnceTriggered();
							}
						}
						else
						{
							Vector3 hitdir = target.EngineObject.Position - this._origin;
							hitdir.y = 0f;
							hitdir.Normalize();
							XSkill.SkillResult(this._data.Token, this._data.Firer, this._data.SkillCore, this, this._data.Sequnce, this._data.ResultID, this._data.ResultTime, hitdir, target);
						}
						bool triggerOnce2 = this._data.Result.LongAttackData.TriggerOnce;
						if (triggerOnce2)
						{
							this._hit_triggered = true;
						}
					}
				}
			}
		}

		public void Update(float fDeltaT)
		{
			bool flag = !this._active;
			if (!flag)
			{
				this._elapsed += fDeltaT;
				float num = 0f;
				Vector3 vector = Vector3.forward;
				switch (this._data.Result.LongAttackData.Type)
				{
				case XResultBulletType.Sphere:
				case XResultBulletType.Plane:
					num = ((this._elapsed > this._data.Running && this._elapsed < this._data.Life) ? 0f : this._data.Velocity) * fDeltaT;
					vector = this._bullet.Forward;
					break;
				case XResultBulletType.Satellite:
				{
					bool flag2 = this._elapsed - fDeltaT <= XCommon.XEps;
					if (flag2)
					{
						Vector3 position = this._data.Firer.EngineObject.Position + this._data.BulletRay.direction * this._data.Result.LongAttackData.RingRadius;
						position.y = this._bullet.Position.y;
						this._bullet.Position = position;
						num = 0f;
						vector = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(this._data.Firer.MoveObj.Forward, (float)((this._data.Result.LongAttackData.Palstance < 0f) ? -90 : 90), true);
					}
					else
					{
						Vector3 vector2 = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(this._data.BulletRay.direction, this._data.Result.LongAttackData.Palstance * (this._elapsed - fDeltaT), true) * this._data.Result.LongAttackData.RingRadius;
						Vector3 vector3 = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(this._data.BulletRay.direction, this._data.Result.LongAttackData.Palstance * this._elapsed, true) * this._data.Result.LongAttackData.RingRadius;
						this._bullet.Forward = XSingleton<XCommon>.singleton.Horizontal(vector3 - vector2);
						vector3 += this._data.Firer.EngineObject.Position;
						Vector3 vector4 = vector3 - this._bullet.Position;
						vector4.y = 0f;
						num = vector4.magnitude;
						vector = vector4.normalized;
					}
					break;
				}
				case XResultBulletType.Ring:
				{
					Vector3 position2 = this._data.Firer.EngineObject.Position;
					position2.y = this._bullet.Position.y;
					this._bullet.Position = position2;
					break;
				}
				}
				bool flag3 = this._data.Result.LongAttackData.IsPingPong && this._pingpong;
				if (flag3)
				{
					bool flag4 = !this._data.Demonstration && !XEntity.ValideEntity(this._data.Firer);
					if (flag4)
					{
						this._active = false;
						return;
					}
					Vector3 vector5 = this._data.Firer.EngineObject.Position - this._bullet.Position;
					vector5.y = 0f;
					bool flag5 = num * num >= vector5.sqrMagnitude;
					if (flag5)
					{
						this._active = false;
						return;
					}
					vector = vector5.normalized;
				}
				else
				{
					bool flag6 = this._data.Result.LongAttackData.Follow && XEntity.ValideEntity(this._data.Target);
					if (flag6)
					{
						vector = XSingleton<XCommon>.singleton.Horizontal(this._data.Target.EngineObject.Position - this._bullet.Position);
					}
				}
				bool flag7 = this._data.Result.LongAttackData.Type != XResultBulletType.Satellite;
				if (flag7)
				{
					this._bullet.Forward = vector;
				}
				Vector3 vector6 = vector * num;
				this._origin = this._bullet.Position;
				this._bullet.Position += vector6;
				bool demonstration = this._data.Demonstration;
				if (!demonstration)
				{
					float num2 = 0f;
					bool flag8 = !XSingleton<XScene>.singleton.TryGetTerrainY(this._bullet.Position, out num2);
					if (flag8)
					{
						bool isPingPong = this._data.Result.LongAttackData.IsPingPong;
						if (isPingPong)
						{
							this.OnPingPong();
						}
						else
						{
							this._active = false;
						}
					}
					else
					{
						bool staticCollider = this._data.Result.LongAttackData.StaticCollider;
						if (staticCollider)
						{
							bool flag9 = num2 < 0f;
							if (flag9)
							{
								bool isPingPong2 = this._data.Result.LongAttackData.IsPingPong;
								if (isPingPong2)
								{
									this.OnPingPong();
								}
								else
								{
									this._active = false;
								}
								return;
							}
						}
						bool dynamicCollider = this._data.Result.LongAttackData.DynamicCollider;
						if (dynamicCollider)
						{
							bool flag10 = !XSingleton<XScene>.singleton.CheckDynamicBlock(this._origin, this._bullet.Position);
							if (flag10)
							{
								bool isPingPong3 = this._data.Result.LongAttackData.IsPingPong;
								if (isPingPong3)
								{
									this.OnPingPong();
								}
								else
								{
									this._active = false;
								}
								return;
							}
						}
						bool flag11 = !this._data.HasTarget;
						if (flag11)
						{
							bool flyWithTerrain = this._data.FlyWithTerrain;
							if (flyWithTerrain)
							{
								Vector3 position3 = this._bullet.Position;
								position3.y = num2 + this._data.InitHeight;
								this._bullet.Position = position3;
							}
							else
							{
								bool flag12 = Mathf.Abs(this._bullet.Position.y - num2) < 0.2f || num2 < 0f;
								if (flag12)
								{
									this._active = false;
									bool flag13 = !string.IsNullOrEmpty(this._data.Result.LongAttackData.HitGround_Fx);
									if (flag13)
									{
										XFx xfx = XSingleton<XFxMgr>.singleton.CreateFx(this._data.Result.LongAttackData.HitGround_Fx, null, true);
										xfx.DelayDestroy = this._data.Result.LongAttackData.HitGroundFx_LifeTime;
										Quaternion rotation = this._bullet.Rotation;
										rotation = XSingleton<XCommon>.singleton.RotateToGround(this._bullet.Position, this._bullet.Forward);
										xfx.Play(this._bullet.Position, rotation, Vector3.one, 1f);
										XSingleton<XFxMgr>.singleton.DestroyFx(xfx, false);
									}
									return;
								}
							}
							vector6 = this._bullet.Position - this._origin;
						}
						bool syncMode = XSingleton<XGame>.singleton.SyncMode;
						if (!syncMode)
						{
							bool manipulation = this._data.Result.LongAttackData.Manipulation;
							if (manipulation)
							{
								List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._data.Firer);
								Vector3 position4 = this._bullet.Position;
								for (int i = 0; i < opponent.Count; i++)
								{
									XEntity xentity = opponent[i];
									bool flag14 = !XEntity.ValideEntity(xentity);
									if (!flag14)
									{
										Vector3 vector7 = position4 - xentity.EngineObject.Position;
										vector7.y = 0f;
										bool flag15 = vector7.magnitude < this._data.Result.LongAttackData.ManipulationRadius;
										if (flag15)
										{
											float num3 = this._data.Result.LongAttackData.ManipulationForce * fDeltaT;
											xentity.ApplyMove(vector7.normalized * Mathf.Min(vector7.magnitude, num3));
										}
									}
								}
							}
							bool hit_triggered = this._hit_triggered;
							if (!hit_triggered)
							{
								bool withCollision = this._data.Result.LongAttackData.WithCollision;
								if (withCollision)
								{
									switch (this._data.Result.LongAttackData.Type)
									{
									case XResultBulletType.Sphere:
									case XResultBulletType.Satellite:
									{
										Vector3 vector8;
										vector8= new Vector3(vector6.x, 0f, vector6.z);
										float num4 = vector8.magnitude * 0.5f;
										vector.y = 0f;
										float num5 = (vector.sqrMagnitude == 0f) ? 0f : Vector3.Angle(Vector3.right, vector);
										bool flag16 = num5 > 0f && XSingleton<XCommon>.singleton.Clockwise(Vector3.right, vector);
										if (flag16)
										{
											num5 = -num5;
										}
										XBullet.BulletCollideUnit(this._data.Firer, new Vector3(this._origin.x + vector.x * num4, 0f, this._origin.z + vector.z * num4), num4, num5, this._data.Radius, this);
										break;
									}
									case XResultBulletType.Plane:
										XBullet.PlaneBulletCollideUnit(this._data.Firer, this._origin, vector6, this._data.Radius, this);
										break;
									case XResultBulletType.Ring:
									{
										float num6 = XSingleton<XCommon>.singleton.IsGreater(this._elapsed, this._data.Life) ? 0f : (this._data.Result.LongAttackData.RingFull ? (XSingleton<XCommon>.singleton.IsGreater(this._elapsed, this._data.Life * 0.5f) ? (this._data.Life - this._elapsed) : this._elapsed) : this._elapsed);
										float num7 = num6 * this._data.Result.LongAttackData.RingVelocity;
										float or = num7 + this._data.Result.LongAttackData.RingRadius;
										XBullet.RingBulletCollideUnit(this._data.Firer, num7, or, this);
										break;
									}
									}
								}
							}
						}
					}
				}
			}
		}

		private static void RingBulletCollideUnit(XEntity firer, float ir, float or, XBullet bullet)
		{
			Vector3 position = firer.EngineObject.Position;
			List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(firer);
			for (int i = 0; i < opponent.Count; i++)
			{
				bool flag = !XEntity.ValideEntity(opponent[i]);
				if (!flag)
				{
					bool flag2 = false;
					bool flag3 = opponent[i].Present != null && opponent[i].Present.PresentLib.Huge;
					if (flag3)
					{
						SeqListRef<float> hugeMonsterColliders = opponent[i].Present.PresentLib.HugeMonsterColliders;
						for (int j = 0; j < hugeMonsterColliders.Count; j++)
						{
							float num = hugeMonsterColliders[j, 2] * opponent[i].Scale;
							Vector3 vector = opponent[i].HugeMonsterColliderCenter(j) - position;
							vector.y = 0f;
							float sqrMagnitude = vector.sqrMagnitude;
							flag2 = (sqrMagnitude > ir * ir && sqrMagnitude < or * or);
							bool flag4 = flag2;
							if (flag4)
							{
								break;
							}
						}
					}
					else
					{
						Vector3 vector2 = opponent[i].RadiusCenter - position;
						vector2.y = 0f;
						float sqrMagnitude2 = vector2.sqrMagnitude;
						flag2 = (sqrMagnitude2 > ir * ir && sqrMagnitude2 < or * or);
					}
					bool flag5 = flag2;
					if (flag5)
					{
						bullet.Result(opponent[i], true);
					}
					bool flag6 = bullet.IsExpired();
					if (flag6)
					{
						break;
					}
				}
			}
		}

		private static void PlaneBulletCollideUnit(XEntity firer, Vector3 origin, Vector3 move, float r, XBullet bullet)
		{
			Vector3 vector = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(move, 90f, true);
			Vector3 q = origin + vector * r;
			Vector3 q2 = origin - vector * r;
			List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(firer);
			for (int i = 0; i < opponent.Count; i++)
			{
				bool flag = !XEntity.ValideEntity(opponent[i]);
				if (!flag)
				{
					bool flag2 = false;
					bool flag3 = opponent[i].Present != null && opponent[i].Present.PresentLib.Huge;
					if (flag3)
					{
						SeqListRef<float> hugeMonsterColliders = opponent[i].Present.PresentLib.HugeMonsterColliders;
						for (int j = 0; j < hugeMonsterColliders.Count; j++)
						{
							float num = hugeMonsterColliders[j, 2] * opponent[i].Scale;
							Vector3 vector2 = opponent[i].HugeMonsterColliderCenter(j);
							flag2 = XSingleton<XCommon>.singleton.IsLineSegmentCross(vector2, vector2 - move, q, q2);
							bool flag4 = flag2;
							if (flag4)
							{
								break;
							}
						}
					}
					else
					{
						Vector3 radiusCenter = opponent[i].RadiusCenter;
						flag2 = XSingleton<XCommon>.singleton.IsLineSegmentCross(radiusCenter, radiusCenter - move, q, q2);
					}
					bool flag5 = flag2;
					if (flag5)
					{
						bullet.Result(opponent[i], true);
					}
					bool flag6 = bullet.IsExpired();
					if (flag6)
					{
						break;
					}
				}
			}
		}

		private static void BulletCollideUnit(XEntity firer, Vector3 rectcenter, float hlen, float rotation, float r, XBullet bullet)
		{
			List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(firer);
			for (int i = 0; i < opponent.Count; i++)
			{
				bool flag = !XEntity.ValideEntity(opponent[i]);
				if (!flag)
				{
					bool flag2 = false;
					bool flag3 = opponent[i].Present != null && opponent[i].Present.PresentLib.Huge;
					if (flag3)
					{
						SeqListRef<float> hugeMonsterColliders = opponent[i].Present.PresentLib.HugeMonsterColliders;
						for (int j = 0; j < hugeMonsterColliders.Count; j++)
						{
							float num = hugeMonsterColliders[j, 2] * opponent[i].Scale;
							Vector3 vector = opponent[i].HugeMonsterColliderCenter(j);
							vector -= rectcenter;
							vector.y = 0f;
							flag2 = XSingleton<XCommon>.singleton.IsRectCycleCross(hlen, r, vector, num);
							bool flag4 = !flag2;
							if (flag4)
							{
								float num2 = num;
								float magnitude = vector.magnitude;
								flag2 = (magnitude - num2 < r);
							}
							bool flag5 = flag2;
							if (flag5)
							{
								break;
							}
						}
					}
					else
					{
						Vector3 vector2 = opponent[i].RadiusCenter;
						vector2 -= rectcenter;
						vector2.y = 0f;
						vector2 = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(vector2, rotation, false);
						flag2 = XSingleton<XCommon>.singleton.IsRectCycleCross(hlen, r, vector2, opponent[i].Radius);
						bool flag6 = !flag2;
						if (flag6)
						{
							float radius = opponent[i].Radius;
							float magnitude2 = vector2.magnitude;
							flag2 = (magnitude2 - radius < r);
						}
					}
					bool flag7 = flag2;
					if (flag7)
					{
						bullet.Result(opponent[i], true);
					}
					bool flag8 = bullet.IsExpired();
					if (flag8)
					{
						break;
					}
				}
			}
		}
	}
}