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 System.Security;
using System.Security.Permissions;
using BepInEx;
using DM;
using EzECS.Barriers;
using HarmonyLib;
using Landfall.TABS;
using Landfall.TABS.AI.Components;
using Landfall.TABS.AI.Components.Modifiers;
using Landfall.TABS.AI.Components.Tags;
using Landfall.TABS.GameState;
using SLMA;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Mod name")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("made in SFT by FhpSlime")]
[assembly: AssemblyCopyright("Copyright ©  2022")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("3a45c3cf-230c-4310-952f-0887d4266a22")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class Item : MonoBehaviour
{
	public enum kind
	{
		Weapon,
		Cloth,
		Skill,
		Unit,
		Projectile,
		Other
	}

	public string name;

	public kind Kind;
}
namespace CurscdArmyOfVolumnia;

[UpdateAfter(typeof(UpdateBarrier))]
[UpdateBefore(typeof(PreLateUpdateBarrier))]
public class 近战保持距离大力转飞 : JobComponentSystem
{
	private struct Filter
	{
		public EntityArray Entities;

		public ComponentDataArray<Velocity> Velocities;

		[ReadOnly]
		public ComponentDataArray<Range> Ranges;

		[ReadOnly]
		public ComponentDataArray<TargetData> TargetDatas;

		[ReadOnly]
		public ComponentDataArray<HasTargetTag> HasTargetTags;

		[ReadOnly]
		public ComponentDataArray<诅咒长毛手近战> 诅咒长毛手近战;

		[ReadOnly]
		public SubtractiveComponent<IsInPool> IsInPool;

		public readonly int Length;
	}

	private struct Job : IJobParallelFor
	{
		public EntityArray Entities;

		public ComponentDataArray<Velocity> Velocities;

		[ReadOnly]
		public ComponentDataArray<Range> Ranges;

		[ReadOnly]
		public ComponentDataArray<TargetData> TargetDatas;

		[ReadOnly]
		public ComponentDataArray<HasTargetTag> HasTargetTags;

		[ReadOnly]
		public SubtractiveComponent<IsInPool> IsInPool;

		public Concurrent CommandBuffer;

		public void Execute(int index)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0051: 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_0087: 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)
			Entity val = ((EntityArray)(ref Entities))[index];
			Velocity val2 = Velocities[index];
			Range val3 = Ranges[index];
			if (!(HasTargetTags[index].Target == Entity.Null) && TargetDatas[index].TargetInPreferredRange == 1)
			{
				val2.Value = new float3(0f, 0f, -2f);
				((Concurrent)(ref CommandBuffer)).SetComponent<Velocity>(index, val, val2);
			}
		}
	}

	[Inject]
	private Filter m_filter;

	[Inject]
	private PreLateUpdateBarrier m_barrier;

	protected override JobHandle OnUpdate(JobHandle inputDeps)
	{
		//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_001d: 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_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: 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_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: 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_0073: 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_008b: 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_0094: Unknown result type (might be due to invalid IL or missing references)
		EntityCommandBuffer val = ((BarrierSystem)m_barrier).CreateCommandBuffer();
		Job job = default(Job);
		job.Entities = m_filter.Entities;
		job.Ranges = m_filter.Ranges;
		job.Velocities = m_filter.Velocities;
		job.HasTargetTags = m_filter.HasTargetTags;
		job.TargetDatas = m_filter.TargetDatas;
		job.CommandBuffer = ((EntityCommandBuffer)(ref val)).ToConcurrent();
		return IJobParallelForExtensions.Schedule<Job>(job, m_filter.Length, 12, inputDeps);
	}
}
[StructLayout(LayoutKind.Sequential, Size = 1)]
public struct 诅咒长毛手近战 : IMovementComponent, IComponentData
{
}
internal class Hbudingads
{
}
[BepInPlugin("CurscdArmyOfVolumnia", "CurscdArmyOfVolumnia", "1.0.0")]
internal class Loader : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <call>d__1 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Loader <>4__this;

		private GameObject <SecretUnlockSpawner>5__1;

		private LandfallContentDatabase <landfallContentDatabase>5__2;

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

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

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

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

		private bool MoveNext()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Object.FindObjectOfType<ServiceLocator>() != (Object)null));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<>2__current = (object)new WaitUntil((Func<bool>)(() => ServiceLocator.GetService<ISaveLoaderService>() != null));
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				<>2__current = (object)new WaitForSecondsRealtime(0.3f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				<SecretUnlockSpawner>5__1 = new GameObject("诅咒军团隐藏物体添加");
				Object.DontDestroyOnLoad((Object)(object)<SecretUnlockSpawner>5__1);
				<SecretUnlockSpawner>5__1.AddComponent<ScenesManager17>();
				SLMALoader.GetInstance();
				<landfallContentDatabase>5__2 = ContentDatabase.Instance().LandfallContentDatabase;
				UManager.Init(<landfallContentDatabase>5__2);
				new Harmony(UManager.modname).PatchAll();
				Debug.Log((object)("Loaded " + UManager.modname + " Successfully"));
				Debug.Log((object)(UManager.modname + "is made in SFT by FhpSlime"));
				Debug.Log((object)(UManager.modder + "wished you a pleasant trip"));
				<>2__current = (object)new WaitForSecondsRealtime(60f);
				<>1__state = 4;
				return true;
			case 4:
				<>1__state = -1;
				<>4__this.CheckAndPrintRenderPipeline();
				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()
	{
		((MonoBehaviour)this).StartCoroutine("call");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"诅咒军团补丁注入中...");
		Harmony.CreateAndPatchAll(typeof(Hbudingads), (string)null);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"诅咒军团补丁注入完成！");
	}

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

	private void CheckAndPrintRenderPipeline()
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
		Debug.Log((object)"=== 当前游戏渲染管线信息 ===");
		if ((Object)(object)currentRenderPipeline != (Object)null)
		{
			string name = ((object)currentRenderPipeline).GetType().Name;
			Debug.Log((object)("渲染管线类型: " + name));
		}
		else
		{
			Debug.Log((object)"检测到：内置渲染管线 (Built-in Render Pipeline)");
		}
		Debug.Log((object)$"当前图形API: {SystemInfo.graphicsDeviceType}");
		Debug.Log((object)("当前显卡: " + SystemInfo.graphicsDeviceName));
		RenderPipelineAsset renderPipeline = QualitySettings.renderPipeline;
		if ((Object)(object)renderPipeline != (Object)null)
		{
			Debug.Log((object)("质量设置中的渲染管线: " + ((object)renderPipeline).GetType().Name));
		}
		Debug.Log((object)"================================");
	}
}
public static class UManager
{
	public static class 工具
	{
		public static void 设置兵编分类(GameObject item, string categoryName = "CurscdArmyOfVolumnia", TagType tagType = 0)
		{
			//IL_001c: 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_0025: 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)
			CharacterItem componentInChildren = item.GetComponentInChildren<CharacterItem>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.tags = new List<Tag>
				{
					new Tag
					{
						tagType = tagType,
						value = categoryName
					}
				};
			}
		}

		public static Sprite 设置图标(AssetBundle assetBundle, string assetbundlename = "")
		{
			//IL_002a: 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)
			Texture2D val = assetBundle.LoadAsset<Texture2D>(assetbundlename);
			((Texture)val).filterMode = (FilterMode)2;
			return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
		}

		public static Sprite 直接设置图标(AssetBundle assetBundle, string assetbundlename = "")
		{
			return assetBundle.LoadAsset<Sprite>(assetbundlename);
		}

		public static GameObject[] 获取游戏物品服饰(AssetBundle ab包, string[] 名称组)
		{
			List<GameObject> list = new List<GameObject>();
			for (int i = 0; i < 名称组.Length; i++)
			{
				list.Add(UPool.MyPool.AddObject(名称组[i], ab包.LoadAsset<GameObject>(名称组[i]), true, (HideFlags)52, (Sprite)null, modid, true));
				modid++;
			}
			return list.ToArray();
		}

