using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using UnityEngine;
using UnityEngine.Networking;
using Valquake;
using neobotics.ModSdk;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Valquake")]
[assembly: AssemblyConfiguration("Deploy")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+8e19df8b534a27d3b2ca5117932f15e53f8787cd")]
[assembly: AssemblyProduct("Valquake")]
[assembly: AssemblyTitle("Valquake")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public sealed class ConfigurationManagerAttributes
{
	public delegate void CustomHotkeyDrawerFunc(ConfigEntryBase setting, ref bool isCurrentlyAcceptingInput);

	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public CustomHotkeyDrawerFunc CustomHotkeyDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;
}
namespace Valquake
{
	internal static class FissureTerrainOps
	{
		[HarmonyPatch(typeof(TerrainComp), "Awake")]
		private static class TerrainComp_Awake_Patch
		{
			[HarmonyPostfix]
			private static void TerrainComp_Awake_Postfix(TerrainComp __instance)
			{
				__instance.m_nview.Register<ZPackage>("Valquake_ApplyOperation", (Action<long, ZPackage>)delegate(long sender, ZPackage pkg)
				{
					RPC_ApplyOperation(__instance, pkg);
				});
			}
		}

		private const string RpcName = "Valquake_ApplyOperation";

		public static void SetFissureTerrainOpSettings(Settings settings, float radius, float delta)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			settings.m_levelOffset = delta;
			settings.m_level = false;
			settings.m_levelRadius = radius;
			settings.m_square = true;
			settings.m_raise = true;
			settings.m_raiseRadius = radius;
			settings.m_raisePower = 0f;
			settings.m_raiseDelta = delta;
			settings.m_smooth = false;
			settings.m_smoothRadius = radius;
			settings.m_smoothPower = 1f;
			settings.m_paintCleared = false;
			settings.m_paintHeightCheck = false;
			settings.m_paintType = (PaintType)0;
			settings.m_paintRadius = radius;
		}

		public static void Apply(TerrainComp comp, Vector3 pos, Settings settings)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (comp.IsOwner())
			{
				comp.DoOperation(pos, Vector3.zero, settings);
				return;
			}
			ZPackage val = new ZPackage();
			val.Write(pos);
			Serialize(val, settings);
			comp.m_nview.InvokeRPC("Valquake_ApplyOperation", new object[1] { val });
		}

		private static void RPC_ApplyOperation(TerrainComp comp, ZPackage pkg)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (comp.IsOwner())
			{
				Vector3 val = pkg.ReadVector3();
				Settings val2 = Deserialize(pkg);
				comp.DoOperation(val, Vector3.zero, val2);
			}
		}

		private static void Serialize(ZPackage pkg, Settings s)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected I4, but got Unknown
			pkg.Write(s.m_levelOffset);
			pkg.Write(s.m_level);
			pkg.Write(s.m_levelRadius);
			pkg.Write(s.m_square);
			pkg.Write(s.m_raise);
			pkg.Write(s.m_raiseRadius);
			pkg.Write(s.m_raisePower);
			pkg.Write(s.m_raiseDelta);
			pkg.Write(s.m_smooth);
			pkg.Write(s.m_smoothRadius);
			pkg.Write(s.m_smoothPower);
			pkg.Write(s.m_paintCleared);
			pkg.Write(s.m_paintHeightCheck);
			pkg.Write((int)s.m_paintType);
			pkg.Write(s.m_paintRadius);
		}

		private static Settings Deserialize(ZPackage pkg)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			return new Settings
			{
				m_levelOffset = pkg.ReadSingle(),
				m_level = pkg.ReadBool(),
				m_levelRadius = pkg.ReadSingle(),
				m_square = pkg.ReadBool(),
				m_raise = pkg.ReadBool(),
				m_raiseRadius = pkg.ReadSingle(),
				m_raisePower = pkg.ReadSingle(),
				m_raiseDelta = pkg.ReadSingle(),
				m_smooth = pkg.ReadBool(),
				m_smoothRadius = pkg.ReadSingle(),
				m_smoothPower = pkg.ReadSingle(),
				m_paintCleared = pkg.ReadBool(),
				m_paintHeightCheck = pkg.ReadBool(),
				m_paintType = (PaintType)pkg.ReadInt(),
				m_paintRadius = pkg.ReadSingle()
			};
		}
	}
}
namespace neobotics.ModSdk
{
	public class AudioHelper : MonoBehaviour
	{
		private readonly Dictionary<string, AudioClip> audioClips = new Dictionary<string, AudioClip>();

		private Logging logger;

		public void Awake()
		{
			logger = Logging.GetLogger();
			logger.Debug("AudidHelper.Awake");
		}

		public void Start()
		{
			logger.Debug("AudioHelper.Start");
			ZRoutedRpc.instance.Register<Vector3, string>("NeoPlayClip", (Action<long, Vector3, string>)RPC_NeoPlayClip);
		}

		public void RPC_NeoPlayClip(long sender, Vector3 sourcePoint, string clipName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (ZNet.instance.IsDedicated())
			{
				return;
			}
			try
			{
				NeoPlayClip(sourcePoint, clipName);
			}
			catch (Exception e)
			{
				logger.Error(e, stackTrace: false);
			}
		}

		public void Play(Vector3 sourcePoint, string clipName)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			ZRoutedRpc.instance.InvokeRoutedRPC(0L, "NeoPlayClip", new object[2] { sourcePoint, clipName });
		}

