using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using EzECS.Barriers;
using HarmonyLib;
using Landfall.TABS;
using Landfall.TABS.AI;
using Landfall.TABS.AI.Components;
using Landfall.TABS.AI.Components.Tags;
using Landfall.TABS.AI.Systems;
using Landfall.TABS.GameMode;
using Landfall.TABS.GameState;
using ModdingForDummies;
using Niiido;
using SLMA;
using TFBGames;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ModdingForDummies")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ModdingForDummies")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1619c49c-bc45-486c-bbca-6b52cef4f478")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
public class 斯安维斯坦 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <激活时间>d__16 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public float time;

		public 斯安维斯坦 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <激活时间>d__16(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.是否开启斯安维斯坦 = true;
				<>2__current = (object)new WaitForSeconds(time);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.是否开启斯安维斯坦 = false;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private SkinnedMeshRenderer[] 所有蒙皮网格1;

	private float 计时器;

	private float 计时器2;

	private bool 是否开启斯安维斯坦 = false;

	public float 间隔时间 = 0.05f;

	public Material 可变色材质1 = new Material(UmMyMod.Asset1.LoadAsset<Material>("率hi哦那个3"));

	public Material 材质232 = new Material((Material)SLMALoader.SDic["materials"]["M_BrowningM2_Metal004"]);

	private float 持续百变量;

	public float 完成颜色循环时间 = 5f;

	public float 残影持续时间 = 2f;

	private Color 开始颜色 = new Color(0f, 1.4f, 0f, 0.5f);

	private Color 结束颜色 = new Color(1.4f, 0f, 0f, 0.5f);

	public Color 残影颜色;

	private List<GameObject> 残影列表 = new List<GameObject>();

	private void Start()
	{
		所有蒙皮网格1 = ((Component)((Component)this).transform.root).GetComponentsInChildren<SkinnedMeshRenderer>();
	}

	public void 启动(float time1 = 1f)
	{
		((MonoBehaviour)this).StartCoroutine(激活时间(time1));
	}

	[IteratorStateMachine(typeof(<激活时间>d__16))]
	private IEnumerator 激活时间(float time = 1f)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <激活时间>d__16(0)
		{
			<>4__this = this,
			time = time
		};
	}

	private void 生成一次()
	{
		if (所有蒙皮网格1 == null || 所有蒙皮网格1.Length == 0)
		{
			所有蒙皮网格1 = ((Component)((Component)this).transform.root).GetComponentsInChildren<SkinnedMeshRenderer>();
		}
		生成蒙皮网格残影(所有蒙皮网格1, 材质232);
	}

	public void 生成蒙皮网格残影(SkinnedMeshRenderer[] 所有蒙皮网格, Material 可变色材质)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Expected O, but got Unknown
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Expected O, but got Unknown
		foreach (SkinnedMeshRenderer val in 所有蒙皮网格)
		{
			if (((Renderer)val).enabled && !((Object)(object)val.sharedMesh == (Object)null))
			{
				GameObject val2 = new GameObject("残影");
				val2.transform.position = ((Component)val).transform.position;
				val2.transform.rotation = ((Component)val).transform.rotation;
				MeshRenderer val3 = val2.AddComponent<MeshRenderer>();
				MeshFilter val4 = val2.AddComponent<MeshFilter>();
				val2.AddComponent<n秒后移除物体并生成爆炸>().cd = 残影持续时间;
				Mesh val5 = new Mesh();
				val.BakeMesh(val5);
				val4.mesh = val5;
				Material material = new Material(可变色材质);
				((Renderer)val3).material = material;
			}
		}
	}

	private void Update()
	{
		if (是否开启斯安维斯坦)
		{
			计时器 += Time.deltaTime;
			更新残影颜色();
			if (计时器 >= 间隔时间)
			{
				生成一次();
				计时器 -= 间隔时间;
			}
		}
		else
		{
			重置颜色状态();
			计时器 = 0f;
		}
	}

	private void 更新残影颜色()
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		计时器2 += Time.deltaTime;
		float num = Mathf.PingPong(计时器2 / (完成颜色循环时间 / 2f), 1f);
		Color color = Color.Lerp(开始颜色, 结束颜色, num);
		材质232.color = color;
	}

	private void 重置颜色状态()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		计时器2 = 0f;
		材质232.color = 开始颜色;
	}
}
public class n秒后移除物体并生成爆炸 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <开始删除生成>d__2 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public n秒后移除物体并生成爆炸 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <开始删除生成>d__2(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.cd);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public float cd = 1.3f;

	public void Start()
	{
		((MonoBehaviour)this).StartCoroutine(开始删除生成());
	}

	[IteratorStateMachine(typeof(<开始删除生成>d__2))]
	private IEnumerator 开始删除生成()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <开始删除生成>d__2(0)
		{
			<>4__this = this
		};
	}
}
public class 添加延迟事件 : MonoBehaviour
{
	private DelayEvent 延迟事件组件;

	private 斯安维斯坦 斯安维斯坦组件;

	public float 持续时间 = 0.15f;

	private void Start()
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Expected O, but got Unknown
		延迟事件组件 = ((Component)this).GetComponent<DelayEvent>();
		斯安维斯坦组件 = ((Component)this).GetComponent<斯安维斯坦>();
		if ((Object)(object)延迟事件组件 != (Object)null && (Object)(object)斯安维斯坦组件 != (Object)null)
		{
			延迟事件组件.delayedEvent.AddListener(new UnityAction(启动残影));
		}
		else
		{
			Debug.LogWarning((object)(((Object)((Component)this).gameObject).name + ": 缺少必要组件"));
		}
	}

	private void 启动残影()
	{
		if ((Object)(object)斯安维斯坦组件 != (Object)null)
		{
			斯安维斯坦组件.启动(持续时间);
		}
	}

	private void OnDestroy()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		if ((Object)(object)延迟事件组件 != (Object)null)
		{
			延迟事件组件.delayedEvent.RemoveListener(new UnityAction(启动残影));
		}
	}
}
public class 添加延迟2事件 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <启动残影xz>d__11 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public 添加延迟2事件 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <启动残影xz>d__11(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.feixx = true;
				<>4__this.斯安维斯坦组件.启动(5f);
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.feixx = false;
				<>4__this.ClearAllVelocity();
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private DelayEvent 延迟事件组件;

	private 斯安维斯坦 斯安维斯坦组件;

	public float 持续时间 = 0.15f;

	private bool feixx = false;

	private Unit unit34;

	private Rigidbody[] allrig;

	public float 力度 = 8000f;

	private float 计时器1;

	public GameObject 生生爆炸23 = UmMyMod.Asset1.LoadAsset<GameObject>("螳螂刀打击爆炸34");

	private void Start()
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		unit34 = ((Component)((Component)this).transform.root).GetComponentInChildren<Unit>();
		延迟事件组件 = ((Component)this).GetComponent<DelayEvent>();
		斯安维斯坦组件 = ((Component)this).GetComponent<斯安维斯坦>();
		if ((Object)(object)延迟事件组件 != (Object)null && (Object)(object)斯安维斯坦组件 != (Object)null)
		{
			延迟事件组件.delayedEvent.AddListener(new UnityAction(启动残影));
		}
		else
		{
			Debug.LogWarning((object)(((Object)((Component)this).gameObject).name + ": 缺少必要组件"));
		}
	}

	private void 启动残影()
	{
		((MonoBehaviour)this).StartCoroutine(启动残影xz());
	}

	[IteratorStateMachine(typeof(<启动残影xz>d__11))]
	private IEnumerator 启动残影xz()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <启动残影xz>d__11(0)
		{
			<>4__this = this
		};
	}

	private void Update()
	{
		飞翔11();
	}

	private void 飞翔11()
	{
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		if (!feixx)
		{
			return;
		}
		Unit unit = unit34.data.targetData.unit;
		if (!unit.data.Dead)
		{
			Vector3 val = unit.data.mainRig.position - unit34.data.mainRig.position;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			allrig = unit34.data.allRigs.AllRigs;
			for (int i = 0; i < allrig.Length; i++)
			{
				allrig[i].AddForce(normalized * (力度 * Time.deltaTime), (ForceMode)5);
			}
			计时器1 += Time.deltaTime;
			if ((double)计时器1 > 0.1 && unit34.data.distanceToTarget < 1f)
			{
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(生生爆炸23, unit.data.mainRig.position, Quaternion.identity), ((Component)this).gameObject);
				计时器1 = 0f;
			}
		}
	}

	private void ClearAllVelocity()
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < allrig.Length; i++)
		{
			allrig[i].velocity = Vector3.zero;
			allrig[i].angularVelocity = Vector3.zero;
		}
	}
}
public class 是否下马判断 : MonoBehaviour
{
	private Unit unit;