		public static GameObject 获取游戏物品服饰单(AssetBundle ab包, string 名称组)
		{
			GameObject result = UPool.MyPool.AddObject(名称组, ab包.LoadAsset<GameObject>(名称组), true, (HideFlags)52, (Sprite)null, modid, true);
			modid++;
			return result;
		}
	}

	public static AssetBundle ab包;

	public static int modid = 29302933;

	public static string modname = "CurscdArmyOfVolumnia";

	public static string modder = "FhpSlime";

	private static string com;

	public static void Init(LandfallContentDatabase db)
	{
		//IL_0057: 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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0493: Unknown result type (might be due to invalid IL or missing references)
		//IL_049f: Expected O, but got Unknown
		//IL_0666: Unknown result type (might be due to invalid IL or missing references)
		//IL_066c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0788: Unknown result type (might be due to invalid IL or missing references)
		//IL_078e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cb5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ccb: Expected O, but got Unknown
		//IL_0ef6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0efc: Expected O, but got Unknown
		com = "——————————Fations and Units——————————";
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("CurscdArmyOfVolumnia.ghjwrter");
		AssetBundle val = (ab包 = AssetBundle.LoadFromStream(manifestResourceStream));
		Texture2D val2 = val.LoadAsset<Texture2D>("sdhsoeugfe");
		((Texture)val2).filterMode = (FilterMode)2;
		Sprite val3 = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f));
		Faction val4 = SLMATool.CreateFaction("CurscdArmyOfVolumnia", (UnitBlueprint[])null, val3, 794502);
		val4.m_FactionCatagory = (FactionCatagory)0;
		s.SetField<Faction>(val4, "m_isSecret", (object)true);
		s.SetField<Faction>(val4, "m_lockSecrets", (object)true);
		多国语言部分hhh.语言添加("UNIT_ZUDUANDUANNU", "诅咒短弩#Cursed Crossbow#呪われたクロスボウ#Verfluchte Armbrust#Arbalète Maudite#Проклятый арбалет#Ballesta Maldita#Balestra Maledetta");
		多国语言部分hhh.语言添加("UNIT_ZUJUJIAN", "诅咒巨剑#Cursed Greatsword#呪われた大剣#Verfluchtes Großschwert#Espadon Maudit#Проклятый двуручный меч#Espadón Maldito#Spadone Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUDUNPAI", "诅咒盾牌#Cursed Shield#呪われた盾#Verfluchter Schild#Bouclier Maudit#Проклятый щит#Escudo Maldito#Scudo Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUBISHOU", "诅咒匕首#Cursed Dagger#呪われた短剣#Verfluchter Dolch#Dague Maudite#Проклятый кинжал#Daga Maldita#Pugnale Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGJIAN", "诅咒长剑#Cursed Longsword#呪われた長剣#Verfluchtes Langschwert#Épée Longue Maudite#Проклятый длинный меч#Espada Larga Maldita#Spada Lunga Maledetta");
		多国语言部分hhh.语言添加("UNIT_TEZHIQIANG", "特制骑枪#Custom Lance#特製ランス#Speziallanze#Lance Sur Mesure#Особое копьё#Lanza Especial#Lancia Speciale");
		多国语言部分hhh.语言添加("UNIT_ZUYOUXIAGONG", "诅咒游侠弓#Cursed Ranger Bow#呪われたレンジャーボウ#Verfluchter Waldläuferbogen#Arc de Ranger Maudit#Проклятый лук рейнджера#Arco de Explorador Maldito#Arco da Ranger Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUSHENGQISHICUIZI", "诅咒圣骑士的锤子#Cursed Paladin Hammer#呪われたパラディンのハンマー#Verfluchter Paladinshammer#Marteau de Paladin Maudit#Проклятый молот паладина#Martillo de Paladín Maldito#Martello del Paladino Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGGONG", "诅咒长弓#Cursed Longbow#呪われた長弓#Verfluchter Langbogen#Arc Long Maudit#Проклятый длинный лук#Arco Largo Maldito#Arco Lungo Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGJIBINGWUQI", "诅咒长戟兵武器#Cursed Halberdier Weapon#呪われたハルバーディアの武器#Verfluchte Hellebarde#Arme de Hallebardier Maudite#Проклятое оружие алебардщика#Arma de Alabardero Maldita#Arma dell'Alabardiere Maledetta");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGQIANG", "诅咒长枪#Cursed Spear#呪われた長槍#Verfluchter Speer#Lance Maudite#Проклятое копьё#Lanza Maldita#Lancia Maledetta");
		多国语言部分hhh.语言添加("UNIT_JIAOSHIDEFUZI", "教士的斧头#Cleric Axe#聖職者の斧#Klerikeraxt#Hache de Clerc#Топор священника#Hacha de Clérigo#Ascia del Chierico");
		GameObject val5 = UPool.MyPool.AddObject("UNIT_ZUDUANDUANNU", val.LoadAsset<GameObject>("nuergjhrefd"), true, (HideFlags)52, (Sprite)null, 773332, true);
		GameObject rightWeapon = UPool.MyPool.AddObject("UNIT_ZUJUJIAN", val.LoadAsset<GameObject>("巨剑435543"), true, (HideFlags)52, (Sprite)null, 773333, true);
		GameObject val6 = UPool.MyPool.AddObject("UNIT_ZUDUNPAI", val.LoadAsset<GameObject>("诅咒盾牌423"), true, (HideFlags)52, (Sprite)null, 773334, true);
		GameObject val7 = UPool.MyPool.AddObject("UNIT_ZUBISHOU", val.LoadAsset<GameObject>("诅咒匕首4323"), true, (HideFlags)52, (Sprite)null, 773335, true);
		GameObject rightWeapon2 = UPool.MyPool.AddObject("UNIT_ZUCHANGJIAN", val.LoadAsset<GameObject>("诅咒长剑fe"), true, (HideFlags)52, (Sprite)null, 773336, true);
		GameObject leftWeapon = UPool.MyPool.AddObject("UNIT_TEZHIQIANG", val.LoadAsset<GameObject>("特制骑枪34"), true, (HideFlags)52, (Sprite)null, 773337, true);
		GameObject val8 = UPool.MyPool.AddObject("UNIT_ZUYOUXIAGONG", val.LoadAsset<GameObject>("诅咒游侠弓54"), true, (HideFlags)52, (Sprite)null, 773338, true);
		GameObject rightWeapon3 = UPool.MyPool.AddObject("UNIT_ZUSHENGQISHICUIZI", val.LoadAsset<GameObject>("诅咒圣骑士的大锤43"), true, (HideFlags)52, (Sprite)null, 773339, true);
		GameObject val9 = UPool.MyPool.AddObject("UNIT_ZUCHANGGONG", val.LoadAsset<GameObject>("长弓4535465"), true, (HideFlags)52, (Sprite)null, 773340, true);
		GameObject rightWeapon4 = UPool.MyPool.AddObject("UNIT_ZUCHANGJIBINGWUQI", val.LoadAsset<GameObject>("诅咒长戟兵武器3231"), true, (HideFlags)52, (Sprite)null, 773341, true);
		GameObject rightWeapon5 = UPool.MyPool.AddObject("UNIT_ZUCHANGQIANG", val.LoadAsset<GameObject>("诅咒长枪3432"), true, (HideFlags)52, (Sprite)null, 773342, true);
		GameObject val10 = UPool.MyPool.AddObject("UNIT_JIAOSHIDEFUZI", val.LoadAsset<GameObject>("教士的斧头34"), true, (HideFlags)52, (Sprite)null, 773343, true);
		多国语言部分hhh.语言添加("UNIT_XIAOXINGNUJIAN", "小型弩箭#Small Bolt#小型ボルト#Kleiner Bolzen#Carreau Léger#Малый болт#Virote Pequeño#Quadrello Piccolo");
		多国语言部分hhh.语言添加("UNIT_ZUYOUXIAJIAN", "诅咒游侠箭#Cursed Ranger Arrow#呪われたレンジャーの矢#Verfluchter Waldläuferpfeil#Flèche de Ranger Maudite#Проклятая стрела рейнджера#Flecha de Explorador Maldita#Freccia da Ranger Maledetta");
		多国语言部分hhh.语言添加("UNIT_CHANGGONGSHOUJIAN", "长弓手射箭#Longbowman Arrow#長弓兵の矢#Langbogenschützenpfeil#Flèche d'Archer Long#Стрела лучника#Flecha de Arquero Largo#Freccia dell'Arciere Lungo");
		多国语言部分hhh.语言添加("UNIT_YOUXIAJITUIJIAN", "游侠击退箭#Ranger Repelling Sword#レンジャーの撃退剣#Waldläufer-Abwehrschwert#Épée de Répulsion du Ranger#Меч отбрасывания рейнджера#Espada de Repulsión de Explorador#Spada di Respingimento del Ranger");
		多国语言部分hhh.语言添加("UNIT_ZUJIAOSHIDEDAFUZI", "诅咒教士的大斧头#Cursed Cleric Great Axe#呪われた聖職者の大斧#Verfluchte Klerikergroßaxt#Grande Hache de Clerc Maudite#Проклятый большой топор священника#Gran Hacha de Clérigo Maldita#Grande Ascia del Chierico Maledetta");
		GameObject val11 = UPool.MyPool.AddObject("UNIT_XIAOXINGNUJIAN", val.LoadAsset<GameObject>("小型弩箭23"), true, (HideFlags)52, (Sprite)null, 773344, true);
		val11.GetComponentInChildren<ProjectileHit>().damage = 140f;
		val5.GetComponentInChildren<RangeWeapon>().ObjectToSpawn = val11;
		((Weapon)val5.GetComponentInChildren<RangeWeapon>()).internalCooldown = 6f;
		GameObject val12 = UPool.MyPool.AddObject("UNIT_ZUYOUXIAJIAN", val.LoadAsset<GameObject>("诅咒游侠箭657"), true, (HideFlags)52, (Sprite)null, 773345, true);
		val12.GetComponentInChildren<ProjectileHit>().damage = 200f;
		val8.GetComponentInChildren<RangeWeapon>().ObjectToSpawn = val12;
		GameObject val13 = UPool.MyPool.AddObject("UNIT_CHANGGONGSHOUJIAN", val.LoadAsset<GameObject>("长弓手射箭34"), true, (HideFlags)52, (Sprite)null, 773346, true);
		GameObject val14 = UPool.MyPool.AddObject("UNIT_YOUXIAJITUIJIAN", val.LoadAsset<GameObject>("游侠击退箭425"), true, (HideFlags)52, (Sprite)null, 10928837, true);
		UnitBlueprint val15 = SLMATool.CreateUnit("空骷髅单位", (UnitBlueprint)SLMALoader.SDic["blueprints"]["UNIT_HALLOWEEN_SKELETONWARRIOR"], (Faction)null, (Sprite)null);
		val15.sizeMultiplier = 1f;
		val15.massMultiplier = 1f;
		val15.RightWeapon = null;
		val15.LeftWeapon = null;
		val15.health = 100f;
		val15.movementSpeedMuiltiplier = 1f;
		val15.m_props = (GameObject[])(object)new GameObject[0];
		val15.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[0];
		GameObject rightWeapon6 = UPool.MyPool.AddObject("UNIT_ZUJIAOSHIDEDAFUZI", val.LoadAsset<GameObject>("教士的斧头(大)34"), true, (HideFlags)52, (Sprite)null, 10928838, true);
		多国语言部分hhh.语言添加("UNIT_PENGZHUANGMIANYIYUANCHENG3MIAO", "碰撞免疫远程3秒#Collision Immunity Ranged 3s#衝突免疫（遠隔）3秒#Aufprallimmunität Fernkampf 3s#Immunité de Collision à Distance 3s#Иммунитет к столкновениям дальний 3с#Inmunidad a Colisiones a Distancia 3s#Immunità agli Urti a Distanza 3s");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGQIANGSOUS", "诅咒长枪手#Cursed Spearman#呪われた槍兵#Verfluchter Speerkämpfer#Lancier Maudit#Проклятый копейщик#Lancero Maldito#Lanciere Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUNUSHOU", "诅咒弩手#Cursed Crossbowman#呪われた弩兵#Verfluchter Armbrustschütze#Arbalétrier Maudit#Проклятый арбалетчик#Ballestero Maldito#Balestriere Maledetto");
		多国语言部分hhh.语言添加("UNIT_JINZHANSHANBI3MIAO", "近战闪避3秒#Melee Dodge 3s#近接回避3秒#Nahkampfausweichen 3s#Esquive de Mêlée 3s#Уклонение в ближнем бою 3с#Esquiva Cuerpo a Cuerpo 3s#Schivata in Mischia 3s");
		多国语言部分hhh.语言添加("UNIT_PAOSHEWUSHANBI3MIAO", "抛射物闪避3秒#Projectile Dodge 3s#投射物回避3秒#Geschossausweichen 3s#Esquive de Projectile 3s#Уклонение от снарядов 3с#Esquiva de Proyectiles 3s#Schivata dei Proiettili 3s");
		多国语言部分hhh.语言添加("UNIT_ZUJIAOSHI", "诅咒教士#Cursed Cleric#呪われた聖職者#Verfluchter Kleriker#Clerc Maudit#Проклятый священник#Clérigo Maldito#Chierico Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUYOULIEZHE", "诅咒游猎者#Cursed Hunter#呪われた狩猟者#Verfluchter Jäger#Chasseur Maudit#Проклятый охотник#Cazador Maldito#Cacciatore Maledetto");
		GameObject val16 = UPool.MyPool.AddObject("UNIT_PENGZHUANGMIANYIYUANCHENG3MIAO", val.LoadAsset<GameObject>("碰撞免疫远程34"), true, (HideFlags)52, (Sprite)null, 10928839, true);
		UnitBlueprint val17 = SLMATool.CreateUnit("UNIT_ZUCHANGQIANGSOUS", val15, val4, 工具.直接设置图标(val, "诅咒长枪手"));
		val17.RightWeapon = rightWeapon5;
		val17.health = 100f;
		val17.forceCost = 100u;
		val17.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(诅咒长毛手近战) };
		val17.massMultiplier = 10f;
		UnitBlueprint val18 = SLMATool.CreateUnit("UNIT_ZUNUSHOU", val15, val4, 工具.直接设置图标(val, "诅咒弩手"));
		val18.RightWeapon = val5;
		val18.health = 70f;
		val18.forceCost = 100u;
		val18.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
		GameObject val19 = UPool.MyPool.AddObject("UNIT_JINZHANSHANBI3MIAO", val.LoadAsset<GameObject>("进展闪避3秒"), true, (HideFlags)52, (Sprite)null, 14785733, true);
		GameObject val20 = UPool.MyPool.AddObject("UNIT_PAOSHEWUSHANBI3MIAO", val.LoadAsset<GameObject>("抛射物闪避3秒"), true, (HideFlags)52, (Sprite)null, 467665, true);
		val20.GetComponentInChildren<DodgeMove>().forceMultiplier = 0.3f;
		UnitBlueprint val21 = SLMATool.CreateUnit("UNIT_ZUJIAOSHI", val15, val4, 工具.直接设置图标(val, "诅咒教士"));
		val21.health = 200f;
		val21.forceCost = 250u;
		val21.RightWeapon = rightWeapon6;
		val21.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2] { val19, val20 };
		UnitBlueprint val22 = SLMATool.CreateUnit("UNIT_ZUYOULIEZHE", val15, val4, 工具.直接设置图标(val, "诅咒游猎者"));
		val22.forceCost = 250u;
		val22.health = 100f;
		val22.RightWeapon = val8;
		val22.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { val14 };
		val22.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
		多国语言部分hhh.语言添加("UNIT_ZUSHENGQISHI", "诅咒圣骑士#Cursed Paladin#呪われたパラディン#Verfluchter Paladin#Paladin Maudit#Проклятый паладин#Paladín Maldito#Paladino Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUDUNJIANSHOU", "诅咒盾剑手#Cursed Sword and Shield#呪われた盾剣士#Verfluchter Schwert-und-Schild-Kämpfer#Épée et Bouclier Maudit#Проклятый мечник со щитом#Espada y Escudo Maldito#Spada e Scudo Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUDUNPAIJIABISHOU", "诅咒盾牌加匕首#Cursed Shield and Dagger#呪われた盾と短剣#Verfluchter Schild und Dolch#Bouclier et Dague Maudits#Проклятые щит и кинжал#Escudo y Daga Malditos#Scudo e Pugnale Maledetti");
		多国语言部分hhh.语言添加("UNIT_ZUZHONGJIAQISHI", "诅咒重甲骑士#Cursed Heavy Armor Knight#呪われた重甲騎士#Verfluchter Schwerer Ritter#Chevalier en Armure Lourde Maudit#Проклятый рыцарь в тяжелых доспехах#Caballero de Armadura Pesada Maldito#Cavaliere con Armatura Pesante Maledetto");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGGONGDONGHUABAN", "诅咒长弓动画版#Cursed Longbow Animated#呪われた長弓アニメ版#Verfluchter Langbogen Animiert#Arc Long Maudit Animé#Проклятый длинный лук анимированный#Arco Largo Maldito Animado#Arco Lungo Maledetto Animato");
		UnitBlueprint val23 = SLMATool.CreateUnit("UNIT_ZUSHENGQISHI", val15, val4, 工具.直接设置图标(val, "诅咒圣骑士"));
		val23.RightWeapon = rightWeapon3;
		val23.health = 390f;
		val23.sizeMultiplier *= 1.1f;
		val23.forceCost = 500u;
		UnitBlueprint val24 = SLMATool.CreateUnit("UNIT_ZUDUNJIANSHOU", val15, val4, 工具.直接设置图标(val, "诅咒盾剑手"));
		val24.RightWeapon = rightWeapon2;
		val24.LeftWeapon = UPool.MyPool.AddObject("UNIT_ZUDUNPAIJIABISHOU", val.LoadAsset<GameObject>("诅咒盾牌and匕首"), true, (HideFlags)52, (Sprite)null, 10928840, true);
		val24.health = 885.555f;
		val24.sizeMultiplier *= 1.2f;
		val24.massMultiplier = 5f;
		val24.forceCost = 800u;
		UnitBlueprint val25 = SLMATool.CreateUnit("UNIT_ZUZHONGJIAQISHI", (UnitBlueprint)null, val4, 工具.直接设置图标(val, "诅咒重甲骑士"));
		val25.health = 812.244f;
		val25.sizeMultiplier = 1.4f;
		val25.RightWeapon = rightWeapon;
		val25.massMultiplier = 10f;
		val25.forceCost = 1500u;
		val25.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { val16 };
		val25.UnitBase = UPool.MyPool.AddObject("白色人物wee", val.LoadAsset<GameObject>("白色人物wee"), true, (HideFlags)52, (Sprite)null, 10928841, true);
		s.SetField<UnitBlueprint>(val25, "DeathRef", (object)"Fantasy Dark Death Vocals/DarkKingHuman");
		s.SetField<UnitBlueprint>(val25, "VocalRef", (object)"Fantasy Dark Death Vocals/DarkKingHuman");
		s.SetField<UnitBlueprint>(val25, "VoicePitch", (object)1.3f);
		val25.Validate();
		GameObject val26 = UPool.MyPool.AddObject("UNIT_ZUCHANGGONGDONGHUABAN", val.LoadAsset<GameObject>("动画343434"), true, (HideFlags)52, (Sprite)null, 10928847, true);
		((Weapon)val26.GetComponentInChildren<RangeWeapon>()).internalCooldown = 6f;
		多国语言部分hhh.语言添加("UNIT_JINJULIQIEHUANCHANGQIANG", "近距离切换长枪#Close Range Switch Spear#近距離で長槍に切り替え#Nahbereichsumschaltung Speer#Changement d'Arme Lance à Courte Portée#Смена на копье на ближней дистанции#Cambio a Lanza a Corta Distancia#Cambio a Lancia a Corta Distanza");
		多国语言部分hhh.语言添加("UNIT_ZUCHANGGONGSHOU", "诅咒长弓手#Cursed Longbowman#呪われた長弓兵#Verfluchter Langbogenschütze#Archer Long Maudit#Проклятый лучник с длинным луком#Arquero de Arco Largo Maldito#Arciere con Arco Lungo Maledetto");
		多国语言部分hhh.语言添加("UNIT_CHANGGONGJINZHANSHANBI", "长弓近战闪避#Longbow Melee Dodge#長弓近接回避#Langbogen Nahkampfausweichen#Esquive de Mêlée d'Arc Long#Уклонение в ближнем бою для длинного лука#Esquiva Cuerpo a Cuerpo de Arco Largo#Schivata in Mischia per Arco Lungo");
		多国语言部分hhh.语言添加("UNIT_CHANGGONGPAOSHEWUSHANBI", "长弓抛射物闪避#Longbow Projectile Dodge#長弓投射物回避#Langbogen Geschossausweichen#Esquive de Projectile d'Arc Long#Уклонение от снарядов для длинного лука#Esquiva de Proyectiles de Arco Largo#Schivata dei Proiettili per Arco Lungo");
		GameObject val27 = UPool.MyPool.AddObject("UNIT_JINJULIQIEHUANCHANGQIANG", val.LoadAsset<GameObject>("近距离切换长枪34"), true, (HideFlags)52, (Sprite)null, 10928848, true);
		val27.GetComponentInChildren<自由切换武器>().武器1号 = UPool.MyPool.AddObject("长弓手的长矛", val.LoadAsset<GameObject>("长弓手的长毛45"), true, (HideFlags)52, (Sprite)null, 10928849, true);
		val27.GetComponentInChildren<自由切换武器>().武器2号 = val26;
		UnitBlueprint val28 = SLMATool.CreateUnit("UNIT_ZUCHANGGONGSHOU", (UnitBlueprint)null, val4, 工具.直接设置图标(val, "诅咒长弓手"));
		val28.health = 400f;
		val28.forceCost = 1400u;
		val28.RightWeapon = val26;
		val28.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[3]
		{
			UPool.MyPool.AddObject("UNIT_CHANGGONGJINZHANSHANBI", val.LoadAsset<GameObject>("长弓闪避435"), true, (HideFlags)52, (Sprite)null, 10928842, true),
			UPool.MyPool.AddObject("UNIT_CHANGGONGPAOSHEWUSHANBI", val.LoadAsset<GameObject>("长弓抛射物闪避32"), true, (HideFlags)52, (Sprite)null, 10928843, true),
			val27
		};
		val28.Entity.SetUnlockKey("SECRET_ZUZHOUCHANGGONGSHOU");
		s.SetField<UnitBlueprint>(val28, "DeathRef", (object)"Medieval Attack Vocals/Priest");
		s.SetField<UnitBlueprint>(val28, "VocalRef", (object)"Medieval Attack Vocals/Priest");
		s.SetField<UnitBlueprint>(val28, "VoicePitch", (object)1.1f);
		val28.Validate();
		多国语言部分hhh.语言添加("UNIT_ZUCHANGJISHOU", "诅咒长戟手#Cursed Halberdier#呪われたハルバーディア#Verfluchter Hellebardier#Hallebardier Maudit#Проклятый алебардщик#Alabardero Maldito#Alabardiere Maledetto");
		多国语言部分hhh.语言添加("UNIT_CHANGJIBINGCHONGZHUANG", "长戟兵冲撞#Halberdier Charge#ハルバーディア突撃#Hellebardier-Ansturm#Charge du Hallebardier#Таран алебардщика#Carga de Alabardero#Carica dell'Alabardiere");
		多国语言部分hhh.语言添加("UNIT_WANGTINGQISHI", "王庭骑士#Court Knight#王庭の騎士#Hofritter#Chevalier de la Cour#Придворный рыцарь#Caballero de la Corte#Cavaliere di Corte");
		多国语言部分hhh.语言添加("UNIT_ZUWANGLINGMACHONGJI", "诅咒亡灵马冲击#Cursed Undead Horse Charge#呪われた亡霊馬の突撃#Verfluchter Untotenpferd-Ansturm#Charge de Cheval Mort-Vivant Maudite#Проклятый удар нежити верхом#Carga de Caballo No Muerto Maldito#Carica del Cavallo Non Morto Maledetta");
		多国语言部分hhh.语言添加("UNIT_TEZHIQIANGSSJJMZ", "特质骑枪双手剑模组#Custom Lance Two-Handed Sword Mod#特製ランス両手剣モッド#Speziallanze Zweihandschwert-Modul#Module Lance Sur Mesure Épée à Deux Mains#Мод особого копья с двуручным мечом#Mod Lanza Especial Espada de Dos Manos#Mod Lancia Speciale Spada a Due Mani");
		UnitBlueprint val29 = SLMATool.CreateUnit("UNIT_ZUCHANGJISHOU", (UnitBlueprint)null, val4, 工具.直接设置图标(val, "诅咒长戟手"));
		val29.health = 877.78f;
		val29.sizeMultiplier = 1.5f;
		val29.massMultiplier = 15f;
		val29.RightWeapon = rightWeapon4;
		val29.forceCost = 1800u;
		val29.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { UPool.MyPool.AddObject("UNIT_CHANGJIBINGCHONGZHUANG", val.LoadAsset<GameObject>("长戟兵冲撞243"), true, (HideFlags)52, (Sprite)null, 10928844, true) };
		val29.Entity.SetUnlockKey("SECRET_ZUZHOUCHANGJIBING");
		s.SetField<UnitBlueprint>(val29, "DeathRef", (object)"Reinassance Death Vocals/Halberd");
		s.SetField<UnitBlueprint>(val29, "VocalRef", (object)"Reinassance Attack Vocals/Halberd");
		s.SetField<UnitBlueprint>(val29, "VoicePitch", (object)0.8f);
		val29.Validate();
		UnitBlueprint val30 = SLMATool.CreateUnit("王庭骑士/亡灵马", (UnitBlueprint)SLMALoader.SDic["blueprints"]["UNIT_SUBUNITS_HORSE_CHARIOT"], (Faction)null, 工具.直接设置图标(val, "sdhsoeugfe"));
		val30.forceCost = 2500u;
		val30.UnitBase = UPool.MyPool.AddObject("亡灵吗24", val.LoadAsset<GameObject>("亡灵吗24"), true, (HideFlags)52, (Sprite)null, 10928845, true);
		val30.health *= 1.4f;
		val30.sizeMultiplier *= 1.4f;
		UnitBlueprint val31 = SLMATool.CreateUnit("王庭骑士.y", (UnitBlueprint)null, (Faction)null, (Sprite)null);
		val31.health = 1116.326f;
		val31.sizeMultiplier = 1.4f;
		val31.massMultiplier = 20f;
		val31.LeftWeapon = leftWeapon;
		val31.holdinigWithTwoHands = false;
		val31.forceCost = 2500u;
		GameObject val32 = UPool.MyPool.AddObject("亡灵马冲击", val.LoadAsset<GameObject>("骑兵冲击423"), true, (HideFlags)52, (Sprite)null, 10928846, true);
		val31.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { val32 };
		s.SetField<UnitBlueprint>(val31, "DeathRef", (object)"Fantasy Dark Death Vocals/DarkKingHuman");
		s.SetField<UnitBlueprint>(val31, "VocalRef", (object)"Fantasy Dark Death Vocals/DarkKingHuman");
		s.SetField<UnitBlueprint>(val31, "VoicePitch", (object)1f);
		val31.Validate();
		s.SetField<UnitBlueprint>(val30, "Riders", (object)new UnitBlueprint[1] { val31 });
		GameObject val33 = UPool.MyPool.AddObject("UNIT_ZUWANGLINGMACHONGJI", val.LoadAsset<GameObject>("骑兵冲击423"), true, (HideFlags)52, (Sprite)null, 435732044, true);
		val33.GetComponentInChildren<DodgeMove>().forceMultiplier = 1f;
		UnitBlueprint val34 = SLMATool.CreateUnit("UNIT_WANGTINGQISHI", val31, val4, 工具.直接设置图标(val, "sdhsoeugfe"));
		val34.LeftWeapon = null;
		GameObject val35 = UPool.MyPool.AddObject("UNIT_TEZHIQIANGSSJJMZ", val.LoadAsset<GameObject>("特质骑墙345"), true, (HideFlags)52, (Sprite)null, 4353456, true);
		val35.GetComponentInChildren<DodgeMove>().forceMultiplier = 0.1f;
		((Weapon)val35.GetComponentInChildren<MeleeWeapon>()).maxRange = 3f;
		val34.RightWeapon = val35;
		val34.holdinigWithTwoHands = true;
		val34.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[4]
		{
			val33,
			val19,
			val20,
			(GameObject)SLMALoader.SDic["moves"]["SpinToWin_Red Jade"]
		};
		val34.Entity.SetUnlockKey("SECRET_WANGTINGQISHI");
		val17.m_props = 工具.获取游戏物品服饰(val, new string[12]
		{
			"诅咒长枪兵头盔", "诅咒长枪兵手套", "诅咒长枪兵护腕", "诅咒长枪兵披风", "诅咒长枪兵胸甲", "诅咒长枪兵腰带", "诅咒长枪兵衬衫", "诅咒长枪兵袍子", "诅咒长枪兵裤子", "诅咒长枪兵软甲",
			"诅咒长枪兵软甲裙", "诅咒长枪兵鞋子"
		});
		val18.m_props = 工具.获取游戏物品服饰(val, new string[2] { "诅咒弩手Cloak罩袍", "诅咒弩手护腕" }).Concat((IEnumerable<GameObject>)(object)new GameObject[8]
		{
			UPool.MyPool.GetObject("诅咒长枪兵头盔"),
			UPool.MyPool.GetObject("诅咒长枪兵披风"),
			UPool.MyPool.GetObject("诅咒长枪兵腰带"),
			UPool.MyPool.GetObject("诅咒长枪兵软甲"),
			UPool.MyPool.GetObject("诅咒长枪兵软甲裙"),
			UPool.MyPool.GetObject("诅咒长枪兵鞋子"),
			UPool.MyPool.GetObject("诅咒长枪兵裤子"),
			UPool.MyPool.GetObject("诅咒长枪兵衬衫")
		}).ToArray();
		val22.m_props = 工具.获取游戏物品服饰(val, new string[8] { "诅咒游猎者上衣", "诅咒游猎者护腕", "诅咒游猎者披肩", "诅咒游猎者束腰", "诅咒游猎者绿色披肩", "诅咒游猎者背带", "诅咒游猎者裤子", "诅咒游猎者鞋子" });
		val21.m_props = 工具.获取游戏物品服饰(val, new string[4] { "诅咒教士上衣", "诅咒教士披肩", "诅咒教士罩袍", "诅咒教士腰带" }).Concat((IEnumerable<GameObject>)(object)new GameObject[3]
		{
			UPool.MyPool.GetObject("诅咒游猎者护腕"),
			UPool.MyPool.GetObject("诅咒游猎者裤子"),
			UPool.MyPool.GetObject("诅咒游猎者鞋子")
		}).ToArray();
		val23.m_props = 工具.获取游戏物品服饰(val, new string[12]
		{
			"诅咒圣骑士头盔", "诅咒圣骑士披肩", "诅咒圣骑士皮质小腿护甲", "诅咒圣骑士皮质小臂护甲", "诅咒圣骑士皮质护膝甲", "诅咒圣骑士皮质胸甲", "诅咒圣骑士皮质鞋甲", "诅咒圣骑士罩袍", "诅咒圣骑士腰带", "诅咒圣骑士衬衫",
			"诅咒圣骑士领子", "诅咒圣骑士黑色罩袍"
		}).Concat((IEnumerable<GameObject>)(object)new GameObject[1] { UPool.MyPool.GetObject("诅咒长枪兵裤子") }).ToArray();
		val24.m_props = 工具.获取游戏物品服饰(val, new string[14]
		{
			"诅咒盾剑手右肩甲", "诅咒盾剑手头盔", "诅咒盾剑手左肩甲", "诅咒盾剑手护手", "诅咒盾剑手护肘1", "诅咒盾剑手护肘2", "诅咒盾剑手护腕", "诅咒盾剑手护膝", "诅咒盾剑手护颈", "诅咒盾剑手盔甲鞋",
			"诅咒盾剑手罩袍", "诅咒盾剑手胸甲", "诅咒盾剑手腿甲", "诅咒盾剑手裤子"
		}).Concat((IEnumerable<GameObject>)(object)new GameObject[5]
		{
			UPool.MyPool.GetObject("诅咒长枪兵软甲"),
			UPool.MyPool.GetObject("诅咒长枪兵软甲裙"),
			UPool.MyPool.GetObject("诅咒长枪兵衬衫"),
			UPool.MyPool.GetObject("诅咒长枪兵腰带"),
			UPool.MyPool.GetObject("诅咒长枪兵披风")
		}).ToArray();
		val25.m_props = 工具.获取游戏物品服饰(val, new string[9] { "重甲骑士上臂护甲", "重甲骑士头盔", "重甲骑士护手", "重甲骑士护腕", "重甲骑士肩甲右", "重甲骑士肩甲左", "重甲骑士胸甲", "重甲骑士软甲头盔", "重甲骑士衬衫" }).Concat((IEnumerable<GameObject>)(object)new GameObject[7]
		{
			UPool.MyPool.GetObject("诅咒盾剑手罩袍"),
			UPool.MyPool.GetObject("诅咒长枪兵软甲裙"),
			UPool.MyPool.GetObject("诅咒盾剑手裤子"),
			UPool.MyPool.GetObject("诅咒盾剑手护膝"),
			UPool.MyPool.GetObject("诅咒盾剑手腿甲"),
			UPool.MyPool.GetObject("诅咒盾剑手盔甲鞋"),
			UPool.MyPool.GetObject("诅咒长枪兵腰带")
		}).ToArray();
		val28.m_props = 工具.获取游戏物品服饰(val, new string[13]
		{
			"诅咒长弓手下摆", "诅咒长弓手小臂铠甲", "诅咒长弓手帽子", "诅咒长弓手手套", "诅咒长弓手披肩", "诅咒长弓手披肩2", "诅咒长弓手披风", "诅咒长弓手罩袍", "诅咒长弓手胸甲", "诅咒长弓手衬衫",
			"诅咒长弓手裤子", "诅咒长弓手贵族袖套", "诅咒长弓手鞋子"
		});
		val29.m_props = 工具.获取游戏物品服饰(val, new string[16]
		{
			"诅咒长戟手上臂护甲", "诅咒长戟手书包", "诅咒长戟手封闭蛙嘴盔", "诅咒长戟手护肘", "诅咒长戟手护颈", "诅咒长戟手披肩", "诅咒长戟手斗篷", "诅咒长戟手绳子", "诅咒长戟手罩袍", "诅咒长戟手肩甲右",
			"诅咒长戟手肩甲左", "诅咒长戟手胸甲", "诅咒长戟手腰带", "诅咒长戟手衬衫", "诅咒长戟手裤子", "诅咒长戟手软甲裙"
		}).Concat((IEnumerable<GameObject>)(object)new GameObject[4]
		{
			UPool.MyPool.GetObject("诅咒盾剑手盔甲鞋"),
			UPool.MyPool.GetObject("诅咒盾剑手护膝"),
			UPool.MyPool.GetObject("诅咒盾剑手腿甲"),
			UPool.MyPool.GetObject("重甲骑士护手")
		}).ToArray();
		GameObject[] props = (val31.m_props = 工具.获取游戏物品服饰(val, new string[22]
		{
			"王庭骑士上臂铠甲", "王庭骑士下摆1", "王庭骑士下摆2", "王庭骑士下臂铠甲", "王庭骑士侧裙甲", "王庭骑士大腿板甲", "王庭骑士头盔", "王庭骑士小腿板甲", "王庭骑士护颈", "王庭骑士披风",
			"王庭骑士板甲鞋", "王庭骑士盔甲手套", "王庭骑士盔甲手套2", "王庭骑士肘部护甲", "王庭骑士肩甲右", "王庭骑士肩甲左", "王庭骑士胸甲", "王庭骑士膝盖护甲", "王庭骑士衬衫", "王庭骑士裤子",
			"王庭骑士软甲", "王庭骑士软甲帽"
		}));
		val34.m_props = props;
	}
}
public class 自由切换武器 : MonoBehaviour
{
	public Unit 当前单位;