		public void NeoPlayClip(Vector3 sourcePoint, string clipName)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			NeoPlayClip(sourcePoint, position, clipName);
		}

		public void NeoPlayClip(Vector3 sourcePoint, Vector3 targetPoint, string clipName)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (!audioClips.TryGetValue(clipName.ToLower(), out var value))
			{
				logger.Warning("Couldn't find audio clip for " + clipName);
				return;
			}
			Vector3 val = sourcePoint - targetPoint;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			float num = (Vector3.Distance(sourcePoint, targetPoint) + 1f) / 10f;
			AudioSource.PlayClipAtPoint(value, targetPoint + normalized * num, 1f);
		}

		public float GetClipDuration(string clipName)
		{
			if (!audioClips.TryGetValue(clipName.ToLower(), out var value))
			{
				return -1f;
			}
			return value.length;
		}

		internal void LoadAudioResources(string resourceFolder)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			audioClips.Clear();
			logger.Debug("LoadAudioResources");
			string[] files = Directory.GetFiles(resourceFolder, "*.*", SearchOption.TopDirectoryOnly);
			foreach (string text in files)
			{
				string text2 = Path.GetExtension(text).ToLowerInvariant();
				AudioType val = (AudioType)0;
				if (!(text2 == ".wav"))
				{
					if (text2 == ".mp3")
					{
						val = (AudioType)13;
					}
				}
				else
				{
					val = (AudioType)20;
				}
				if ((int)val != 0)
				{
					((MonoBehaviour)this).StartCoroutine(LoadExternalClip(text, val));
				}
			}
		}

		private IEnumerator LoadExternalClip(string filePath, AudioType type)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			string uri = new Uri(filePath).AbsoluteUri;
			string clipName = Path.GetFileName(filePath).ToLowerInvariant();
			UnityWebRequest req = UnityWebRequestMultimedia.GetAudioClip(uri, type);
			yield return req.SendWebRequest();
			if ((int)req.result == 1)
			{
				AudioClip content = DownloadHandlerAudioClip.GetContent(req);
				audioClips[clipName] = content;
				logger.Debug("Loaded external audio: " + clipName);
			}
			else
			{
				logger.Warning("Failed to load external audio: " + uri);
			}
		}
	}
	internal class CircularList<T>
	{
		private List<T> circle;

		private int index;

		public int Index => index;

		public CircularList(List<T> source, T startingElement)
		{
			circle = new List<T>(source);
			index = circle.FindIndex((T x) => x.Equals(startingElement));
		}

		public T Next()
		{
			index = ((index < circle.Count - 1) ? (index + 1) : 0);
			return circle[index];
		}

		public T Previous()
		{
			index = ((index > 0) ? (index - 1) : (circle.Count - 1));
			return circle[index];
		}
	}
	public static class ConfigFolderHelper
	{
		private const string ROOT = "Neobotics";

		public static string GetOrCreateModConfigFolder(string modName)
		{
			string text = Path.Combine(Paths.ConfigPath, "Neobotics", modName);
			Directory.CreateDirectory(text);
			return text;
		}
	}
	public class ConfigMock
	{
		public bool Value { get; set; }
	}
	public class CrossPlatformRandom : Random
	{
		private const int LCG_MULTIPLIER = 134775813;

		private const int LCG_INCREMENT = 1;

		private int _seed;

		public float value => (float)NextDouble();

		public CrossPlatformRandom()
		{
			Random random = new Random();
			_seed = random.Next();
		}

		public CrossPlatformRandom(int seed)
		{
			_seed = seed;
		}

		public float Range(int min, int max)
		{
			return Next(min, max);
		}

		public float Range(float min, float max)
		{
			return Mathf.Lerp(min, max, (float)NextDouble());
		}

		private int GetNext()
		{
			_seed = _seed * 134775813 + 1;
			return _seed;
		}

		public override int Next()
		{
			return Next(int.MaxValue);
		}

		public override int Next(int maxValue)
		{
			if (maxValue < 0)
			{
				throw new ArgumentOutOfRangeException("maxValue is less than zero.");
			}
			return (int)((long)(uint)GetNext() * (long)(uint)maxValue >>> 32);
		}

		public override int Next(int minValue, int maxValue)
		{
			if (minValue > maxValue)
			{
				throw new ArgumentOutOfRangeException("minValue is greater than maxValue.");
			}
			return minValue + Next(maxValue - minValue);
		}

		public override double NextDouble()
		{
			return Sample();
		}

		protected override double Sample()
		{
			return (double)Next() / 2147483647.0;
		}
	}
	internal class CustomDataWrapper
	{
		private Dictionary<string, string> playerData;

		private Dictionary<string, string> Data { get; set; }

		public CustomDataWrapper(Dictionary<string, string> sourceData, string keyPrefix)
		{
			CustomDataWrapper customDataWrapper = this;
			playerData = sourceData;
			Data = new Dictionary<string, string>();
			sourceData.Keys.ToList().ForEach(delegate(string key)
			{
				if (key.StartsWith(keyPrefix))
				{
					customDataWrapper.Data.Add(key, sourceData[key]);
				}
			});
		}

		public void Add(string key, string value)
		{
			Data.Add(key, value);
			playerData.Add(key, value);
		}

		public bool Remove(string key)
		{
			return Data.Remove(key) & playerData.Remove(key);
		}

		public void Set(string key, string value)
		{
			if (Data.ContainsKey(key))
			{
				Data[key] = value;
			}
			else
			{
				Data.Add(key, value);
			}
			if (playerData.ContainsKey(key))
			{
				playerData[key] = value;
			}
			else
			{
				playerData.Add(key, value);
			}
		}

		public string Get(string key)
		{
			if (Data.ContainsKey(key))
			{
				return Data[key];
			}
			return null;
		}

		public bool ContainsKey(string key)
		{
			return Data.ContainsKey(key);
		}

		public void PreSaveSync()
		{
			foreach (KeyValuePair<string, string> datum in Data)
			{
				if (!playerData.ContainsKey(datum.Key))
				{
					playerData.Add(datum.Key, datum.Value);
				}
			}
		}
	}
	internal class DebugUtils
	{
		internal static void ObjectInspector(object o)
		{
			if (o == null)
			{
				Debug.Log((object)"Object is null");
				return;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			Type type = o.GetType();
			Debug.Log((object)("Object: " + o.ToString() + " Type " + type.Name));
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			foreach (PropertyInfo propertyInfo in properties)
			{
				if (propertyInfo.CanRead)
				{
					Debug.Log((object)$"Property: {type.Name}.{propertyInfo.Name} = {propertyInfo.GetValue(o)}");
					continue;
				}
				Debug.Log((object)("Property: " + type.Name + "." + propertyInfo.Name + " is write-only"));
			}
			FieldInfo[] fields = type.GetFields(bindingAttr);
			foreach (FieldInfo field in fields)
			{
				FieldPrinter(o, type, field);
			}
		}

		internal static void MethodInspector(object o)
		{
			if (o == null)
			{
				Debug.Log((object)"Object is null");
				return;
			}
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			Type type = o.GetType();
			Debug.Log((object)("Method: " + o.ToString() + " Type " + type.Name));
			MethodInfo[] methods = type.GetMethods(bindingAttr);
			foreach (MethodInfo methodInfo in methods)
			{
				methodInfo.GetParameters();
				string arg = string.Join(", ", (from x in methodInfo.GetParameters()
					select x.ParameterType?.ToString() + " " + x.Name).ToArray());
				Debug.Log((object)$"{methodInfo.ReturnType} {methodInfo.Name} ({arg})");
			}
		}

		private static void ItemDataInspector(ItemData item)
		{
			ObjectInspector(item);
			ObjectInspector(item?.m_shared);
		}

		private static void FieldPrinter(object o, Type t, FieldInfo field)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			try
			{
				if (field.FieldType == typeof(ItemData))
				{
					ItemData val = (ItemData)field.GetValue(o);
					if (val != null)
					{
						ItemDataInspector(val);
					}
					else
					{
						Debug.Log((object)$"{t.Name}.{field.Name} = {field.GetValue(o)} [null]");
					}
				}
				else if (field.FieldType == typeof(Transform))
				{
					Transform val2 = (Transform)field.GetValue(o);
					if ((Object)(object)val2 != (Object)null)
					{
						Debug.Log((object)("\tTransform.parent = " + ((Object)val2.parent).name));
					}
					else
					{
						Debug.Log((object)$"{t.Name}.{field.Name} = {field.GetValue(o)} [null]");
					}
				}
				else if (field.FieldType == typeof(EffectList))
				{
					EffectList val3 = (EffectList)field.GetValue(o);
					if (val3 != null)
					{
						Debug.Log((object)$"{t.Name}.{field.Name} = {field.GetValue(o)}:");
						EffectData[] effectPrefabs = val3.m_effectPrefabs;
						foreach (EffectData val4 in effectPrefabs)
						{
							Debug.Log((object)("\tEffectData.m_prefab = " + ((Object)val4.m_prefab).name));
						}
					}
					else
					{
						Debug.Log((object)$"{t.Name}.{field.Name} = {field.GetValue(o)} [null]");
					}
				}
				else
				{
					Debug.Log((object)$"{t.Name}.{field.Name} = {field.GetValue(o)}");
				}
			}
			catch (Exception)
			{
				Debug.Log((object)("Exception accessing " + t?.Name + "." + field?.Name));
			}
		}

		internal static void GameObjectInspector(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				Debug.Log((object)"\n\nGame Object is null");
				return;
			}
			Debug.Log((object)("\n\nInspecting GameObject " + ((Object)go).name));
			ObjectInspector(go);
			Component[] componentsInChildren = go.GetComponentsInChildren<Component>();
			if (componentsInChildren.Length == 0)
			{
				return;
			}
			Component[] array = componentsInChildren;
			foreach (Component c in array)
			{
				try
				{
					ComponentInspector(c);
				}
				catch (Exception)
				{
				}
			}
		}

		internal static void PrintList<T>(List<T> l)
		{
			foreach (T item in l)
			{
				Debug.Log((object)item.ToString());
			}
		}

		internal static void ComponentInspector(Component c)
		{
			string obj = ((c != null) ? ((Object)c).name : null);
			object obj2;
			if (c == null)
			{
				obj2 = null;
			}
			else
			{
				Transform transform = c.transform;
				if (transform == null)
				{
					obj2 = null;
				}
				else
				{
					Transform parent = transform.parent;
					obj2 = ((parent != null) ? ((Object)parent).name : null);
				}
			}
			Debug.Log((object)("\n\nInspecting Component " + obj + " with parent " + (string?)obj2));
			ObjectInspector(c);
		}

		internal static void EffectsInspector(EffectList e)
		{
			EffectData[] effectPrefabs = e.m_effectPrefabs;
			Debug.Log((object)$"Effect list has effects {e.HasEffects()} count {effectPrefabs.Length}");
			EffectData[] array = effectPrefabs;
			foreach (EffectData val in array)
			{
				Debug.Log((object)$"Effect Data {val} prefab name {((Object)val.m_prefab).name} prefab GameObject name {((Object)val.m_prefab.gameObject).name}");
			}
		}

		internal static void PrintInventory()
		{
			foreach (ItemData allItem in ((Humanoid)Player.m_localPlayer).GetInventory().GetAllItems())
			{
				Debug.Log((object)allItem.m_shared.m_name);
			}
		}

		internal static void PrintAllObjects()
		{
			ZNetScene.instance.m_prefabs.ForEach(delegate(GameObject x)
			{
				Debug.Log((object)("GameObject " + ((Object)x).name));
			});
		}

		internal static void PrintAllCharacters()
		{
			Character.GetAllCharacters().ForEach(delegate(Character x)
			{
				Debug.Log((object)("Character " + ((Object)x).name));
			});
		}

		internal static void PrintAllLayers()
		{
			string[] array = (from index in Enumerable.Range(0, 31)
				select LayerMask.LayerToName(index) into l
				where !string.IsNullOrEmpty(l)
				select l).ToArray();
			foreach (string text in array)
			{
				Debug.Log((object)("Layer " + text + " " + Convert.ToString(LayerMask.NameToLayer(text), 2).PadLeft(32, '0')));
			}
		}
	}
	public class DelegatedConfigEntry<T> : DelegatedConfigEntryBase
	{
		private ConfigEntry<T> _entry;

		private EventHandler rootHandler;

		private Action<object, EventArgs> clientDelegate;

		private Logging Log;

		public ConfigEntry<T> ConfigEntry
		{
			get
			{
				return _entry;
			}
			set
			{
				_entry = value;
				if (_entry != null && rootHandler != null)
				{
					_entry.SettingChanged += rootHandler;
				}
				Name = ((ConfigEntryBase)_entry).Definition.Key;
				Section = ((ConfigEntryBase)_entry).Definition.Section;
				ServerValue = ((ConfigEntryBase)_entry).GetSerializedValue();
				Log.Trace("Set " + Section + " " + Name + " to serialized value " + ServerValue);
			}
		}

		public T Value
		{
			get
			{
				return _entry.Value;
			}
			set
			{
				_entry.Value = value;
			}
		}

		public DelegatedConfigEntry(bool useServerDelegate = false)
			: this((Action<object, EventArgs>)null, useServerDelegate)
		{
		}

		public DelegatedConfigEntry(Action<object, EventArgs> delegateHandler, bool useServerDelegate = false)
		{
			Log = Logging.GetLogger();
			Log.Trace("DelegatedConfigEntry");
			if (delegateHandler != null)
			{
				clientDelegate = delegateHandler;
			}
			if (useServerDelegate)
			{
				Log.Trace("Configuring server delegate");
				rootHandler = delegate(object s, EventArgs e)
				{
					ServerDelegate(s, e);
				};
				ServerConfiguration.ServerDelegatedEntries.Add(this);
			}
			else if (clientDelegate != null)
			{
				rootHandler = delegate(object s, EventArgs e)
				{
					clientDelegate(s, e);
				};
			}
		}

		private void ServerDelegate(object sender, EventArgs args)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			Logging.GetLogger().Trace("ServerDelegate");
			_entry.SettingChanged -= rootHandler;
			ZNet instance = ZNet.instance;
			bool? flag = ((instance != null) ? new bool?(instance.IsServer()) : ((bool?)null));
			if (flag.HasValue)
			{
				if (flag == false && ServerConfiguration.Instance.ReceivedServerValues)
				{
					if (ServerValue != null)
					{
						((ConfigEntryBase)_entry).SetSerializedValue(ServerValue);
						Log.Debug("Setting " + Name + " to server value " + ServerValue);
					}
				}
				else if (flag == true)
				{
					ServerValue = ((ConfigEntryBase)_entry).GetSerializedValue();
					ServerConfiguration.Instance.SendConfigToAllClients(sender, (SettingChangedEventArgs)args);
				}
			}
			if (clientDelegate != null)
			{
				clientDelegate(sender, args);
			}
			_entry.SettingChanged += rootHandler;
		}

		public void EnableHandler(bool setActive)
		{
			if (setActive)
			{
				_entry.SettingChanged += rootHandler;
			}
			else
			{
				_entry.SettingChanged -= rootHandler;
			}
		}

		public bool IsKeyPressed()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
			{
				return InputEvaluator.IsPressed(val.Value);
			}
			Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
			return false;
		}

		public bool IsKeyDown()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
			{
				return InputEvaluator.IsDown(val.Value);
			}
			Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
			return false;
		}

		public bool IsKeyReleased()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigEntry is ConfigEntry<KeyboardShortcut> val)
			{
				return InputEvaluator.IsReleased(val.Value);
			}
			Log.Error("Keyboard read attempted on non-KeyboardShortcut config.");
			return false;
		}
	}
	public class DelegatedConfigEntryBase
	{
		public string Name;

		public string Section;

		public string ServerValue;
	}
	internal class HarmonyHelper
	{
		public enum PatchType
		{
			Prefix,
			Postfix,
			Transpiler,
			Finalizer
		}

		private static Dictionary<string, string> detectionSet = new Dictionary<string, string>();

		private static Dictionary<string, string> unpatchMods = new Dictionary<string, string>();

		public static IReadOnlyDictionary<string, string> DetectionSet => detectionSet;

		public static void GetDetectionSet(Dictionary<string, string> harmonyIds)
		{
			Logging logger = Logging.GetLogger();
			foreach (KeyValuePair<string, string> harmonyId in harmonyIds)
			{
				if (Harmony.HasAnyPatches(harmonyId.Key))
				{
					logger.Debug("Detected " + harmonyId.Value + " from Harmony");
					if (!detectionSet.ContainsKey(harmonyId.Key))
					{
						detectionSet.Add(harmonyId.Key, harmonyId.Value);
					}
				}
				else if (Chainloader.PluginInfos.ContainsKey(harmonyId.Key))
				{
					logger.Debug("Detected " + harmonyId.Value + " from BepInEx");
					if (!detectionSet.ContainsKey(harmonyId.Key))
					{
						detectionSet.Add(harmonyId.Key, harmonyId.Value);
					}
				}
			}
		}

		public static void AddToUnpatch(string key)
		{
			if (detectionSet.ContainsKey(key))
			{
				unpatchMods.Add(key, detectionSet[key]);
			}
		}

		public static void UnpatchMods(Harmony harmony)
		{
			Logging logger = Logging.GetLogger();
			foreach (KeyValuePair<string, string> unpatchMod in unpatchMods)
			{
				logger.Warning("Not compatible with " + unpatchMod.Value);
				Harmony.UnpatchID(unpatchMod.Key);
				detectionSet.Remove(unpatchMod.Key);
				logger.Warning("Disabled " + unpatchMod.Value);
			}
		}

		public static bool IsModDetected(string key)
		{
			return detectionSet.ContainsKey(key);
		}

		public static bool IsModNameDetected(string value)
		{
			return detectionSet.ContainsValue(value);
		}

		public static bool TryGetDetectedModName(string key, out string mod)
		{
			return detectionSet.TryGetValue(key, out mod);
		}

		public static bool TryGetDetectedModKey(string value, out string key)
		{
			key = null;
			foreach (string key2 in detectionSet.Keys)
			{
				if (detectionSet[key2] == value)
				{
					key = key2;
					return true;
				}
			}
			return false;
		}

		public static string AddAnonymousPatch(string baseMethodName, PatchType patchType, string modName, string patchMethodName = null)
		{
			string text = null;
			int num = 0;
			Logging logger = Logging.GetLogger();
			foreach (MethodBase item in Harmony.GetAllPatchedMethods().ToList())
			{
				MethodBaseExtensions.HasMethodBody(item);
				Patches patchInfo = Harmony.GetPatchInfo(item);
				ReadOnlyCollection<Patch> readOnlyCollection = patchInfo.Prefixes;
				switch (patchType)
				{
				case PatchType.Postfix:
					readOnlyCollection = patchInfo.Postfixes;
					break;
				case PatchType.Prefix:
					readOnlyCollection = patchInfo.Prefixes;
					break;
				case PatchType.Transpiler:
					readOnlyCollection = patchInfo.Transpilers;
					break;
				case PatchType.Finalizer:
					readOnlyCollection = patchInfo.Finalizers;
					break;
				}
				foreach (Patch item2 in readOnlyCollection)
				{
					if (!item2.owner.StartsWith("harmony-auto") || !(item.Name == baseMethodName))
					{
						continue;
					}
					if (patchMethodName != null)
					{
						if (item2.PatchMethod.Name == patchMethodName)
						{
							num++;
							text = item2.owner;
						}
					}
					else
					{
						num++;
						text = item2.owner;
					}
				}
				if (num == 1)
				{
					detectionSet.Add(text, modName);
					logger.Info($"Added unique anonymous {baseMethodName} {patchType}: {text} as {modName}");
				}
				else if (num > 1)
				{
					text = null;
					logger.Warning($"Found multiple anonymous {baseMethodName} {patchType} entries. Can't identify correct patch to remove or modify.");
				}
			}
			if (num == 0)
			{
				logger.Info("No patch found for " + modName);
			}
			return text;
		}
	}
	public class ImageHelper
	{
		private readonly string externalFolder;

		private readonly Logging logger;

		private bool isEmbedded;

		public ImageHelper(string externalFolder)
			: this(externalFolder, embedded: false)
		{
		}

		public ImageHelper(string externalFolder, bool embedded = true)
		{
			this.externalFolder = externalFolder;
			logger = Logging.GetLogger();
			isEmbedded = embedded;
		}

		public Sprite LoadSprite(string name, int width, int height, bool linear = false, float pixelsPerUnit = 100f)
		{
			logger.Debug("Reading image and creating sprite " + name);
			if (TryLoadImage(name, width, height, linear, out var image))
			{
				return LoadSprite(image, pixelsPerUnit);
			}
			return null;
		}

		public Sprite LoadSprite(Texture2D texture, float pixelsPerUnit = 100f)
		{
			return LoadSprite(texture, ((Object)texture).name, ((Texture)texture).width, ((Texture)texture).height, pixelsPerUnit);
		}

		public Sprite LoadSprite(Texture2D texture, string name, float width, float height, float pixelsPerUnit = 100f)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			if (string.IsNullOrWhiteSpace(name))
			{
				name = ((Object)texture).name;
			}
			logger.Debug("Creating sprite " + name + " from existing texture");
			Sprite obj = Sprite.Create(texture, new Rect(0f, 0f, width, height), Vector2.zero, pixelsPerUnit);
			if ((Object)(object)obj == (Object)null)
			{
				throw new ApplicationException("Can't create sprite " + name);
			}
			((Object)obj).name = name;
			return obj;
		}

		public bool TryLoadImage(string name, int width, int height, bool linear, out Texture2D image)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			image = null;
			byte[] array = null;
			if (isEmbedded)
			{
				Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(externalFolder + "." + name);
				if (manifestResourceStream == null)
				{
					throw new FileNotFoundException("Can't find " + name + " in " + externalFolder);
				}
				array = new byte[manifestResourceStream.Length];
				manifestResourceStream.Read(array, 0, (int)manifestResourceStream.Length);
			}
			else
			{
				string text = Path.Combine(externalFolder, name);
				logger.Debug("Reading external file " + text);
				if (!File.Exists(text))
				{
					throw new FileNotFoundException("Cannot find image " + name);
				}
				array = File.ReadAllBytes(text);
			}
			Texture2D val = new Texture2D(width, height, (TextureFormat)4, true, linear);
			if (!ImageConversion.LoadImage(val, array, false))
			{
				throw new FileLoadException("Can't load image " + name);
			}
			image = val;
			return true;
		}
	}
	internal class InputCycler
	{
		private static InputCycler _instance;

		private bool useMouseWheel;

		private DelegatedConfigEntry<KeyboardShortcut> keyAdvance;

		private DelegatedConfigEntry<KeyboardShortcut> keyReferse;

		public static InputCycler Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new InputCycler();
				}
				return _instance;
			}
		}

		private InputCycler()
		{
		}

		public void Init(bool useMouseWheel, DelegatedConfigEntry<KeyboardShortcut> keyAdvance, DelegatedConfigEntry<KeyboardShortcut> keyReverse = null)
		{
			this.useMouseWheel = useMouseWheel;
			this.keyAdvance = keyAdvance;
			keyReferse = keyReverse;
		}
	}
	internal static class InputEvaluator
	{
		public unsafe static bool IsPressed(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			object obj = KeyboardShortcut.Empty;
			if (((object)(*(KeyboardShortcut*)(&shortcut))/*cast due to .constrained prefix*/).Equals(obj))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if ((int)modifier != 0 && !Input.GetKey(modifier))
				{
					return false;
				}
			}
			return Input.GetKeyDown(((KeyboardShortcut)(ref shortcut)).MainKey);
		}

		public unsafe static bool IsDown(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			object obj = KeyboardShortcut.Empty;
			if (((object)(*(KeyboardShortcut*)(&shortcut))/*cast due to .constrained prefix*/).Equals(obj))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if ((int)modifier != 0 && !Input.GetKey(modifier))
				{
					return false;
				}
			}
			return Input.GetKey(((KeyboardShortcut)(ref shortcut)).MainKey);
		}

		public unsafe static bool IsReleased(KeyboardShortcut shortcut)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			object obj = KeyboardShortcut.Empty;
			if (((object)(*(KeyboardShortcut*)(&shortcut))/*cast due to .constrained prefix*/).Equals(obj))
			{
				return false;
			}
			foreach (KeyCode modifier in ((KeyboardShortcut)(ref shortcut)).Modifiers)
			{
				if ((int)modifier != 0 && !Input.GetKeyUp(modifier))
				{
					return false;
				}
			}
			return Input.GetKeyUp(((KeyboardShortcut)(ref shortcut)).MainKey);
		}
	}
	public class IterativeStopwatch : Stopwatch
	{
		private double startMillis;

		private Logging Log = Logging.GetLogger();

		public long Iterations { get; private set; }

		public double IterationMicroseconds { get; private set; }

		public double TotalElapsedMicroseconds { get; private set; }

		public double IterationMilliseconds { get; private set; }

		public double TotalElapsedMilliseconds { get; private set; }

		public double AverageMicroseconds { get; private set; }

		public double AverageMilliseconds { get; private set; }

		public IterativeStopwatch()
		{
			Iterations = 0L;
		}

		public new void Start()
		{
			startMillis = base.Elapsed.TotalMilliseconds;
			base.Start();
		}

		public new void Stop()
		{
			if (base.IsRunning)
			{
				base.Stop();
				Iterations++;
				IterationMilliseconds = base.Elapsed.TotalMilliseconds - startMillis;
				IterationMicroseconds = IterationMilliseconds * 1000.0;
				TotalElapsedMilliseconds = base.Elapsed.TotalMilliseconds;
				TotalElapsedMicroseconds = base.Elapsed.TotalMilliseconds * 1000.0;
				AverageMilliseconds = TotalElapsedMilliseconds / (double)Iterations;
				AverageMicroseconds = TotalElapsedMicroseconds / (double)Iterations;
			}
		}

		public new void Reset()
		{
			startMillis = 0.0;
			Iterations = 0L;
			base.Reset();
		}

		public new void Restart()
		{
			startMillis = 0.0;
			Iterations = 0L;
			base.Restart();
		}
	}
	public static class JsonHelper
	{
		[Serializable]
		private class JsonWrapper<T>
		{
			public T[] Items;
		}

		public static T[] FromJson<T>(string json)
		{
			return JsonUtility.FromJson<JsonWrapper<T>>(json).Items;
		}

		public static string ToJson<T>(T[] array)
		{
			return JsonUtility.ToJson((object)new JsonWrapper<T>
			{
				Items = array
			});
		}

		public static string ToJson<T>(T[] array, bool prettyPrint)
		{
			return JsonUtility.ToJson((object)new JsonWrapper<T>
			{
				Items = array
			}, prettyPrint);
		}
	}
	public class Logging
	{
		internal enum LogLevels
		{
			Critical,
			Error,
			Warning,
			Info,
			Debug,
			Trace
		}

		private static Logging _instance;

		public static Logging Instance
		{
			get
			{
				if (_instance == null)
				{
					throw new InvalidOperationException("Logging.Instance was accessed before initialization. Call Logging.Initialize() in your mod's startup code first.");
				}
				return _instance;
			}
			private set
			{
				_instance = value;
			}
		}

		internal LogLevels LogLevel { get; set; }

		internal string ModName { get; private set; }

		private Logging(LogLevels level, string name)
		{
			LogLevel = level;
			ModName = name;
		}

		internal static Logging Initialize(LogLevels level, string name)
		{
			if (_instance != null)
			{
				Instance.Warning("Logger is already initialized. Using existing logger");
				return _instance;
			}
			Instance = new Logging(level, name);
			return _instance;
		}

		internal static Logging GetLogger(LogLevels level, string name)
		{
			if (_instance == null)
			{
				Initialize(level, name);
			}
			return Instance;
		}

		internal static Logging GetLogger()
		{
			return Instance;
		}

		internal void Trace(string msg)
		{
			if (LogLevel >= LogLevels.Trace)
			{
				Debug.Log((object)Message(msg));
			}
		}

		internal void Debug(string msg)
		{
			if (LogLevel >= LogLevels.Debug)
			{
				Debug.Log((object)Message(msg));
			}
		}

		internal void Info(string msg)
		{
			if (LogLevel >= LogLevels.Info)
			{
				Debug.Log((object)Message(msg));
			}
		}

		internal void Warning(string msg)
		{
			if (LogLevel >= LogLevels.Warning)
			{
				Debug.LogWarning((object)Message(msg));
			}
		}

		internal void Error(string msg)
		{
			if (LogLevel >= LogLevels.Error)
			{
				Debug.LogWarning((object)Message(msg));
			}
		}

		internal void Error(Exception e)
		{
			Error(e, stackTrace: false);
		}

		internal void Error(Exception e, bool stackTrace)
		{
			if (LogLevel >= LogLevels.Error)
			{
				Warning(Message(e.Message));
				if (stackTrace)
				{
					Warning(e.StackTrace);
				}
			}
		}

		internal void Critical(Exception e)
		{
			if (LogLevel >= LogLevels.Critical)
			{
				Debug(Message(e.Message));
				Error(e.StackTrace);
			}
		}

		private string Message(string msg)
		{
			return ModName + ": " + msg;
		}

		internal bool Testing()
		{
			return Instance.LogLevel >= LogLevels.Debug;
		}

		internal static void ChangeLogging(object s, EventArgs e)
		{
			ConfigEntry<LogLevels> val = s as ConfigEntry<LogLevels>;
			if (_instance != null)
			{
				Instance.LogLevel = val.Value;
				Instance.Info($"Change {((ConfigEntryBase)val).Definition.Key} to {val.Value}");
			}
		}
	}
	public static class ModResourceBootstrap
	{
		public static string InitializeModResources(Type pluginType, string modName)
		{
			string orCreateModConfigFolder = ConfigFolderHelper.GetOrCreateModConfigFolder(modName);
			string? name = pluginType.Assembly.GetName().Name;
			if (!Directory.Exists(orCreateModConfigFolder))
			{
				Directory.CreateDirectory(orCreateModConfigFolder);
				Logging.Instance.Debug("Created subfolder layout: " + orCreateModConfigFolder);
			}
			string text = name + ".Resources.";
			Logging.Instance.Debug("Scanning assembly for standard prefix: " + text);
			ExtractResources(pluginType.Assembly, text, orCreateModConfigFolder);
			return orCreateModConfigFolder;
		}

		private static void ExtractResources(Assembly asm, string prefix, string targetFolder)
		{
			string[] manifestResourceNames = asm.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				string text2 = text.Substring(prefix.Length);
				string text3 = Path.Combine(targetFolder, text2);
				if (File.Exists(text3))
				{
					continue;
				}
				try
				{
					Logging.Instance.Debug("Extracting asset: " + text2 + " -> " + text3);
					using Stream stream = asm.GetManifestResourceStream(text);
					if (stream == null)
					{
						Logging.Instance.Error("Could not access resource stream for: " + text);
						continue;
					}
					using FileStream destination = File.Create(text3);
					stream.CopyTo(destination);
				}
				catch (Exception ex)
				{
					Logging.Instance.Error("Failed to unpack embedded asset " + text2 + ": " + ex.Message);
				}
			}
		}
	}
	public class ServerConfiguration
	{
		[HarmonyPatch(typeof(ZNet), "StopAll")]
		private static class ZNet_Shutdown_Patch
		{
			[HarmonyPrefix]
			private static void ZNet_StopAll_Prefix(ZNet __instance)
			{
				if (_instance != null)
				{
					Log.Debug("ZNet_StopAll_Patch_Prefix");
					_instance.ReceivedServerValues = false;
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class ZNet_OnNewConnection_Patch
		{
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				Log.Debug("ZNet OnNewConnection postfix");
				if (!__instance.IsServer())
				{
					try
					{
						peer.m_rpc.Register<ZPackage>("ClientConfigReceiver." + GetPluginGuid(), (Action<ZRpc, ZPackage>)Instance.RPC_ClientConfigReceiver);
						Log.Debug("Player registered RPC_ClientConfigReceiver");
						return;
					}
					catch (Exception)
					{
						Log.Warning("Failed to register RPC");
						return;
					}
				}
				try
				{
					Instance.SendConfigToClient(peer);
				}
				catch (Exception)
				{
					Log.Warning("Error sending server configuration to client");
				}
			}
		}

		public static List<DelegatedConfigEntryBase> ServerDelegatedEntries = new List<DelegatedConfigEntryBase>();

		private static ConfigFile LocalConfig;

		private static BaseUnityPlugin Mod;

		private static string ConfigFileName;

		private static ServerConfiguration _instance;

		private static Logging Log;

		public bool IsSetup;

		public bool ReceivedServerValues;

		public FileSystemWatcher ConfigWatcher;

		private const string NOT_CONFIGURED = "ServerConfiguration not initialized. Setup first.";

		public static ServerConfiguration Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new ServerConfiguration();
				}
				return _instance;
			}
		}

		private ServerConfiguration()
		{
		}

		public void Setup(ConfigFile config, BaseUnityPlugin modInstance)
		{
			LocalConfig = config;
			Log = Logging.GetLogger();
			Log.Trace("ServerConfiguration Setup");
			Mod = modInstance;
			ConfigFileName = Path.GetFileName(LocalConfig.ConfigFilePath);
			IsSetup = true;
		}

		public void CreateConfigWatcher()
		{
			ConfigWatcher = Utils.CreateFileWatcher(LocalConfig.ConfigFilePath, LoadConfig);
		}

		private void LoadConfig(object sender, FileSystemEventArgs e)
		{
			if (!File.Exists(LocalConfig.ConfigFilePath))
			{
				return;
			}
			try
			{
				Log.Debug($"Loading configuration {e.ChangeType}");
				LocalConfig.Reload();
			}
			catch
			{
				Log.Error("Error loading configuration file " + ConfigFileName);
			}
		}

		public static string GetPluginGuid()
		{
			return Mod.Info.Metadata.GUID;
		}

		public void RPC_ClientConfigReceiver(ZRpc zrpc, ZPackage package)
		{
			if (!Instance.IsSetup)
			{
				Log.Error("ServerConfiguration not initialized. Setup first.");
				return;
			}
			Log.Debug("ClientConfigReceiver");
			string section;
			string name;
			while (package.GetPos() < package.Size())
			{
				section = package.ReadString();
				name = package.ReadString();
				string text = package.ReadString();
				Log.Trace("Reading " + section + " " + name + " value " + text + " from ZPackage");
				DelegatedConfigEntryBase delegatedConfigEntryBase = ServerDelegatedEntries.Find((DelegatedConfigEntryBase e) => e.Name == name && e.Section == section);
				if (delegatedConfigEntryBase != null)
				{
					Log.Trace("Found DCEB on client and setting to server value " + text);
					delegatedConfigEntryBase.ServerValue = text;
				}
				ConfigEntryBase val = LocalConfig[section, name];
				if (val != null)
				{
					Log.Trace("Found local CEB and setting underlying config value " + text);
					val.SetSerializedValue(text);
				}
			}
			ReceivedServerValues = true;
		}

		internal void WriteConfigEntries(ZPackage zpkg)
		{
			foreach (DelegatedConfigEntryBase serverDelegatedEntry in ServerDelegatedEntries)
			{
				Log.Trace("Writing " + serverDelegatedEntry.Section + " " + serverDelegatedEntry.Name + " value " + serverDelegatedEntry.ServerValue + " to ZPackage");
				zpkg.Write(serverDelegatedEntry.Section);
				zpkg.Write(serverDelegatedEntry.Name);
				zpkg.Write(serverDelegatedEntry.ServerValue);
			}
		}

		internal void SendConfigToClient(ZNetPeer peer)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (!Instance.IsSetup)
			{
				Log.Error("ServerConfiguration not initialized. Setup first.");
				return;
			}
			Log.Debug("SendConfigToClient");
			ZPackage val = new ZPackage();
			WriteConfigEntries(val);
			peer.m_rpc.Invoke("ClientConfigReceiver." + GetPluginGuid(), new object[1] { val });
			Log.Trace("Invoked ClientConfigReceiver on peer");
		}

		public void SendConfigToAllClients(object o, SettingChangedEventArgs e)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			if (!IsSetup)
			{
				Log.Error("ServerConfiguration not initialized. Setup first.");
			}
			else if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && ZNet.instance.GetPeerConnections() > 0)
			{
				Log.Debug("SendConfigToAllClients");
				ZPackage zpkg = new ZPackage();
				WriteConfigEntries(zpkg);
				((MonoBehaviour)Mod).StartCoroutine(_instance.Co_BroadcastConfig(zpkg));
			}
		}

		private IEnumerator Co_BroadcastConfig(ZPackage zpkg)
		{
			Log.Debug("Co_BroadcastConfig");
			List<ZNetPeer> connectedPeers = ZNet.instance.GetConnectedPeers();
			foreach (ZNetPeer item in connectedPeers)
			{
				if (item != ZNet.instance.GetServerPeer())
				{
					item.m_rpc.Invoke("ClientConfigReceiver." + GetPluginGuid(), new object[1] { zpkg });
					Log.Trace("Invoked ClientConfigReceiver on peer");
				}
				yield return null;
			}
		}
	}
	public class Utils
	{
		public static TEnum Guardrails<TEnum>(string value, TEnum enumDefault) where TEnum : struct
		{
			if (Enum.TryParse<TEnum>(value, ignoreCase: true, out var result))
			{
				return result;
			}
			return enumDefault;
		}

		public static int Guardrails(int value, int lbound, int ubound)
		{
			if (value < lbound)
			{
				return lbound;
			}
			if (value > ubound)
			{
				return ubound;
			}
			return value;
		}

		public static string Truncate(string value, int maxChars)
		{
			if (value == null)
			{
				return null;
			}
			if (value.Length <= maxChars)
			{
				return value;
			}
			return value.Substring(0, maxChars);
		}

		public static void GetCharactersInRangeXZ(Vector3 point, float radius, List<Character> characters)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			float num = radius * radius;
			foreach (Character s_character in Character.s_characters)
			{
				if (DistanceSqrXZ(((Component)s_character).transform.position, point) < num)
				{
					characters.Add(s_character);
				}
			}
		}

		public static PinData GetClosestPin(Vector3 pos, float radius, PinType pType)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			PinData result = null;
			float num = float.MaxValue;
			float num2 = radius * radius;
			if ((Object)(object)Minimap.instance != (Object)null)
			{
				foreach (PinData pin in Minimap.instance.m_pins)
				{
					if ((Object)(object)pin.m_uiElement != (Object)null && pin.m_type == pType)
					{
						float num3 = DistanceSqrXZ(pos, pin.m_pos);
						if (Logging.Instance.LogLevel >= Logging.LogLevels.Debug)
						{
							Logging.Instance.Debug($"Testing for pin at {pin.m_pos} within radius {radius} from {pos}");
						}
						if (num3 < num2 && num3 < num)
						{
							Logging.Instance.Debug("Pin is within radius");
							num = num3;
							result = pin;
						}
					}
				}
			}
			return result;
		}

		public static float DistanceSqr(Vector3 v0, Vector3 v1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = v1 - v0;
			return ((Vector3)(ref val)).sqrMagnitude;
		}

		public static float DistanceSqrXZ(Vector3 v0, Vector3 v1)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = v1.x - v0.x;
			float num2 = v1.z - v0.z;
			return num * num + num2 * num2;
		}

		public static Vector3 ClosestPoint<T>(Vector3 point, IEnumerable<T> collection, Func<T, Vector3> selector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			Vector3 result = default(Vector3);
			float num = float.MaxValue;
			foreach (T item in collection)
			{
				Vector3 val = selector(item);
				Vector3 val2 = val - point;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = val;
				}
			}
			return result;
		}

		public static T ClosestObject<T>(Vector3 point, IEnumerable<T> collection, Func<T, Vector3> selector)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			T result = default(T);
			float num = float.MaxValue;
			foreach (T item in collection)
			{
				Vector3 val = selector(item) - point;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < num)
				{
					num = sqrMagnitude;
					result = item;
				}
			}
			return result;
		}

		public static Vector3 ClosestPointXZ<T>(Vector3 point, IEnumerable<T> collection, Func<T, Vector3> selector)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			float num = float.MaxValue;
			foreach (T item in collection)
			{
				Vector3 val = selector(item);
				float num2 = DistanceSqrXZ(val, point);
				if (num2 < num)
				{
					num = num2;
					result = val;
				}
			}
			return result;
		}

		public static T ClosestObjectXZ<T>(Vector3 point, IEnumerable<T> collection, Func<T, Vector3> selector)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			T result = default(T);
			float num = float.MaxValue;
			foreach (T item in collection)
			{
				float num2 = DistanceSqrXZ(selector(item), point);
				if (num2 < num)
				{
					num = num2;
					result = item;
				}
			}
			return result;
		}

		public static float Guardrails(float value, float lbound, float ubound)
		{
			if (value < lbound)
			{
				return lbound;
			}
			if (value > ubound)
			{
				return ubound;
			}
			return value;
		}

		public static string UnClonifiedName(string name)
		{
			if (name == null)
			{
				return null;
			}
			int num = name.IndexOf("(Clone)");
			if (num < 1)
			{
				return name;
			}
			return name.Substring(0, num);
		}

		public static void SetTranslator(int id, string idText)
		{
			Localization.instance.AddWord("skill_" + id, idText);
		}

		public static string GetTranslated(int id)
		{
			Logging.GetLogger().Debug(string.Format("Got translation for id {0} to {1}", id, Localization.instance.Localize("skill_" + id)));
			return Localization.instance.Localize("$skill_" + id);
		}

		public static string GetAssemblyPathedFile(string fileName)
		{
			return new FileInfo(Assembly.GetExecutingAssembly().Location).DirectoryName.Replace('\\', '/') + "/" + fileName;
		}

		public static Sprite GetPrefabIcon(string prefabName)
		{
			Sprite result = null;
			GameObject prefab = GetPrefab(prefabName);
			ItemDrop val = default(ItemDrop);
			if (Object.op_Implicit((Object)(object)prefab) && prefab.TryGetComponent<ItemDrop>(ref val))
			{
				result = val.m_itemData.GetIcon();
			}
			return result;
		}

		public static Player GetPlayerByZDOID(ZDOID zid)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				ZDOID zDOID = ((Character)allPlayer).GetZDOID();
				if (((ZDOID)(ref zDOID)).Equals(zid))
				{
					return allPlayer;
				}
			}
			return null;
		}

		public static Character GetCharacterByZDOID(string cid)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (((object)allCharacter.GetZDOID()/*cast due to .constrained prefix*/).ToString().Equals(cid))
				{
					return allCharacter;
				}
			}
			return null;
		}

		public static Character GetCharacterByZDOID(ZDOID cid)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				ZDOID zDOID = allCharacter.GetZDOID();
				if (((ZDOID)(ref zDOID)).Equals(cid))
				{
					return allCharacter;
				}
			}
			return null;
		}

		public static ZNetPeer GetPeerByRPC(ZRpc rpc)
		{
			foreach (ZNetPeer peer in ZNet.instance.GetPeers())
			{
				if (peer.m_rpc == rpc)
				{
					return peer;
				}
			}
			return null;
		}

		public static List<GameObject> GetGameObjectsOfType(Type t)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			List<GameObject> list = new List<GameObject>();
			Object[] array = Object.FindObjectsByType(t, (FindObjectsSortMode)0);
			foreach (Object val in array)
			{
				list.Add(((Component)val).gameObject);
			}
			return list;
		}

		public static GameObject GetClosestGameObjectOfType(Type t, Vector3 point, float radius)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return GetGameObjectsOfTypeInRangeByDistance(t, point, radius)?[0];
		}

		public static List<GameObject> GetGameObjectsOfTypeInRangeByDistance(Type t, Vector3 point, float radius)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			List<KeyValuePair<GameObject, float>> list = new List<KeyValuePair<GameObject, float>>();
			List<GameObject> gameObjectsOfTypeInRange = GetGameObjectsOfTypeInRange(t, point, radius);
			if (gameObjectsOfTypeInRange.Count > 0)
			{
				foreach (GameObject item in gameObjectsOfTypeInRange)
				{
					list.Add(new KeyValuePair<GameObject, float>(item, Vector3.Distance(item.transform.position, point)));
				}
				list.Sort((KeyValuePair<GameObject, float> pair1, KeyValuePair<GameObject, float> pair2) => pair1.Value.CompareTo(pair2.Value));
				return list.ConvertAll((KeyValuePair<GameObject, float> x) => x.Key);
			}
			return null;
		}

		public static List<GameObject> GetGameObjectsOfTypeInRange(Type t, Vector3 point, float radius)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			float radiusSq = radius * radius;
			return GetGameObjectsOfType(t).Where(delegate(GameObject x)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = x.transform.position - point;
				return ((Vector3)(ref val)).sqrMagnitude < radiusSq;
			}).ToList();
		}

		public static float GetPointDepth(Vector3 p)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return ZoneSystem.instance.m_waterLevel - GetSolidHeight(p);
		}

		public static List<string> GetDelimitedStringAsList(string delimitedString, char delimiter)
		{
			List<string> list = new List<string>();
			string[] array = delimitedString.Split(new char[1] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				list.Add(text.Trim());
			}
			return list;
		}

		public static float GetSolidHeight(Vector3 p)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			int solidRayMask = ZoneSystem.instance.m_solidRayMask;
			float result = 0f;
			p.y += 1000f;
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(p, Vector3.down, ref val, 2000f, solidRayMask) && !Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).collider.attachedRigidbody))
			{
				result = ((RaycastHit)(ref val)).point.y;
			}
			return result;
		}

		public static Transform FindChild(Transform aParent, string aName)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			foreach (Transform item in aParent)
			{
				Transform val = item;
				if (((Object)val).name == aName)
				{
					return val;
				}
				Transform val2 = FindChild(val, aName);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		public static Transform FindParent(Transform go)
		{
			while ((Object)(object)go.parent != (Object)null)
			{
				go = go.parent;
			}
			return go;
		}

		public static bool IsPrefabInScene(string prefabName)
		{
			return IsPrefabInScene(StringExtensionMethods.GetStableHashCode(prefabName));
		}

		public static bool IsPrefabInScene(int prefabHash)
		{
			ZNetScene instance = ZNetScene.instance;
			return (Object)(object)((instance != null) ? instance.GetPrefab(prefabHash) : null) != (Object)null;
		}

		public static bool TryGetPrefab(string prefabName, out GameObject prefab)
		{
			return TryGetPrefab(StringExtensionMethods.GetStableHashCode(prefabName), out prefab);
		}

		public static bool TryGetPrefab(int prefabHash, out GameObject prefab)
		{
			prefab = GetPrefabByHash(prefabHash);
			return (Object)(object)prefab != (Object)null;
		}

		public static GameObject GetPrefabByHash(int prefabHash)
		{
			GameObject val = null;
			Logging logger = Logging.GetLogger();
			ZNetScene instance = ZNetScene.instance;
			val = ((instance != null) ? instance.GetPrefab(prefabHash) : null);
			if ((Object)(object)val != (Object)null)
			{
				logger.Debug("Found prefab in Scene");
				return val;
			}
			val = ObjectDB.instance.GetItemPrefab(prefabHash);
			if ((Object)(object)val != (Object)null)
			{
				logger.Debug("Found prefab in ObjectDB");
				return val;
			}
			logger.Debug("No prefab found");
			return val;
		}

		public static GameObject GetPrefab(int prefabHash)
		{
			return GetPrefabByHash(prefabHash);
		}

		public static GameObject GetPrefab(string prefabName)
		{
			return GetPrefabByHash(StringExtensionMethods.GetStableHashCode(prefabName));
		}

		public static void LoadPrefabInScene(GameObject prefab)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)prefab).name);
			if ((Object)(object)ZNetScene.instance != (Object)null && !ZNetScene.instance.m_namedPrefabs.ContainsKey(stableHashCode))
			{
				ZNetScene.instance.m_prefabs.Add(prefab);
				ZNetScene.instance.m_namedPrefabs[stableHashCode] = prefab;
			}
		}

		public static GameObject SpawnObject(string prefabName, Vector3 position, Quaternion rotation, bool persist = true)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetPrefab(prefabName, out var prefab))
			{
				return SpawnObject(prefab, position, rotation, persist);
			}
			return null;
		}

		public static GameObject SpawnObject(GameObject prefab, Vector3 position, Quaternion rotation, bool persist = true)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			LoadPrefabInScene(prefab);
			GameObject val = Object.Instantiate<GameObject>(prefab, position, rotation);
			ZNetView val2 = default(ZNetView);
			if (persist && val.TryGetComponent<ZNetView>(ref val2))
			{
				val2.GetZDO().Persistent = true;
			}
			return val;
		}

		public static string SerializeFromDictionary<K, V>(string delimp, string delimc, IDictionary<K, V> dict)
		{
			if (dict == null)
			{
				return null;
			}
			IEnumerable<string> values = dict.Select(delegate(KeyValuePair<K, V> kvp)
			{
				KeyValuePair<K, V> keyValuePair = kvp;
				string? obj = keyValuePair.Key?.ToString();
				string text = delimc;
				keyValuePair = kvp;
				return obj + text + keyValuePair.Value;
			});
			return string.Join(delimp, values);
		}

		public static void DeserializeToDictionary<K, V>(string serializedString, string delimp, string delimc, ref IDictionary<K, V> dict)
		{
			if (dict == null)
			{
				return;
			}
			dict.Clear();
			string[] separator = new string[1] { delimp };
			string[] separator2 = new string[1] { delimc };
			string[] array = serializedString.Split(separator, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(separator2, StringSplitOptions.RemoveEmptyEntries);
				if (array2.Length == 2)
				{
					dict.Add(TypedValue<K>(array2[0]), TypedValue<V>(array2[1]));
				}
			}
		}

		public static FileSystemWatcher CreateFileWatcher(string fullPath, FileSystemEventHandler handler)
		{
			string fileName = Path.GetFileName(fullPath);
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(fullPath.Substring(0, fullPath.Length - fileName.Length), fileName);
			fileSystemWatcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.Size | NotifyFilters.LastWrite | NotifyFilters.CreationTime;
			fileSystemWatcher.Changed += handler;
			fileSystemWatcher.Created += handler;
			fileSystemWatcher.IncludeSubdirectories = false;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			return fileSystemWatcher;
		}

		public static T TypedValue<T>(object a)
		{
			return (T)Convert.ChangeType(a, typeof(T));
		}

		public static float TimeAdjustedRamp(float maxValue, float duration, float elapsedTime, float pctFromStartRise, float pctFromEndFall)
		{
			float num = elapsedTime / duration;
			if (num <= pctFromStartRise)
			{
				return maxValue * (num / pctFromStartRise);
			}
			if (num >= 1f - pctFromEndFall)
			{
				return maxValue * ((1f - num) / pctFromEndFall);
			}
			return maxValue;
		}

		public static Color IntToColor(int rgba)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)((rgba >> 16) & 0xFF) / 255f;
			float num2 = (float)((rgba >> 8) & 0xFF) / 255f;
			float num3 = (float)(rgba & 0xFF) / 255f;
			float num4 = (float)((rgba >> 24) & 0xFF) / 255f;
			return new Color(num, num2, num3, num4);
		}

		public static bool CopyComponentToGameObject(Component original, ref GameObject destination)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			Logging logger = Logging.GetLogger();
			Type type = ((object)original).GetType();
			logger.Debug($"Original Type is {type}");
			GameObject obj = destination;
			logger.Debug("Destination GameObject " + ((obj != null) ? ((Object)obj).name : null));
			Component val = destination.GetComponent(type);
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = destination.AddComponent(type);
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				logger.Debug("Destination component is null");
				return false;
			}
			Component val2 = (Component)Activator.CreateInstance(type);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				logger.Debug("Destination component is null");
				return false;
			}
			if (!Object.op_Implicit((Object)(object)val2))
			{
				logger.Debug("Boxed component is null");
				return false;
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(val2, fieldInfo.GetValue(original));
			}
			val = val2;
			return true;
		}

		public static bool CopyObject(object original, object target)
		{
			Logging logger = Logging.GetLogger();
			Type type = original.GetType();
			Type type2 = target.GetType();
			if (type == null)
			{
				logger.Warning("Copy Object: Source object is null");
				return false;
			}
			if (type2 == null)
			{
				logger.Warning("Copy Object: Destination object is null");
				return false;
			}
			if (type2 != type)
			{
				logger.Warning("Copy Object: Source and destination components are different types");
				return false;
			}
			FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(target, fieldInfo.GetValue(original));
			}
			return true;
		}
	}
}
namespace neobotics.ValheimMods
{
	internal class Cfg
	{
		public static DelegatedConfigEntry<int> displacementChance;