	private bool 判断1 = true;

	private float 计时器 = 0f;

	private Mount mount2;

	private 添加延迟2事件 wwww;

	public void Start()
	{
		unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
		mount2 = ((Component)unit).GetComponentInChildren<Mount>();
		wwww = ((Component)this).gameObject.GetComponent<添加延迟2事件>();
		((Behaviour)wwww).enabled = false;
		if ((Object)(object)mount2 == (Object)null)
		{
			((Behaviour)wwww).enabled = true;
		}
	}

	public void Update()
	{
		if ((Object)(object)mount2 != (Object)null && 判断1 && !mount2.IsMounted)
		{
			((Behaviour)wwww).enabled = true;
			判断1 = false;
		}
	}
}
public class 黑客真伤效果 : MonoBehaviour
{
	private Unit unit;

	private bool 判断1 = true;

	private float 计时器 = 0f;

	private void Start()
	{
		unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
		if ((Object)(object)unit == (Object)null)
		{
			Debug.LogError((object)"未找到Unit组件");
			return;
		}
		float maxHealth = unit.data.maxHealth;
		if (maxHealth > 10000f)
		{
			强制死亡();
		}
		else if (maxHealth > 8000f)
		{
			固定扣血(1000f);
		}
		else if (maxHealth > 5000f)
		{
			固定扣血(600f);
		}
		else if (maxHealth > 3000f)
		{
			固定扣血(400f);
		}
		else if (maxHealth > 1000f)
		{
			固定扣血(100f);
		}
		else if (maxHealth > 500f)
		{
			固定扣血(10f);
		}
	}

	private void 强制死亡()
	{
		黑客消除er();
		GameModeService service = ServiceLocator.GetService<GameModeService>();
		if (service.CurrentGameMode == null)
		{
			Debug.LogError((object)"Could not find CurrentGameMode!");
		}
		else
		{
			service.CurrentGameMode.OnUnitDied(unit);
		}
		Object.Destroy((Object)(object)((Component)unit).gameObject);
	}

