using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using AzuEPI;
using AzuEPI.Core.Slots;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using ItemManager;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using PieceManager;
using ServerSync;
using Splatform;
using StatusEffectManager;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.ObjectPool;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: Guid("E74EB49A-461D-48EA-85BC-F462D60C98C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyProduct("Vikings_Summoner")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Vikings_Summoner")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("1.4.4")]
[assembly: AssemblyCompany("Radamanto")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.4.0")]
[module: <0f5dda22-adc4-4eb7-9dec-383820a7c9a5>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<944d4903-c032-4390-9b7e-e5d8660b6277>Embedded]
	internal sealed class <944d4903-c032-4390-9b7e-e5d8660b6277>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<944d4903-c032-4390-9b7e-e5d8660b6277>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<944d4903-c032-4390-9b7e-e5d8660b6277>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[<944d4903-c032-4390-9b7e-e5d8660b6277>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class <0f5dda22-adc4-4eb7-9dec-383820a7c9a5>RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public <0f5dda22-adc4-4eb7-9dec-383820a7c9a5>RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Vikings_Summoner
{
	internal static class Registrations_Grimories
	{
		public static void RegisterGrimories()
		{
			Item item = new Item("rd_armor", "RD_grimoire_01");
			item.Configurable = Configurability.Recipe;
			item.Crafting.Add("RD_necromancer_table", 1);
			item.RequiredItems.Add("DeerHide", 20);
			item.RequiredItems.Add("LeatherScraps", 10);
			item.RequiredItems.Add("Feathers", 15);
			item.RequiredItems.Add("GreydwarfEye", 10);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_armor", "RD_grimoire_summons_01");
			item2.Configurable = Configurability.Recipe;
			item2.Crafting.Add("RD_necromancer_table", 1);
			item2.RequiredItems.Add("TrophyAbomination", 1);
			item2.RequiredItems.Add("DeerHide", 20);
			item2.RequiredItems.Add("Iron", 2);
			item2.RequiredItems.Add("Guck", 15);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_armor", "RD_grimoire_02");
			item3.Configurable = Configurability.Recipe;
			item3.Crafting.Add("RD_necromancer_table", 1);
			item3.RequiredItems.Add("WolfPelt", 10);
			item3.RequiredItems.Add("WolfFang", 4);
			item3.RequiredItems.Add("Crystal", 5);
			item3.RequiredItems.Add("Resin", 15);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_armor", "RD_grimoire_summons_02");
			item4.Configurable = Configurability.Recipe;
			item4.Crafting.Add("RD_necromancer_table_02", 1);
			item4.RequiredItems.Add("TrophyGoblinShaman", 1);
			item4.RequiredItems.Add("LoxPelt", 20);
			item4.RequiredItems.Add("BlackMetal", 2);
			item4.RequiredItems.Add("Tar", 15);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_armor", "RD_grimoire_03");
			item5.Configurable = Configurability.Recipe;
			item5.Crafting.Add("RD_necromancer_table_02", 1);
			item5.RequiredItems.Add("YmirRemains", 10);
			item5.RequiredItems.Add("DeerHide", 20);
			item5.RequiredItems.Add("BlackCore", 5);
			item5.RequiredItems.Add("Eitr", 15);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_armor", "RD_grimoire_summons_03");
			item6.Configurable = Configurability.Recipe;
			item6.Crafting.Add("RD_necromancer_table_02", 1);
			item6.RequiredItems.Add("TrophyCharredMage", 1);
			item6.RequiredItems.Add("AskHide", 10);
			item6.RequiredItems.Add("FlametalNew", 2);
			item6.RequiredItems.Add("CelestialFeather", 5);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_Armors
	{
		public static void RegisterArmors()
		{
			Item item = new Item("rd_armor", "RD_inv_chest_meadows");
			item.Configurable = Configurability.Recipe | Configurability.Stats;
			item.Crafting.Add("RD_necromancer_table", 1);
			item.RequiredItems.Add("DeerHide", 10);
			item.RequiredItems.Add("LeatherScraps", 10);
			item.RequiredUpgradeItems.Add("DeerHide", 2);
			item.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item2 = new Item("rd_armor", "RD_inv_helmet_meadows");
			item2.Configurable = Configurability.Recipe | Configurability.Stats;
			item2.Crafting.Add("RD_necromancer_table", 1);
			item2.RequiredItems.Add("DeerHide", 4);
			item2.RequiredItems.Add("LeatherScraps", 4);
			item2.RequiredUpgradeItems.Add("DeerHide", 2);
			item2.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item2.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item2.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item3 = new Item("rd_armor", "RD_inv_legs_meadows");
			item3.Configurable = Configurability.Recipe | Configurability.Stats;
			item3.Crafting.Add("RD_necromancer_table", 1);
			item3.RequiredItems.Add("DeerHide", 8);
			item3.RequiredItems.Add("LeatherScraps", 8);
			item3.RequiredUpgradeItems.Add("DeerHide", 2);
			item3.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item3.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item3.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item4 = new Item("rd_armor", "RD_inv_cape_meadows");
			item4.Configurable = Configurability.Recipe | Configurability.Stats;
			item4.Crafting.Add("RD_necromancer_table", 1);
			item4.RequiredItems.Add("DeerHide", 6);
			item4.RequiredItems.Add("LeatherScraps", 6);
			item4.RequiredUpgradeItems.Add("DeerHide", 2);
			item4.RequiredUpgradeItems.Add("LeatherScraps", 2);
			item4.RequiredUpgradeItems.Add("BoneFragments", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item4.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item5 = new Item("rd_armor", "RD_inv_helmet_bforest");
			item5.Configurable = Configurability.Recipe | Configurability.Stats;
			item5.Crafting.Add("RD_necromancer_table", 1);
			item5.RequiredItems.Add("TrollHide", 4);
			item5.RequiredItems.Add("BoneFragments", 6);
			item5.RequiredItems.Add("Bronze", 5);
			item5.RequiredUpgradeItems.Add("TrollHide", 1);
			item5.RequiredUpgradeItems.Add("BoneFragments", 2);
			item5.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item5.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item6 = new Item("rd_armor", "RD_inv_chest_bforest");
			item6.Configurable = Configurability.Recipe | Configurability.Stats;
			item6.Crafting.Add("RD_necromancer_table", 1);
			item6.RequiredItems.Add("TrollHide", 4);
			item6.RequiredItems.Add("BoneFragments", 8);
			item6.RequiredItems.Add("Bronze", 5);
			item6.RequiredUpgradeItems.Add("TrollHide", 1);
			item6.RequiredUpgradeItems.Add("BoneFragments", 3);
			item6.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item6.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item7 = new Item("rd_armor", "RD_inv_legs_bforest");
			item7.Configurable = Configurability.Recipe | Configurability.Stats;
			item7.Crafting.Add("RD_necromancer_table", 1);
			item7.RequiredItems.Add("TrollHide", 4);
			item7.RequiredItems.Add("BoneFragments", 6);
			item7.RequiredItems.Add("Bronze", 5);
			item7.RequiredUpgradeItems.Add("TrollHide", 1);
			item7.RequiredUpgradeItems.Add("BoneFragments", 4);
			item7.RequiredUpgradeItems.Add("Bronze", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item7.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item8 = new Item("rd_armor", "RD_inv_cape_bforest");
			item8.Configurable = Configurability.Recipe | Configurability.Stats;
			item8.Crafting.Add("RD_necromancer_table", 1);
			item8.RequiredItems.Add("TrollHide", 2);
			item8.RequiredItems.Add("BoneFragments", 4);
			item8.RequiredItems.Add("Bronze", 2);
			item8.RequiredUpgradeItems.Add("TrollHide", 1);
			item8.RequiredUpgradeItems.Add("BoneFragments", 2);
			item8.RequiredUpgradeItems.Add("Bronze", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item8.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item9 = new Item("rd_armor", "RD_inv_helmet_swamp");
			item9.Configurable = Configurability.Recipe | Configurability.Stats;
			item9.Crafting.Add("RD_necromancer_table", 2);
			item9.RequiredItems.Add("Iron", 10);
			item9.RequiredItems.Add("ElderBark", 10);
			item9.RequiredItems.Add("Entrails", 6);
			item9.RequiredUpgradeItems.Add("Iron", 2);
			item9.RequiredUpgradeItems.Add("ElderBark", 6);
			item9.RequiredUpgradeItems.Add("Entrails", 3);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item9.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item10 = new Item("rd_armor", "RD_inv_chest_swamp");
			item10.Configurable = Configurability.Recipe | Configurability.Stats;
			item10.Crafting.Add("RD_necromancer_table", 2);
			item10.RequiredItems.Add("Iron", 12);
			item10.RequiredItems.Add("ElderBark", 8);
			item10.RequiredItems.Add("Entrails", 8);
			item10.RequiredUpgradeItems.Add("Iron", 3);
			item10.RequiredUpgradeItems.Add("ElderBark", 4);
			item10.RequiredUpgradeItems.Add("Entrails", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item10.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item11 = new Item("rd_armor", "RD_inv_legs_swamp");
			item11.Configurable = Configurability.Recipe | Configurability.Stats;
			item11.Crafting.Add("RD_necromancer_table", 2);
			item11.RequiredItems.Add("Iron", 12);
			item11.RequiredItems.Add("ElderBark", 8);
			item11.RequiredItems.Add("Entrails", 8);
			item11.RequiredUpgradeItems.Add("Iron", 3);
			item11.RequiredUpgradeItems.Add("ElderBark", 4);
			item11.RequiredUpgradeItems.Add("Entrails", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item11.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item12 = new Item("rd_armor", "RD_inv_cape_swamp");
			item12.Configurable = Configurability.Recipe | Configurability.Stats;
			item12.Crafting.Add("RD_necromancer_table", 2);
			item12.RequiredItems.Add("ElderBark", 4);
			item12.RequiredItems.Add("Entrails", 6);
			item12.RequiredUpgradeItems.Add("ElderBark", 2);
			item12.RequiredUpgradeItems.Add("Entrails", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item12.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item13 = new Item("rd_armor", "RD_inv_helmet_mountain");
			item13.Configurable = Configurability.Recipe | Configurability.Stats;
			item13.Crafting.Add("RD_necromancer_table", 2);
			item13.RequiredItems.Add("WolfFang", 3);
			item13.RequiredItems.Add("WolfPelt", 10);
			item13.RequiredItems.Add("FreezeGland", 6);
			item13.RequiredItems.Add("TrollHide", 6);
			item13.RequiredUpgradeItems.Add("WolfPelt", 6);
			item13.RequiredUpgradeItems.Add("FreezeGland", 2);
			item13.RequiredUpgradeItems.Add("TrollHide", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item13.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item14 = new Item("rd_armor", "RD_inv_chest_mountain");
			item14.Configurable = Configurability.Recipe | Configurability.Stats;
			item14.Crafting.Add("RD_necromancer_table", 2);
			item14.RequiredItems.Add("WolfClaw", 3);
			item14.RequiredItems.Add("WolfPelt", 14);
			item14.RequiredItems.Add("Silver", 18);
			item14.RequiredItems.Add("DeerHide", 12);
			item14.RequiredUpgradeItems.Add("WolfPelt", 6);
			item14.RequiredUpgradeItems.Add("Silver", 8);
			item14.RequiredUpgradeItems.Add("DeerHide", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item14.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item15 = new Item("rd_armor", "RD_inv_legs_mountain");
			item15.Configurable = Configurability.Recipe | Configurability.Stats;
			item15.Crafting.Add("RD_necromancer_table", 2);
			item15.RequiredItems.Add("WolfClaw", 3);
			item15.RequiredItems.Add("WolfPelt", 12);
			item15.RequiredItems.Add("Silver", 24);
			item15.RequiredItems.Add("DeerHide", 16);
			item15.RequiredUpgradeItems.Add("WolfPelt", 6);
			item15.RequiredUpgradeItems.Add("Silver", 12);
			item15.RequiredUpgradeItems.Add("DeerHide", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item15.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item16 = new Item("rd_armor", "RD_inv_cape_mountain");
			item16.Configurable = Configurability.Recipe | Configurability.Stats;
			item16.Crafting.Add("RD_necromancer_table", 2);
			item16.RequiredItems.Add("WolfPelt", 12);
			item16.RequiredItems.Add("Silver", 6);
			item16.RequiredItems.Add("FreezeGland", 6);
			item16.RequiredUpgradeItems.Add("WolfPelt", 6);
			item16.RequiredUpgradeItems.Add("Silver", 4);
			item16.RequiredUpgradeItems.Add("FreezeGland", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item16.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item17 = new Item("rd_armor", "RD_inv_helmet_plains");
			item17.Configurable = Configurability.Recipe | Configurability.Stats;
			item17.Crafting.Add("RD_necromancer_table_02", 1);
			item17.RequiredItems.Add("BlackMetal", 16);
			item17.RequiredItems.Add("LoxPelt", 8);
			item17.RequiredItems.Add("LinenThread", 6);
			item17.RequiredItems.Add("JuteRed", 4);
			item17.RequiredUpgradeItems.Add("BlackMetal", 8);
			item17.RequiredUpgradeItems.Add("LoxPelt", 4);
			item17.RequiredUpgradeItems.Add("LinenThread", 3);
			item17.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item17.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item18 = new Item("rd_armor", "RD_inv_chest_plains");
			item18.Configurable = Configurability.Recipe | Configurability.Stats;
			item18.Crafting.Add("RD_necromancer_table_02", 1);
			item18.RequiredItems.Add("BlackMetal", 24);
			item18.RequiredItems.Add("LoxPelt", 12);
			item18.RequiredItems.Add("LinenThread", 12);
			item18.RequiredItems.Add("JuteRed", 4);
			item18.RequiredUpgradeItems.Add("BlackMetal", 12);
			item18.RequiredUpgradeItems.Add("LoxPelt", 6);
			item18.RequiredUpgradeItems.Add("LinenThread", 6);
			item18.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item18.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item19 = new Item("rd_armor", "RD_inv_legs_plains");
			item19.Configurable = Configurability.Recipe | Configurability.Stats;
			item19.Crafting.Add("RD_necromancer_table_02", 1);
			item19.RequiredItems.Add("BlackMetal", 24);
			item19.RequiredItems.Add("LoxPelt", 12);
			item19.RequiredItems.Add("LinenThread", 12);
			item19.RequiredItems.Add("JuteRed", 4);
			item19.RequiredUpgradeItems.Add("BlackMetal", 12);
			item19.RequiredUpgradeItems.Add("LoxPelt", 6);
			item19.RequiredUpgradeItems.Add("LinenThread", 6);
			item19.RequiredUpgradeItems.Add("JuteRed", 2);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item19.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item20 = new Item("rd_armor", "RD_inv_cape_plains");
			item20.Configurable = Configurability.Recipe | Configurability.Stats;
			item20.Crafting.Add("RD_necromancer_table_02", 1);
			item20.RequiredItems.Add("BlackMetal", 8);
			item20.RequiredItems.Add("LoxPelt", 6);
			item20.RequiredItems.Add("LinenThread", 8);
			item20.RequiredItems.Add("JuteRed", 2);
			item20.RequiredUpgradeItems.Add("BlackMetal", 4);
			item20.RequiredUpgradeItems.Add("LoxPelt", 2);
			item20.RequiredUpgradeItems.Add("LinenThread", 4);
			item20.RequiredUpgradeItems.Add("JuteRed", 1);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item20.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item21 = new Item("rd_armor", "RD_inv_helmet_mistlands");
			item21.Configurable = Configurability.Recipe | Configurability.Stats;
			item21.Crafting.Add("RD_necromancer_table_02", 1);
			item21.RequiredItems.Add("LinenThread", 16);
			item21.RequiredItems.Add("ScaleHide", 12);
			item21.RequiredItems.Add("Carapace", 8);
			item21.RequiredItems.Add("Eitr", 14);
			item21.RequiredUpgradeItems.Add("ScaleHide", 6);
			item21.RequiredUpgradeItems.Add("Carapace", 4);
			item21.RequiredUpgradeItems.Add("Eitr", 8);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item21.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item22 = new Item("rd_armor", "RD_inv_chest_mistlands");
			item22.Configurable = Configurability.Recipe | Configurability.Stats;
			item22.Crafting.Add("RD_necromancer_table_02", 1);
			item22.RequiredItems.Add("Mandible", 8);
			item22.RequiredItems.Add("ScaleHide", 18);
			item22.RequiredItems.Add("Carapace", 16);
			item22.RequiredItems.Add("Eitr", 22);
			item22.RequiredUpgradeItems.Add("ScaleHide", 9);
			item22.RequiredUpgradeItems.Add("Carapace", 8);
			item22.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item22.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item23 = new Item("rd_armor", "RD_inv_legs_mistlands");
			item23.Configurable = Configurability.Recipe | Configurability.Stats;
			item23.Crafting.Add("RD_necromancer_table_02", 1);
			item23.RequiredItems.Add("Mandible", 8);
			item23.RequiredItems.Add("ScaleHide", 18);
			item23.RequiredItems.Add("Carapace", 16);
			item23.RequiredItems.Add("Eitr", 22);
			item23.RequiredUpgradeItems.Add("ScaleHide", 9);
			item23.RequiredUpgradeItems.Add("Carapace", 8);
			item23.RequiredUpgradeItems.Add("Eitr", 11);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item23.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item24 = new Item("rd_armor", "RD_inv_cape_mistlands");
			item24.Configurable = Configurability.Recipe | Configurability.Stats;
			item24.Crafting.Add("RD_necromancer_table_02", 1);
			item24.RequiredItems.Add("Mandible", 2);
			item24.RequiredItems.Add("ScaleHide", 8);
			item24.RequiredItems.Add("Carapace", 8);
			item24.RequiredItems.Add("Eitr", 12);
			item24.RequiredUpgradeItems.Add("ScaleHide", 4);
			item24.RequiredUpgradeItems.Add("Carapace", 4);
			item24.RequiredUpgradeItems.Add("Eitr", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item24.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item25 = new Item("rd_armor", "RD_inv_helmet_ashlands");
			item25.Configurable = Configurability.Recipe | Configurability.Stats;
			item25.Crafting.Add("RD_necromancer_table_02", 1);
			item25.RequiredItems.Add("GemstoneRed", 1);
			item25.RequiredItems.Add("AskHide", 8);
			item25.RequiredItems.Add("CelestialFeather", 4);
			item25.RequiredItems.Add("FlametalNew", 8);
			item25.RequiredUpgradeItems.Add("AskHide", 4);
			item25.RequiredUpgradeItems.Add("CelestialFeather", 2);
			item25.RequiredUpgradeItems.Add("FlametalNew", 4);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item25.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item26 = new Item("rd_armor", "RD_inv_chest_ashlands");
			item26.Configurable = Configurability.Recipe | Configurability.Stats;
			item26.Crafting.Add("RD_necromancer_table_02", 1);
			item26.RequiredItems.Add("GemstoneRed", 1);
			item26.RequiredItems.Add("AskHide", 28);
			item26.RequiredItems.Add("CharredBone", 16);
			item26.RequiredItems.Add("FlametalNew", 26);
			item26.RequiredUpgradeItems.Add("AskHide", 14);
			item26.RequiredUpgradeItems.Add("CharredBone", 8);
			item26.RequiredUpgradeItems.Add("FlametalNew", 14);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item26.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item27 = new Item("rd_armor", "RD_inv_legs_ashlands");
			item27.Configurable = Configurability.Recipe | Configurability.Stats;
			item27.Crafting.Add("RD_necromancer_table_02", 1);
			item27.RequiredItems.Add("GemstoneRed", 1);
			item27.RequiredItems.Add("AskHide", 28);
			item27.RequiredItems.Add("CharredBone", 16);
			item27.RequiredItems.Add("FlametalNew", 26);
			item27.RequiredUpgradeItems.Add("AskHide", 14);
			item27.RequiredUpgradeItems.Add("CharredBone", 8);
			item27.RequiredUpgradeItems.Add("FlametalNew", 14);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item27.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
			Item item28 = new Item("rd_armor", "RD_inv_cape_ashlands");
			item28.Configurable = Configurability.Recipe | Configurability.Stats;
			item28.Crafting.Add("RD_necromancer_table_02", 1);
			item28.RequiredItems.Add("GemstoneRed", 1);
			item28.RequiredItems.Add("AskHide", 6);
			item28.RequiredItems.Add("CelestialFeather", 6);
			item28.RequiredItems.Add("FlametalNew", 12);
			item28.RequiredUpgradeItems.Add("AskHide", 3);
			item28.RequiredUpgradeItems.Add("CelestialFeather", 4);
			item28.RequiredUpgradeItems.Add("FlametalNew", 6);
			MaterialReplacer.RegisterGameObjectForShaderSwap(item28.Prefab, MaterialReplacer.ShaderType.UseUnityShader);
		}
	}
	internal static class Registrations_Mobs_EnemyHudIcons
	{
		internal static void Register()
		{
		}
	}
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	[HarmonyPatch(typeof(EnemyHud), "UpdateHuds")]
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
	[HarmonyPriority(0)]
	internal static class Patch_EnemyHud_UpdateHuds_SummonIcons
	{
		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)]
		private const string CombatSpriteName = "ico_summon_combat";

		private static readonly FieldInfo HudsField = AccessTools.Field(typeof(EnemyHud), "m_huds");

		private static readonly Type HudDataType = AccessTools.Inner(typeof(EnemyHud), "HudData");

		private static readonly FieldInfo CharacterField = ((HudDataType != null) ? AccessTools.Field(HudDataType, "m_character") : null);

		private static readonly FieldInfo AlertedField = ((HudDataType != null) ? AccessTools.Field(HudDataType, "m_alerted") : null);

		private static readonly FieldInfo AwareField = ((HudDataType != null) ? AccessTools.Field(HudDataType, "m_aware") : null);

		private static readonly FieldInfo TargetCreatureField = AccessTools.Field(typeof(MonsterAI), "m_targetCreature");

		private static readonly FieldInfo TargetStaticField = AccessTools.Field(typeof(MonsterAI), "m_targetStatic");

		private static Sprite _combatSprite;

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(EnemyHud __instance)
		{
			if ((Object)(object)__instance == (Object)null || HudsField == null || CharacterField == null || AlertedField == null || AwareField == null || !(HudsField.GetValue(__instance) is IDictionary dictionary) || dictionary.Count == 0)
			{
				return;
			}
			EnsureSprites();
			foreach (DictionaryEntry item in dictionary)
			{
				UpdateSummonHud(item.Value);
			}
		}

		private static void UpdateSummonHud(object hudData)
		{
			if (hudData == null)
			{
				return;
			}
			object? obj = CharacterField?.GetValue(hudData);
			Character val = (Character)((obj is Character) ? obj : null);
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			if ((Object)(object)val == (Object)null || !((Component)val).TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
			{
				return;
			}
			object? obj2 = AlertedField?.GetValue(hudData);
			RectTransform val2 = (RectTransform)((obj2 is RectTransform) ? obj2 : null);
			object? obj3 = AwareField?.GetValue(hudData);
			RectTransform val3 = (RectTransform)((obj3 is RectTransform) ? obj3 : null);
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
			{
				SetVisible(val2, visible: false);
				if (!HasRealCombatTarget(val))
				{
					SetVisible(val3, visible: false);
					return;
				}
				ApplySprite(val3, _combatSprite);
				SetVisible(val3, (Object)(object)_combatSprite != (Object)null);
			}
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static bool HasRealCombatTarget(Character character)
		{
			BaseAI baseAI = character.GetBaseAI();
			MonsterAI val = (MonsterAI)(object)((baseAI is MonsterAI) ? baseAI : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			object? obj = TargetCreatureField?.GetValue(val);
			Character val2 = (Character)((obj is Character) ? obj : null);
			if ((Object)(object)val2 != (Object)null && !val2.IsDead() && BaseAI.IsEnemy(character, val2))
			{
				return true;
			}
			object? obj2 = TargetStaticField?.GetValue(val);
			StaticTarget val3 = (StaticTarget)((obj2 is StaticTarget) ? obj2 : null);
			return (Object)(object)val3 != (Object)null;
		}

		private static void EnsureSprites()
		{
			if (_combatSprite == null)
			{
				_combatSprite = Vikings_Summoner_AssetLoader.GetSprite("ico_summon_combat");
			}
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void ApplySprite(RectTransform rect, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Sprite sprite)
		{
			if (!((Object)(object)sprite == (Object)null))
			{
				Image val = ((Component)rect).GetComponent<Image>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)rect).GetComponentInChildren<Image>(true);
				}
				if (!((Object)(object)val == (Object)null) && (Object)(object)val.sprite != (Object)(object)sprite)
				{
					val.sprite = sprite;
				}
			}
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void SetVisible(RectTransform rect, bool visible)
		{
			if (((Component)rect).gameObject.activeSelf != visible)
			{
				((Component)rect).gameObject.SetActive(visible);
			}
		}
	}
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
	internal static class Patch_MonsterAI_UpdateAI_SummonOwnerFollow
	{
		internal static float GroundStopDistance = 6f;

		internal static float FlyingStopDistanceHorizontal = 10f;

		internal static float FlyingFollowHeightOffset = 2.5f;

		internal static float FlyingVerticalTolerance = 1.5f;

		internal static float FlyingVerticalDeadzone = 0.75f;

		private const float MinMoveSqrMagnitude = 0.0001f;

		private static void Postfix(MonsterAI __instance, float dt, bool __result)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			if ((Object)(object)__instance == (Object)null || !__result || !((Component)__instance).TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
			{
				return;
			}
			ZNetView component = ((Component)__instance).GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid() || !component.IsOwner())
			{
				return;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return;
			}
			Player val = ResolveOwnerPlayer(zDO);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Character component2 = ((Component)__instance).GetComponent<Character>();
			if ((Object)(object)component2 == (Object)null)
			{
				return;
			}
			Character targetCreature = ((BaseAI)__instance).GetTargetCreature();
			StaticTarget staticTarget = __instance.GetStaticTarget();
			if (!((Object)(object)staticTarget != (Object)null) && (!((Object)(object)targetCreature != (Object)null) || targetCreature.IsDead() || !((BaseAI)__instance).IsEnemy(targetCreature)))
			{
				Vector3 position = ((Component)val).transform.position;
				Vector3 position2 = ((Component)__instance).transform.position;
				if (!component2.m_flying)
				{
					MoveGround(__instance, position, position2);
				}
				else
				{
					MoveFlying(__instance, position, position2);
				}
			}
		}

		private static void MoveGround(MonsterAI ai, Vector3 ownerPos, Vector3 summonPos)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(ownerPos.x - summonPos.x, 0f, ownerPos.z - summonPos.z);
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < GroundStopDistance)
			{
				((BaseAI)ai).StopMoving();
			}
			else if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
			{
				((BaseAI)ai).StopMoving();
			}
			else
			{
				((BaseAI)ai).MoveTowards(((Vector3)(ref val)).normalized, true);
			}
		}

		private static void MoveFlying(MonsterAI ai, Vector3 ownerPos, Vector3 summonPos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ownerPos + Vector3.up * FlyingFollowHeightOffset;
			Vector3 val2 = val - summonPos;
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(val2.x, 0f, val2.z);
			float magnitude = ((Vector3)(ref val3)).magnitude;
			float num = Mathf.Abs(val2.y);
			bool flag = magnitude < FlyingStopDistanceHorizontal;
			bool flag2 = num <= FlyingVerticalTolerance;
			if (flag && flag2)
			{
				((BaseAI)ai).StopMoving();
				return;
			}
			if (num <= FlyingVerticalDeadzone)
			{
				val2.y = 0f;
			}
			if (((Vector3)(ref val2)).sqrMagnitude <= 0.0001f)
			{
				((BaseAI)ai).StopMoving();
			}
			else
			{
				((BaseAI)ai).MoveTowards(((Vector3)(ref val2)).normalized, true);
			}
		}

		[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)]
		private static Player ResolveOwnerPlayer(ZDO zdo)
		{
			string text = zdo.GetString("VS_OwnerSteamID", string.Empty).Trim();
			if (text.Length == 0)
			{
				return null;
			}
			List<Player> allPlayers = Player.GetAllPlayers();
			if (allPlayers == null || allPlayers.Count == 0)
			{
				return null;
			}
			for (int i = 0; i < allPlayers.Count; i++)
			{
				Player val = allPlayers[i];
				if (!((Object)(object)val == (Object)null) && VS_SteamOwnerIdentity.TryGetSteamIdentity(val, out var steamId, out var _) && string.Equals(text, steamId.Trim(), StringComparison.Ordinal))
				{
					return val;
				}
			}
			return null;
		}
	}
	internal static class Registrations_Mobs_Hp
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		internal static float CalculateFinalHp(Mob_Registry.SummonDef def, int level)
		{
			float num = Mathf.Max(1f, def.BaseHpCE.Value);
			float num2 = Mathf.Max(0f, def.HpPercentPerStarCE.Value);
			int num3 = Mathf.Max(0, level - 1);
			return Mathf.Max(1f, num * (1f + (float)num3 * (num2 / 100f)));
		}
	}
	[HarmonyPatch(typeof(Character), "SetupMaxHealth")]
	internal static class Patch_Character_SetupMaxHealth_SummonHp
	{
		private readonly struct State
		{
			internal readonly float OldMaxHealth;

			internal readonly float OldHealth;

			internal State(float oldMaxHealth, float oldHealth)
			{
				OldMaxHealth = oldMaxHealth;
				OldHealth = oldHealth;
			}
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Prefix(Character __instance, out State __state)
		{
			__state = (((Object)(object)__instance == (Object)null) ? default(State) : new State(__instance.GetMaxHealth(), __instance.GetHealth()));
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(Character __instance, State __state)
		{
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			if (!((Object)(object)__instance == (Object)null) && ((Component)__instance).TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
			{
				string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
				if (Mob_Registry.TryGet(prefabName, out var def) && def != null)
				{
					int level = Mathf.Max(1, __instance.GetLevel());
					float num = Registrations_Mobs_Hp.CalculateFinalHp(def, level);
					float num2 = Mathf.Max(1f, __state.OldMaxHealth);
					float num3 = Mathf.Max(0f, __state.OldHealth);
					bool flag = num3 >= num2 - 0.01f;
					float num4 = Mathf.Clamp01(num3 / num2);
					__instance.SetMaxHealth(num);
					__instance.SetHealth(flag ? num : Mathf.Clamp(num * num4, 0f, num));
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZNet), "Awake")]
	internal static class Patch_ZNet_Awake_SummonOwnerCleanupRpc
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(ZNet __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<VS_SummonOwnerCleanupRpcRegistrar>()))
			{
				((Component)__instance).gameObject.AddComponent<VS_SummonOwnerCleanupRpcRegistrar>();
			}
		}
	}
	internal sealed class VS_SummonOwnerCleanupRpcRegistrar : MonoBehaviour
	{
		private static bool _registered;

		private float _tick;

		private void Update()
		{
			if (_registered)
			{
				((Behaviour)this).enabled = false;
				return;
			}
			_tick -= Time.deltaTime;
			if (!(_tick > 0f))
			{
				_tick = 0.25f;
				if (ZRoutedRpc.instance != null)
				{
					_registered = true;
					ZRoutedRpc.instance.Register<string, int>("VS_RPC_RemoveOwnedSummons", (Action<long, string, int>)VS_SummonOwnerCleanup.RPC_RemoveOwnedSummons);
					((Behaviour)this).enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnDeath")]
	internal static class Patch_Player_OnDeath_RemoveOwnedSummons
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(Player __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				VS_SummonOwnerCleanup.RequestRemoveOwnedSummons(__instance, VS_SummonRemovalReason.OwnerDeath);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "TeleportTo", new Type[]
	{
		typeof(Vector3),
		typeof(Quaternion),
		typeof(bool)
	})]
	internal static class Patch_Player_TeleportTo_RemoveOwnedSummons
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Prefix(Player __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				VS_SummonOwnerCleanup.RequestRemoveOwnedSummons(__instance, VS_SummonRemovalReason.OwnerTeleport);
			}
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal static class VS_SummonOwnerCleanup
	{
		internal static void RequestRemoveOwnedSummons(Player owner, VS_SummonRemovalReason reason)
		{
			if ((Object)(object)owner == (Object)null || !VS_SteamOwnerIdentity.TryGetSteamIdentity(owner, out var steamId, out var _))
			{
				return;
			}
			steamId = VS_SteamOwnerIdentity.NormalizeOwnerId(steamId);
			if (!string.IsNullOrWhiteSpace(steamId))
			{
				RemoveOwnedSummonsBySteamId(steamId, reason);
				if (!VS_SummonState.IsServer() && ZRoutedRpc.instance != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC("VS_RPC_RemoveOwnedSummons", new object[2]
					{
						steamId,
						(int)reason
					});
				}
			}
		}

		internal static void RPC_RemoveOwnedSummons(long sender, string steamId, int reason)
		{
			if (VS_SummonState.IsServer())
			{
				steamId = VS_SteamOwnerIdentity.NormalizeOwnerId(steamId);
				if (!string.IsNullOrWhiteSpace(steamId))
				{
					VS_SummonRemovalReason reason2 = (Enum.IsDefined(typeof(VS_SummonRemovalReason), reason) ? ((VS_SummonRemovalReason)reason) : VS_SummonRemovalReason.OwnerDeath);
					RemoveOwnedSummonsBySteamId(steamId, reason2);
				}
			}
		}

		private static void RemoveOwnedSummonsBySteamId(string steamId, VS_SummonRemovalReason reason)
		{
			if (string.IsNullOrWhiteSpace(steamId))
			{
				return;
			}
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null || allCharacters.Count == 0)
			{
				return;
			}
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			for (int num = allCharacters.Count - 1; num >= 0; num--)
			{
				Character val = allCharacters[num];
				if (!((Object)(object)val == (Object)null) && Object.op_Implicit((Object)(object)val) && !val.IsDead() && ((Component)val).TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
				{
					ZNetView component = ((Component)val).GetComponent<ZNetView>();
					if (!((Object)(object)component == (Object)null) && component.IsValid())
					{
						ZDO zDO = component.GetZDO();
						if (zDO != null && VS_SteamOwnerIdentity.IsSameOwner(zDO, steamId))
						{
							VS_SummonRemoval.TryRemove(((Component)val).gameObject, reason);
						}
					}
				}
			}
		}
	}
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
	internal static class Registrations_Mobs_Lifetime_UpgradeTotem
	{
		internal static ItemData ResolveWeapon(Character owner, ItemData weapon)
		{
			if (weapon != null && (Object)(object)weapon.m_dropPrefab != (Object)null)
			{
				return weapon;
			}
			Humanoid val = (Humanoid)(object)((owner is Humanoid) ? owner : null);
			if (val == null)
			{
				return null;
			}
			ItemData currentWeapon = val.GetCurrentWeapon();
			if (currentWeapon != null && (Object)(object)currentWeapon.m_dropPrefab != (Object)null)
			{
				return currentWeapon;
			}
			return null;
		}

		internal static float GetBonusSeconds(Character owner, ItemData weapon)
		{
			ItemData val = ResolveWeapon(owner, weapon);
			if (val == null || (Object)(object)val.m_dropPrefab == (Object)null)
			{
				return 0f;
			}
			int num = Mathf.Max(val.m_quality, 1);
			if (num <= 1)
			{
				return 0f;
			}
			string prefabName = Utils.GetPrefabName(val.m_dropPrefab);
			if (string.IsNullOrEmpty(prefabName))
			{
				return 0f;
			}
			float num2 = Mathf.Max(Vikings_SummonerPlugin.GetLifetimeUpgradeTotemCE(prefabName).Value, 0f);
			if (num2 <= 0f)
			{
				return 0f;
			}
			return (float)(num - 1) * num2;
		}

		internal static float GetFinalLifetimeSeconds([<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)] string summonPrefab, Character owner, ItemData weapon)
		{
			float num = Mathf.Max(Vikings_SummonerPlugin.GetLifetimeCE(summonPrefab).Value, 0.01f);
			float bonusSeconds = GetBonusSeconds(owner, weapon);
			return Mathf.Max(num + bonusSeconds, 0.01f);
		}
	}
	internal static class Registrations_Mobs_OwnerDebuff
	{
		internal static void Register()
		{
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal sealed class VS_SummonOwnerRegenDebuff : SE_Stats
	{
		internal const string EffectName = "SE_VS_SummonOwnerRegenDebuff";

		public override string GetIconText()
		{
			Character character = ((StatusEffect)this).m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val == null)
			{
				return "";
			}
			int num = VS_SummonOwnerDebuffRuntime.CountActiveSummons(val);
			return (num > 0) ? num.ToString() : "";
		}

		public override string GetTooltipString()
		{
			int num = 0;
			Character character = ((StatusEffect)this).m_character;
			Player val = (Player)(object)((character is Player) ? character : null);
			if (val != null)
			{
				num = VS_SummonOwnerDebuffRuntime.CountActiveSummons(val);
			}
			float num2 = Mathf.Max(0f, (1f - base.m_healthRegenMultiplier) * 100f);
			string text = ((StatusEffect)this).m_tooltip;
			if (Localization.instance != null && !string.IsNullOrWhiteSpace(text))
			{
				text = Localization.instance.Localize(text);
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			return string.Format(text, num, num2.ToString("0.#"));
		}
	}
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	internal static class VS_SummonOwnerDebuffRuntime
	{
		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)]
		private static VS_SummonOwnerRegenDebuff _template;

		private static readonly int EffectHash = StringExtensionMethods.GetStableHashCode("SE_VS_SummonOwnerRegenDebuff");

		internal static void EnsureRegistered()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_template != (Object)null))
			{
				_template = ScriptableObject.CreateInstance<VS_SummonOwnerRegenDebuff>();
				((Object)_template).name = "SE_VS_SummonOwnerRegenDebuff";
				((StatusEffect)_template).m_name = "$vs_summon_regen_burden_name";
				((StatusEffect)_template).m_tooltip = "$vs_summon_regen_burden_tooltip";
				((StatusEffect)_template).m_category = "Equipment";
				((StatusEffect)_template).m_icon = Vikings_Summoner_AssetLoader.GetSprite("ico_debuff");
				((StatusEffect)_template).m_flashIcon = false;
				((StatusEffect)_template).m_cooldownIcon = false;
				((StatusEffect)_template).m_startMessageType = (MessageType)2;
				((StatusEffect)_template).m_startMessage = "";
				((StatusEffect)_template).m_stopMessageType = (MessageType)2;
				((StatusEffect)_template).m_stopMessage = "";
				((StatusEffect)_template).m_ttl = 0f;
				((SE_Stats)_template).m_healthRegenMultiplier = 1f;
			}
		}

		internal static void EnsureInObjectDb()
		{
			EnsureRegistered();
			if (!((Object)(object)ObjectDB.instance == (Object)null) && !((Object)(object)_template == (Object)null) && !ObjectDB.instance.m_StatusEffects.Contains((StatusEffect)(object)_template))
			{
				ObjectDB.instance.m_StatusEffects.Add((StatusEffect)(object)_template);
				ObjectDB.instance.UpdateRegisters();
			}
		}

		internal static int CountActiveSummons(Player owner)
		{
			if (!TryResolveOwner(owner, out var steamId, out var _))
			{
				return 0;
			}
			int num = 0;
			List<Character> allCharacters = Character.GetAllCharacters();
			if (allCharacters == null || allCharacters.Count == 0)
			{
				return 0;
			}
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			for (int i = 0; i < allCharacters.Count; i++)
			{
				Character val = allCharacters[i];
				if (!Object.op_Implicit((Object)(object)val) || !((Component)val).TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker) || val.IsDead())
				{
					continue;
				}
				ZNetView component = ((Component)val).GetComponent<ZNetView>();
				if (!((Object)(object)component == (Object)null) && component.IsValid())
				{
					ZDO zDO = component.GetZDO();
					if (zDO != null && !zDO.GetBool("vs_summon_removing", false) && VS_SteamOwnerIdentity.IsSameOwner(zDO, steamId))
					{
						num++;
					}
				}
			}
			return num;
		}

		internal static float CalculateHealthRegenMultiplier(int activeSummons)
		{
			float num = Mathf.Max(0f, Vikings_SummonerPlugin.CE_ActiveSummonHealthRegenPenaltyPerSummon.Value);
			return Mathf.Max(0f, 1f - (float)activeSummons * num);
		}

		internal static void UpdateDebuff(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			SEMan seman = ((Character)player).m_seman;
			if (seman == null)
			{
				return;
			}
			if (!Vikings_SummonerPlugin.CE_ActiveSummonHealthRegenDebuffEnabled.Value)
			{
				seman.RemoveStatusEffect(EffectHash, true);
				return;
			}
			if (!TryResolveOwner(player, out var _, out var _))
			{
				seman.RemoveStatusEffect(EffectHash, true);
				return;
			}
			int num = CountActiveSummons(player);
			if (num <= 0)
			{
				seman.RemoveStatusEffect(EffectHash, true);
				return;
			}
			EnsureInObjectDb();
			StatusEffect statusEffect = seman.GetStatusEffect(EffectHash);
			VS_SummonOwnerRegenDebuff vS_SummonOwnerRegenDebuff = statusEffect as VS_SummonOwnerRegenDebuff;
			if ((Object)(object)vS_SummonOwnerRegenDebuff == (Object)null)
			{
				statusEffect = seman.AddStatusEffect(EffectHash, true, 0, 0f);
				vS_SummonOwnerRegenDebuff = statusEffect as VS_SummonOwnerRegenDebuff;
				if ((Object)(object)vS_SummonOwnerRegenDebuff == (Object)null)
				{
					return;
				}
			}
			((SE_Stats)vS_SummonOwnerRegenDebuff).m_healthRegenMultiplier = CalculateHealthRegenMultiplier(num);
		}

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
		internal static void EnsureUpdater(Player player)
		{
			VS_SummonOwnerDebuffUpdater vS_SummonOwnerDebuffUpdater = default(VS_SummonOwnerDebuffUpdater);
			if (!((Object)(object)player == (Object)null) && TryResolveOwner(player, out var _, out var _) && !((Component)player).TryGetComponent<VS_SummonOwnerDebuffUpdater>(ref vS_SummonOwnerDebuffUpdater))
			{
				((Component)player).gameObject.AddComponent<VS_SummonOwnerDebuffUpdater>();
			}
		}

		internal static bool HasValidOwnerIdentity(Player player)
		{
			string steamId;
			string ownerName;
			return TryResolveOwner(player, out steamId, out ownerName);
		}

		private static bool TryResolveOwner(Player player, out string steamId, out string ownerName)
		{
			return VS_SteamOwnerIdentity.TryGetSteamIdentity(player, out steamId, out ownerName);
		}
	}
	internal sealed class VS_SummonOwnerDebuffUpdater : MonoBehaviour
	{
		private const float UpdateInterval = 1f;

		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)]
		private Player _player;

		private float _tick;

		private void Awake()
		{
			_player = ((Component)this).GetComponent<Player>();
			_tick = 0f;
		}

		private void Update()
		{
			if (!((Object)(object)_player == (Object)null) && !((Character)_player).IsDead() && VS_SummonOwnerDebuffRuntime.HasValidOwnerIdentity(_player))
			{
				_tick -= Time.deltaTime;
				if (!(_tick > 0f))
				{
					_tick = 1f;
					VS_SummonOwnerDebuffRuntime.UpdateDebuff(_player);
				}
			}
		}

		private void OnDestroy()
		{
			if (((Character)(_player?)).m_seman != null)
			{
				((Character)_player).m_seman.RemoveStatusEffect(StringExtensionMethods.GetStableHashCode("SE_VS_SummonOwnerRegenDebuff"), true);
			}
		}
	}
	[HarmonyPatch(typeof(ObjectDB), "Awake")]
	internal static class Patch_ObjectDB_Awake_SummonOwnerDebuff
	{
		private static void Postfix()
		{
			VS_SummonOwnerDebuffRuntime.EnsureInObjectDb();
		}
	}
	[HarmonyPatch(typeof(Player), "SetPlayerID", new Type[]
	{
		typeof(long),
		typeof(string)
	})]
	internal static class Patch_Player_SetPlayerID_SummonOwnerDebuff
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(Player __instance, long playerID, string name)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				VS_SummonOwnerDebuffRuntime.EnsureUpdater(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "Start")]
	internal static class Patch_Player_Start_SummonOwnerDebuff
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static void Postfix(Player __instance)
		{
			VS_SummonOwnerDebuffRuntime.EnsureUpdater(__instance);
		}
	}
	internal readonly struct VS_SummonProgressionEntry
	{
		internal readonly int MinSkill;

		internal readonly int MaxSkill;

		internal readonly int SummonLevel;

		internal readonly int MaxInstances;

		internal VS_SummonProgressionEntry(int minSkill, int maxSkill, int summonLevel, int maxInstances)
		{
			MinSkill = minSkill;
			MaxSkill = maxSkill;
			SummonLevel = ((summonLevel < 1) ? 1 : summonLevel);
			MaxInstances = ((maxInstances < 1) ? 1 : maxInstances);
		}
	}
	internal readonly struct VS_SummonProgressionResult
	{
		internal readonly int SummonLevel;

		internal readonly int MaxInstances;

		internal VS_SummonProgressionResult(int summonLevel, int maxInstances)
		{
			SummonLevel = ((summonLevel < 1) ? 1 : summonLevel);
			MaxInstances = ((maxInstances < 1) ? 1 : maxInstances);
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal static class VS_SummonProgression
	{
		internal static bool TryGetGateFromConfig(string prefab, out int minGate)
		{
			minGate = 0;
			if (!TryParse(prefab, out var result))
			{
				return false;
			}
			if (result.Count == 0)
			{
				return false;
			}
			minGate = result[0].MinSkill;
			for (int i = 1; i < result.Count; i++)
			{
				if (result[i].MinSkill < minGate)
				{
					minGate = result[i].MinSkill;
				}
			}
			return true;
		}

		internal static bool TryResolve(string prefab, float bloodMagic, out VS_SummonProgressionResult result)
		{
			result = default(VS_SummonProgressionResult);
			if (!TryParse(prefab, out var result2))
			{
				return false;
			}
			if (result2.Count == 0)
			{
				return false;
			}
			int num = Mathf.FloorToInt(bloodMagic);
			VS_SummonProgressionEntry? vS_SummonProgressionEntry = null;
			for (int i = 0; i < result2.Count; i++)
			{
				VS_SummonProgressionEntry value = result2[i];
				if (num < value.MinSkill)
				{
					break;
				}
				vS_SummonProgressionEntry = value;
			}
			if (!vS_SummonProgressionEntry.HasValue)
			{
				return false;
			}
			result = new VS_SummonProgressionResult(vS_SummonProgressionEntry.Value.SummonLevel, vS_SummonProgressionEntry.Value.MaxInstances);
			return true;
		}

		internal static VS_SummonProgressionResult Resolve(string prefab, float bloodMagic)
		{
			if (TryResolve(prefab, bloodMagic, out var result))
			{
				return result;
			}
			throw new InvalidOperationException($"Invalid summon progression config for prefab '{prefab}' or Blood Magic '{bloodMagic}'.");
		}

		private static bool TryParse(string prefab, out List<VS_SummonProgressionEntry> result)
		{
			result = new List<VS_SummonProgressionEntry>();
			ConfigEntry<string> progressionCE = Vikings_SummonerPlugin.GetProgressionCE(prefab);
			if (progressionCE == null)
			{
				return false;
			}
			string value = progressionCE.Value;
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string[] array = value.Split(new char[1] { ';' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					return false;
				}
				string[] array2 = text.Split(new char[1] { ':' });
				if (array2.Length != 3)
				{
					return false;
				}
				string[] array3 = array2[0].Split(new char[1] { '-' });
				if (array3.Length != 2)
				{
					return false;
				}
				if (!int.TryParse(array3[0].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result2))
				{
					return false;
				}
				if (!int.TryParse(array3[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result3))
				{
					return false;
				}
				if (!int.TryParse(array2[1].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result4))
				{
					return false;
				}
				if (!int.TryParse(array2[2].Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result5))
				{
					return false;
				}
				if (result2 < 0)
				{
					return false;
				}
				if (result3 < result2)
				{
					return false;
				}
				if (result4 < 1)
				{
					return false;
				}
				if (result5 < 1)
				{
					return false;
				}
				result.Add(new VS_SummonProgressionEntry(result2, result3, result4, result5));
			}
			result.Sort(delegate(VS_SummonProgressionEntry a, VS_SummonProgressionEntry b)
			{
				int minSkill = a.MinSkill;
				return minSkill.CompareTo(b.MinSkill);
			});
			return result.Count > 0;
		}

		internal static void EnforceMaxInstances(string prefab, Humanoid owner, int maxInstances)
		{
			maxInstances = Mathf.Max(0, maxInstances);
			Player val = (Player)(object)((owner is Player) ? owner : null);
			if (val == null || !TryResolveOwner(val, out var steamId, out var ownerName))
			{
				return;
			}
			List<BaseAI> list = new List<BaseAI>();
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (!Object.op_Implicit((Object)(object)allCharacter) || !Object.op_Implicit((Object)(object)((Component)allCharacter).GetComponent<VS_SummonMarker>()))
				{
					continue;
				}
				string basePrefab = VS_SummonState.GetBasePrefab(((Component)allCharacter).gameObject);
				if (!string.Equals(basePrefab, prefab, StringComparison.Ordinal))
				{
					continue;
				}
				ZNetView component = ((Component)allCharacter).GetComponent<ZNetView>();
				if (!Object.op_Implicit((Object)(object)component) || !component.IsValid())
				{
					continue;
				}
				ZDO zDO = component.GetZDO();
				if (zDO != null && VS_SteamOwnerIdentity.IsSameOwner(zDO, steamId))
				{
					VS_SteamOwnerIdentity.RepairOwnerZDO(component, zDO, steamId, ownerName);
					BaseAI component2 = ((Component)allCharacter).GetComponent<BaseAI>();
					if (!((Object)(object)component2 == (Object)null))
					{
						list.Add(component2);
					}
				}
			}
			list.Sort((BaseAI a, BaseAI b) => b.GetTimeSinceSpawned().CompareTo(a.GetTimeSinceSpawned()));
			int num = list.Count - maxInstances;
			for (int i = 0; i < num; i++)
			{
				TryUnsummonNow(((Component)list[i]).gameObject);
			}
			if (num > 0)
			{
				((Character)val).Message((MessageType)2, "$hud_maxsummonsreached", 0, (Sprite)null);
			}
		}

		internal static void EnforceAllSummonLimits(Humanoid owner)
		{
			Player val = (Player)(object)((owner is Player) ? owner : null);
			if (val == null || !TryResolveOwner(val, out var steamId, out var ownerName))
			{
				return;
			}
			Skills skills = ((Character)owner).GetSkills();
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			float skillLevel = skills.GetSkillLevel((SkillType)10);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (!Object.op_Implicit((Object)(object)allCharacter) || !Object.op_Implicit((Object)(object)((Component)allCharacter).GetComponent<VS_SummonMarker>()))
				{
					continue;
				}
				ZNetView component = ((Component)allCharacter).GetComponent<ZNetView>();
				if (!Object.op_Implicit((Object)(object)component) || !component.IsValid())
				{
					continue;
				}
				ZDO zDO = component.GetZDO();
				if (zDO != null && VS_SteamOwnerIdentity.IsSameOwner(zDO, steamId))
				{
					VS_SteamOwnerIdentity.RepairOwnerZDO(component, zDO, steamId, ownerName);
					string basePrefab = VS_SummonState.GetBasePrefab(((Component)allCharacter).gameObject);
					if (!string.IsNullOrEmpty(basePrefab) && Mob_Registry.All.ContainsKey(basePrefab))
					{
						hashSet.Add(basePrefab);
					}
				}
			}
			foreach (string item in hashSet)
			{
				if (!TryResolve(item, skillLevel, out var result))
				{
					EnforceMaxInstances(item, owner, 0);
					continue;
				}
				int maxInstances = SE_SummonExtra.ApplyExtraMaxSummons(owner, result.MaxInstances);
				EnforceMaxInstances(item, owner, maxInstances);
			}
		}

		private static bool TryResolveOwner(Player p, out string steamId, out string ownerName)
		{
			return VS_SteamOwnerIdentity.TryGetSteamIdentity(p, out steamId, out ownerName);
		}

		private static void TryUnsummonNow(GameObject go)
		{
			VS_SummonRemoval.TryRemove(go, VS_SummonRemovalReason.ProgressionLimit);
		}
	}
	internal enum VS_SummonRemovalReason
	{
		Manual,
		LifetimeExpired,
		OwnerDeath,
		OwnerTeleport,
		ProgressionLimit,
		DeathCleanup,
		OwnerIdentityFailed
	}
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	internal static class VS_SummonRemoval
	{
		internal const string ZdoRemoving = "vs_summon_removing";

		internal const string ZdoRemovingAtTicks = "vs_summon_removing_at";

		internal static bool TryRemove(GameObject go, VS_SummonRemovalReason reason)
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)go))
			{
				return false;
			}
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			if (!go.TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
			{
				return false;
			}
			ZNetView component = go.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			ZDO zDO = component.GetZDO();
			if (zDO == null)
			{
				return false;
			}
			if (zDO.GetBool("vs_summon_removing", false))
			{
				return false;
			}
			if (!component.IsOwner() && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				component.ClaimOwnership();
			}
			if (!component.IsOwner())
			{
				return false;
			}
			zDO.Set("vs_summon_removing", true);
			zDO.Set("vs_summon_removing_at", VS_SummonTime.NowTicks());
			VS_SummonVfxProfile component2 = go.GetComponent<VS_SummonVfxProfile>();
			if (reason != VS_SummonRemovalReason.DeathCleanup && (Object)(object)component2 != (Object)null && component2.UnSummonEffect != null && component2.UnSummonEffect.HasEffects())
			{
				component2.UnSummonEffect.Create(go.transform.position, go.transform.rotation, (Transform)null, 1f, -1);
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				ZNetScene.instance.Destroy(go);
			}
			else
			{
				component.Destroy();
			}
			return true;
		}

		internal static bool TryRemove(Component c, VS_SummonRemovalReason reason)
		{
			return (Object)(object)c != (Object)null && TryRemove(c.gameObject, reason);
		}

		internal static bool TryForceDestroy(GameObject go)
		{
			if (!Object.op_Implicit((Object)(object)go))
			{
				return false;
			}
			VS_SummonMarker vS_SummonMarker = default(VS_SummonMarker);
			if (!go.TryGetComponent<VS_SummonMarker>(ref vS_SummonMarker))
			{
				return false;
			}
			ZNetView component = go.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				return false;
			}
			if (!component.IsOwner() && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				component.ClaimOwnership();
			}
			if (!component.IsOwner())
			{
				return false;
			}
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				ZNetScene.instance.Destroy(go);
			}
			else
			{
				component.Destroy();
			}
			return true;
		}
	}
	internal static class Registrations_Mobs_SpawnAbility
	{
		internal static void Register()
		{
			Mob_Registry.Init();
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal static class VS_SpawnAbilityScope
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(0)]
		private sealed class Marker
		{
		}

		private static readonly ConditionalWeakTable<SpawnAbility, Marker> Marked = new ConditionalWeakTable<SpawnAbility, Marker>();

		internal static bool TryGetSummonPrefabs(SpawnAbility sa, out List<GameObject> prefabs)
		{
			prefabs = new List<GameObject>();
			if ((Object)(object)sa == (Object)null || sa.m_spawnPrefab == null || sa.m_spawnPrefab.Length == 0)
			{
				return false;
			}
			for (int i = 0; i < sa.m_spawnPrefab.Length; i++)
			{
				GameObject val = sa.m_spawnPrefab[i];
				if (!Object.op_Implicit((Object)(object)val))
				{
					return false;
				}
				string prefabName = Utils.GetPrefabName(((Object)val).name);
				if (string.IsNullOrEmpty(prefabName))
				{
					return false;
				}
				if (!Mob_Registry.All.ContainsKey(prefabName))
				{
					return false;
				}
				prefabs.Add(val);
			}
			return prefabs.Count > 0;
		}

		internal static bool IsMarked(SpawnAbility sa)
		{
			Marker value;
			return (Object)(object)sa != (Object)null && Marked.TryGetValue(sa, out value);
		}

		internal static void Mark(SpawnAbility sa)
		{
			if (!((Object)(object)sa == (Object)null))
			{
				Unmark(sa);
				Marked.Add(sa, new Marker());
			}
		}

		internal static void Unmark(SpawnAbility sa)
		{
			if (!((Object)(object)sa == (Object)null))
			{
				Marked.Remove(sa);
			}
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal static class VS_SpawnAbilityContextStore
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
		private sealed class SpawnSetupContext
		{
			internal Character Owner;

			internal ItemData Weapon;
		}

		private static readonly ConditionalWeakTable<SpawnAbility, SpawnSetupContext> Table = new ConditionalWeakTable<SpawnAbility, SpawnSetupContext>();

		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
		internal static void Set([<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)] SpawnAbility ability, Character owner, ItemData weapon)
		{
			if (!((Object)(object)ability == (Object)null))
			{
				Table.Remove(ability);
				Table.Add(ability, new SpawnSetupContext
				{
					Owner = owner,
					Weapon = weapon
				});
			}
		}

		[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)]
		internal static Character GetOwner(SpawnAbility ability)
		{
			SpawnSetupContext value;
			return ((Object)(object)ability != (Object)null && Table.TryGetValue(ability, out value)) ? value.Owner : null;
		}

		[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)]
		internal static ItemData GetWeapon(SpawnAbility ability)
		{
			SpawnSetupContext value;
			return ((Object)(object)ability != (Object)null && Table.TryGetValue(ability, out value)) ? value.Weapon : null;
		}

		internal static void Clear(SpawnAbility ability)
		{
			if (!((Object)(object)ability == (Object)null))
			{
				Table.Remove(ability);
			}
		}
	}
	[HarmonyPatch(typeof(SpawnAbility), "Setup")]
	internal static class Patch_SpawnAbility_Setup_SummonMark
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
		private static bool Prefix(SpawnAbility __instance, Character owner, ItemData item)
		{
			VS_SpawnAbilityContextStore.Set(__instance, owner, item);
			if (VS_SummonSpawnAbility.ShouldBlockSetup(__instance, owner))
			{
				VS_SpawnAbilityScope.Unmark(__instance);
				VS_SpawnAbilityContextStore.Clear(__instance);
				return false;
			}
			VS_SummonSpawnAbility.TryMarkFromSetup(__instance);
			return true;
		}
	}
	[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(1)]
	[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
	internal static class VS_SummonSpawnAbility
	{
		[<d0224abe-9e35-4939-ae60-73d7162dcac6>NullableContext(2)]
		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
		private readonly struct SpawnContext
		{
			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)]
			internal readonly SpawnAbility Ability;

			internal readonly Character Owner;

			internal readonly ItemData Weapon;

			internal readonly Skills Skills;

			internal readonly float BloodMagic;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)]
			internal readonly List<GameObject> Prefabs;

			internal SpawnContext([<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)] SpawnAbility ability, Character owner, ItemData weapon, Skills skills, float bloodMagic, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(1)] List<GameObject> prefabs)
			{
				Ability = ability;
				Owner = owner;
				Weapon = weapon;
				Skills = skills;
				BloodMagic = bloodMagic;
				Prefabs = prefabs;
			}
		}

		[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
		private readonly struct ValidSummonPrefab
		{
			internal readonly GameObject Prefab;

			internal readonly string Name;

			internal readonly VS_SummonProgressionResult Progression;

			internal ValidSummonPrefab(GameObject prefab, string name, VS_SummonProgressionResult progression)
			{
				Prefab = prefab;
				Name = name;
				Progression = progression;
			}
		}

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

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

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

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private object <>2__current;

			public SpawnContext ctx;

			public int index;

			public int spawnCount;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private SpawnAbility <sa>5__1;

			private Vector3 <targetPosition>5__2;

			private Vector3 <spawnPoint>5__3;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private GameObject <prefab>5__4;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private string <summonPrefab>5__5;

			private VS_SummonProgressionResult <progression>5__6;

			private int <finalMaxInstances>5__7;

			private float <finalLifetime>5__8;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private GameObject <go>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sa>5__1 = null;
				<prefab>5__4 = null;
				<summonPrefab>5__5 = null;
				<go>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Expected O, but got Unknown
				//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d7: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sa>5__1 = ctx.Ability;
					if (!TryResolveSpawnPoint(ctx, index, spawnCount, out <targetPosition>5__2, out <spawnPoint>5__3))
					{
						return false;
					}
					if (!TrySelectSummonPrefab(ctx.Prefabs, ctx.BloodMagic, out <prefab>5__4, out <summonPrefab>5__5, out <progression>5__6))
					{
						ShowBloodMagicGateMessageIfPossible(ctx);
						return false;
					}
					<finalMaxInstances>5__7 = SE_SummonExtra.ApplyExtraMaxSummons(ctx.Owner, <progression>5__6.MaxInstances);
					<finalLifetime>5__8 = Registrations_Mobs_Lifetime_UpgradeTotem.GetFinalLifetimeSeconds(<summonPrefab>5__5, ctx.Owner, ctx.Weapon);
					<sa>5__1.m_preSpawnEffects.Create(<spawnPoint>5__3, Quaternion.identity, (Transform)null, 1f, -1);
					if (<sa>5__1.m_preSpawnDelay > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<sa>5__1.m_preSpawnDelay);
						<>1__state = 1;
						return true;
					}
					goto IL_0158;
				case 1:
					<>1__state = -1;
					goto IL_0158;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0158:
					<go>5__9 = SpawnSummonInstance(<prefab>5__4, <spawnPoint>5__3);
					if (!Object.op_Implicit((Object)(object)<go>5__9))
					{
						return false;
					}
					ApplyLifetime(<go>5__9, <finalLifetime>5__8);
					ApplyRandomYRotation(<sa>5__1, <go>5__9);
					SetupSpawnedProjectile(<sa>5__1, ctx.Owner, <go>5__9, <targetPosition>5__2);
					ApplyCopiedSkillFactor(<sa>5__1, ctx.Skills, <go>5__9);
					ApplyProgression(<go>5__9, new VS_SummonProgressionResult(<progression>5__6.SummonLevel, <finalMaxInstances>5__7));
					VS_SummonState.Begin(<go>5__9, ctx.Owner, <summonPrefab>5__5, <finalMaxInstances>5__7);
					RegisterPlayerSummonStat(<sa>5__1, ctx.Owner);
					ApplyWakeupAnimation(<sa>5__1, <go>5__9);
					ApplyAiState(<sa>5__1, <go>5__9);
					SetupAoe(<sa>5__1, <go>5__9.GetComponent<Character>(), <spawnPoint>5__3);
					<sa>5__1.m_spawnEffects.Create(<spawnPoint>5__3, Quaternion.identity, (Transform)null, 1f, -1);
					if (<sa>5__1.m_spawnDelay > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<sa>5__1.m_spawnDelay);
						<>1__state = 2;
						return true;
					}
					break;
				}
				return false;
			}

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

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

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

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private object <>2__current;

			public SpawnContext ctx;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private SpawnAbility <sa>5__1;

			private int <toSpawn>5__2;

			private int <i>5__3;

			[<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
			private IEnumerator <step>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 1u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<sa>5__1 = null;
				<step>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				try
				{
					int num;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>1__state = -3;
						<sa>5__1 = ctx.Ability;
						if (<sa>5__1.m_initialSpawnDelay > 0f)
						{
							<>2__current = (object)new WaitForSeconds(<sa>5__1.m_initialSpawnDelay);
							<>1__state = 1;
							return true;
						}
						goto IL_008f;
					case 1:
						<>1__state = -3;
						goto IL_008f;
					case 2:
						{
							<>1__state = -3;
							goto IL_00fd;
						}
						IL_008f:
						<toSpawn>5__2 = Random.Range(<sa>5__1.m_minToSpawn, <sa>5__1.m_maxToSpawn);
						<i>5__3 = 0;
						goto IL_0126;
						IL_0126:
						if (<i>5__3 < <toSpawn>5__2)
						{
							<step>5__4 = SpawnOne(ctx, <i>5__3, <toSpawn>5__2);
							goto IL_00fd;
						}
						DestroySpawnAbilityObjectIfNeeded(<sa>5__1);
						<sa>5__1 = null;
						<>m__Finally1();
						return false;
						IL_00fd:
						if (<step>5__4.MoveNext())
						{
							<>2__current = <step>5__4.Current;
							<>1__state = 2;
							return true;
						}
						<step>5__4 = null;
						num = <i>5__3 + 1;
						<i>5__3 = num;
						goto IL_0126;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				VS_SpawnAbilityScope.Unmark(ctx.Ability);
				VS_SpawnAbilityContextStore.Clear(ctx.Ability);
			}

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

		private static void ShowInvalidProgressionMessage(Character owner)
		{
			Player val = (Player)(object)((owner is Player) ? owner : null);
			if (val != null)
			{
				((Character)val).Message((MessageType)2, "Invalid summon progression config.", 0, (Sprite)null);
			}
		}

		internal static bool ShouldBlockSetup(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Character owner)
		{
			if ((Object)(object)owner == (Object)null)
			{
				return false;
			}
			if (!VS_SpawnAbilityScope.TryGetSummonPrefabs(sa, out var prefabs))
			{
				return false;
			}
			float num = ResolveRequiredBloodMagic(prefabs);
			if (num < 0f)
			{
				ShowInvalidProgressionMessage(owner);
				return true;
			}
			Skills skills = owner.GetSkills();
			if ((Object)(object)skills == (Object)null)
			{
				return false;
			}
			float skillLevel = skills.GetSkillLevel((SkillType)10);
			if (skillLevel >= num)
			{
				return false;
			}
			ShowBloodMagicGateMessage(owner, skillLevel, num);
			return true;
		}

		internal static bool TryMarkFromSetup(SpawnAbility sa)
		{
			VS_SpawnAbilityScope.Unmark(sa);
			if (!VS_SpawnAbilityScope.TryGetSummonPrefabs(sa, out var _))
			{
				return false;
			}
			VS_SpawnAbilityScope.Mark(sa);
			return true;
		}

		internal static bool TryBuildSpawnOverride(SpawnAbility sa, ref IEnumerator result)
		{
			if (!VS_SpawnAbilityScope.IsMarked(sa))
			{
				return false;
			}
			if (!VS_SpawnAbilityScope.TryGetSummonPrefabs(sa, out var prefabs))
			{
				VS_SpawnAbilityScope.Unmark(sa);
				VS_SpawnAbilityContextStore.Clear(sa);
				result = AbortSpawn();
				return true;
			}
			result = SpawnOverride(BuildContext(sa, prefabs));
			return true;
		}

		private static SpawnContext BuildContext(SpawnAbility sa, List<GameObject> prefabs)
		{
			Character owner = VS_SpawnAbilityContextStore.GetOwner(sa);
			ItemData weapon = VS_SpawnAbilityContextStore.GetWeapon(sa);
			Skills val = (Object.op_Implicit((Object)(object)owner) ? owner.GetSkills() : null);
			float bloodMagic = (((Object)(object)val != (Object)null) ? val.GetSkillLevel((SkillType)10) : 0f);
			return new SpawnContext(sa, owner, weapon, val, bloodMagic, prefabs);
		}

		private static float ResolveRequiredBloodMagic(List<GameObject> prefabs)
		{
			int num = int.MaxValue;
			bool flag = false;
			for (int i = 0; i < prefabs.Count; i++)
			{
				string prefabName = Utils.GetPrefabName(((Object)prefabs[i]).name);
				if (string.IsNullOrEmpty(prefabName))
				{
					return -1f;
				}
				if (!VS_SummonProgression.TryGetGateFromConfig(prefabName, out var minGate))
				{
					return -1f;
				}
				if (!flag || minGate < num)
				{
					num = minGate;
					flag = true;
				}
			}
			return flag ? ((float)num) : (-1f);
		}

		private static void ShowBloodMagicGateMessage(Character owner, float have, float required)
		{
			Player val = (Player)(object)((owner is Player) ? owner : null);
			if (val != null)
			{
				int num = Mathf.FloorToInt(have);
				int num2 = Mathf.FloorToInt(required);
				string arg = $"<color=red><b>{num}</b></color>";
				string arg2 = $"<color=red><b>{num2}</b></color>";
				string format = Localization.instance.Localize("$vs_bm_gate_msg");
				string text = string.Format(format, arg, arg2);
				((Character)val).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static void ShowBloodMagicGateMessageIfPossible(SpawnContext ctx)
		{
			if (!((Object)(object)ctx.Owner == (Object)null))
			{
				float num = ResolveRequiredBloodMagic(ctx.Prefabs);
				if (num < 0f)
				{
					ShowInvalidProgressionMessage(ctx.Owner);
				}
				else
				{
					ShowBloodMagicGateMessage(ctx.Owner, ctx.BloodMagic, num);
				}
			}
		}

		[IteratorStateMachine(typeof(<AbortSpawn>d__10))]
		private static IEnumerator AbortSpawn()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AbortSpawn>d__10(0);
		}

		[IteratorStateMachine(typeof(<SpawnOverride>d__11))]
		private static IEnumerator SpawnOverride(SpawnContext ctx)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnOverride>d__11(0)
			{
				ctx = ctx
			};
		}

		[IteratorStateMachine(typeof(<SpawnOne>d__12))]
		private static IEnumerator SpawnOne(SpawnContext ctx, int index, int spawnCount)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnOne>d__12(0)
			{
				ctx = ctx,
				index = index,
				spawnCount = spawnCount
			};
		}

		private static bool TryResolveSpawnPoint(SpawnContext ctx, int index, int spawnCount, out Vector3 targetPosition, out Vector3 spawnPoint)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			SpawnAbility ability = ctx.Ability;
			targetPosition = ((Component)ability).transform.position;
			spawnPoint = targetPosition;
			if (!TryResolveTargetPosition(ctx, index, spawnCount, out targetPosition))
			{
				return false;
			}
			return TryResolveFinalSpawnPoint(ability, targetPosition, index, spawnCount, out spawnPoint);
		}

		private static bool TryResolveTargetPosition(SpawnContext ctx, int index, int spawnCount, out Vector3 targetPosition)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			SpawnAbility ability = ctx.Ability;
			targetPosition = ((Component)ability).transform.position;
			bool result = false;
			int num = (((int)ability.m_targetType != 4) ? 1 : 5);
			for (int i = 0; i < num; i++)
			{
				if (result = FindTarget(ability, ctx.Owner, out targetPosition, index, spawnCount))
				{
					break;
				}
				if ((int)ability.m_targetType == 4 && i == num - 1)
				{
					targetPosition = ((Component)ability).transform.position;
					result = true;
				}
			}
			return result;
		}

		private static bool TryResolveFinalSpawnPoint(SpawnAbility sa, Vector3 targetPosition, int index, int spawnCount, out Vector3 spawnPoint)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			spawnPoint = targetPosition;
			if ((int)sa.m_targetType == 4)
			{
				return true;
			}
			Vector3 val = (sa.m_spawnAtTarget ? targetPosition : ((Component)sa).transform.position);
			Vector2 val2 = (sa.m_circleSpawn ? (GetCirclePoint(index, spawnCount) * sa.m_spawnRadius) : (Random.insideUnitCircle * sa.m_spawnRadius));
			spawnPoint = val + new Vector3(val2.x, 0f, val2.y);
			if (sa.m_snapToTerrain)
			{
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					return false;
				}
				float y = default(float);
				ZoneSystem.instance.GetSolidHeight(spawnPoint, ref y, sa.m_getSolidHeightMargin);
				spawnPoint.y = y;
			}
			spawnPoint.y += sa.m_spawnGroundOffset;
			return Mathf.Abs(spawnPoint.y - val.y) <= 100f;
		}

		private static bool TrySelectSummonPrefab(List<GameObject> summonPrefabs, float bloodMagic, out GameObject prefab, out string summonPrefab, out VS_SummonProgressionResult progression)
		{
			prefab = null;
			summonPrefab = string.Empty;
			progression = default(VS_SummonProgressionResult);
			if (summonPrefabs.Count == 0)
			{
				return false;
			}
			List<ValidSummonPrefab> list = new List<ValidSummonPrefab>();
			for (int i = 0; i < summonPrefabs.Count; i++)
			{
				GameObject val = summonPrefabs[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					string prefabName = Utils.GetPrefabName(((Object)val).name);
					if (!string.IsNullOrEmpty(prefabName) && VS_SummonProgression.TryResolve(prefabName, bloodMagic, out var result))
					{
						list.Add(new ValidSummonPrefab(val, prefabName, result));
					}
				}
			}
			if (list.Count == 0)
			{
				return false;
			}
			ValidSummonPrefab validSummonPrefab = list[Random.Range(0, list.Count)];
			prefab = validSummonPrefab.Prefab;
			summonPrefab = validSummonPrefab.Name;
			progression = validSummonPrefab.Progression;
			return true;
		}

		private static GameObject SpawnSummonInstance(GameObject prefab, Vector3 spawnPoint)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.Euler(0f, Random.value * 360f, 0f);
			return Object.Instantiate<GameObject>(prefab, spawnPoint, val);
		}

		private static void ApplyLifetime(GameObject go, float finalLifetime)
		{
			VS_SummonLifetime.Apply(go, finalLifetime);
		}

		private static void ApplyRandomYRotation(SpawnAbility sa, GameObject go)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (sa.m_randomYRotation)
			{
				go.transform.Rotate(Vector3.up, (float)Random.Range(-180, 180));
			}
		}

		private static void SetupSpawnedProjectile(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Character owner, GameObject go, Vector3 targetPosition)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Projectile component = go.GetComponent<Projectile>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)owner == (Object)null))
			{
				SetupProjectile(sa, owner, component, targetPosition);
			}
		}

		private static void ApplyCopiedSkillFactor(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Skills skills, GameObject go)
		{
			//IL_0044: 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)
			if ((Object)(object)skills == (Object)null)
			{
				return;
			}
			ZNetView component = go.GetComponent<ZNetView>();
			if (!((Object)(object)component == (Object)null) && component.IsValid())
			{
				ZDO zDO = component.GetZDO();
				if (zDO != null && (int)sa.m_copySkill != 0 && !(sa.m_copySkillToRandomFactor <= 0f))
				{
					zDO.Set(ZDOVars.s_randomSkillFactor, 1f + skills.GetSkillLevel(sa.m_copySkill) * sa.m_copySkillToRandomFactor);
				}
			}
		}

		private static void ApplyProgression(GameObject go, VS_SummonProgressionResult progression)
		{
			Character component = go.GetComponent<Character>();
			if ((Object)(object)component != (Object)null)
			{
				component.SetLevel(progression.SummonLevel);
			}
		}

		private static void RegisterPlayerSummonStat(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Character owner)
		{
			if (sa.m_commandOnSpawn && (Object)(object)owner == (Object)(object)Player.m_localPlayer)
			{
				Game.instance.IncrementPlayerStat((PlayerStatType)50, 1f);
			}
		}

		private static void ApplyWakeupAnimation(SpawnAbility sa, GameObject go)
		{
			if (sa.m_wakeUpAnimation)
			{
				ZSyncAnimation component = go.GetComponent<ZSyncAnimation>();
				if (component != null)
				{
					component.SetBool("wakeup", true);
				}
			}
		}

		private static void ApplyAiState(SpawnAbility sa, GameObject go)
		{
			BaseAI component = go.GetComponent<BaseAI>();
			if (!((Object)(object)component == (Object)null) && sa.m_passiveAggressive)
			{
				component.m_passiveAggresive = true;
			}
		}

		private static void DestroySpawnAbilityObjectIfNeeded(SpawnAbility sa)
		{
			if (!sa.m_spawnOnAwake)
			{
				Object.Destroy((Object)(object)((Component)sa).gameObject);
			}
		}

		private static void SetupProjectile(SpawnAbility sa, Character owner, Projectile projectile, Vector3 targetPoint)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (sa.m_randomDirection ? GetRandomConeDirection(sa) : (targetPoint - ((Component)projectile).transform.position));
			if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
			{
				val = owner.GetLookDir();
			}
			if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
			{
				val = ((Component)projectile).transform.forward;
			}
			((Vector3)(ref val)).Normalize();
			Vector3 val2 = Vector3.Cross(val, Vector3.up);
			if (((Vector3)(ref val2)).sqrMagnitude <= 0.0001f)
			{
				val2 = Vector3.right;
			}
			Vector3 val3 = Quaternion.AngleAxis(Random.Range(0f - sa.m_projectileAccuracy, sa.m_projectileAccuracy), Vector3.up) * (Quaternion.AngleAxis(Random.Range(0f - sa.m_projectileAccuracy, sa.m_projectileAccuracy), ((Vector3)(ref val2)).normalized) * val);
			float num = ((sa.m_projectileVelocityMax > 0f) ? Random.Range(sa.m_projectileVelocity, sa.m_projectileVelocityMax) : sa.m_projectileVelocity);
			projectile.Setup(owner, val3 * num, -1f, (HitData)null, (ItemData)null, (ItemData)null);
		}

		private static Vector3 GetRandomConeDirection(SpawnAbility sa)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			int num = Random.Range(0, 360);
			float num2 = Random.Range(sa.m_randomAngleMin, sa.m_randomAngleMax);
			return Quaternion.AngleAxis((float)num, Vector3.up) * new Vector3(Mathf.Sin(num2), Mathf.Cos(num2), 0f);
		}

		private static void SetupAoe(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Character owner, Vector3 targetPoint)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)sa.m_aoePrefab == (Object)null) && !((Object)(object)owner == (Object)null))
			{
				Aoe component = Object.Instantiate<GameObject>(sa.m_aoePrefab, targetPoint, Quaternion.identity).GetComponent<Aoe>();
				if (!((Object)(object)component == (Object)null))
				{
					component.Setup(owner, Vector3.zero, -1f, (HitData)null, (ItemData)null, (ItemData)null);
				}
			}
		}

		private static bool FindTarget(SpawnAbility sa, [<49e4b12e-f0b5-4be8-bcf3-f4780f1def32>Nullable(2)] Character owner, out Vector3 point, int i, int spawnCount)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected I4, but got Unknown
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			point = Vector3.zero;
			TargetType targetType = sa.m_targetType;
			TargetType val = targetType;
			switch ((int)val)
			{
			case 0:
			{
				if ((Object)(object)owner == (Object)null)
				{
					return false;
				}
				Character val3 = BaseAI.FindClosestEnemy(owner, ((Component)sa).transform.position, sa.m_maxTargetRange);
				if (!Object.op_Implicit((Object)(object)val3))
				{
					return false;
				}
				point = ((Component)val3).transform.position;
				return true;
			}
			case 1:
			{
				if ((Object)(object)owner == (Object)null)
				{
					return false;
				}
				Character val4 = BaseAI.FindRandomEnemy(owner, ((Component)sa).transform.position, sa.m_maxTargetRange);
				if (!Object.op_Implicit((Object)(object)val4))
				{
					return false;
				}
				point = ((Component)val4).transform.position;
				return true;
			}
			case 2:
				if ((Object)(object)owner == (Object)null)
				{
					return false;
				}
				point = ((Component)owner).transform.position;
				return true;
			case 3:
				point = ((Component)sa).transform.position;
				return true;
			case 4:
			{
				if ((Object)(object)owner == (Object)null)
				{
					return false;
				}
				if ((Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)Pathfinding.instance == (Object)null)
				{
					return false;
				}
				List<Vector3> list = new List<Vector3>();
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 val2 = ((Vector2)(ref insideUnitCircle)).normalized * Random.Range(sa.m_spawnRadius / 2f, sa.m_spawnRadius);
				point = ((Component)sa).transform.position + new Vector3(val2.x, 2f, val2.y);
				float y = default(float);
				ZoneSystem.instance.GetSolidHeight(point, ref y, 2);
				point.y = y;
				if (!Pathfinding.instance.GetPath(((Component)owner).transform.position, point, list, sa.m_targetWhenPathfindingType, true, false, true))
				{
					return false;
				}
				if (list.Count == 0)
				{
					return false;
				}
				point = list[list.Count - 1];
				return true;
			}
			default:
				return false;
			}
		}

		private static Vector2 GetCirclePoint(int i, int spawnCount)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			/