		public static DelegatedConfigEntry<int> maxPieceDamage;

		public static DelegatedConfigEntry<int> maxTreeDamage;

		public static DelegatedConfigEntry<bool> allowFullDestruction;

		public static DelegatedConfigEntry<float> faultChance;

		public static DelegatedConfigEntry<bool> activeWardsPreventDamage;

		public static DelegatedConfigEntry<bool> activeShieldsPreventDamage;

		public static DelegatedConfigEntry<bool> monstersFlee;

		public static DelegatedConfigEntry<bool> showDust;

		public static DelegatedConfigEntry<bool> charactersStagger;

		public static DelegatedConfigEntry<bool> hookedItemsFall;

		public static DelegatedConfigEntry<bool> activeItemsMove;

		public static DelegatedConfigEntry<bool> quakeSpawnsTreasure;

		public static DelegatedConfigEntry<int> earthquakeRadius;

		public static DelegatedConfigEntry<bool> cameraShakeOverride;

		public static DelegatedConfigEntry<int> cameraShakeIntensity;

		public static DelegatedConfigEntry<int> cameraShakeFrequency;

		public static DelegatedConfigEntry<bool> biomeMeadows;

		public static DelegatedConfigEntry<bool> biomeSwamp;

		public static DelegatedConfigEntry<bool> biomeBlackForest;