	private void 黑客消除er()
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Expected O, but got Unknown
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Expected O, but got Unknown
		SkinnedMeshRenderer[] componentsInChildren = ((Component)unit).GetComponentsInChildren<SkinnedMeshRenderer>();
		foreach (SkinnedMeshRenderer val in componentsInChildren)
		{
			if (((Renderer)val).enabled && !((Object)(object)val.sharedMesh == (Object)null))
			{
				GameObject val2 = new GameObject("残影");
				val2.transform.position = ((Component)val).transform.position;
				val2.transform.rotation = ((Component)val).transform.rotation;
				MeshRenderer val3 = val2.AddComponent<MeshRenderer>();
				MeshFilter val4 = val2.AddComponent<MeshFilter>();
				val2.AddComponent<n秒后移除物体并淡出>().cd = 2f;
				Mesh val5 = new Mesh();
				val.BakeMesh(val5);
				val4.mesh = val5;
				Material material = new Material(UmMyMod.Asset1.LoadAsset<Material>("透明公司收到23其3"));
				((Renderer)val3).material = material;
			}
		}
	}

	private void 固定扣血(float he12)
	{
		DataHandler data = unit.data;
		data.health -= he12;
		if (unit.data.health <= 0f)
		{
			强制死亡();
		}
	}
}
public class n秒后移除物体并淡出 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <开始删除生成>d__6 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public n秒后移除物体并淡出 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <开始删除生成>d__6(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.cd);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = ((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.淡出效果());
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <淡出效果>d__7 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public n秒后移除物体并淡出 <>4__this;

		private float <计时器>5__1;

		private Color <最终颜色>5__2;

		private float <进度>5__3;

		private Color <新颜色>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <淡出效果>d__7(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if ((Object)(object)<>4__this.渲染器 == (Object)null || (Object)(object)<>4__this.材质 == (Object)null)
				{
					return false;
				}
				<计时器>5__1 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<计时器>5__1 < <>4__this.淡出时间)
			{
				<计时器>5__1 += Time.deltaTime;
				<进度>5__3 = <计时器>5__1 / <>4__this.淡出时间;
				<新颜色>5__4 = <>4__this.初始颜色;
				<新颜色>5__4.a = Mathf.Lerp(1f, 0f, <进度>5__3);
				<>4__this.材质.color = <新颜色>5__4;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<最终颜色>5__2 = <>4__this.初始颜色;
			<最终颜色>5__2.a = 0f;
			<>4__this.材质.color = <最终颜色>5__2;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public float cd = 1.3f;

	public float 淡出时间 = 0.5f;

	private Renderer 渲染器;

	private Material 材质;

	private Color 初始颜色;

	public void Start()
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		渲染器 = ((Component)this).GetComponent<Renderer>();
		if ((Object)(object)渲染器 != (Object)null)
		{
			材质 = 渲染器.material;
			初始颜色 = 材质.color;
		}
		((MonoBehaviour)this).StartCoroutine(开始删除生成());
	}

	[IteratorStateMachine(typeof(<开始删除生成>d__6))]
	private IEnumerator 开始删除生成()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <开始删除生成>d__6(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<淡出效果>d__7))]
	private IEnumerator 淡出效果()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <淡出效果>d__7(0)
		{
			<>4__this = this
		};
	}

	private void OnDestroy()
	{
	}

	public void 开始淡出()
	{
		((MonoBehaviour)this).StartCoroutine(开始删除生成());
	}

	public void 设置参数(float 新CD, float 新淡出时间)
	{
		cd = 新CD;
		淡出时间 = 新淡出时间;
	}
}
public class 飞天坠落3 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <激活时间>d__20 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public float time;

		public float time2;

		public 飞天坠落3 <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <激活时间>d__20(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.激活跳跃 = true;
				<>4__this.正在起飞 = true;
				<>4__this.正在坠落 = false;
				<>2__current = (object)new WaitForSeconds(time);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>4__this.正在起飞 = false;
				<>4__this.正在坠落 = true;
				<>2__current = (object)new WaitForSeconds(time2);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>4__this.激活跳跃 = false;
				<>4__this.正在坠落 = false;
				<>4__this.到达目标判断 = true;
				<>4__this.计时器3 = 0f;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private Rigidbody[] 所有刚体组件;

	public Transform 目标变换;

	public Transform 本体变换;

	public bool 激活跳跃 = false;

	public float 跳跃时间 = 1f;

	public float 坠落时间 = 1f;

	public float 水平力强度 = 2000f;

	public float 起飞强度 = 2000f;

	public float 坠落强度 = 2000f;

	private float 计时器3 = 0f;

	private bool 正在起飞 = false;

	public GameObject exp;

	public GameObject 转化a;

	private bool 到达目标判断 = true;

	private bool 正在坠落 = false;

	private float 平滑系数 = 0.1f;

	private Dictionary<Rigidbody, Vector3> 初始角速度 = new Dictionary<Rigidbody, Vector3>();

	private void Start()
	{
	}

	public void 启动(Rigidbody[] 所有刚体, float 上升, float 下降, float 水平, float 跳跃时间1, float 下落时间1, Transform 目标变换1, Transform 本体变换1, GameObject exp1, GameObject exp转化)
	{
		所有刚体组件 = 所有刚体;
		目标变换 = 目标变换1;
		本体变换 = 本体变换1;
		水平力强度 = 水平;
		起飞强度 = 上升;
		坠落强度 = 下降;
		跳跃时间 = 跳跃时间1;
		坠落时间 = 下落时间1;
		exp = exp1;
		转化a = exp转化;
		保存初始角速度();
		((MonoBehaviour)this).StartCoroutine(激活时间(跳跃时间1, 下落时间1));
	}

	private void 保存初始角速度()
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		初始角速度.Clear();
		Rigidbody[] array = 所有刚体组件;
		foreach (Rigidbody val in array)
		{
			初始角速度[val] = val.angularVelocity;
		}
	}

	[IteratorStateMachine(typeof(<激活时间>d__20))]
	private IEnumerator 激活时间(float time = 3f, float time2 = 3f)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <激活时间>d__20(0)
		{
			<>4__this = this,
			time = time,
			time2 = time2
		};
	}

	private void Update()
	{
		if (激活跳跃)
		{
			起飞3();
		}
	}

	private void 起飞3()
	{
		计时器3 += Time.deltaTime;
		if (正在起飞 && 计时器3 < 跳跃时间)
		{
			上升力32();
			平滑旋转();
		}
		if (与目标水平距离() < 3f && 到达目标判断 && 正在起飞)
		{
			正在起飞 = false;
			正在坠落 = true;
			计时器3 = 0f;
			到达目标判断 = false;
		}
		if (正在坠落 && 计时器3 < 坠落时间)
		{
			坠落力32();
			平滑旋转();
			射线地面检测();
		}
		if (!正在起飞 && !正在坠落 && 激活跳跃)
		{
			平滑旋转();
		}
	}

	private void 平滑旋转()
	{
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val2 = default(Vector3);
		for (int i = 0; i < 所有刚体组件.Length; i++)
		{
			Rigidbody val = 所有刚体组件[i];
			if (初始角速度.ContainsKey(val))
			{
				val.angularVelocity = Vector3.Lerp(val.angularVelocity, 初始角速度[val] * 0.3f, 平滑系数 * Time.deltaTime * 10f);
			}
			((Vector3)(ref val2))..ctor(val.velocity.x, 0f, val.velocity.z);
			if (((Vector3)(ref val2)).magnitude > 5f && !正在起飞)
			{
				val.velocity = new Vector3(Mathf.Lerp(val.velocity.x, 0f, 平滑系数 * Time.deltaTime * 5f), val.velocity.y, Mathf.Lerp(val.velocity.z, 0f, 平滑系数 * Time.deltaTime * 5f));
			}
		}
	}

	private Vector3 与目标水平方向()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = 目标变换.position - 本体变换.position;
		val.y = 0f;
		return ((Vector3)(ref val)).normalized;
	}

	private float 与目标水平距离()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = 目标变换.position;
		position.y = 0f;
		Vector3 position2 = 本体变换.position;
		position2.y = 0f;
		return Vector3.Distance(position, position2);
	}

	private void 上升力32()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 所有刚体组件.Length; i++)
		{
			Vector3 val = 与目标水平方向();
			float num = Mathf.Clamp01(与目标水平距离() / 10f);
			所有刚体组件[i].AddForce(Vector3.up * 起飞强度 * Time.deltaTime, (ForceMode)5);
			所有刚体组件[i].AddForce(val * 水平力强度 * num * Time.deltaTime, (ForceMode)5);
		}
	}

	private void 坠落力32()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 所有刚体组件.Length; i++)
		{
			Vector3 val = 与目标水平方向();
			float num = Mathf.Clamp01(与目标水平距离() / 5f);
			所有刚体组件[i].AddForce(Vector3.down * 坠落强度 * Time.deltaTime, (ForceMode)5);
			所有刚体组件[i].AddForce(val * 水平力强度 * num * Time.deltaTime, (ForceMode)5);
		}
	}

	private void 射线地面检测()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = 本体变换.position + Vector3.up * 10f;
		RaycastHit[] array = Physics.RaycastAll(val, Vector3.down, 60f);
		Array.Sort(array, (RaycastHit a, RaycastHit b) => ((RaycastHit)(ref a)).distance.CompareTo(((RaycastHit)(ref b)).distance));
		RaycastHit? val2 = null;
		RaycastHit[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			RaycastHit value = array2[i];
			if (!IsUnitOrChildOfUnit(((Component)((RaycastHit)(ref value)).collider).gameObject))
			{
				val2 = value;
				break;
			}
		}
		if (val2.HasValue)
		{
			Vector3 position = 本体变换.position;
			RaycastHit value2 = val2.Value;
			float num = Vector3.Distance(position, ((RaycastHit)(ref value2)).point);
			if (num < 1.5f)
			{
				平滑减速();
				GameObject gameObjectw = exp;
				value2 = val2.Value;
				生成坠落爆炸(gameObjectw, ((RaycastHit)(ref value2)).point, 转化a);
				已坠落1();
			}
		}
	}

	private void 平滑减速()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 所有刚体组件.Length; i++)
		{
			Rigidbody val = 所有刚体组件[i];
			val.velocity = Vector3.Lerp(val.velocity, Vector3.zero, 0.5f * Time.deltaTime * 10f);
			val.angularVelocity = Vector3.Lerp(val.angularVelocity, Vector3.zero, 0.5f * Time.deltaTime * 10f);
		}
	}

	private bool IsUnitOrChildOfUnit(GameObject obj)
	{
		if ((Object)(object)obj.GetComponent<FollowTransform>() != (Object)null)
		{
			return true;
		}
		GameObject gameObject = ((Component)obj.transform.root).gameObject;
		Unit[] componentsInChildren = gameObject.GetComponentsInChildren<Unit>(true);
		return componentsInChildren.Length != 0;
	}

	private void 生成坠落爆炸(GameObject gameObjectw, Vector3 pion, GameObject 召唤物)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)gameObjectw != (Object)null)
		{
			TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(gameObjectw, pion, Quaternion.identity), 召唤物);
		}
	}

	private void 已坠落1()
	{
		激活跳跃 = false;
		正在起飞 = false;
		正在坠落 = false;
		到达目标判断 = true;
		计时器3 = 0f;
	}
}
public class 泰山压顶控制器 : MonoBehaviour
{
	private DelayEvent 延迟事件组件;

	private 飞天坠落3 泰山压顶组件;

	private Unit Unit23;

	public GameObject exp323 = UmMyMod.Asset1.LoadAsset<GameObject>("坠落爆炸234");