	public DataHandler 当前单位数据;

	public GameObject 武器1号;

	public GameObject 武器2号;

	private GameObject 当前右手武器;

	private GameObject 当前左手武器;

	public Transform 右手挂载点;

	public Transform 左手挂载点;

	private void Start()
	{
		Transform root = ((Component)this).transform.root;
		当前单位 = ((Component)this).GetComponentInParent<Unit>();
		当前单位数据 = 当前单位.data;
		if ((Object)(object)右手挂载点 == (Object)null)
		{
			HandRight componentInChildren = ((Component)root).GetComponentInChildren<HandRight>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				右手挂载点 = ((Component)componentInChildren).transform;
			}
		}
		if ((Object)(object)左手挂载点 == (Object)null)
		{
			HandLeft componentInChildren2 = ((Component)root).GetComponentInChildren<HandLeft>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				左手挂载点 = ((Component)componentInChildren2).transform;
			}
		}
		WeaponHandler componentInChildren3 = ((Component)当前单位).GetComponentInChildren<WeaponHandler>();
		if ((Object)(object)componentInChildren3 != (Object)null)
		{
			if ((Object)(object)componentInChildren3.rightWeapon != (Object)null)
			{
				当前右手武器 = ((Component)componentInChildren3.rightWeapon).gameObject;
			}
			if ((Object)(object)componentInChildren3.leftWeapon != (Object)null)
			{
				当前左手武器 = ((Component)componentInChildren3.leftWeapon).gameObject;
			}
		}
	}

	public void 切换右手武器(GameObject 新武器)
	{
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)右手挂载点 == (Object)null)
		{
			return;
		}
		Debug.Log((object)"开始切换右手武器");
		if ((Object)(object)当前右手武器 != (Object)null)
		{
			UnitBowAnimation componentInChildren = 当前右手武器.GetComponentInChildren<UnitBowAnimation>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				HealthHandler componentInChildren2 = ((Component)当前单位).GetComponentInChildren<HealthHandler>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.RemoveDieAction((Action)componentInChildren.ResetPos);
					Debug.Log((object)"已移除旧武器的死亡委托");
				}
			}
			else
			{
				Transform transform = ((Component)当前单位.data.rightHand).transform;
				if ((Object)(object)transform == (Object)null)
				{
					return;
				}
				UnitBowAnimation componentInChildren3 = ((Component)transform).GetComponentInChildren<UnitBowAnimation>();
				if ((Object)(object)componentInChildren3 != (Object)null)
				{
					HealthHandler componentInChildren4 = ((Component)当前单位).GetComponentInChildren<HealthHandler>();
					if ((Object)(object)componentInChildren4 != (Object)null)
					{
						componentInChildren4.RemoveDieAction((Action)componentInChildren.ResetPos);
						Debug.Log((object)"已移除旧武器的死亡委托");
					}
					((Component)componentInChildren3).transform.SetParent(当前右手武器.transform);
				}
			}
			Object.Destroy((Object)(object)当前右手武器);
		}
		if ((Object)(object)新武器 != (Object)null)
		{
			Torso componentInChildren5 = ((Component)当前单位).GetComponentInChildren<Torso>();
			当前右手武器 = Object.Instantiate<GameObject>(新武器, ((Component)componentInChildren5).transform.position + ((Component)componentInChildren5).transform.forward * 0.5f, 右手挂载点.rotation, ((Component)当前单位).transform);
			Holdable component = 当前右手武器.GetComponent<Holdable>();
			WeaponItem component2 = 当前右手武器.GetComponent<WeaponItem>();
			WeaponHandler componentInChildren6 = ((Component)当前单位).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren6 != (Object)null)
			{
				Weapon component3 = 当前右手武器.GetComponent<Weapon>();
				当前单位.holdingHandler.rightHandActivity = (HandActivity)1;
				当前单位.holdingHandler.leftHandActivity = (HandActivity)1;
				当前单位.holdingHandler.rightObject = component;
				componentInChildren6.SetWeapon(component3, (HandType)0);
				component2.Initialize(当前单位.Team);
			}
		}
	}

	public void 切换左手武器(GameObject 新武器)
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)左手挂载点 == (Object)null)
		{
			return;
		}
		if ((Object)(object)当前左手武器 != (Object)null)
		{
			Object.Destroy((Object)(object)当前左手武器);
		}
		if ((Object)(object)新武器 != (Object)null)
		{
			当前左手武器 = Object.Instantiate<GameObject>(新武器, 左手挂载点.position, 左手挂载点.rotation, 左手挂载点);
			WeaponHandler componentInChildren = ((Component)当前单位).GetComponentInChildren<WeaponHandler>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Weapon component = 当前左手武器.GetComponent<Weapon>();
				componentInChildren.SetWeapon(component, (HandType)1);
			}
		}
	}

	public void 切换武器1号()
	{
		切换右手武器(武器1号);
	}

	public void 切换武器2号()
	{
		切换右手武器(武器2号);
	}
}
public class 单位靠近事件 : MonoBehaviour
{
	public DataHandler 当前单位数据;

