Decompiled source of WinterFest v1.0.5

Winterfest.dll

Decompiled 3 weeks ago
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 BepInEx;
using DM;
using HarmonyLib;
using Landfall.TABS;
using Landfall.TABS.AI.Components.Modifiers;
using Landfall.TABS.AI.Systems;
using Landfall.TABS.GameState;
using Landfall.TABS.UnitEditor;
using SLMA;
using TFBGames;
using Unity.Entities;
using UnityEngine;
using UnityEngine.SceneManagement;
using WinterFest;
using WinterfestFunctions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("WinterFest")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("GeeztJeez")]
[assembly: AssemblyProduct("WinterFest")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[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.5.0")]
[module: UnverifiableCode]
namespace WinterFest
{
	public static class UManager
	{
		public class Utility : MonoBehaviour
		{
			public static class ItemCategorizer
			{
				public static void SetTag(GameObject item, string categoryName = "Winterfest", TagType tagType = 0)
				{
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					//IL_0020: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_002e: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						CharacterItem componentInChildren = item.GetComponentInChildren<CharacterItem>();
						if (Object.op_Implicit((Object)(object)componentInChildren))
						{
							componentInChildren.tags = new List<Tag>
							{
								new Tag
								{
									tagType = tagType,
									value = categoryName
								}
							};
						}
					}
					catch (Exception ex)
					{
						Debug.Log((object)ex);
					}
				}
			}

			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 Material LoadBundleMaterial(string name)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Expected O, but got Unknown
				return (Material)bundle.LoadAsset(name);
			}

			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 Faction SetFactionHidden(Faction faction)
			{
				s.SetField<Faction>(faction, "m_isSecret", (object)true);
				s.SetField<Faction>(faction, "m_lockSecrets", (object)true);
				return faction;
			}
		}

		private static string comment;

		public static AssetBundle bundle;

		public static void SetBlueprint(UnitBlueprint unit, LandfallContentDatabase db)
		{
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Expected O, but got Unknown
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0731: Expected O, but got Unknown
			//IL_074c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Expected O, but got Unknown
			//IL_0760: Unknown result type (might be due to invalid IL or missing references)
			//IL_0766: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ab: Expected O, but got Unknown
			//IL_08c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cc: Expected O, but got Unknown
			//IL_08e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ed: Expected O, but got Unknown
			//IL_0908: Unknown result type (might be due to invalid IL or missing references)
			//IL_090e: Expected O, but got Unknown
			//IL_0929: Unknown result type (might be due to invalid IL or missing references)
			//IL_092f: Expected O, but got Unknown
			//IL_094a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0950: Expected O, but got Unknown
			//IL_0970: Unknown result type (might be due to invalid IL or missing references)
			//IL_0977: Expected O, but got Unknown
			//IL_09ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b3: Expected O, but got Unknown
			//IL_09dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e4: Expected O, but got Unknown
			//IL_0a0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a14: Expected O, but got Unknown
			//IL_0a38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3f: Expected O, but got Unknown
			//IL_0a63: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6a: Expected O, but got Unknown
			//IL_0ac7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0acd: Expected O, but got Unknown
			//IL_0b23: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db8: Expected O, but got Unknown
			//IL_0dd3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dd9: Expected O, but got Unknown
			//IL_0df4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfa: Expected O, but got Unknown
			//IL_0e16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1c: Expected O, but got Unknown
			//IL_0e38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3e: Expected O, but got Unknown
			//IL_0e5a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e60: Expected O, but got Unknown
			//IL_0e6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e74: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fdd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fe3: Expected O, but got Unknown
			//IL_105d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1063: Unknown result type (might be due to invalid IL or missing references)
			if (unit.Entity.Name == "Abnormal Envoy")
			{
				SLMATool.UnitCost(unit, 1200);
				unit.UnitBase = UPool.MyPool.GetObject("AbnormalEnvoy_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Secret Attack Vocals/Raptor");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Secret Death Vocals/Raptor");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/Raptor");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.5f);
				unit.health = 800f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 3f;
				unit.massMultiplier = 0.5f;
				unit.balanceMultiplier = 1.4f;
				unit.animationMultiplier = 1.4f;
				unit.balanceForceMultiplier = 1.2f;
				unit.movementSpeedMuiltiplier = 1.1f;
				unit.LeftWeapon = UPool.MyPool.GetObject("EnvoyExtendedClaw");
				unit.RightWeapon = UPool.MyPool.GetObject("EnvoyExtendedClaw");
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[4]
				{
					UPool.MyPool.GetObject("Move_EnvoyBite"),
					UPool.MyPool.GetObject("Move_EnvoyOfMadness"),
					(GameObject)SLMALoader.SDic["moves"]["BallAndChain_Jump"],
					(GameObject)SLMALoader.SDic["moves"]["Jump_BerserkerShort"]
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			}
			if (unit.Entity.Name == "Frigid Huntress")
			{
				SLMATool.UnitCost(unit, 2500);
				unit.UnitBase = UPool.MyPool.GetObject("FrigidHuntress_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Farmer Attack Vocals/Pitchfork");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Farmer Death Vocals/Pitchfork");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.6f);
				unit.health = 600f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 2f;
				unit.balanceMultiplier = 1.4f;
				unit.animationMultiplier = 1.5f;
				unit.balanceForceMultiplier = 1.4f;
				unit.movementSpeedMuiltiplier = 1.2f;
				unit.holdinigWithTwoHands = true;
				unit.RightWeapon = UPool.MyPool.GetObject("FrigidHuntingLongbow");
				unit.rightProjectile = UPool.MyPool.GetObject("P_FrigidBow").GetComponentInChildren<ProjectileEntity>();
				unit.m_props = (GameObject[])(object)new GameObject[12]
				{
					UPool.MyPool.GetObject("FrigidArrows"),
					UPool.MyPool.GetObject("FrigidRightHandStocking"),
					UPool.MyPool.GetObject("FrigidLeftArmStocking"),
					UPool.MyPool.GetObject("FrigidMouthCover"),
					UPool.MyPool.GetObject("FrigidBoots"),
					UPool.MyPool.GetObject("FrigidChestArmor"),
					UPool.MyPool.GetObject("FrigidHair"),
					UPool.MyPool.GetObject("FrigidInnerShirt"),
					UPool.MyPool.GetObject("FrigidHuntress_Eyes"),
					UPool.MyPool.GetObject("FrigidMask"),
					UPool.MyPool.GetObject("FrigidPants"),
					UPool.MyPool.GetObject("FrigidRightGlove")
				};
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[3]
				{
					UPool.MyPool.GetObject("Move_ArrowStep"),
					UPool.MyPool.GetObject("Move_GazingPierces"),
					(GameObject)SLMALoader.SDic["moves"]["Small_Hover"]
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepPreferredDistance) };
			}
			if (unit.Entity.Name == "Skrægore")
			{
				SLMATool.UnitCost(unit, 6000);
				unit.UnitBase = UPool.MyPool.GetObject("Skraegore_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Effects/PriestHeal");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Effects/PriestHeal");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/Big");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.4f);
				unit.health = 3000f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 2f;
				unit.massMultiplier = 100f;
				unit.balanceMultiplier = 2f;
				unit.animationMultiplier = 2f;
				unit.balanceForceMultiplier = 2f;
				unit.movementSpeedMuiltiplier = 0f;
				unit.LeftWeapon = UPool.MyPool.GetObject("Throw_HaywireSickle");
				unit.RightWeapon = UPool.MyPool.GetObject("Throw_HaywireSickle");
				unit.m_props = (GameObject[])(object)new GameObject[3]
				{
					UPool.MyPool.GetObject("SkraegoreStrawOldHat"),
					UPool.MyPool.GetObject("SkraegoreScarecrowButchedMask"),
					UPool.MyPool.GetObject("SkraegoreRaggedShirt")
				};
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[2]
				{
					UPool.MyPool.GetObject("Move_Lifereaping"),
					UPool.MyPool.GetObject("Move_BountifulHarvest")
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(KeepPreferredDistance) };
			}
			if (unit.Entity.Name == "Dreamful Oracle")
			{
				SLMATool.UnitCost(unit, 20000);
				unit.UnitBase = UPool.MyPool.GetObject("DreamerUnit_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Western Attack Vocals/Deadeye");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Western Death Vocals/Deadeye");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/Small");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.8f);
				unit.health = 6000f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.massMultiplier = 0.5f;
				unit.animationMultiplier = 5f;
				unit.movementSpeedMuiltiplier = 1f;
				unit.LeftWeapon = UPool.MyPool.GetObject("Throw_SleepySand");
				unit.RightWeapon = UPool.MyPool.GetObject("Throw_SleepySand");
				unit.m_props = (GameObject[])(object)new GameObject[1] { UPool.MyPool.GetObject("DreamerHair") };
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[5]
				{
					UPool.MyPool.GetObject("Move_Bedridden"),
					UPool.MyPool.GetObject("Move_SirenLullaby"),
					UPool.MyPool.GetObject("Move_NightmarishPersistence"),
					(GameObject)SLMALoader.SDic["moves"]["Hover"],
					(GameObject)SLMALoader.SDic["moves"]["Hover"]
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			}
			if (unit.Entity.Name == "Miraculus")
			{
				SLMATool.UnitCost(unit, 40000);
				unit.UnitBase = UPool.MyPool.GetObject("Miraculus_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Farmer Attack Vocals/Halfling");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Farmer Death Vocals/Halfling");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/Skeleton");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.5f);
				unit.health = 8000f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 1.4f;
				unit.massMultiplier = 100f;
				unit.balanceMultiplier = 1.4f;
				unit.animationMultiplier = 1.2f;
				unit.balanceForceMultiplier = 1.2f;
				unit.movementSpeedMuiltiplier = 1.2f;
				unit.holdinigWithTwoHands = true;
				unit.RightWeapon = UPool.MyPool.GetObject("JoyousBlade");
				unit.m_props = (GameObject[])(object)new GameObject[7]
				{
					(GameObject)SLMALoader.SDic["clothes"]["VikingHelmet001"],
					(GameObject)SLMALoader.SDic["clothes"]["Viking_Ullr_Shirt001"],
					(GameObject)SLMALoader.SDic["clothes"]["misc_shirt002"],
					(GameObject)SLMALoader.SDic["clothes"]["Western_gloves002"],
					(GameObject)SLMALoader.SDic["clothes"]["Ottoman_pants002"],
					(GameObject)SLMALoader.SDic["clothes"]["Pirate_Shoes001"],
					UPool.MyPool.GetObject("ContagiousSmile")
				};
				PropItemData[] array = (PropItemData[])(object)new PropItemData[6];
				int num = 0;
				PropItemData val = new PropItemData();
				val.m_colors = new int[3] { 76, 58, 0 };
				val.m_isTeamColor = new bool[3] { false, false, true };
				array[num] = val;
				PropItemData val2 = new PropItemData();
				val2.m_colors = new int[5] { 63, 53, 63, -1, 76 };
				val2.m_isTeamColor = new bool[5];
				array[1] = val2;
				val2 = new PropItemData();
				val2.m_colors = new int[2] { 73, 63 };
				val2.m_isTeamColor = new bool[2];
				array[2] = val2;
				val2 = new PropItemData();
				val2.m_colors = new int[1] { 62 };
				val2.m_isTeamColor = new bool[1];
				array[3] = val2;
				val2 = new PropItemData();
				val2.m_colors = new int[1];
				val2.m_isTeamColor = new bool[1] { true };
				array[4] = val2;
				int num2 = 5;
				val = new PropItemData();
				val.m_colors = new int[4] { 0, -1, 76, 76 };
				val.m_isTeamColor = new bool[4] { true, false, false, false };
				array[num2] = val;
				unit.m_propData = array;
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[5]
				{
					(GameObject)SLMALoader.SDic["moves"]["Small_Hover"],
					UPool.MyPool.GetObject("Move_ShiningStar"),
					UPool.MyPool.GetObject("Move_MarchingPressure"),
					UPool.MyPool.GetObject("Move_Masochist"),
					UPool.MyPool.GetObject("Move_DopamineOverdose")
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			}
			if (unit.Entity.Name == "Flame Apostle")
			{
				SLMATool.UnitCost(unit, 7000000);
				unit.Entity.SetUnlockKey("SECRET_FLAMEAPOSTLE");
				unit.UnitBase = UPool.MyPool.GetObject("FlameApostle_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Halloween Attack Vocals/Reaper");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Halloween Death Vocals/Reaper");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/Big");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.5f);
				unit.health = 18000f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 0.15f;
				unit.massMultiplier = 200f;
				unit.animationMultiplier = 0.8f;
				unit.movementSpeedMuiltiplier = 1.5f;
				unit.LeftWeapon = UPool.MyPool.GetObject("OrderOfBlazesWeapon");
				unit.RightWeapon = UPool.MyPool.GetObject("FireFistWeapon");
				unit.m_props = (GameObject[])(object)new GameObject[11]
				{
					UPool.MyPool.GetObject("FireShepherdShouldersFierceArmor"),
					UPool.MyPool.GetObject("SpawnEyes_FireShepherd"),
					UPool.MyPool.GetObject("FireShepherdPant"),
					UPool.MyPool.GetObject("FireShepherdHat"),
					UPool.MyPool.GetObject("FireShepherdGloves"),
					UPool.MyPool.GetObject("FireShepherdGasMask"),
					UPool.MyPool.GetObject("FireShepherdCover"),
					UPool.MyPool.GetObject("FireShepherdCoat"),
					UPool.MyPool.GetObject("FireShepherdChestArmor"),
					UPool.MyPool.GetObject("FireShepherdBoots"),
					UPool.MyPool.GetObject("FireShepherdBelt")
				};
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[12]
				{
					UPool.MyPool.GetObject("Move_HeavyBreathing"),
					UPool.MyPool.GetObject("Move_FlamingExecution"),
					UPool.MyPool.GetObject("Move_SwiftBurningAshes"),
					UPool.MyPool.GetObject("Move_BaptismWarfield"),
					UPool.MyPool.GetObject("Move_InfernalShepherd"),
					UPool.MyPool.GetObject("Move_BoilingHatred"),
					(GameObject)SLMALoader.SDic["moves"]["Hover"],
					(GameObject)SLMALoader.SDic["moves"]["Kick_Captain_R"],
					(GameObject)SLMALoader.SDic["moves"]["Kick_Captain_L"],
					(GameObject)SLMALoader.SDic["moves"]["ProjectileDodge_Superboxer"],
					(GameObject)SLMALoader.SDic["moves"]["SwordArtParry_Piratequeen"],
					(GameObject)SLMALoader.SDic["moves"]["Dodge"]
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			}
			if (unit.Entity.Name == "Cryobomination")
			{
				SLMATool.UnitCost(unit, int.MaxValue);
				unit.Entity.SetUnlockKey("SECRET_CRYOBOMINATION");
				unit.UnitBase = UPool.MyPool.GetObject("Cryobomination_Base");
				s.SetField<UnitBlueprint>(unit, "VocalRef", (object)"Halloween Attack Vocals/Reaper");
				s.SetField<UnitBlueprint>(unit, "DeathRef", (object)"Halloween Death Vocals/Reaper");
				s.SetField<UnitBlueprint>(unit, "footRef", (object)"Footsteps/IceGiant");
				s.SetField<UnitBlueprint>(unit, "VoicePitch", (object)0.05f);
				unit.health = 4E+12f;
				unit.minSizeRandom = 1f;
				unit.maxSizeRandom = 1f;
				unit.sizeMultiplier = 1f;
				unit.stepMultiplier = 0.1f;
				unit.massMultiplier = 8000f;
				unit.animationMultiplier = 0.75f;
				unit.movementSpeedMuiltiplier = 0.5f;
				unit.holdinigWithTwoHands = false;
				unit.RightWeapon = UPool.MyPool.GetObject("UndeadLordGreatsword");
				unit.m_props = (GameObject[])(object)new GameObject[2]
				{
					UPool.MyPool.GetObject("CryobominationCrown"),
					UPool.MyPool.GetObject("CryobominationRobe")
				};
				unit.objectsToSpawnAsChildren = (GameObject[])(object)new GameObject[7]
				{
					(GameObject)SLMALoader.SDic["moves"]["Small_Hover"],
					UPool.MyPool.GetObject("Move_Frostwind"),
					UPool.MyPool.GetObject("Move_MountainThawer"),
					UPool.MyPool.GetObject("Move_Cryopathic"),
					UPool.MyPool.GetObject("Move_Cryocataclysm"),
					UPool.MyPool.GetObject("Move_Frenzy"),
					UPool.MyPool.GetObject("Move_WinterStormFog")
				};
				unit.MovementComponents = new List<IMovementComponent> { (IMovementComponent)(object)default(NeverStopRunning) };
			}
		}

		public static void SetMoves(GameObject move, LandfallContentDatabase db)
		{
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_SwiftBurningAshes"))
			{
				move.GetComponentInChildren<SpawnObject>().objectToSpawn = UPool.MyPool.GetObject("E_SwiftBurningAshes");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_BaptismWarfield"))
			{
				move.AddComponent<WarfieldBaptismMovement>().projectile = UPool.MyPool.GetObject("P_WarfieldRocket");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_FlamingExecution"))
			{
				move.GetComponentInChildren<SpawnObject>().objectToSpawn = UPool.MyPool.GetObject("FlamingShotgunInfernalShepherdCollisionEffectNameTection");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_BoilingHatred"))
			{
				move.AddComponent<BoilingHatredPassive>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_InfernalShepherd"))
			{
				move.AddComponent<AddInfernalShepherd>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_NightmarishPersistence"))
			{
				move.AddComponent<NightmarishPersistencePassive>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Lifereaping"))
			{
				move.AddComponent<LifereapingPassive>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_GazingPierces"))
			{
				move.AddComponent<GazingPiercesMovement>().eyeSpawn = Utility.LoadBundleGameObject("E_EyeGazePierces");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_ShiningStar"))
			{
				move.GetComponentInChildren<SpawnObject>().objectToSpawn = UPool.MyPool.GetObject("P_UltiStarr");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_MountainThawer"))
			{
				move.AddComponent<MountainThawMovement>().bigExplosion = UPool.MyPool.GetObject("E_MountainThaw");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Cryopathic"))
			{
				move.AddComponent<AddCryopathic>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Cryocataclysm"))
			{
				move.GetComponentInChildren<SpawnObject>().objectToSpawn = UPool.MyPool.GetObject("E_Cryocataclysm");
				move.AddComponent<MoveCryocataclysmPassive>().point = Utility.LoadBundleGameObject("IcePointCryopathicCarnageEffectNameTection");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Frenzy"))
			{
				move.AddComponent<FrenzyPassive>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Frostwind"))
			{
				move.AddComponent<FrostwindMovement>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_MarchingPressure"))
			{
				move.AddComponent<MarchingPressureMovement>().tracker = Utility.LoadBundleGameObject("MarchingPressureMarker");
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_Masochist"))
			{
				move.AddComponent<Masochist>();
			}
			if ((Object)(object)move == (Object)(object)UPool.MyPool.GetObject("Move_DopamineOverdose"))
			{
				move.AddComponent<DopamineOverdose>();
			}
		}

		public static void SetUnits(Unit unit, LandfallContentDatabase db)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: 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_0100: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_049e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_070f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Expected O, but got Unknown
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			//IL_0445: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Expected O, but got Unknown
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_050e: Expected O, but got Unknown
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Expected O, but got Unknown
			//IL_07d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07de: Expected O, but got Unknown
			//IL_07f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_0780: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0631: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			ConfigurableJoint[] componentsInChildren;
			if (unit.Entity.Name == "Skraegore_Base")
			{
				Transform transform = ((Component)unit).gameObject.transform;
				transform.localScale *= 2f;
				((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
				ConfigurableJointMotion val = (ConfigurableJointMotion)0;
				componentsInChildren = ((Component)unit).GetComponentsInChildren<ConfigurableJoint>();
				foreach (ConfigurableJoint val2 in componentsInChildren)
				{
					if (!((Object)((Component)val2).gameObject).name.Contains("Head") || !((Object)((Component)val2).gameObject).name.Contains("Torso"))
					{
						val2.xMotion = val;
						val2.yMotion = val;
						val2.zMotion = val;
						val2.angularXMotion = val;
						val2.angularYMotion = val;
						val2.angularZMotion = val;
					}
				}
			}
			if (unit.Entity.Name == "FrigidHuntress_Base")
			{
				((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
				TeamColor[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<TeamColor>();
				foreach (TeamColor obj in componentsInChildren2)
				{
					obj.redMaterial = new Material(obj.redMaterial);
					obj.blueMaterial = new Material(obj.blueMaterial);
					obj.redMaterial.color = new Color(1f, 0.8f, 0.8f);
					obj.blueMaterial.color = new Color(0.8f, 0.8f, 1f);
				}
			}
			if (unit.Entity.Name == "AbnormalEnvoy_Base")
			{
				Transform transform2 = ((Component)unit).gameObject.transform;
				transform2.localScale *= 1.4f;
				AbnormEnvoyDeathEvent abnormEnvoyDeathEvent = ((Component)unit).gameObject.AddComponent<AbnormEnvoyDeathEvent>();
				abnormEnvoyDeathEvent.bigLog = Utility.LoadBundleGameObject("EnvoyRemainsBigLog");
				abnormEnvoyDeathEvent.logs = Utility.LoadBundleGameObject("EnvoyRemainsLogs");
				((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
				Transform transform3 = ((Component)((Component)((Component)((Component)unit).gameObject.transform.FindChild("Rigidbodies")).transform.FindChild("Mesh")).transform.FindChild("Armature")).transform;
				((Component)transform3.FindChild("M_Hip")).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Torso")).transform.localScale = new Vector3(0.8f, 1f, 0.8f);
				((Component)transform3.FindChild("M_Arm_Left")).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Arm_Right")).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Elbow_Left")).transform.localScale = new Vector3(1f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Elbow_Right")).transform.localScale = new Vector3(1f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Leg_Left")).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Leg_Right")).transform.localScale = new Vector3(0.8f, 0.8f, 0.8f);
				((Component)transform3.FindChild("M_Knee_Left")).transform.localScale = new Vector3(0.8f, 1f, 0.8f);
				((Component)transform3.FindChild("M_Knee_Right")).transform.localScale = new Vector3(0.8f, 1f, 0.8f);
			}
			if (unit.Entity.Name == "FlameApostle_Base")
			{
				Transform transform4 = ((Component)unit).gameObject.transform;
				transform4.localScale *= 1.5f;
				unit.neverStopRunning = true;
				unit.data.takeFallDamage = false;
				unit.targetingPriorityMultiplier = 2f;
				((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
				TeamColor[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<TeamColor>();
				foreach (TeamColor obj2 in componentsInChildren2)
				{
					obj2.redMaterial = new Material(obj2.redMaterial);
					obj2.blueMaterial = new Material(obj2.blueMaterial);
					obj2.redMaterial.color = new Color(0.5f, 0.3f, 0.3f);
					obj2.blueMaterial.color = new Color(0.3f, 0.3f, 0.5f);
				}
			}
			if (unit.Entity.Name == "Miraculus_Base")
			{
				Transform transform5 = ((Component)unit).gameObject.transform;
				transform5.localScale *= 1.5f;
				unit.neverStopRunning = true;
				unit.data.takeFallDamage = false;
				unit.targetingPriorityMultiplier = 2f;
				((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
				TeamColor[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<TeamColor>();
				foreach (TeamColor obj3 in componentsInChildren2)
				{
					obj3.redMaterial = new Material(obj3.redMaterial);
					obj3.blueMaterial = new Material(obj3.blueMaterial);
					obj3.redMaterial.color = new Color(0.5f, 0.3f, 0.3f);
					obj3.blueMaterial.color = new Color(0.3f, 0.3f, 0.5f);
				}
				Material val3 = new Material(Shader.Find("Standard"))
				{
					color = new Color(2f, 2f, 2f)
				};
				GameObject val4 = UPool.MyPool.AddObject("Miraculus_Eye", ((Component)unit).GetComponentInChildren<EyeSpawner>().eyeObject, true, (HideFlags)52, (Sprite)null, 0, false);
				((Renderer)val4.GetComponentsInChildren<MeshRenderer>()[0]).material = val3;
				((Component)val4.GetComponentsInChildren<MeshRenderer>()[1]).gameObject.SetActive(false);
				val4.AddComponent<RandomEyeSizes>();
				((Component)unit).GetComponentInChildren<EyeSpawner>().randomizeEyes = false;
				((Component)unit).GetComponentInChildren<EyeSpawner>().eyeObject = val4;
				ParticleTeamColor[] componentsInChildren3 = ((Component)unit).GetComponentsInChildren<ParticleTeamColor>();
				foreach (ParticleTeamColor obj4 in componentsInChildren3)
				{
					obj4.redMat = val3;
					obj4.blueMat = val3;
					obj4.redColor = new Color(2f, 2f, 2f);
					obj4.blueColor = new Color(2f, 2f, 2f);
				}
				ParticleSystem[] componentsInChildren4 = ((Component)unit).GetComponentsInChildren<ParticleSystem>();
				foreach (ParticleSystem obj5 in componentsInChildren4)
				{
					obj5.startSize *= 10f;
					obj5.startColor = new Color(2f, 2f, 2f);
				}
				ParticleSystemRenderer[] componentsInChildren5 = ((Component)unit).GetComponentsInChildren<ParticleSystemRenderer>();
				for (int j = 0; j < componentsInChildren5.Length; j++)
				{
					((Renderer)componentsInChildren5[j]).material = val3;
				}
			}
			if (!(((Object)((Component)unit).gameObject).name == ((Object)UPool.MyPool.GetObject("Cryobomination_Base")).name))
			{
				return;
			}
			Transform transform6 = ((Component)unit).transform;
			transform6.localScale *= 4f;
			unit.targetingPriorityMultiplier = 50f;
			unit.data.takeFallDamage = false;
			ConfigurableJointMotion val5 = (ConfigurableJointMotion)0;
			componentsInChildren = ((Component)unit).GetComponentsInChildren<ConfigurableJoint>();
			foreach (ConfigurableJoint val6 in componentsInChildren)
			{
				if (((Object)((Component)val6).gameObject).name.Contains("Knee") || ((Object)((Component)val6).gameObject).name.Contains("Elbow") || ((Object)((Component)val6).gameObject).name.Contains("Hip"))
				{
					val6.xMotion = val5;
					val6.yMotion = val5;
					val6.zMotion = val5;
					val6.angularXMotion = val5;
					val6.angularYMotion = val5;
					val6.angularZMotion = val5;
				}
			}
			OnDeathFreeze onDeathFreeze = ((Component)unit).gameObject.AddComponent<OnDeathFreeze>();
			onDeathFreeze.material = (Material)SLMALoader.SDic["materials"]["IceArrowIce"];
			onDeathFreeze.color = ((GameObject)SLMALoader.SDic["effects"]["E_IceArrowEffect"]).GetComponentInChildren<Effect_IceArrow>().color;
			onDeathFreeze.soundEffect = "Effects/IceArrowEffect";
			((Component)unit).GetComponentInChildren<RigidbodyHolder>().randomizeRigidbodySizes = false;
		}

		public static void Init(LandfallContentDatabase db)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_09c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09da: Expected O, but got Unknown
			//IL_0a08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1c: Expected O, but got Unknown
			//IL_0aa6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aba: Expected O, but got Unknown
			//IL_0b16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2a: Expected O, but got Unknown
			//IL_0b58: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6c: Expected O, but got Unknown
			//IL_0c24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c38: Expected O, but got Unknown
			//IL_0c66: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c7a: Expected O, but got Unknown
			//IL_0d32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d46: Expected O, but got Unknown
			//IL_0da2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0db6: Expected O, but got Unknown
			//IL_0de4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df8: Expected O, but got Unknown
			//IL_0e26: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e3a: Expected O, but got Unknown
			//IL_129c: Unknown result type (might be due to invalid IL or missing references)
			//IL_12b0: Expected O, but got Unknown
			//IL_130c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1320: Expected O, but got Unknown
			//IL_13aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_13be: Expected O, but got Unknown
			LoadBundle("winterfestbundle");
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Create Custom Object";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Sprite val = Utility.LoadBundleTextureToSprite("factionicon_winterland");
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Create Custom Faction";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Faction val2 = Utility.SetFactionHidden(SLMATool.CreateFaction("Winterland", (UnitBlueprint[])null, val, 4123212));
			val2.m_FactionColor = new Color(0.5f, 0.5f, 0.8f);
			val2.index = 4;
			val2.m_FactionCatagory = (FactionCatagory)0;
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Create Custom Units";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			SLMATool.CreateUnit("Abnormal Envoy", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_abnormalenvoy"));
			SLMATool.CreateUnit("Frigid Huntress", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_frigidhuntress"));
			SLMATool.CreateUnit("Skrægore", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_skrægore"));
			SLMATool.CreateUnit("Dreamful Oracle", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_dreamfuloracle"));
			SLMATool.CreateUnit("Miraculus", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_miraculus"));
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Create Secret Units";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			SLMATool.CreateUnit("Cryobomination", (UnitBlueprint)null, val2, Utility.LoadBundleTextureToSprite("icon_iceabomination"));
			SLMATool.CreateUnit("Flame Apostle", (UnitBlueprint)null, Utility.SetFactionHidden((Faction)SLMALoader.SDic["factions"]["Western"]), Utility.LoadBundleTextureToSprite("icon_flameapostle"));
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Weapons";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("OrderOfBlazesWeapon", Utility.LoadBundleGameObject("OrderOfBlazesWeapon"), true, (HideFlags)52, val, 72345243, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireFistWeapon", Utility.LoadBundleGameObject("FireFistWeapon"), true, (HideFlags)52, val, 73452532, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Throw_SleepySand", Utility.LoadBundleGameObject("Throw_SleepySand"), true, (HideFlags)52, val, 9743654, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Throw_HaywireSickle", Utility.LoadBundleGameObject("Throw_HaywireSickle"), true, (HideFlags)52, val, 6243433, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidHuntingLongbow", Utility.LoadBundleGameObject("FrigidHuntingLongbow"), true, (HideFlags)52, val, 421422, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("EnvoyExtendedClaw", Utility.LoadBundleGameObject("EnvoyExtendedClaw"), true, (HideFlags)52, val, 76435234, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("UndeadLordGreatsword", Utility.LoadBundleGameObject("UndeadLordGreatsword"), true, (HideFlags)52, val, 6546546, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("JoyousBlade", Utility.LoadBundleGameObject("JoyousBlade"), true, (HideFlags)52, val, 76324151, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Clothing";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("CryobominationRobe", Utility.LoadBundleGameObject("CryobominationRobe"), true, (HideFlags)52, val, 845624523, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("CryobominationCrown", Utility.LoadBundleGameObject("CryobominationCrown"), true, (HideFlags)52, val, 634523423, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdShouldersFierceArmor", Utility.LoadBundleGameObject("FireShepherdShouldersFierceArmor"), true, (HideFlags)52, val, 8363453, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SpawnEyes_FireShepherd", Utility.LoadBundleGameObject("SpawnEyes_FireShepherd"), true, (HideFlags)52, val, 72453532, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdPant", Utility.LoadBundleGameObject("FireShepherdPant"), true, (HideFlags)52, val, 73252343, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdHat", Utility.LoadBundleGameObject("FireShepherdHat"), true, (HideFlags)52, val, 13567134, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdGloves", Utility.LoadBundleGameObject("FireShepherdGloves"), true, (HideFlags)52, val, 84624533, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdGasMask", Utility.LoadBundleGameObject("FireShepherdGasMask"), true, (HideFlags)52, val, 98475634, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdCover", Utility.LoadBundleGameObject("FireShepherdCover"), true, (HideFlags)52, val, 9534643, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdCoat", Utility.LoadBundleGameObject("FireShepherdCoat"), true, (HideFlags)52, val, 95775463, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdChestArmor", Utility.LoadBundleGameObject("FireShepherdChestArmor"), true, (HideFlags)52, val, 96134342, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdBoots", Utility.LoadBundleGameObject("FireShepherdBoots"), true, (HideFlags)52, val, 97846535, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FireShepherdBelt", Utility.LoadBundleGameObject("FireShepherdBelt"), true, (HideFlags)52, val, 83453543, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SpawnEyes_Dreamer", Utility.LoadBundleGameObject("SpawnEyes_Dreamer"), true, (HideFlags)52, val, 85363454, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("DreamerHair", Utility.LoadBundleGameObject("DreamerHair"), true, (HideFlags)52, val, 62343243, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SkraegoreStrawOldHat", Utility.LoadBundleGameObject("SkraegoreStrawOldHat"), true, (HideFlags)52, val, 12455123, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SkraegoreScarecrowButchedMask", Utility.LoadBundleGameObject("SkraegoreScarecrowButchedMask"), true, (HideFlags)52, val, 52342343, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("SkraegoreRaggedShirt", Utility.LoadBundleGameObject("SkraegoreRaggedShirt"), true, (HideFlags)52, val, 6412342, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidArrows", Utility.LoadBundleGameObject("FrigidArrows"), true, (HideFlags)52, val, 5123213, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidRightHandStocking", Utility.LoadBundleGameObject("FrigidRightHandStocking"), true, (HideFlags)52, val, 6243323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidLeftArmStocking", Utility.LoadBundleGameObject("FrigidLeftArmStocking"), true, (HideFlags)52, val, 52343423, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidMouthCover", Utility.LoadBundleGameObject("FrigidMouthCover"), true, (HideFlags)52, val, 254512321, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidBoots", Utility.LoadBundleGameObject("FrigidBoots"), true, (HideFlags)52, val, 62343423, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidChestArmor", Utility.LoadBundleGameObject("FrigidChestArmor"), true, (HideFlags)52, val, 532421323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidHair", Utility.LoadBundleGameObject("FrigidHair"), true, (HideFlags)52, val, 5234323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidInnerShirt", Utility.LoadBundleGameObject("FrigidInnerShirt"), true, (HideFlags)52, val, 624312243, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidHuntress_Eyes", Utility.LoadBundleGameObject("FrigidHuntress_Eyes"), true, (HideFlags)52, val, 62343323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidMask", Utility.LoadBundleGameObject("FrigidMask"), true, (HideFlags)52, val, 12345623, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidPants", Utility.LoadBundleGameObject("FrigidPants"), true, (HideFlags)52, val, 12632312, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidRightGlove", Utility.LoadBundleGameObject("FrigidRightGlove"), true, (HideFlags)52, val, 6234323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("ContagiousSmile", Utility.LoadBundleGameObject("ContagiousSmile"), true, (HideFlags)52, val, 605284341, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Abilities";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_HeavyBreathing", Utility.LoadBundleGameObject("Move_HeavyBreathing"), true, (HideFlags)52, val, 8456523, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_FlamingExecution", Utility.LoadBundleGameObject("Move_FlamingExecution"), true, (HideFlags)52, val, 9845563, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_SwiftBurningAshes", Utility.LoadBundleGameObject("Move_SwiftBurningAshes"), true, (HideFlags)52, val, 456343534, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_BaptismWarfield", Utility.LoadBundleGameObject("Move_BaptismWarfield"), true, (HideFlags)52, val, 235363433, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_BoilingHatred", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 8456544, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_InfernalShepherd", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 46754634, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Bedridden", Utility.LoadBundleGameObject("Move_Bedridden"), true, (HideFlags)52, val, 6234232, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_SirenLullaby", Utility.LoadBundleGameObject("Move_SirenLullaby"), true, (HideFlags)52, val, 6234523, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_NightmarishPersistence", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 74253432, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_BountifulHarvest", Utility.LoadBundleGameObject("Move_BountifulHarvest"), true, (HideFlags)52, val, 734544345, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Lifereaping", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 64532434, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_GazingPierces", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 7353234, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_ArrowStep", Utility.LoadBundleGameObject("Move_ArrowStep"), true, (HideFlags)52, val, 6524234, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_EnvoyOfMadness", Utility.LoadBundleGameObject("Move_EnvoyOfMadness"), true, (HideFlags)52, val, 62343343, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_EnvoyBite", Utility.LoadBundleGameObject("Move_EnvoyBite"), true, (HideFlags)52, val, 73454323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_MountainThawer", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 642314122, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Cryopathic", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 6546542, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Cryocataclysm", Utility.LoadBundleGameObject("Move_Cryocataclysm"), true, (HideFlags)52, val, 12456132, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Frenzy", Utility.LoadBundleGameObject("Move_Frenzy"), true, (HideFlags)52, val, 873453342, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_WinterStormFog", Utility.LoadBundleGameObject("Move_WinterStormFog"), true, (HideFlags)52, val, 43534532, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Frostwind", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 736344345, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_ShiningStar", Utility.LoadBundleGameObject("Move_ShiningStar"), true, (HideFlags)52, val, 123132412, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_MarchingPressure", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 432453231, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_Masochist", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 542343242, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Move_DopamineOverdose", (GameObject)SLMALoader.SDic["moves"]["Head_up"], true, (HideFlags)52, val, 532443223, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Projectiles";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_WarfieldRocket", Utility.LoadBundleGameObject("P_WarfieldRocket"), true, (HideFlags)52, val, 62453423, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_FireTsunamiOrder", Utility.LoadBundleGameObject("P_FireTsunamiOrder"), true, (HideFlags)52, val, 734135432, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_SleepySand", Utility.LoadBundleGameObject("P_SleepySand"), true, (HideFlags)52, val, 7345345, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_HaywireSickle", Utility.LoadBundleGameObject("P_HaywireSickle"), true, (HideFlags)52, val, 62443223, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_FrigidBow", Utility.LoadBundleGameObject("P_FrigidBow"), true, (HideFlags)52, val, 5324323, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_EnvoyOfMadness", Utility.LoadBundleGameObject("P_EnvoyOfMadness"), true, (HideFlags)52, val, 6324321, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_Firefist", Utility.LoadBundleGameObject("P_Firefist"), true, (HideFlags)52, val, 65463452, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("P_UltiStarr", Utility.LoadBundleGameObject("P_UltiStarr"), true, (HideFlags)52, val, 313241232, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Effect";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Eff_Hatemark", Utility.LoadBundleGameObject("Eff_Hatemark"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Eff_StarrFire", Utility.LoadBundleGameObject("Eff_StarrFire"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Eff_Paranoid", Utility.LoadBundleGameObject("Eff_Paranoid"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Explosions";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_WarfieldRocket", Utility.LoadBundleGameObject("E_Cryocataclysm"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_Cryocataclysm", Utility.LoadBundleGameObject("E_Cryocataclysm"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_MountainThaw", Utility.LoadBundleGameObject("E_MountainThaw"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_FieryDescend", Utility.LoadBundleGameObject("E_FieryDescend"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_BurningTornado", Utility.LoadBundleGameObject("E_BurningTornado"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_SwiftBurningAshes", Utility.LoadBundleGameObject("E_SwiftBurningAshes"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_BountifulHarvest", Utility.LoadBundleGameObject("E_BountifulHarvest"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_Haywire", Utility.LoadBundleGameObject("E_Haywire"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_Vanish", Utility.LoadBundleGameObject("E_Vanish"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_ToTheMoon", Utility.LoadBundleGameObject("E_ToTheMoon"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("E_StarrRapture", Utility.LoadBundleGameObject("E_StarrRapture"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Unit Bases";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FlameApostle_Base", (GameObject)SLMALoader.SDic["bases"]["Humanoid"], true, (HideFlags)52, val, 62432332, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Skraegore_Base", Utility.LoadBundleGameObject("SkraegoreUnitBase"), true, (HideFlags)52, val, 735344534, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FrigidHuntress_Base", (GameObject)SLMALoader.SDic["bases"]["Humanoid"], true, (HideFlags)52, val, 56123212, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("DreamerUnit_Base", Utility.LoadBundleGameObject("DreamerUnitBase"), true, (HideFlags)52, val, 623424332, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("AbnormalEnvoy_Base", Utility.LoadBundleGameObject("AbnormalEnvoyUnitBase"), true, (HideFlags)52, val, 62432432, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Miraculus_Base", (GameObject)SLMALoader.SDic["bases"]["Humanoid"], true, (HideFlags)52, val, 78216192, true), "Winterfest", (TagType)0);
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("Cryobomination_Base", Utility.LoadBundleGameObject("CryobominationUnitBase"), true, (HideFlags)52, val, 6543421, true), "Winterfest", (TagType)0);
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			comment = "Custom Object";
			comment = "----------------------------------------------------------------------------------------------------------------------------";
			Utility.ItemCategorizer.SetTag(UPool.MyPool.AddObject("FlamingShotgunInfernalShepherdCollisionEffectNameTection", Utility.LoadBundleGameObject("FlamingShotgunInfernalShepherdCollisionEffectNameTection"), true, (HideFlags)52, val, 0, true), "Winterfest", (TagType)0);
		}

		public static void SetWeapon(GameObject weapon, MeleeWeapon melee, RangeWeapon range, LandfallContentDatabase db)
		{
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Expected O, but got Unknown
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("OrderOfBlazesWeapon"))
			{
				OrderOfBlazesFunction orderOfBlazesFunction = weapon.AddComponent<OrderOfBlazesFunction>();
				orderOfBlazesFunction.burnExplosion = UPool.MyPool.GetObject("E_BurningTornado");
				orderOfBlazesFunction.pushProjectile = UPool.MyPool.GetObject("P_FireTsunamiOrder");
				orderOfBlazesFunction.crushExplosion = UPool.MyPool.GetObject("E_FieryDescend");
				orderOfBlazesFunction.chargeExplosion = UPool.MyPool.GetObject("E_SwiftBurningAshes");
				orderOfBlazesFunction.effectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("Throw_SleepySand"))
			{
				range.ObjectToSpawn = UPool.MyPool.GetObject("P_SleepySand");
			}
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("FrigidHuntingLongbow"))
			{
				range.ObjectToSpawn = UPool.MyPool.GetObject("P_FrigidBow");
			}
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("FireFistWeapon"))
			{
				range.ObjectToSpawn = UPool.MyPool.GetObject("P_Firefist");
			}
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("UndeadLordGreatsword"))
			{
				CryopathicSwordCollision cryopathicSwordCollision = weapon.AddComponent<CryopathicSwordCollision>();
				cryopathicSwordCollision.iceMaterial = (Material)SLMALoader.SDic["materials"]["IceArrowIce"];
				cryopathicSwordCollision.soundEffect = "Effects/IceArrowEffect";
			}
			if ((Object)(object)weapon == (Object)(object)UPool.MyPool.GetObject("JoyousBlade"))
			{
				weapon.AddComponent<SwingStarrFall>().explosion = UPool.MyPool.GetObject("E_ToTheMoon");
			}
		}

		public static void LoadBundle(string assetBundleName)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(assetBundleName);
			bundle = AssetBundle.LoadFromStream(stream);
		}

		public static void SetExplosion(GameObject explosion)
		{
			if ((Object)(object)explosion == (Object)(object)UPool.MyPool.GetObject("E_SwiftBurningAshes"))
			{
				explosion.GetComponentInChildren<AddObjectEffect>().EffectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
			if ((Object)(object)explosion == (Object)(object)UPool.MyPool.GetObject("E_FieryDescend"))
			{
				explosion.GetComponentInChildren<AddObjectEffect>().EffectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
			if ((Object)(object)explosion == (Object)(object)UPool.MyPool.GetObject("E_BurningTornado"))
			{
				explosion.GetComponentInChildren<AddObjectEffect>().EffectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
		}

		public static void SetProjectile(GameObject proj, ProjectileHit projhit, LandfallContentDatabase db)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			SlowingProjectile slowingProjectile = default(SlowingProjectile);
			if ((Object)(object)proj == (Object)(object)UPool.MyPool.GetObject("P_FireTsunamiOrder") && !proj.TryGetComponent<SlowingProjectile>(ref slowingProjectile))
			{
				proj.AddComponent<SlowingProjectile>();
				proj.GetComponentInChildren<AddObjectEffect>().EffectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
			if ((Object)(object)proj == (Object)(object)UPool.MyPool.GetObject("P_SleepySand") && !proj.TryGetComponent<SlowingProjectile>(ref slowingProjectile))
			{
				proj.AddComponent<SlowingProjectile>();
			}
			SpeedingArrow speedingArrow = default(SpeedingArrow);
			if ((Object)(object)proj == (Object)(object)UPool.MyPool.GetObject("P_FrigidBow") && !proj.TryGetComponent<SpeedingArrow>(ref speedingArrow))
			{
				proj.AddComponent<SpeedingArrow>();
			}
			FireSplatter fireSplatter = default(FireSplatter);
			if ((Object)(object)proj == (Object)(object)UPool.MyPool.GetObject("P_Firefist") && !proj.TryGetComponent<FireSplatter>(ref fireSplatter))
			{
				proj.AddComponent<FireSplatter>().projectile = (GameObject)SLMALoader.SDic["projectiles"]["P_FireBall"];
			}
			StarrProjFunctionality starrProjFunctionality = default(StarrProjFunctionality);
			if ((Object)(object)proj == (Object)(object)UPool.MyPool.GetObject("P_UltiStarr") && !proj.TryGetComponent<StarrProjFunctionality>(ref starrProjFunctionality))
			{
				proj.AddComponent<StarrProjFunctionality>().explosion = UPool.MyPool.GetObject("E_StarrRapture");
			}
		}

		public static void SetAllGameObject(GameObject gameObject)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			AddCryocatalysmCollision addCryocatalysmCollision = default(AddCryocatalysmCollision);
			if ((Object)(object)gameObject == (Object)(object)UPool.MyPool.GetObject("E_Cryocataclysm") && !gameObject.TryGetComponent<AddCryocatalysmCollision>(ref addCryocatalysmCollision))
			{
				gameObject.AddComponent<AddCryocatalysmCollision>();
			}
			HateMarkIndicator hateMarkIndicator = default(HateMarkIndicator);
			if ((Object)(object)gameObject == (Object)(object)UPool.MyPool.GetObject("Eff_Hatemark") && !gameObject.TryGetComponent<HateMarkIndicator>(ref hateMarkIndicator))
			{
				gameObject.AddComponent<HateMarkIndicator>();
			}
			BurningExecutionShotgun burningExecutionShotgun = default(BurningExecutionShotgun);
			if ((Object)(object)gameObject == (Object)(object)UPool.MyPool.GetObject("FlamingShotgunInfernalShepherdCollisionEffectNameTection") && !gameObject.TryGetComponent<BurningExecutionShotgun>(ref burningExecutionShotgun))
			{
				gameObject.AddComponent<BurningExecutionShotgun>().projectile = (GameObject)SLMALoader.SDic["projectiles"]["P_Barrett"];
			}
			if ((Object)(object)gameObject == (Object)(object)UPool.MyPool.GetObject("E_BurningTornado"))
			{
				gameObject.GetComponentInChildren<AddObjectEffect>().EffectPrefab = (UnitEffectBase)(object)UPool.MyPool.GetObject("Eff_Hatemark").GetComponentInChildren<DamageOverTimeEffect>();
			}
		}
	}
	[BepInPlugin("GeeztJeez.winterfest", "WinterFest", "1.0.5")]
	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 WinterFest!");
			SLMALoader.GetInstance();
			LandfallContentDatabase landfallContentDatabase = ContentDatabase.Instance().LandfallContentDatabase;
			UManager.Init(landfallContentDatabase);
			new Harmony("WinterFest").PatchAll();
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			for (int i = 0; i < array.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<Unit>()))
				{
					UManager.SetUnits(array[i].GetComponent<Unit>(), landfallContentDatabase);
				}
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<Explosion>()))
				{
					UManager.SetExplosion(array[i]);
				}
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<ProjectileHit>()))
				{
					UManager.SetProjectile(array[i], array[i].GetComponent<ProjectileHit>(), landfallContentDatabase);
				}
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<WeaponItem>()))
				{
					UManager.SetWeapon(array[i], array[i].GetComponent<MeleeWeapon>(), array[i].GetComponent<RangeWeapon>(), landfallContentDatabase);
				}
				if (Object.op_Implicit((Object)(object)array[i].GetComponent<SpecialAbility>()))
				{
					UManager.SetMoves(array[i], landfallContentDatabase);
				}
				UManager.SetAllGameObject(array[i]);
			}
			UnitBlueprint[] array2 = Resources.FindObjectsOfTypeAll<UnitBlueprint>();
			for (int j = 0; j < array2.Length; j++)
			{
				UManager.SetBlueprint(array2[j], landfallContentDatabase);
				array2[j].Validate();
			}
			SceneManager.sceneLoaded += SceneLoaded;
			Debug.Log((object)"Loaded WinterFest Successfully!");
		}

		public void SceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			if (((Scene)(ref scene)).name == "04_Sandbox_Viking_VC")
			{
				Object.Instantiate<GameObject>(UManager.Utility.LoadBundleGameObject("CryobominationSecretProp"));
			}
			if (((Scene)(ref scene)).name == "09_Lvl1_Western_VC")
			{
				Object.Instantiate<GameObject>(UManager.Utility.LoadBundleGameObject("FlameApostleSecretProp"));
			}
		}
	}
}
namespace WinterfestFunctions
{
	public class SwingStarrFall : MonoBehaviour
	{
		private MeleeWeapon weapon;

		private Unit unit;

		private float counter;

		public Vector3 position;

		public GameObject explosion;

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

		public void Update()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			counter += Time.deltaTime;
			if (weapon.isSwinging && counter >= 0.3f)
			{
				counter = 0f;
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, RandomVector3Strike(), Quaternion.identity), ((Component)this).gameObject);
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, RandomVector3Strike(), Quaternion.identity), ((Component)this).gameObject);
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, RandomVector3Strike(), Quaternion.identity), ((Component)this).gameObject);
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, RandomVector3Strike(), Quaternion.identity), ((Component)this).gameObject);
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, RandomVector3Strike(), Quaternion.identity), ((Component)this).gameObject);
			}
		}

		private Vector3 RandomVector3Strike()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			float num = unit.data.mainRig.position.x + Random.Range(-40f, 40f);
			float num2 = unit.data.mainRig.position.y + Random.Range(15f, 20f);
			float num3 = unit.data.mainRig.position.z + Random.Range(-40f, 40f);
			return new Vector3(num, num2, num3);
		}
	}
	public class StormLineEditor : MonoBehaviour
	{
		public float highestY = 6000000f;

		public float lowestY = -6000000f;

		private void Update()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			((Component)((Component)((Component)((Component)this).transform.FindChild("Storm")).gameObject.transform.FindChild("LineEffect")).gameObject.transform.FindChild("T1")).gameObject.transform.localPosition = new Vector3(0f, 0f, highestY);
			((Component)((Component)((Component)((Component)this).transform.FindChild("Storm")).gameObject.transform.FindChild("LineEffect")).gameObject.transform.FindChild("T2")).gameObject.transform.localPosition = new Vector3(0f, 0f, lowestY);
		}
	}
	public class StarrProjFunctionality : MonoBehaviour
	{
		public GameObject explosion;

		private float delay = 1f;

		public void Update()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Enlarge();
			ServiceLocator.GetService<SoundPlayer>().PlaySoundEffect("Effects/VoidMonarchTransformation", 1f, ((Component)this).transform.position, (MaterialType)0, ((Component)this).gameObject.transform, 1f);
		}

		private void Enlarge()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)this).gameObject.transform;
			transform.localScale += Vector3.one * 0.1f * Time.deltaTime;
		}

		public IEnumerator<WaitForSeconds> StarrShatterExplosion(float delay, GameObject explosion)
		{
			yield return new WaitForSeconds(delay);
			TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, ((Component)this).transform.position, Quaternion.identity), ((Component)this).gameObject);
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}

		public void Start()
		{
			((MonoBehaviour)this).StartCoroutine((IEnumerator)StarrShatterExplosion(delay, explosion));
		}
	}
	public class DopamineOverdose : MonoBehaviour
	{
		private Unit unit;

		private float counter;

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

		public void Update()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			counter += Time.deltaTime;
			if (counter >= 1f)
			{
				counter = 0f;
				((Damagable)unit.data.healthHandler).TakeDamage(0f - (unit.data.maxHealth - unit.data.health) * 0.1f, Vector3.zero, (Unit)null, (DamageType)0);
			}
		}
	}
	public class Masochist : MonoBehaviour
	{
		private Unit unit;

		private MeleeWeapon[] meleeWeapons;

		private float minSpeed = 1f;

		public float extraOffset = 2500f;

		public float maxDamage = 5000f;

		public void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponent<Unit>();
			meleeWeapons = ((Component)unit).gameObject.GetComponentsInChildren<MeleeWeapon>();
		}

		public void Update()
		{
			float num = (unit.data.maxHealth - unit.data.health) / extraOffset;
			if (num < minSpeed)
			{
				num = minSpeed;
			}
			MeleeWeapon[] array = meleeWeapons;
			foreach (MeleeWeapon obj in array)
			{
				((Weapon)obj).attackSpeedM = num;
				CollisionWeapon componentInChildren = ((Component)obj).GetComponentInChildren<CollisionWeapon>();
				if (componentInChildren.damage <= maxDamage)
				{
					componentInChildren.damage += num;
				}
			}
		}
	}
	public class RandomEyeSizes : MonoBehaviour
	{
		private void Start()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).gameObject.transform.localScale = Vector3.one * Random.Range(0.8f, 1.2f);
		}
	}
	public class MarchingPressureMovement : GameStateListener
	{
		private Unit unit;

		private float counter;

		private bool onBattle;

		public GameObject tracker;

		public float cooldown = 20f;

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

		protected override void Awake()
		{
			((GameStateListener)this).Awake();
		}

		public override void OnEnterBattleState()
		{
			onBattle = true;
		}

		public override void OnEnterPlacementState()
		{
		}

		public MarchingPressureMovement()
		{
			counter = 20f;
		}

		public void Update()
		{
			if (onBattle && !unit.data.Dead)
			{
				counter += Time.deltaTime;
				if (counter > cooldown && unit.data.groundedThisFrame && Object.op_Implicit((Object)(object)unit.data.targetData) && Object.op_Implicit((Object)(object)tracker))
				{
					counter = 0f;
					((MonoBehaviour)this).StartCoroutine((IEnumerator)DoMove(unit.data.targetData.unit));
				}
			}
		}

		private Vector3 RandomVector3Strike(Unit unit)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			float num = unit.data.mainRig.position.x + Random.Range(-40f, 40f);
			float num2 = unit.data.mainRig.position.y + Random.Range(15f, 20f);
			float num3 = unit.data.mainRig.position.z + Random.Range(-40f, 40f);
			return new Vector3(num, num2, num3);
		}

		public void TeleportUnit(Unit unit, Vector3 position, bool useGravity, string soundEffect, float volume = 1f, float pitch = 1f)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			ServiceLocator.GetService<SoundPlayer>().PlaySoundEffect(soundEffect, volume, unit.data.mainRig.position, (MaterialType)0, (Transform)null, pitch);
			for (int i = 0; i < unit.data.allRigs.AllRigs.Length; i++)
			{
				unit.data.allRigs.AllRigs[i].position = position;
			}
			for (int j = 0; j < unit.data.allRigs.AllRigs.Length; j++)
			{
				unit.data.allRigs.AllRigs[j].useGravity = useGravity;
			}
			ServiceLocator.GetService<SoundPlayer>().PlaySoundEffect(soundEffect, volume, unit.data.mainRig.position, (MaterialType)0, (Transform)null, pitch);
		}

		public IEnumerator<WaitForSeconds> DoMove(Unit target)
		{
			TeamHolder teamHolder = new TeamHolder();
			teamHolder.team = unit.Team;
			SpawnExplosion(UPool.MyPool.GetObject("E_ToTheMoon"), unit.data.mainRig.position, 1, teamHolder);
			SpawnExplosion(UPool.MyPool.GetObject("E_Vanish"), unit.data.mainRig.position, 1, teamHolder);
			GameObject tracker = Object.Instantiate<GameObject>(this.tracker, unit.data.mainRig.position, Quaternion.identity, (Transform)null);
			MarkerTracker markerTracker = tracker.AddComponent<MarkerTracker>();
			markerTracker.target = target;
			markerTracker.unit = unit;
			TeleportUnit(unit, unit.data.mainRig.position + Vector3.up * 500f, useGravity: false, "Effects/HammerUp", 2f, 0.8f);
			yield return new WaitForSeconds(5f);
			TeleportUnit(unit, tracker.transform.position, useGravity: true, "Effects/HammerExplosion", 2f, 0.6f);
			Object.Destroy((Object)(object)tracker);
			SpawnExplosion(UPool.MyPool.GetObject("E_StarrRapture"), unit.data.mainRig.position, 1, teamHolder);
			SpawnExplosion(UPool.MyPool.GetObject("E_Vanish"), unit.data.mainRig.position, 1, teamHolder);
			SpawnExplosion(UPool.MyPool.GetObject("E_ToTheMoon"), unit.data.mainRig.position, 1, teamHolder);
			for (int i = 0; i < 25; i++)
			{
				SpawnExplosion(UPool.MyPool.GetObject("E_ToTheMoon"), RandomVector3Strike(unit), 1, teamHolder);
			}
		}

		public void SpawnExplosion(GameObject explosion, Vector3 position, int amount, TeamHolder teamHolder)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < amount; i++)
			{
				TeamHolder.AddTeamHolder(Object.Instantiate<GameObject>(explosion, position, Quaternion.identity, (Transform)null), unit, teamHolder);
			}
		}
	}
	public class CryopathicCollision : MonoBehaviour
	{
		private Unit unit;

		public Material iceMaterial;

		public string soundEffect;

		public string nameDetection = "CryopathicCarnageEffectNameTection";

		public Material frozenWaterMaterial;

		public void OnCollisionEnter(Collision collision)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)collision.gameObject.transform.root).gameObject;
			if (!Object.op_Implicit((Object)(object)collision.gameObject) || !Object.op_Implicit((Object)(object)gameObject) || ((Object)gameObject).name.Contains(nameDetection) || !Object.op_Implicit((Object)(object)unit))
			{
				return;
			}
			Unit componentInChildren = gameObject.gameObject.GetComponentInChildren<Unit>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				if (componentInChildren.Team != unit.Team && (Object)(object)componentInChildren != (Object)(object)unit && !componentInChildren.data.Dead)
				{
					((Damagable)componentInChildren.data.healthHandler).TakeDamage(Random.Range(150f, 230f), Vector3.zero, unit, (DamageType)3);
					FrostCarnage(((Component)componentInChildren).gameObject);
					Rigidbody[] allRigs = componentInChildren.data.allRigs.AllRigs;
					for (int i = 0; i < allRigs.Length; i++)
					{
						allRigs[i].isKinematic = true;
					}
				}
			}
			else
			{
				FrostCarnage(gameObject);
			}
		}

		public void FrostCarnage(GameObject targetObject)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			Color[] array = (Color[])(object)new Color[3]
			{
				Color.white,
				new Color(0.75f, 0.75f, 0.9f),
				new Color(0.65f, 0.65f, 0.8f)
			};
			Water[] componentsInChildren = targetObject.GetComponentsInChildren<Water>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				CarnageColdWaterModifier carnageColdWaterModifier = ((Component)componentsInChildren[i]).gameObject.AddComponent<CarnageColdWaterModifier>();
				carnageColdWaterModifier.force = componentsInChildren[i].force;
				carnageColdWaterModifier.waterSinkOffset = componentsInChildren[i].waterSinkOffset;
				carnageColdWaterModifier.streamForce = componentsInChildren[i].streamForce;
				carnageColdWaterModifier.m_killMask = (LayerMask)s.GetField<Water>(componentsInChildren[i], "m_killMask");
				carnageColdWaterModifier.effectBase = (UnitEffectBase)(object)((GameObject)SLMALoader.SDic["effects"]["E_IceUllrEffect"]).GetComponentInChildren<Effect_IceArrow>();
			}
			Collider[] componentsInChildren2 = targetObject.GetComponentsInChildren<Collider>();
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				componentsInChildren2[j].material = new PhysicMaterial
				{
					dynamicFriction = 0.1f,
					staticFriction = 0.1f,
					frictionCombine = (PhysicMaterialCombine)2
				};
			}
			Renderer[] componentsInChildren3 = targetObject.GetComponentsInChildren<Renderer>();
			for (int k = 0; k < componentsInChildren3.Length; k++)
			{
				if (componentsInChildren3[k] is ParticleSystemRenderer)
				{
					continue;
				}
				List<Material> list = new List<Material>();
				Material[] materials = componentsInChildren3[k].materials;
				for (int l = 0; l < materials.Length; l++)
				{
					if (materials[l].renderQueue == 2450)
					{
						((Component)componentsInChildren3[k]).gameObject.SetActive(false);
					}
					else if (Object.op_Implicit((Object)(object)((Component)componentsInChildren3[k]).gameObject.GetComponent<Water>()))
					{
						list.Add(new Material(frozenWaterMaterial));
					}
					else if (Random.value < 0.5f)
					{
						int num = Random.Range(0, array.Length);
						list.Add(new Material(iceMaterial)
						{
							color = array[num]
						});
					}
					else
					{
						list.Add(new Material(iceMaterial));
					}
				}
				componentsInChildren3[k].materials = list.ToArray();
			}
			((Object)targetObject).name = ((Object)targetObject).name + "_" + nameDetection;
			ServiceLocator.GetService<SoundPlayer>().PlaySoundEffect(soundEffect, 1.2f, ((Component)unit.data.mainRig).transform.position, (MaterialType)0, (Transform)null, 1f);
		}

		public void Start()
		{
			if (Object.op_Implicit((Object)(object)MapSettings.Instance))
			{
				MapSettings.Instance.mapGroundMaterial = iceMaterial;
			}
			unit = ((Component)((Component)this).gameObject.transform.root).gameObject.GetComponentInChildren<Unit>();
		}
	}
	public class OnDeathFreeze : MonoBehaviour
	{
		private Unit unit;

		public Material material;

		public UnitColorInstance color;

		private UnitColorHandler colorHandler;

		public string soundEffect;

		public void Start()
		{
			unit = ((Component)((Component)this).gameObject.transform.root).GetComponentInChildren<Unit>();
			colorHandler = ((Component)unit).gameObject.GetComponentInChildren<UnitColorHandler>();
			unit.data.healthHandler.AddDieAction((Action)delegate
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				((Component)unit).gameObject.AddComponent<SinkOnDeath>().Sink();
				colorHandler.SetColor(color, 100f);
				colorHandler.SetMaterial(material);
				for (int i = 0; i < unit.data.allRigs.AllRigs.Length; i++)
				{
					unit.data.allRigs.AllRigs[i].isKinematic = true;
				}
				ServiceLocator.GetService<SoundPlayer>().PlaySoundEffect(soundEffect, 1.2f, unit.data.mainRig.position, (MaterialType)0, (Transform)null, 1f);
			});
		}
	}
	public class ProjToIce : ProjectileSurfaceEffect
	{
		public Material iceMaterial;

		public override bool DoEffect(HitData hit, GameObject projectile)
		{
			projectile.GetComponentInChildren<Renderer>();
			Renderer[] componentsInChildren = projectile.GetComponentsInChildren<Renderer>();
			foreach (Renderer val in componentsInChildren)
			{
				List<Material> list = new List<Material>();
				Material[] materials = val.materials;
				for (int j = 0; j < materials.Length; j++)
				{
					_ = materials[j];
					list.Add(iceMaterial);
				}
				val.materials = list.ToArray();
			}
			RemoveAfterSeconds val2 = default(RemoveAfterSeconds);
			if (((Component)this).TryGetComponent<RemoveAfterSeconds>(ref val2))
			{
				RemoveAfterSeconds componentInChildren = projectile.GetComponentInChildren<RemoveAfterSeconds>();
				componentInChildren.seconds *= 5f;
			}
			return false;
		}
	}
	public class CarnageColdWaterModifier : GameStateListener
	{
		public float force = 1000f;

		public float streamForce;

		public float damage = 10f;

		public float waterSinkOffset;

		public LayerMask m_killMask;

		public UnitEffectBase effectBase;

		private bool onBattle;

		private void Start()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			m_killMask = LayerMask.op_Implicit(LayerMask.NameToLayer("MainRig"));
			Collider component = ((Component)this).GetComponent<Collider>();
			if (Object.op_Implicit((Object)(object)WaterPost.instance) && Object.op_Implicit((Object)(object)component))
			{
				WaterPost.instance.AddWaterCollider(component);
			}
		}

		private void OnDisable()
		{
			Collider component = ((Component)this).GetComponent<Collider>();
			if (Object.op_Implicit((Object)(object)WaterPost.instance) && Object.op_Implicit((Object)(object)component))
			{
				WaterPost.instance.AddWaterCollider(component);
			}
		}

		private void OnTriggerStay(Collider other)
		{
			//IL_0076: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			if (!onBattle)
			{
				return;
			}
			_ = ((Component)((Component)other).transform.root).gameObject;
			Unit componentInChildren = ((Component)((Component)other).transform.root).GetComponentInChildren<Unit>();
			HealthHandler componentInChildren2 = ((Component)((Component)other).transform.root).GetComponentInChildren<HealthHandler>();
			DataHandler componentInChildren3 = ((Component)((Component)other).transform.root).GetComponentInChildren<DataHandler>();
			if (!Object.op_Implicit((Object)(object)componentInChildren) || !Object.op_Implicit((Object)(object)componentInChildren2) || !Object.op_Implicit((Object)(object)componentInChildren3))
			{
				return;
			}
			float num = Mathf.Clamp((((Component)this).transform.position.y + waterSinkOffset - ((Component)other).transform.position.y) * 10f, 0f, 10f) * Time.deltaTime;
			if (!componentInChildren3.Dead && ((Component)other).gameObject.layer == LayerMask.op_Implicit(m_killMask))
			{
				((Damagable)componentInChildren.data.healthHandler).TakeDamage(damage, Vector3.zero, (Unit)null, (DamageType)0);
			}
			componentInChildren3.sinceGrounded = Mathf.Clamp(componentInChildren3.sinceGrounded, float.NegativeInfinity, 1f);
			Rigidbody[] componentsInChildren = ((Component)componentInChildren).GetComponentsInChildren<Rigidbody>();
			foreach (Rigidbody obj in componentsInChildren)
			{
				obj.AddForce(force * num * Vector3.up, (ForceMode)5);
				obj.AddForce(streamForce * num * ((Component)this).transform.forward, (ForceMode)5);
				obj.angularVelocity *= 0.1f;
				obj.velocity *= 0.1f;
			}
			if (!Object.op_Implicit((Object)(object)effectBase))
			{
				return;
			}
			Type type = ((object)effectBase).GetType();
			UnitEffectBase val = (UnitEffectBase)((Component)((Component)componentInChildren).transform).GetComponentInChildren(type);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)effectBase).gameObject, ((Component)componentInChildren).transform);
				val2.transform.position = ((Component)componentInChildren).gameObject.transform.position;
				if (Object.op_Implicit((Object)(object)val2.GetComponentInChildren<UnitEffectBase>()))
				{
					val2.GetComponentInChildren<UnitEffectBase>().Ping();
					val2.GetComponentInChildren<UnitEffectBase>().DoEffect();
				}
			}
			else
			{
				val.Ping();
			}
		}

		protected override void Awake()
		{
			((GameStateListener)this).Awake();
		}

		public override void OnEnterBattleState()
		{
			onBattle = true;
		}

		public override void OnEnterPlacementState()
		{
		}

		public override void OnExitBattleState()
		{
			onBattle = false;
		}
	}
	public class AddCryopathic : MonoBehaviour
	{
		private Unit unit;

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

		public void Update()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)unit))
			{
				return;
			}
			if (Object.op_Implicit((Object)(object)((Component)unit).gameObject.GetComponentInChildren<Effect_IceArrow>()))
			{
				Effect_IceArrow[] componentsInChildren = ((Component)unit).gameObject.GetComponentsInChildren<Effect_IceArrow>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)componentsInChildren[i]);
				}
			}
			Collider[] componentsInChildren2 = ((Component)unit).GetComponentsInChildren<Collider>();
			ProjToIce projToIce = default(ProjToIce);
			CryopathicCollision cryopathicCollision = default(CryopathicCollision);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if (!((Component)componentsInChildren2[j]).gameObject.TryGetComponent<ProjToIce>(ref projToIce))
				{
					((Component)componentsInChildren2[j]).gameObject.AddComponent<ProjToIce>().iceMaterial = (Material)SLMALoader.SDic["materials"]["IceArrowIce"];
				}
				if (Object.op_Implicit((Object)(object)((Component)componentsInChildren2[j]).transform.parent) && !((Component)((Component)componentsInChildren2[j]).transform.parent).gameObject.TryGetComponent<CryopathicCollision>(ref cryopathicCollision))
				{
					CryopathicCollision cryopathicCollision2 = ((Component)((Component)componentsInChildren2[j]).transform.parent).gameObject.AddComponent<CryopathicCollision>();
					cryopathicCollision2.frozenWaterMaterial = (Material)SLMALoader.SDic["materials"]["M_viking_ice_Transparent"];
					cryopathicCollision2.iceMaterial = (Material)SLMALoader.SDic["materials"]["IceArrowIce"];
					cryopathicCollision2.soundEffect = "Effects/IceArrowEffect";
				}
			}
		}
	}
	public class FireSplatter : ProjectileHitEffect
	{
		public int amount = 20;

		public TeamHolder team;

		public GameObject projectile;

		public ProjectilesSpawnManager spawnManager;

		public override bool DoEffect(HitData hit)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < amount; i++)
			{
				Shoot(hit.point);
			}
			return false;
		}

		public void Start()
		{
			team = ((Component)this).GetComponentInChildren<TeamHolder>();
			if (!Object.op_Implicit((Object)(object)spawnManager))
			{
				spawnManager = ServiceLocator.GetService<ProjectilesSpawnManager>();
			}
		}

		public Vector3 RandomProjRot()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(0f, 359f);
			float num2 = Random.Range(0f, 359f);
			float num3 = Random.Range(0f, 359f);
			return new Vector3(num, num2, num3);
		}

		public GameObject Shoot(Vector3 position)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = spawnManager.SpawnProjectile(projectile, position, Quaternion.Euler(RandomProjRot()));
			obj.AddComponent<TeamHolder>().team = team.team;
			return obj;
		}
	}
	public class MarkerTracker : MonoBehaviour
	{
		public Unit unit;

		public float speed = 50f;

		private float size;

		public Unit target;

		public float chaseSpeed = 50f;

		public void Start()
		{
			((Component)this).gameObject.transform.Rotate(-90f, 0f, 0f, (Space)1);
		}

		public void Update()
		{
			//IL_00a2: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)unit) && Object.op_Implicit((Object)(object)target) && !unit.data.Dead)
			{
				size += size * Time.deltaTime;
				speed += speed / 1.5f * Time.deltaTime;
				chaseSpeed -= chaseSpeed * Time.deltaTime;
				((Component)this).gameObject.transform.localScale = new Vector3(size, size, 0.01f);
				((Component)this).gameObject.transform.Rotate(0f, 0f, speed * Time.deltaTime,