#define TRACE
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FeaturesLib;
using HarmonyLib;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using PatchingLib;
using PluginConfiguration;
using Requirements;
using UnityEngine;
using Valheim_Serverside;
using Valheim_Serverside.Features;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Valheim_Serverside")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Valheim_Serverside")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("118598c3-bcc2-4a92-a60e-f77be92f1305")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace PluginConfiguration
{
	public class Configuration
	{
		public static ConfigEntry<bool> modEnabled;

		public static ConfigEntry<bool> maxObjectsPerFrameEnabled;

		public static ConfigEntry<int> maxObjectsPerFrame;

		public static void Load(ConfigFile config)
		{
			modEnabled = config.Bind<bool>("General", "Enabled", true, "Enable or disable the mod");
			maxObjectsPerFrameEnabled = config.Bind<bool>("MaxObjectsPerFrame", "Enabled", true, "Enable or disable the feature");
			maxObjectsPerFrame = config.Bind<int>("MaxObjectsPerFrame", "MaxObjects", 100, "Maximum number of objects the server can create per frame.");
		}
	}
}
namespace FeaturesLib
{
	public interface IFeature
	{
		bool FeatureEnabled();
	}
	public class AvailableFeatures
	{
		public readonly List<IFeature> _features;

		public AvailableFeatures()
		{
			_features = new List<IFeature>();
		}

		public AvailableFeatures(List<IFeature> features)
		{
			_features = features;
		}

		public AvailableFeatures AddFeature(IFeature feature)
		{
			_features.Add(feature);
			return this;
		}

		public List<IFeature> EnabledFeatures()
		{
			return _features.Where((IFeature feature) => feature.FeatureEnabled()).ToList();
		}

		public Type[] GetAllNestedTypes()
		{
			return (from feature in EnabledFeatures()
				select feature.GetType().GetNestedTypes() into list
				from item in list
				select item).ToArray();
		}
	}
}
namespace Requirements
{
	public class PatchRequirement
	{
		public class DebugBuild : IPatchRequirement
		{
			public const string name = "DebugBuild";

			string IPatchRequirement.Name => "DebugBuild";

			Func<bool> IPatchRequirement.Checker => Utilities.IsDebugBuild;
		}
	}
}
namespace PatchingLib
{
	public interface IPatchRequirement
	{
		string Name { get; }

		Func<bool> Checker { get; }
	}
	public class PatchRequirements
	{
		private readonly Dictionary<string, Func<bool>> _requirements;

		public PatchRequirements()
		{
			_requirements = new Dictionary<string, Func<bool>>();
		}

		public PatchRequirements(Dictionary<string, Func<bool>> requirements)
		{
			_requirements = requirements;
		}

		public PatchRequirements AddRequirement(IPatchRequirement patchRequirement)
		{
			_requirements.Add(patchRequirement.Name, patchRequirement.Checker);
			return this;
		}

		public bool IsAllowed(string requirement_name)
		{
			_requirements.TryGetValue(requirement_name, out var value);
			return value?.Invoke() ?? false;
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
	public class PatchRequiresAttribute : Attribute
	{
		public readonly string requirement_name;

		public PatchRequiresAttribute(string requirement_name)
		{
			this.requirement_name = requirement_name;
		}
	}
	public class HarmonyFeaturesPatcher
	{
		private readonly PatchRequirements _patchRequirements;

		public HarmonyFeaturesPatcher(PatchRequirements availableFeatures)
		{
			_patchRequirements = availableFeatures;
		}

		public void PatchAll(Type[] types, Harmony harmony_instance)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			foreach (Type type in types)
			{
				if (!type.GetCustomAttributes<PatchRequiresAttribute>().ToList().Any((PatchRequiresAttribute attribute) => !_patchRequirements.IsAllowed(attribute.requirement_name)))
				{
					ZLog.Log((object)("Patching: " + type.ToString()));
					new PatchClassProcessor(harmony_instance, type).Patch();
				}
				else
				{
					ZLog.Log((object)("Patch disabled: " + type.ToString()));
				}
			}
		}
	}
}
namespace Valheim_Serverside
{
	public class Utilities
	{
		public static bool IsDebugBuild()
		{
			return false;
		}
	}
	public class SequentialInstructions
	{
		private int num_found;

		public List<CodeInstruction> Sequential;

		public SequentialInstructions(List<CodeInstruction> instructions)
		{
			Sequential = instructions;
		}