	public float 进入距离 = 10f;

	public float 离开距离 = 12f;

	public UnityEvent 距离事件靠近;

	public UnityEvent 距离事件离开;

	private GameStateManager man;

	private bool 单位目标已靠近 = false;

	private float 检查间隔 = 0.2f;

	private float 下次检查时间 = 0f;

	private void Start()
	{
		if ((Object)(object)当前单位数据 == (Object)null)
		{
			当前单位数据 = ((Component)((Component)this).transform.root).GetComponentInChildren<DataHandler>();
			if ((Object)(object)当前单位数据 == (Object)null)
			{
				Transform parent = ((Component)this).transform.parent;
				Debug.LogError((object)("未找到DataHandler组件在 " + ((parent != null) ? ((Object)parent).name : null)), (Object)(object)this);
				((Behaviour)this).enabled = false;
				return;
			}
		}
		man = ServiceLocator.GetService<GameStateManager>();
		if (man == null)
		{
			Debug.LogError((object)"未找到GameStateManager服务", (Object)(object)this);
			((Behaviour)this).enabled = false;
		}
	}

	private void Update()
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Invalid comparison between Unknown and I4
		GameStateManager obj = man;
		if (obj == null || (int)obj.GameState != 1 || Time.time < 下次检查时间)
		{
			return;
		}
		下次检查时间 = Time.time + 检查间隔;
		DataHandler obj2 = 当前单位数据;
		if (obj2 == null)
		{
			return;
		}
		_ = obj2.distanceToTarget;
		if (0 == 0 && !当前单位数据.Dead)
		{
			float distanceToTarget = 当前单位数据.distanceToTarget;
			if (!单位目标已靠近 && distanceToTarget <= 进入距离)
			{
				Debug.Log((object)$"单位靠近触发，距离：{当前单位数据.distanceToTarget}");
				进入触发();
			}
			else if (单位目标已靠近 && distanceToTarget >= 离开距离)
			{
				离开触发();
			}
		}
	}

	private void 进入触发()
	{
		UnityEvent obj = 距离事件靠近;
		if (obj != null)
		{
			obj.Invoke();
		}
		单位目标已靠近 = true;
		Debug.Log((object)$"单位靠近触发，距离：{当前单位数据.distanceToTarget}");
	}

	private void 离开触发()
	{
		UnityEvent obj = 距离事件离开;
		if (obj != null)
		{
			obj.Invoke();
		}
		单位目标已靠近 = false;
		Debug.Log((object)$"单位离开触发，距离：{当前单位数据.distanceToTarget}");
	}

	private void OnDrawGizmosSelected()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: 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_005b: Unknown result type (might be due to invalid IL or missing references)
		DataHandler obj = 当前单位数据;
		if ((Object)(object)((obj != null) ? ((Component)obj).transform : null) != (Object)null)
		{
			Gizmos.color = Color.yellow;
			Gizmos.DrawWireSphere(((Component)当前单位数据).transform.position, 进入距离);
			Gizmos.color = Color.red;
			Gizmos.DrawWireSphere(((Component)当前单位数据).transform.position, 离开距离);
		}
	}
}
public class 动画播放器 : MonoBehaviour
{
	[Header("动画组件设置")]
	[Tooltip("如果为空，会自动查找组件")]
	public Animator 动画控制器;