	private void Start()
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Expected O, but got Unknown
		延迟事件组件 = ((Component)this).GetComponent<DelayEvent>();
		泰山压顶组件 = ((Component)this).GetComponent<飞天坠落3>();
		Unit23 = ((Component)((Component)this).transform.root).GetComponentInChildren<Unit>();
		if ((Object)(object)延迟事件组件 != (Object)null && (Object)(object)泰山压顶组件 != (Object)null)
		{
			延迟事件组件.delayedEvent.AddListener(new UnityAction(启动泰山压顶控制器));
		}
		else
		{
			Debug.LogWarning((object)(((Object)((Component)this).gameObject).name + ": 缺少必要组件"));
		}
	}

	private void 启动泰山压顶控制器()
	{
		Unit unit = Unit23.data.targetData.unit;
		if ((Object)(object)泰山压顶组件 != (Object)null)
		{
			泰山压顶组件.启动(Unit23.data.allRigs.AllRigs, 6000f, 8000f, 4000f, 1.5f, 4f, ((Component)unit.data.mainRig).transform, ((Component)Unit23.data.mainRig).transform, exp323, ((Component)this).gameObject);
		}
	}

	private void OnDestroy()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		if ((Object)(object)延迟事件组件 != (Object)null)
		{
			延迟事件组件.delayedEvent.RemoveListener(new UnityAction(启动泰山压顶控制器));
		}
	}
}
public class 顺序发射炮弹 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <DisableChildrenOneByOne>d__5 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public 顺序发射炮弹 <>4__this;

		private int <i>5__1;

		private Transform <child>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DisableChildrenOneByOne>d__5(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<child>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				<child>5__2 = null;
				<i>5__1++;
				break;
			}
			if (<i>5__1 < <>4__this.parentObject.transform.childCount)
			{
				<child>5__2 = <>4__this.parentObject.transform.GetChild(<i>5__1);
				if ((Object)(object)((Component)<child>5__2).gameObject.GetComponentInChildren<SpawnObject>() != (Object)null)
				{
					((Component)<child>5__2).gameObject.GetComponent<DelayEvent>().Go();
				}
				<>2__current = (object)new WaitForSeconds(<>4__this.delayBetweenDisable);
				<>1__state = 1;
				return true;
			}
			Debug.Log((object)"所有子物体已按顺序禁用完成！");
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("设置")]
	public GameObject parentObject;

	public float delayBetweenDisable = 0.1f;

	private Unit erree;

	private void Start()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Expected O, but got Unknown
		erree = ((Component)((Component)this).transform.root).GetComponentInChildren<Unit>();
		((Component)this).gameObject.GetComponent<DelayEvent>().delayedEvent.AddListener(new UnityAction(启动32));
		parentObject = ((Component)((Component)this).gameObject.transform.Find("本体火箭同233244")).gameObject;
		if (!((Object)(object)parentObject != (Object)null))
		{
			Debug.LogError((object)"请指定父物体！");
		}
	}

	private void 启动32()
	{
		if (!erree.data.targetData.Dead)
		{
			((MonoBehaviour)this).StartCoroutine(DisableChildrenOneByOne());
		}
	}

	[IteratorStateMachine(typeof(<DisableChildrenOneByOne>d__5))]
	private IEnumerator DisableChildrenOneByOne()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DisableChildrenOneByOne>d__5(0)
		{
			<>4__this = this
		};
	}
}
public class 半血变换4 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <kiazhaidsfj>d__7 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public UnitBlueprint unit3;

		public 半血变换4 <>4__this;

		private Quaternion <rotation>5__1;

		private GameObject <gameObject1>5__2;

		private Rigidbody[] <allRigs>5__3;

		private Rigidbody[] <allRigs2>5__4;

		private int <num>5__5;

		private int <m>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <kiazhaidsfj>d__7(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<gameObject1>5__2 = null;
			<allRigs>5__3 = null;
			<allRigs2>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			if (<>1__state != 0)
			{
				return false;
			}
			<>1__state = -1;
			<rotation>5__1 = Quaternion.LookRotation(Vector3.up);
			TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(<>4__this.母体集束炸弹, <>4__this.unit.data.mainRig.position + ((Component)<>4__this.unit.data.mainRig).transform.forward * -4f, <rotation>5__1), ((Component)<>4__this).gameObject);
			<gameObject1>5__2 = unit3.Spawn(<>4__this.unit.data.mainRig.position + Vector3.up * 1000f, <>4__this.unit.data.mainRig.rotation, <>4__this.unit.Team, 1f, (UnitPoolInfo?)null)[0];
			<allRigs>5__3 = <>4__this.unit.data.allRigs.AllRigs;
			<allRigs2>5__4 = <gameObject1>5__2.GetComponent<Unit>().data.allRigs.AllRigs;
			((Component)<>4__this.unit).GetComponentsInChildren<Rigidbody>();
			<gameObject1>5__2.transform.localScale = ((Component)<>4__this.unit).transform.localScale;
			for (<m>5__6 = 0; <m>5__6 < <allRigs2>5__4.Length; <m>5__6 = <num>5__5 + 1)
			{
				((Component)<allRigs2>5__4[<m>5__6]).transform.localScale = ((Component)<allRigs>5__3[<m>5__6]).transform.localScale;
				((Component)<allRigs2>5__4[<m>5__6]).transform.position = ((Component)<allRigs>5__3[<m>5__6]).transform.position;
				((Component)<allRigs2>5__4[<m>5__6]).transform.rotation = ((Component)<allRigs>5__3[<m>5__6]).transform.rotation;
				<allRigs2>5__4[<m>5__6].velocity = <allRigs>5__3[<m>5__6].velocity;
				<num>5__5 = <m>5__6;
			}
			Object.Destroy((Object)(object)((Component)<>4__this.unit).gameObject);
			<>4__this.判断1 = false;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private Unit unit;

	private bool 判断1 = true;

	private float 计时器 = 0f;

	public UnitBlueprint unitBlueprint323;

	public GameObject 母体集束炸弹;

	public void Start()
	{
		unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
	}

	public void Update()
	{
		if ((double)unit.data.health <= (double)unit.data.maxHealth * 0.5 && 判断1)
		{
			((MonoBehaviour)this).StartCoroutine(kiazhaidsfj(unitBlueprint323));
		}
	}

	[IteratorStateMachine(typeof(<kiazhaidsfj>d__7))]
	public IEnumerator kiazhaidsfj(UnitBlueprint unit3)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <kiazhaidsfj>d__7(0)
		{
			<>4__this = this,
			unit3 = unit3
		};
	}
}
public class 集束炸弹母体脚本 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <集束爆炸协程>d__4 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public 集束炸弹母体脚本 <>4__this;

		private GameObject <集束炸弹控制器>5__1;

		private RemoveAfterSeconds <自动销毁组件>5__2;

		private 集束炸弹32 <集束炸弹逻辑>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <集束爆炸协程>d__4(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<集束炸弹控制器>5__1 = null;
			<自动销毁组件>5__2 = null;
			<集束炸弹逻辑>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(<>4__this.爆炸延迟时间);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<集束炸弹控制器>5__1 = new GameObject("集束炸弹控制器");
				<集束炸弹控制器>5__1.transform.position = ((Component)<>4__this).transform.position;
				<自动销毁组件>5__2 = <集束炸弹控制器>5__1.AddComponent<RemoveAfterSeconds>();
				<自动销毁组件>5__2.seconds = <>4__this.生成物存在时间;
				TeamHolder.AddTeamHolder(<集束炸弹控制器>5__1, ((Component)<>4__this).gameObject);
				<集束炸弹逻辑>5__3 = <集束炸弹控制器>5__1.AddComponent<集束炸弹32>();
				<集束炸弹逻辑>5__3.子体集束炸弹预制体 = <>4__this.子体集束炸弹预制体1;
				Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public GameObject 子体集束炸弹预制体1;

	[SerializeField]
	private float 爆炸延迟时间 = 1f;

	[SerializeField]
	private float 生成物存在时间 = 5f;

	private void Start()
	{
		((MonoBehaviour)this).StartCoroutine(集束爆炸协程());
	}

	[IteratorStateMachine(typeof(<集束爆炸协程>d__4))]
	public IEnumerator 集束爆炸协程()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <集束爆炸协程>d__4(0)
		{
			<>4__this = this
		};
	}
}
public class 集束炸弹32 : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <集束爆炸协程>d__8 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public 集束炸弹32 <>4__this;

		private int <i>5__1;

		private Vector3 <随机方向>5__2;

		private GameObject <炸弹实例>5__3;

		private Rigidbody <rb>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <集束爆炸协程>d__8(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<炸弹实例>5__3 = null;
			<rb>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
				goto IL_018a;
			}
			<>1__state = -1;
			<i>5__1 = 0;
			goto IL_01ab;
			IL_018a:
			<炸弹实例>5__3 = null;
			<rb>5__4 = null;
			<i>5__1++;
			goto IL_01ab;
			IL_01ab:
			if ((float)<i>5__1 < <>4__this.集束炸弹数量)
			{
				<随机方向>5__2 = new Vector3(Random.Range(0f - <>4__this.随机散布范围, <>4__this.随机散布范围), Random.Range((0f - <>4__this.随机散布范围) * 1f, 0f), Random.Range(0f - <>4__this.随机散布范围, <>4__this.随机散布范围));
				<炸弹实例>5__3 = Object.Instantiate<GameObject>(<>4__this.子体集束炸弹预制体, ((Component)<>4__this).transform.position, Quaternion.identity);
				if (<随机方向>5__2 != Vector3.zero)
				{
					<炸弹实例>5__3.transform.rotation = Quaternion.LookRotation(((Vector3)(ref <随机方向>5__2)).normalized);
				}
				<rb>5__4 = <炸弹实例>5__3.GetComponent<Rigidbody>();
				if ((Object)(object)<rb>5__4 != (Object)null)
				{
					<rb>5__4.velocity = ((Vector3)(ref <随机方向>5__2)).normalized * 10f;
				}
				TeamHolder.AddTeamHolder(<炸弹实例>5__3, ((Component)<>4__this).gameObject);
				if (<>4__this.爆炸间隔 > 0f)
				{
					<>2__current = (object)new WaitForSeconds(<>4__this.爆炸间隔);
					<>1__state = 1;
					return true;
				}
				goto IL_018a;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[SerializeField]
	private float 集束炸弹数量 = 200f;

	[SerializeField]
	public GameObject 子体集束炸弹预制体;

	[SerializeField]
	private float 随机散布范围 = 12f;

	[SerializeField]
	private float 爆炸间隔 = 0.02f;

	private MoveTransform moveqw;

	public float 速度变化 = 50f;

	private void Start()
	{
		moveqw = 子体集束炸弹预制体.GetComponent<MoveTransform>();
		((MonoBehaviour)this).StartCoroutine(集束爆炸协程());
	}

	private void Update()
	{
		moveqw.selfImpulse.z = Random.Range(0f, 速度变化);
	}

	[IteratorStateMachine(typeof(<集束爆炸协程>d__8))]
	public IEnumerator 集束爆炸协程()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <集束爆炸协程>d__8(0)
		{
			<>4__this = this
		};
	}
}
public class 召唤爆炸并删除自身 : MonoBehaviour
{
	private Unit unit;