		public static DelegatedConfigEntry<bool> biomeMistlands;

		public static DelegatedConfigEntry<bool> biomeAshlands;

		public static DelegatedConfigEntry<bool> biomeDeepNorth;

		public static DelegatedConfigEntry<bool> biomeMountains;

		public static DelegatedConfigEntry<bool> biomePlains;

		public static DelegatedConfigEntry<float> fissureMaxDepth;

		public static DelegatedConfigEntry<float> fissureDeepenPct;

		public static DelegatedConfigEntry<int> minInterval;

		public static DelegatedConfigEntry<int> maxInterval;

		public static DelegatedConfigEntry<Logging.LogLevels> debugLevel;

		public static void BepInExConfig(BaseUnityPlugin _instance)
		{
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Expected O, but got Unknown
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Expected O, but got Unknown
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Expected O, but got Unknown
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04de: Expected O, but got Unknown
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_052b: Expected O, but got Unknown
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Expected O, but got Unknown
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Expected O, but got Unknown
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Expected O, but got Unknown
			ServerConfiguration.Instance.Setup(_instance.Config, _instance);
			debugLevel = new DelegatedConfigEntry<Logging.LogLevels>(ChangeLogging);
			debugLevel.ConfigEntry = _instance.Config.Bind<Logging.LogLevels>("Utility", "LogLevel", Logging.LogLevels.Info, "Controls the level of information contained in the log");
			Valquake.Log.LogLevel = debugLevel.Value;
			biomeMeadows = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeMeadows.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Meadows", true, "Earthquakes trigger in the Meadows.@");
			biomeSwamp = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeSwamp.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Swamp", false, "Earthquakes trigger in the Swamp.@");
			biomeBlackForest = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeBlackForest.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Black Forest", false, "Earthquakes trigger in the Black Forest.@");
			biomeMountains = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeMountains.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Mountains", true, "Earthquakes trigger in the Mountains.@");
			biomePlains = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomePlains.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Plains", false, "Earthquakes trigger in the Plains.@");
			biomeMistlands = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeMistlands.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Mistlands", true, "Earthquakes trigger in the Mistlands.@");
			biomeAshlands = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeAshlands.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Ashlands", true, "Earthquakes trigger in the Ashlands.@");
			biomeDeepNorth = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			biomeDeepNorth.ConfigEntry = _instance.Config.Bind<bool>("Biomes", "Deep North", false, "Earthquakes trigger in the Deep North.@");
			showDust = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			showDust.ConfigEntry = _instance.Config.Bind<bool>("Effects", "A. Show Dust", true, "If enabled, will display a cloud of dust along the fault line during a quake. Only meaningful if Fissure Chance is > 0%.@");
			monstersFlee = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			monstersFlee.ConfigEntry = _instance.Config.Bind<bool>("Effects", "B. Creatures Scatter", true, "If enabled, creatures close enough to quake zone will scatter for a short time.@");
			charactersStagger = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			charactersStagger.ConfigEntry = _instance.Config.Bind<bool>("Effects", "C. Staggering", true, "If enabled, players and creatures can stagger during the quake while inside the quake zone.@");
			allowFullDestruction = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			allowFullDestruction.ConfigEntry = _instance.Config.Bind<bool>("Effects", "D. Allow Piece Destruction", false, "If enabled, allows the full destruction of pieces duing the quake (dropping materials). If disabled, pieces can only be reduced to 1 health.@");
			displacementChance = new DelegatedConfigEntry<int>(useServerDelegate: true);
			displacementChance.ConfigEntry = _instance.Config.Bind<int>("Effects", "E. Piece Displacement Chance", 0, new ConfigDescription("The percent chance pieces are displaced in the horizontal plane during a quake. A value of zero (0) never displaces pieces.@", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			hookedItemsFall = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			hookedItemsFall.ConfigEntry = _instance.Config.Bind<bool>("Effects", "F. Items Can Fall", true, "If enabled, things mounted on items stands can be shaken loose and fall during a quake.@");
			activeItemsMove = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			activeItemsMove.ConfigEntry = _instance.Config.Bind<bool>("Effects", "G. Things Can Move", true, "If enabled, some 'active' things like carts & ships, will move with the quake.@");
			earthquakeRadius = new DelegatedConfigEntry<int>(useServerDelegate: true);
			earthquakeRadius.ConfigEntry = _instance.Config.Bind<int>("Control", "A. Quake Radius", 100, new ConfigDescription("Radius (in meters) of the earthquake damage zone. Effects will diminish farther from the epicenter.@", (AcceptableValueBase)(object)new AcceptableValueRange<int>(20, 200), Array.Empty<object>()));
			minInterval = new DelegatedConfigEntry<int>(Valquake.ChangeMinInterval, useServerDelegate: true);
			minInterval.ConfigEntry = _instance.Config.Bind<int>("Control", "B. Min Interval", 30, "Minimum possible time (in minutes) between earthquakes. Minimum value is 1.@");
			maxInterval = new DelegatedConfigEntry<int>(Valquake.ChangeMaxInterval, useServerDelegate: true);
			maxInterval.ConfigEntry = _instance.Config.Bind<int>("Control", "C. Max Interval", 120, "Maximum possible time (in minutes) between earthquakes. Value must be equal to or greater than Min Interval.@");
			faultChance = new DelegatedConfigEntry<float>(useServerDelegate: true);
			faultChance.ConfigEntry = _instance.Config.Bind<float>("Control", "D. Fault Zone Chance", 20f, new ConfigDescription("The percent chance of a zone having a 'fault line'. Quakes will only create a fissure in a zone with a fault line. A value of 0% will prevent any fissures from forming.@", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f), Array.Empty<object>()));
			maxPieceDamage = new DelegatedConfigEntry<int>(useServerDelegate: true);
			maxPieceDamage.ConfigEntry = _instance.Config.Bind<int>("Control", "E. Max Piece Damage", 1000, new ConfigDescription("The maximum damage that can be applied to pieces in the quake zone. A value of 0 will not apply any damage. Damage is attenuated by distance from the epicenter and degree of support.@", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2000), Array.Empty<object>()));
			maxTreeDamage = new DelegatedConfigEntry<int>(useServerDelegate: true);
			maxTreeDamage.ConfigEntry = _instance.Config.Bind<int>("Control", "F. Max Tree Damage", 200, new ConfigDescription("The maximum damage that can be applied to trees in the quake zone. A value of 0 will not apply any damage. Damage is attenuated by distance from the epicenter.@", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 200), Array.Empty<object>()));
			fissureMaxDepth = new DelegatedConfigEntry<float>(useServerDelegate: true);
			fissureMaxDepth.ConfigEntry = _instance.Config.Bind<float>("Control", "G. Max Fissure Depth", 2f, new ConfigDescription("The maximum depth (in meters) of the fissure for the first quake along a fault line. Subsequent quakes along the same fault line are controlled by Successive Quake Depth as a percentage of this value.@", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 6f), Array.Empty<object>()));
			fissureDeepenPct = new DelegatedConfigEntry<float>(useServerDelegate: true);
			fissureDeepenPct.ConfigEntry = _instance.Config.Bind<float>("Control", "H. Successive Quake Depth", 0.2f, new ConfigDescription("Sets the percent of the Max Fissure Depth to apply to each successive quake along the same fault line. A value of 0% will not deepen the fissure.@", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			activeWardsPreventDamage = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			activeWardsPreventDamage.ConfigEntry = _instance.Config.Bind<bool>("Control", "I. Active Wards Reduce Damage", false, "If enabled, an active ward will reduce damage to pieces if the quake epicenter is within the ward's area of protection.@");
			activeShieldsPreventDamage = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			activeShieldsPreventDamage.ConfigEntry = _instance.Config.Bind<bool>("Control", "J. Active Shields Reduce Damage", false, "If enabled, a fueled Shield Generator will reduce damage to pieces if the quake epicenter is within the shield's area of protection.@");
			quakeSpawnsTreasure = new DelegatedConfigEntry<bool>(useServerDelegate: true);
			quakeSpawnsTreasure.ConfigEntry = _instance.Config.Bind<bool>("Control", "K. Quake Unearths Treasure", false, "If enabled, a quake has a chance of unearthing random treasure in the fissure.@");
			cameraShakeOverride = new DelegatedConfigEntry<bool>();
			cameraShakeOverride.ConfigEntry = _instance.Config.Bind<bool>("Camera", "Camera Sway Override", false, "If enabled, will override Valheim's camera shake setting (just for quakes) and 'sway' camera. If disabled, will use Valheim's setting.");
			cameraShakeIntensity = new DelegatedConfigEntry<int>();
			cameraShakeIntensity.ConfigEntry = _instance.Config.Bind<int>("Camera", "Camera Sway Intensity", 100, new ConfigDescription("Sets how much the camera 'sways'. Lower values will reduce the amount of camera movement.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			cameraShakeFrequency = new DelegatedConfigEntry<int>();
			cameraShakeFrequency.ConfigEntry = _instance.Config.Bind<int>("Camera", "Camera Sway Frequency", 10, new ConfigDescription("Sets how fast the camera 'sways'. Lower values will reduce how quickly the camera moves.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()));
			ServerConfiguration.Instance.CreateConfigWatcher();
		}

		public static void ChangeLogging(object s, EventArgs e)
		{
			SettingChangedEventArgs e2 = (SettingChangedEventArgs)(object)((e is SettingChangedEventArgs) ? e : null);
			Valquake.Log.Debug($"ChangeLog {e2.ChangedSetting.Definition.Key} to {e2.ChangedSetting.BoxedValue}");
			Valquake.Log.LogLevel = debugLevel.Value;
		}
	}
	public class QuakeShaker
	{
		private float angle;

		public static float s_baseIntensity = 3f;

		public static float PctRise = 0.2f;

		public static float PctFall = 0.5f;

		private const float twoPi = MathF.PI * 2f;

		private float lastTime;

		public Vector3 Epicenter { get; set; }

		public float Frequency { get; set; }

		public float Duration { get; set; }

		public float Intensity { get; set; }

		public float Radius { get; set; }

		private float StopTime { get; set; }

		public QuakeShaker(Vector3 epicenter, float radius, float intensity, float duration, float frequency = 30f)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Epicenter = epicenter;
			Frequency = frequency;
			Duration = duration;
			Intensity = intensity;
			Radius = radius;
			StopTime = 0f;
		}

		public bool isActive()
		{
			return Time.time < StopTime;
		}

		public void Start()
		{
			StopTime = Time.time + Duration;
		}

		public void Stop()
		{
			StopTime = 0f;
		}

		public float PctOfDuration()
		{
			return 1f - (StopTime - Time.time) / Duration;
		}

		public bool HasPeaked()
		{
			return PctOfDuration() >= PctRise;
		}

		public bool InPeakWindow()
		{
			float num = PctOfDuration();
			if (num >= PctRise)
			{
				return num <= PctFall;
			}
			return false;
		}

		public float ElapsedTime()
		{
			return Time.time + Duration - StopTime;
		}

		public float TimeRemaining()
		{
			return StopTime - Time.time;
		}

		public float GetCurrentAngle()
		{
			return angle;
		}

		public void Update(float dt)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			if (!isActive())
			{
				lastTime = 0f;
				return;
			}
			GameCamera instance = GameCamera.instance;
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null))
			{
				float time = Time.time;
				if (lastTime != 0f)
				{
					dt = time - lastTime;
				}
				lastTime = time;
				float num = Vector3.Distance(((Component)localPlayer).transform.position, Epicenter);
				float num2 = 200f;
				num = Mathf.Min(num, num2);
				float num3 = (float)Cfg.cameraShakeIntensity.Value / 100f;
				float baseMagnitude = TimeAdjustedIntensity() * num3;
				float aggregateMagnitude = GetAggregateMagnitude(baseMagnitude, num, num2);
				float num4 = Intensity * 0.05f;
				aggregateMagnitude = Mathf.Max(aggregateMagnitude, num4);
				float num5 = AdjustFrequencyForDistance(num, num2);
				float num6 = Frequency * num5;
				angle += dt * num6;
				if (angle > MathF.PI * 2f)
				{
					angle -= MathF.PI * 2f;
				}
				Quaternion val = Quaternion.Euler(Mathf.Sin(angle) * aggregateMagnitude, 0f, Mathf.Cos(angle * 0.9f) * aggregateMagnitude);
				((Component)instance).transform.rotation = ((Component)instance).transform.rotation * val;
			}
		}

		internal float GetAggregateMagnitude(float baseMagnitude, float dist, float maxDist)
		{
			return baseMagnitude * GetGeometricDamping(dist, maxDist) * AdjustIntensityForDistance(dist, maxDist) * GetBiomeDamping(Player.m_localPlayer);
		}

		internal float TimeAdjustedIntensity()
		{
			return Utils.TimeAdjustedRamp(Intensity, Duration, ElapsedTime(), PctRise, PctFall);
		}

		private float GetBiomeDamping(Player player)
		{
			return 1f;
		}

		private float GetGeometricDamping(float dist, float radius)
		{
			return 1f / Mathf.Sqrt(1f + dist / radius * (dist / radius));
		}

		private float AdjustFrequencyForDistance(float dist, float radius)
		{
			float num = Mathf.Clamp01(dist / radius);
			return Mathf.Lerp(1f, 0.4f, num);
		}

		private float AdjustIntensityForDistance(float dist, float radius)
		{
			float num = Mathf.Clamp01(dist / radius);
			return 1f / (1f + Mathf.Log(1f + num * 4f));
		}
	}
	public class QuakeTreasureSpawner
	{
		public class DropEntry
		{
			public string ItemPrefab { get; set; }