	[Tooltip("如果使用Animation组件，请在此赋值")]
	public Animation 旧版动画;

	[Header("默认动画设置")]
	[Tooltip("默认进入时播放的动画名")]
	public string 默认动画名;

	[Tooltip("是否在开始时播放默认动画")]
	public bool 启动时播放默认动画 = true;

	private void Start()
	{
		if ((Object)(object)动画控制器 == (Object)null)
		{
			动画控制器 = ((Component)this).GetComponent<Animator>();
		}
		if ((Object)(object)旧版动画 == (Object)null)
		{
			旧版动画 = ((Component)this).GetComponent<Animation>();
		}
		if (启动时播放默认动画 && !string.IsNullOrEmpty(默认动画名))
		{
			播放(默认动画名);
		}
	}

	public void 播放(string 动画名称)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.Play(动画名称, 0, 0f);
			Debug.Log((object)("播放动画 (Animator): " + 动画名称));
		}
		else if ((Object)(object)旧版动画 != (Object)null)
		{
			旧版动画.Stop(动画名称);
			旧版动画.Play(动画名称);
			Debug.Log((object)("播放动画 (Animation): " + 动画名称));
		}
		else
		{
			Debug.LogWarning((object)("未找到任何动画组件，无法播放动画: " + 动画名称));
		}
	}

	public void 立即播放(string 动画名称, int 过渡层 = 0, float 开始时间归一化 = 0f)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.Play(动画名称, 过渡层, 开始时间归一化);
			Debug.Log((object)("立即播放动画 (Animator): " + 动画名称));
		}
		else if ((Object)(object)旧版动画 != (Object)null)
		{
			旧版动画.Play(动画名称, (PlayMode)4);
			Debug.Log((object)("立即播放动画 (Animation): " + 动画名称));
		}
		else
		{
			Debug.LogWarning((object)("未找到任何动画组件，无法立即播放: " + 动画名称));
		}
	}

	public void 淡入播放(string 动画名称, float 过渡时间 = 0.3f)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.CrossFade(动画名称, 过渡时间);
			Debug.Log((object)("淡入播放动画 (Animator): " + 动画名称));
		}
		else if ((Object)(object)旧版动画 != (Object)null)
		{
			旧版动画.CrossFade(动画名称, 过渡时间);
			Debug.Log((object)("淡入播放动画 (Animation): " + 动画名称));
		}
		else
		{
			Debug.LogWarning((object)("未找到任何动画组件，无法淡入播放: " + 动画名称));
		}
	}

	public void 暂停()
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.speed = 0f;
			Debug.Log((object)"动画已暂停 (Animator)");
		}
		else
		{
			if (!((Object)(object)旧版动画 != (Object)null))
			{
				return;
			}
			foreach (AnimationState item in 旧版动画)
			{
				AnimationState val = item;
				val.speed = 0f;
			}
			Debug.Log((object)"动画已暂停 (Animation)");
		}
	}

	public void 继续()
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Expected O, but got Unknown
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.speed = 1f;
			Debug.Log((object)"动画已继续 (Animator)");
		}
		else
		{
			if (!((Object)(object)旧版动画 != (Object)null))
			{
				return;
			}
			foreach (AnimationState item in 旧版动画)
			{
				AnimationState val = item;
				val.speed = 1f;
			}
			Debug.Log((object)"动画已继续 (Animation)");
		}
	}

	public void 停止()
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.StopPlayback();
			Debug.Log((object)"动画已停止 (Animator)");
		}
		else if ((Object)(object)旧版动画 != (Object)null)
		{
			旧版动画.Stop();
			Debug.Log((object)"动画已停止 (Animation)");
		}
	}

	public void 设置速度(float 速度倍率)
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Expected O, but got Unknown
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.speed = 速度倍率;
			Debug.Log((object)$"设置动画速度: {速度倍率}x (Animator)");
		}
		else
		{
			if (!((Object)(object)旧版动画 != (Object)null))
			{
				return;
			}
			foreach (AnimationState item in 旧版动画)
			{
				AnimationState val = item;
				val.speed = 速度倍率;
			}
			Debug.Log((object)$"设置动画速度: {速度倍率}x (Animation)");
		}
	}

	public void 设置布尔(string 参数名, bool 值)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.SetBool(参数名, 值);
			Debug.Log((object)$"设置布尔参数: {参数名} = {值}");
		}
		else
		{
			Debug.LogWarning((object)"Animator组件不存在，无法设置布尔参数");
		}
	}

	public void 触发(string 参数名)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.SetTrigger(参数名);
			Debug.Log((object)("触发参数: " + 参数名));
		}
		else
		{
			Debug.LogWarning((object)"Animator组件不存在，无法触发");
		}
	}

	public void 设置整数(string 参数名, int 值)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.SetInteger(参数名, 值);
			Debug.Log((object)$"设置整数参数: {参数名} = {值}");
		}
		else
		{
			Debug.LogWarning((object)"Animator组件不存在，无法设置整数参数");
		}
	}

	public void 设置浮点(string 参数名, float 值)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.SetFloat(参数名, 值);
			Debug.Log((object)$"设置浮点参数: {参数名} = {值}");
		}
		else
		{
			Debug.LogWarning((object)"Animator组件不存在，无法设置浮点参数");
		}
	}

	public void 重置触发器(string 参数名)
	{
		if ((Object)(object)动画控制器 != (Object)null)
		{
			动画控制器.ResetTrigger(参数名);
			Debug.Log((object)("重置触发器: " + 参数名));
		}
		else
		{
			Debug.LogWarning((object)"Animator组件不存在，无法重置触发器");
		}
	}

	public bool 是否在播放(string 动画名称)
	{
		//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)
		if ((Object)(object)动画控制器 != (Object)null)
		{
			AnimatorStateInfo currentAnimatorStateInfo = 动画控制器.GetCurrentAnimatorStateInfo(0);
			return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName(动画名称);
		}
		if ((Object)(object)旧版动画 != (Object)null)
		{
			return 旧版动画.IsPlaying(动画名称);
		}
		return false;
	}
}
public class ecs设置攻击距离手动设置 : MonoBehaviour
{
	private GameObjectEntity m_goEntity;