		public bool Check(CodeInstruction instruction)
		{
			for (int i = 0; i < Sequential.Count(); i++)
			{
				CodeInstruction val = Sequential[i];
				bool flag = false;
				_ = val.opcode;
				if (val.operand != null && val.opcode == instruction.opcode && val.operand == instruction.operand)
				{
					flag = true;
				}
				else
				{
					_ = val.opcode;
					if (val.operand == null && val.opcode == instruction.opcode)
					{
						flag = true;
					}
					else if (val.operand != null)
					{
						_ = val.opcode;
					}
				}
				if (flag && i == num_found)
				{
					if (i == 0)
					{
						num_found = 1;
					}
					else
					{
						num_found = i + 1;
					}
					if (num_found == Sequential.Count())
					{
						return true;
					}
					return false;
				}
			}
			num_found = 0;
			return false;
		}
	}
	[Harmony]
	[BepInPlugin("MVP.Valheim_Serverside_Simulations", "Serverside Simulations", "1.1.9")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ServersidePlugin : BaseUnityPlugin
	{
		private static ServersidePlugin context;

		public static Configuration configuration;

		public static Harmony harmony;

		public const string ValheimPlusPluginId = "org.bepinex.plugins.valheim_plus";

		public static ManualLogSource logger;

		private void Awake()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			context = this;
			logger = ((BaseUnityPlugin)this).Logger;
			Configuration.Load(((BaseUnityPlugin)this).Config);
			if (!ModIsEnabled())
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Serverside Simulations is disabled. (configuration)");
				return;
			}
			if (!IsDedicated())
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Serverside Simulations is disabled. (not a dedicated server)");
				return;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Installing Serverside Simulations");
			harmony = new Harmony("MVP.Valheim_Serverside_Simulations");
			AvailableFeatures availableFeatures = new AvailableFeatures();
			availableFeatures.AddFeature(new Core());
			availableFeatures.AddFeature(new MaxObjectsPerFrame());
			availableFeatures.AddFeature(new Debugging());
			availableFeatures.AddFeature(new Compat_ValheimPlus());
			PatchRequirements patchRequirements = new PatchRequirements();
			patchRequirements.AddRequirement(new PatchRequirement.DebugBuild());
			new HarmonyFeaturesPatcher(patchRequirements).PatchAll(availableFeatures.GetAllNestedTypes(), harmony);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Serverside Simulations installed");
		}

		public bool ModIsEnabled()
		{
			return Configuration.modEnabled.Value;
		}

		public static bool IsDedicated()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new ZNet().IsDedicated();
		}
	}
}
namespace Valheim_Serverside.Features
{
	public class Compat_ValheimPlus : IFeature
	{
		public class ZNetScene_Awake_Patch
		{
			private static bool triedToPatchSmelter;

			public static void Postfix()
			{
				if (!triedToPatchSmelter)
				{
					TryPatchSmelter();
					triedToPatchSmelter = true;
				}
			}
		}

		public bool haveValheimPlus;