	private bool 判断1 = true;

	private float 计时器 = 0f;

	public GameObject 爆炸;

	private void Start()
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
		((Damagable)unit.data.healthHandler).TakeDamage(1000f, unit.data.mainRig.position, (Unit)null, (DamageType)0);
		TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(爆炸, unit.data.mainRig.position, Quaternion.identity), ((Component)this).gameObject);
		Object.Destroy((Object)(object)((Component)this).gameObject);
	}
}
public class OffsetCameraController : MonoBehaviour
{
	[Header("放大镜设置")]
	[SerializeField]
	private float magnification = 1.2f;

	[SerializeField]
	private float maxMagnification = 5f;

	[SerializeField]
	private float minMagnification = 1f;

	[SerializeField]
	private float smoothFactor = 10f;

	[SerializeField]
	private float cameraDistance = 5f;

	[Header("参考对象")]
	[SerializeField]
	private Camera mainCamera;

	[SerializeField]
	private Transform targetPlane;

	public Material materialTemplate;

	[Header("渲染设置")]
	[SerializeField]
	private LayerMask cullingMask = LayerMask.op_Implicit(-1);

	[SerializeField]
	private float renderDepth = 100f;

	[SerializeField]
	private Vector2 renderResolution = new Vector2(400f, 400f);

	private Camera portalCamera;

	private Vector3 originalPosition;

	private float originalFOV;

	private RenderTexture renderTexture;

	private Material instanceMaterial;

	private static int instanceCounter;

	private int instanceId;

	private string portalCameraName;

	private Vector3 targetPosition;

	private Quaternion targetRotation;

	private Vector3 planeNormal;

	private Vector3 planeCenter;

	private void Awake()
	{
		instanceId = ++instanceCounter;
		portalCameraName = $"PortalCamera_{instanceId}";
		((Object)((Component)this).gameObject).name = portalCameraName;
	}

	private void Start()
	{
		Debug.Log((object)$"初始化门户相机 {instanceId}");
		InitializeComponents();
		if (ValidateComponents())
		{
			CalculatePlaneProperties();
			CreateRenderTexture();
			CreateInstanceMaterial();
			SetupPortalCamera();
			Debug.Log((object)$"门户相机 {instanceId} 初始化完成");
		}
	}

	private bool ValidateComponents()
	{
		if ((Object)(object)portalCamera == (Object)null)
		{
			Debug.LogError((object)$"实例 {instanceId}: 门户相机组件为空！");
			return false;
		}
		if ((Object)(object)mainCamera == (Object)null)
		{
			mainCamera = Camera.main;
			if ((Object)(object)mainCamera == (Object)null)
			{
				Debug.LogError((object)$"实例 {instanceId}: 找不到主相机！");
				return false;
			}
		}
		if ((Object)(object)targetPlane == (Object)null)
		{
			Debug.LogError((object)$"实例 {instanceId}: 目标平面为空！");
			return false;
		}
		return true;
	}

	private void InitializeComponents()
	{
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Expected O, but got Unknown
		portalCamera = ((Component)this).GetComponent<Camera>();
		if ((Object)(object)portalCamera == (Object)null)
		{
			portalCamera = ((Component)this).gameObject.AddComponent<Camera>();
		}
		if ((Object)(object)mainCamera == (Object)null)
		{
			mainCamera = Camera.main;
		}
		if (!((Object)(object)targetPlane == (Object)null))
		{
			return;
		}
		Transform parent = ((Component)this).transform.parent;
		if (!((Object)(object)parent != (Object)null))
		{
			return;
		}
		targetPlane = parent.Find("Plane");
		if (!((Object)(object)targetPlane == (Object)null))
		{
			return;
		}
		foreach (Transform item in parent)
		{
			Transform val = item;
			if (((Object)val).name.Contains("Plane"))
			{
				targetPlane = val;
				break;
			}
		}
	}