	private EntityManager entityManager;

	private Entity entity;

	private void Start()
	{
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: 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_006b: Unknown result type (might be due to invalid IL or missing references)
		m_goEntity = ((Component)((Component)this).transform.root).GetComponent<GameObjectEntity>();
		if ((Object)(object)m_goEntity == (Object)null)
		{
			Debug.LogError((object)"未找到GameObjectEntity组件！", (Object)(object)((Component)this).gameObject);
			return;
		}
		entityManager = m_goEntity.EntityManager;
		entity = m_goEntity.Entity;
		if (entityManager == null || entity == Entity.Null)
		{
			Debug.LogError((object)"EntityManager或Entity无效！", (Object)(object)((Component)this).gameObject);
		}
	}

	public void 设置攻击距离(float attackRange = 15f)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		if (!IsValid())
		{
			Debug.LogWarning((object)"ECS组件未就绪，无法设置攻击距离！");
			return;
		}
		try
		{
			Range componentData = entityManager.GetComponentData<Range>(entity);
			componentData.AttackRange = attackRange;
			entityManager.SetComponentData<Range>(entity, componentData);
			Debug.Log((object)$"成功设置攻击距离为: {attackRange}");
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("设置攻击距离失败: " + ex.Message));
		}
	}

	public void 设置完整距离(float attackRange, float preferredRange)
	{
		//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_003b: 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)
		if (!IsValid())
		{
			return;
		}
		try
		{
			Range componentData = entityManager.GetComponentData<Range>(entity);
			componentData.AttackRange = attackRange;
			componentData.PreferredRange = preferredRange;
			entityManager.SetComponentData<Range>(entity, componentData);
			Debug.Log((object)$"成功设置攻击距离: {attackRange}, 偏好距离: {preferredRange}");
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("设置完整距离失败: " + ex.Message));
		}
	}

	public float 获取攻击距离()
	{
		//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_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		if (!IsValid())
		{
			return 0f;
		}
		try
		{
			Range componentData = entityManager.GetComponentData<Range>(entity);
			return componentData.AttackRange;
		}
		catch
		{
			return 0f;
		}
	}

	public float 获取偏好距离()
	{
		//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_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		if (!IsValid())
		{
			return 0f;
		}
		try
		{
			Range componentData = entityManager.GetComponentData<Range>(entity);
			return componentData.PreferredRange;
		}
		catch
		{
			return 0f;
		}
	}

	private bool IsValid()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: 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_004d: 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)
		if ((Object)(object)m_goEntity == (Object)null || entityManager == null || entity == Entity.Null)
		{
			Start();
			return (Object)(object)m_goEntity != (Object)null && entityManager != null && entity != Entity.Null;
		}
		return entityManager.HasComponent<Range>(entity);
	}
}
[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))]
public class 刀光拖尾渲染器 : MonoBehaviour
{
	private struct 历史顶点
	{
		public Vector3 头部位置;

		public Vector3 尾部位置;

		public float 创建时间;