			public float RarityChance { get; set; }

			public int Biome { get; set; }

			public DropEntry(string prefab, float rarityChance, int biome)
			{
				ItemPrefab = prefab;
				RarityChance = rarityChance;
				Biome = biome;
			}
		}

		public class BiomeLootPool
		{
			public List<DropEntry> Items { get; set; } = new List<DropEntry>();
		}

		internal static Dictionary<Biome, int> biomeValues;

		private static readonly List<DropEntry> MasterDropTable;

		private static readonly Dictionary<int, BiomeLootPool> CompiledLootPools;

		private static readonly Random Rand;

		static QuakeTreasureSpawner()
		{
			biomeValues = new Dictionary<Biome, int>
			{
				{
					(Biome)1,
					1
				},
				{
					(Biome)8,
					2
				},
				{
					(Biome)2,
					3
				},
				{
					(Biome)4,
					4
				},
				{
					(Biome)16,
					5
				},
				{
					(Biome)512,
					6
				},
				{
					(Biome)32,
					7
				},
				{
					(Biome)64,
					8
				},
				{
					(Biome)256,
					3
				}
			};
			MasterDropTable = new List<DropEntry>
			{
				new DropEntry("Amber", 1f, 0),
				new DropEntry("AmberPearl", 1f, 0),
				new DropEntry("BoneFragments", 1f, 0),
				new DropEntry("Coal", 1f, 0),
				new DropEntry("Coins", 1f, 0),
				new DropEntry("Ruby", 1f, 0),
				new DropEntry("TrophyBoar", 1f, 1),
				new DropEntry("TrophyDeer", 1f, 1),
				new DropEntry("TrophyNeck", 1f, 1),
				new DropEntry("AxeHead1", 0.5f, 1),
				new DropEntry("AxeHead2", 0.5f, 1),
				new DropEntry("StoneRock", 0.5f, 1),
				new DropEntry("TrophyBjorn", 1f, 2),
				new DropEntry("TrophyFrostTroll", 1f, 2),
				new DropEntry("TrophyGreydwarf", 1f, 2),
				new DropEntry("TrophyGreydwarfBrute", 1f, 2),
				new DropEntry("TrophyGreydwarfShaman", 1f, 2),
				new DropEntry("TrophySkeleton", 1f, 2),
				new DropEntry("TrophySkeletonPoison", 0.75f, 2),
				new DropEntry("YmirRemains", 0.75f, 2),
				new DropEntry("BronzeScrap", 0.75f, 2),
				new DropEntry("CopperOre", 0.75f, 2),
				new DropEntry("CopperScrap", 0.75f, 2),
				new DropEntry("TinOre", 0.75f, 2),
				new DropEntry("TrophyDraugr", 1f, 3),
				new DropEntry("WitheredBone", 1f, 3),
				new DropEntry("TrophyDraugrElite", 0.75f, 3),
				new DropEntry("TrophySurtling", 0.75f, 3),
				new DropEntry("Chain", 0.75f, 3),
				new DropEntry("IronOre", 0.75f, 3),
				new DropEntry("IronScrap", 0.75f, 3),
				new DropEntry("TrophyCultist_Hildir", 1f, 4),
				new DropEntry("TrophyFenring", 1f, 4),
				new DropEntry("TrophyUlv", 1f, 4),
				new DropEntry("WolfClaw", 1f, 4),
				new DropEntry("WolfFang", 1f, 4),
				new DropEntry("TrophyCultist", 0.75f, 4),
				new DropEntry("TrophyHatchling", 0.75f, 4),
				new DropEntry("TrophySGolem", 0.75f, 4),
				new DropEntry("TrophyWolf", 0.75f, 4),
				new DropEntry("Crystal", 0.75f, 4),
				new DropEntry("Obsidian", 0.75f, 4),
				new DropEntry("SharpeningStone", 0.75f, 4),
				new DropEntry("SilverOre", 0.75f, 4),
				new DropEntry("TrophyDeathsquito", 1f, 5),
				new DropEntry("TrophyGoblin", 1f, 5),
				new DropEntry("TrophyGoblinBrute", 1f, 5),
				new DropEntry("TrophyGoblinShaman", 1f, 5),
				new DropEntry("TrophyLox", 1f, 5),
				new DropEntry("TrophyBjornUndead", 0.75f, 5),
				new DropEntry("BlackMetalScrap", 0.75f, 5),
				new DropEntry("TrophyDvergr", 1f, 6),
				new DropEntry("TrophySeeker", 1f, 6),
				new DropEntry("TrophySeekerBrute", 0.75f, 6),
				new DropEntry("BlackMarble", 0.75f, 6),
				new DropEntry("DvergrKeyFragment", 0.5f, 6),
				new DropEntry("TrophyAsksvin", 1f, 7),
				new DropEntry("TrophyCharredArcher", 1f, 7),
				new DropEntry("TrophyCharredMage", 1f, 7),
				new DropEntry("TrophyCharredMelee", 1f, 7),
				new DropEntry("TrophyMorgen", 1f, 7),
				new DropEntry("TrophyVolture", 1f, 7),
				new DropEntry("TrophyFallenValkyrie", 0.75f, 7),
				new DropEntry("AsksvinCarrionNeck", 0.75f, 7),
				new DropEntry("AsksvinCarrionPelvic", 0.75f, 7),
				new DropEntry("AsksvinCarrionRibcage", 0.75f, 7),
				new DropEntry("AsksvinCarrionSkull", 0.75f, 7),
				new DropEntry("BellFragment", 0.25f, 7),
				new DropEntry("CharredBone", 0.5f, 7),
				new DropEntry("Charredskull", 1f, 7),
				new DropEntry("DyrnwynHiltFragment", 0.25f, 7),
				new DropEntry("DyrnwynBladeFragment", 0.25f, 7),
				new DropEntry("DyrnwynTipFragment", 0.25f, 7),
				new DropEntry("FlametalOreNew", 0.5f, 7),
				new DropEntry("Pot_Shard_Green", 0.75f, 7),
				new DropEntry("Pot_Shard_Red", 0.75f, 7)
			};
			Rand = new Random();
			CompiledLootPools = new Dictionary<int, BiomeLootPool>();
			InitializeLootPools();
		}