	private void CalculatePlaneProperties()
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)targetPlane == (Object)null))
		{
			planeCenter = targetPlane.position;
			planeNormal = targetPlane.forward;
		}
	}

	private void CreateRenderTexture()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Expected O, but got Unknown
		if ((Object)(object)renderTexture != (Object)null)
		{
			renderTexture.Release();
			Object.DestroyImmediate((Object)(object)renderTexture);
		}
		renderTexture = new RenderTexture((int)renderResolution.x, (int)renderResolution.y, 24, (RenderTextureFormat)0)
		{
			name = $"PortalRT_{instanceId}",
			antiAliasing = 4,
			filterMode = (FilterMode)1,
			wrapMode = (TextureWrapMode)1,
			useMipMap = false,
			autoGenerateMips = false,
			depth = 24
		};
		renderTexture.Create();
		Debug.Log((object)$"实例 {instanceId}: 创建RenderTexture {((Object)renderTexture).name}");
	}

	private void CreateInstanceMaterial()
	{
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Expected O, but got Unknown
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Expected O, but got Unknown
		if ((Object)(object)materialTemplate == (Object)null)
		{
			Shader val = Shader.Find("Custom/DoubleSidedPortal");
			if ((Object)(object)val == (Object)null)
			{
				val = Shader.Find("Unlit/Texture");
			}
			instanceMaterial = new Material(val);
			Debug.LogWarning((object)$"实例 {instanceId}: 使用默认材质");
		}
		else
		{
			instanceMaterial = new Material(materialTemplate);
		}
		((Object)instanceMaterial).name = $"PortalMaterial_{instanceId}";
		if ((Object)(object)renderTexture != (Object)null)
		{
			instanceMaterial.SetTexture("_MainTex", (Texture)(object)renderTexture);
		}
		if ((Object)(object)targetPlane != (Object)null)
		{
			MeshRenderer component = ((Component)targetPlane).GetComponent<MeshRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				((Renderer)component).material = instanceMaterial;
				Debug.Log((object)$"实例 {instanceId}: 材质应用到平面");
			}
		}
	}

	private void SetupPortalCamera()
	{
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)portalCamera == (Object)null))
		{
			portalCamera.targetTexture = renderTexture;
			portalCamera.depth = -100f + (float)instanceId * 0.1f;
			portalCamera.cullingMask = LayerMask.op_Implicit(cullingMask);
			portalCamera.clearFlags = (CameraClearFlags)2;
			portalCamera.backgroundColor = Color.clear;
			originalFOV = portalCamera.fieldOfView;
			originalPosition = ((Component)this).transform.localPosition;
			UpdateCameraTransform(instant: true);
			Debug.Log((object)$"实例 {instanceId}: 相机设置完成");
		}
	}

	private void Update()
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		if (ValidateComponents())
		{
			((Component)this).transform.position = targetPosition;
			if ((Object)(object)portalCamera != (Object)null)
			{
				portalCamera.fieldOfView = originalFOV / magnification;
			}
		}
	}

	private void UpdateCameraTransform(bool instant = false)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)targetPlane == (Object)null))
		{
			Vector3 val = -planeNormal;
			targetPosition = planeCenter + val * cameraDistance;
			float num = 0.5f;
			float num2 = 20f;
			float num3 = Vector3.Distance(targetPosition, planeCenter);
			num3 = Mathf.Clamp(num3, num, num2);
			targetPosition = planeCenter + val * num3;
			Vector3 val2 = planeCenter - targetPosition;
			if (val2 != Vector3.zero)
			{
				targetRotation = Quaternion.LookRotation(val2, Vector3.up);
			}
			if (instant)
			{
				((Component)this).transform.position = targetPosition;
				((Component)this).transform.rotation = ((Component)mainCamera).transform.rotation;
				return;
			}
			float num4 = smoothFactor * Time.deltaTime;
			float num5 = smoothFactor * Time.deltaTime * 2f;
			((Component)this).transform.position = Vector3.Lerp(((Component)this).transform.position, targetPosition, num4);
			((Component)this).transform.rotation = Quaternion.Slerp(((Component)this).transform.rotation, targetRotation, num5);
		}
	}

	private void LateUpdate()
	{
		if (!ValidateComponents())
		{
			return;
		}
		if ((Object)(object)portalCamera != (Object)null)
		{
			portalCamera.nearClipPlane = 0.01f;
			portalCamera.farClipPlane = renderDepth;
			if ((Object)(object)portalCamera.targetTexture != (Object)(object)renderTexture)
			{
				portalCamera.targetTexture = renderTexture;
			}
		}
		UpdateCameraTransform();
		ValidateCameraPosition();
	}

	private void ValidateCameraPosition()
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)targetPlane == (Object)null) && !((Object)(object)portalCamera == (Object)null))
		{
			Vector3 val = ((Component)this).transform.position - planeCenter;
			float num = Vector3.Dot(val, planeNormal);
			if (Mathf.Abs(num) < 0.3f)
			{
				((Component)this).transform.position = planeCenter + planeNormal * 0.5f * Mathf.Sign(num);
				Debug.LogWarning((object)$"实例 {instanceId}: 相机位置调整，避免穿透平面");
			}
			Vector3 val2 = planeCenter - ((Component)this).transform.position;
			if (val2 != Vector3.zero)
			{
				((Component)this).transform.rotation = Quaternion.LookRotation(val2, Vector3.up);
			}
		}
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)targetPlane == (Object)null) && !((Object)(object)portalCamera == (Object)null))
		{
			Gizmos.color = Color.cyan;
			Gizmos.DrawWireSphere(planeCenter, 0.1f);
			Gizmos.color = Color.green;
			Gizmos.DrawLine(planeCenter, planeCenter + planeNormal);
			Gizmos.color = Color.yellow;
			Gizmos.DrawWireSphere(((Component)this).transform.position, 0.05f);
			Gizmos.DrawLine(((Component)this).transform.position, planeCenter);
			if ((Object)(object)portalCamera != (Object)null)
			{
				Gizmos.color = new Color(1f, 0.5f, 0f, 0.3f);
				DrawCameraFrustum(portalCamera);
			}
		}
	}

	private void DrawCameraFrustum(Camera cam)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		cam.CalculateFrustumCorners(new Rect(0f, 0f, 1f, 1f), cam.farClipPlane, (MonoOrStereoscopicEye)2, array);
		Vector3[] array2 = (Vector3[])(object)new Vector3[4];
		for (int i = 0; i < 4; i++)
		{
			array2[i] = ((Component)cam).transform.TransformVector(array[i]) + ((Component)cam).transform.position;
		}
		Gizmos.DrawLine(((Component)cam).transform.position, array2[0]);
		Gizmos.DrawLine(((Component)cam).transform.position, array2[1]);
		Gizmos.DrawLine(((Component)cam).transform.position, array2[2]);
		Gizmos.DrawLine(((Component)cam).transform.position, array2[3]);
		Gizmos.DrawLine(array2[0], array2[1]);
		Gizmos.DrawLine(array2[1], array2[2]);
		Gizmos.DrawLine(array2[2], array2[3]);
		Gizmos.DrawLine(array2[3], array2[0]);
	}

	private void OnDestroy()
	{
		Debug.Log((object)$"清理门户相机 {instanceId} 资源");
		if ((Object)(object)renderTexture != (Object)null)
		{
			if ((Object)(object)portalCamera != (Object)null && (Object)(object)portalCamera.targetTexture == (Object)(object)renderTexture)
			{
				portalCamera.targetTexture = null;
			}
			renderTexture.Release();
			Object.DestroyImmediate((Object)(object)renderTexture);
		}
		if ((Object)(object)instanceMaterial != (Object)null)
		{
			Object.DestroyImmediate((Object)(object)instanceMaterial);
		}
	}

	public void SetMagnification(float newMagnification)
	{
		magnification = Mathf.Clamp(newMagnification, minMagnification, maxMagnification);
		if ((Object)(object)portalCamera != (Object)null)
		{
			portalCamera.fieldOfView = originalFOV / magnification;
		}
	}

	public void SetCameraDistance(float distance)
	{
		cameraDistance = Mathf.Max(0.5f, distance);
	}

	public RenderTexture GetRenderTexture()
	{
		return renderTexture;
	}

	public Material GetMaterial()
	{
		return instanceMaterial;
	}
}
public class 空间碎裂生成器 : MonoBehaviour
{
	private class FragmentData
	{
		public GameObject fragment;

		public Vector3 moveDirection;

		public float moveSpeed;

		public float shrinkSpeed;

		public Vector3 originalScale;

		public float lifeTime = 0f;

		public bool isActive = true;
	}

	[CompilerGenerated]
	private sealed class <FadeOutAndDestroy>d__23 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public FragmentData fragment;

		public 空间碎裂生成器 <>4__this;

		private Renderer <renderer>5__1;

		private Material <material>5__2;

		private Color <originalColor>5__3;

		private float <fadeTime>5__4;

		private float <elapsedTime>5__5;