		public 历史顶点(Vector3 head, Vector3 tail, float time)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			头部位置 = head;
			尾部位置 = tail;
			创建时间 = time;
		}
	}

	[Header("位置引用")]
	public Transform 头部;

	public Transform 尾部;

	[Header("材质设置")]
	public Material 拖尾材质;

	[Header("时间参数")]
	public float 每次网格生成间隔时间 = 0.05f;

	public float 每段网格存在时间 = 0.5f;

	[Header("宽度控制")]
	public bool 启用宽度控制 = true;

	public AnimationCurve 宽度曲线 = AnimationCurve.Linear(0f, 1f, 1f, 0f);

	public float 基础宽度 = 0.2f;

	private List<历史顶点> 历史顶点列表 = new List<历史顶点>();

	private Mesh 刀光拖尾网格;

	private MeshFilter 网格过滤器;

	private float 上次生成时间 = 0f;

	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<MeshFilter>();
		if ((Object)(object)网格过滤器 == (Object)null)
		{
			网格过滤器 = ((Component)this).gameObject.AddComponent<MeshFilter>();
		}
		MeshRenderer val = ((Component)this).GetComponent<MeshRenderer>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)this).gameObject.AddComponent<MeshRenderer>();
		}
		刀光拖尾网格 = new Mesh();
		((Object)刀光拖尾网格).name = "刀光拖尾网格";
		网格过滤器.mesh = 刀光拖尾网格;
		((Renderer)val).material = 拖尾材质;
		if (宽度曲线.keys.Length == 0)
		{
			宽度曲线 = AnimationCurve.Linear(0f, 1f, 1f, 0f);
		}
		上次生成时间 = Time.time;
	}

	private void Update()
	{
		if (Time.time - 上次生成时间 >= 每次网格生成间隔时间)
		{
			添加新顶点对();
			上次生成时间 = Time.time;
		}
		移除过期顶点对();
		if (历史顶点列表.Count >= 2)
		{
			更新网格();
		}
		else
		{
			刀光拖尾网格.Clear();
		}
	}

	private void 添加新顶点对()
	{
		//IL_0030: 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)
		if (!((Object)(object)头部 == (Object)null) && !((Object)(object)尾部 == (Object)null))
		{
			历史顶点列表.Add(new 历史顶点(头部.position, 尾部.position, Time.time));
		}
	}

	private void 移除过期顶点对()
	{
		for (int num = 历史顶点列表.Count - 1; num >= 0; num--)
		{
			if (Time.time - 历史顶点列表[num].创建时间 > 每段网格存在时间)
			{
				历史顶点列表.RemoveAt(num);
			}
		}
	}

	private void 更新网格()
	{
		//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_008b: 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_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_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: 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_00c7: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: 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_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: 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_010f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		int count = 历史顶点列表.Count;
		Vector3[] array = (Vector3[])(object)new Vector3[count * 2];
		Vector2[] array2 = (Vector2[])(object)new Vector2[count * 2];
		int[] array3 = new int[(count - 1) * 6];
		float time = Time.time;
		Matrix4x4 worldToLocalMatrix = ((Component)this).transform.worldToLocalMatrix;
		for (int i = 0; i < count; i++)
		{
			历史顶点 历史顶点 = 历史顶点列表[i];
			float num = (time - 历史顶点.创建时间) / 每段网格存在时间;
			float num2 = (启用宽度控制 ? 宽度曲线.Evaluate(num) : 1f);
			Vector3 val = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyPoint3x4(历史顶点.头部位置);
			Vector3 val2 = ((Matrix4x4)(ref worldToLocalMatrix)).MultiplyPoint3x4(历史顶点.尾部位置);
			if (启用宽度控制 && num2 != 1f)
			{
				Vector3 val3 = val2 - val;
				Vector3 normalized = ((Vector3)(ref val3)).normalized;
				Vector3 val4 = (val + val2) * 0.5f;
				val = val4 - normalized * (基础宽度 * num2 * 0.5f);
				val2 = val4 + normalized * (基础宽度 * num2 * 0.5f);
			}
			array[i * 2] = val;
			array[i * 2 + 1] = val2;
			float num3 = (float)i / (float)(count - 1);
			array2[i * 2] = new Vector2(num3, 0f);
			array2[i * 2 + 1] = new Vector2(num3, 1f);
		}
		for (int j = 0; j < count - 1; j++)
		{
			int num4 = j * 6;
			array3[num4] = j * 2;
			array3[num4 + 1] = (j + 1) * 2;
			array3[num4 + 2] = j * 2 + 1;
			array3[num4 + 3] = (j + 1) * 2;
			array3[num4 + 4] = (j + 1) * 2 + 1;
			array3[num4 + 5] = j * 2 + 1;
		}
		刀光拖尾网格.Clear();
		刀光拖尾网格.vertices = array;
		刀光拖尾网格.triangles = array3;
		刀光拖尾网格.uv = array2;
		刀光拖尾网格.RecalculateNormals();
		刀光拖尾网格.RecalculateBounds();
	}

	private void OnDrawGizmosSelected()
	{
		//IL_0013: 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_004e: 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_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0156: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		if (历史顶点列表 == null)
		{
			return;
		}
		Gizmos.color = Color.yellow;
		for (int i = 0; i < 历史顶点列表.Count; i++)
		{
			Gizmos.DrawSphere(历史顶点列表[i].头部位置, 0.03f);
			Gizmos.DrawSphere(历史顶点列表[i].尾部位置, 0.03f);
			if (i > 0)
			{
				Gizmos.color = new Color(1f, 1f, 0f, 0.3f);
				Gizmos.DrawLine(历史顶点列表[i].头部位置, 历史顶点列表[i - 1].头部位置);
				Gizmos.DrawLine(历史顶点列表[i].尾部位置, 历史顶点列表[i - 1].尾部位置);
			}
		}
		if ((Object)(object)刀光拖尾网格 != (Object)null && 刀光拖尾网格.vertexCount > 0)
		{
			Gizmos.color = Color.red;
			Matrix4x4 localToWorldMatrix = ((Component)this).transform.localToWorldMatrix;
			Vector3[] vertices = 刀光拖尾网格.vertices;
			for (int j = 0; j < vertices.Length; j++)
			{
				Vector3 val = ((Matrix4x4)(ref localToWorldMatrix)).MultiplyPoint3x4(vertices[j]);
				Gizmos.DrawSphere(val, 0.02f);
			}
		}
	}
}
public class 刚体姿势管理器 : MonoBehaviour
{
	[Header("物理刚体部位")]
	private Transform myHead;

	private Transform myTorso;

	private Transform myHip;

	private Transform myRightArm;

	private Transform myRightHand;

	private Transform myLeftArm;

	private Transform myLeftHand;

	private Transform myRightLeg;

	private Transform myRightKnee;

	private Transform myLeftLeg;

	private Transform myLeftKnee;

	[Header("动画模型目标")]
	public Transform 动画模型头部;

	public Transform 动画模型躯干;

	public Transform 动画模型hip;

	public Transform 动画模型右肩膀;

	public Transform 动画模型右手臂;

	public Transform 动画模型左肩膀;

	public Transform 动画模型左手臂;

	public Transform 动画模型右大腿;

	public Transform 动画模型右小腿;

	public Transform 动画模型左大腿;

	public Transform 动画模型左小腿;

	[Header("设置")]
	public DataHandler 单位数据;

	public bool 启用动画驱动 = true;

	public bool 保持动力学模式 = true;

	private List<Rigidbody> 所有刚体 = new List<Rigidbody>();

	private Dictionary<Transform, Rigidbody> 部位刚体映射 = new Dictionary<Transform, Rigidbody>();

	private Dictionary<Rigidbody, bool> 原始动力学状态 = new Dictionary<Rigidbody, bool>();

	private Dictionary<Transform, Quaternion> 初始局部旋转 = new Dictionary<Transform, Quaternion>();

	private Dictionary<Transform, Quaternion> 动画目标初始旋转 = new Dictionary<Transform, Quaternion>();

	private void Start()
	{
		初始化物理部位();
		记录初始旋转();
		初始化刚体设置();
	}

	private void 初始化物理部位()
	{
		单位数据 = ((Component)((Component)this).transform.root).GetComponentInChildren<DataHandler>();
		myHead = 单位数据.head;
		myTorso = 单位数据.torso;
		myHip = ((Component)单位数据.hip).transform;
		myLeftArm = 单位数据.leftArm;
		myLeftHand = 单位数据.leftHand;
		myRightArm = 单位数据.rightArm;
		myRightHand = 单位数据.rightHand;
		myLeftLeg = 单位数据.legLeft;
		myLeftKnee = 单位数据.footLeft;
		myRightLeg = 单位数据.legRight;
		myRightKnee = 单位数据.footRight;
		收集刚体(myHead);
		收集刚体(myTorso);
		收集刚体(myHip);
		收集刚体(myRightArm);
		收集刚体(myRightHand);
		收集刚体(myLeftArm);
		收集刚体(myLeftHand);
		收集刚体(myRightLeg);
		收集刚体(myRightKnee);
		收集刚体(myLeftLeg);
		收集刚体(myLeftKnee);
	}

	private void 收集刚体(Transform 部位)
	{
		if (!((Object)(object)部位 == (Object)null))
		{
			Rigidbody component = ((Component)部位).GetComponent<Rigidbody>();
			if ((Object)(object)component != (Object)null)
			{
				所有刚体.Add(component);
				部位刚体映射[部位] = component;
				原始动力学状态[component] = component.isKinematic;
			}
		}
	}

	private void 记录初始旋转()
	{
		记录部位初始旋转(myHead);
		记录部位初始旋转(myTorso);
		记录部位初始旋转(myHip);
		记录部位初始旋转(myRightArm);
		记录部位初始旋转(myRightHand);
		记录部位初始旋转(myLeftArm);
		记录部位初始旋转(myLeftHand);
		记录部位初始旋转(myRightLeg);
		记录部位初始旋转(myRightKnee);
		记录部位初始旋转(myLeftLeg);
		记录部位初始旋转(myLeftKnee);
		记录动画目标初始旋转(动画模型头部);
		记录动画目标初始旋转(动画模型躯干);
		记录动画目标初始旋转(动画模型hip);
		记录动画目标初始旋转(动画模型右肩膀);
		记录动画目标初始旋转(动画模型右手臂);
		记录动画目标初始旋转(动画模型左肩膀);
		记录动画目标初始旋转(动画模型左手臂);
		记录动画目标初始旋转(动画模型右大腿);
		记录动画目标初始旋转(动画模型右小腿);
		记录动画目标初始旋转(动画模型左大腿);
		记录动画目标初始旋转(动画模型左小腿);
	}