		public static void InitializeLootPools()
		{
			CompiledLootPools.Clear();
			List<DropEntry> second = MasterDropTable.Where((DropEntry e) => e.Biome == 0).ToList();
			for (int num = 1; num <= 7; num++)
			{
				int currentBiome = num;
				BiomeLootPool biomeLootPool = new BiomeLootPool();
				biomeLootPool.Items = MasterDropTable.Where((DropEntry e) => e.Biome == currentBiome).Concat(second).ToList();
				CompiledLootPools[currentBiome] = biomeLootPool;
			}
		}

		public static void TreasurizeFissureNode(Vector3 surfacePos, float currentDepth, int biomeIndex, double nodeDropChance)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			Logging instance = Logging.Instance;
			instance.Debug($"Getting drops for {biomeIndex}");
			float num = Mathf.Max(0.1f, Cfg.fissureMaxDepth.Value);
			Mathf.Clamp01(currentDepth / num);
			double num2 = Rand.NextDouble();
			instance.Debug($"rand {num2}");
			if (num2 > nodeDropChance)
			{
				instance.Debug("Missed drop chance");
				return;
			}
			string text = ChooseDropForBiome(biomeIndex);
			instance.Debug("Trying to drop " + text);
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(surfacePos.x, surfacePos.y - currentDepth + 0.25f, surfacePos.z);
			Utils.SpawnObject(text, position, Quaternion.identity);
		}