		private float <alpha>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <FadeOutAndDestroy>d__23(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<renderer>5__1 = null;
			<material>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			int num = <>1__state;
			if (num != 0)
			{
				if (num != 1)
				{
					return false;
				}
				<>1__state = -1;
			}
			else
			{
				<>1__state = -1;
				if ((Object)(object)fragment.fragment == (Object)null)
				{
					return false;
				}
				<renderer>5__1 = fragment.fragment.GetComponent<Renderer>();
				if (!((Object)(object)<renderer>5__1 != (Object)null))
				{
					goto IL_0143;
				}
				<material>5__2 = <renderer>5__1.material;
				<originalColor>5__3 = <material>5__2.color;
				<fadeTime>5__4 = 0.5f;
				<elapsedTime>5__5 = 0f;
			}
			if (<elapsedTime>5__5 < <fadeTime>5__4)
			{
				<elapsedTime>5__5 += Time.deltaTime;
				<alpha>5__6 = Mathf.Lerp(1f, 0f, <elapsedTime>5__5 / <fadeTime>5__4);
				<material>5__2.color = new Color(<originalColor>5__3.r, <originalColor>5__3.g, <originalColor>5__3.b, <alpha>5__6);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			<material>5__2 = null;
			goto IL_0143;
			IL_0143:
			if ((Object)(object)fragment.fragment != (Object)null)
			{
				Object.Destroy((Object)(object)fragment.fragment);
			}
			fragment.isActive = false;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpawnObjects>d__19 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public 空间碎裂生成器 <>4__this;

		private int <i>5__1;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpawnObjects>d__19(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.isSpawning = true;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				<i>5__1++;
				break;
			}
			if (<i>5__1 < <>4__this.objectsPerKeyPress)
			{
				<>4__this.SpawnRandomObject();
				<>4__this.spawnInterval -= 0.01f;
				if (<>4__this.spawnInterval <= 0.01f)
				{
					<>4__this.spawnInterval = 0.01f;
				}
				<>2__current = (object)new WaitForSeconds(<>4__this.spawnInterval);
				<>1__state = 1;
				return true;
			}
			<>4__this.isSpawning = false;
			<>4__this.allObjectsGenerated = true;
			Debug.Log((object)$"所有碎片生成完成，开始运动效果，碎片数量：{<>4__this.activeFragments.Count}");
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[Header("生成设置")]
	[SerializeField]
	private float spawnRadius = 15f;

	[SerializeField]
	public GameObject[] objectPrefabs;

	[SerializeField]
	private KeyCode spawnKey = (KeyCode)107;

	[Header("随机范围")]
	[SerializeField]
	private Vector2 scaleRange = new Vector2(1f, 2f);

	[SerializeField]
	private Vector2 moveSpeedRange = new Vector2(1f, 3f);

	[SerializeField]
	private Vector2 shrinkSpeedRange = new Vector2(0.5f, 1.5f);

	[SerializeField]
	private bool randomizeRotation = true;

	[Header("生成控制")]
	[SerializeField]
	private float spawnInterval = 0.1f;

	[SerializeField]
	private int objectsPerKeyPress = 7;

	[SerializeField]
	private float destroyDelay = 3f;

	private bool isSpawning = false;

	private bool allObjectsGenerated = false;

	private Coroutine spawnCoroutine;

	private List<FragmentData> activeFragments = new List<FragmentData>();

	private void Start()
	{
		StartSpawning();
	}

	private void Update()
	{
		if (allObjectsGenerated && activeFragments.Count > 0)
		{
			UpdateFragmentsMovement();
		}
	}

	private void StartSpawning()
	{
		if (spawnCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(spawnCoroutine);
		}
		allObjectsGenerated = false;
		CleanupOldFragments();
		spawnCoroutine = ((MonoBehaviour)this).StartCoroutine(SpawnObjects());
	}

	private void StopSpawning()
	{
		if (spawnCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(spawnCoroutine);
		}
		isSpawning = false;
	}

	[IteratorStateMachine(typeof(<SpawnObjects>d__19))]
	private IEnumerator SpawnObjects()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpawnObjects>d__19(0)
		{
			<>4__this = this
		};
	}

	private void SpawnRandomObject()
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_017e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_0187: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
		if (objectPrefabs == null || objectPrefabs.Length == 0)
		{
			Debug.LogWarning((object)"请为空间碎裂生成器脚本分配预制体！");
			return;
		}
		GameObject val = objectPrefabs[Random.Range(0, objectPrefabs.Length)];
		Vector3 val2 = ((Component)this).transform.position + Random.insideUnitSphere * spawnRadius;
		Quaternion val3 = (randomizeRotation ? Random.rotation : Quaternion.identity);
		float num = Random.Range(scaleRange.x, scaleRange.y);
		Vector3 val4 = Vector3.one * num;
		GameObject val5 = Object.Instantiate<GameObject>(val, val2, val3, ((Component)this).gameObject.transform);
		((Object)val5).name = $"空间碎片_{Time.time:F2}";
		val5.transform.localScale = val4;
		FragmentData fragmentData = new FragmentData
		{
			fragment = val5,
			originalScale = val4,
			moveSpeed = Random.Range(moveSpeedRange.x, moveSpeedRange.y),
			shrinkSpeed = Random.Range(shrinkSpeedRange.x, shrinkSpeedRange.y),
			isActive = true
		};
		float num2 = Random.Range(0f, 360f);
		float num3 = num2 * ((float)Math.PI / 180f);
		Vector3 val6 = new Vector3(Mathf.Cos(num3) * 0.3f, -1f, Mathf.Sin(num3) * 0.3f);
		fragmentData.moveDirection = ((Vector3)(ref val6)).normalized;
		activeFragments.Add(fragmentData);
		Debug.Log((object)("生成物体: " + ((Object)val5).name + " " + $"位置: {val2} " + $"缩放: {num}"));
	}

	private void UpdateFragmentsMovement()
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_0189: Unknown result type (might be due to invalid IL or missing references)
		List<FragmentData> list = new List<FragmentData>();
		for (int num = activeFragments.Count - 1; num >= 0; num--)
		{
			FragmentData fragmentData = activeFragments[num];
			if (fragmentData == null || (Object)(object)fragmentData.fragment == (Object)null || !fragmentData.isActive)
			{
				list.Add(fragmentData);
				continue;
			}
			fragmentData.lifeTime += Time.deltaTime;
			Vector3 val = fragmentData.moveDirection * fragmentData.moveSpeed * Time.deltaTime;
			Transform transform = fragmentData.fragment.transform;
			transform.position += val;
			Vector3 localScale = fragmentData.fragment.transform.localScale;
			if (((Vector3)(ref localScale)).magnitude > 0.001f)
			{
				float num2 = fragmentData.shrinkSpeed * Time.deltaTime;
				fragmentData.fragment.transform.localScale = Vector3.Lerp(fragmentData.fragment.transform.localScale, Vector3.zero, num2 * 0.5f);
				fragmentData.fragment.transform.Rotate(Random.Range(-90f, 90f) * Time.deltaTime, Random.Range(-90f, 90f) * Time.deltaTime, Random.Range(-90f, 90f) * Time.deltaTime);
			}
			else
			{
				fragmentData.isActive = false;
			}
			if (!(fragmentData.lifeTime >= destroyDelay))
			{
				localScale = fragmentData.fragment.transform.localScale;
				if (!(((Vector3)(ref localScale)).magnitude <= 0.01f))
				{
					continue;
				}
			}
			Object.Destroy((Object)(object)fragmentData.fragment);
			fragmentData.isActive = false;
			list.Add(fragmentData);
		}
		foreach (FragmentData item in list)
		{
			activeFragments.Remove(item);
		}
		if (activeFragments.Count == 0 && allObjectsGenerated)
		{
			Debug.Log((object)"所有碎片已处理完毕");
			allObjectsGenerated = false;
		}
	}

	private void CleanupOldFragments()
	{
		foreach (FragmentData activeFragment in activeFragments)
		{
			if (activeFragment != null && (Object)(object)activeFragment.fragment != (Object)null)
			{
				Object.Destroy((Object)(object)activeFragment.fragment);
			}
		}
		activeFragments.Clear();
	}

	[IteratorStateMachine(typeof(<FadeOutAndDestroy>d__23))]
	private IEnumerator FadeOutAndDestroy(FragmentData fragment)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <FadeOutAndDestroy>d__23(0)
		{
			<>4__this = this,
			fragment = fragment
		};
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		Gizmos.color = Color.cyan;
		Gizmos.DrawWireSphere(((Component)this).transform.position, spawnRadius);
		Gizmos.color = Color.red;
		Vector3 val = new Vector3(0.3f, -1f, 0.3f);
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		Gizmos.DrawRay(((Component)this).transform.position, normalized * 5f);
	}

	private void SpawnSingleObject()
	{
		SpawnRandomObject();
	}

	public void TriggerShatterEffect()
	{
		StartSpawning();
	}

	public void SetFragmentCount(int count)
	{
		objectsPerKeyPress = Mathf.Max(1, count);
	}

	public void StartFragmentMovement()
	{
		if (!allObjectsGenerated && !isSpawning)
		{
			allObjectsGenerated = true;
		}
	}
}
public class 召唤预制体 : MonoBehaviour
{
	public GameObject prefabToSpawn;

