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 HeMoDingDingMod.ECS;
using HeMoDingDingMod.unity脚本;
using HeMoDingDingMod.unity脚本.事件相关;
using HeMoDingDingMod.unity脚本.场景清理相关;
using HeMoDingDingMod.unity脚本.检测相关类.基类;
using HeMoDingDingMod.unity脚本.蠕虫类;
using HeMoDingDingMod.unity脚本.补丁空间;
using HeMoDingDingMod.unity脚本.补丁空间.补丁添加进;
using HeMoDingDingMod.unity脚本.补丁空间.锁定胜利判断单例;
using HeMoDingDingMod.工具文件夹.我的工具单例;
using HeMoDingDingMod.我的反射;
using HeMoDingDingMod.角色类.初王;
using HeMoDingDingMod.角色类.基兰;
using HeMoDingDingMod.角色类.幸运方块j;
using HeMoDingDingMod.角色类.武装直升机;
using HeMoDingDingMod.角色类.至高神性;
using Landfall.TABC;
using Landfall.TABS;
using Landfall.TABS.AI.Components;
using Landfall.TABS.AI.Components.Modifiers;
using Landfall.TABS.AI.Components.Tags;
using Landfall.TABS.AI.Systems;
using Landfall.TABS.GameMode;
using Landfall.TABS.GameState;
using Landfall.TABS.UnitEditor;
using TFBGames;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using ZhaoHuanshi.召唤类;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("HeMoDingDingMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[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]
namespace ZhaoHuanshi.召唤类
{
	public enum SimulatedButtonType
	{
		Normal,
		Confirm,
		Cooldown
	}
	public class SimulatedButtonConfig
	{
		public string Key { get; set; }

		public string DisplayName { get; set; }

		public SimulatedButtonType Type { get; set; } = SimulatedButtonType.Normal;

		public Action OnClick { get; set; }

		public float CooldownSeconds { get; set; } = 1f;

		public string ConfirmMessage { get; set; } = "确认执行？";
	}
	public static class 模拟按钮管理器
	{
		private class ButtonState
		{
			public bool IsOnCooldown = false;

			public bool IsWaitingConfirm = false;

			public float LastClickTime = 0f;

			public SettingsInstance SettingsInstance;

			public SimulatedButtonConfig Config;
		}

		private static GlobalSettingsHandler _settingsHandler;

		private static Dictionary<string, ButtonState> _buttonStates = new Dictionary<string, ButtonState>();

		private static MonoBehaviour _coroutineRunner;

		private static bool _isInitialized = false;

		public static void Initialize(MonoBehaviour coroutineRunner)
		{
			if (!_isInitialized)
			{
				_coroutineRunner = coroutineRunner;
				_settingsHandler = ServiceLocator.GetService<GlobalSettingsHandler>();
				if ((Object)(object)_settingsHandler == (Object)null)
				{
					Debug.LogError((object)"[模拟按钮管理器] 无法获取 GlobalSettingsHandler");
					return;
				}
				_isInitialized = true;
				Debug.Log((object)"[模拟按钮管理器] 初始化成功");
			}
		}

		public static void AddNormalButton(string key, string displayName, Action onClick)
		{
			SimulatedButtonConfig config = new SimulatedButtonConfig
			{
				Key = key,
				DisplayName = displayName,
				Type = SimulatedButtonType.Normal,
				OnClick = onClick
			};
			AddButton(config);
		}

		public static void AddCooldownButton(string key, string displayName, Action onClick, float cooldownSeconds = 1f)
		{
			SimulatedButtonConfig config = new SimulatedButtonConfig
			{
				Key = key,
				DisplayName = displayName,
				Type = SimulatedButtonType.Cooldown,
				OnClick = onClick,
				CooldownSeconds = cooldownSeconds
			};
			AddButton(config);
		}

		public static void AddConfirmButton(string key, string displayName, Action onClick, string confirmMessage = "确认执行？")
		{
			SimulatedButtonConfig config = new SimulatedButtonConfig
			{
				Key = key,
				DisplayName = displayName,
				Type = SimulatedButtonType.Confirm,
				OnClick = onClick,
				ConfirmMessage = confirmMessage
			};
			AddButton(config);
		}

		public static void AddButton(SimulatedButtonConfig config)
		{
			if (!_isInitialized)
			{
				Debug.LogError((object)"[模拟按钮管理器] 未初始化，请先调用 Initialize()");
				return;
			}
			try
			{
				if (_buttonStates.ContainsKey(config.Key))
				{
					Debug.LogWarning((object)("[模拟按钮管理器] 按钮已存在: " + config.Key));
					return;
				}
				ButtonState buttonState = new ButtonState
				{
					Config = config,
					IsOnCooldown = false,
					IsWaitingConfirm = false,
					LastClickTime = 0f
				};
				SettingsInstance val = (buttonState.SettingsInstance = CreateButtonSettingsInstance(config));
				AddToGameplaySettings(val);
				val.OnValueChanged += delegate(int value)
				{
					OnButtonValueChanged(config.Key, value > 0);
				};
				_buttonStates[config.Key] = buttonState;
				Debug.Log((object)("[模拟按钮管理器] 成功添加按钮: " + config.DisplayName + " (" + config.Key + ")"));
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[模拟按钮管理器] 添加按钮失败: " + ex.Message));
			}
		}

		private static SettingsInstance CreateButtonSettingsInstance(SimulatedButtonConfig config)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			SettingsInstance val = new SettingsInstance();
			val.localizeOptions = false;
			val.settingsType = (SettingsType)0;
			val.m_settingsKey = config.Key;
			val.settingName = config.DisplayName;
			val.toolTip = GetTooltipByType(config);
			val.options = new string[2] { "点击执行", "已点击" };
			val.defaultValue = 0;
			val.currentValue = 0;
			val.defaultSliderValue = 0f;
			val.currentSliderValue = 0f;
			val.min = 0f;
			val.max = 1f;
			return val;
		}

		private static string GetTooltipByType(SimulatedButtonConfig config)
		{
			return config.Type switch
			{
				SimulatedButtonType.Normal => "点击执行：" + config.DisplayName, 
				SimulatedButtonType.Confirm => "点击后需要再次确认：" + config.DisplayName, 
				SimulatedButtonType.Cooldown => $"点击执行（冷却 {config.CooldownSeconds} 秒）：{config.DisplayName}", 
				_ => "点击执行：" + config.DisplayName, 
			};
		}

		private static void OnButtonValueChanged(string key, bool isClicked)
		{
			if (!_buttonStates.TryGetValue(key, out var value) || !isClicked)
			{
				return;
			}
			if (value.IsOnCooldown)
			{
				Debug.Log((object)("[模拟按钮管理器] 按钮 " + key + " 正在冷却中"));
				ResetButtonValue(value);
				return;
			}
			switch (value.Config.Type)
			{
			case SimulatedButtonType.Normal:
				ExecuteButtonClick(value);
				break;
			case SimulatedButtonType.Confirm:
				HandleConfirmButton(value);
				break;
			case SimulatedButtonType.Cooldown:
				HandleCooldownButton(value);
				break;
			}
		}

		private static void ExecuteButtonClick(ButtonState state)
		{
			try
			{
				Debug.Log((object)("[模拟按钮管理器] 按钮被点击: " + state.Config.DisplayName));
				state.Config.OnClick?.Invoke();
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[模拟按钮管理器] 按钮执行失败: " + ex.Message));
			}
			finally
			{
				_coroutineRunner.StartCoroutine(ResetButtonValueDelayed(state, 0.1f));
			}
		}

		private static void HandleConfirmButton(ButtonState state)
		{
			if (!state.IsWaitingConfirm)
			{
				state.IsWaitingConfirm = true;
				UpdateButtonOptions(state, new string[2] { "确认执行？", "取消" }, 0);
				Debug.Log((object)("[模拟按钮管理器] 请再次点击确认: " + state.Config.DisplayName));
			}
			else
			{
				state.IsWaitingConfirm = false;
				ExecuteButtonClick(state);
				UpdateButtonOptions(state, new string[2] { "点击执行", "已点击" }, 0);
			}
		}

		private static void HandleCooldownButton(ButtonState state)
		{
			state.IsOnCooldown = true;
			state.LastClickTime = Time.time;
			ExecuteButtonClick(state);
			_coroutineRunner.StartCoroutine(CooldownCoroutine(state));
		}

		private static IEnumerator CooldownCoroutine(ButtonState state)
		{
			float elapsed = 0f;
			float cooldown = state.Config.CooldownSeconds;
			UpdateButtonOptions(state, new string[2] { "冷却中...", "冷却中..." }, 0);
			while (elapsed < cooldown)
			{
				elapsed += Time.deltaTime;
				if (elapsed < cooldown)
				{
					int remaining = Mathf.CeilToInt(cooldown - elapsed);
					UpdateButtonOptions(state, new string[2]
					{
						$"冷却中 {remaining}s",
						$"冷却中 {remaining}s"
					}, 0);
				}
				yield return null;
			}
			state.IsOnCooldown = false;
			UpdateButtonOptions(state, new string[2] { "点击执行", "已点击" }, 0);
			Debug.Log((object)("[模拟按钮管理器] 按钮 " + state.Config.Key + " 冷却结束"));
		}

		private static void UpdateButtonOptions(ButtonState state, string[] options, int currentValue)
		{
			if (state.SettingsInstance != null)
			{
				state.SettingsInstance.options = options;
				state.SettingsInstance.currentValue = currentValue;
				FieldInfo field = typeof(SettingsInstance).GetField("OnValueChanged", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
		}

		private static void ResetButtonValue(ButtonState state)
		{
			if (state.SettingsInstance != null)
			{
				typeof(SettingsInstance).GetField("currentValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(state.SettingsInstance, 0);
			}
		}

		private static IEnumerator ResetButtonValueDelayed(ButtonState state, float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			ResetButtonValue(state);
		}

		private static void AddToGameplaySettings(SettingsInstance instance)
		{
			FieldInfo field = typeof(GlobalSettingsHandler).GetField("m_gameplaySettings", BindingFlags.Instance | BindingFlags.NonPublic);
			List<SettingsInstance> list = ((SettingsInstance[])field.GetValue(_settingsHandler))?.ToList() ?? new List<SettingsInstance>();
			if (list.Any((SettingsInstance s) => s.m_settingsKey == instance.m_settingsKey))
			{
				Debug.LogWarning((object)("[模拟按钮管理器] 设置项已存在: " + instance.m_settingsKey));
				return;
			}
			list.Add(instance);
			field.SetValue(_settingsHandler, list.ToArray());
		}

		public static void RemoveButton(string key)
		{
			if (_buttonStates.ContainsKey(key))
			{
				FieldInfo field = typeof(GlobalSettingsHandler).GetField("m_gameplaySettings", BindingFlags.Instance | BindingFlags.NonPublic);
				List<SettingsInstance> list = ((SettingsInstance[])field.GetValue(_settingsHandler))?.ToList() ?? new List<SettingsInstance>();
				SettingsInstance val = ((IEnumerable<SettingsInstance>)list).FirstOrDefault((Func<SettingsInstance, bool>)((SettingsInstance s) => s.m_settingsKey == key));
				if (val != null)
				{
					list.Remove(val);
					field.SetValue(_settingsHandler, list.ToArray());
				}
				_buttonStates.Remove(key);
				Debug.Log((object)("[模拟按钮管理器] 已移除按钮: " + key));
			}
		}

		public static void ClearAllButtons()
		{
			foreach (string item in _buttonStates.Keys.ToList())
			{
				RemoveButton(item);
			}
		}
	}
}
namespace HeMoDingDingMod
{
	[BepInPlugin("HeMoDingDingMod", "HeMoDingDingMod", "1.0.0")]
	internal class Loader : BaseUnityPlugin
	{
		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"黑莫丁丁补丁注入中...");
			Harmony val = new Harmony("HeMoDingDingMod");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"黑莫丁丁补丁注入完成！");
			((MonoBehaviour)this).StartCoroutine(call());
		}

		private IEnumerator call()
		{
			UManager.Init();
			GameObject HeMoDingdingDanli = new GameObject("HeMoDingdingDanli");
			Object.DontDestroyOnLoad((Object)(object)HeMoDingdingDanli);
			HeMoDingdingDanli.AddComponent<添加自定义内容>();
			Debug.Log((object)"黑莫丁丁mod已加载完毕");
			yield return (object)new WaitUntil((Func<bool>)(() => (Object)(object)Object.FindObjectOfType<ServiceLocator>() != (Object)null));
			yield return (object)new WaitUntil((Func<bool>)(() => ServiceLocator.GetService<ISaveLoaderService>() != null));
			UManager.音库合并方法();
			多国语言部分333.添加语言();
			幸运方块加载类.更新列表();
			幸运方块加载类.更新爆炸对象列表();
			幸运方块加载类.更新效果对象列表();
			添加设置按钮.Initialize();
			模拟按钮管理器.Initialize((MonoBehaviour)(object)this);
			模拟按钮管理器.AddNormalButton("幸运方块刷新所有单位列表", "[幸运方块] 刷新所有单位列表", delegate
			{
				Debug.Log((object)"刷新列表！！");
				幸运方块加载类.更新列表();
			});
			模拟按钮管理器.AddNormalButton("幸运方块刷新爆炸物列表和效果列表", "[幸运方块] ", delegate
			{
				Debug.Log((object)"刷新列表！！");
				幸运方块加载类.更新爆炸对象列表();
				幸运方块加载类.更新效果对象列表();
			});
			添加设置按钮.AddToggle("单位测试模式", "[黑莫丁丁] 特色功能", HeMoDingDing游戏模式单例.Instance.IsLocked, delegate(bool isEnabled)
			{
				if (isEnabled)
				{
					HeMoDingDing游戏模式单例.Instance.Lock();
				}
				else
				{
					HeMoDingDing游戏模式单例.Instance.Unlock();
				}
				Debug.Log((object)("沉浸式模式" + (isEnabled ? "启用" : "禁用")));
			});
			_ = 死亡单位清理组件.Instance;
		}
	}
	public static class UManager
	{
		public enum 对象类
		{
			单位模型,
			武器,
			技能,
			服饰,
			抛射物
		}

		public static string modname = "HeMoDingDingMod";

		public static AssetBundle ab包;

		public static List<UnitBlueprint> 编辑器单位基础 = new List<UnitBlueprint>();

		public static int MYmodid = 228472303;

		public static int MYmodunitid = 62847203;

		public static void 音库合并方法()
		{
			SoundPlayer service = ServiceLocator.GetService<SoundPlayer>();
			if ((Object)(object)service == (Object)null)
			{
				Debug.LogError((object)"无法获取SoundPlayer服务");
				ab包.Unload(false);
				return;
			}
			SoundBank soundBank = service.soundBank;
			if ((Object)(object)soundBank == (Object)null)
			{
				Debug.LogError((object)"SoundPlayer中的soundBank为空");
				ab包.Unload(false);
				return;
			}
			SoundBank[] array = ab包.LoadAllAssets<SoundBank>();
			if (array != null && array.Length != 0)
			{
				List<SoundBankCategory> list = soundBank.Categories?.ToList() ?? new List<SoundBankCategory>();
				SoundBank[] array2 = array;
				foreach (SoundBank val in array2)
				{
					if ((Object)(object)val != (Object)null && val.Categories != null)
					{
						list.AddRange(val.Categories);
						Debug.Log((object)$"已合并SoundBank: {((Object)val).name}, 类别数: {val.Categories.Length}");
					}
					else if ((Object)(object)val == (Object)null)
					{
						Debug.LogWarning((object)"遇到空的SoundBank引用，已跳过");
					}
					else
					{
						Debug.LogWarning((object)("SoundBank " + ((Object)val).name + " 的Categories为空"));
					}
				}
				soundBank.Categories = list.ToArray();
				Debug.Log((object)$"SoundBank合并完成，总类别数: {list.Count}");
			}
			else
			{
				Debug.LogWarning((object)"主AssetBundle中没有找到任何SoundBank");
			}
		}

		public static void Init()
		{
			//IL_013f: 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_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_055d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0745: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0846: Unknown result type (might be due to invalid IL or missing references)
			//IL_088c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d15: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d87: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e4a: Unknown result type (might be due to invalid IL or missing references)
			//IL_10ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_10d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_1107: Unknown result type (might be due to invalid IL or missing references)
			//IL_1211: Unknown result type (might be due to invalid IL or missing references)
			//IL_124d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1253: Unknown result type (might be due to invalid IL or missing references)
			//IL_1286: Unknown result type (might be due to invalid IL or missing references)
			//IL_129e: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_12ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_1301: Unknown result type (might be due to invalid IL or missing references)
			//IL_1313: Unknown result type (might be due to invalid IL or missing references)
			//IL_1350: Unknown result type (might be due to invalid IL or missing references)
			//IL_13d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_1518: Unknown result type (might be due to invalid IL or missing references)
			//IL_151e: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_17aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_1808: Unknown result type (might be due to invalid IL or missing references)
			//IL_183d: Unknown result type (might be due to invalid IL or missing references)
			//IL_19b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bab: Unknown result type (might be due to invalid IL or missing references)
			//IL_1bb1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c70: Unknown result type (might be due to invalid IL or missing references)
			//IL_1cd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e1e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1eda: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f38: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f96: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ff4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2052: Unknown result type (might be due to invalid IL or missing references)
			//IL_20b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_210e: Unknown result type (might be due to invalid IL or missing references)
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("HeMoDingDingMod.hemodingdongsass");
			AssetBundle val = (ab包 = AssetBundle.LoadFromStream(manifestResourceStream));
			Material[] array = val.LoadAllAssets<Material>();
			if (array == null || array.Length == 0)
			{
				Debug.LogWarning((object)"主AssetBundle中没有找到任何材质");
			}
			else
			{
				Material[] array2 = array;
				foreach (Material val2 in array2)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						Debug.LogWarning((object)"遇到空的材质引用，已跳过");
					}
					else if ((Object)(object)val2.shader == (Object)null)
					{
						Debug.LogWarning((object)("材质 " + ((Object)val2).name + " 的Shader为空，无法修复"));
					}
					else
					{
						材质修复工具.刷新材质属性(val2);
					}
				}
			}
			Faction val3 = 游戏内容工具.创建派系("UNIT_KONGBUSHENGWU", null, val.LoadAsset<Sprite>("恐怖生物派系dsadsicon"), -4, 49582393);
			GameObject val4 = 游戏内容工具.注册单位Base(val.LoadAsset<GameObject>("世界吞噬者模型"));
			val4.GetComponentInChildren<平滑蠕虫跟随>().节间距 = 2f;
			val4.GetComponentInChildren<平滑蠕虫跟随>().最大允许距离倍数 = 0.9f;
			val4.GetComponentInChildren<吞噬者移动类>().巡游时间 = 7f;
			val4.GetComponentInChildren<吞噬者移动类>().转向速度 = 80f;
			UnitBlueprint val5 = 游戏内容工具.复制单位("UNIT_SHIJIETUNSHIZHE", 游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1166250463)), val3, val.LoadAsset<Sprite>("世界吞噬者dsfk"), (DatabaseID?)new DatabaseID(-3, 350452348));
			val5.UnitBase = val4;
			val5.sizeMultiplier = 0.8f;
			val5.health = 599f;
			val5.forceCost = 4800u;
			val5.SetUnitSounds("Secret Attack Vocals/Raptor", "Secret Death Vocals/Raptor", 0.6f);
			UnitBlueprint val6 = 游戏内容工具.复制单位("世界吞噬者基础蓝图", 游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1166250463)), (Faction)null, val.LoadAsset<Sprite>("世界吞噬者dsfk"), (DatabaseID?)new DatabaseID(-3, 345363465));
			val6.UnitBase = val4;
			编辑器单位基础.Add(val6);
			游戏内容工具.注册道具(游戏物品加入.Instance.创建物品("调整身体体节连接", val.LoadAsset<GameObject>("空服饰3453"), new DatabaseID(-3, 176742343))).AddComponent<蠕虫服饰调整>();
			游戏内容工具.注册道具(游戏物品加入.Instance.创建物品("调整蠕虫移动属性", val.LoadAsset<GameObject>("空服饰3453"), new DatabaseID(-3, 176742344))).AddComponent<蠕虫服饰调整2>();
			游戏内容工具.注册道具(游戏物品加入.Instance.创建物品("调整蠕虫移动属性2", val.LoadAsset<GameObject>("空服饰3453"), new DatabaseID(-3, 176742345))).AddComponent<蠕虫服饰调整3>();
			UnitBlueprint val7 = 游戏内容工具.复制单位("UNIT_HEIJIABUBUSIZHAN", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("玛丽卡死icon"), (DatabaseID?)new DatabaseID(-3, 312534211));
			val7.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[0];
			val7.health = 9000f;
			val7.massMultiplier = 20f;
			GameObject rightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("黑剑23243"), 对象类.武器);
			val7.RightWeapon = rightWeapon;
			val7.m_props = (GameObject[])(object)new GameObject[11]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯后披风"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯大腿护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯大臂护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯头盔"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯小腿护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯小臂护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯护膝"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯肩膀护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯胸甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯腰部护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("玛利喀斯鞋子"), 对象类.服饰)
			};
			GameObject val8 = 游戏内容工具.注册单位Base(游戏物品加入.Instance.创建物品("灰色人物模型", 获取工具.获取原版内容游戏物品("m_unitBases", new DatabaseID(-1, 1760500345)), new DatabaseID(-3, 13972330)));
			TeamColor[] componentsInChildren = val8.GetComponentsInChildren<TeamColor>();
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				componentsInChildren[j].blueMaterial = val.LoadAsset<Material>("低反射灰色12");
				componentsInChildren[j].redMaterial = val.LoadAsset<Material>("低反射灰色12");
			}
			val7.UnitBase = val8;
			val7.forceCost = 10000u;
			val7.SetUnitSounds("Reinassance Attack Vocals/Jouster", "Reinassance Attack Vocals/Jouster", 0.4f);
			UnitBlueprint val9 = 游戏内容工具.复制单位("UNIT_YILIUTI", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("遗留着uu"), (DatabaseID?)new DatabaseID(-3, 312534212));
			val9.forceCost = 120u;
			val9.m_props = (GameObject[])(object)new GameObject[7]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士大臂套"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士头部插件"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士小臂刺"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士躯干装饰剑"), 对象类.服饰),
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 1944888562)),
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 273394296))
			};
			val9.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("死亡剑士刀剑"), 对象类.武器);
			val9.health = 20f;
			val9.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("cd瞬移技能")) };
			val9.UnitBase = 获取工具.获取原版内容游戏物品("m_unitBases", new DatabaseID(-1, 1288909650));
			val9.SetUnitSounds("Reinassance Attack Vocals/Halberd", "Reinassance Death Vocals/Halberd", 0.5f);
			UnitBlueprint val10 = 游戏内容工具.复制单位("UNIT_KUANGBAOZHADANREN", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("精神病人32213"), (DatabaseID?)new DatabaseID(-3, 312534213));
			val10.sizeMultiplier = 1f;
			val10.health = 70f;
			val10.forceCost = 350u;
			val10.m_props = (GameObject[])(object)new GameObject[6]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才左腿装饰"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才的夹克"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才的脑袋"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才的连体服饰"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才背包342"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("爆破鬼才的轮子腰带"), 对象类.服饰)
			};
			val10.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("扔炸弹34"), 对象类.武器);
			val10.LeftWeapon = val10.RightWeapon;
			注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("大小炸弹34"), 对象类.抛射物);
			val10.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("桶装爆破进243")) };
			val10.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			val10.SetUnitSounds("Western Attack Vocals/Quickdraw", "Western Death Vocals/Quickdraw", 1.5f);
			UnitBlueprint val11 = 游戏内容工具.复制单位("UNIT_JUEXINGSHUBING", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("觉醒骷髅兵3we"), (DatabaseID?)new DatabaseID(-3, 312534214));
			val11.sizeMultiplier = 0.7f;
			val11.health = 200f;
			val11.forceCost = 500u;
			val11.m_props = (GameObject[])(object)new GameObject[4]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("觉醒骷髅大褂"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("觉醒骷髅帽子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("觉醒骷髅裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("觉醒骷髅鞋子"), 对象类.服饰)
			};
			val11.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("觉醒骷髅复制剑"), 对象类.武器);
			val11.UnitBase = 获取工具.获取原版内容游戏物品("m_unitBases", new DatabaseID(-1, 1288909650));
			val11.SetUnitSounds("Halloween Attack Vocals/SkeletonWarrior", "Halloween Death Vocals/SkeletonWarrior", 0.95f);
			UnitBlueprint val12 = 游戏内容工具.复制单位("UNIT_YONGYEQIANXINGZHE", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("幻影刺客sdkfhj"), (DatabaseID?)new DatabaseID(-3, 332534267));
			val12.health = 900f;
			val12.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("体积雾技能")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客瞬移技能"))
			};
			val12.m_props = (GameObject[])(object)new GameObject[5]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客头发"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客意义不明的手臂套子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客鞋子"), 对象类.服饰)
			};
			val12.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("暗影刺客武器"), 对象类.武器);
			val12.LeftWeapon = val12.RightWeapon;
			val12.forceCost = 1500u;
			val12.SetUnitSounds("Fantasy Dark Attack Vocals/FantasyAssassin", "Fantasy Dark Death Vocals/FantasyAssassin", 0.95f);
			UnitBlueprint val13 = 游戏内容工具.复制单位("UNIT_SHIluoTANXIANJIA", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("失落冒险家43rdsf"), (DatabaseID?)new DatabaseID(-3, 332534268));
			val13.sizeMultiplier = 1.5f;
			val13.health = 1400f;
			val13.massMultiplier = 20f;
			val13.m_props = (GameObject[])(object)new GameObject[6]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者外套"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者头盔和头发"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者披风"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("迷雾行者鞋子"), 对象类.服饰)
			};
			val13.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 获取工具.获取原版内容游戏物品("m_combatMoves", new DatabaseID(-1, 920020464)) };
			val13.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("十字巨剑3434"), 对象类.武器);
			val13.holdinigWithTwoHands = true;
			val13.movementSpeedMuiltiplier = 1.8f;
			val13.forceCost = 3700u;
			val13.SetUnitSounds("Fantasy Dark Attack Vocals/StormPriest", "Fantasy Dark Death Vocals/StormPriest", 0.85f);
			UnitBlueprint val14 = 游戏内容工具.复制单位("UNIT_ZHONGXINGJUNCHUANQIANGQBING", (UnitBlueprint)null, val3, val.LoadAsset<Sprite>("重装步兵daskfn"), (DatabaseID?)new DatabaseID(-3, 332534269));
			val14.health = 3000f;
			val14.sizeMultiplier = 1.7f;
			val14.massMultiplier = 30f;
			val14.m_props = (GameObject[])(object)new GameObject[12]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵上板甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵下体板甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵前挡"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵大腿护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵大臂护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵头盔"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵护手"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵护膝刺甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵护颈"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵板甲裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵羊角护臂"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("重装亡灵鞋子"), 对象类.服饰)
			};
			GameObject val15 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("空技能3434"));
			val15.AddComponent<重装亡灵抛射物免疫添加工具>();
			val14.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { val15 };
			val14.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("戳矛23"), 对象类.武器);
			val14.LeftWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("石头盾牌345"), 对象类.武器);
			val14.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(重装亡灵后撤步) };
			val14.forceCost = 8000u;
			val14.SetUnitSounds("Pirate Attack Vocals/Cannon", "Pirate Attack Vocals/Cannon", 0.85f);
			GameObject unitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("单位模型直升机23"), 对象类.单位模型);
			UnitBlueprint val16 = 游戏内容工具.复制单位("UNIT_WUZHUANGZHISHENGJI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("生成武装直升机图标"), (DatabaseID?)new DatabaseID(-3, 332534270));
			val16.UnitBase = unitBase;
			val16.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("直升机机炮sad"), 对象类.武器);
			val16.LeftWeapon = val16.RightWeapon;
			val16.massMultiplier = 100f;
			val16.SetRiders((UnitBlueprint[])(object)new UnitBlueprint[4]
			{
				游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1885243923)),
				游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1885243923)),
				游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1885243923)),
				游戏内容工具.获取原版单位蓝图(new DatabaseID(-1, 1885243923))
			});
			val16.forceCost = 6000u;
			GameObject val17 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("空技能3434"));
			val17.AddComponent<直升机抗性添加工具>();
			val16.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { val17 };
			val16.SetUnitSounds("Legacy Attack Vocals/Tank", "Legacy Attack Vocals/Tank");
			Faction 指定派系 = 游戏内容工具.获取原版派系(new DatabaseID(-1, 673578412));
			添加单位到指定派系(val16, 指定派系, 自动排序: true, 去重: true);
			UnitBlueprint val18 = 游戏内容工具.复制单位("UNIT_AERDENGZHINAGEFULEI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("葛孚雷图标32"), (DatabaseID?)new DatabaseID(-3, 332534271));
			val18.health = 1500f;
			val18.massMultiplier = 12f;
			val18.movementSpeedMuiltiplier = 1.8f;
			GameObject[] first = (GameObject[])(object)new GameObject[6]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—护肘"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—肩甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—躯干护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—披风"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—狮子宰相"), 对象类.服饰)
			};
			GameObject[] array3 = (GameObject[])(object)new GameObject[12]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—下把胡子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—前摆"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—右摆"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—后摆"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—头发"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—左摆"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—无骨骼胡子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—毛发挂件"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—皇冠"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—腰部系绳"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王服饰—鞋子"), 对象类.服饰)
			};
			val18.m_props = first.Concat(array3).ToArray();
			val18.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王武器dsfj"), 对象类.武器);
			val18.holdinigWithTwoHands = true;
			GameObject unitBase2 = (val18.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("强壮的人形单位"), 对象类.单位模型));
			val18.sizeMultiplier = 1.8f;
			GameObject val20 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("半血升级技能"));
			GameObject val21 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("葛孚雷死亡二阶段"));
			val18.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[4]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("初王冲刺践踏")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("向下砸斧子asd")),
				val20,
				val21
			};
			val18.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
			val18.forceCost = 16000u;
			UnitBlueprint val22 = 游戏内容工具.复制单位("战士何来露", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("葛孚雷图标32"), (DatabaseID?)new DatabaseID(-3, 332534272));
			val22.UnitBase = unitBase2;
			val22.health = 1000f;
			val22.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[3]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("何来露投技")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("何来露掀地板23")),
				val20
			};
			val22.m_props = array3;
			val22.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("何来露拳头245"), 对象类.武器);
			val22.LeftWeapon = val22.RightWeapon;
			val22.sizeMultiplier = 1.8f;
			val22.movementSpeedMuiltiplier = 3f;
			val21.GetComponent<死亡后进入2阶段>().二阶段单位蓝图 = val22;
			val18.SetUnitSounds("Viking Attack Vocals/Jarl", "Viking Attack Vocals/Jarl", 0.7f);
			val22.SetUnitSounds("Viking Attack Vocals/Jarl", "Viking Attack Vocals/Jarl", 0.7f);
			UnitBlueprint val23 = 游戏内容工具.复制单位("UNIT_SHUXUELAOSHI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("数学老师图标32"), (DatabaseID?)new DatabaseID(-3, 332534273));
			val23.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("数学家之力sdakfh"), 对象类.武器);
			val23.holdinigWithTwoHands = true;
			val23.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
			val23.forceCost = 600u;
			val23.m_props = (GameObject[])(object)new GameObject[4]
			{
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 789074667)),
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 1515039722)),
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 1263832372)),
				获取工具.获取原版内容游戏物品("m_characterProps", new DatabaseID(-1, 1012097602))
			};
			val23.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			Faction 指定派系2 = 游戏内容工具.获取原版派系(new DatabaseID(-1, 442148333));
			Faction 指定派系3 = 游戏内容工具.获取原版派系(new DatabaseID(-1, 1701001489));
			添加单位到指定派系(val18, 指定派系2, 自动排序: true, 去重: true);
			添加单位到指定派系(val23, 指定派系3, 自动排序: true, 去重: true);
			UnitBlueprint val24 = 游戏内容工具.复制单位("UNIT_XINGYUNFANGKUAI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("幸运方块图标123"), (DatabaseID?)new DatabaseID(-3, 332534274));
			val24.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("幸运方块模型"), 对象类.单位模型);
			val24.forceCost = 650u;
			val24.health = 100f;
			val24.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			添加单位到指定派系(val24, 指定派系, 自动排序: true, 去重: true);
			UnitBlueprint val25 = 游戏内容工具.复制单位("UNIT_XINGUIREN", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("基兰图标asl1"), (DatabaseID?)new DatabaseID(-3, 332534275));
			val25.m_props = (GameObject[])(object)new GameObject[12]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--前挡"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--头发"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--肩甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--胡子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--胸甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--腰部后披风"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--腰部系绳"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--面具"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--鞋子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("基兰服饰--魔法圆盘"), 对象类.服饰)
			};
			val25.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("时间老头武器23"), 对象类.武器);
			val25.LeftWeapon = val25.RightWeapon;
			val25.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
			val25.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("在目标出召唤时钟")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("给予高价值单位复活效果"))
			};
			val25.forceCost = 3000u;
			val25.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			添加单位到指定派系(val25, 指定派系, 自动排序: true, 去重: true);
			UnitBlueprint val26 = 游戏内容工具.复制单位("UNIT_SHETI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("瑟提图标asdas"), (DatabaseID?)new DatabaseID(-3, 332534276));
			val26.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("强壮人形单位带肌肉版本"), 对象类.单位模型);
			val26.m_props = (GameObject[])(object)new GameObject[9]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_上衣"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_发型"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_手套"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_腰带"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_鞋子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_龙头装饰"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_肩部皮毛"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提服饰_豪意值附体"), 对象类.服饰)
			};
			val26.health = 3000f;
			val26.massMultiplier = 20f;
			val26.forceCost = 20000u;
			val26.movementSpeedMuiltiplier = 1.8f;
			val26.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[4]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("腕豪技能_强手裂颅")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("腕豪技能_叹为观止")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("腕豪技能_豪意值系统")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("腕豪技能_蓄意轰拳"))
			};
			GameObject val27 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("瑟提拳头与中"), 对象类.武器);
			val27.GetComponent<MeleeWeapon>().curveForce = 150000f;
			val26.RightWeapon = val27;
			val26.LeftWeapon = val26.RightWeapon;
			val26.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			添加单位到指定派系(val26, 指定派系, 自动排序: true, 去重: true);
			UnitBlueprint val28 = 游戏内容工具.复制单位("手推车幸运方块sdf", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("幸运方块图标123"), (DatabaseID?)new DatabaseID(-3, 332534277));
			val28.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("拉泡始幸运方块"), 对象类.单位模型);
			val28.forceCost = 650u;
			val28.health = 100f;
			添加单位到指定派系(val28, 指定派系, 自动排序: true, 去重: true);
			UnitBlueprint val29 = 游戏内容工具.复制单位("红魔鬼", (UnitBlueprint)null, val3, (Sprite)null, (DatabaseID?)new DatabaseID(-3, 332534278));
			val29.forceCost = uint.MaxValue;
			GameObject val30 = 游戏内容工具.注册能力(游戏物品加入.Instance.创建物品("一键清除所有单位asda", val.LoadAsset<GameObject>("空白技能asdkjas"), new DatabaseID(-3, 435475345)));
			测试超级清除 测试超级清除 = val30.AddComponent<测试超级清除>();
			测试超级清除.清除特效 = val.LoadAsset<GameObject>("受难特效");
			测试超级清除.清除预制体 = val.LoadAsset<GameObject>("清除实例有音效");
			val29.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("抬手动作技能___1")),
				val30
			};
			val29.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("残缺熔岩单位"), 对象类.单位模型);
			val29.massMultiplier = 10f;
			val29.health = 3000f;
			val29.m_props = (GameObject[])(object)new GameObject[8]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_头部"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_插件2"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_毛发"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_肩部黑手"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_背部装饰1"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_背部装饰2"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_背部装饰3"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("怨恨的化身服饰_躯干黑手"), 对象类.服饰)
			};
			val29.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			UnitBlueprint val31 = 游戏内容工具.复制单位("UNIT_WUWEIZHANSHI", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("无畏战士图标asdf"), (DatabaseID?)new DatabaseID(-3, 332534280));
			val31.m_props = (GameObject[])(object)new GameObject[18]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_上衣2"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_大护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_头盔"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_小臂护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_弹药背包"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_手套"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_手雷挂件"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护大腿"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护肘1"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护肩"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护胸"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护臂"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护颈1"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_护颈2"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_裤子"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_面罩"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_胯部护甲"), 对象类.服饰),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("无畏战士服饰_鞋子43"), 对象类.服饰)
			};
			val31.sizeMultiplier = 1.6f;
			val31.massMultiplier = 60f;
			val31.health = 4000f;
			GameObject val32 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("加特林_MiNiGatling333"), 对象类.武器);
			((Weapon)val32.GetComponent<RangeWeapon>()).maxRange = 30f;
			val31.RightWeapon = val32;
			val31.holdinigWithTwoHands = true;
			val31.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepRangedDistance) };
			val31.stepMultiplier = 3f;
			val31.movementSpeedMuiltiplier = 1.6f;
			val31.damageMultiplier = 2f;
			val31.forceCost = 15000u;
			val31.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow", 1f, "Footsteps/IceGiant");
			添加单位到指定派系(val31, 指定派系, 自动排序: true, 去重: true);
			for (int k = 0; k < array.Length; k++)
			{
				if (((Object)array[k]).name.StartsWith("WuWeiZhanShiMats_"))
				{
					材质修复工具.调整颜色亮度(array[k], 1.4f);
				}
			}
			UnitBlueprint val33 = 游戏内容工具.复制单位("简易的房子", (UnitBlueprint)null, val3, (Sprite)null, (DatabaseID?)new DatabaseID(-3, 332534281));
			val33.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("房子32234234"), 对象类.单位模型);
			val33.excludeFromWinCondition = true;
			val33.targetingPriorityMultiplier = 0.0001f;
			val33.health = float.PositiveInfinity;
			UnitBlueprint val34 = 游戏内容工具.复制单位("UNIT_WOLIBEIER", (UnitBlueprint)null, (Faction)null, val.LoadAsset<Sprite>("生成沃利贝尔图222标"), (DatabaseID?)new DatabaseID(-3, 332534282));
			val34.UnitBase = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("沃利贝尔模型sdjhs"), 对象类.单位模型);
			val34.RightWeapon = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("沃利贝尔拳击sdfjk"), 对象类.武器);
			val34.LeftWeapon = val34.RightWeapon;
			val34.holdinigWithTwoHands = false;
			val34.sizeMultiplier = 2f;
			val34.health = 3000f;
			val34.massMultiplier = 10f;
			val34.movementSpeedMuiltiplier = 1.6f;
			val34.stepMultiplier = 1.4f;
			val34.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2]
			{
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天声雷落sd")),
				注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("召唤雷电32d"))
			};
			val34.forceCost = 10000u;
			val34.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
			添加单位到指定派系(val34, 指定派系2, 自动排序: true, 去重: true);
			Faction 所属派系 = 游戏内容工具.创建派系("UNIT_TIANTazhu", null, val.LoadAsset<Sprite>("天_塔_柱icon"), -4, 49582394);
			GameObject unitBase3 = 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天踏著dsfj"), 对象类.单位模型);
			UnitBlueprint val35 = 游戏内容工具.复制单位("UNIT_LIANYUTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534283));
			val35.UnitBase = unitBase3;
			val35.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_炼狱")) };
			设置装饰单位(val35);
			UnitBlueprint val36 = 游戏内容工具.复制单位("UNIT_YANJIANGLEIWENTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534284));
			val36.UnitBase = unitBase3;
			val36.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_岩浆裂纹")) };
			设置装饰单位(val36);
			UnitBlueprint val37 = 游戏内容工具.复制单位("UNIT_RIYAOYANJIANGTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534285));
			val37.UnitBase = unitBase3;
			val37.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_日耀岩浆")) };
			设置装饰单位(val37);
			UnitBlueprint val38 = 游戏内容工具.复制单位("UNIT_HUNDUNTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534286));
			val38.UnitBase = unitBase3;
			val38.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_混沌")) };
			设置装饰单位(val38);
			UnitBlueprint val39 = 游戏内容工具.复制单位("UNIT_FANXINGTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534287));
			val39.UnitBase = unitBase3;
			val39.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_繁星")) };
			设置装饰单位(val39);
			UnitBlueprint val40 = 游戏内容工具.复制单位("UNIT_HEIANFANXINGTIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534288));
			val40.UnitBase = unitBase3;
			val40.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_黑暗繁星")) };
			设置装饰单位(val40);
			UnitBlueprint val41 = 游戏内容工具.复制单位("UNIT_SHAMOHUANJINGzhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534289));
			val41.UnitBase = unitBase3;
			val41.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("热浪生成技能")) };
			设置装饰单位(val41);
			UnitBlueprint val42 = 游戏内容工具.复制单位("UNIT_TIANHEILE_TIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534290));
			val42.UnitBase = unitBase3;
			val42.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("技能_天黑了_兵编勿用")) };
			设置装饰单位(val42);
			UnitBlueprint val43 = 游戏内容工具.复制单位("UNIT_SANTISHIJIETIANTazhu", (UnitBlueprint)null, 所属派系, val.LoadAsset<Sprite>("天_塔_柱icon"), (DatabaseID?)new DatabaseID(-3, 332534291));
			val43.UnitBase = unitBase3;
			val43.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[1] { 注册创建游戏对象自动id分配(val.LoadAsset<GameObject>("天空盒替换技能_三体世界")) };
			设置装饰单位(val43);
			List<UnitBlueprint> list = new List<UnitBlueprint>();
			UnitBlueprint[] units = val3.Units;
			foreach (UnitBlueprint item in units)
			{
				list.Add(item);
			}
			list.Sort((UnitBlueprint unit1, UnitBlueprint unit2) => unit1.GetUnitCost(true).CompareTo(unit2.GetUnitCost(true)));
			val3.Units = list.ToArray();
		}

		public static GameObject 注册创建游戏对象自动id分配(GameObject 对象, 对象类 类型 = 对象类.技能)
		{
			//IL_001d: 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_00a1: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			switch (类型)
			{
			case 对象类.技能:
			{
				GameObject result5 = 游戏内容工具.注册能力(游戏物品加入.Instance.创建物品(((Object)对象).name, 对象, new DatabaseID(-3, MYmodid)));
				MYmodid++;
				return result5;
			}
			case 对象类.服饰:
			{
				GameObject result4 = 游戏内容工具.注册道具(游戏物品加入.Instance.创建物品(((Object)对象).name, 对象, new DatabaseID(-3, MYmodid)));
				MYmodid++;
				return result4;
			}
			case 对象类.抛射物:
			{
				GameObject result3 = 游戏内容工具.注册投射物(游戏物品加入.Instance.创建物品(((Object)对象).name, 对象, new DatabaseID(-3, MYmodid)));
				MYmodid++;
				return result3;
			}
			case 对象类.单位模型:
			{
				GameObject result2 = 游戏内容工具.注册单位Base(游戏物品加入.Instance.创建物品(((Object)对象).name, 对象, new DatabaseID(-3, MYmodid)));
				MYmodid++;
				return result2;
			}
			case 对象类.武器:
			{
				GameObject result = 游戏内容工具.注册武器(游戏物品加入.Instance.创建物品(((Object)对象).name, 对象, new DatabaseID(-3, MYmodid)));
				MYmodid++;
				return result;
			}
			default:
				return null;
			}
		}

		public static void 添加单位到指定派系(UnitBlueprint[] 指定的所有单位, Faction 指定派系, bool 自动排序 = false, bool 去重 = false)
		{
			if (指定的所有单位 == null || 指定的所有单位.Length == 0)
			{
				return;
			}
			List<UnitBlueprint> list = new List<UnitBlueprint>();
			if (指定派系.Units != null)
			{
				list.AddRange(指定派系.Units);
			}
			list.AddRange(指定的所有单位);
			if (去重)
			{
				list = (from unit in list
					where ((unit != null) ? unit.Entity : null) != null
					group unit by unit.Entity.GUID into @group
					select @group.First()).ToList();
			}
			if (自动排序)
			{
				list.Sort((UnitBlueprint unit1, UnitBlueprint unit2) => unit1.GetUnitCost(true).CompareTo(unit2.GetUnitCost(true)));
			}
			指定派系.Units = list.ToArray();
		}

		public static void 添加单位到指定派系(UnitBlueprint 指定单位, Faction 指定派系, bool 自动排序 = false, bool 去重 = false)
		{
			if (!((Object)(object)指定单位 == (Object)null))
			{
				添加单位到指定派系((UnitBlueprint[])(object)new UnitBlueprint[1] { 指定单位 }, 指定派系, 自动排序, 去重);
			}
		}

		public static void 设置装饰单位(UnitBlueprint d)
		{
			d.excludeFromWinCondition = true;
			d.targetingPriorityMultiplier = 0.0001f;
			d.health = float.PositiveInfinity;
			d.forceCost = 170298124u;
			d.SetUnitSounds("Misc Attack Vocals/Crow", "Misc Attack Vocals/Crow");
		}
	}
	public class 游戏物品加入
	{
		private GameObject 物品对象池;

		private static 游戏物品加入 _instance;

		public static 游戏物品加入 Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new 游戏物品加入();
				}
				return _instance;
			}
		}

		private 游戏物品加入()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			Debug.Log((object)"开始创建对象池");
			物品对象池 = new GameObject
			{
				hideFlags = (HideFlags)61
			};
			((Object)物品对象池).name = "HeMoDingDingObject";
			物品对象池.SetActive(false);
			Debug.Log((object)"对象池创建完毕");
		}

		public GameObject 创建物品(string 名字, GameObject 要复制的物体, DatabaseID 物体标识, Sprite icon = null)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)"开始创建物品");
			GameObject val = Object.Instantiate<GameObject>(要复制的物体, 物品对象池.transform);
			((Object)val).hideFlags = (HideFlags)52;
			SetHideFlagsRecursive(val, (HideFlags)52);
			((Object)val).name = 名字 + Assembly.GetCallingAssembly().GetName().Name;
			IDatabaseEntity componentInChildren = val.GetComponentInChildren<IDatabaseEntity>();
			if (componentInChildren != null)
			{
				CharacterItem val2 = (CharacterItem)(object)((componentInChildren is CharacterItem) ? componentInChildren : null);
				componentInChildren.Entity.GUID = 物体标识;
				componentInChildren.Entity.Name = 名字;
				if ((Object)(object)icon != (Object)null)
				{
					componentInChildren.Entity.SpriteIcon = icon;
				}
			}
			Debug.Log((object)("物品创建完毕" + ((Object)val).name));
			return val;
		}

		private void SetHideFlagsRecursive(GameObject obj, HideFlags flags)
		{
			//IL_000f: 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_0031: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)obj == (Object)null)
			{
				return;
			}
			((Object)obj).hideFlags = flags;
			foreach (Transform item in obj.transform)
			{
				Transform val = item;
				if ((Object)(object)val != (Object)null)
				{
					SetHideFlagsRecursive(((Component)val).gameObject, flags);
				}
			}
		}
	}
	public static class 游戏内容工具
	{
		private static LandfallContentDatabase 内容数据库 => ContentDatabase.Instance().LandfallContentDatabase;

		private static AssetLoader 资源加载器 => ContentDatabase.Instance().AssetLoader;

		private static Dictionary<DatabaseID, Object> 非流式资源字典 => (Dictionary<DatabaseID, Object>)(typeof(AssetLoader).GetField("m_nonStreamableAssets", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(资源加载器));

		public static GameObject 注册单位Base(GameObject 单位基础)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return 注册游戏对象到数据库(单位基础, 单位基础.GetComponent<Unit>().Entity.GUID, "m_unitBases", (GameObject db) => db.GetComponent<Unit>().Entity.GUID);
		}

		public static GameObject 注册武器(GameObject 武器对象)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return 注册游戏对象到数据库(武器对象, ((CharacterItem)武器对象.GetComponent<WeaponItem>()).Entity.GUID, "m_weapons", (GameObject obj) => ((CharacterItem)obj.GetComponent<WeaponItem>()).Entity.GUID);
		}

		public static GameObject 注册能力(GameObject 能力对象)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return 注册游戏对象到数据库(能力对象, ((CharacterItem)能力对象.GetComponent<SpecialAbility>()).Entity.GUID, "m_combatMoves", (GameObject obj) => ((CharacterItem)obj.GetComponent<SpecialAbility>()).Entity.GUID);
		}

		public static GameObject 注册投射物(GameObject 投射物对象)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return 注册游戏对象到数据库(投射物对象, 投射物对象.GetComponent<ProjectileEntity>().Entity.GUID, "m_projectiles", (GameObject obj) => obj.GetComponent<ProjectileEntity>().Entity.GUID);
		}

		public static GameObject 注册道具(GameObject 道具对象)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return 注册游戏对象到数据库(道具对象, ((CharacterItem)道具对象.GetComponent<PropItem>()).Entity.GUID, "m_characterProps", (GameObject obj) => ((CharacterItem)obj.GetComponent<PropItem>()).Entity.GUID);
		}

		private static GameObject 注册游戏对象到数据库(GameObject 游戏对象, DatabaseID 对象ID, string 数据库字段名, Func<GameObject, DatabaseID> 获取ID函数)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			Dictionary<DatabaseID, GameObject> dictionary = 获取字典<GameObject>(数据库字段名);
			if (!dictionary.ContainsKey(对象ID))
			{
				dictionary.Add(对象ID, 游戏对象);
				非流式资源字典.Add(对象ID, (Object)(object)游戏对象);
				设置字典值<GameObject>(数据库字段名, dictionary);
			}
			return 游戏对象;
		}

		public static UnitBlueprint 获取原版单位蓝图(DatabaseID id)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<DatabaseID, UnitBlueprint> dictionary = 获取字典<UnitBlueprint>("m_unitBlueprints");
			UnitBlueprint value;
			return dictionary.TryGetValue(id, out value) ? value : null;
		}

		public static Faction 获取原版派系(DatabaseID id)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<DatabaseID, Faction> dictionary = 获取字典<Faction>("m_factions");
			Faction value;
			return dictionary.TryGetValue(id, out value) ? value : null;
		}

		public static UnitBlueprint 复制单位(string 名称, UnitBlueprint 源单位蓝图 = null, Faction 所属派系 = null, Sprite 图标 = null, DatabaseID? 自定义ID = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)源单位蓝图 == (Object)null)
			{
				源单位蓝图 = 获取原版单位蓝图(new DatabaseID(-1, 1166250463));
			}
			if ((Object)(object)源单位蓝图 == (Object)null)
			{
				Debug.LogError((object)"无法获取源单位蓝图");
				return null;
			}
			Debug.LogWarning((object)"开始创建蓝图");
			UnitBlueprint val = Object.Instantiate<UnitBlueprint>(源单位蓝图);
			val.Entity.GUID = (DatabaseID)(((??)自定义ID) ?? DatabaseID.NewID());
			val.Entity.Name = 名称;
			((Object)val).name = 名称;
			if ((Object)(object)图标 != (Object)null)
			{
				val.Entity.SpriteIcon = 图标;
			}
			Debug.LogWarning((object)"完成蓝图创建并指定ID");
			Dictionary<DatabaseID, UnitBlueprint> dictionary = 获取字典<UnitBlueprint>("m_unitBlueprints");
			if (!dictionary.ContainsKey(val.Entity.GUID))
			{
				非流式资源字典.Add(val.Entity.GUID, (Object)(object)val);
				dictionary.Add(val.Entity.GUID, val);
				设置字典值<UnitBlueprint>("m_unitBlueprints", dictionary);
				Debug.LogWarning((object)"成功添加到数据库");
			}
			if ((Object)(object)所属派系 != (Object)null && (Object)(object)val != (Object)null)
			{
				List<UnitBlueprint> list = 所属派系.Units?.ToList() ?? new List<UnitBlueprint>();
				if (!list.Contains(val))
				{
					list.Add(val);
					所属派系.Units = list.ToArray();
				}
			}
			return val;
		}

		public static Faction 创建派系(string 名称, UnitBlueprint[] 单位列表 = null, Sprite 图标 = null, int 模组ID = 0, int 派系ID = 0)
		{
			//IL_001b: 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_0083: 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_00b3: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			Faction val = ScriptableObject.CreateInstance<Faction>();
			val.Init();
			val.Entity.GUID = (DatabaseID)((模组ID != 0 && 派系ID != 0) ? new DatabaseID(模组ID, 派系ID) : DatabaseID.NewID());
			val.Entity.Name = 名称;
			((Object)val).name = 名称;
			val.Units = (UnitBlueprint[])(((object)单位列表) ?? ((object)new UnitBlueprint[0]));
			if ((Object)(object)图标 != (Object)null)
			{
				val.Entity.SpriteIcon = 图标;
			}
			Dictionary<DatabaseID, Faction> dictionary = 获取字典<Faction>("m_factions");
			if (!dictionary.ContainsKey(val.Entity.GUID))
			{
				非流式资源字典.Add(val.Entity.GUID, (Object)(object)val);
				dictionary.Add(val.Entity.GUID, val);
				List<DatabaseID> list = 获取默认快捷栏派系ID列表();
				if (!list.Contains(val.Entity.GUID))
				{
					list.Add(val.Entity.GUID);
					排序并设置默认快捷栏列表(list, dictionary);
				}
				设置字典值<Faction>("m_factions", dictionary);
			}
			return val;
		}

		private static Dictionary<DatabaseID, T> 获取字典<T>(string 字段名) where T : Object
		{
			return (Dictionary<DatabaseID, T>)(typeof(LandfallContentDatabase).GetField(字段名, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(内容数据库));
		}

		private static void 设置字典值<T>(string 字段名, Dictionary<DatabaseID, T> 字典) where T : Object
		{
			typeof(LandfallContentDatabase).GetField(字段名, BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(内容数据库, 字典);
		}

		private static List<DatabaseID> 获取默认快捷栏派系ID列表()
		{
			return (List<DatabaseID>)(typeof(LandfallContentDatabase).GetField("m_defaultHotbarFactionIds", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(内容数据库));
		}

		private static void 排序并设置默认快捷栏列表(List<DatabaseID> 列表, Dictionary<DatabaseID, Faction> 派系字典)
		{
			Faction value2;
			List<DatabaseID> value = 列表.OrderBy((DatabaseID id) => 派系字典.TryGetValue(id, out value2) ? value2.index : int.MaxValue).ToList();
			typeof(LandfallContentDatabase).GetField("m_defaultHotbarFactionIds", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(内容数据库, value);
		}
	}
	public static class 获取工具
	{
		private static LandfallContentDatabase 内容数据库 => ContentDatabase.Instance().LandfallContentDatabase;

		private static AssetLoader 资源加载器 => ContentDatabase.Instance().AssetLoader;

		private static Dictionary<DatabaseID, Object> 非流式资源字典 => (Dictionary<DatabaseID, Object>)(typeof(AssetLoader).GetField("m_nonStreamableAssets", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(资源加载器));

		private static Dictionary<DatabaseID, T> 获取字典<T>(string 字段名) where T : Object
		{
			return (Dictionary<DatabaseID, T>)(typeof(LandfallContentDatabase).GetField(字段名, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(内容数据库));
		}

		public static GameObject 获取原版内容游戏物品(string 字典名, DatabaseID id)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return 获取字典<GameObject>(字典名)[id];
		}
	}
}
namespace HeMoDingDingMod.角色类.英雄联盟.沃利贝尔
{
	[DisallowMultipleComponent]
	public class 描边添加器 : MonoBehaviour
	{
		[Header("描边设置")]
		[ColorUsage(true, true)]
		public Color 描边颜色 = Color.black;

		[Range(0f, 0.1f)]
		public float 描边宽度 = 0.02f;

		[Range(-0.01f, 0.01f)]
		public float 描边深度偏移 = -0.001f;

		[Tooltip("留空则自动查找 Custom/描边着色器Outline；也可以直接拖入指定的 Shader")]
		public Shader 指定着色器;

		[Tooltip("运行时自动应用（也可以在编辑器里点 Apply）")]
		public bool 启动时应用 = true;

		private Material _描边材质;

		private readonly List<Renderer> _受影响的渲染器 = new List<Renderer>();

		public bool 描边是否开启 { get; private set; }

		private void Start()
		{
			if (启动时应用)
			{
				应用();
			}
		}

		public void 设置描边开关(bool 开启)
		{
			if (开启)
			{
				应用();
			}
			else
			{
				移除描边();
			}
		}

		public void 切换描边()
		{
			设置描边开关(!描边是否开启);
		}

		public static void 设置描边(GameObject 目标, bool 开启)
		{
			if (!((Object)(object)目标 == (Object)null))
			{
				描边添加器 描边添加器2 = 目标.GetComponent<描边添加器>();
				if ((Object)(object)描边添加器2 == (Object)null)
				{
					描边添加器2 = 目标.AddComponent<描边添加器>();
					描边添加器2.启动时应用 = false;
				}
				描边添加器2.设置描边开关(开启);
			}
		}

		[ContextMenu("应用描边")]
		public void 应用()
		{
			//IL_0075: 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_0057: Expected O, but got Unknown
			if ((Object)(object)_描边材质 == (Object)null)
			{
				Shader val = 指定着色器;
				if ((Object)(object)val == (Object)null)
				{
					val = Shader.Find("Custom/描边着色器Outline");
				}
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogError((object)"[描边应用器] 找不到 Shader：Custom/描边着色器Outline，请确认 Outline.shader 已导入，或在“指定着色器”字段中手动指定。");
					return;
				}
				_描边材质 = new Material(val);
				((Object)_描边材质).name = "Outline (Runtime)";
			}
			_描边材质.SetColor("_OutlineColor", 描边颜色);
			_描边材质.SetFloat("_OutlineWidth", 描边宽度);
			_描边材质.SetFloat("_OutlineZOffset", 描边深度偏移);
			_受影响的渲染器.Clear();
			收集渲染器(((Component)this).transform.root, _受影响的渲染器);
			foreach (Renderer item in _受影响的渲染器)
			{
				List<Material> list = new List<Material>(item.sharedMaterials);
				bool flag = false;
				foreach (Material item2 in list)
				{
					if ((Object)(object)item2 != (Object)null && (Object)(object)item2.shader == (Object)(object)_描边材质.shader)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(_描边材质);
					item.sharedMaterials = list.ToArray();
				}
			}
			描边是否开启 = true;
		}

		[ContextMenu("移除描边")]
		public void 移除描边()
		{
			if ((Object)(object)_描边材质 == (Object)null)
			{
				描边是否开启 = false;
				return;
			}
			_受影响的渲染器.Clear();
			收集渲染器(((Component)this).transform.root, _受影响的渲染器);
			foreach (Renderer item in _受影响的渲染器)
			{
				List<Material> list = new List<Material>(item.sharedMaterials);
				int num = list.RemoveAll((Material 材质) => (Object)(object)材质 != (Object)null && (Object)(object)材质.shader == (Object)(object)_描边材质.shader);
				if (num > 0)
				{
					item.sharedMaterials = list.ToArray();
				}
			}
			描边是否开启 = false;
		}

		private void 收集渲染器(Transform 根节点, List<Renderer> 结果)
		{
			Renderer[] componentsInChildren = ((Component)根节点).GetComponentsInChildren<Renderer>();
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if (!(val is ParticleSystemRenderer) && !结果.Contains(val))
				{
					结果.Add(val);
				}
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_描边材质 != (Object)null)
			{
				Object.Destroy((Object)(object)_描边材质);
				_描边材质 = null;
			}
		}
	}
	public class 迅速绑定武器 : MonoBehaviour
	{
		public enum SyncMode
		{
			Once,
			Continuous,
			UntilGrabbed
		}

		[Header("同步设置")]
		[Tooltip("同步模式")]
		public SyncMode mode = SyncMode.Once;

		[Tooltip("是否在抓取后停止同步")]
		public bool stopWhenGrabbed = true;

		[Tooltip("同步频率（每秒）")]
		public float syncRate = 60f;

		private float syncTimer = 0f;

		private bool isGrabbed = false;

		private Holdable holdable;

		private Unit unit;

		[Header("调试")]
		public bool debugMode = false;

		private void Start()
		{
			unit = ((Component)((Component)this).transform.root).GetComponent<Unit>();
			holdable = ((Component)this).GetComponent<Holdable>();
			if (mode == SyncMode.Once)
			{
				SyncPosition();
				Object.Destroy((Object)(object)this);
			}
		}

		private void Update()
		{
			if ((Object)(object)unit == (Object)null || (Object)(object)holdable == (Object)null)
			{
				return;
			}
			if (stopWhenGrabbed && holdable.held)
			{
				if (!isGrabbed)
				{
					isGrabbed = true;
					if (debugMode)
					{
						Debug.Log((object)"武器已被抓取，停止同步");
					}
				}
				return;
			}
			syncTimer += Time.deltaTime;
			if (syncTimer >= 1f / syncRate)
			{
				syncTimer = 0f;
				if (mode == SyncMode.Continuous || (mode == SyncMode.UntilGrabbed && !holdable.held))
				{
					SyncPosition();
				}
			}
		}

		public void SyncPosition()
		{
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)unit == (Object)null)
			{
				return;
			}
			WeaponHandler weaponHandler = unit.WeaponHandler;
			if ((Object)(object)weaponHandler == (Object)null)
			{
				return;
			}
			bool flag = (Object)(object)weaponHandler.rightWeapon != (Object)null && (Object)(object)((Component)this).gameObject == (Object)(object)((Component)weaponHandler.rightWeapon).gameObject;
			bool flag2 = (Object)(object)weaponHandler.leftWeapon != (Object)null && (Object)(object)((Component)this).gameObject == (Object)(object)((Component)weaponHandler.leftWeapon).gameObject;
			Transform val = null;
			Transform val2 = null;
			if (flag && (Object)(object)unit.data.rightHand != (Object)null)
			{
				val = unit.data.rightHand;
				val2 = GetGripPoint(isRight: true);
			}
			else if (flag2 && (Object)(object)unit.data.leftHand != (Object)null)
			{
				val = unit.data.leftHand;
				val2 = GetGripPoint(isRight: false);
			}
			if (!((Object)(object)val == (Object)null))
			{
				Vector3 position;
				if ((Object)(object)val2 != (Object)null)
				{
					Vector3 val3 = val2.position - ((Component)this).transform.position;
					position = val.position - val3;
				}
				else
				{
					position = val.position;
				}
				((Component)this).transform.position = position;
				if ((Object)(object)val2 != (Object)null)
				{
					Quaternion val4 = val2.rotation * Quaternion.Inverse(((Component)this).transform.rotation);
					((Component)this).transform.rotation = val.rotation * val4;
				}
				else
				{
					((Component)this).transform.rotation = val.rotation;
				}
			}
		}

		private Transform GetGripPoint(bool isRight)
		{
			if (isRight)
			{
				HandRight componentInChildren = ((Component)this).GetComponentInChildren<HandRight>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					return ((Component)componentInChildren).transform;
				}
			}
			else
			{
				HandLeft componentInChildren2 = ((Component)this).GetComponentInChildren<HandLeft>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					return ((Component)componentInChildren2).transform;
				}
			}
			Transform val = ((Component)this).transform.Find("GripPoint");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			val = ((Component)this).transform.Find("Handle");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			return null;
		}
	}
	public class 近战切换生成物体 : MonoBehaviour
	{
		public MeleeWeaponSpawn 指定类;

		public void 切换(GameObject 指定)
		{
			指定类.objectToSpawn = 指定;
		}
	}
	public class 武器增加攻速 : MonoBehaviour
	{
		public Weapon 指定类;

		public void 执行cd(float cd)
		{
			指定类.internalCooldown = cd;
		}
	}
	public class 单位加速脚本 : MonoBehaviour
	{
		public MovementHandler 指定类;

		private float 初始乘数;

		private void Start()
		{
			指定类 = ((Component)((Component)this).transform.root).GetComponentInChildren<MovementHandler>();
			初始乘数 = 指定类.multiplier;
		}

		public void 执行cd(float 速度)
		{
			指定类.multiplier = 速度;
		}

		public void 回到初始速度()
		{
			指定类.multiplier = 初始乘数;
		}
	}
	public class 连锁闪电脚本 : MonoBehaviour
	{
		public LineRenderer 闪电线渲染器;

		public float 闪电伤害;

		public int 连锁次数;

		public float 每次连锁间隔;

		public float 闪电抖动幅度;

		[Header("每两个记录点之间小点的间隔距离")]
		public float 小点间隔距离 = 0.5f;

		[Header("最大连锁距离")]
		public float 最大连锁距离 = 8f;

		[Header("抖动刷新间隔（秒）")]
		public float 抖动间隔 = 0.1f;

		public GameObject 连锁位置生成预制体;

		private TeamHolder 队伍系统;

		private Team 队伍标识;

		private Vector3 目标定位器;

		private float 当前连锁次数 = 0f;

		private readonly List<Transform> 记录点 = new List<Transform>();

		private readonly HashSet<DataHandler> 已命中目标 = new HashSet<DataHandler>();

		private readonly List<GameObject> 已生成预制体 = new List<GameObject>();

		private readonly List<Vector3> 顶点缓存 = new List<Vector3>();

		private Coroutine 连锁协程;

		private bool 正在连锁 = false;

		private float 抖动计时 = 0f;

		private bool 需要立即刷新 = false;

		private void Start()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			队伍系统 = ((Component)this).GetComponentInParent<TeamHolder>();
			队伍标识 = 队伍系统.team;
			目标定位器 = ((Component)this).transform.position;
			记录点.Clear();
			记录点.Add(((Component)this).transform);
		}

		private void Update()
		{
			if (正在连锁)
			{
				抖动计时 += Time.deltaTime;
				if (需要立即刷新 || 抖动计时 >= 抖动间隔)
				{
					抖动计时 = 0f;
					需要立即刷新 = false;
					刷新闪电线();
				}
			}
		}

		private List<DataHandler> 获取全部敌方数据()
		{
			//IL_0040: 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)
			List<Unit> list = 场内单位存储器.GetAliveUnits().ToList();
			List<DataHandler> list2 = new List<DataHandler>();
			if (list.Count > 0)
			{
				foreach (Unit item in list)
				{
					if ((Object)(object)item != (Object)null && item.Team != 队伍标识)
					{
						list2.Add(item.data);
					}
				}
			}
			return list2;
		}

		private DataHandler 获取最近单位(List<DataHandler> 全部敌方数据, Vector3 目标位置)
		{
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			if (全部敌方数据 == null || 全部敌方数据.Count == 0)
			{
				return null;
			}
			DataHandler result = null;
			float num = float.MaxValue;
			for (int i = 0; i < 全部敌方数据.Count; i++)
			{
				DataHandler val = 全部敌方数据[i];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.mainRig == (Object)null) && !已命中目标.Contains(val))
				{
					Vector3 position = val.mainRig.position;
					Vector3 val2 = position - 目标位置;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = val;
					}
				}
			}
			return result;
		}

		private void 造成伤害(DataHandler 伤害目标, float 伤害)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			((Damagable)伤害目标.healthHandler).TakeDamage(伤害, 目标定位器, (Unit)null, (DamageType)0);
		}

		private bool 连锁一次()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_00a4: 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_00ab: 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_00e6: 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)
			if (当前连锁次数 >= (float)连锁次数)
			{
				return false;
			}
			Transform val = ((记录点.Count > 0) ? 记录点[记录点.Count - 1] : ((Component)this).transform);
			Vector3 val2 = (((Object)(object)val != (Object)null) ? val.position : 目标定位器);
			List<DataHandler> 全部敌方数据 = 获取全部敌方数据();
			DataHandler val3 = 获取最近单位(全部敌方数据, val2);
			if ((Object)(object)val3 == (Object)null || (Object)(object)val3.mainRig == (Object)null)
			{
				return false;
			}
			Vector3 position = val3.mainRig.position;
			float num = Vector3.Distance(val2, position);
			if (num > 最大连锁距离)
			{
				return false;
			}
			if ((Object)(object)连锁位置生成预制体 != (Object)null)
			{
				GameObject val4 = Object.Instantiate<GameObject>(连锁位置生成预制体, position, Quaternion.identity);
				TeamHolder.AddTeamHolder(val4, ((Component)this).gameObject);
				已生成预制体.Add(val4);
			}
			造成伤害(val3, 闪电伤害);
			已命中目标.Add(val3);
			记录点.Add(((Component)val3.mainRig).transform);
			当前连锁次数 += 1f;
			需要立即刷新 = true;
			return true;
		}

		private void 刷新闪电线()
		{
			//IL_004a: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00ba: 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_00be: 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)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_014e: 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)
			if ((Object)(object)闪电线渲染器 == (Object)null)
			{
				return;
			}
			顶点缓存.Clear();
			Vector3 val4 = default(Vector3);
			for (int i = 0; i < 记录点.Count; i++)
			{
				Transform val = 记录点[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Vector3 position = val.position;
				if (顶点缓存.Count == 0)
				{
					顶点缓存.Add(position);
					continue;
				}
				Vector3 val2 = (((Object)(object)记录点[i - 1] != (Object)null) ? 记录点[i - 1].position : 顶点缓存[顶点缓存.Count - 1]);
				float num = Vector3.Distance(val2, position);
				int num2 = ((!(小点间隔距离 > 0f)) ? 1 : Mathf.Max(1, Mathf.FloorToInt(num / 小点间隔距离)));
				for (int j = 1; j < num2; j++)
				{
					float num3 = (float)j / (float)num2;
					Vector3 val3 = Vector3.Lerp(val2, position, num3);
					((Vector3)(ref val4))..ctor(Random.Range(0f - 闪电抖动幅度, 闪电抖动幅度), Random.Range(0f - 闪电抖动幅度, 闪电抖动幅度), Random.Range(0f - 闪电抖动幅度, 闪电抖动幅度));
					顶点缓存.Add(val3 + val4);
				}
				顶点缓存.Add(position);
			}
			闪电线渲染器.positionCount = 顶点缓存.Count;
			闪电线渲染器.SetPositions(顶点缓存.ToArray());
		}

		public void 执行连锁()
		{
			if (连锁协程 != null)
			{
				((MonoBehaviour)this).StopCoroutine(连锁协程);
			}
			连锁协程 = ((MonoBehaviour)this).StartCoroutine(连锁流程());
		}

		private IEnumerator 连锁流程()
		{
			正在连锁 = true;
			抖动计时 = 0f;
			需要立即刷新 = true;
			for (int i = 0; i < 连锁次数; i++)
			{
				if (!连锁一次())
				{
					break;
				}
				if (每次连锁间隔 > 0f)
				{
					yield return (object)new WaitForSeconds(每次连锁间隔);
				}
			}
			if (每次连锁间隔 > 0f)
			{
				yield return (object)new WaitForSeconds(每次连锁间隔);
			}
			正在连锁 = false;
			if ((Object)(object)闪电线渲染器 != (Object)null)
			{
				yield return ((MonoBehaviour)this).StartCoroutine(线消散携程(0.3f));
			}
		}

		private IEnumerator 线消散携程(float 总时间)
		{
			float 起始宽度 = (((Object)(object)闪电线渲染器 != (Object)null) ? 闪电线渲染器.startWidth : 0f);
			float 结束宽度 = (((Object)(object)闪电线渲染器 != (Object)null) ? 闪电线渲染器.endWidth : 0f);
			float 计时 = 0f;
			while (计时 < 总时间)
			{
				计时 += Time.deltaTime;
				float t = Mathf.Clamp01(计时 / 总时间);
				if ((Object)(object)闪电线渲染器 != (Object)null)
				{
					闪电线渲染器.startWidth = Mathf.Lerp(起始宽度, 0f, t);
					闪电线渲染器.endWidth = Mathf.Lerp(结束宽度, 0f, t);
				}
				yield return null;
			}
			if ((Object)(object)闪电线渲染器 != (Object)null)
			{
				闪电线渲染器.positionCount = 0;
				闪电线渲染器.startWidth = 起始宽度;
				闪电线渲染器.endWidth = 结束宽度;
			}
			已生成预制体.Clear();
			记录点.Clear();
			已命中目标.Clear();
			当前连锁次数 = 0f;
		}
	}
}
namespace HeMoDingDingMod.角色类.至高神性
{
	public class 怨恨化身_普通技能 : MonoBehaviour
	{
		public Unit 此单位;

