using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Timers;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ErenshorCoop.Client;
using ErenshorCoop.Server;
using ErenshorCoop.Shared;
using ErenshorCoop.Shared.Packets;
using ErenshorCoop.UI;
using HarmonyLib;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ErenshorCoop")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ErenshorCoop")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("060ca869-6710-4c26-a2d8-63572e58569b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace ErenshorCoop
{
	public class CommandHandler
	{
		public static void CreateHooks(Harmony harm)
		{
			ErenshorCoopMod.CreatePrefixHook(typeof(TypeText), "CheckCommands", typeof(CommandHandler), "CheckCommands_Prefix");
		}

		public static bool CheckCommands_Prefix(TypeText __instance)
		{
			string text = __instance.typed.text;
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			if (text.StartsWith("/"))
			{
				string[] array = text.Substring(1).Split(new char[1] { ' ' });
				string text2 = array[0].ToLower();
				int result = 0;
				switch (text2)
				{
				case "host":
					if (array.Length < 2)
					{
						Logging.LogError("Not enough arguments for \"host\". Usage: /host port");
						return false;
					}
					if (!int.TryParse(array[1], out result))
					{
						Logging.LogError("Could not parse port. (" + array[2] + ")");
					}
					else if (ServerConnectionManager.Instance.StartHost(result))
					{
						ClientConnectionManager.Instance.Connect("localhost", result);
					}
					return false;
				case "connect":
				{
					if (array.Length == 1)
					{
						ClientConnectionManager.Instance.Connect("localhost", 1234);
						return false;
					}
					if (array.Length < 3)
					{
						Logging.LogError("Not enough arguments for \"connect\". Usage: /connect ip port");
						return false;
					}
					string text3 = array[1];
					if (text3 != "localhost" && !IPAddress.TryParse(text3, out IPAddress _))
					{
						Logging.LogError(text3 + " is not a valid IP Address.");
						return false;
					}
					if (!int.TryParse(array[2], out result))
					{
						Logging.LogError("Could not parse port. (" + array[2] + ")");
					}
					else
					{
						ClientConnectionManager.Instance.Connect(text3, result);
					}
					return false;
				}
				case "disconnect":
					ClientConnectionManager.Instance?.Disconnect();
					ServerConnectionManager.Instance?.Disconnect();
					return false;
				}
			}
			return true;
		}
	}
	[BepInPlugin("mizuki.coop", "Erenshor Coop", "1.0.5")]
	public class ErenshorCoopMod : BaseUnityPlugin
	{
		public struct PluginData
		{
			public string name;

			public Version version;
		}

		public static ConfigEntry<int> someConfig;

		public static float mobSyncDistance = 40f;

		public static Action<Scene> OnGameMapLoad;

		public static Action<Scene> OnGameMenuLoad;

		public static SceneChange sceneChange;

		public static ManualLogSource logger;

		private static Harmony harm;

		public static Main ModMain;

		public static List<PluginData> loadedPlugins = new List<PluginData>();

		public static Version version;

		public void Awake()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			version = ((BaseUnityPlugin)this).Info.Metadata.Version;
			logger = ((BaseUnityPlugin)this).Logger;
			SceneManager.sceneLoaded += OnSceneLoaded;
			OnGameMapLoad = (Action<Scene>)Delegate.Combine(OnGameMapLoad, new Action<Scene>(OnGameLoad));
			OnGameMenuLoad = (Action<Scene>)Delegate.Combine(OnGameMenuLoad, new Action<Scene>(OnMenuLoad));
			GameObject val = new GameObject("Erenshor Coop");
			val.transform.SetParent(((Component)this).transform);
			ClientConfig.Load(((BaseUnityPlugin)this).Config);
			ServerConfig.Load(((BaseUnityPlugin)this).Config);
			val.AddComponent<ClientConnectionManager>();
			val.AddComponent<ServerConnectionManager>();
			val.AddComponent<ClientNPCSyncManager>();
			val.AddComponent<SharedNPCSyncManager>();
			ModMain = new GameObject("CoopUI").AddComponent<Main>();
			((Component)ModMain).transform.SetParent(val.transform);
			EnableHooks();
			GetLoadedPlugins();
			SceneManager.GetActiveScene();
			if ((Object)(object)sceneChange == (Object)null)
			{
				sceneChange = Object.FindObjectOfType<SceneChange>();
			}
			if ((Object)(object)sceneChange == (Object)null)
			{
				return;
			}
			if ((Object)(object)sceneChange.Player != (Object)null && (Object)(object)ClientConnectionManager.Instance.LocalPlayer != (Object)null)
			{
				PlayerSync component = ((Component)sceneChange.Player).GetComponent<PlayerSync>();
				if ((Object)(object)component != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)component);
				}
			}
			else if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer == (Object)null)
			{
				ClientConnectionManager.Instance.LocalPlayer = ((Component)sceneChange.Player).gameObject.AddComponent<PlayerSync>();
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			harm.UnpatchSelf();
		}

		private void GetLoadedPlugins()
		{
			loadedPlugins.Clear();
			foreach (PluginInfo value in Chainloader.PluginInfos.Values)
			{
				PluginData pluginData = default(PluginData);
				pluginData.name = value.Metadata.Name;
				pluginData.version = value.Metadata.Version;
				PluginData item = pluginData;
				loadedPlugins.Add(item);
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"Loaded Mods: {item.name} v{item.version}");
			}
		}

		private void OnMenuLoad(Scene scene)
		{
			if (!((Object)(object)ClientConnectionManager.Instance == (Object)null) && !((Object)(object)ClientConnectionManager.Instance.LocalPlayer == (Object)null) && !((Object)(object)sceneChange.Player == (Object)null))
			{
				Object.Destroy((Object)(object)ClientConnectionManager.Instance.LocalPlayer);
				ClientConnectionManager.Instance.LocalPlayer = null;
			}
		}

		private void OnGameLoad(Scene scene)
		{
			if ((Object)(object)sceneChange == (Object)null)
			{
				sceneChange = Object.FindObjectOfType<SceneChange>();
			}
			if (!((Object)(object)sceneChange == (Object)null))
			{
				if ((Object)(object)sceneChange.Player != (Object)null && (Object)(object)ClientConnectionManager.Instance.LocalPlayer == (Object)null)
				{
					ClientConnectionManager.Instance.LocalPlayer = ((Component)sceneChange.Player).gameObject.AddComponent<PlayerSync>();
				}
				else if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer == (Object)null)
				{
					Logging.LogError("Could not find Player object. Try changing scenes?");
				}
			}
		}

		public void Update()
		{
			PacketManager.ExtremePoolNoodleAction();
		}

		public void EnableHooks()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			harm = new Harmony("mizuki.coop");
			GameHooks.CreateHooks(harm);
			CommandHandler.CreateHooks(harm);
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0030: 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)
			if (((Scene)(ref scene)).name == "LoadScene" || ((Scene)(ref scene)).name == "Menu")
			{
				OnGameMenuLoad?.Invoke(scene);
			}
			else
			{
				OnGameMapLoad?.Invoke(scene);
			}
		}

		public static void CreatePrefixHook(Type origType, string origName, Type newType, string newName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			try
			{
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(newType, newName, (Type[])null, (Type[])null));
				MethodInfo methodInfo = AccessTools.Method(origType, origName, (Type[])null, (Type[])null);
				harm.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void CreatePostHook(Type origType, string origName, Type newType, string newName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			try
			{
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(newType, newName, (Type[])null, (Type[])null));
				MethodInfo methodInfo = AccessTools.Method(origType, origName, (Type[])null, (Type[])null);
				harm.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void CreatePrefixHook(Type origType, string origName, Type newType, string newName, Type[] paramTypes)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			try
			{
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(newType, newName, (Type[])null, (Type[])null));
				MethodInfo methodInfo = AccessTools.Method(origType, origName, paramTypes, (Type[])null);
				harm.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void UnPatchTranspiler(Type origType, string origName, Type newType, string newName)
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(origType, origName, (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(newType, newName, (Type[])null, (Type[])null);
				harm.Unpatch((MethodBase)methodInfo, methodInfo2);
			}
			catch
			{
			}
		}

		public static void CreateTranspilerHook(Type origType, string origName, Type newType, string newName, Type[] paramTypes)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(origType, origName, paramTypes, (Type[])null);
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(newType, newName, (Type[])null, (Type[])null));
				harm.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static void CreateTranspilerHook(Type origType, string origName, Type newType, string newName)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(origType, origName, (Type[])null, (Type[])null);
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(newType, newName, (Type[])null, (Type[])null));
				harm.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch
			{
			}
		}

		public static Class ClassID2Class(byte _class)
		{
			return (Class)(_class switch
			{
				0 => GameData.ClassDB.Warrior, 
				1 => GameData.ClassDB.Druid, 
				2 => GameData.ClassDB.Duelist, 
				3 => GameData.ClassDB.Arcanist, 
				_ => null, 
			});
		}

		public static byte Class2ClassID(Class _class)
		{
			if ((Object)(object)_class == (Object)(object)GameData.ClassDB.Warrior)
			{
				return 0;
			}
			if ((Object)(object)_class == (Object)(object)GameData.ClassDB.Druid)
			{
				return 1;
			}
			if ((Object)(object)_class == (Object)(object)GameData.ClassDB.Duelist)
			{
				return 2;
			}
			if ((Object)(object)_class == (Object)(object)GameData.ClassDB.Arcanist)
			{
				return 3;
			}
			return byte.MaxValue;
		}
	}
	public class GameHooks
	{
		private static FieldInfo _actualSpawn;

		private static List<GameObject> fightSpawnList = new List<GameObject>();

		private static List<string> fightSpawnListID = new List<string>();

		private static FieldInfo _malarothSpawn;

		private static FieldInfo _chessSpawn;

		private static bool isMalaroth = false;

		private static byte chessSpawn = 0;

		private static bool hasWardOne = false;

		private static bool hasWardTwo = false;

		private static bool hasWardThree = false;

		private static int insertions = 0;

		public static FieldInfo targ;

		public static FieldInfo SpellSource;

		public static FieldInfo xpBonus;

		public static FieldInfo lastTyped;

		public static FieldInfo spawnPoint;

		public static MethodInfo startMethod;

		public static MethodInfo handleNameTag;

		public static FieldInfo rotTimer;

		public static FieldInfo leashing;

		private static FieldInfo thisZoning;

		public static FieldInfo hideHair;

		public static FieldInfo hideHead;

		public static MethodInfo GetTransformNames;

		public static FieldInfo animatorController;

		public static void CreateHooks(Harmony harm)
		{
			ErenshorCoopMod.CreatePrefixHook(typeof(Animator), "SetBool", typeof(GameHooks), "SetBool_Prefix", new Type[2]
			{
				typeof(string),
				typeof(bool)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Animator), "SetFloat", typeof(GameHooks), "SetFloat_Prefix", new Type[2]
			{
				typeof(string),
				typeof(float)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Animator), "SetInteger", typeof(GameHooks), "SetInteger_Prefix", new Type[2]
			{
				typeof(string),
				typeof(int)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Animator), "SetTrigger", typeof(GameHooks), "SetTrigger_Prefix", new Type[1] { typeof(string) });
			ErenshorCoopMod.CreatePrefixHook(typeof(Animator), "ResetTrigger", typeof(GameHooks), "ResetTrigger_Prefix", new Type[1] { typeof(string) });
			ErenshorCoopMod.CreatePrefixHook(typeof(AnimatorOverrideController), "set_Item", typeof(GameHooks), "AnimOverrideSet_Prefix", new Type[2]
			{
				typeof(string),
				typeof(AnimationClip)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Zoneline), "OnTriggerEnter", typeof(GameHooks), "ZoneLineOnTriggerEnter_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(NPC), "Update", typeof(GameHooks), "NPCUpdate_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(NPC), "Combat", typeof(GameHooks), "NPCCombat_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(TypeText), "CheckInput", typeof(GameHooks), "CheckInput_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "ReduceHP", typeof(GameHooks), "StatsReduceHP_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "MitigatePhysical", typeof(GameHooks), "StatsMitigatePhysical_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Character), "DamageMe", typeof(GameHooks), "CharacterDamageMe_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Character), "MagicDamageMe", typeof(GameHooks), "MagicDamageMe_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Character), "CheckVsMR", typeof(GameHooks), "CheckVsMR_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerGrouping), "InviteToGroup", typeof(GameHooks), "InviteToGroup_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerGrouping), "DismissMember1", typeof(GameHooks), "DismissMember1_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerGrouping), "DismissMember2", typeof(GameHooks), "DismissMember2_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerGrouping), "DismissMember3", typeof(GameHooks), "DismissMember3_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerTracking), "SpawnMeInGame", typeof(GameHooks), "SpawnMeInGame_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SpellVessel), "CreateSpellChargeEffect", typeof(GameHooks), "ChargeEffect_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SpellVessel), "EndSpell", typeof(GameHooks), "EndSpell_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SpellVessel), "EndSpellNoCD", typeof(GameHooks), "EndSpell_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SpellVessel), "ResolveSpell", typeof(GameHooks), "ResolveSpell_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerMngr), "BringPlayerGroupToZone", typeof(GameHooks), "BringGroup_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(GameData), "AddExperience", typeof(GameHooks), "AddExperience_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "AddStatusEffect", typeof(GameHooks), "AddStatusEffectType1_Prefix", new Type[3]
			{
				typeof(Spell),
				typeof(bool),
				typeof(int)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "AddStatusEffect", typeof(GameHooks), "AddStatusEffectType2_Prefix", new Type[4]
			{
				typeof(Spell),
				typeof(bool),
				typeof(int),
				typeof(Character)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "AddStatusEffect", typeof(GameHooks), "AddStatusEffectType3_Prefix", new Type[5]
			{
				typeof(Spell),
				typeof(bool),
				typeof(int),
				typeof(Character),
				typeof(float)
			});
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "RemoveStatusEffect", typeof(GameHooks), "RemoveStatusEffect_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "RemoveAllStatusEffects", typeof(GameHooks), "RemoveAllStatusEffects_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Stats), "RemoveBreakableEffects", typeof(GameHooks), "RemoveBreakableEffects_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(MalarothFeed), "CheckForGamepiece", typeof(GameHooks), "MCheckForGamepiece_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(MalarothFeed), "SpawnPiece", typeof(GameHooks), "MSpawnPiece_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Chessboard), "CheckForGamepiece", typeof(GameHooks), "CCheckForGamepiece_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(Chessboard), "SpawnPiece", typeof(GameHooks), "CSpawnPiece_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SiraetheEvent), "Update", typeof(GameHooks), "SUpdate_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(NPCFightEvent), "FixedUpdate", typeof(GameHooks), "FightFixedUpdate_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(CharmedNPC), "GoAway", typeof(GameHooks), "CharmedGoAway_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SimPlayerMngr), "CollectActiveSimData", typeof(GameHooks), "CollectActiveSimData_Prefix");
			ErenshorCoopMod.CreatePrefixHook(typeof(SceneChange), "ChangeScene", typeof(GameHooks), "ChangeScene_Prefix");
			ErenshorCoopMod.CreatePostHook(typeof(SpawnPoint), "SpawnNPC", typeof(GameHooks), "SpawnPointSpawnNPC_Post");
			ErenshorCoopMod.CreatePostHook(typeof(Character), "DamageMe", typeof(GameHooks), "CharacterDamageMe_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(Character), "MagicDamageMe", typeof(GameHooks), "MagicDamageMe_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(Respawn), "RespawnPlayer", typeof(GameHooks), "RespawnPlayer_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(SimPlayerGrouping), "InviteToGroup", typeof(GameHooks), "InviteToGroup_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(GameManager), "OpenEscMenu", typeof(GameHooks), "OpenEscMenu_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(GameManager), "CloseEscMenu", typeof(GameHooks), "CloseEscMenu_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(GameManager), "ToggleEscapeMenu", typeof(GameHooks), "ToggleEscMenu_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(MalarothFeed), "SpawnPiece", typeof(GameHooks), "MSpawnPiece_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(Chessboard), "SpawnPiece", typeof(GameHooks), "CSpawnPiece_Postfix");
			ErenshorCoopMod.CreatePostHook(typeof(SiraetheEvent), "Update", typeof(GameHooks), "SUpdate_Postfix");
			try
			{
				ErenshorCoopMod.UnPatchTranspiler(typeof(SpellVessel), "ResolveSpell", typeof(GameHooks), "ResolveSpellTranspiler");
			}
			catch
			{
			}
			ErenshorCoopMod.CreateTranspilerHook(typeof(SpellVessel), "ResolveSpell", typeof(GameHooks), "ResolveSpellTranspiler");
			if (insertions < 10)
			{
				Logging.LogError("There was an issue resolving healing\nPlease Update to the newest mod version or wait\nuntil a new version has been released.\nHealing might not work, continue at your own risk.");
			}
			Type typeFromHandle = typeof(ModularParts);
			hideHair = typeFromHandle.GetField("hideHair", BindingFlags.Instance | BindingFlags.NonPublic);
			hideHead = typeFromHandle.GetField("hideHead", BindingFlags.Instance | BindingFlags.NonPublic);
			GetTransformNames = typeFromHandle.GetMethod("GetTransformNames", BindingFlags.Instance | BindingFlags.NonPublic);
			lastTyped = typeof(TypeText).GetField("lastTyped", BindingFlags.Instance | BindingFlags.NonPublic);
			Type typeFromHandle2 = typeof(NPC);
			animatorController = typeFromHandle2.GetField("AnimOverride", BindingFlags.Instance | BindingFlags.NonPublic);
			spawnPoint = typeFromHandle2.GetField("MySpawnPoint", BindingFlags.Instance | BindingFlags.NonPublic);
			rotTimer = typeFromHandle2.GetField("rotTimer", BindingFlags.Instance | BindingFlags.NonPublic);
			startMethod = typeFromHandle2.GetMethod("Start", BindingFlags.Instance | BindingFlags.NonPublic);
			handleNameTag = typeFromHandle2.GetMethod("HandleNameTag", BindingFlags.Instance | BindingFlags.NonPublic);
			leashing = typeFromHandle2.GetField("spawnCD", BindingFlags.Instance | BindingFlags.NonPublic);
			Type typeFromHandle3 = typeof(SpellVessel);
			targ = typeFromHandle3.GetField("targ", BindingFlags.Instance | BindingFlags.NonPublic);
			SpellSource = typeFromHandle3.GetField("SpellSource", BindingFlags.Instance | BindingFlags.NonPublic);
			thisZoning = typeof(Zoneline).GetField("thisZoning", BindingFlags.Instance | BindingFlags.NonPublic);
			xpBonus = typeof(Stats).GetField("XPBonus", BindingFlags.Instance | BindingFlags.NonPublic);
			_malarothSpawn = typeof(MalarothFeed).GetField("Spawned", BindingFlags.Instance | BindingFlags.NonPublic);
			_chessSpawn = typeof(Chessboard).GetField("Spawned", BindingFlags.Instance | BindingFlags.NonPublic);
			_actualSpawn = typeof(NPCFightEvent).GetField("actualSpawn", BindingFlags.Instance | BindingFlags.NonPublic);
		}

		public static bool CollectActiveSimData_Prefix(SimPlayerMngr __instance)
		{
			return true;
		}

		public static bool ChangeScene_Prefix(SceneChange __instance, string _dest, Vector3 _landing, bool _useSun, float yRot)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return true;
			}
			if (ClientConnectionManager.Instance.LocalPlayer.currentScene == _dest)
			{
				GameData.SimPlayerGrouping.GroupTargets.Clear();
				GameData.SimPlayerGrouping.isPulling = false;
				GameData.AttackingPlayer.Clear();
				GameData.InCombat = false;
				GameData.GroupMatesInCombat.Clear();
				((Component)GameData.PlayerControl).GetComponent<Fishing>().resetFishing();
				GameData.PlayerControl.HuntingMe.Clear();
				((Collider)((Component)__instance.Player).GetComponent<CharacterController>()).enabled = false;
				GameData.CharmedNPC = null;
				__instance.SetLandingPos(_landing);
				((Component)__instance.Player).transform.position = _landing;
				((Collider)((Component)__instance.Player).GetComponent<CharacterController>()).enabled = true;
				((Behaviour)((Component)__instance.Player).GetComponent<PlayerControl>()).enabled = true;
				GameData.usingSun = _useSun;
				((Component)__instance.Player).transform.eulerAngles = new Vector3(0f, yRot, 0f);
				InZoneEvents.ClearNodes();
				GameData.Zoning = false;
				return false;
			}
			return true;
		}

		public static NetworkedPlayer CreatePlayer(int playerID, Vector3 pos, Quaternion rot)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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)
			List<GameObject> actualSims = GameData.SimMngr.ActualSims;
			if (actualSims.Count == 0)
			{
				Logging.LogError($"Could not create player for {playerID}. No Sim instances.");
				return null;
			}
			GameObject val = actualSims[0];
			if ((Object)(object)val == (Object)null)
			{
				Logging.LogError($"Could not create player for {playerID}. No Sim.");
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val.gameObject, pos, rot);
			val2.SetActive(false);
			SimPlayer component = val2.GetComponent<SimPlayer>();
			if ((Object)(object)component == (Object)null)
			{
				Logging.LogError($"Could not create player for {playerID}.");
				return null;
			}
			((Behaviour)component).enabled = false;
			NavMeshAgent component2 = val2.GetComponent<NavMeshAgent>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
			NetworkedPlayer networkedPlayer = val2.AddComponent<NetworkedPlayer>();
			networkedPlayer.sim = component;
			networkedPlayer.pos = pos;
			networkedPlayer.rot = rot;
			return networkedPlayer;
		}

		public static void CharmedGoAway_Prefix(CharmedNPC __instance)
		{
			if (ClientConnectionManager.Instance.IsRunning && GameData.PlayerControl.Myself.MyCharmedNPC.SummonedByPlayer)
			{
				ClientConnectionManager.Instance.LocalPlayer.DespawnSummon();
			}
		}

		public static bool FightFixedUpdate_Prefix(NPCFightEvent __instance)
		{
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return true;
			}
			if (!ClientZoneOwnership.isZoneOwner)
			{
				return true;
			}
			bool flag = false;
			if ((Object)(object)__instance.MyNPC.CurrentAggroTarget != (Object)null && __instance.MyStats.Myself.Alive)
			{
				if (__instance.PercentagesToSpawn.Count > 0 && (float)__instance.MyStats.CurrentHP / (float)__instance.MyStats.CurrentMaxHP * 100f < __instance.PercentagesToSpawn[0])
				{
					UpdateSocialLog.LogAdd(__instance.PromptOnSpawn, "orange");
					__instance.PercentagesToSpawn.RemoveAt(0);
					int num = 0;
					foreach (GameObject spawnAdd in __instance.SpawnAdds)
					{
						GameObject item = Object.Instantiate<GameObject>(spawnAdd, ((Component)__instance).transform.position + new Vector3((float)Random.Range(-11, 11), 0f, (float)Random.Range(-11, 11)), ((Component)__instance).transform.rotation);
						fightSpawnList.Add(item);
						fightSpawnListID.Add($"1,{num}");
						num++;
					}
					flag = true;
				}
				if (__instance.SpawnAddsEveryXSeconds > 0f)
				{
					float num2 = (float)_actualSpawn.GetValue(__instance);
					if (num2 > 0f)
					{
						_actualSpawn.SetValue(__instance, num2 - 1f);
					}
					else
					{
						UpdateSocialLog.LogAdd(__instance.PromptOnSpawn, "orange");
						int num3 = 0;
						foreach (GameObject spawnAdd2 in __instance.SpawnAdds)
						{
							GameObject item2 = Object.Instantiate<GameObject>(spawnAdd2, ((Component)__instance).transform.position + new Vector3((float)Random.Range(-11, 11), 0f, (float)Random.Range(-11, 11)), ((Component)__instance).transform.rotation);
							fightSpawnList.Add(item2);
							fightSpawnListID.Add($"2,{num3}");
							num3++;
						}
						_actualSpawn.SetValue(__instance, __instance.SpawnAddsEveryXSeconds * 60f);
						flag = true;
					}
				}
			}
			if (__instance.SpawnOnDeath.Count > 0 && !__instance.MyStats.Myself.Alive)
			{
				int num4 = 0;
				foreach (GameObject item4 in __instance.SpawnOnDeath)
				{
					Vector3 position = ((Component)__instance).transform.position;
					Vector3 localScale = ((Component)__instance).transform.localScale;
					float num5 = 0f - ((Vector3)(ref localScale)).magnitude;
					localScale = ((Component)__instance).transform.localScale;
					float num6 = Random.Range(num5, ((Vector3)(ref localScale)).magnitude);
					localScale = ((Component)__instance).transform.localScale;
					float num7 = 0f - ((Vector3)(ref localScale)).magnitude;
					localScale = ((Component)__instance).transform.localScale;
					GameObject item3 = Object.Instantiate<GameObject>(item4, position + new Vector3(num6, 0f, Random.Range(num7, ((Vector3)(ref localScale)).magnitude)), ((Component)__instance).transform.rotation);
					fightSpawnList.Add(item3);
					fightSpawnListID.Add($"3,{num4}");
					num4++;
				}
				__instance.SpawnOnDeath.Clear();
				UpdateSocialLog.LogAdd(__instance.PromptOnSpawn, "orange");
				if (__instance.InstantDespawn)
				{
					__instance.MyStats.Myself.MyNPC.ExpediteRot();
				}
				flag = true;
			}
			if (fightSpawnList.Count > 0)
			{
				SharedNPCSyncManager.Instance.ServerSpawnMobs(fightSpawnList, fightSpawnListID, -4, __instance.MyNPC);
				fightSpawnList.Clear();
				fightSpawnListID.Clear();
			}
			return !flag;
		}

		public static bool MCheckForGamepiece_Prefix()
		{
			if (ClientConnectionManager.Instance.IsRunning && !ClientZoneOwnership.isZoneOwner)
			{
				return false;
			}
			return true;
		}

		public static bool CCheckForGamepiece_Prefix()
		{
			if (ClientConnectionManager.Instance.IsRunning && !ClientZoneOwnership.isZoneOwner)
			{
				return false;
			}
			return true;
		}

		public static bool SUpdate_Prefix()
		{
			if (ClientConnectionManager.Instance.IsRunning && !ClientZoneOwnership.isZoneOwner)
			{
				hasWardOne = false;
				hasWardTwo = false;
				hasWardThree = false;
				return false;
			}
			return true;
		}

		public static void MSpawnPiece_Prefix(MalarothFeed __instance, GameObject _npc)
		{
			if (ClientConnectionManager.Instance.IsRunning)
			{
				isMalaroth = (Object)(object)_npc == (Object)(object)__instance.Malaroth;
			}
		}

		public static void CSpawnPiece_Prefix(Chessboard __instance, GameObject _npc)
		{
			if (ClientConnectionManager.Instance.IsRunning)
			{
				if ((Object)(object)_npc == (Object)(object)__instance.PeonNPC)
				{
					chessSpawn = 1;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.EmberNPC)
				{
					chessSpawn = 2;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.BlazeNPC)
				{
					chessSpawn = 3;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.MonarchNPC)
				{
					chessSpawn = 4;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.KingsmanNPC)
				{
					chessSpawn = 5;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.CandlekeeperNPC)
				{
					chessSpawn = 6;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.FacelessDuel)
				{
					chessSpawn = 7;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.FacelessArc)
				{
					chessSpawn = 8;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.FacelessPal)
				{
					chessSpawn = 9;
				}
				if ((Object)(object)_npc == (Object)(object)__instance.FacelessDru)
				{
					chessSpawn = 10;
				}
			}
		}

		public static void MSpawnPiece_Postfix(MalarothFeed __instance, GameObject _npc)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (ClientConnectionManager.Instance.IsRunning)
			{
				object? value = _malarothSpawn.GetValue(__instance);
				Character val = (Character)((value is Character) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					SharedNPCSyncManager.Instance.ServerSpawnMob(((Component)val).gameObject, -1, 0, isMalaroth, ((Component)val).transform.position, ((Component)val).transform.rotation);
				}
			}
		}

		public static void CSpawnPiece_Postfix(Chessboard __instance, GameObject _npc)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (ClientConnectionManager.Instance.IsRunning)
			{
				object? value = _chessSpawn.GetValue(__instance);
				Character val = (Character)((value is Character) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					SharedNPCSyncManager.Instance.ServerSpawnMob(((Component)val).gameObject, -2, chessSpawn, isRare: false, ((Component)val).transform.position, ((Component)val).transform.rotation);
				}
			}
		}

		public static void SUpdate_Postfix(SiraetheEvent __instance)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			if (ClientConnectionManager.Instance.IsRunning && ClientZoneOwnership.isZoneOwner)
			{
				if ((Object)(object)__instance.WardOne != (Object)null && !hasWardOne)
				{
					SharedNPCSyncManager.Instance.ServerSpawnMob(__instance.WardOne, -3, 1, isRare: false, __instance.WardOne.transform.position, __instance.WardOne.transform.rotation);
					hasWardOne = true;
				}
				else if ((Object)(object)__instance.WardOne == (Object)null && hasWardOne)
				{
					hasWardOne = false;
				}
				if ((Object)(object)__instance.WardTwo != (Object)null && !hasWardTwo)
				{
					SharedNPCSyncManager.Instance.ServerSpawnMob(__instance.WardTwo, -3, 2, isRare: false, __instance.WardTwo.transform.position, __instance.WardTwo.transform.rotation);
					hasWardTwo = true;
				}
				else if ((Object)(object)__instance.WardTwo == (Object)null && hasWardTwo)
				{
					hasWardTwo = false;
				}
				if ((Object)(object)__instance.WardThree != (Object)null && !hasWardThree)
				{
					SharedNPCSyncManager.Instance.ServerSpawnMob(__instance.WardThree, -3, 3, isRare: false, __instance.WardThree.transform.position, __instance.WardThree.transform.rotation);
					hasWardThree = true;
				}
				else if ((Object)(object)__instance.WardThree == (Object)null && hasWardThree)
				{
					hasWardThree = false;
				}
			}
		}

		public static IEnumerable<CodeInstruction> ResolveSpellTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Expected O, but got Unknown
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Expected O, but got Unknown
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Expected O, but got Unknown
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Expected O, but got Unknown
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Expected O, but got Unknown
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Expected O, but got Unknown
			//IL_05f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Expected O, but got Unknown
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Expected O, but got Unknown
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0635: Expected O, but got Unknown
			//IL_0656: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Expected O, but got Unknown
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Expected O, but got Unknown
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Expected O, but got Unknown
			//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c1: Expected O, but got Unknown
			List<CodeInstruction> codes2 = new List<CodeInstruction>(instructions);
			Label item = default(Label);
			Label item2 = default(Label);
			for (int j = 0; j < codes2.Count; j++)
			{
				if (codes2[j].opcode == OpCodes.Switch && codes2[j].operand is Label[] array)
				{
					item = array[6];
					item2 = array[7];
				}
				codes2[j].labels.Contains(item);
				codes2[j].labels.Contains(item2);
				bool flag = codes2[j].operand is FieldInfo;
				FieldInfo fieldInfo = codes2[j].operand as FieldInfo;
				if (j - 7 >= 0 && codes2[j].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentHP" && fieldInfo.DeclaringType == typeof(Stats) && codes2[j - 7].opcode == OpCodes.Stloc_S && ((LocalBuilder)codes2[j - 7].operand).LocalIndex == 18)
				{
					int num = j + 1;
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "targ")));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldloc_S, (object)16));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldloc_S, (object)17));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					codes2.Insert(num++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					MethodInfo methodInfo = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
					codes2.Insert(num++, new CodeInstruction(OpCodes.Call, (object)methodInfo));
					insertions++;
					j = num - 1;
				}
				if (codes2.Count >= j + 1 && codes2[j].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentHP" && fieldInfo.DeclaringType == typeof(Stats) && codes2[j + 1].opcode == OpCodes.Ldsfld)
				{
					FieldInfo fieldInfo2 = codes2[j + 1].operand as FieldInfo;
					if (fieldInfo2 != null && fieldInfo2.Name == "GroupMember1" && fieldInfo2.DeclaringType == typeof(GameData))
					{
						InsertSyncHealingCalls(codes2, ref j, j + 1, fieldInfo2.Name);
					}
					if (fieldInfo2 != null && fieldInfo2.Name == "GroupMember2" && fieldInfo2.DeclaringType == typeof(GameData))
					{
						InsertSyncHealingCalls(codes2, ref j, j + 1, fieldInfo2.Name);
					}
					if (fieldInfo2 != null && fieldInfo2.Name == "GroupMember3" && fieldInfo2.DeclaringType == typeof(GameData))
					{
						InsertSyncHealingCalls(codes2, ref j, j + 1, fieldInfo2.Name);
					}
				}
				if (codes2.Count >= j + 4 && codes2[j].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentHP" && fieldInfo.DeclaringType == typeof(Stats) && codes2[j + 4].opcode == OpCodes.Ldfld)
				{
					FieldInfo fieldInfo3 = codes2[j + 4].operand as FieldInfo;
					if (fieldInfo3 != null && fieldInfo3.Name == "MyCharmedNPC")
					{
						_ = fieldInfo3.DeclaringType == typeof(Character);
					}
				}
				if (codes2.Count >= j + 1 && codes2[j].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentHP" && fieldInfo.DeclaringType == typeof(Stats) && codes2[j + 1].opcode == OpCodes.Ldloc_S)
				{
					int num2 = j + 1;
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldloc_S, (object)22));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Character), "MyStats")));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldloc_S, (object)17));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					MethodInfo methodInfo2 = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
					codes2.Insert(num2++, new CodeInstruction(OpCodes.Call, (object)methodInfo2));
					insertions++;
					j = num2 - 1;
				}
				DoMPCalls(ref codes2, ref j);
			}
			return codes2.AsEnumerable();
			static void InsertSyncHealingCalls(List<CodeInstruction> codes, ref int i, int insertAt, string groupMemberName)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Expected O, but got Unknown
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Expected O, but got Unknown
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Expected O, but got Unknown
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Expected O, but got Unknown
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameData), groupMemberName)));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SimPlayerTracking), "MyStats")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldloc_S, (object)17));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
				MethodInfo methodInfo3 = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Call, (object)methodInfo3));
				i = insertAt - 1;
				insertions++;
			}
		}

		private static void DoMPCalls(ref List<CodeInstruction> codes, ref int i)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			//IL_0554: Unknown result type (might be due to invalid IL or missing references)
			//IL_055e: Expected O, but got Unknown
			//IL_0580: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Expected O, but got Unknown
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a9: Expected O, but got Unknown
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d5: Expected O, but got Unknown
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Expected O, but got Unknown
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_061a: Expected O, but got Unknown
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Expected O, but got Unknown
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Expected O, but got Unknown
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_067c: Expected O, but got Unknown
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Expected O, but got Unknown
			//IL_06b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c1: Expected O, but got Unknown
			//IL_06d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Expected O, but got Unknown
			//IL_0702: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Expected O, but got Unknown
			bool flag = codes[i].operand is FieldInfo;
			FieldInfo fieldInfo = codes[i].operand as FieldInfo;
			if (codes.Count >= i + 3 && codes[i].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentMana" && fieldInfo.DeclaringType == typeof(Stats))
			{
				FieldInfo fieldInfo2 = codes[i + 3].operand as FieldInfo;
				if (fieldInfo2 != null && fieldInfo2.DeclaringType == typeof(Spell) && fieldInfo2.Name == "GroupEffect")
				{
					int num = i + 1;
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "targ")));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Spell), "Mana")));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldstr, (object)""));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
					codes.Insert(num++, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
					MethodInfo methodInfo = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
					codes.Insert(num++, new CodeInstruction(OpCodes.Call, (object)methodInfo));
					insertions++;
					i = num - 1;
				}
			}
			if (codes.Count >= i + 1 && codes[i].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentMana" && fieldInfo.DeclaringType == typeof(Stats) && codes[i + 1].opcode == OpCodes.Ldsfld)
			{
				FieldInfo fieldInfo3 = codes[i + 1].operand as FieldInfo;
				if (fieldInfo3 != null && fieldInfo3.Name == "GroupMember1" && fieldInfo3.DeclaringType == typeof(GameData))
				{
					InsertSyncHealingCalls(codes, ref i, i + 1, fieldInfo3.Name);
				}
				if (fieldInfo3 != null && fieldInfo3.Name == "GroupMember2" && fieldInfo3.DeclaringType == typeof(GameData))
				{
					InsertSyncHealingCalls(codes, ref i, i + 1, fieldInfo3.Name);
				}
				if (fieldInfo3 != null && fieldInfo3.Name == "GroupMember3" && fieldInfo3.DeclaringType == typeof(GameData))
				{
					InsertSyncHealingCalls(codes, ref i, i + 1, fieldInfo3.Name);
				}
			}
			if (codes.Count >= i + 4 && codes[i].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentMana" && fieldInfo.DeclaringType == typeof(Stats) && codes[i + 4].opcode == OpCodes.Ldfld)
			{
				FieldInfo fieldInfo4 = codes[i + 4].operand as FieldInfo;
				if (fieldInfo4 != null && fieldInfo4.Name == "MyCharmedNPC")
				{
					_ = fieldInfo4.DeclaringType == typeof(Character);
				}
			}
			if (codes.Count >= i + 1 && codes[i].opcode == OpCodes.Stfld && flag && fieldInfo.Name == "CurrentMana" && fieldInfo.DeclaringType == typeof(Stats) && codes[i + 1].opcode == OpCodes.Ldloc_S)
			{
				int num2 = i + 1;
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldloc_S, (object)23));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Character), "MyStats")));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Spell), "Mana")));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldstr, (object)""));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
				codes.Insert(num2++, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
				MethodInfo methodInfo2 = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
				codes.Insert(num2++, new CodeInstruction(OpCodes.Call, (object)methodInfo2));
				insertions++;
				i = num2 - 1;
			}
			static void InsertSyncHealingCalls(List<CodeInstruction> codes, ref int i, int insertAt, string groupMemberName)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Expected O, but got Unknown
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Expected O, but got Unknown
				//IL_010d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Expected O, but got Unknown
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_012e: Expected O, but got Unknown
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Expected O, but got Unknown
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Expected O, but got Unknown
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Expected O, but got Unknown
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Expected O, but got Unknown
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(GameData), groupMemberName)));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SimPlayerTracking), "MyStats")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "spell")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Spell), "Mana")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldstr, (object)""));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(SpellVessel), "SpellSource")));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldc_I4_0, (object)null));
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Ldc_I4_1, (object)null));
				MethodInfo methodInfo3 = AccessTools.Method(typeof(GameHooks), "SyncHealing", (Type[])null, (Type[])null);
				codes.Insert(insertAt++, new CodeInstruction(OpCodes.Call, (object)methodInfo3));
				i = insertAt - 1;
				insertions++;
			}
		}

		public static void SyncHealing(Spell spell, Stats target, int amount, string text, CastSpell caster, bool calc, bool isMP)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			var (flag, flag2, num) = GetEntityIDByCharacter(caster.MyChar);
			if (num == -1)
			{
				Logging.Log("no caster? " + ((Object)caster).name);
				return;
			}
			if (!flag && ((flag2 && !ServerConnectionManager.Instance.IsRunning) || (!flag2 && !ClientZoneOwnership.isZoneOwner)))
			{
				Logging.Log($"er {flag} {flag2} {num}");
				return;
			}
			if (flag && num != ClientConnectionManager.Instance.LocalPlayerID)
			{
				Logging.Log("er NoLocalPlayer");
				return;
			}
			if (amount == 0 && !isMP)
			{
				amount = spell.HP + caster.MyChar.MyStats.CharacterClass.WisBenefit / 100 * caster.MyChar.MyStats.GetCurrentWis();
			}
			var (flag3, flag4, num2) = GetEntityIDByCharacter(target.Myself);
			if (num2 == -1)
			{
				Logging.Log($"no target {flag3} {flag4} {num2} {((Object)target).name}");
				return;
			}
			bool isCrit = !isMP && text.Contains("CRITICAL");
			HealingData healingData = default(HealingData);
			healingData.amount = amount;
			healingData.isCrit = isCrit;
			healingData.isMP = isMP;
			healingData.targetID = num2;
			healingData.targetIsNPC = !flag3 && !flag4;
			healingData.targetIsSim = flag4;
			HealingData hd = healingData;
			if (!flag)
			{
				((NPCSync)SharedNPCSyncManager.Instance.GetEntityFromID(num, flag2)).SendHeal(hd);
			}
			else
			{
				ClientConnectionManager.Instance.LocalPlayer.SendHeal(hd);
			}
		}

		public static void OpenEscMenu_Postfix()
		{
			Main.isGameMenuOpen = true;
			if ((Object)(object)Main.connectUI != (Object)null)
			{
				Main.connectUI.SetActive(true);
			}
		}

		public static void CloseEscMenu_Postfix()
		{
			Main.isGameMenuOpen = false;
			if ((Object)(object)Main.connectUI != (Object)null)
			{
				Main.connectUI.SetActive(false);
			}
		}

		public static void ToggleEscMenu_Postfix(GameManager __instance)
		{
			Main.isGameMenuOpen = __instance.EscapeMenu.activeSelf;
			if ((Object)(object)Main.connectUI != (Object)null)
			{
				Main.connectUI.SetActive(Main.isGameMenuOpen);
			}
		}

		public static bool AddExperience_Prefix(int xp, bool useMod)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return true;
			}
			if (Grouping.currentGroup.groupList == null || Grouping.currentGroup.groupList.Count <= 1)
			{
				return true;
			}
			if (Grouping.currentGroup.groupList.Count > 1)
			{
				if (Grouping.IsLocalLeader())
				{
					float num = (float)xpBonus.GetValue(GameData.PlayerStats);
					if (!ServerConnectionManager.Instance.IsRunning)
					{
						PacketManager.GetOrCreatePacket<GroupPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.GROUP).AddPacketData(GroupDataType.EXPERIENCE, "xp", xp).SetData("xpBonus", num)
							.SetData("useMod", useMod);
					}
					else
					{
						Grouping.ServerHandleXP(ClientConnectionManager.Instance.LocalPlayerID, xp, useMod, num);
					}
					return false;
				}
				return false;
			}
			return true;
		}

		public static bool BringGroup_Prefix(SimPlayerMngr __instance)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return true;
			}
			if (!ServerConnectionManager.Instance.IsRunning)
			{
				return false;
			}
			Scene activeScene;
			if (GameData.GroupMember1 != null && GameData.GroupMember1.simIndex >= 0)
			{
				__instance.ActiveSimInstances.Add(GameData.GroupMember1.SpawnMeInGame(((Component)GameData.PlayerControl).transform.position + new Vector3((float)Random.Range(-1, 1), 0f, (float)Random.Range(-1, 1))));
				GameData.GroupMember1.MyAvatar.InGroup = true;
				GameData.GroupMember1.isPuller = false;
				GameData.GroupMember1.Caution = false;
				SimPlayerTracking groupMember = GameData.GroupMember1;
				activeScene = SceneManager.GetActiveScene();
				groupMember.CurScene = ((Scene)(ref activeScene)).name;
				List<string> simsInZones = __instance.SimsInZones;
				int simIndex = GameData.GroupMember1.simIndex;
				activeScene = SceneManager.GetActiveScene();
				simsInZones[simIndex] = ((Scene)(ref activeScene)).name;
			}
			if (GameData.GroupMember2 != null && GameData.GroupMember2.simIndex >= 0)
			{
				__instance.ActiveSimInstances.Add(GameData.GroupMember2.SpawnMeInGame(((Component)GameData.PlayerControl).transform.position + new Vector3((float)Random.Range(-1, 1), 0f, (float)Random.Range(-1, 1))));
				GameData.GroupMember2.MyAvatar.InGroup = true;
				GameData.GroupMember2.isPuller = false;
				GameData.GroupMember2.Caution = false;
				SimPlayerTracking groupMember2 = GameData.GroupMember2;
				activeScene = SceneManager.GetActiveScene();
				groupMember2.CurScene = ((Scene)(ref activeScene)).name;
				List<string> simsInZones2 = __instance.SimsInZones;
				int simIndex2 = GameData.GroupMember2.simIndex;
				activeScene = SceneManager.GetActiveScene();
				simsInZones2[simIndex2] = ((Scene)(ref activeScene)).name;
			}
			if (GameData.GroupMember3 != null && GameData.GroupMember3.simIndex >= 0)
			{
				__instance.ActiveSimInstances.Add(GameData.GroupMember3.SpawnMeInGame(((Component)GameData.PlayerControl).transform.position + new Vector3((float)Random.Range(-1, 1), 0f, (float)Random.Range(-1, 1))));
				GameData.GroupMember3.MyAvatar.InGroup = true;
				GameData.GroupMember3.isPuller = false;
				GameData.GroupMember3.Caution = false;
				SimPlayerTracking groupMember3 = GameData.GroupMember3;
				activeScene = SceneManager.GetActiveScene();
				groupMember3.CurScene = ((Scene)(ref activeScene)).name;
				List<string> simsInZones3 = __instance.SimsInZones;
				int simIndex3 = GameData.GroupMember3.simIndex;
				activeScene = SceneManager.GetActiveScene();
				simsInZones3[simIndex3] = ((Scene)(ref activeScene)).name;
			}
			return false;
		}

		public static void ResolveSpell_Prefix(SpellVessel __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			bool flag = true;
			short num = -1;
			Character myChar = ((CastSpell)SpellSource.GetValue(__instance)).MyChar;
			EntityType entityType = EntityType.ENEMY;
			if ((Object)(object)myChar != (Object)(object)ClientConnectionManager.Instance.LocalPlayer.character)
			{
				if (!ServerConnectionManager.Instance.IsRunning)
				{
					return;
				}
				foreach (KeyValuePair<short, NPCSync> mob in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = mob.Key;
						entityType = mob.Value.type;
						break;
					}
				}
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = sim.Key;
						entityType = sim.Value.type;
						break;
					}
				}
				if (flag)
				{
					return;
				}
			}
			Stats val = (Stats)targ.GetValue(__instance);
			bool targetIsNPC = false;
			short num2 = -1;
			bool targetIsSim = false;
			if (!ClientZoneOwnership.isZoneOwner)
			{
				foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
				{
					if ((Object)(object)networkedMob.Value.character.MyStats == (Object)(object)val)
					{
						targetIsNPC = true;
						num2 = networkedMob.Key;
						break;
					}
				}
			}
			else
			{
				foreach (KeyValuePair<short, NPCSync> mob2 in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob2.Value.character.MyStats == (Object)(object)val)
					{
						targetIsNPC = true;
						num2 = mob2.Key;
						break;
					}
				}
				foreach (KeyValuePair<short, NPCSync> sim2 in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim2.Value.character.MyStats == (Object)(object)val)
					{
						targetIsNPC = true;
						num2 = sim2.Key;
						targetIsSim = true;
						break;
					}
				}
			}
			if (num2 == -1)
			{
				foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
				{
					if ((Object)(object)player.Value.sim.MyStats == (Object)(object)val)
					{
						num2 = player.Key;
						break;
					}
				}
				if (num2 == -1 && (Object)(object)val == (Object)(object)ClientConnectionManager.Instance.LocalPlayer.stats)
				{
					num2 = ClientConnectionManager.Instance.LocalPlayerID;
				}
			}
			if (num2 == -1)
			{
				Logging.Log("no valid target? " + ((Object)val).name);
			}
			else if (!flag)
			{
				EntityActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<EntityActionPacket>(num, PacketType.ENTITY_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.SPELL_EFFECT);
				orCreatePacket.spellID = ((BaseScriptableObject)__instance.spell).Id;
				orCreatePacket.targetID = num2;
				orCreatePacket.targetIsNPC = targetIsNPC;
				orCreatePacket.targetIsSim = targetIsSim;
				orCreatePacket.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
				if (ServerConnectionManager.Instance.IsRunning && SharedNPCSyncManager.Instance.sims.ContainsKey(num))
				{
					entityType = EntityType.SIM;
				}
				orCreatePacket.entityType = entityType;
			}
			else
			{
				PlayerActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket2.dataTypes.Add(ActionType.SPELL_EFFECT);
				orCreatePacket2.spellID = ((BaseScriptableObject)__instance.spell).Id;
				orCreatePacket2.targetID = num2;
				orCreatePacket2.targetIsNPC = targetIsNPC;
				orCreatePacket2.targetIsSim = targetIsSim;
			}
		}

		public static void EndSpell_Prefix(SpellVessel __instance)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Invalid comparison between Unknown and I4
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Invalid comparison between Unknown and I4
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			bool flag = true;
			short num = -1;
			Character myChar = ((CastSpell)SpellSource.GetValue(__instance)).MyChar;
			EntityType entityType = EntityType.ENEMY;
			if ((Object)(object)myChar != (Object)(object)ClientConnectionManager.Instance.LocalPlayer.character)
			{
				if (!ClientZoneOwnership.isZoneOwner)
				{
					return;
				}
				foreach (KeyValuePair<short, NPCSync> mob in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = mob.Key;
						entityType = mob.Value.type;
						break;
					}
				}
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = sim.Key;
						entityType = sim.Value.type;
						break;
					}
				}
				if (flag)
				{
					return;
				}
			}
			if (flag)
			{
				PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION).dataTypes.Add(ActionType.SPELL_END);
				if ((int)__instance.spell.Type == 7 && (Object)(object)myChar.MyCharmedNPC != (Object)null)
				{
					ClientConnectionManager.Instance.LocalPlayer.CreateSummon(__instance.spell, ((Component)myChar.MyCharmedNPC).gameObject);
				}
				return;
			}
			EntityActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<EntityActionPacket>(num, PacketType.ENTITY_ACTION);
			orCreatePacket.dataTypes.Add(ActionType.SPELL_END);
			orCreatePacket.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
			if (ServerConnectionManager.Instance.IsRunning && SharedNPCSyncManager.Instance.sims.ContainsKey(num))
			{
				entityType = EntityType.SIM;
			}
			if ((int)__instance.spell.Type == 7 && (Object)(object)myChar.MyCharmedNPC != (Object)null)
			{
				GetEntityByCharacter(myChar).CreateSummon(__instance.spell, ((Component)myChar.MyCharmedNPC).gameObject);
			}
			orCreatePacket.entityType = entityType;
		}

		public static void ChargeEffect_Prefix(SpellVessel __instance, Spell _spell, Transform _caster, Stats _target, CastSpell _source, float _castTime, bool _useMana, bool _resonate)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			bool flag = true;
			short num = -1;
			Character myChar = _source.MyChar;
			EntityType entityType = EntityType.ENEMY;
			if ((Object)(object)myChar != (Object)(object)ClientConnectionManager.Instance.LocalPlayer.character)
			{
				if (!ClientZoneOwnership.isZoneOwner)
				{
					return;
				}
				foreach (KeyValuePair<short, NPCSync> mob in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = mob.Key;
						entityType = mob.Value.type;
						break;
					}
				}
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character == (Object)(object)myChar)
					{
						flag = false;
						num = sim.Key;
						entityType = sim.Value.type;
						break;
					}
				}
				if (flag)
				{
					return;
				}
			}
			if (flag)
			{
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.SPELL_CHARGE);
				orCreatePacket.SpellChargeFXIndex = _spell.SpellChargeFXIndex;
				return;
			}
			EntityActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<EntityActionPacket>(num, PacketType.ENTITY_ACTION);
			orCreatePacket2.dataTypes.Add(ActionType.SPELL_CHARGE);
			orCreatePacket2.SpellChargeFXIndex = _spell.SpellChargeFXIndex;
			orCreatePacket2.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
			if (ServerConnectionManager.Instance.IsRunning && SharedNPCSyncManager.Instance.sims.ContainsKey(num))
			{
				entityType = EntityType.SIM;
			}
			orCreatePacket2.entityType = entityType;
		}

		public static bool SpawnMeInGame_Prefix(SimPlayerTracking __instance)
		{
			if (__instance.simIndex < 0)
			{
				return false;
			}
			return true;
		}

		public static bool DismissMember1_Prefix(SimPlayerGrouping __instance)
		{
			if (ClientConnectionManager.Instance.IsRunning && GameData.GroupMember1 != null && (Object)(object)GameData.GroupMember1.MyAvatar != (Object)null && GameData.GroupMember1.simIndex < 0)
			{
				int num = Math.Abs(GameData.GroupMember1.simIndex) - 1;
				Entity playerFromID = ClientConnectionManager.Instance.GetPlayerFromID((short)num);
				if ((Object)(object)playerFromID != (Object)null && (Object)(object)((NetworkedPlayer)playerFromID).sim.MyStats == (Object)(object)GameData.GroupMember1.MyStats)
				{
					Grouping.RemoveFromGroup((short)num);
					return false;
				}
			}
			if (ServerConnectionManager.Instance.IsRunning && GameData.GroupMember1 != null && (Object)(object)GameData.GroupMember1.MyAvatar != (Object)null && GameData.GroupMember1.simIndex >= 0)
			{
				NPCSync component = ((Component)GameData.GroupMember1.MyAvatar).GetComponent<NPCSync>();
				if ((Object)(object)component != (Object)null)
				{
					SharedNPCSyncManager.Instance.ServerRemoveSim(component.entityID);
					Grouping.RemoveSim(GameData.GroupMember1);
				}
			}
			return true;
		}

		public static bool DismissMember2_Prefix(SimPlayerGrouping __instance)
		{
			if (ClientConnectionManager.Instance.IsRunning && GameData.GroupMember2 != null && (Object)(object)GameData.GroupMember2.MyAvatar != (Object)null && GameData.GroupMember2.simIndex < 0)
			{
				int num = Math.Abs(GameData.GroupMember2.simIndex) - 1;
				Entity playerFromID = ClientConnectionManager.Instance.GetPlayerFromID((short)num);
				if ((Object)(object)playerFromID != (Object)null && (Object)(object)((NetworkedPlayer)playerFromID).sim.MyStats == (Object)(object)GameData.GroupMember2.MyStats)
				{
					Grouping.RemoveFromGroup((short)num);
					return false;
				}
			}
			if (ServerConnectionManager.Instance.IsRunning && GameData.GroupMember2 != null && (Object)(object)GameData.GroupMember2.MyAvatar != (Object)null && GameData.GroupMember2.simIndex >= 0)
			{
				NPCSync component = ((Component)GameData.GroupMember2.MyAvatar).GetComponent<NPCSync>();
				if ((Object)(object)component != (Object)null)
				{
					SharedNPCSyncManager.Instance.ServerRemoveSim(component.entityID);
					Grouping.RemoveSim(GameData.GroupMember2);
				}
			}
			return true;
		}

		public static bool DismissMember3_Prefix(SimPlayerGrouping __instance)
		{
			if (ClientConnectionManager.Instance.IsRunning && GameData.GroupMember3 != null && (Object)(object)GameData.GroupMember3.MyAvatar != (Object)null && GameData.GroupMember3.simIndex < 0)
			{
				int num = Math.Abs(GameData.GroupMember3.simIndex) - 1;
				Entity playerFromID = ClientConnectionManager.Instance.GetPlayerFromID((short)num);
				if ((Object)(object)playerFromID != (Object)null && (Object)(object)((NetworkedPlayer)playerFromID).sim.MyStats == (Object)(object)GameData.GroupMember3.MyStats)
				{
					Grouping.RemoveFromGroup((short)num);
					return false;
				}
			}
			if (ServerConnectionManager.Instance.IsRunning && GameData.GroupMember3 != null && (Object)(object)GameData.GroupMember3.MyAvatar != (Object)null && GameData.GroupMember3.simIndex >= 0)
			{
				NPCSync component = ((Component)GameData.GroupMember3.MyAvatar).GetComponent<NPCSync>();
				if ((Object)(object)component != (Object)null)
				{
					SharedNPCSyncManager.Instance.ServerRemoveSim(component.entityID);
					Grouping.RemoveSim(GameData.GroupMember3);
				}
			}
			return true;
		}

		public static void InviteToGroup_Postfix(SimPlayerGrouping __instance)
		{
			if (ServerConnectionManager.Instance.IsRunning)
			{
				if (GameData.GroupMember1 != null && GameData.GroupMember1.simIndex >= 0)
				{
					Grouping.InviteSim(GameData.GroupMember1);
				}
				if (GameData.GroupMember2 != null && GameData.GroupMember2.simIndex >= 0)
				{
					Grouping.InviteSim(GameData.GroupMember2);
				}
				if (GameData.GroupMember3 != null && GameData.GroupMember3.simIndex >= 0)
				{
					Grouping.InviteSim(GameData.GroupMember3);
				}
			}
		}

		public static bool InviteToGroup_Prefix(SimPlayerGrouping __instance)
		{
			if (ClientConnectionManager.Instance.IsRunning)
			{
				Character currentTarget = GameData.PlayerControl.CurrentTarget;
				NetworkedPlayer networkedPlayer = null;
				if ((Object)(object)currentTarget != (Object)null && (Object)(object)(networkedPlayer = ((Component)currentTarget).GetComponent<NetworkedPlayer>()) != (Object)null)
				{
					if (!GameData.PlayerControl.Myself.Alive)
					{
						return true;
					}
					Grouping.InvitePlayer(networkedPlayer);
					return false;
				}
				if ((Object)(object)currentTarget != (Object)null && !ServerConnectionManager.Instance.IsRunning)
				{
					Logging.LogGameMessage("[Grouping] Only the host can invite sims.");
					return false;
				}
			}
			return true;
		}

		public static void RespawnPlayer_Postfix()
		{
			if (ClientConnectionManager.Instance.IsRunning)
			{
				PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION).dataTypes.Add(ActionType.REVIVE);
			}
		}

		public static bool MiscGenPopup_Prefix(int _dmg, bool _crit, DamageType _type, Transform _tar)
		{
			//IL_002b: 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)
			if (ClientConnectionManager.Instance.IsRunning)
			{
				Debug.Log((object)$"{_dmg} {_crit} {_type} {_tar.position}");
			}
			return true;
		}

		private static (bool, bool, short) GetEntityIDByCharacter(Character _char)
		{
			foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
			{
				if ((Object)(object)networkedMob.Value.character == (Object)(object)_char)
				{
					return (false, false, networkedMob.Value.entityID);
				}
			}
			foreach (KeyValuePair<short, NetworkedNPC> networkedSim in ClientNPCSyncManager.Instance.NetworkedSims)
			{
				if ((Object)(object)networkedSim.Value.character == (Object)(object)_char)
				{
					return (false, true, networkedSim.Value.entityID);
				}
			}
			foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
			{
				if ((Object)(object)player.Value.character == (Object)(object)_char)
				{
					return (true, false, player.Value.entityID);
				}
			}
			if (ServerConnectionManager.Instance.IsRunning)
			{
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character == (Object)(object)_char)
					{
						return (false, true, sim.Value.entityID);
					}
				}
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.character == (Object)(object)_char)
			{
				return (true, false, ClientConnectionManager.Instance.LocalPlayerID);
			}
			return (false, false, -1);
		}

		public static Entity GetEntityByCharacter(Character _char)
		{
			foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
			{
				if ((Object)(object)networkedMob.Value.character == (Object)(object)_char)
				{
					return networkedMob.Value;
				}
			}
			foreach (KeyValuePair<short, NetworkedNPC> networkedSim in ClientNPCSyncManager.Instance.NetworkedSims)
			{
				if ((Object)(object)networkedSim.Value.character == (Object)(object)_char)
				{
					return networkedSim.Value;
				}
			}
			foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
			{
				if ((Object)(object)player.Value.character == (Object)(object)_char)
				{
					return player.Value;
				}
			}
			if (ServerConnectionManager.Instance.IsRunning)
			{
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character == (Object)(object)_char)
					{
						return sim.Value;
					}
				}
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.character == (Object)(object)_char)
			{
				return ClientConnectionManager.Instance.LocalPlayer;
			}
			return null;
		}

		private static (bool, bool, short) GetEntityIDByStats(Stats _char)
		{
			foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
			{
				if ((Object)(object)networkedMob.Value.character.MyStats == (Object)(object)_char)
				{
					return (false, false, networkedMob.Value.entityID);
				}
			}
			foreach (KeyValuePair<short, NetworkedNPC> networkedSim in ClientNPCSyncManager.Instance.NetworkedSims)
			{
				if ((Object)(object)networkedSim.Value.character.MyStats == (Object)(object)_char)
				{
					return (false, true, networkedSim.Value.entityID);
				}
			}
			foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
			{
				if ((Object)(object)player.Value.character.MyStats == (Object)(object)_char)
				{
					return (true, false, player.Value.entityID);
				}
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.character.MyStats == (Object)(object)_char)
			{
				return (true, false, ClientConnectionManager.Instance.LocalPlayerID);
			}
			return (false, false, -1);
		}

		private static Entity GetEntityByStats(Stats _char)
		{
			if (!ClientZoneOwnership.isZoneOwner)
			{
				foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
				{
					if ((Object)(object)networkedMob.Value.character.MyStats == (Object)(object)_char)
					{
						return networkedMob.Value;
					}
				}
				foreach (KeyValuePair<short, NetworkedNPC> networkedSim in ClientNPCSyncManager.Instance.NetworkedSims)
				{
					if ((Object)(object)networkedSim.Value.character.MyStats == (Object)(object)_char)
					{
						return networkedSim.Value;
					}
				}
			}
			else
			{
				foreach (KeyValuePair<short, NPCSync> mob in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob.Value.character.MyStats == (Object)(object)_char)
					{
						return mob.Value;
					}
				}
				foreach (KeyValuePair<short, NPCSync> sim in SharedNPCSyncManager.Instance.sims)
				{
					if ((Object)(object)sim.Value.character.MyStats == (Object)(object)_char)
					{
						return sim.Value;
					}
				}
			}
			foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
			{
				if ((Object)(object)player.Value.character.MyStats == (Object)(object)_char)
				{
					return player.Value;
				}
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.character.MyStats == (Object)(object)_char)
			{
				return ClientConnectionManager.Instance.LocalPlayer;
			}
			return null;
		}

		public static void AddStatusEffectType1_Prefix(Stats __instance, Spell spell, bool _fromPlayer, int _dmgBonus)
		{
			if (ClientConnectionManager.Instance.IsRunning && (Object)(object)ClientConnectionManager.Instance.LocalPlayer.stats == (Object)(object)__instance && !Variables.DontCheckEffectCharacters.Contains(ClientConnectionManager.Instance.LocalPlayer))
			{
				string id = ((BaseScriptableObject)spell).Id;
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket.effectData = new StatusEffectData
				{
					spellID = id,
					damageBonus = _dmgBonus,
					targetID = -1,
					duration = -1f
				};
				if (id == "83280423440")
				{
					Logging.Log("StatusEffectData 1:\n- spellID: " + orCreatePacket.effectData.spellID + "\n" + $"- damageBonus: {orCreatePacket.effectData.damageBonus}\n" + $"- attackerIsPlayer: {orCreatePacket.effectData.casterType}\n" + $"- attackerID: {orCreatePacket.effectData.casterID}\n" + $"- duration: {orCreatePacket.effectData.duration}\n");
				}
			}
		}

		public static void AddStatusEffectType2_Prefix(Stats __instance, Spell spell, bool _fromPlayer, int _dmgBonus, Character _specificCaster)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			Entity entityByStats = GetEntityByStats(__instance);
			Entity entityByCharacter = GetEntityByCharacter(_specificCaster);
			if ((Object)(object)entityByStats == (Object)null || (Object)(object)entityByCharacter == (Object)null || Variables.DontCheckEffectCharacters.Contains(entityByStats))
			{
				return;
			}
			if ((Object)(object)entityByStats == (Object)(object)ClientConnectionManager.Instance.LocalPlayer && (Object)(object)entityByCharacter == (Object)(object)ClientConnectionManager.Instance.LocalPlayer)
			{
				string id = ((BaseScriptableObject)spell).Id;
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket.effectData = new StatusEffectData
				{
					spellID = id,
					damageBonus = _dmgBonus,
					casterType = EntityType.PLAYER,
					targetID = -2,
					duration = -1f
				};
				if (id == "83280423440")
				{
					Logging.Log("StatusEffectData 2:\n- spellID: " + orCreatePacket.effectData.spellID + "\n" + $"- damageBonus: {orCreatePacket.effectData.damageBonus}\n" + $"- attackerIsPlayer: {orCreatePacket.effectData.casterType}\n" + $"- attackerID: {orCreatePacket.effectData.casterID}\n" + $"- duration: {orCreatePacket.effectData.duration}\n");
				}
			}
			else if ((Object)(object)entityByCharacter == (Object)(object)ClientConnectionManager.Instance.LocalPlayer)
			{
				string id2 = ((BaseScriptableObject)spell).Id;
				PlayerActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket2.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket2.effectData = new StatusEffectData
				{
					spellID = id2,
					damageBonus = _dmgBonus,
					casterType = EntityType.PLAYER,
					casterID = entityByCharacter.entityID,
					duration = -1f,
					targetID = entityByStats.entityID,
					targetType = entityByStats.type
				};
			}
			else if (ClientZoneOwnership.isZoneOwner)
			{
				string id3 = ((BaseScriptableObject)spell).Id;
				EntityActionPacket orCreatePacket3 = PacketManager.GetOrCreatePacket<EntityActionPacket>(entityByCharacter.entityID, PacketType.ENTITY_ACTION);
				orCreatePacket3.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket3.effectData = new StatusEffectData
				{
					spellID = id3,
					damageBonus = _dmgBonus,
					casterType = entityByCharacter.type,
					casterID = entityByCharacter.entityID,
					duration = -1f,
					targetID = entityByStats.entityID,
					targetType = entityByStats.type
				};
				orCreatePacket3.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
			}
		}

		public static void AddStatusEffectType3_Prefix(Stats __instance, Spell spell, bool _fromPlayer, int _dmgBonus, Character _specificCaster, float _duration)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			Entity entityByStats = GetEntityByStats(__instance);
			Entity entityByCharacter = GetEntityByCharacter(_specificCaster);
			if ((Object)(object)entityByStats == (Object)null || (Object)(object)entityByCharacter == (Object)null || Variables.DontCheckEffectCharacters.Contains(entityByStats))
			{
				return;
			}
			if ((Object)(object)entityByStats == (Object)(object)ClientConnectionManager.Instance.LocalPlayer && (Object)(object)entityByCharacter == (Object)(object)ClientConnectionManager.Instance.LocalPlayer)
			{
				string id = ((BaseScriptableObject)spell).Id;
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket.effectData = new StatusEffectData
				{
					spellID = id,
					damageBonus = _dmgBonus,
					casterType = EntityType.PLAYER,
					targetID = -3,
					duration = _duration
				};
				if (id == "83280423440")
				{
					Logging.Log("StatusEffectData 3:\n- spellID: " + orCreatePacket.effectData.spellID + "\n" + $"- damageBonus: {orCreatePacket.effectData.damageBonus}\n" + $"- attackerIsPlayer: {orCreatePacket.effectData.casterType}\n" + $"- attackerID: {orCreatePacket.effectData.casterID}\n" + $"- duration: {orCreatePacket.effectData.duration}\n");
				}
			}
			else if ((Object)(object)entityByCharacter == (Object)(object)ClientConnectionManager.Instance.LocalPlayer)
			{
				string id2 = ((BaseScriptableObject)spell).Id;
				PlayerActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket2.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket2.effectData = new StatusEffectData
				{
					spellID = id2,
					damageBonus = _dmgBonus,
					casterType = EntityType.PLAYER,
					casterID = entityByCharacter.entityID,
					duration = _duration,
					targetID = entityByStats.entityID,
					targetType = entityByStats.type
				};
			}
			else if (ClientZoneOwnership.isZoneOwner)
			{
				string id3 = ((BaseScriptableObject)spell).Id;
				EntityActionPacket orCreatePacket3 = PacketManager.GetOrCreatePacket<EntityActionPacket>(entityByCharacter.entityID, PacketType.ENTITY_ACTION);
				orCreatePacket3.dataTypes.Add(ActionType.STATUS_EFFECT_APPLY);
				orCreatePacket3.effectData = new StatusEffectData
				{
					spellID = id3,
					damageBonus = _dmgBonus,
					casterType = entityByCharacter.type,
					casterID = entityByCharacter.entityID,
					duration = _duration,
					targetID = entityByStats.entityID,
					targetType = entityByStats.type
				};
				orCreatePacket3.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
			}
		}

		public static void RemoveStatusEffect_Prefix(Stats __instance, int index)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.stats == (Object)(object)__instance)
			{
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
				orCreatePacket.statusID = index;
			}
			else if (ClientZoneOwnership.isZoneOwner)
			{
				Entity entityByStats = GetEntityByStats(__instance);
				if (!((Object)(object)entityByStats == (Object)null))
				{
					EntityActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<EntityActionPacket>(entityByStats.entityID, PacketType.ENTITY_ACTION);
					orCreatePacket2.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
					orCreatePacket2.statusID = index;
					orCreatePacket2.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
				}
			}
		}

		public static void RemoveAllStatusEffects_Prefix(Stats __instance)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.stats == (Object)(object)__instance)
			{
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
				orCreatePacket.RemoveAllStatus = true;
			}
			else if (ClientZoneOwnership.isZoneOwner)
			{
				Entity entityByStats = GetEntityByStats(__instance);
				if (!((Object)(object)entityByStats == (Object)null))
				{
					EntityActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<EntityActionPacket>(entityByStats.entityID, PacketType.ENTITY_ACTION);
					orCreatePacket2.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
					orCreatePacket2.RemoveAllStatus = true;
					orCreatePacket2.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
				}
			}
		}

		public static void RemoveBreakableEffects_Prefix(Stats __instance)
		{
			if (!ClientConnectionManager.Instance.IsRunning)
			{
				return;
			}
			if ((Object)(object)ClientConnectionManager.Instance.LocalPlayer.stats == (Object)(object)__instance)
			{
				PlayerActionPacket orCreatePacket = PacketManager.GetOrCreatePacket<PlayerActionPacket>(ClientConnectionManager.Instance.LocalPlayerID, PacketType.PLAYER_ACTION);
				orCreatePacket.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
				orCreatePacket.RemoveBreakable = true;
			}
			else if (ClientZoneOwnership.isZoneOwner)
			{
				Entity entityByStats = GetEntityByStats(__instance);
				if (!((Object)(object)entityByStats == (Object)null))
				{
					EntityActionPacket orCreatePacket2 = PacketManager.GetOrCreatePacket<EntityActionPacket>(entityByStats.entityID, PacketType.ENTITY_ACTION);
					orCreatePacket2.dataTypes.Add(ActionType.STATUS_EFFECT_REMOVE);
					orCreatePacket2.RemoveBreakable = true;
					orCreatePacket2.targetPlayerIDs = SharedNPCSyncManager.Instance.GetPlayerSendList();
				}
			}
		}

		public static bool StatsMitigatePhysical_Prefix(Stats __instance, ref int __result, int _incomingDmg)
		{
			Character component = ((Component)__instance).gameObject.GetComponent<Character>();
			if ((Object)(object)component == (Object)null)
			{
				return true;
			}
			if (Variables.DontCalculateDamageMitigationCharacters.Contains(component))
			{
				__result = _incomingDmg;
				return false;
			}
			return true;
		}

		public static bool StatsReduceHP_Prefix(Stats __instance, ref bool __result, int _dmg, DamageType _dmgType)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			if (!ClientZoneOwnership.isZoneOwner && ClientConnectionManager.Instance.IsRunning)
			{
				foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
				{
					if ((Object)(object)networkedMob.Value.character.MyStats == (Object)(object)__instance)
					{
						GameData.Misc.GenPopup(_dmg, false, _dmgType, ((Component)__instance).transform);
						__result = __instance.CurrentHP <= 0;
						return false;
					}
				}
				foreach (KeyValuePair<short, NetworkedNPC> networkedSim in ClientNPCSyncManager.Instance.NetworkedSims)
				{
					if ((Object)(object)networkedSim.Value.character.MyStats == (Object)(object)__instance)
					{
						GameData.Misc.GenPopup(_dmg, false, _dmgType, ((Component)__instance).transform);
						__result = __instance.CurrentHP <= 0;
						return false;
					}
				}
				foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
				{
					if ((Object)(object)player.Value.character.MyStats == (Object)(object)__instance)
					{
						GameData.Misc.GenPopup(_dmg, false, _dmgType, ((Component)__instance).transform);
						__result = __instance.CurrentHP <= 0;
						return false;
					}
				}
			}
			return true;
		}

		public static bool CheckVsMR_Prefix(Character __instance, ref float __result)
		{
			if (Variables.DontCalculateDamageMitigationCharacters.Contains(__instance))
			{
				__result = 0f;
				return false;
			}
			return true;
		}

		private static void SyncDamage(Character attackedChar, int __result, DamageType _dmgType, Character _attacker, bool _animEffect, float resistMod)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			NPCSync component = ((Component)attackedChar).GetComponent<NPCSync>();
			PlayerSync component2 = ((Component)attackedChar).GetComponent<PlayerSync>();
			NetworkedPlayer component3 = ((Component)attackedChar).GetComponent<NetworkedPlayer>();
			NetworkedNPC component4 = ((Component)attackedChar).GetComponent<NetworkedNPC>();
			if ((Object)(object)_attacker == (Object)null)
			{
				Logging.LogError("no attacker");
				return;
			}
			NPCSync component5 = ((Component)_attacker).GetComponent<NPCSync>();
			bool flag = (Object)(object)component != (Object)null;
			bool flag2 = (Object)(object)component2 != (Object)null;
			bool flag3 = (Object)(object)component3 != (Object)null;
			bool flag4 = (Object)(object)component4 != (Object)null;
			if ((Object)(object)component5 != (Object)null && (flag || flag2 || flag3 || flag4))
			{
				if (flag)
				{
					component5.SendAttack(__result, component.entityID, attackerNPC: true, _dmgType, _animEffect, resistMod);
				}
				else if (flag3)
				{
					component5.SendAttack(__result, component3.playerID, attackerNPC: false, _dmgType, _animEffect, resistMod);
				}
				else if (flag2)
				{
					component5.SendAttack(__result, ClientConnectionManager.Instance.LocalPlayerID, attackerNPC: false, _dmgType, _animEffect, resistMod);
				}
				else if (flag4)
				{
					component5.SendAttack(__result, component4.entityID, attackerNPC: true, _dmgType, _animEffect, resistMod);
				}
			}
		}

		private static void SyncDamageClient(Character attackedChar, int damage, DamageType _dmgType, Character _attacker, bool _animEffect, float resistMod)
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_attacker == (Object)null)
			{
				return;
			}
			NetworkedNPC component = ((Component)attackedChar).GetComponent<NetworkedNPC>();
			NetworkedPlayer component2 = ((Component)attackedChar).GetComponent<NetworkedPlayer>();
			NPCSync component3 = ((Component)attackedChar).GetComponent<NPCSync>();
			bool flag = (Object)(object)component != (Object)null;
			bool flag2 = (Object)(object)component2 != (Object)null;
			bool flag3 = (Object)(object)component3 != (Object)null;
			if (!flag && !flag2 && !flag3)
			{
				return;
			}
			short num = -1;
			bool attackedIsNPC = false;
			if (flag)
			{
				foreach (KeyValuePair<short, NetworkedNPC> networkedMob in ClientNPCSyncManager.Instance.NetworkedMobs)
				{
					if ((Object)(object)networkedMob.Value == (Object)(object)component)
					{
						num = networkedMob.Key;
						attackedIsNPC = true;
						break;
					}
				}
			}
			else if (flag2)
			{
				foreach (KeyValuePair<short, NetworkedPlayer> player in ClientConnectionManager.Instance.Players)
				{
					if ((Object)(object)player.Value == (Object)(object)component2)
					{
						num = player.Key;
						break;
					}
				}
			}
			else if (flag3)
			{
				foreach (KeyValuePair<short, NPCSync> mob in SharedNPCSyncManager.Instance.mobs)
				{
					if ((Object)(object)mob.Value == (Object)(object)component3)
					{
						num = mob.Key;
						attackedIsNPC = true;
						break;
					}
				}
			}
			if (num != -1)
			{
				ClientConnectionManager.Instance.LocalPlayer.SendDamageAttack(damage, num, attackedIsNPC, _dmgType, _animEffect, resistMod);
			}
		}

		publ