	private void Start()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)prefabToSpawn != (Object)null)
		{
			Object.Instantiate<GameObject>(prefabToSpawn, ((Component)this).transform.position, ((Component)this).transform.rotation);
			Debug.LogWarning((object)"yi实例化!!");
		}
		else
		{
			Debug.LogWarning((object)"请指定要实例化的预制体");
		}
	}
}
public class 会员客户目标选择器 : MonoBehaviour
{
	private Unit unit;

	private bool 判断1 = true;

	private float 计时器 = 0f;

	public void Start()
	{
		unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
		UnitAPI api = unit.api;
	}
}
namespace ModdingForDummies
{
	[BepInPlugin("nihongpaoxi34589", "nihongpaoxi344589", "1.0.0")]
	public class Launcher : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <Launcher1>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Launcher <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Launcher1>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(7f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					SLMALoader.GetInstance();
					UmMyMod.Main2();
					new Harmony(Main212.modname).PatchAll();
					Debug.Log((object)"已加载霓虹派系");
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private void Awake()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"霓虹补丁注入中...");
			Harmony.CreateAndPatchAll(typeof(bububudinghding), (string)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"霓虹补丁注入完成！");
			((MonoBehaviour)this).StartCoroutine(Launcher1());
		}

		[IteratorStateMachine(typeof(<Launcher1>d__1))]
		private IEnumerator Launcher1()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Launcher1>d__1(0)
			{
				<>4__this = this
			};
		}
	}
	public static class UmMyMod
	{
		public static AssetBundle Asset1;

		public static AssetBundle Asset2;

		public static Faction 霓虹派系公用;

		public static void Main2()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0502: Unknown result type (might be due to invalid IL or missing references)
			//IL_0781: Unknown result type (might be due to invalid IL or missing references)
			//IL_0795: Expected O, but got Unknown
			//IL_0856: Unknown result type (might be due to invalid IL or missing references)
			//IL_086b: Expected O, but got Unknown
			//IL_0c3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c50: Expected O, but got Unknown
			//IL_0c75: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c8a: Expected O, but got Unknown
			//IL_0caf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc4: Expected O, but got Unknown
			//IL_1039: Unknown result type (might be due to invalid IL or missing references)
			//IL_103f: Expected O, but got Unknown
			//IL_105e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1064: Expected O, but got Unknown
			//IL_10b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_10bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_121e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1224: Expected O, but got Unknown
			//IL_1257: Unknown result type (might be due to invalid IL or missing references)
			//IL_125d: Expected O, but got Unknown
			//IL_12aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b0: Expected O, but got Unknown
			//IL_12cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d5: Expected O, but got Unknown
			//IL_13e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_13ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_1435: Unknown result type (might be due to invalid IL or missing references)
			//IL_143a: Unknown result type (might be due to invalid IL or missing references)
			//IL_144b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1450: Unknown result type (might be due to invalid IL or missing references)
			//IL_1455: Unknown result type (might be due to invalid IL or missing references)
			//IL_145f: Expected O, but got Unknown
			//IL_1547: Unknown result type (might be due to invalid IL or missing references)
			//IL_154c: Unknown result type (might be due to invalid IL or missing references)
			//IL_16b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_16bb: Expected O, but got Unknown
			//IL_17c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_17cb: Expected O, but got Unknown
			//IL_18d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_18de: Expected O, but got Unknown
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("Niiido.fghrrh");
			AssetBundle val = (Asset1 = AssetBundle.LoadFromStream(manifestResourceStream));
			Material[] redmaterials = (Material[])(object)new Material[1]
			{
				new Material(val.LoadAsset<Material>("redt1"))
			};
			Material[] bullmasss = (Material[])(object)new Material[1]
			{
				new Material(val.LoadAsset<Material>("bullt1"))
			};
			Material[] redmaterials2 = (Material[])(object)new Material[1]
			{
				new Material(val.LoadAsset<Material>("redt2"))
			};
			Material[] bullmasss2 = (Material[])(object)new Material[1]
			{
				new Material(val.LoadAsset<Material>("bullt2"))
			};
			Texture2D val2 = val.LoadAsset<Texture2D>("光剑士兵43");
			((Texture)val2).filterMode = (FilterMode)0;
			Sprite val3 = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f));
			Texture2D val4 = val.LoadAsset<Texture2D>("光剑大师34");
			((Texture)val4).filterMode = (FilterMode)0;
			Sprite val5 = Sprite.Create(val4, new Rect(0f, 0f, (float)((Texture)val4).width, (float)((Texture)val4).height), new Vector2(0.5f, 0.5f));
			Texture2D val6 = val.LoadAsset<Texture2D>("或i吨传送23");
			((Texture)val6).filterMode = (FilterMode)0;
			Sprite val7 = Sprite.Create(val6, new Rect(0f, 0f, (float)((Texture)val6).width, (float)((Texture)val6).height), new Vector2(0.5f, 0.5f));
			Texture2D val8 = val.LoadAsset<Texture2D>("擂台炮2342");
			((Texture)val8).filterMode = (FilterMode)0;
			Sprite val9 = Sprite.Create(val8, new Rect(0f, 0f, (float)((Texture)val8).width, (float)((Texture)val8).height), new Vector2(0.5f, 0.5f));
			Texture2D val10 = val.LoadAsset<Texture2D>("激光塔345t");
			((Texture)val10).filterMode = (FilterMode)0;
			Sprite val11 = Sprite.Create(val10, new Rect(0f, 0f, (float)((Texture)val10).width, (float)((Texture)val10).height), new Vector2(0.5f, 0.5f));
			Texture2D val12 = val.LoadAsset<Texture2D>("激光枪手i234");
			((Texture)val12).filterMode = (FilterMode)0;
			Sprite val13 = Sprite.Create(val12, new Rect(0f, 0f, (float)((Texture)val12).width, (float)((Texture)val12).height), new Vector2(0.5f, 0.5f));
			Texture2D val14 = val.LoadAsset<Texture2D>("磁暴步兵234");
			((Texture)val14).filterMode = (FilterMode)0;
			Sprite val15 = Sprite.Create(val14, new Rect(0f, 0f, (float)((Texture)val14).width, (float)((Texture)val14).height), new Vector2(0.5f, 0.5f));
			Texture2D val16 = val.LoadAsset<Texture2D>("罪恶克星1234");
			((Texture)val16).filterMode = (FilterMode)0;
			Sprite val17 = Sprite.Create(val16, new Rect(0f, 0f, (float)((Texture)val16).width, (float)((Texture)val16).height), new Vector2(0.5f, 0.5f));
			Texture2D val18 = val.LoadAsset<Texture2D>("雷电法王3144");
			((Texture)val18).filterMode = (FilterMode)0;
			Sprite val19 = Sprite.Create(val18, new Rect(0f, 0f, (float)((Texture)val18).width, (float)((Texture)val18).height), new Vector2(0.5f, 0.5f));
			Texture2D val20 = val.LoadAsset<Texture2D>("穿透射线23");
			((Texture)val20).filterMode = (FilterMode)0;
			Sprite val21 = Sprite.Create(val20, ne