		public Team 队伍标识 = (Team)1;

		private void Start()
		{
			//IL_002d: 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)
			此单位 = ((Component)((Component)this).transform.root).GetComponent<Unit>();
			if (Object.op_Implicit((Object)(object)此单位))
			{
				队伍标识 = 此单位.Team;
			}
		}
	}
	public class 清除单例设置 : MonoBehaviour
	{
		private static 清除单例设置 _instance;

		private static bool _isClearing;

		public static 清除单例设置 Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("清除单例场景唯一");
					val.AddComponent<RemoveAfterSeconds>().seconds = 3f;
					_instance = val.AddComponent<清除单例设置>();
				}
				return _instance;
			}
		}

		public static bool IsClearing()
		{
			return _isClearing;
		}

		public static bool 开始清除()
		{
			if (_isClearing)
			{
				Debug.Log((object)"已有清除操作正在执行，跳过本次调用");
				return false;
			}
			_isClearing = true;
			清除单例设置 instance = Instance;
			((MonoBehaviour)instance).CancelInvoke("完成清除");
			((MonoBehaviour)instance).Invoke("完成清除", 5f);
			return true;
		}

		private void 完成清除()
		{
			Debug.Log((object)"5秒倒计时结束，清除操作完成");
			_isClearing = false;
			DestroySelf();
		}

		private void DestroySelf()
		{
			if ((Object)(object)_instance != (Object)null)
			{
				Debug.Log((object)"销毁清除单例");
				Object.Destroy((Object)(object)((Component)this).gameObject);
				_instance = null;
			}
		}