using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using DM;
using FhpSLib;
using HarmonyLib;
using Landfall.TABC;
using Landfall.TABS;
using Landfall.TABS.AI.Components;
using Landfall.TABS.AI.Components.Modifiers;
using Landfall.TABS.UnitEditor;
using SLMA;
using TFBGames;
using TIComponents;
using TechnicalItems;
using Unity.Entities;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("TechnicalItems")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("GeeztJeez")]
[assembly: AssemblyProduct("TechnicalItems")]
[assembly: AssemblyCopyright("Copyright © 4Ever")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("7acfaef0-7669-4401-8bff-5a9a02e18c75")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.13.0")]
[module: UnverifiableCode]
namespace TechnicalItems
{
	public static class UManager
	{
		public class Utility : MonoBehaviour
		{
			public static class ItemCategorizer
			{
				public static void SetTag(GameObject item, string categoryName = "Technical Items", TagType tagType = 0)
				{
					//IL_00ab: 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_00b4: 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)
					try
					{
						if ((Object)(object)item == (Object)null)
						{
							Debug.LogWarning((object)"[SetTag] Provided item is null.");
							return;
						}
						CharacterItem componentInChildren = item.GetComponentInChildren<CharacterItem>();
						if ((Object)(object)componentInChildren == (Object)null)
						{
							Debug.LogWarning((object)"[SetTag] CharacterItem not found in children.");
							return;
						}
						if (componentInChildren.tags == null)
						{
							componentInChildren.tags = new List<Tag>();
						}
						string uniqueValue = categoryName;
						int num = 0;
						while (componentInChildren.tags.Exists((Tag tag) => tag.value == uniqueValue))
						{
							num++;
							uniqueValue = $"{categoryName}_{num}";
							if (num > 999999)
							{
								Debug.LogError((object)"[SetTag] Failed to generate a unique tag value after 999999 attempts.");
								return;
							}
						}
						componentInChildren.tags.Add(new Tag
						{
							tagType = tagType,
							value = uniqueValue
						});
					}
					catch (Exception ex)
					{
						Debug.LogError((object)("[SetTag] Exception occurred: " + ex.Message));
					}
				}
			}

			private static Dictionary<DatabaseID, GameObject> CombatMoves
			{
				get
				{
					Dictionary<DatabaseID, GameObject> dictionary = HelpLibrary.m_combatMoves;
					if (dictionary == null)
					{
						dictionary = (HelpLibrary.m_combatMoves = new Dictionary<DatabaseID, GameObject>());
					}
					return dictionary;
				}
			}

			private static Dictionary<DatabaseID, GameObject> CharacterProps
			{
				get
				{
					Dictionary<DatabaseID, GameObject> dictionary = HelpLibrary.m_characterProps;
					if (dictionary == null)
					{
						dictionary = (HelpLibrary.m_characterProps = new Dictionary<DatabaseID, GameObject>());
					}
					return dictionary;
				}
			}

			public static Sprite Image2Sprite(string name)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Expected O, but got Unknown
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name);
				Texture2D val = new Texture2D(4, 4);
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, (int)stream.Length);
				((Texture)val).filterMode = (FilterMode)0;
				ImageConversion.LoadImage(val, array);
				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 LoadBundleTextureToSprite(string name)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				//IL_0031: 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)
				Texture2D val = (Texture2D)bundle.LoadAsset(name);
				((Texture)val).filterMode = (FilterMode)0;
				return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
			}

			public static GameObject LoadBundleGameObject(string name)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (GameObject)bundle.LoadAsset(name);
			}

			public static int IDChecker(assetType type, int startId = 1)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				int num = Math.Max(1, startId);
				DatabaseID id = default(DatabaseID);
				((DatabaseID)(ref id))..ctor(num);
				while (IsOccupied(id))
				{
					Debug.LogWarning((object)$"[IDChecker] ID {num} in use, trying {num + 1}…");
					num++;
					((DatabaseID)(ref id))..ctor(num);
				}
				Debug.Log((object)$"[IDChecker] Found free ID: {num}");
				return num;
			}

			private static bool IsOccupied(DatabaseID id)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				if (!CombatMoves.ContainsKey(id))
				{
					return CharacterProps.ContainsKey(id);
				}
				return true;
			}
		}

		public enum assetType
		{
			Prop,
			Ability
		}

		public static string comment;

		public static AssetBundle bundle;

		public static void SetClothItems(GameObject cloth, CharacterItem item, PropItemData data, LandfallContentDatabase db)
		{
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleHead"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.Head;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleTorso"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.Torso;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleLegLeft"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.LegLeft;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleLegRight"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.LegRight;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleFootLeft"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.FootLeft;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleFootRight"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.FootRight;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleLeftHand"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.LeftHand;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleRightHand"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.RightHand;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleLeftArm"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.LeftArm;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleRightArm"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.RightArm;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RigScaleHip"))
			{
				cloth.AddComponent<SmartRigScaleSizing>().rigType = SmartRigScaleSizing.RigType.Hip;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleHead"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.Head;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleNeck"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.Neck;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleTorso"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.Torso;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleLegLeft"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.LegLeft;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleLegRight"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.LegRight;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleFootLeft"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.FootLeft;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleFootRight"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.FootRight;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleLeftHand"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.LeftHand;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleRightHand"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.RightHand;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleLeftArm"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.LeftArm;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleRightArm"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.RightArm;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("BodyPartScaleHip"))
			{
				cloth.AddComponent<SmartBodyPartScaleSizing>().rigType = SmartBodyPartScaleSizing.RigType.Hip;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartTransformationAmount"))
			{
				cloth.AddComponent<SmartTransformationAmountBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartTransformToRider"))
			{
				cloth.AddComponent<SmartTransformToRiderBehaviour>().particle = Utility.LoadBundleGameObject("E_EmptySpawnerPoof");
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartConnectedTransform"))
			{
				cloth.AddComponent<SmartConnectedTransformBehaviour>().particle = Utility.LoadBundleGameObject("E_EmptySpawnerPoof");
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("MoreRider"))
			{
				cloth.AddComponent<SmartMount>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitWeaponSoundManager"))
			{
				cloth.AddComponent<SmartSoundsManagerBehaviour>().soundType = SmartSoundsManagerBehaviour.SoundType.Weapons;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitVocalManager"))
			{
				cloth.AddComponent<SmartSoundsManagerBehaviour>().soundType = SmartSoundsManagerBehaviour.SoundType.Vocal;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartSFXManager"))
			{
				cloth.AddComponent<SmartSoundsManagerBehaviour>().soundType = SmartSoundsManagerBehaviour.SoundType.SFX;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartRangeDistance"))
			{
				cloth.AddComponent<SmartRangeDistanceBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartProjectileScaling"))
			{
				cloth.AddComponent<SmartProjectileScalingBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartMeleeKnockback"))
			{
				cloth.AddComponent<SmartMeleeKnockbackBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitDupe"))
			{
				cloth.AddComponent<SmartUnitDupeBehaviour>().abilityToRemove = UPool.MyPool.GetObject("SmartUnitDupe");
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartHealingItem"))
			{
				cloth.AddComponent<SmartHealingItemBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartMovingProp"))
			{
				cloth.AddComponent<SmartMovingPropBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitBalanceModifier"))
			{
				cloth.AddComponent<SmartUnitBalanceModifierBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartSummonRider"))
			{
				cloth.AddComponent<SmartSummonRiderBehaviour>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartConditionalEventManager"))
			{
				cloth.AddComponent<SmartConditionalEventManagerSet>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitRigidbodyLimiter"))
			{
				cloth.AddComponent<SmartUnitRigidbodyLimiterSet>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartUnitRigidbody"))
			{
				cloth.AddComponent<SmartUnitRigidbodySet>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartMeleeAddDash"))
			{
				cloth.AddComponent<AddSmartMeleeDash>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("ColorableProjParticle"))
			{
				cloth.AddComponent<ColorableProj>().MaterialChangeType = ColorableProj.ChangeType.Particle;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("ColorableProjModel"))
			{
				cloth.AddComponent<ColorableProj>().MaterialChangeType = ColorableProj.ChangeType.Model;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderBoxRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderBoxRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderBoxLeft"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderBoxHands"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderBoxLegs"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderBoxFeet"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderBoxArms"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderSphereRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderSphereRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderSphereLeft"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderSphereHands"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderSphereLegs"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderSphereFeet"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderSphereArms"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderPyramidRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderPyramidRight"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponPlaceholderPyramidLeft"))
			{
				cloth.AddComponent<DynamicPropWeapon>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderPyramidHands"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderPyramidLegs"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderPyramidFeet"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AddPlaceholderPyramidArms"))
			{
				cloth.AddComponent<DynamicPropSetup>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponScalingLeft"))
			{
				cloth.AddComponent<SmartWeaponScaling>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponScalingRight"))
			{
				cloth.AddComponent<SmartWeaponScaling>().right = true;
			}
			GameObject[] explosions = (GameObject[])(object)new GameObject[9]
			{
				Utility.LoadBundleGameObject("E_GroundExplosionTI"),
				Utility.LoadBundleGameObject("E_FireExplosionTI"),
				Utility.LoadBundleGameObject("E_IceExplosionTI"),
				Utility.LoadBundleGameObject("E_GunpowderExplosionTI"),
				Utility.LoadBundleGameObject("E_ThorHammerLightningExplosionTI"),
				Utility.LoadBundleGameObject("E_ReaperExplosionTI"),
				Utility.LoadBundleGameObject("E_ChronotimeExplosionTI"),
				Utility.LoadBundleGameObject("E_EFBluefireExplosionTI"),
				Utility.LoadBundleGameObject("E_EFEvilSwordExplosionTI")
			};
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartOnHitEffectAll"))
			{
				SmartOnHitEffect smartOnHitEffect = cloth.AddComponent<SmartOnHitEffect>();
				smartOnHitEffect.effectType = SmartOnHitEffect.EffectType.All;
				smartOnHitEffect.explosions = explosions;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartOnHitEffectWeapon"))
			{
				SmartOnHitEffect smartOnHitEffect2 = cloth.AddComponent<SmartOnHitEffect>();
				smartOnHitEffect2.effectType = SmartOnHitEffect.EffectType.Weapon;
				smartOnHitEffect2.explosions = explosions;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartOnHitEffectProj"))
			{
				SmartOnHitEffect smartOnHitEffect3 = cloth.AddComponent<SmartOnHitEffect>();
				smartOnHitEffect3.effectType = SmartOnHitEffect.EffectType.Projectile;
				smartOnHitEffect3.explosions = explosions;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartProjSetLeft"))
			{
				cloth.AddComponent<SmartProjSet>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartProjSetRight"))
			{
				cloth.AddComponent<SmartProjSet>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("ForcePointAddReaperScytheEffect"))
			{
				cloth.AddComponent<ForcePointAddReaperScytheEffect>().trailObject = Utility.LoadBundleGameObject("ReaperParticleTI");
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartLeftMeleeSet"))
			{
				cloth.AddComponent<SmartMeleeSet>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartRightMeleeSet"))
			{
				cloth.AddComponent<SmartMeleeSet>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartLeftRangedSet"))
			{
				cloth.AddComponent<SmartRangedSet>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartRightRangedSet"))
			{
				cloth.AddComponent<SmartRangedSet>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartLeftMagSet"))
			{
				cloth.AddComponent<SmartMagSet>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartRightMagSet"))
			{
				cloth.AddComponent<SmartMagSet>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponWeightingLeft"))
			{
				cloth.AddComponent<SmartWeaponRigidbodyChange>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponWeightingRight"))
			{
				cloth.AddComponent<SmartWeaponRigidbodyChange>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingUpRotationLeft"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange.right = false;
				smartWeaponHoldingChange.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.UpRotation;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingForwardRotationLeft"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange2 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange2.right = false;
				smartWeaponHoldingChange2.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.ForwardRotation;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingRelativePositionLeft"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange3 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange3.right = false;
				smartWeaponHoldingChange3.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.RelativePosition;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingUpRotationRight"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange4 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange4.right = true;
				smartWeaponHoldingChange4.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.UpRotation;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingForwardRotationRight"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange5 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange5.right = true;
				smartWeaponHoldingChange5.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.ForwardRotation;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("WeaponHoldingRelativePositionRight"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange6 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange6.right = true;
				smartWeaponHoldingChange6.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.RelativePosition;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponHoldableRight"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange7 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange7.right = true;
				smartWeaponHoldingChange7.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.HoldingStats;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SmartWeaponHoldableLeft"))
			{
				SmartWeaponHoldingChange smartWeaponHoldingChange8 = cloth.AddComponent<SmartWeaponHoldingChange>();
				smartWeaponHoldingChange8.right = false;
				smartWeaponHoldingChange8.holdingChangeType = SmartWeaponHoldingChange.HoldingChangeType.HoldingStats;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("ForceSkinChange"))
			{
				cloth.AddComponent<ForcedSkinnedChanges>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("MeleeTrailLeft"))
			{
				cloth.AddComponent<MeleeTrail>().right = false;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("MeleeTrailRight"))
			{
				cloth.AddComponent<MeleeTrail>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("SkinChanges"))
			{
				cloth.AddComponent<SkinnedChanges>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("AlwaysOpenedEyes"))
			{
				cloth.AddComponent<EyeKeepOpened>();
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RemoveRightWParticles"))
			{
				cloth.AddComponent<RemoveWeaponParticles>().right = true;
			}
			if ((Object)(object)cloth == (Object)(object)UPool.MyPool.GetObject("RemoveLeftWParticles"))
			{
				cloth.AddComponent<RemoveWeaponParticles>().right = false;
			}
		}

		public static void SetMovesItems(GameObject move, LandfallContentDatabase db)
		{
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			//IL_04e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Expected O, but got Unknown
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MovementComponentConfusedMovement"))
			{
				move.AddComponent<SwapMovementComponent>().newMovementType = SwapMovementComponent.MovementType.ConfusedMovement;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MovementComponentFleeDistance"))
			{
				move.AddComponent<SwapMovementComponent>().newMovementType = SwapMovementComponent.MovementType.FleeDistance;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MovementComponentKeepPreferredDistance"))
			{
				move.AddComponent<SwapMovementComponent>().newMovementType = SwapMovementComponent.MovementType.KeepPreferredDistance;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MovementComponentKeepRangedDistance"))
			{
				move.AddComponent<SwapMovementComponent>().newMovementType = SwapMovementComponent.MovementType.KeepRangedDistance;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MovementComponentNeverStopRunning"))
			{
				move.AddComponent<SwapMovementComponent>().newMovementType = SwapMovementComponent.MovementType.NeverStopRunning;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("UnitDisableFriendlyFire"))
			{
				move.AddComponent<UnitDisableFriendlyFireBehaviour>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("UnitTargetSelf"))
			{
				move.AddComponent<UnitTargetSelfBehaviour>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("DisableUnitOutline"))
			{
				move.AddComponent<DisableUnitOutlineBehaviour>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MeleeAddStick"))
			{
				move.AddComponent<MeleeAddStick>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MeleeHitFaster"))
			{
				move.AddComponent<MeleeHitFaster>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("SetProjHoming"))
			{
				move.AddComponent<ChangeProjectileHoming>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("UnbindVehicleHealth"))
			{
				move.AddComponent<BindSiegeHealth>().HealthBindType = BindSiegeHealth.BindType.UnbindVehicleHealth;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("UnbindRiderHealth"))
			{
				move.AddComponent<BindSiegeHealth>().HealthBindType = BindSiegeHealth.BindType.UnbindRiderHealth;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("BindVehicleHealth"))
			{
				move.AddComponent<BindSiegeHealth>().HealthBindType = BindSiegeHealth.BindType.BindVehicleHealth;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("BindRiderHealth"))
			{
				move.AddComponent<BindSiegeHealth>().HealthBindType = BindSiegeHealth.BindType.BindRiderHealth;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("KeepNormalUnitColorInstance"))
			{
				move.AddComponent<KeepNormalUnitColorInstance>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AbilityRemoveSound"))
			{
				move.AddComponent<AbilityRemoveSound>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("HideAbilityModel"))
			{
				move.AddComponent<AddDestroyAbilityChildRenderer>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("NullifyAllDelay"))
			{
				move.AddComponent<NullifyAllDelay>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("TornadoDisables"))
			{
				move.AddComponent<RemoveTurnado>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("NoFallDamage"))
			{
				move.AddComponent<NoFallDamage>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("StandStill"))
			{
				move.AddComponent<StandStill>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("FusionWithRider"))
			{
				move.AddComponent<GetAndDeleteRider>();
				move.AddComponent<FusionMechanic>();
				move.GetComponentInChildren<UnitSpawner>().destroyroot = false;
				move.GetComponentInChildren<UnitSpawner>().transferHp = false;
				move.GetComponentInChildren<UnitSpawner>().switchIfRanged = true;
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MeleeAddDissarm"))
			{
				move.AddComponent<AddMeleeDissarm>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("MeleeAddBlink"))
			{
				move.AddComponent<AddMeleeBlinks>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("WeaponSwapWhenBelowHalf"))
			{
				move.AddComponent<SwapDistanceHalf>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("WeaponSwapWhenTargetDistance"))
			{
				move.AddComponent<SwapDistanceBase>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AlwaysTansferHP"))
			{
				move.AddComponent<TransferHPEnable>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("NeverShowHealthBar"))
			{
				move.AddComponent<NeverShowHealthBar>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("TransformToRiderChronoCondition"))
			{
				move.AddComponent<GetAndDeleteRider>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("TransformToRiderDarkKingCondition"))
			{
				move.AddComponent<GetAndDeleteRider>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AdaptiveOrbCasting"))
			{
				SpookySwords componentInChildren = move.GetComponentInChildren<SpookySwords>();
				AdaptiveCast adaptiveCast = move.AddComponent<AdaptiveCast>();
				adaptiveCast.followSpeed = componentInChildren.followSpeed;
				adaptiveCast.throwSpeed = componentInChildren.throwSpeed;
				adaptiveCast.throwCurve = componentInChildren.throwCurve;
				adaptiveCast.attackRate = componentInChildren.attackRate;
				adaptiveCast.projToCopyCodeAnimation = (GameObject)SLMALoader.SDic["projectiles"]["E_Swordcastspell"];
				Object.Destroy((Object)(object)componentInChildren);
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AdaptiveSwordCasting"))
			{
				SpookySwords componentInChildren2 = move.GetComponentInChildren<SpookySwords>();
				AdaptiveCast adaptiveCast2 = move.AddComponent<AdaptiveCast>();
				adaptiveCast2.followSpeed = componentInChildren2.followSpeed;
				adaptiveCast2.throwSpeed = componentInChildren2.throwSpeed;
				adaptiveCast2.throwCurve = componentInChildren2.throwCurve;
				adaptiveCast2.attackRate = componentInChildren2.attackRate;
				adaptiveCast2.projToCopyCodeAnimation = (GameObject)SLMALoader.SDic["projectiles"]["E_Swordcastspell"];
				Object.Destroy((Object)(object)componentInChildren2);
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AdaptiveArrowVolley"))
			{
				move.AddComponent<AdaptiveThrow>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AdaptivePirateQueenThrow"))
			{
				move.AddComponent<AdaptiveThrow>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("AdaptiveSenseiBurstThrow"))
			{
				ParticleSystem[] componentsInChildren = move.GetComponentsInChildren<ParticleSystem>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].startSize = 1.6f;
				}
				move.AddComponent<AdaptiveBurst>();
			}
		}

		public static void Init(LandfallContentDatabase db)
		{
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Static Variable";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			LoadBundle("techitemsbundle");
			Sprite val = Utility.LoadBundleTextureToSprite("icon_technicalitems");
			GameObject val2 = Utility.LoadBundleGameObject("Move_EmptyAbility");
			GameObject val3 = Utility.LoadBundleGameObject("EmptyPropTechItem");
			GameObject val4 = Utility.LoadBundleGameObject("Move_EmptySpawner");
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Clothes";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleHead", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100967), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleTorso", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100968), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleLegLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100969), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleLegRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100970), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleFootLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100971), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleFootRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100972), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleLeftHand", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100973), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleRightHand", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100974), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleLeftArm", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100975), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleRightArm", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100976), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RigScaleHip", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100977), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleHead", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100978), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleNeck", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100979), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleTorso", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100980), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleLegLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100981), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleLegRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100982), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleFootLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100983), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleFootRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100984), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleLeftHand", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100985), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleRightHand", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100986), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleLeftArm", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100987), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleRightArm", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100988), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BodyPartScaleHip", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100989), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartOnHitEffectAll", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100990), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("ColorableProjModel", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100991), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("ColorableProjParticle", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100992), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("ForcePointAddReaperScytheEffect", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100993), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxHead", Utility.LoadBundleGameObject("AddPlaceholderBoxHead"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100994), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxNeck", Utility.LoadBundleGameObject("AddPlaceholderBoxNeck"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100995), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxTorso", Utility.LoadBundleGameObject("AddPlaceholderBoxTorso"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100997), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderBoxLeft", Utility.LoadBundleGameObject("AddPlaceholderBoxWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100996), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxArms", Utility.LoadBundleGameObject("AddPlaceholderBoxArms"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100998), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderBoxRight", Utility.LoadBundleGameObject("AddPlaceholderBoxWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10100999), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxHands", Utility.LoadBundleGameObject("AddPlaceholderBoxHands"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101001), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxWaist", Utility.LoadBundleGameObject("AddPlaceholderBoxWaist"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101002), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxLegs", Utility.LoadBundleGameObject("AddPlaceholderBoxLegs"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101003), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderBoxFeet", Utility.LoadBundleGameObject("AddPlaceholderBoxFeet"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101004), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("ForceSkinChange", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101005), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeTrailLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101006), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeTrailRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101007), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SkinChanges", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101008), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AlwaysOpenedEyes", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101009), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartOnHitEffectWeapon", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101010), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartOnHitEffectProj", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101011), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartMeleeAddDash", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101012), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitRigidbody", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101013), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitRigidbodyLimiter", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101014), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartConditionalEventManager", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101015), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartSummonRider", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101016), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitBalanceModifier", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101017), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartMovingProp", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101018), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartHealingItem", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101019), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitDupe", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101020), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartMeleeKnockback", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101021), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartProjectileScaling", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101022), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartRangeDistance", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101023), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitVocalManager", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101024), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartUnitWeaponSoundManager", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101025), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartSFXManager", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101026), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MoreRider", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101027), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartConnectedTransform", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101028), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartTransformToRider", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101029), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartTransformationAmount", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 10101030), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereHead", Utility.LoadBundleGameObject("AddPlaceholderSphereHead"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101031), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereNeck", Utility.LoadBundleGameObject("AddPlaceholderSphereNeck"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101032), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereTorso", Utility.LoadBundleGameObject("AddPlaceholderSphereTorso"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101033), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderSphereLeft", Utility.LoadBundleGameObject("AddPlaceholderSphereWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101034), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereArms", Utility.LoadBundleGameObject("AddPlaceholderSphereArms"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101035), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderSphereRight", Utility.LoadBundleGameObject("AddPlaceholderSphereWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101036), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereHands", Utility.LoadBundleGameObject("AddPlaceholderSphereHands"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101037), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereWaist", Utility.LoadBundleGameObject("AddPlaceholderSphereWaist"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101038), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereLegs", Utility.LoadBundleGameObject("AddPlaceholderSphereLegs"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101039), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderSphereFeet", Utility.LoadBundleGameObject("AddPlaceholderSphereFeet"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101040), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidHead", Utility.LoadBundleGameObject("AddPlaceholderPyramidHead"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101041), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidNeck", Utility.LoadBundleGameObject("AddPlaceholderPyramidNeck"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101042), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidTorso", Utility.LoadBundleGameObject("AddPlaceholderPyramidTorso"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101043), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderPyramidLeft", Utility.LoadBundleGameObject("AddPlaceholderPyramidWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101044), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidArms", Utility.LoadBundleGameObject("AddPlaceholderPyramidArms"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101045), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponPlaceholderPyramidRight", Utility.LoadBundleGameObject("AddPlaceholderPyramidWeapon"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101046), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidHands", Utility.LoadBundleGameObject("AddPlaceholderPyramidHands"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101047), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidWaist", Utility.LoadBundleGameObject("AddPlaceholderPyramidWaist"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101048), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidLegs", Utility.LoadBundleGameObject("AddPlaceholderPyramidLegs"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101049), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AddPlaceholderPyramidFeet", Utility.LoadBundleGameObject("AddPlaceholderPyramidFeet"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 10101050), true), "Technical Items", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Right Weapons";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponScalingRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101010), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RemoveRightWParticles", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101011), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponWeightingLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101017), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingUpRotationLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101018), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingForwardRotationLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101019), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingRelativePositionLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101020), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartRightMagSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101021), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartRightRangedSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101022), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartRightMeleeSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101023), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartProjSetRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101024), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponHoldableRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 40101025), true), "Technical Items", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Left Weapons";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponScalingLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 20101010), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("RemoveLeftWParticles", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 20202024), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponWeightingRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101017), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingUpRotationRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101018), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingForwardRotationRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101019), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponHoldingRelativePositionRight", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101020), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartLeftMagSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101021), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartLeftRangedSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101022), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartLeftMeleeSet", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101023), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartProjSetLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101024), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SmartWeaponHoldableLeft", val3, true, (HideFlags)52, val, Utility.IDChecker(assetType.Prop, 50101025), true), "Technical Items", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Technical Abilities";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("HideAbilityModel", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303001), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("TornadoDisables", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303003), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BindVehicleHealth", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303007), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("BindRiderHealth", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303008), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SetProjHoming", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303009), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("NoFallDamage", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303019), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("StandStill", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303020), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FusionWithRider", val4, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303021), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("UnitTargetSelf", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303023), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeAddDissarm", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303024), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeAddBlink", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303025), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponSwapWhenBelowHalf", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303026), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("WeaponSwapWhenTargetDistance", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303027), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AlwaysTansferHP", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303028), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("NeverShowHealthBar", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303029), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("TransformToRiderChronoCondition", Utility.LoadBundleGameObject("TransformToRiderChronoCondition"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303033), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("TransformToRiderDarkKingCondition", Utility.LoadBundleGameObject("TransformToRiderDarkKingCondition"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303034), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AdaptivePirateQueenThrow", Utility.LoadBundleGameObject("AdaptivePirateQueenThrow"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303038), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AdaptiveSenseiBurstThrow", Utility.LoadBundleGameObject("AdaptiveSenseiBurstThrow"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303035), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeAddStick", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303039), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("UnitDisableFriendlyFire", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303040), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("UnbindVehicleHealth", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303041), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("UnbindRiderHealth", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303042), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AdaptiveOrbCasting", Utility.LoadBundleGameObject("AdaptiveOrbCasting"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303043), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AdaptiveSwordCasting", Utility.LoadBundleGameObject("AdaptiveSwordCasting"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303044), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MeleeHitFaster", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303045), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AbilityRemoveSound", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303046), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("KeepNormalUnitColorInstance", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303047), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("NullifyAllDelay", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303048), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("DisableUnitOutline", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303051), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AdaptiveArrowVolley", Utility.LoadBundleGameObject("AdaptiveArrowVolley"), true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303052), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MovementComponentConfusedMovement", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303053), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MovementComponentFleeDistance", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303054), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MovementComponentKeepPreferredDistance", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303055), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MovementComponentKeepRangedDistance", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303056), true), "Technical Items", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("MovementComponentNeverStopRunning", val2, true, (HideFlags)52, val, Utility.IDChecker(assetType.Ability, 30303057), true), "Technical Items", (TagType)0);
		}

		public static void LoadBundle(string assetBundleName)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assetBundleName);
			bundle = AssetBundle.LoadFromStream(stream);
		}
	}
	[BepInPlugin("GeeztJeez.Technicalitems", "TechnicalItems", "1.0.13")]
	internal class Loader : BaseUnityPlugin
	{
		private void Awake()
		{
			((MonoBehaviour)this).StartCoroutine("Call");
		}

		private IEnumerator Call()
		{
			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));
			Debug.Log((object)"Loading TechnicalItems...");
			SLMALoader.GetInstance();
			LandfallContentDatabase landfallContentDatabase = ContentDatabase.Instance().LandfallContentDatabase;
			UManager.Init(landfallContentDatabase);
			new Harmony("TechnicalItems").PatchAll();
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<SpecialAbility>()))
				{
					UManager.SetMovesItems(array[i], landfallContentDatabase);
				}
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<PropItem>()))
				{
					UManager.SetClothItems(array[i], array[i].GetComponent<CharacterItem>(), array[i].GetComponent<PropItemData>(), landfallContentDatabase);
				}
			}
			Debug.Log((object)"Loaded TechnicalItems Successfully!");
		}
	}
}
namespace TIComponents
{
	public class AddVanillaCompatibility : MonoBehaviour
	{
		private void Start()
		{
			UManager.comment = "I tried, it was worth trying but didn't worth as much as having blood and extremely painful headache :(";
		}

		private void Update()
		{
			if (((Component)this).gameObject.tag.EndsWith("(TI)"))
			{
				Debug.Log((object)("Verified Tag is " + ((Component)this).gameObject.tag));
				Debug.Log((object)"Adding Permanent Script to unit!");
			}
			else
			{
				Debug.Log((object)("Undetected Tag is " + ((Component)this).gameObject.tag));
			}
		}
	}
	public class ScaleWeapon : MonoBehaviour
	{
		private Unit unit;

		public bool right;

		public float scaleMultiplier;

		private void Start()
		{
			//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)
			//IL_0085: 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)
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			if (right)
			{
				Transform transform = ((Component)unit.data.weaponHandler.rightWeapon).gameObject.transform;
				transform.localScale *= scaleMultiplier;
			}
			if (!right)
			{
				Transform transform2 = ((Component)unit.data.weaponHandler.leftWeapon).gameObject.transform;
				transform2.localScale *= scaleMultiplier;
			}
		}
	}
	public class RemoveWeaponParticles : MonoBehaviour
	{
		private Unit unit;

		private Weapon weapon;

		public bool right;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			if (right)
			{
				weapon = unit.data.weaponHandler.rightWeapon;
			}
			if (!right)
			{
				weapon = unit.data.weaponHandler.leftWeapon;
			}
			ParticleSystem[] componentsInChildren = ((Component)weapon).gameObject.GetComponentsInChildren<ParticleSystem>();
			foreach (ParticleSystem obj in componentsInChildren)
			{
				Object.Destroy((Object)(object)((Component)obj).gameObject.GetComponentInChildren<ParticleSystemRenderer>());
				Object.Destroy((Object)(object)obj);
			}
		}
	}
	public class GetAndDeleteRider : MonoBehaviour
	{
		private UnitSpawner unitSpawner;

		private void Start()
		{
			GameObject obj = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<RiderHolder>().riders[0];
			UnitBlueprint unitBlueprint = obj.GetComponentInChildren<Unit>().unitBlueprint;
			unitSpawner = ((Component)this).gameObject.GetComponentInChildren<UnitSpawner>();
			unitSpawner.unitBlueprint = unitBlueprint;
			unitSpawner.rangedUnitBlueprint = unitBlueprint;
			Object.Destroy((Object)(object)obj.gameObject);
		}
	}
	public class AdaptiveBurst : MonoBehaviour
	{
		private Color color;

		private Unit unit;

		private RangeWeapon[] rangeWeapons;

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

		private void Update()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_00f7: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			rangeWeapons = ((Component)unit).gameObject.GetComponentsInChildren<RangeWeapon>();
			if (rangeWeapons.Length != 0)
			{
				int num = Random.Range(0, rangeWeapons.Length);
				SpawnObject[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<SpawnObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].objectToSpawn = rangeWeapons[num].ObjectToSpawn;
				}
				Renderer[] componentsInChildren2 = rangeWeapons[num].ObjectToSpawn.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren2)
				{
					color = val.material.color;
				}
				ParticleSystem[] componentsInChildren3 = ((Component)this).GetComponentsInChildren<ParticleSystem>();
				for (int k = 0; k < componentsInChildren3.Length; k++)
				{
					componentsInChildren3[k].startColor = color;
				}
				ParticleSystemRenderer[] componentsInChildren4 = ((Component)this).GetComponentsInChildren<ParticleSystemRenderer>();
				foreach (ParticleSystemRenderer obj in componentsInChildren4)
				{
					((Renderer)obj).material = new Material(((Renderer)obj).material)
					{
						color = color
					};
					obj.trailMaterial = new Material(obj.trailMaterial)
					{
						color = color
					};
				}
			}
		}
	}
	public class AdaptiveThrow : MonoBehaviour
	{
		private Unit unit;

		private RangeWeapon[] rangeWeapons;

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

		private void Update()
		{
			rangeWeapons = ((Component)unit).gameObject.GetComponentsInChildren<RangeWeapon>();
			if (rangeWeapons.Length != 0)
			{
				int num = Random.Range(0, rangeWeapons.Length);
				SpawnObject[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<SpawnObject>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].objectToSpawn = rangeWeapons[num].ObjectToSpawn;
				}
			}
		}
	}
	public class NeverShowHealthBar : MonoBehaviour
	{
		private Unit unit;

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

		public void Update()
		{
			unit.SetHealthBarActive(false);
		}
	}
	public class EyeKeepOpened : MonoBehaviour
	{
		public void Update()
		{
			try
			{
				GooglyEye[] componentsInChildren = ((Component)((Component)this).gameObject.transform.root).GetComponentsInChildren<GooglyEye>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].SetState((EyeState)0);
				}
			}
			catch (Exception)
			{
				Debug.LogWarning((object)"No eye detected");
			}
		}
	}
	public class TransferHPEnable : MonoBehaviour
	{
		private Unit unit;

		public void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponentInChildren<Unit>();
			UnitSpawner[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<UnitSpawner>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].transferHp = true;
			}
			SmartTransformToRiderBehaviour[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<SmartTransformToRiderBehaviour>();
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				componentsInChildren2[j].transferHP = true;
			}
			SmartConnectedTransformBehaviour[] componentsInChildren3 = ((Component)unit).GetComponentsInChildren<SmartConnectedTransformBehaviour>();
			for (int j = 0; j < componentsInChildren3.Length; j++)
			{
				componentsInChildren3[j].transferHP = true;
			}
		}
	}
	public class SwapDistanceBase : MonoBehaviour
	{
		private HoldingHandler holdingHandler;

		private Unit unit;

		private bool swapped;

		private GameObject leftObject;

		private Holdable leftObjectHoldable;

		private GameObject rightObject;

		private Holdable rightObjectHoldable;

		private WeaponHandler WeaponHandler;

		public void Start()
		{
			//IL_011b: 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)
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponentInChildren<Unit>();
			if (!Object.op_Implicit((Object)(object)unit))
			{
				return;
			}
			WeaponHandler = unit.WeaponHandler;
			holdingHandler = unit.holdingHandler;
			if (!Object.op_Implicit((Object)(object)holdingHandler))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
			{
				rightObject = ((Component)holdingHandler.rightObject).gameObject;
				rightObjectHoldable = holdingHandler.rightObject;
			}
			if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
			{
				leftObject = ((Component)holdingHandler.leftObject).gameObject;
				leftObjectHoldable = holdingHandler.leftObject;
				holdingHandler.LetGoOfWeapon(leftObject);
				if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
				{
					holdingHandler.leftObject = holdingHandler.rightObject;
					holdingHandler.leftHandActivity = (HandActivity)1;
				}
				Scaler(leftObject, Vector3.zero);
			}
		}

		public void Update()
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			float num = 5f;
			if (Object.op_Implicit((Object)(object)unit))
			{
				if (!Object.op_Implicit((Object)(object)rightObject))
				{
					rightObject = ((Component)holdingHandler.rightObject).gameObject;
					rightObjectHoldable = holdingHandler.rightObject;
				}
				if (!Object.op_Implicit((Object)(object)leftObject))
				{
					leftObject = ((Component)holdingHandler.leftObject).gameObject;
					leftObjectHoldable = holdingHandler.leftObject;
					holdingHandler.LetGoOfWeapon(leftObject);
					if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
					{
						holdingHandler.leftObject = holdingHandler.rightObject;
						holdingHandler.leftHandActivity = (HandActivity)1;
					}
					Scaler(leftObject, Vector3.zero);
				}
			}
			if (Object.op_Implicit((Object)(object)unit.data.targetData) && !unit.data.Dead)
			{
				if (Vector3.Distance(unit.data.mainRig.position, unit.data.targetData.mainRig.position) <= num && !swapped)
				{
					WeaponSwap(SwapToLeft: true);
					swapped = true;
				}
				else if (Vector3.Distance(unit.data.mainRig.position, unit.data.targetData.mainRig.position) > num && swapped)
				{
					WeaponSwap(SwapToLeft: false);
					swapped = false;
				}
			}
		}

		public void WeaponSwap(bool SwapToLeft)
		{
			//IL_009a: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)leftObject != (Object)null) || !((Object)(object)rightObject != (Object)null))
			{
				return;
			}
			if (SwapToLeft)
			{
				holdingHandler.LetGoOfWeapon(rightObject);
				holdingHandler.GrabObject(leftObjectHoldable, true, true, (Action)delegate
				{
				});
				if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
				{
					holdingHandler.rightObject = holdingHandler.leftObject;
				}
				Scaler(rightObject, Vector3.zero);
				Scaler(leftObject, Vector3.one);
				holdingHandler.leftHandActivity = (HandActivity)1;
				holdingHandler.rightHandActivity = (HandActivity)1;
				WeaponHandler.SetWeapon(leftObject.GetComponentInChildren<Weapon>(), (HandType)0);
			}
			else if (!SwapToLeft)
			{
				holdingHandler.LetGoOfWeapon(leftObject);
				holdingHandler.GrabObject(rightObjectHoldable, true, true, (Action)delegate
				{
				});
				if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
				{
					holdingHandler.leftObject = holdingHandler.rightObject;
				}
				Scaler(rightObject, Vector3.one);
				Scaler(leftObject, Vector3.zero);
				holdingHandler.leftHandActivity = (HandActivity)1;
				holdingHandler.rightHandActivity = (HandActivity)1;
				WeaponHandler.SetWeapon(rightObject.GetComponentInChildren<Weapon>(), (HandType)0);
			}
		}

		public void Scaler(GameObject basedGameObject, Vector3 scale)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			basedGameObject.transform.localScale = scale;
		}
	}
	public class SwapDistanceHalf : MonoBehaviour
	{
		private HoldingHandler holdingHandler;

		private Unit unit;

		private bool swapped;

		private GameObject leftObject;

		private Holdable leftObjectHoldable;

		private GameObject rightObject;

		private Holdable rightObjectHoldable;

		private WeaponHandler WeaponHandler;

		public void Start()
		{
			//IL_011b: 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)
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponentInChildren<Unit>();
			if (!Object.op_Implicit((Object)(object)unit))
			{
				return;
			}
			WeaponHandler = unit.WeaponHandler;
			holdingHandler = unit.holdingHandler;
			if (!Object.op_Implicit((Object)(object)holdingHandler))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
			{
				rightObject = ((Component)holdingHandler.rightObject).gameObject;
				rightObjectHoldable = holdingHandler.rightObject;
			}
			if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
			{
				leftObject = ((Component)holdingHandler.leftObject).gameObject;
				leftObjectHoldable = holdingHandler.leftObject;
				holdingHandler.LetGoOfWeapon(leftObject);
				if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
				{
					holdingHandler.leftObject = holdingHandler.rightObject;
					holdingHandler.leftHandActivity = (HandActivity)1;
				}
				Scaler(leftObject, Vector3.zero);
			}
		}

		public void Update()
		{
			//IL_014b: 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_00db: 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)
			float num = unit.data.maxHealth * 0.5f;
			if (Object.op_Implicit((Object)(object)unit))
			{
				if (!Object.op_Implicit((Object)(object)rightObject))
				{
					rightObject = ((Component)holdingHandler.rightObject).gameObject;
					rightObjectHoldable = holdingHandler.rightObject;
				}
				if (!Object.op_Implicit((Object)(object)leftObject))
				{
					leftObject = ((Component)holdingHandler.leftObject).gameObject;
					leftObjectHoldable = holdingHandler.leftObject;
					holdingHandler.LetGoOfWeapon(leftObject);
					if (Object.op_Implicit((Object)(object)holdingHandler.rightObject))
					{
						holdingHandler.leftObject = holdingHandler.rightObject;
						holdingHandler.leftHandActivity = (HandActivity)1;
					}
					Scaler(leftObject, Vector3.zero);
				}
			}
			if (Object.op_Implicit((Object)(object)unit.data.targetData) && !unit.data.Dead)
			{
				if (unit.data.health <= num && !swapped)
				{
					WeaponSwap(SwapToLeft: true);
					swapped = true;
				}
				else if (Vector3.Distance(unit.data.mainRig.position, unit.data.targetData.mainRig.position) > num && swapped)
				{
					WeaponSwap(SwapToLeft: false);
					swapped = false;
				}
			}
		}

		public void WeaponSwap(bool SwapToLeft)
		{
			//IL_009a: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)leftObject != (Object)null) || !((Object)(object)rightObject != (Object)null))
			{
				return;
			}
			if (SwapToLeft)
			{
				holdingHandler.LetGoOfWeapon(rightObject);
				holdingHandler.GrabObject(leftObjectHoldable, true, true, (Action)delegate
				{
				});
				if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
				{
					holdingHandler.rightObject = holdingHandler.leftObject;
				}
				Scaler(rightObject, Vector3.zero);
				Scaler(leftObject, Vector3.one);
				holdingHandler.leftHandActivity = (HandActivity)1;
				holdingHandler.rightHandActivity = (HandActivity)1;
				WeaponHandler.SetWeapon(leftObject.GetComponentInChildren<Weapon>(), (HandType)0);
			}
			else if (!SwapToLeft)
			{
				holdingHandler.LetGoOfWeapon(leftObject);
				holdingHandler.GrabObject(rightObjectHoldable, true, true, (Action)delegate
				{
				});
				if (Object.op_Implicit((Object)(object)holdingHandler.leftObject))
				{
					holdingHandler.leftObject = holdingHandler.rightObject;
				}
				Scaler(rightObject, Vector3.one);
				Scaler(leftObject, Vector3.zero);
				holdingHandler.leftHandActivity = (HandActivity)1;
				holdingHandler.rightHandActivity = (HandActivity)1;
				WeaponHandler.SetWeapon(rightObject.GetComponentInChildren<Weapon>(), (HandType)0);
			}
		}

		public void Scaler(GameObject basedGameObject, Vector3 scale)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			basedGameObject.transform.localScale = scale;
		}
	}
	public class AddMeleeBlinks : MonoBehaviour
	{
		private Unit unit;

		private MeleeWeapon[] meleeWeapons;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			meleeWeapons = ((Component)unit).GetComponentsInChildren<MeleeWeapon>();
			MeleeWeapon[] array = meleeWeapons;
			for (int i = 0; i < array.Length; i++)
			{
				List<AttackEffect> list = new List<AttackEffect>(((Weapon)array[i]).attackEffects);
				list.Add((AttackEffect)(object)((Component)array[i]).gameObject.AddComponent<BlinkDagger>());
				((Weapon)array[i]).attackEffects = list.ToArray();
			}
		}
	}
	public class AddMeleeDissarm : MonoBehaviour
	{
		private Unit unit;

		private MeleeWeapon[] meleeWeapons;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			meleeWeapons = ((Component)unit).GetComponentsInChildren<MeleeWeapon>();
			MeleeWeapon[] array = meleeWeapons;
			for (int i = 0; i < array.Length; i++)
			{
				((Component)array[i]).gameObject.AddComponent<MeleeWeaponDissarm>();
			}
		}
	}
	public class AddSmartMeleeDash : MonoBehaviour
	{
		public enum AnimationProperty
		{
			RigForce,
			Delay
		}

		private Unit unit;

		private MeleeWeapon[] meleeWeapons;

		private void Start()
		{
			//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)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			meleeWeapons = ((Component)unit).GetComponentsInChildren<MeleeWeapon>();
			float x = ((Component)this).transform.localScale.x;
			float y = ((Component)this).transform.localScale.y;
			MeleeWeapon[] array = meleeWeapons;
			for (int i = 0; i < array.Length; i++)
			{
				MeleeWeapon obj = array[i];
				((Weapon)obj).maxRange = ((Weapon)obj).maxRange * ((Component)this).transform.localScale.z;
				WeaponForceAnimation componentInChildren = ((Component)array[i]).gameObject.GetComponentInChildren<WeaponForceAnimation>();
				if (!Object.op_Implicit((Object)(object)componentInChildren))
				{
					List<AttackEffect> list = new List<AttackEffect>(((Weapon)array[i]).attackEffects);
					WeaponForceAnimation val = ((Component)array[i]).gameObject.AddComponent<WeaponForceAnimation>();
					s.DeepCopyOf<WeaponForceAnimation>(val, ((GameObject)SLMALoader.SDic["weapons"]["shogunSword"]).GetComponentInChildren<WeaponForceAnimation>());
					SetDefaultProperty(val, 100f);
					SetAnimationProperty(val, AnimationProperty.RigForce, x);
					SetAnimationProperty(val, AnimationProperty.Delay, y);
					list.Add((AttackEffect)(object)val);
					((Weapon)array[i]).attackEffects = list.ToArray();
				}
				else
				{
					s.DeepCopyOf<WeaponForceAnimation>(componentInChildren, ((GameObject)SLMALoader.SDic["weapons"]["shogunSword"]).GetComponentInChildren<WeaponForceAnimation>());
					SetDefaultProperty(componentInChildren, 100f);
					SetAnimationProperty(componentInChildren, AnimationProperty.RigForce, x);
					SetAnimationProperty(componentInChildren, AnimationProperty.Delay, y);
				}
			}
		}

		private void SetAnimationProperty(WeaponForceAnimation anim, AnimationProperty property, float value)
		{
			if ((Object)(object)anim == (Object)null || anim.animations == null || anim.animations.Length == 0)
			{
				Debug.LogWarning((object)"Animation or animation data missing.");
				return;
			}
			switch (property)
			{
			case AnimationProperty.RigForce:
			{
				SpellAnimation obj2 = anim.animations[0];
				obj2.rigAnimationForce *= value;
				break;
			}
			case AnimationProperty.Delay:
			{
				SpellAnimation obj = anim.animations[0];
				obj.animationDelay *= value;
				break;
			}
			default:
				Debug.LogWarning((object)"Unknown animation property!");
				break;
			}
		}

		private void SetDefaultProperty(WeaponForceAnimation anim, float value)
		{
			if ((Object)(object)anim == (Object)null || anim.animations == null || anim.animations.Length == 0)
			{
				Debug.LogWarning((object)"Animation or animation data missing.");
				return;
			}
			Debug.Log((object)"Set the animation to default value");
			anim.animations[0].rigAnimationForce = value;
		}
	}
	public class SmartRangeDistanceBehaviour : MonoBehaviour
	{
		private Unit unit;

		private Weapon[] weapons;

		public float unitAttackDistance;

		public float weaponDistance;

		public bool alwaysAttack;

		private static float SETMAX = 99999f;

		private void Start()
		{
			//IL_0048: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			Transform root = ((Component)this).transform.root;
			unit = ((Component)root).GetComponentInChildren<Unit>();
			if ((Object)(object)unit == (Object)null)
			{
				Debug.LogError((object)"Unit not found in hierarchy.");
				return;
			}
			weapons = ((Component)unit).GetComponentsInChildren<Weapon>();
			Vector3 localScale = ((Component)this).transform.localScale;
			unitAttackDistance = localScale.x;
			weaponDistance = localScale.y;
			alwaysAttack = localScale.z >= 1f;
			if (alwaysAttack)
			{
				Weapon[] array = weapons;
				for (int i = 0; i < array.Length; i++)
				{
					array[i].maxRange = SETMAX;
				}
				unit.api.UpdateECSValues();
				unit.m_PreferedDistance = SETMAX;
			}
			else
			{
				Weapon[] array2 = weapons;
				for (int j = 0; j < array2.Length; j++)
				{
					array2[j].maxRange = weaponDistance;
				}
				unit.api.UpdateECSValues();
				unit.m_PreferedDistance = unitAttackDistance;
			}
		}

		private void Update()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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)
			if ((Object)(object)unit == (Object)null || unit.data.Dead || (Object)(object)unit.data.targetData == (Object)null || (Object)(object)MainCam.instance == (Object)null)
			{
				return;
			}
			CameraAbilityPossess componentInParent = ((Component)MainCam.instance).GetComponentInParent<CameraAbilityPossess>();
			if ((!((Object)(object)componentInParent != (Object)null) || !((Object)(object)componentInParent.currentUnit == (Object)(object)unit)) && (alwaysAttack || unit.data.distanceToTarget <= unit.m_PreferedDistance || unit.data.distanceToTarget <= unitAttackDistance))
			{
				Unit val = unit.data.targetData.unit;
				if ((Object)(object)val != (Object)null)
				{
					unit.Attack(val.data.mainRig.position, val.data.mainRig, val.data.mainRig.position - val.data.mainRig.position);
				}
			}
		}
	}
	public class FusionMechanic : MonoBehaviour
	{
		private UnitSpawner unitSpawner;

		private Unit unit;

		private Unit rider;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			unitSpawner = ((Component)this).gameObject.GetComponentInChildren<UnitSpawner>();
			rider = unitSpawner.Spawn();
			Object.Destroy((Object)(object)unitSpawner);
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)unit) & Object.op_Implicit((Object)(object)rider))
			{
				MirrorRigs(rider, unit);
			}
		}

		private void MirrorRigs(Unit unit, Unit target)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			Rigidbody[] allRigs = unit.data.allRigs.AllRigs;
			Rigidbody[] allRigs2 = target.data.allRigs.AllRigs;
			for (int i = 0; i < allRigs.Length; i++)
			{
				if (allRigs.Length == allRigs2.Length)
				{
					((Component)allRigs[i]).transform.position = ((Component)allRigs2[i]).transform.position;
					((Component)allRigs[i]).transform.rotation = ((Component)allRigs2[i]).transform.rotation;
				}
				else
				{
					unit.data.mainRig.position = target.data.mainRig.position;
					unit.data.mainRig.rotation = target.data.mainRig.rotation;
				}
			}
		}
	}
	public class StandStill : MonoBehaviour
	{
		private Unit unit;

		private UnitDontWalkFor unitDontWalkFor;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			unitDontWalkFor = ((Component)unit).gameObject.AddComponent<UnitDontWalkFor>();
			unitDontWalkFor.time = float.PositiveInfinity;
			unitDontWalkFor.Go();
		}

		private void Update()
		{
			unitDontWalkFor.Go();
		}
	}
	public class SkinnedChanges : MonoBehaviour
	{
		private Unit unit;

		private Material curMat;

		private void Start()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			curMat = ((Component)this).gameObject.GetComponentInChildren<Renderer>().materials[0];
			if (!Object.op_Implicit((Object)(object)curMat))
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				if (((Component)val).tag == "UnitMesh" && (Object)(object)val.materials[0] != (Object)(object)curMat)
				{
					List<Material> list = new List<Material>();
					Material[] materials = val.materials;
					for (int j = 0; j < materials.Length; j++)
					{
						list.Add(new Material(curMat));
					}
					val.materials = list.ToArray();
				}
			}
		}
	}
	public class NoFallDamage : MonoBehaviour
	{
		private Unit unit;

		private UnitDontWalkFor unitDontWalkFor;

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

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)unit) && Object.op_Implicit((Object)(object)unit.data))
			{
				unit.data.takeFallDamage = false;
				unit.data.canFall = false;
			}
		}
	}
	public class MeleeTrail : MonoBehaviour
	{
		private Unit unit;

		public bool right;

		public Material curMat;

		private void Start()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			curMat = ((Component)this).gameObject.GetComponentInChildren<Renderer>().materials[0];
			AnimationCurve val = new AnimationCurve();
			val.AddKey(0f, 0f);
			val.AddKey(0.75f, 0.1f);
			val.AddKey(1f, 0f);
			GameObject val2 = ((!right) ? ((Component)unit.data.weaponHandler.leftWeapon).gameObject : ((Component)unit.data.weaponHandler.rightWeapon).gameObject);
			MeshRenderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<MeshRenderer>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren[i]);
			}
			AddTrail(((Component)val2.GetComponentInChildren<ForcePoint>()).gameObject, curMat, val);
		}

		private void AddTrail(GameObject point, Material material, AnimationCurve widthCurve)
		{
			TrailRenderer obj = point.AddComponent<TrailRenderer>();
			obj.time = 0.5f;
			((Renderer)obj).material = material;
			obj.widthCurve = widthCurve;
		}
	}
	public class ForcedSkinnedChanges : MonoBehaviour
	{
		private Unit unit;

		private Material curMat;

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

		private void Update()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			curMat = ((Renderer)((Component)this).gameObject.GetComponentInChildren<MeshRenderer>()).materials[0];
			if (!Object.op_Implicit((Object)(object)curMat))
			{
				return;
			}
			SkinnedMeshRenderer[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponentInParent<PropItem>()) && !Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponentInParent<WeaponItem>()) && !Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponentInParent<CharacterItem>()) && !Object.op_Implicit((Object)(object)((Component)val).gameObject.GetComponentInParent<SpecialAbility>()))
				{
					List<Material> list = new List<Material>();
					Material[] materials = ((Renderer)val).materials;
					for (int j = 0; j < materials.Length; j++)
					{
						list.Add(new Material(curMat));
					}
					((Renderer)val).materials = list.ToArray();
				}
			}
		}
	}
	public class SmartTransformationAmountBehaviour : MonoBehaviour
	{
		private Unit unit;

		public void Start()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			unit = ((Component)((Component)this).transform.root).GetComponentInChildren<Unit>();
			int num = (int)((Component)this).gameObject.transform.localScale.x;
			UnitSpawner[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<UnitSpawner>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].amountToSpawn = num;
			}
			SmartTransformToRiderBehaviour[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<SmartTransformToRiderBehaviour>();
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				componentsInChildren2[j].spawnAmount = num;
			}
			SmartConnectedTransformBehaviour[] componentsInChildren3 = ((Component)unit).GetComponentsInChildren<SmartConnectedTransformBehaviour>();
			for (int k = 0; k < componentsInChildren3.Length; k++)
			{
				componentsInChildren3[k].spawnAmount = num;
			}
		}
	}
	public class AddDestroyAbilityChildRenderer : MonoBehaviour
	{
		private Unit unit;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
			SpecialAbility[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<SpecialAbility>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Component)componentsInChildren[i]).gameObject.AddComponent<DestroyChildRenderer>();
			}
		}
	}
	public class RemoveTurnado : MonoBehaviour
	{
		private Unit unit;

		private void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponentInChildren<Unit>();
			SpinToWinBehaviour[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<SpinToWinBehaviour>();
			foreach (SpinToWinBehaviour obj in componentsInChildren)
			{
				obj.turnadoStartEvent = obj.turnadoEndEvent;
			}
		}
	}
	public class DestroyChildRenderer : MonoBehaviour
	{
		private void Start()
		{
			Renderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<R