		public Compat_ValheimPlus()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			haveValheimPlus = Chainloader.PluginInfos.ContainsKey("org.bepinex.plugins.valheim_plus");
			if (haveValheimPlus)
			{
				TryPatchInventoryAssistant();
				ServersidePlugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(ZNetScene), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(ZNetScene_Awake_Patch), "Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		public bool FeatureEnabled()
		{
			return haveValheimPlus;
		}

		private void TryPatchInventoryAssistant()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			Type type = Type.GetType("ValheimPlus.InventoryAssistant, ValheimPlus");
			if (type != null)
			{
				ServersidePlugin.logger.LogInfo((object)"Patching ValheimPlus.InventoryAssistant.GetNearbyChests");
				ServersidePlugin.harmony.Patch((MethodBase)AccessTools.Method(type, "GetNearbyChests", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Compat_ValheimPlus), "Transpile_InventoryAssistant_GetNearbyChests", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				ServersidePlugin.logger.LogError((object)"Couldn't find ValheimPlus.InventoryAssistant");
			}
		}

		private static void TryPatchSmelter()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			Type type = Type.GetType("ValheimPlus.GameClasses.Smelter_UpdateSmelter_Patch, ValheimPlus");
			if (type != null)
			{
				ServersidePlugin.logger.LogInfo((object)"Patching ValheimPlus.GameClasses.Smelter_UpdateSmelter_Patch.Prefix");
				ServersidePlugin.harmony.Patch((MethodBase)AccessTools.Method(type, "Prefix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Compat_ValheimPlus), "Transpile_Smelter_FixedUpdate_Patch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				ServersidePlugin.logger.LogError((object)"Couldn't find ValheimPlus.GameClasses.Smelter_UpdateSmelter_Patch");
			}
		}

		private static IEnumerable<CodeInstruction> Transpile_InventoryAssistant_GetNearbyChests(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Player), "m_localPlayer"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Player), "GetPlayerID", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(Container), "CheckAccess", (Type[])null, (Type[])null), (string)null)
			}).RemoveInstructions(4).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldc_I4_1, (object)null)
			})
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Stloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_2, (object)null, (string)null)
				})
				.SetInstruction(new CodeInstruction(OpCodes.Ldc_I4_0, (object)null))
				.InstructionEnumeration();
		}

		private static IEnumerable<CodeInstruction> Transpile_Smelter_FixedUpdate_Patch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Implicit", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
			}).SetOpcodeAndAdvance(OpCodes.Brtrue).InstructionEnumeration();
		}
	}
	public class Core : IFeature
	{
		[HarmonyPatch(typeof(ZNetScene), "CreateDestroyObjects")]
		public class CreateDestroyObjects_Patch
		{
			private static bool Prefix(ZNetScene __instance)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				List<ZDO> list = new List<ZDO>();
				List<ZDO> list2 = new List<ZDO>();
				foreach (ZNetPeer connectedPeer in ZNet.instance.GetConnectedPeers())
				{
					Vector2i zone = ZoneSystem.GetZone(connectedPeer.GetRefPos());
					ZDOMan.instance.FindSectorObjects(zone, ZoneSystem.instance.m_activeArea, ZoneSystem.instance.m_activeDistantArea, list, list2);
				}
				list2 = list2.Distinct().ToList();
				list = list.Distinct().ToList();
				Traverse.Create((object)__instance).Method("CreateObjects", new object[2] { list, list2 }).GetValue();
				Traverse.Create((object)__instance).Method("RemoveObjects", new object[2] { list, list2 }).GetValue();
				return false;
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "IsActiveAreaLoaded")]
		public static class ZoneSystem_IsActiveAreaLoaded_Patch
		{
			private static bool Prefix(ZoneSystem __instance, ref bool __result, Dictionary<Vector2i, dynamic> ___m_zones)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: 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)
				foreach (ZNetPeer peer in ZNet.instance.GetPeers())
				{
					Vector2i zone = ZoneSystem.GetZone(peer.GetRefPos());
					for (int i = zone.y - __instance.m_activeArea; i <= zone.y + __instance.m_activeArea; i++)
					{
						for (int j = zone.x - __instance.m_activeArea; j <= zone.x + __instance.m_activeArea; j++)
						{
							if (!___m_zones.ContainsKey(new Vector2i(j, i)))
							{
								__result = false;
								return false;
							}
						}
					}
				}
				__result = true;
				return false;
			}
		}

		[HarmonyPatch(typeof(ZoneSystem), "Update")]
		public static class ZoneSystem_Update_Patch
		{
			private static bool Prefix(ZoneSystem __instance, ref float ___m_updateTimer)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				if ((int)ZNet.GetConnectionStatus() != 2)
				{
					return false;
				}
				___m_updateTimer += Time.deltaTime;
				if (___m_updateTimer > 0.1f)
				{
					___m_updateTimer = 0f;
					Traverse.Create((object)__instance).Method("UpdateTTL", new object[1] { 0.1f }).GetValue();
					if (ZNet.instance.IsServer())
					{
						foreach (ZNetPeer peer in ZNet.instance.GetPeers())
						{
							Traverse.Create((object)__instance).Method("CreateLocalZones", new object[1] { peer.GetRefPos() }).GetValue();
						}
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ZDOMan), "ReleaseNearbyZDOS")]
		public static class ZDOMan_ReleaseNearbyZDOS_Patch
		{
			private static bool Prefix(ZDOMan __instance, ref Vector3 refPosition, ref long uid)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				Vector2i zone = ZoneSystem.GetZone(refPosition);
				List<ZDO> value = Traverse.Create((object)__instance).Field("m_tempNearObjects").GetValue<List<ZDO>>();
				value.Clear();
				__instance.FindSectorObjects(zone, ZoneSystem.instance.m_activeArea, 0, value, (List<ZDO>)null);
				foreach (ZDO item in value)
				{
					if (!item.Persistent)
					{
						continue;
					}
					bool flag = false;
					foreach (ZNetPeer peer in ZNet.instance.GetPeers())
					{
						if (ZNetScene.InActiveArea(item.GetSector(), ZoneSystem.GetZone(peer.GetRefPos())))
						{
							flag = true;
							break;
						}
					}
					long owner = item.GetOwner();
					if (owner == uid || owner == ZNet.GetUID())
					{
						if (!flag)
						{
							item.SetOwner(0L);
						}
					}
					else if ((owner == 0L || !new Traverse((object)__instance).Method("IsInPeerActiveArea", new object[2]
					{
						item.GetSector(),
						item.GetOwner()
					}).GetValue<bool>()) && flag)
					{
						item.SetOwner(ZNet.GetUID());
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(RandEventSystem), "FixedUpdate")]
		public static class RandEventSystem_FixedUpdate_Patch
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__1 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private IEnumerable<CodeInstruction> _instructions;

				public IEnumerable<CodeInstruction> <>3___instructions;

				private List<CodeInstruction> <new_instructions>5__2;

				private SequentialInstructions <localPlayerCheck>5__3;

				private int <i>5__4;

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

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

				[DebuggerHidden]
				public <Transpiler>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<new_instructions>5__2 = null;
					<localPlayerCheck>5__3 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0097: Unknown result type (might be due to invalid IL or missing references)
					//IL_009d: Expected O, but got Unknown
					//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Expected O, but got Unknown
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b9: Expected O, but got Unknown
					//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c7: Expected O, but got Unknown
					//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d5: Expected O, but got Unknown
					//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e3: Expected O, but got Unknown
					//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Expected O, but got Unknown
					//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c2: Expected O, but got Unknown
					//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d0: Expected O, but got Unknown
					//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
					//IL_01de: Expected O, but got Unknown
					//IL_0225: Unknown result type (might be due to invalid IL or missing references)
					//IL_022f: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						MethodInfo methodInfo = AccessTools.Method(typeof(RandEventSystem), "IsAnyPlayerInEventArea", (Type[])null, (Type[])null);
						FieldInfo fieldInfo = AccessTools.Field(typeof(Player), "m_localPlayer");
						MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Implicit", (Type[])null, (Type[])null);
						bool flag = false;
						CodeInstruction val = null;
						List<CodeInstruction> list = _instructions.ToList();
						<new_instructions>5__2 = _instructions.ToList();
						SequentialInstructions sequentialInstructions = new SequentialInstructions(new List<CodeInstruction>((IEnumerable<CodeInstruction>)(object)new CodeInstruction[7]
						{
							new CodeInstruction(OpCodes.Ldarg_0, (object)null),
							new CodeInstruction(OpCodes.Ldarg_0, (object)null),
							new CodeInstruction(OpCodes.Ldfld, (object)null),
							new CodeInstruction(OpCodes.Ldsfld, (object)null),
							new CodeInstruction(OpCodes.Callvirt, (object)null),
							new CodeInstruction(OpCodes.Callvirt, (object)null),
							new CodeInstruction(OpCodes.Call, (object)null)
						}));
						for (int i = 0; i < list.Count; i++)
						{
							CodeInstruction val2 = list[i];
							if (CodeInstructionExtensions.OperandIs(val2, (MemberInfo)methodInfo))
							{
								flag = true;
							}
							else if (flag && CodeInstructionExtensions.IsStloc(val2, (LocalBuilder)null))
							{
								val = val2.Clone();
								val.opcode = StlocToLdloc[val2.opcode];
								flag = false;
							}
							else if (val != null && sequentialInstructions.Check(val2))
							{
								int count = sequentialInstructions.Sequential.Count;
								int index = i - (count - 1);
								<new_instructions>5__2.RemoveRange(index, count);
								<new_instructions>5__2.Insert(index, val);
								break;
							}
						}
						<localPlayerCheck>5__3 = new SequentialInstructions(new List<CodeInstruction>((IEnumerable<CodeInstruction>)(object)new CodeInstruction[3]
						{
							new CodeInstruction(OpCodes.Ldsfld, (object)fieldInfo),
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							new CodeInstruction(OpCodes.Brfalse, (object)null)
						}));
						<i>5__4 = 0;
						break;
					}
					case 1:
						<>1__state = -1;
						goto IL_0259;
					case 2:
						{
							<>1__state = -1;
							goto IL_0259;
						}
						IL_0259:
						<i>5__4++;
						break;
					}
					if (<i>5__4 < <new_instructions>5__2.Count)
					{
						CodeInstruction val3 = <new_instructions>5__2[<i>5__4];
						if (<localPlayerCheck>5__3.Check(val3))
						{
							<>2__current = new CodeInstruction(OpCodes.Brtrue, val3.operand);
							<>1__state = 1;
							return true;
						}
						<>2__current = val3;
						<>1__state = 2;
						return true;
					}
					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();
				}

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__1 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__1(0);
					}
					<Transpiler>d__._instructions = <>3___instructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			private static Dictionary<OpCode, OpCode> StlocToLdloc = new Dictionary<OpCode, OpCode>
			{
				{
					OpCodes.Stloc_0,
					OpCodes.Ldloc_0
				},
				{
					OpCodes.Stloc_1,
					OpCodes.Ldloc_1
				},
				{
					OpCodes.Stloc_2,
					OpCodes.Ldloc_2
				},
				{
					OpCodes.Stloc_3,
					OpCodes.Ldloc_3
				},
				{
					OpCodes.Stloc_S,
					OpCodes.Ldloc_S
				},
				{
					OpCodes.Stloc,
					OpCodes.Ldloc
				}
			};

			[IteratorStateMachine(typeof(<Transpiler>d__1))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> _instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__1(-2)
				{
					<>3___instructions = _instructions
				};
			}
		}

		[HarmonyPatch(typeof(SpawnSystem), "UpdateSpawning")]
		public static class SpawnSystem_UpdateSpawning_Patch
		{
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> _instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				return new CodeMatcher(_instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Player), "m_localPlayer"), (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null), (string)null),
					new CodeMatch((OpCode?)OpCodes.Brfalse, (object)null, (string)null)
				}).SetOpcodeAndAdvance(OpCodes.Brtrue).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(RandEventSystem), "GetCurrentSpawners", (Type[])null, (Type[])null), (string)null)
				})
					.RemoveInstruction()
					.Insert((CodeInstruction[])(object)new CodeInstruction[2]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Core), "GetCurrentSpawners", (Type[])null, (Type[])null))
					})
					.InstructionEnumeration();
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "OutsideActiveArea", new Type[] { typeof(Vector3) })]
		public static class ZNetScene_OutsideActiveArea_Patch
		{
			private static bool Prefix(ref bool __result, ZNetScene __instance, Vector3 point)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				__result = true;
				foreach (ZNetPeer peer in ZNet.instance.GetPeers())
				{
					if (!ZNetScene.OutsideActiveArea(point, peer.GetRefPos()))
					{
						__result = false;
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(ZRoutedRpc), "RouteRPC")]
		public static class ZRoutedRpc_RouteRPC_Patch
		{
			private static void Prefix(RoutedRPCData rpcData)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (rpcData.m_methodHash == StringExtensionMethods.GetStableHashCode("RequestRespons"))
				{
					bool flag = rpcData.m_parameters.ReadBool();
					ZDO zDO = ZDOMan.instance.GetZDO(rpcData.m_targetZDO);
					if (zDO != null && flag)
					{
						ServersidePlugin.logger.LogDebug((object)$"RequestRespons: Setting ship's owner to {rpcData.m_targetPeerID}");
						zDO.SetOwner(rpcData.m_targetPeerID);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Humanoid), "UpdateAttack")]
		public static class Humanoid_UpdateAttack_Patch
		{
			private static void Prefix(ref Humanoid __instance)
			{
				if (__instance.m_currentAttack != null && (Object)(object)__instance.m_currentAttack.m_character == (Object)null)
				{
					__instance.m_currentAttack = null;
				}
			}
		}

		[HarmonyPatch(typeof(WearNTear), "UpdateSupport")]
		public static class WearNTear_UpdateSupport_Patch
		{
			private static void Prefix(ref WearNTear __instance)
			{
				if (__instance.m_colliders != null && __instance.m_bounds == null)
				{
					__instance.SetupColliders();
				}
			}
		}

		[HarmonyPatch(typeof(Ship), "UpdateOwner")]
		public static class Ship_UpdateOwner_Patch
		{
			private static bool Prefix(ref Ship __instance)
			{
				ZDO zDO = __instance.m_nview.GetZDO();
				if (zDO.GetInt("InUse", 0) == 0)
				{
					if (!__instance.m_shipControlls.HaveValidUser())
					{
						__instance.m_lastWaterImpactTime = Time.time;
						zDO.SetOwner(ZNet.GetUID());
						return false;
					}
					long user = __instance.m_shipControlls.GetUser();
					if (user != 0L)
					{
						long owner = ((Character)Player.GetPlayer(user)).GetOwner();
						ServersidePlugin.logger.LogDebug((object)$"UpdateOwner: Setting ship's owner to {owner}");
						zDO.SetOwner(owner);
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(AudioMan), "Update")]
		public static class AudioMan_Update_Patch
		{
			private static bool Prefix()
			{
				return false;
			}
		}

		[HarmonyPatch(typeof(ShieldDomeImageEffect), "GetDomeColor")]
		public static class ShieldDomeImageEffect_GetDomeColor_Patch
		{
			private static bool Prefix(ref Color __result)
			{
				//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)
				__result = new Color(1f, 1f, 1f);
				return false;
			}
		}

		public bool FeatureEnabled()
		{
			return true;
		}

		public static bool IsServer()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}

		public static void PrintLog(string text)
		{
			Trace.WriteLine(text);
		}

		public static void PrintLog(object[] obj)
		{
			Trace.WriteLine(string.Concat(obj));
		}

		public static List<SpawnData> GetCurrentSpawners(RandEventSystem instance, SpawnSystem spawnSystem)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (Traverse.Create((object)instance).Field("m_activeEvent").GetValue<RandomEvent>() == null)
			{
				return null;
			}
			ZNetView value = Traverse.Create((object)spawnSystem).Field("m_nview").GetValue<ZNetView>();
			RandomEvent value2 = Traverse.Create((object)instance).Field("m_randomEvent").GetValue<RandomEvent>();
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if (ZNetScene.InActiveArea(value.GetZDO().GetSector(), ((Component)allPlayer).transform.position) && Traverse.Create((object)instance).Method("IsInsideRandomEventArea", new Type[2]
				{
					typeof(RandomEvent),
					typeof(Vector3)
				}, new object[2]
				{
					value2,
					((Component)allPlayer).transform.position
				}).GetValue<bool>())
				{
					return instance.GetCurrentSpawners();
				}
			}
			return null;
		}
	}
	public class MaxObjectsPerFrame : IFeature
	{
		[HarmonyPatch(typeof(ZNetScene), "CreateObjects")]
		public class CreateObjects_Patch
		{
			public static void ILManipulator(ILContext il)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				new ILCursor(il).GotoNext((MoveType)0, new Func<Instruction, bool>[5]
				{
					(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
					(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 1),
					(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, 0),
					(Instruction i) => ILPatternMatchingExt.MatchLdloca(i, 1),
					(Instruction i) => ILPatternMatchingExt.MatchCall<ZNetScene>(i, "CreateObjectsSorted")
				}).Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(MaxObjectsPerFrame), "GetMaxCreatedPerFrame", (Type[])null, (Type[])null)).Emit(OpCodes.Stloc_0);
			}
		}

		public bool FeatureEnabled()
		{
			return Configuration.maxObjectsPerFrameEnabled.Value;
		}

		public static int GetMaxCreatedPerFrame()
		{
			return Configuration.maxObjectsPerFrame.Value;
		}
	}
	[Harmony]
	internal class Debugging : IFeature
	{
		[PatchRequires("DebugBuild")]
		[HarmonyPatch(typeof(Chat), "RPC_ChatMessage")]
		public static class Chat_RPC_ChatMessage_Patch
		{
			private static void Prefix(ref long sender, ref string text)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				ZNetPeer peer = ZNet.instance.GetPeer(sender);
				if (peer != null)
				{
					if (text == "startevent")
					{
						RandEventSystem.instance.SetRandomEventByName("army_theelder", peer.GetRefPos());
					}
					else if (text == "stopevent")
					{
						RandEventSystem.instance.ResetRandomEvent();
					}
					else if (text.StartsWith("maxobjects"))
					{
						Configuration.maxObjectsPerFrame.Value = Convert.ToInt32(text.Split(new char[1] { ' ' }).GetValue(1));
					}
				}
			}
		}

		public bool FeatureEnabled()
		{
			return Utilities.IsDebugBuild();
		}
	}
}