	private void 记录部位初始旋转(Transform 部位)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)部位 != (Object)null)
		{
			初始局部旋转[部位] = 部位.localRotation;
		}
	}

	private void 记录动画目标初始旋转(Transform 目标)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)目标 != (Object)null)
		{
			动画目标初始旋转[目标] = 目标.localRotation;
		}
	}

	private void 初始化刚体设置()
	{
		foreach (Rigidbody item in 所有刚体)
		{
			item.isKinematic = true;
			item.useGravity = false;
			item.interpolation = (RigidbodyInterpolation)1;
		}
	}

	private void Update()
	{
		if (启用动画驱动)
		{
			更新所有部位跟随();
		}
	}

	private void 更新所有部位跟随()
	{
		更新部位变换(myHead, 动画模型头部);
		更新部位变换(myTorso, 动画模型躯干);
		更新部位变换(myHip, 动画模型hip);
		更新部位变换(myRightArm, 动画模型右肩膀);
		更新部位变换(myRightHand, 动画模型右手臂);
		更新部位变换(myLeftArm, 动画模型左肩膀);
		更新部位变换(myLeftHand, 动画模型左手臂);
		更新部位变换(myRightLeg, 动画模型右大腿);
		更新部位变换(myRightKnee, 动画模型右小腿);
		更新部位变换(myLeftLeg, 动画模型左大腿);
		更新部位变换(myLeftKnee, 动画模型左小腿);
	}

	private void 更新部位变换(Transform 物理部位, Transform 动画目标)
	{
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: 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_0062: 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)
		//IL_0073: 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_007d: 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_0085: 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)
		if (!((Object)(object)物理部位 == (Object)null) && !((Object)(object)动画目标 == (Object)null))
		{
			if (初始局部旋转.ContainsKey(物理部位) && 动画目标初始旋转.ContainsKey(动画目标))
			{
				Transform parent = 物理部位.parent;
				物理部位.SetParent((Transform)null);
				物理部位.position = 动画目标.position;
				Quaternion val = 初始局部旋转[物理部位] * Quaternion.Inverse(动画目标初始旋转[动画目标]);
				物理部位.rotation = 动画目标.rotation * val;
				物理部位.SetParent(parent);
			}
			else
			{
				物理部位.position = 动画目标.position;
				物理部位.rotation = 动画目标.rotation;
			}
		}
	}

	private void 更新部位变换简化版(Transform 物理部位, Transform 动画目标)
	{
		//IL_002b: 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)
		if (!((Object)(object)物理部位 == (Object)null) && !((Object)(object)动画目标 == (Object)null))
		{
			Transform parent = 物理部位.parent;
			物理部位.SetParent((Transform)null);
			物理部位.position = 动画目标.position;
			物理部位.rotation = 动画目标.rotation;
			物理部位.SetParent(parent);
		}
	}

	public void 切换到物理模式()
	{
		foreach (Rigidbody item in 所有刚体)
		{
			item.isKinematic = false;
			item.useGravity = true;
		}
		启用动画驱动 = false;
	}

	public void 切换到动画模式()
	{
		foreach (Rigidbody item in 所有刚体)
		{
			item.isKinematic = true;
			item.useGravity = false;
		}
		启用动画驱动 = true;
	}

	public void 暂停姿势()
	{
		启用动画驱动 = false;
	}

	public void 恢复动画跟随()
	{
		启用动画驱动 = true;
	}

	public void 重新记录初始旋转()
	{
		初始局部旋转.Clear();
		动画目标初始旋转.Clear();
		记录初始旋转();
	}
}
public class 动画跟随管理器 : MonoBehaviour
{
	[Header("物理刚体部位")]
	private Transform myHead;

	private Transform myTorso;

	private Transform myHip;

	private Transform myRightArm;

	private Transform myRightHand;

	private Transform myLeftArm;

	private Transform myLeftHand;

	private Transform myRightLeg;

	private Transform myRightKnee;

	private Transform myLeftLeg;

	private Transform myLeftKnee;

	[Header("动画模型目标")]
	public Transform 动画模型头部;

	public Transform 动画模型躯干;

	public Transform 动画模型hip;

	public Transform 动画模型右肩膀;

	public Transform 动画模型右手臂;

	public Transform 动画模型左肩膀;

	public Transform 动画模型左手臂;

	public Transform 动画模型右大腿;

	public Transform 动画模型右小腿;

	public Transform 动画模型左大腿;

	public Transform 动画模型左小腿;
}
public class ScenesManager17 : MonoBehaviour
{
	public ScenesManager17()
	{
		SceneManager.sceneLoaded += SceneLoaded;
	}

	public void SceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Expected O, but got Unknown
		if (((Scene)(ref scene)).name == "05_Lvl2_Medieval_VC")
		{
			GameObject val = new GameObject();
			((Object)val).name = "诅咒军团单位隐藏";
			Object.Instantiate<GameObject>(UManager.ab包.LoadAsset<GameObject>("王庭骑士隐藏物品"), val.transform);
			Object.Instantiate<GameObject>(UManager.ab包.LoadAsset<GameObject>("诅咒长戟兵隐藏物品"), val.transform);
		}
		if (((Scene)(ref scene)).name == "05_Lvl1_Medieval_VC")
		{
			GameObject val2 = new GameObject();
			((Object)val2).name = "诅咒军团单位隐藏";
			Object.Instantiate<GameObject>(UManager.ab包.LoadAsset<GameObject>("诅咒长弓手隐藏物品"), val2.transform);
		}
	}
}
public class 随机事件qwqw : MonoBehaviour
{
	[Range(0f, 1f)]
	public float 概率;

	public UnityEvent 随机事件;

	public void 触发()
	{
		float value = Random.value;
		if (value < 概率)
		{
			UnityEvent obj = 随机事件;
			if (obj != null)
			{
				obj.Invoke();
			}
		}
	}
}
public class 效果添加器121 : MonoBehaviour
{
	public enum 检测方式
	{
		物体,
		单位
	}

	public UnitEffectBase 效果设置;

	public float 检测半径 = 6f;

	public LayerMask 检测层;

	private Team 队伍信息;

	public 检测方式 sss = 检测方式.单位;

	private void Start()
	{
		//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_003b: 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)
		if (sss == 检测方式.单位)
		{
			队伍信息 = ((Component)this).GetComponentInParent<Unit>().data.team;
		}
		if (sss == 检测方式.物体)
		{
			队伍信息 = ((Component)this).GetComponentInParent<TeamHolder>().team;
		}
	}

	public void 开始检测()
	{
		//IL_0012: 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_0086: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		Debug.Log((object)"开始检测OO");
		Collider[] array = Physics.OverlapSphere(((Component)this).transform.position, 检测半径, LayerMask.op_Implicit(检测层));
		if (array.Length == 0)
		{
			return;
		}
		Debug.Log((object)"开始检测OqqqqO");
		for (int i = 0; i < array.Length; i++)
		{
			Unit componentInParent = ((Component)array[i]).GetComponentInParent<Unit>();
			if (!((Object)(object)componentInParent == (Object)null) && !componentInParent.data.Dead && componentInParent.data.team != 队伍信息)
			{
				UnitEffectBase val = UnitEffectBase.AddEffectToTarget(((Component)((Component)array[i]).transform).gameObject, 效果设置);
				if ((Object)(object)val == (Object)null)
				{
					val = Object.Instantiate<UnitEffectBase>(效果设置, ((Component)array[i]).transform);
					((Component)val).transform.SetPositionAndRotation(((Component)array[i]).transform.root.position, Quaternion.identity);
					TeamHolder.AddTeamHolder(((Component)val).gameObject, ((Component)this).gameObject);
					val.DoEffect();
				}
				else
				{
					val.Ping();
				}
			}
		}
	}

	private void OnDrawGizmos()
	{
		//IL_0015: 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_0037: 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)
		Gizmos.color = new Color(0f, 1f, 0f, 0.3f);
		Gizmos.DrawSphere(((Component)this).transform.position, 检测半径);
		Gizmos.color = Color.green;
		Gizmos.DrawWireSphere(((Component)this).transform.position, 检测半径);
	}
}
public class 事件效果执行12 : UnitEffectBase
{
	public UnityEvent 事件效果;

	public override void DoEffect()
	{
		UnityEvent obj = 事件效果;
		if (obj != null)
		{
			obj.Invoke();
		}
	}

	public override void Ping()
	{
		UnityEvent obj = 事件效果;
		if (obj != null)
		{
			obj.Invoke();
		}
	}
}
public class 击飞单位12 : MonoBehaviour
{
	public Unit 单位;

	public Rigidbody[] 刚体组;

	private void Start()
	{
		单位 = ((Component)this).GetComponentInParent<Unit>();
		刚体组 = 单位.data.allRigs.AllRigs;
	}

	public void 施加力(float 力度 = 1000f)
	{
		//IL_001e: 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)
		if (刚体组.Length != 0)
		{
			for (int i = 0; i < 刚体组.Length; i++)
			{
				刚体组[i].AddForce(Vector3.up * 力度, (ForceMode)5);
			}
		}
	}
}
internal static class 多国语言部分hhh
{
	public static void 语言添加(string key, string trans)
	{
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: 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_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_0281: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		if (string.IsNullOrEmpty(key))
		{
			Debug.LogError((object)"翻译键不能为空！");
			return;
		}
		if (string.IsNullOrEmpty(trans))
		{
			Debug.LogError((object)"翻译内容不能为空！");
			return;
		}
		string[] array = trans.Split(new string[1] { "#" }, StringSplitOptions.RemoveEmptyEntries);
		if (array.Length != 8)
		{
			Debug.LogError((object)$"翻译格式错误：需要8种语言，但只提供了{array.Length}种。格式应为：中文#英文#日文#德文#法文#俄文#西班牙文#意大利文");
			return;
		}
		for (int i = 0; i < array.Length; i++)
		{
			if (string.IsNullOrWhiteSpace(array[i]))
			{
				string[] array2 = new string[8] { "中文", "英文", "日文", "德文", "法文", "俄文", "西班牙文", "意大利文" };
				Debug.LogError((object)$"第{i}个位置({array2[i]})的翻译内容为空！");
				return;
			}
		}
		try
		{
			Dictionary<int, Language> dictionary = new Dictionary<int, Language>();
			dictionary.Add(0, (Language)7);
			dictionary.Add(1, (Language)0);
			dictionary.Add(2, (Language)8);
			dictionary.Add(3, (Language)3);
			dictionary.Add(4, (Language)1);
			dictionary.Add(5, (Language)6);
			dictionary.Add(6, (Language)4);
			dictionary.Add(7, (Language)2);
			FieldInfo field = typeof(Localizer).GetField("m_localization", BindingFlags.Static | BindingFlags.NonPublic);
			if (field == null)
			{
				Debug.LogError((object)"无法访问Localizer的m_localization字段！");
				return;
			}
			if (!(field.GetValue(null) is Dictionary<Language, Dictionary<string, string>> dictionary2))
			{
				Debug.LogError((object)"本地化字典为空或类型不匹配！");
				return;
			}
			foreach (Language value in dictionary.Values)
			{
				if (!dictionary2.ContainsKey(value))
				{
					Debug.LogError((object)$"本地化字典中缺少语言：{value}");
					return;
				}
			}
			int num = 0;
			for (int j = 0; j < dictionary.Count; j++)
			{
				Language val = dictionary[j];
				if (!dictionary2[val].ContainsKey(key))
				{
					dictionary2[val].Add(key, array[j]);
					num++;
				}
				else
				{
					Debug.LogWarning((object)$"语言{val}中已存在键'{key}'，跳过添加");
				}
			}
			field.SetValue(null, dictionary2);
			if (num > 0)
			{
				Debug.Log((object)$"成功为{num}种语言添加了翻译键：{key}");
			}
			else
			{
				Debug.Log((object)("所有语言中都已存在键'" + key + "'，未添加任何新翻译"));
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)("添加翻译时发生错误：" + ex.Message + "\n" + ex.StackTrace));
		}
	}
}