		private static string ChooseDropForBiome(int biomeIndex)
		{
			if (!CompiledLootPools.TryGetValue(biomeIndex, out var value) || value.Items.Count == 0)
			{
				value = CompiledLootPools[1];
			}
			double rarityRoll = Rand.NextDouble();
			List<DropEntry> list = value.Items.Where((DropEntry e) => (double)e.RarityChance <= rarityRoll).ToList();
			if (list.Count == 0)
			{
				list = value.Items;
			}
			int index = Rand.Next(list.Count);
			return list[index].ItemPrefab;
		}
	}
	[BepInPlugin("neobotics.valheim_mod.valquake", "Valquake", "1.0.0")]
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim_server.exe")]
	public class Valquake : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Heightmap), "Regenerate")]
		private static class Heightmap_Regenerate_Patch
		{
			[HarmonyPrefix]
			private static bool Heightmap_Regenerate_Prefix(Heightmap __instance)
			{
				if (isCracking)
				{
					Log.Trace("Skipping Regenerate until fissure complete");
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(AnimalAI), "UpdateAI")]
		private static class AnimalAI_UpdateAI_Patch
		{
			[HarmonyPrefix]
			private static bool AnimalAI_UpdateAI_Prefix(AnimalAI __instance, float dt)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				if (IsShaking() && Vector3.Distance(((Component)__instance).transform.position, quakeShaker.Epicenter) < quakeShaker.Radius)
				{
					((BaseAI)__instance).SetAlerted(true);
					((BaseAI)__instance).Flee(dt, quakeShaker.Epicenter);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(MonsterAI), "UpdateAI")]
		private static class MonsterAI_UpdateAI_Patch
		{
			[HarmonyPrefix]
			private static bool MonsterAI_UpdateAI_Prefix(MonsterAI __instance, float dt)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				if (IsShaking() && Vector3.Distance(((Component)__instance).transform.position, quakeShaker.Epicenter) < quakeShaker.Radius * 0.75f)
				{
					((BaseAI)__instance).SetAlerted(true);
					((BaseAI)__instance).Flee(dt, quakeShaker.Epicenter);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(Game), "Start")]
		private static class Game_Start_Patch
		{
			[HarmonyPostfix]
			private static void Game_Start_Patch_Postfix(Game __instance)
			{
				Log.Debug("Game_Start_Patch_Postfix");
				audioHelper = ((Component)__instance).gameObject.AddComponent<AudioHelper>();
				audioHelper.LoadAudioResources(s_resourceFolder);
				ZRoutedRpc.instance.Register<Vector3, float, float, float>("ValquakeShake", (Method<Vector3, float, float, float>)RPC_ValquakeShake);
				Log.Debug(string.Format("Registered RPC ValquakeShake {0}", StringExtensionMethods.GetStableHashCode("ValquakeShake")));
				ZRoutedRpc.instance.Register("ValquakeReset", (Action<long>)RPC_ValquakeReset);
				Log.Debug(string.Format("Registered RPC ValquakeReset {0}", StringExtensionMethods.GetStableHashCode("ValquakeReset")));
				AddValquakeConsoleCommand();
			}
		}

		[HarmonyPatch(typeof(Game), "Logout")]
		private static class Game_Logout_Patch
		{
			[HarmonyPrefix]
			private static void Game_Logout_Patch_Prefix(Game __instance)
			{
				nextQuakeTime = 0f;
			}
		}

		[HarmonyPatch(typeof(Player), "Update")]
		public static class Player_Update_Patch
		{
			private static void Prefix(Player __instance)
			{
				if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && nextQuakeTime > 0f && Time.time > nextQuakeTime)
				{
					StartQuake();
				}
			}
		}

		[HarmonyPatch(typeof(GameCamera), "UpdateCameraShake")]
		private static class GameCamera_UpdateCameraShake_Patch
		{
			[HarmonyPostfix]
			private static void GameCamera_UpdateCameraShake_Postfix(GameCamera __instance, float dt)
			{
				if (quakeShaker != null)
				{
					quakeShaker.Update(dt);
					if (!quakeShaker.isActive())
					{
						quakeShaker = null;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		public static class Player_OnSpawned_Patch
		{
			public static void Postfix(Player __instance)
			{
				Log.Debug("Player_OnSpawned_Patch_Postfix");
				SetNextQuake(Cfg.minInterval.Value, Cfg.maxInterval.Value);
			}
		}

		[HarmonyPatch(typeof(TerrainComp), "RaiseTerrain")]
		private static class TerrainComp_RaiseTerrain_Patch
		{
			[HarmonyPrefix]
			private static bool TerrainComp_RaiseTerrain_Prefix(TerrainComp __instance, Vector3 worldPos, float radius, float delta, bool square, float power)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (isCracking)
				{
					DigFissure(__instance, __instance.m_hmap, __instance.m_width, worldPos, radius, delta, square, power);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(TreeBase), "Awake")]
		private static class TreeBase_Awake_Patch
		{
			[HarmonyPostfix]
			private static void TreeBase_Awake_Postfix(TreeBase __instance)
			{
				ZDO val = __instance?.m_nview?.m_zdo;
				if (val != null && !treeManager.ContainsKey(val))
				{
					treeManager.Add(val, __instance);
				}
			}
		}

		[HarmonyPatch(typeof(ZNetScene), "Destroy")]
		private static class ZNetScene_Destroy_Patch
		{
			[HarmonyPrefix]
			private static void ZNetScene_Destroy_Prefix(ZNetScene __instance, GameObject go)
			{
				ZNetView val = default(ZNetView);
				if (go.TryGetComponent<ZNetView>(ref val) && val.m_zdo != null && treeManager.Remove(val.m_zdo))
				{
					Log.Trace("Removed tree from manager");
				}
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__35_0;

			public static Func<bool> <>9__38_0;

			public static Func<bool> <>9__43_0;

			public static Func<bool> <>9__44_0;

			public static Func<bool> <>9__45_0;

			public static Func<bool> <>9__49_0;

			public static Func<bool> <>9__57_0;

			internal void <AddValquakeConsoleCommand>b__35_0(ConsoleEventArgs args)
			{
				if (OkToQuake(Player.m_localPlayer))
				{
					StartQuake();
				}
			}

			internal bool <Co_Clatter>b__38_0()
			{
				return quakeShaker.HasPeaked();
			}

			internal bool <Co_DropAttachedPieces>b__43_0()
			{
				return quakeShaker.HasPeaked();
			}

			internal bool <Co_DamagePieces>b__44_0()
			{
				return quakeShaker.HasPeaked();
			}

			internal bool <Co_DamageTrees>b__45_0()
			{
				return quakeShaker.HasPeaked();
			}

			internal bool <Co_StaggerController>b__49_0()
			{
				return halfCracked;
			}

			internal bool <Co_ModifyTerrain>b__57_0()
			{
				return quakeShaker.HasPeaked();
			}
		}

		internal const string PLUGIN_NAME = "Valquake";

		internal const string PLUGIN_VERSION = "1.0.0";

		internal const string PLUGIN_GUID = "neobotics.valheim_mod.valquake";

		internal static string s_resourceFolder;

		internal static Valquake _modInstance;

		private static string Mod = "Valquake";

		private static string LcMod = Mod.ToLower();

		public static Logging Log;

		public static float nextQuakeTime = 0f;

		public static QuakeShaker quakeShaker = null;

		public static bool isCracking = false;

		public static bool halfCracked = false;

		internal static AudioHelper audioHelper;

		internal static GameObject fissure_vfx;

		internal stat