using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Managing.Timing;
using FishNet.Object;
using FishNet.Object.Synchronizing;
using FishNet.Serializing;
using FishNet.Transporting;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using SpongeMods.SpongeTweaks.Abilities;
using SpongeMods.SpongeTweaks.Cosmetic;
using SpongeMods.SpongeTweaks.Gameplay;
using SpongeMods.SpongeTweaks.Hud;
using SpongeMods.SpongeTweaks.Inventory;
using SpongeMods.SpongeTweaks.Multiplayer;
using SpongeMods.SpongeTweaks.Persistence;
using SpongeMods.SpongeTweaks.Progression;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("FishNet.Runtime")]
[assembly: AssemblyCompany("Merged community mod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("All-in-one How to Fish mod merging fourteen community mods.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+dbcdd0857e7f8d44cac85cf2506353d8ac92c331")]
[assembly: AssemblyProduct("SpongeTweaks")]
[assembly: AssemblyTitle("SpongeMods.SpongeTweaks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SpongeMods.SpongeTweaks
{
	[BepInPlugin("spongemods.howtofish.spongetweaks", "SpongeMods - SpongeTweaks", "1.0.0")]
	[BepInProcess("How to Fish.exe")]
	public sealed class CompendiumPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "spongemods.howtofish.spongetweaks";

		public const string PluginName = "SpongeMods - SpongeTweaks";

		public const string PluginVersion = "1.0.0";

		private Harmony _harmony;

		private FileSystemWatcher _configWatcher;

		private readonly List<IFeatureModule> _modules = new List<IFeatureModule>();

		private readonly List<IFeatureModule> _updating = new List<IFeatureModule>();

		private readonly List<IFeatureModule> _lateUpdating = new List<IFeatureModule>();

		internal static CompendiumPlugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigFile Configuration { get; private set; }

		private void Awake()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Configuration = ((BaseUnityPlugin)this).Config;
			bool saveOnConfigSet = ((BaseUnityPlugin)this).Config.SaveOnConfigSet;
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = false;
			_harmony = new Harmony("spongemods.howtofish.spongetweaks");
			SpongeRegister(new GiantCatchModule());
			SpongeRegister(new BossHealthModule());
			SpongeRegister(new BossTimerModule());
			SpongeRegister(new CreatureHealthModule());
			SpongeRegister(new AmmoCounterModule());
			SpongeRegister(new SwimmingModule());
			SpongeRegister(new ShotgunJumpModule());
			SpongeRegister(new FairSlotsModule());
			SpongeRegister(new LaserSightModule());
			SpongeRegister(new LobbySizeModule());
			SpongeRegister(new StackingModule());
			SpongeRegister(new DroppedItemModule());
			SpongeRegister(new SaveBackupModule());
			SpongeRegister(new VoidBeamModule());
			foreach (IFeatureModule module in _modules)
			{
				if (!module.Enabled)
				{
					Log.LogInfo((object)(module.DisplayName + " is disabled by config."));
					continue;
				}
				try
				{
					module.Initialise(_harmony);
					if (module.WantsUpdate)
					{
						_updating.Add(module);
					}
					if (module.WantsLateUpdate)
					{
						_lateUpdating.Add(module);
					}
				}
				catch (Exception ex)
				{
					Log.LogError((object)(module.DisplayName + " failed to start and was skipped: " + ex));
				}
			}
			Log.LogInfo((object)string.Format("{0} {1} loaded {2} live and {3} total features.", "SpongeMods - SpongeTweaks", "1.0.0", _updating.Count + _lateUpdating.Count, _modules.Count));
			if (saveOnConfigSet)
			{
				((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
				((BaseUnityPlugin)this).Config.Save();
			}
			SetupConfigWatcher();
		}

		private void SetupConfigWatcher()
		{
			try
			{
				string fileName = Path.GetFileName(((BaseUnityPlugin)this).Config.ConfigFilePath);
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Config.ConfigFilePath);
				if (!string.IsNullOrEmpty(directoryName) && Directory.Exists(directoryName))
				{
					_configWatcher = new FileSystemWatcher(directoryName, fileName);
					_configWatcher.Changed += OnConfigFileChanged;
					_configWatcher.Created += OnConfigFileChanged;
					_configWatcher.Renamed += OnConfigFileChanged;
					_configWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
					_configWatcher.IncludeSubdirectories = false;
					_configWatcher.EnableRaisingEvents = true;
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Could not watch the config file for changes: " + ex.Message));
			}
		}

		private void OnConfigFileChanged(object sender, FileSystemEventArgs eventArgs)
		{
			if (!File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath))
			{
				return;
			}
			try
			{
				((BaseUnityPlugin)this).Config.Reload();
				Log.LogInfo((object)"Config reloaded from disk.");
			}
			catch (Exception ex)
			{
				Log.LogError((object)("There was an issue reloading the config file: " + ex.Message));
				Log.LogError((object)"Please check your config entries for spelling and format.");
			}
		}

		private void SpongeRegister(IFeatureModule module)
		{
			module.BindConfiguration(((BaseUnityPlugin)this).Config);
			_modules.Add(module);
		}

		private void Update()
		{
			for (int i = 0; i < _updating.Count; i++)
			{
				try
				{
					_updating[i].Tick();
				}
				catch (Exception ex)
				{
					Log.LogError((object)(_updating[i].DisplayName + " threw during Update: " + ex));
				}
			}
		}

		private void LateUpdate()
		{
			for (int i = 0; i < _lateUpdating.Count; i++)
			{
				try
				{
					_lateUpdating[i].LateTick();
				}
				catch (Exception ex)
				{
					Log.LogError((object)(_lateUpdating[i].DisplayName + " threw during LateUpdate: " + ex));
				}
			}
		}

		private void OnDestroy()
		{
			if (_configWatcher != null)
			{
				_configWatcher.EnableRaisingEvents = false;
				_configWatcher.Changed -= OnConfigFileChanged;
				_configWatcher.Created -= OnConfigFileChanged;
				_configWatcher.Renamed -= OnConfigFileChanged;
				_configWatcher.Dispose();
				_configWatcher = null;
			}
			foreach (IFeatureModule module in _modules)
			{
				try
				{
					module.Shutdown();
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)(module.DisplayName + " threw while shutting down: " + ex));
				}
			}
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			((BaseUnityPlugin)this).Config.Save();
			Instance = null;
		}

		internal static Coroutine Run(IEnumerator routine)
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				return ((MonoBehaviour)Instance).StartCoroutine(routine);
			}
			return null;
		}
	}
	internal interface IFeatureModule
	{
		string DisplayName { get; }

		bool Enabled { get; }

		bool WantsUpdate { get; }

		bool WantsLateUpdate { get; }

		void BindConfiguration(ConfigFile config);

		void Initialise(Harmony harmony);

		void Tick();

		void LateTick();

		void Shutdown();
	}
	internal abstract class FeatureModule : IFeatureModule
	{
		protected ConfigEntry<bool> ModuleEnabled;

		public abstract string DisplayName { get; }

		public virtual bool Enabled
		{
			get
			{
				if (ModuleEnabled != null)
				{
					return ModuleEnabled.Value;
				}
				return true;
			}
		}

		public virtual bool WantsUpdate => false;

		public virtual bool WantsLateUpdate => false;

		public abstract void BindConfiguration(ConfigFile config);

		public virtual void Initialise(Harmony harmony)
		{
		}

		public virtual void Tick()
		{
		}

		public virtual void LateTick()
		{
		}

		public virtual void Shutdown()
		{
		}
	}
	internal static class UiSupport
	{
		internal static readonly Vector2 TopLeft = new Vector2(0f, 1f);

		internal static readonly Vector2 TopCentre = new Vector2(0.5f, 1f);

		public static Color ResolveColour(string configured, Color fallback)
		{
			//IL_0010: 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_0054: 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)
			if (string.IsNullOrEmpty(configured) || string.IsNullOrWhiteSpace(configured))
			{
				return fallback;
			}
			if (string.Equals(configured.Trim(), "Default", StringComparison.OrdinalIgnoreCase))
			{
				return fallback;
			}
			string text = configured.Trim();
			if (!text.StartsWith("#", StringComparison.Ordinal))
			{
				text = "#" + text;
			}
			Color result = default(Color);
			if (!ColorUtility.TryParseHtmlString(text, ref result))
			{
				return fallback;
			}
			return result;
		}

		public static string RenderHp(int value)
		{
			return value.ToString("N0", CultureInfo.InvariantCulture);
		}

		public static bool GameplayHudVisible()
		{
			if (MainMenuManager.IsInMenu || PauseManager.IsPaused)
			{
				return false;
			}
			try
			{
				return !PlayerUI.UIDisabled;
			}
			catch
			{
				return true;
			}
		}

		public static bool BossHudVisible()
		{
			if (MainMenuManager.IsInMenu || PauseManager.IsPaused)
			{
				return false;
			}
			try
			{
				return PlayerUI.BossCanvasActive;
			}
			catch
			{
				return false;
			}
		}

		public static TextMeshProUGUI FindFontDonor()
		{
			TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val in array)
			{
				if ((Object)(object)val != (Object)null && ((TMP_Text)val).text != null && ((TMP_Text)val).text.IndexOf("Version", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return val;
				}
			}
			return null;
		}

		public static RectTransform MakeRect(string name, Transform parent)
		{
			//IL_0014: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			return val.GetComponent<RectTransform>();
		}

		public static void SpongeStretchToParent(RectTransform rect)
		{
			//IL_0001: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		public static GameObject CreateOverlayCanvas(string name, int sortingOrder)
		{
			//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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Canvas),
				typeof(CanvasScaler)
			});
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.sortingOrder = sortingOrder;
			CanvasScaler component2 = val.GetComponent<CanvasScaler>();
			component2.uiScaleMode = (ScaleMode)1;
			component2.referenceResolution = new Vector2(1920f, 1080f);
			component2.screenMatchMode = (ScreenMatchMode)0;
			component2.matchWidthOrHeight = 0.5f;
			return val;
		}

		internal static GameObject InsertPanel(Transform parent, string name, Vector2 anchor, Vector2 position, Vector2 size, Color colour)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0053: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = anchor;
			val2.anchorMax = anchor;
			val2.pivot = anchor;
			val2.anchoredPosition = position;
			val2.sizeDelta = size;
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = colour;
			((Graphic)component).raycastTarget = false;
			return val;
		}

		internal static TextMeshProUGUI InsertText(Transform parent, string name, string value, Vector2 anchor, Vector2 position, Vector2 size, float fontSize, FontStyles style, Color colour, TextAlignmentOptions alignment)
		{
			//IL_004d: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = null;
			try
			{
				val = PlayerUI.CanvasTextPrefab;
			}
			catch
			{
			}
			TextMeshProUGUI val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = Object.Instantiate<TextMeshProUGUI>(val, parent);
				((Object)((Component)val2).gameObject).name = name;
			}
			else
			{
				GameObject val3 = new GameObject(name, new Type[2]
				{
					typeof(RectTransform),
					typeof(TextMeshProUGUI)
				});
				val3.transform.SetParent(parent, false);
				val2 = val3.GetComponent<TextMeshProUGUI>();
			}
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			rectTransform.anchorMin = anchor;
			rectTransform.anchorMax = anchor;
			rectTransform.pivot = anchor;
			rectTransform.anchoredPosition = position;
			rectTransform.sizeDelta = size;
			((TMP_Text)val2).text = value;
			((TMP_Text)val2).fontSize = fontSize;
			((TMP_Text)val2).fontStyle = style;
			((Graphic)val2).color = colour;
			((TMP_Text)val2).alignment = alignment;
			((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
			((Graphic)val2).raycastTarget = false;
			return val2;
		}

		internal static T Ensure<T>(GameObject target) where T : Component
		{
			return target.GetComponent<T>() ?? target.AddComponent<T>();
		}

		internal static Color WithAlpha(Color colour, float alpha)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			colour.a = alpha;
			return colour;
		}

		internal static void SetLayoutWidth(GameObject target, float width, bool flexible)
		{
			LayoutElement obj = UiSupport.Ensure<LayoutElement>(target);
			obj.minWidth = width;
			obj.preferredWidth = width;
			obj.flexibleWidth = (flexible ? 1f : 0f);
		}

		internal static void StripLocalisation(GameObject target)
		{
			MonoBehaviour[] componentsInChildren = target.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((object)val).GetType().Name.IndexOf("Localize", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}
	}
}
namespace SpongeMods.SpongeTweaks.Progression
{
	internal static class LeaderboardHud
	{
		private const int Rows = 3;

		private static readonly Color Cyan = new Color(0.18f, 0.82f, 0.88f, 1f);

		private static readonly Color Muted = new Color(0.66f, 0.75f, 0.8f, 1f);

		private static readonly Color[] MedalColours = (Color[])(object)new Color[3]
		{
			new Color(1f, 0.72f, 0.22f, 1f),
			new Color(0.73f, 0.8f, 0.86f, 1f),
			new Color(0.8f, 0.48f, 0.27f, 1f)
		};

		private static GameObject _root;

		private static GameObject _canvasRoot;

		private static readonly TextMeshProUGUI[] RowNames = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private static readonly TextMeshProUGUI[] RowSizes = (TextMeshProUGUI[])(object)new TextMeshProUGUI[3];

		private static string _lastSignature = string.Empty;

		public static void RequireVisible(IReadOnlyList<LeaderboardRow> entries)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI canvasTextPrefab;
			try
			{
				canvasTextPrefab = PlayerUI.CanvasTextPrefab;
			}
			catch
			{
				return;
			}
			if ((Object)(object)Player.LocalPlayer == (Object)null || (Object)(object)canvasTextPrefab == (Object)null)
			{
				return;
			}
			if ((Object)(object)_root == (Object)null || (Object)(object)_canvasRoot == (Object)null)
			{
				Teardown();
				Build();
			}
			string text = ComposeSignature(entries);
			if (text == _lastSignature)
			{
				return;
			}
			for (int i = 0; i < 3; i++)
			{
				bool flag = entries != null && i < entries.Count;
				string text2 = (flag ? (entries[i].DisplayName ?? "Angler") : "No catch");
				if (text2.Length > 18)
				{
					text2 = text2.Substring(0, 17) + "…";
				}
				((TMP_Text)RowNames[i]).text = text2;
				((Graphic)RowNames[i]).color = (Color)(flag ? Color.white : new Color(Muted.r, Muted.g, Muted.b, 0.65f));
				((TMP_Text)RowSizes[i]).text = (flag ? $"×{entries[i].Size:0.00}" : "—");
				((Graphic)RowSizes[i]).color = (Color)(flag ? Cyan : new Color(Muted.r, Muted.g, Muted.b, 0.65f));
			}
			_lastSignature = text;
		}

		public static void Teardown()
		{
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasRoot);
			}
			_root = null;
			_canvasRoot = null;
			for (int i = 0; i < 3; i++)
			{
				RowNames[i] = null;
				RowSizes[i] = null;
			}
			_lastSignature = string.Empty;
		}

		private static void Build()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			_canvasRoot = UiSupport.CreateOverlayCanvas("SpongeMods_RankingCanvas", 5000);
			_root = new GameObject("SpongeMods_RankingHud", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Outline)
			});
			_root.transform.SetParent(_canvasRoot.transform, false);
			RectTransform val = (RectTransform)_root.transform;
			val.anchorMin = new Vector2(1f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(1f, 1f);
			val.anchoredPosition = new Vector2(-28f, -28f);
			val.sizeDelta = new Vector2(390f, 218f);
			Image component = _root.GetComponent<Image>();
			((Graphic)component).color = new Color(0.018f, 0.048f, 0.075f, 0.94f);
			((Graphic)component).raycastTarget = false;
			Outline component2 = _root.GetComponent<Outline>();
			((Shadow)component2).effectColor = new Color(Cyan.r, Cyan.g, Cyan.b, 0.72f);
			((Shadow)component2).effectDistance = new Vector2(2f, -2f);
			UiSupport.InsertPanel(_root.transform, "TopAccent", UiSupport.TopLeft, Vector2.zero, new Vector2(390f, 5f), Cyan);
			UiSupport.InsertPanel(_root.transform, "TitleMarker", UiSupport.TopLeft, new Vector2(18f, -18f), new Vector2(4f, 39f), Cyan);
			UiSupport.InsertText(_root.transform, "Title", "BIGGEST CATCHES", UiSupport.TopLeft, new Vector2(34f, -13f), new Vector2(330f, 27f), 19f, (FontStyles)1, Color.white, (TextAlignmentOptions)513);
			UiSupport.InsertText(_root.transform, "Subtitle", "RECORDS FOR THIS SAVE", UiSupport.TopLeft, new Vector2(34f, -39f), new Vector2(330f, 20f), 11f, (FontStyles)1, Muted, (TextAlignmentOptions)513);
			for (int i = 0; i < 3; i++)
			{
				float num = -72f - (float)i * 46f;
				Color colour = ((i == 0) ? new Color(0.07f, 0.16f, 0.2f, 0.92f) : new Color(0.045f, 0.105f, 0.14f, 0.86f));
				Transform transform = UiSupport.InsertPanel(_root.transform, $"RankRow{i + 1}", UiSupport.TopLeft, new Vector2(18f, num), new Vector2(354f, 38f), colour).transform;
				UiSupport.InsertPanel(transform, "RankBadge", UiSupport.TopLeft, Vector2.zero, new Vector2(38f, 38f), new Color(MedalColours[i].r, MedalColours[i].g, MedalColours[i].b, 0.2f));
				UiSupport.InsertText(transform, "Rank", (i + 1).ToString(), UiSupport.TopLeft, new Vector2(0f, -3f), new Vector2(38f, 31f), 18f, (FontStyles)1, MedalColours[i], (TextAlignmentOptions)514);
				RowNames[i] = UiSupport.InsertText(transform, "Player", "No catch", UiSupport.TopLeft, new Vector2(50f, -3f), new Vector2(210f, 31f), 17f, (FontStyles)0, Color.white, (TextAlignmentOptions)513);
				RowSizes[i] = UiSupport.InsertText(transform, "Size", "—", UiSupport.TopLeft, new Vector2(266f, -3f), new Vector2(72f, 31f), 18f, (FontStyles)1, Cyan, (TextAlignmentOptions)516);
			}
			GiantCatchModule.Instance?.SpongeLogRankingHudCreated();
		}

		private static string ComposeSignature(IReadOnlyList<LeaderboardRow> entries)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < 3; i++)
			{
				if (entries != null && i < entries.Count)
				{
					stringBuilder.Append(entries[i].DisplayName).Append('|').Append(entries[i].Size.ToString("0.00"));
				}
				stringBuilder.Append(';');
			}
			return stringBuilder.ToString();
		}
	}
	internal static class CatchToast
	{
		private static GameObject _currentCard;

		private static RenderTexture _currentTexture;

		private static readonly FieldInfo InventoryCameraField = AccessTools.Field(typeof(PlayerInventory), "_inventoryCamera");

		private static readonly FieldInfo ItemSlotsField = AccessTools.Field(typeof(PlayerInventory), "_itemSlots");

		private static readonly FieldInfo SlotFilterField = AccessTools.Field(typeof(InventorySlot), "_filter");

		private static readonly FieldInfo SlotRendererField = AccessTools.Field(typeof(InventorySlot), "_renderer");

		private static readonly FieldInfo SlotImageField = AccessTools.Field(typeof(InventorySlot), "_itemImage");

		public static void Show(MonoBehaviour runner, Creature creature, string catcherName)
		{
			Cleanup();
			Transform fXCanvasTrans = PlayerUI.FXCanvasTrans;
			if (!((Object)(object)fXCanvasTrans == (Object)null))
			{
				_currentCard = ComposeCard(fXCanvasTrans, creature, catcherName);
				runner.StartCoroutine(TweenCard(_currentCard));
			}
		}

		private static GameObject ComposeCard(Transform parent, Creature creature, string catcherName)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0058: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0477: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SpongeMods_CatchCard", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasGroup),
				typeof(Image),
				typeof(Outline)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(0.5f, 1f);
			val2.anchorMax = new Vector2(0.5f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = new Vector2(0f, -28f);
			val2.sizeDelta = new Vector2(460f, 148f);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.018f, 0.048f, 0.075f, 0.96f);
			Outline component = val.GetComponent<Outline>();
			((Shadow)component).effectColor = new Color(0.18f, 0.82f, 0.88f, 0.72f);
			((Shadow)component).effectDistance = new Vector2(2f, -2f);
			UiSupport.InsertPanel(val.transform, "TopAccent", UiSupport.TopCentre, Vector2.zero, new Vector2(460f, 4f), new Color(0.18f, 0.82f, 0.88f, 1f));
			Transform transform = UiSupport.InsertPanel(val.transform, "PreviewPanel", UiSupport.TopCentre, new Vector2(-166f, -20f), new Vector2(112f, 108f), new Color(0.045f, 0.105f, 0.14f, 0.94f)).transform;
			UiSupport.InsertText(val.transform, "CaptureLabel", "NEW CATCH", UiSupport.TopCentre, new Vector2(42f, -14f), new Vector2(272f, 20f), 11f, (FontStyles)1, new Color(0.62f, 0.75f, 0.81f), (TextAlignmentOptions)513);
			UiSupport.InsertText(val.transform, "Size", $"×{FishSizeService.ObtainDisplaySize(creature):0.00}", UiSupport.TopCentre, new Vector2(42f, -33f), new Vector2(272f, 36f), 29f, (FontStyles)1, new Color(0.38f, 0.94f, 1f), (TextAlignmentOptions)513);
			UiSupport.InsertText(val.transform, "Catcher", "CAUGHT BY  -  " + catcherName, UiSupport.TopCentre, new Vector2(42f, -72f), new Vector2(272f, 22f), 14f, (FontStyles)1, Color.white, (TextAlignmentOptions)513);
			UiSupport.InsertPanel(val.transform, "Divider", UiSupport.TopCentre, new Vector2(42f, -99f), new Vector2(272f, 1f), new Color(0.18f, 0.82f, 0.88f, 0.35f));
			int num = (((Object)(object)creature != (Object)null) ? ((Item)creature).TotalWorth : 0);
			UiSupport.InsertText(val.transform, "SaleValue", $"SALE VALUE  -  ${num:N0}", UiSupport.TopCentre, new Vector2(42f, -108f), new Vector2(272f, 22f), 14f, (FontStyles)1, new Color(0.96f, 0.76f, 0.28f), (TextAlignmentOptions)513);
			Player player = RodTierService.ObtainCatcherForCreature(creature);
			int num2 = RodTierService.ObtainLevel(player);
			UiSupport.InsertText(val.transform, "RodBonuses", $"ROD {num2}  -  LUCK {RodTierService.ObtainLuck(player)}  -  " + $"REEL +{num2 * 5}%  -  SALE +{RodTierService.ObtainSaleBonus(player)}%", UiSupport.TopCentre, new Vector2(42f, -130f), new Vector2(272f, 16f), 9.5f, (FontStyles)1, new Color(0.62f, 0.75f, 0.81f), (TextAlignmentOptions)513);
			GameObject val3 = new GameObject("FishPreview", new Type[2]
			{
				typeof(RectTransform),
				typeof(RawImage)
			});
			val3.transform.SetParent(transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(6f, 6f);
			val4.offsetMax = new Vector2(-6f, -6f);
			_currentTexture = ComposeFishPreview(creature, out var previewUv);
			RawImage component2 = val3.GetComponent<RawImage>();
			component2.texture = (Texture)(object)_currentTexture;
			component2.uvRect = previewUv;
			val.transform.localScale = Vector3.zero;
			return val;
		}

		private static RenderTexture ComposeFishPreview(Creature creature, out Rect previewUv)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: 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_006b: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			previewUv = new Rect(0f, 0f, 1f, 1f);
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Inventory == (Object)null)
			{
				GiantCatchModule.Instance?.SpongeLogPreviewWarning("Local inventory was unavailable for the catch preview.");
				return null;
			}
			PlayerInventory inventory = localPlayer.Inventory;
			Camera val = (Camera)InventoryCameraField.GetValue(inventory);
			List<InventorySlot> list = (List<InventorySlot>)ItemSlotsField.GetValue(inventory);
			if ((Object)(object)val == (Object)null || list == null)
			{
				GiantCatchModule.Instance?.SpongeLogPreviewWarning("Inventory camera or slots were unavailable for the catch preview.");
				return null;
			}
			InventorySlot val2 = null;
			MeshFilter val3 = null;
			Renderer val4 = null;
			RawImage val5 = null;
			foreach (InventorySlot item in list)
			{
				if (!((Object)(object)item == (Object)null))
				{
					MeshFilter val6 = (MeshFilter)SlotFilterField.GetValue(item);
					Renderer val7 = (Renderer)SlotRendererField.GetValue(item);
					RawImage val8 = (RawImage)SlotImageField.GetValue(item);
					if (!((Object)(object)val6 == (Object)null) && !((Object)(object)val7 == (Object)null) && !((Object)(object)val8 == (Object)null))
					{
						val2 = item;
						val3 = val6;
						val4 = val7;
						val5 = val8;
						break;
					}
				}
			}
			RenderTexture targetTexture = val.targetTexture;
			Mesh val9 = ((creature.IsDrip && (Object)(object)((Item)creature).DripMesh != (Object)null) ? ((Item)creature).DripMesh : ((Item)creature).Mesh);
			if ((Object)(object)val2 == (Object)null || (Object)(object)targetTexture == (Object)null || (Object)(object)val9 == (Object)null)
			{
				GiantCatchModule.Instance?.SpongeLogPreviewWarning("Inventory preview resources were incomplete for " + ((Item)creature).GetName() + ".");
				return null;
			}
			previewUv = val5.uvRect;
			RenderTexture val10 = new RenderTexture(((Texture)targetTexture).width, ((Texture)targetTexture).height, targetTexture.depth, targetTexture.format)
			{
				name = "SpongeMods_CatchPreview",
				antiAliasing = Mathf.Max(1, targetTexture.antiAliasing)
			};
			val10.Create();
			Mesh sharedMesh = val3.sharedMesh;
			Vector3 localPosition = ((Component)val3).transform.localPosition;
			Quaternion localRotation = ((Component)val3).transform.localRotation;
			Vector3 localScale = ((Component)val3).transform.localScale;
			bool enabled = val4.enabled;
			bool fog = RenderSettings.fog;
			try
			{
				val3.sharedMesh = val9;
				((Component)val3).transform.localPosition = ((Item)creature).InventoryMeshPos;
				((Component)val3).transform.localEulerAngles = ((Item)creature).InventoryMeshRot;
				((Component)val3).transform.localScale = Vector3.one * ((Item)creature).InventoryMeshScale;
				val4.enabled = true;
				RenderSettings.fog = false;
				val.targetTexture = val10;
				val.Render();
				return val10;
			}
			finally
			{
				val.targetTexture = targetTexture;
				RenderSettings.fog = fog;
				val4.enabled = enabled;
				val3.sharedMesh = sharedMesh;
				((Component)val3).transform.localPosition = localPosition;
				((Component)val3).transform.localRotation = localRotation;
				((Component)val3).transform.localScale = localScale;
			}
		}

		private static IEnumerator TweenCard(GameObject card)
		{
			CanvasGroup group = card.GetComponent<CanvasGroup>();
			float elapsed = 0f;
			while (elapsed < 0.28f && (Object)(object)card != (Object)null)
			{
				elapsed += Time.unscaledDeltaTime;
				float num = Mathf.Clamp01(elapsed / 0.28f);
				card.transform.localScale = Vector3.one * (1f - Mathf.Pow(1f - num, 3f));
				yield return null;
			}
			yield return (object)new WaitForSecondsRealtime(4.5f);
			elapsed = 0f;
			while (elapsed < 0.6f && (Object)(object)card != (Object)null)
			{
				elapsed += Time.unscaledDeltaTime;
				group.alpha = 1f - Mathf.Clamp01(elapsed / 0.6f);
				yield return null;
			}
			if ((Object)(object)card == (Object)(object)_currentCard)
			{
				Cleanup();
			}
		}

		private static void Cleanup()
		{
			if ((Object)(object)_currentCard != (Object)null)
			{
				Object.Destroy((Object)(object)_currentCard);
			}
			if ((Object)(object)_currentTexture != (Object)null)
			{
				_currentTexture.Release();
				Object.Destroy((Object)(object)_currentTexture);
			}
			_currentCard = null;
			_currentTexture = null;
		}
	}
	internal static class SizeRewardToast
	{
		private static GameObject _canvasRoot;

		public static void Show(MonoBehaviour runner, float size)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			Cleanup();
			if (!((Object)(object)runner == (Object)null) && !((Object)(object)PlayerUI.CanvasTextPrefab == (Object)null))
			{
				_canvasRoot = UiSupport.CreateOverlayCanvas("SpongeMods_SizeRewardCanvas", 5001);
				TextMeshProUGUI obj = Object.Instantiate<TextMeshProUGUI>(PlayerUI.CanvasTextPrefab, _canvasRoot.transform);
				((Object)((Component)obj).gameObject).name = "SizeRewardRow";
				RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.anchoredPosition = new Vector2(0f, -181f);
				rectTransform.sizeDelta = new Vector2(620f, 42f);
				((TMP_Text)obj).text = $"<color=#ff6a00>{size:0.00}x</color>  Size";
				((TMP_Text)obj).fontSize = 27f;
				((TMP_Text)obj).fontStyle = (FontStyles)0;
				((Graphic)obj).color = Color.white;
				((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
				((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)obj).richText = true;
				((Graphic)obj).raycastTarget = false;
				CanvasGroup val = _canvasRoot.AddComponent<CanvasGroup>();
				runner.StartCoroutine(ConcealAfterDelay(val));
			}
		}

		private static IEnumerator ConcealAfterDelay(CanvasGroup group)
		{
			yield return (object)new WaitForSecondsRealtime(3.7f);
			float elapsed = 0f;
			while (elapsed < 0.5f && (Object)(object)group != (Object)null)
			{
				elapsed += Time.unscaledDeltaTime;
				group.alpha = 1f - Mathf.Clamp01(elapsed / 0.5f);
				yield return null;
			}
			Cleanup();
		}

		private static void Cleanup()
		{
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasRoot);
			}
			_canvasRoot = null;
		}
	}
	internal sealed class FishHealthReadout : MonoBehaviour
	{
		private Creature _creature;

		private GameObject _root;

		private Image _fill;

		private RectTransform _fillRect;

		private TextMeshProUGUI _numbers;

		private Renderer[] _renderers;

		private float _nextRendererRefresh;

		private Bounds _bounds;

		private float _displayedRatio = 1f;

		private const float NearRange = 12f;

		private const float FarRange = 28f;

		private const float NearRangeSquared = 144f;

		private const float FarRangeSquared = 784f;

		private const float RendererRefreshInterval = 1.5f;

		private void Awake()
		{
			_creature = ((Component)this).GetComponent<Creature>();
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
		}

		private void LateUpdate()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_creature == (Object)null || ((Object)(object)_root == (Object)null && !AttemptCreate()))
			{
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Camera val = (((Object)(object)localPlayer != (Object)null) ? localPlayer.CurCam : Camera.main);
			if ((Object)(object)val == (Object)null)
			{
				_root.SetActive(false);
				return;
			}
			int num = Mathf.Max(1, _creature.MaxHp);
			int num2 = Mathf.Clamp(_creature.Hp, 0, num);
			if (num2 <= 0)
			{
				_root.SetActive(false);
				return;
			}
			Vector3 val2 = ((Component)val).transform.position - ((Component)this).transform.position;
			float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
			bool flag = num2 < num || (Object)(object)((Item)_creature).AttachedRod != (Object)null;
			if (sqrMagnitude > (flag ? 784f : 144f))
			{
				_root.SetActive(false);
				return;
			}
			if (!AnyRendererVisible())
			{
				_root.SetActive(false);
				return;
			}
			_root.SetActive(true);
			if (Time.unscaledTime >= _nextRendererRefresh)
			{
				_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
				_nextRendererRefresh = Time.unscaledTime + 1.5f;
			}
			RedrawBounds();
			float num3 = Mathf.Clamp(((Bounds)(ref _bounds)).extents.y + 0.28f, 0.45f, 4.5f);
			_root.transform.position = new Vector3(((Bounds)(ref _bounds)).center.x, ((Bounds)(ref _bounds)).max.y + num3 * 0.18f, ((Bounds)(ref _bounds)).center.z);
			_root.transform.rotation = ((Component)val).transform.rotation;
			float num4 = Mathf.Clamp(Mathf.Sqrt(sqrMagnitude) * 0.00032f, 0.0024f, 0.0075f);
			_root.transform.localScale = Vector3.one * num4;
			float num5 = (float)num2 / (float)num;
			_displayedRatio = Mathf.MoveTowards(_displayedRatio, num5, Time.unscaledDeltaTime * 2.5f);
			_fillRect.anchorMax = new Vector2(_displayedRatio, 1f);
			_fillRect.offsetMax = new Vector2((_displayedRatio > 0.025f) ? (-4f) : 0f, -4f);
			((Behaviour)_fill).enabled = _displayedRatio > 0.001f;
			((Graphic)_fill).color = ((num5 > 0.55f) ? new Color(0.22f, 0.86f, 0.42f, 0.96f) : ((num5 > 0.25f) ? new Color(1f, 0.7f, 0.16f, 0.96f) : new Color(0.95f, 0.2f, 0.18f, 0.96f)));
			((TMP_Text)_numbers).text = num2 + " / " + num;
		}

		private bool AttemptCreate()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI canvasTextPrefab;
			try
			{
				canvasTextPrefab = PlayerUI.CanvasTextPrefab;
			}
			catch
			{
				return false;
			}
			if ((Object)(object)canvasTextPrefab == (Object)null)
			{
				return false;
			}
			_root = new GameObject("SpongeMods_CreatureHealthBar", new Type[2]
			{
				typeof(RectTransform),
				typeof(Canvas)
			});
			Canvas component = _root.GetComponent<Canvas>();
			component.renderMode = (RenderMode)2;
			component.sortingOrder = 45;
			((RectTransform)_root.transform).sizeDelta = new Vector2(230f, 42f);
			AssignRect(MakeImage(_root.transform, "Shadow", new Color(0f, 0f, 0f, 0.72f)).GetComponent<RectTransform>(), Vector2.zero, Vector2.one, new Vector2(-5f, -5f), new Vector2(5f, 5f));
			GameObject obj2 = MakeImage(_root.transform, "Track", new Color(0.035f, 0.055f, 0.065f, 0.96f));
			AssignRect(obj2.GetComponent<RectTransform>(), Vector2.zero, Vector2.one, new Vector2(2f, 2f), new Vector2(-2f, -2f));
			GameObject val = MakeImage(obj2.transform, "Fill", Color.green);
			_fillRect = val.GetComponent<RectTransform>();
			AssignRect(_fillRect, Vector2.zero, Vector2.one, new Vector2(4f, 4f), new Vector2(-4f, -4f));
			_fill = val.GetComponent<Image>();
			_fill.type = (Type)0;
			_numbers = Object.Instantiate<TextMeshProUGUI>(canvasTextPrefab, _root.transform);
			((Object)((Component)_numbers).gameObject).name = "HealthNumbers";
			AssignRect(((TMP_Text)_numbers).rectTransform, Vector2.zero, Vector2.one, Vector2.zero, Vector2.zero);
			((TMP_Text)_numbers).fontSize = 24f;
			((TMP_Text)_numbers).fontStyle = (FontStyles)1;
			((TMP_Text)_numbers).alignment = (TextAlignmentOptions)514;
			((Graphic)_numbers).color = Color.white;
			((TMP_Text)_numbers).textWrappingMode = (TextWrappingModes)0;
			((Graphic)_numbers).raycastTarget = false;
			return true;
		}

		private bool AnyRendererVisible()
		{
			if (_renderers == null || _renderers.Length == 0)
			{
				return true;
			}
			for (int i = 0; i < _renderers.Length; i++)
			{
				if ((Object)(object)_renderers[i] != (Object)null && _renderers[i].isVisible)
				{
					return true;
				}
			}
			return false;
		}

		private void RedrawBounds()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			for (int i = 0; i < _renderers.Length; i++)
			{
				Renderer val = _renderers[i];
				if (!((Object)(object)val == (Object)null) && val.enabled)
				{
					if (flag)
					{
						((Bounds)(ref _bounds)).Encapsulate(val.bounds);
						continue;
					}
					_bounds = val.bounds;
					flag = true;
				}
			}
			if (!flag)
			{
				_bounds = new Bounds(((Component)this).transform.position, Vector3.one);
			}
		}

		private static GameObject MakeImage(Transform parent, string name, Color colour)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = colour;
			((Graphic)component).raycastTarget = false;
			return val;
		}

		private static void AssignRect(RectTransform rect, Vector2 anchorMin, Vector2 anchorMax, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: 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)
			//IL_000f: 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)
			rect.anchorMin = anchorMin;
			rect.anchorMax = anchorMax;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
		}
	}
	internal static class FishHealthReadoutSystem
	{
		private static float _nextScan;

		public static void Tick()
		{
			if (!(Time.unscaledTime < _nextScan) && !((Object)(object)Player.LocalPlayer == (Object)null))
			{
				_nextScan = Time.unscaledTime + 1.5f;
				Creature[] array = Object.FindObjectsByType<Creature>();
				for (int i = 0; i < array.Length; i++)
				{
					Attach(array[i]);
				}
			}
		}

		public static void Attach(Creature creature)
		{
			if (!((Object)(object)creature == (Object)null) && !FishSizeService.IsFlyingCreature(creature) && !((Object)(object)((Component)creature).GetComponent<FishHealthReadout>() != (Object)null))
			{
				((Component)creature).gameObject.AddComponent<FishHealthReadout>();
			}
		}

		public static void Shutdown()
		{
			FishHealthReadout[] array = Object.FindObjectsByType<FishHealthReadout>();
			foreach (FishHealthReadout fishHealthReadout in array)
			{
				if ((Object)(object)fishHealthReadout != (Object)null)
				{
					Object.Destroy((Object)(object)fishHealthReadout);
				}
			}
		}
	}
	internal static class UnboundedWeaponTiers
	{
		public const int MaximumIndex = 255;

		private const int TableLength = 256;

		private static readonly FieldInfo SharpnessTable = AccessTools.Field(typeof(Melee), "_sharpnessUpgrades");

		private static readonly FieldInfo BulletTable = AccessTools.Field(typeof(Attachments), "_bulletUpgrades");

		private static readonly FieldInfo SharpnessDamage = AccessTools.Field(typeof(SharpnessUpgrade), "_damage");

		private static readonly FieldInfo SharpnessCost = AccessTools.Field(typeof(SharpnessUpgrade), "_cost");

		private static readonly FieldInfo BulletDamage = AccessTools.Field(typeof(BulletUpgrade), "_damage");

		private static readonly FieldInfo BulletCost = AccessTools.Field(typeof(BulletUpgrade), "_cost");

		private static readonly FieldInfo MaximumSharpness = AccessTools.Field(typeof(SharpnessPurchasable), "_maxSharpnessUpgrade");

		private static readonly FieldInfo MaximumBullets = AccessTools.Field(typeof(BulletPurchasable), "_maxBulletUpgrade");

		private static bool _logged;

		public static void Ensure(Melee melee)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			if ((Object)(object)melee == (Object)null || SharpnessTable == null)
			{
				return;
			}
			SharpnessUpgrade[] array = (SharpnessUpgrade[])SharpnessTable.GetValue(melee);
			if (array != null && array.Length != 0 && array.Length < 256)
			{
				int damage = array[^1].Damage;
				int cost = array[^1].Cost;
				int num = ((array.Length > 1) ? Math.Max(1, damage - array[^2].Damage) : Math.Max(1, damage / 4));
				int step = ((array.Length > 1) ? Math.Max(10, cost - array[^2].Cost) : Math.Max(10, cost / 2));
				SharpnessUpgrade[] array2 = (SharpnessUpgrade[])(object)new SharpnessUpgrade[256];
				Array.Copy(array, array2, array.Length);
				for (int i = array.Length; i < array2.Length; i++)
				{
					long num2 = i - ((long)array.Length - 1L);
					SharpnessUpgrade val = new SharpnessUpgrade();
					SharpnessDamage.SetValue(val, SpongeSaturate(damage + num * num2));
					SharpnessCost.SetValue(val, SpongeProgressiveCost(cost, step, num2));
					array2[i] = val;
				}
				SharpnessTable.SetValue(melee, array2);
				SpongeLogOnce();
			}
		}

		public static void Ensure(Attachments attachments)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			if ((Object)(object)attachments == (Object)null || BulletTable == null)
			{
				return;
			}
			BulletUpgrade[] array = (BulletUpgrade[])BulletTable.GetValue(attachments);
			if (array != null && array.Length != 0 && array.Length < 256)
			{
				int damage = array[^1].Damage;
				int cost = array[^1].Cost;
				int num = ((array.Length > 1) ? Math.Max(1, damage - array[^2].Damage) : Math.Max(1, damage / 4));
				int step = ((array.Length > 1) ? Math.Max(10, cost - array[^2].Cost) : Math.Max(10, cost / 2));
				BulletUpgrade[] array2 = (BulletUpgrade[])(object)new BulletUpgrade[256];
				Array.Copy(array, array2, array.Length);
				for (int i = array.Length; i < array2.Length; i++)
				{
					long num2 = i - ((long)array.Length - 1L);
					BulletUpgrade val = new BulletUpgrade();
					BulletDamage.SetValue(val, SpongeSaturate(damage + num * num2));
					BulletCost.SetValue(val, SpongeProgressiveCost(cost, step, num2));
					array2[i] = val;
				}
				BulletTable.SetValue(attachments, array2);
				SpongeLogOnce();
			}
		}

		public static void Unlock(SharpnessPurchasable purchasable)
		{
			if ((Object)(object)purchasable != (Object)null && MaximumSharpness != null)
			{
				MaximumSharpness.SetValue(purchasable, byte.MaxValue);
			}
		}

		public static void Unlock(BulletPurchasable purchasable)
		{
			if ((Object)(object)purchasable != (Object)null && MaximumBullets != null)
			{
				MaximumBullets.SetValue(purchasable, byte.MaxValue);
			}
		}

		private static int SpongeProgressiveCost(int lastCost, int step, long extra)
		{
			return SpongeSaturate(lastCost + step * extra * (extra + 1) / 2);
		}

		private static int SpongeSaturate(long value)
		{
			return (int)Math.Max(1L, Math.Min(2000000000L, value));
		}

		private static void SpongeLogOnce()
		{
			if (!_logged)
			{
				_logged = true;
				GiantCatchModule.Instance?.SpongeLogInfiniteWeaponUpgrades();
			}
		}
	}
	[HarmonyPatch]
	internal static class MeleeTierTablePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(Melee), "Awake", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Melee), "GetCurSharpness", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Melee), "GetNextSharpnessUpgrade", (Type[])null, (Type[])null);
		}

		private static void Prefix(Melee __instance)
		{
			UnboundedWeaponTiers.Ensure(__instance);
		}
	}
	[HarmonyPatch]
	internal static class BulletTierTablePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(Attachments), "Awake", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Attachments), "GetCurBulletUpgrade", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Attachments), "GetNextBulletUpgrade", (Type[])null, (Type[])null);
		}

		private static void Prefix(Attachments __instance)
		{
			UnboundedWeaponTiers.Ensure(__instance);
		}
	}
	[HarmonyPatch]
	internal static class SharpnessBenchCapPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(SharpnessPurchasable), "Hover", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(SharpnessPurchasable), "OnStartHover", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(SharpnessPurchasable), "Interact", (Type[])null, (Type[])null);
		}

		private static void Prefix(SharpnessPurchasable __instance)
		{
			UnboundedWeaponTiers.Unlock(__instance);
		}
	}
	[HarmonyPatch]
	internal static class BulletBenchCapPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(BulletPurchasable), "Hover", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(BulletPurchasable), "OnStartHover", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(BulletPurchasable), "Interact", (Type[])null, (Type[])null);
		}

		private static void Prefix(BulletPurchasable __instance)
		{
			UnboundedWeaponTiers.Unlock(__instance);
		}
	}
	internal static class FishSizeService
	{
		private static readonly FieldInfo WeightField = AccessTools.Field(typeof(Item), "_syncedRandomWeight");

		private static readonly FieldInfo HpField = AccessTools.Field(typeof(Creature), "_hp");

		private static readonly FieldInfo SkipWeightField = AccessTools.Field(typeof(Creature), "_skipRandomizedWeight");

		public static float ObtainSize(Creature creature)
		{
			if (!HasScalableCatch(creature))
			{
				return 1f;
			}
			return Mathf.Clamp(((SyncVar<float>)WeightField.GetValue(creature)).Value, 1f, 25f);
		}

		public static bool IsFlyingCreature(Creature creature)
		{
			if (!(creature is Bird))
			{
				return creature is Albatross;
			}
			return true;
		}

		public static bool HasScalableCatch(Creature creature)
		{
			if ((Object)(object)creature == (Object)null || IsFlyingCreature(creature))
			{
				return false;
			}
			if (IsBoss(creature) || (Object)(object)((Item)creature).AttachedRod != (Object)null)
			{
				return true;
			}
			FishScaleTracker component = ((Component)creature).GetComponent<FishScaleTracker>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (!component.WasHooked)
			{
				return component.LoadedFromSave;
			}
			return true;
		}

		public static bool IsBoss(Creature creature)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((Object)(object)creature != (Object)null)
			{
				return (int)creature.BossType > 0;
			}
			return false;
		}

		public static float ObtainDisplaySize(Creature creature)
		{
			if ((Object)(object)creature == (Object)null)
			{
				return 1f;
			}
			return Mathf.Clamp(ObtainRawWeight(creature), 1f, 25f);
		}

		public static float ObtainRawWeight(Creature creature)
		{
			return ((SyncVar<float>)WeightField.GetValue(creature)).Value;
		}

		public static void AssignSize(Creature creature, float size)
		{
			size = Mathf.Clamp(size, 1f, 25f);
			((SyncVar<float>)WeightField.GetValue(creature)).Value = size;
		}

		public static bool SpongeSkipsRandomWeight(Creature creature)
		{
			return (bool)SkipWeightField.GetValue(creature);
		}

		public static void SpongeRefillHealth(Creature creature)
		{
			SyncVar<int> val = (SyncVar<int>)HpField.GetValue(creature);
			if (val.Value > 0)
			{
				val.Value = creature.MaxHp;
			}
		}

		public static void SpongeMarkLoadedFromSave(Creature creature)
		{
			ObtainOrCreateState(creature).LoadedFromSave = true;
		}

		public static void SpongeRecordCatcher(Creature creature, FishingRod rod)
		{
			if (!((Object)(object)creature == (Object)null) && !((Object)(object)rod == (Object)null))
			{
				FishScaleTracker fishScaleTracker = ObtainOrCreateState(creature);
				fishScaleTracker.WasHooked = true;
				fishScaleTracker.CatcherRod = rod;
				Player val = (((Object)(object)((Item)rod).SyncedHolder != (Object)null) ? ((Item)rod).SyncedHolder : ((Item)rod).Holder);
				if ((Object)(object)val != (Object)null)
				{
					fishScaleTracker.Catcher = val;
					fishScaleTracker.AnglerName = val.SteamName;
				}
				if (InstanceFinder.IsServerStarted && !fishScaleTracker.LuckRollApplied && !fishScaleTracker.LoadedFromSave && !IsBoss(creature))
				{
					int luck = RodTierService.ObtainLuck(val);
					AssignSize(creature, SizeCurve.Roll(((NetworkBehaviour)creature).ObjectId, luck));
					fishScaleTracker.LuckRollApplied = true;
					SpongeRefillHealth(creature);
					SetVisualScale(creature);
					GiantCatchModule.Instance?.SpongeLogLuckRoll(creature, val, luck);
				}
			}
		}

		public static bool AttemptClaimBossInitialRefill(Creature creature)
		{
			if ((Object)(object)creature == (Object)null || !IsBoss(creature))
			{
				return false;
			}
			FishScaleTracker fishScaleTracker = ObtainOrCreateState(creature);
			if (fishScaleTracker.BossHealthInitialized)
			{
				return false;
			}
			fishScaleTracker.BossHealthInitialized = true;
			return true;
		}

		public static bool IsDead(Creature creature)
		{
			if ((Object)(object)creature == (Object)null)
			{
				return false;
			}
			return ((SyncVar<int>)HpField.GetValue(creature)).Value <= 0;
		}

		public static bool AttemptClaimLocalNotification(Creature creature, out string catcherName)
		{
			catcherName = string.Empty;
			if ((Object)(object)creature == (Object)null)
			{
				return false;
			}
			FishScaleTracker component = ((Component)creature).GetComponent<FishScaleTracker>();
			if ((Object)(object)component == (Object)null || component.NotificationShown || (Object)(object)component.CatcherRod == (Object)null)
			{
				return false;
			}
			Player val = component.Catcher;
			if ((Object)(object)val == (Object)null)
			{
				val = (((Object)(object)((Item)component.CatcherRod).SyncedHolder != (Object)null) ? ((Item)component.CatcherRod).SyncedHolder : ((Item)component.CatcherRod).Holder);
			}
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if ((!((Object)(object)localPlayer != (Object)null) || !((Object)(object)val == (Object)(object)localPlayer)) && !((NetworkBehaviour)val).Owner.IsLocalClient)
			{
				return false;
			}
			component.NotificationShown = true;
			catcherName = ((!string.IsNullOrWhiteSpace(component.AnglerName)) ? component.AnglerName : (((Object)(object)val != (Object)null) ? val.SteamName : localPlayer.SteamName));
			return true;
		}

		public static bool SpongeWasLoadedFromSave(Creature creature)
		{
			FishScaleTracker component = ((Component)creature).GetComponent<FishScaleTracker>();
			if ((Object)(object)component != (Object)null)
			{
				return component.LoadedFromSave;
			}
			return false;
		}

		public static void SetVisualScale(Creature creature)
		{
			//IL_0017: 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)
			if (HasScalableCatch(creature))
			{
				FishScaleTracker fishScaleTracker = ObtainOrCreateState(creature);
				((Component)creature).transform.localScale = fishScaleTracker.OriginalScale * ObtainSize(creature);
			}
		}

		private static FishScaleTracker ObtainOrCreateState(Creature creature)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			FishScaleTracker component = ((Component)creature).GetComponent<FishScaleTracker>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			component = ((Component)creature).gameObject.AddComponent<FishScaleTracker>();
			component.OriginalScale = ((Component)creature).transform.localScale;
			return component;
		}

		public static int SpongeScaledInt(int original, Creature creature)
		{
			double value = (double)original * (double)ObtainSize(creature);
			return (int)Math.Min(2147483647.0, Math.Max(1.0, Math.Round(value, MidpointRounding.AwayFromZero)));
		}
	}
	internal sealed class GiantCatchModule : FeatureModule
	{
		private ConfigEntry<bool> _healthBars;

		internal static GiantCatchModule Instance { get; private set; }

		public override string DisplayName => "Giant Catches";

		public override bool WantsUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			ModuleEnabled = config.Bind<bool>("Giant Catches", "Enabled", true, "Random fish sizes, catch records, rod upgrades and creature health bars.");
			_healthBars = config.Bind<bool>("Giant Catches", "CreatureHealthBars", true, "Show a floating health bar above every creature.");
			LeaderboardService.Initialize(config);
			RodTierService.Initialize(config);
		}

		public override void Initialise(Harmony harmony)
		{
			Instance = this;
			harmony.PatchAll(typeof(FishServerStartPatch));
			harmony.PatchAll(typeof(FishClientStartPatch));
			harmony.PatchAll(typeof(FishMaxHpPatch));
			harmony.PatchAll(typeof(FishRestorePatch));
			harmony.PatchAll(typeof(CatchLeaderboardPatch));
			harmony.PatchAll(typeof(CatchOwnerPatch));
			harmony.PatchAll(typeof(CatchDeathAnnouncePatch));
			harmony.PatchAll(typeof(AggressiveFishStrengthPatch));
			harmony.PatchAll(typeof(PufferStrengthPatch));
			harmony.PatchAll(typeof(BowheadStrengthPatch));
			harmony.PatchAll(typeof(RodSaleValuePatch));
			harmony.PatchAll(typeof(RodSaleScopePatch));
			harmony.PatchAll(typeof(MeleeTierTablePatch));
			harmony.PatchAll(typeof(BulletTierTablePatch));
			harmony.PatchAll(typeof(SharpnessBenchCapPatch));
			harmony.PatchAll(typeof(BulletBenchCapPatch));
			CompendiumPlugin.Log.LogInfo((object)"Giant Catches active.");
		}

		public override void Tick()
		{
			LeaderboardService.Tick();
			RodTierService.Tick();
			if (_healthBars.Value)
			{
				FishHealthReadoutSystem.Tick();
			}
		}

		public override void Shutdown()
		{
			LeaderboardService.Shutdown();
			RodTierService.Shutdown();
			FishHealthReadoutSystem.Shutdown();
			Instance = null;
		}

		internal void DisplayCatchCard(Creature creature, string catcherName)
		{
			CatchToast.Show((MonoBehaviour)(object)CompendiumPlugin.Instance, creature, catcherName);
			SizeRewardToast.Show((MonoBehaviour)(object)CompendiumPlugin.Instance, FishSizeService.ObtainDisplaySize(creature));
		}

		internal void DisplayGlobalRankedCatch(Creature creature, string catcherName, float size, bool isLocalCatcher)
		{
			CatchToast.Show((MonoBehaviour)(object)CompendiumPlugin.Instance, creature, catcherName);
			if (isLocalCatcher)
			{
				SizeRewardToast.Show((MonoBehaviour)(object)CompendiumPlugin.Instance, size);
			}
		}

		internal void SpongeScheduleBossHealthRefill(Creature creature)
		{
			CompendiumPlugin.Run(SpongeRefillBossHealthAfterInitialization(creature));
		}

		private static IEnumerator SpongeRefillBossHealthAfterInitialization(Creature creature)
		{
			yield return null;
			yield return null;
			if ((Object)(object)creature != (Object)null && FishSizeService.AttemptClaimBossInitialRefill(creature))
			{
				FishSizeService.SpongeRefillHealth(creature);
			}
		}

		internal void SpongeLogPreviewWarning(string message)
		{
			CompendiumPlugin.Log.LogWarning((object)message);
		}

		internal void SpongeLogCatchSize(Creature creature)
		{
			CompendiumPlugin.Log.LogInfo((object)$"Scaled catch {((Item)creature).GetName()} to x{FishSizeService.ObtainDisplaySize(creature):0.00}.");
		}

		internal void SpongeLogRankingError(string operation, Exception error)
		{
			CompendiumPlugin.Log.LogError((object)$"Ranking {operation} failed safely: {error}");
		}

		internal void SpongeLogRankingHudCreated()
		{
			CompendiumPlugin.Log.LogInfo((object)"Ranking HUD created on its independent overlay canvas.");
		}

		internal void SpongeLogLuckRoll(Creature creature, Player catcher, int luck)
		{
			CompendiumPlugin.Log.LogInfo((object)(string.Format("Applied catcher luck {0} for {1}: ", luck, ((catcher != null) ? catcher.SteamName : null) ?? "Angler") + $"{((Item)creature).GetName()} rolled x{FishSizeService.ObtainDisplaySize(creature):0.00}."));
		}

		internal void SpongeLogUpgradePurchase(Player player, int cost, int newLevel)
		{
			CompendiumPlugin.Log.LogInfo((object)(string.Format("Server charged ${0} to {1} ", cost, ((player != null) ? player.SteamName : null) ?? "Angler") + $"and applied rod upgrade level {newLevel}."));
		}

		internal void SpongeLogPersonalWalletCompatibility()
		{
			CompendiumPlugin.Log.LogInfo((object)"NoSharedMoney detected: rod upgrades will use each player's personal wallet.");
		}

		internal void SpongeLogUpgradeError(string operation, Exception error)
		{
			CompendiumPlugin.Log.LogError((object)$"Rod upgrade failed while {operation}: {error}");
		}

		internal void SpongeLogInfiniteWeaponUpgrades()
		{
			CompendiumPlugin.Log.LogInfo((object)"Expanded melee and bullet upgrade tables to 255 persistent levels.");
		}

		internal void SpongeLogUpgradeRejection(string reason)
		{
			CompendiumPlugin.Log.LogWarning((object)("Rod upgrade rejected: " + reason));
		}
	}
	[HarmonyPatch(typeof(Creature), "OnStartServer")]
	internal static class FishServerStartPatch
	{
		private static void Prefix(Creature __instance, out byte __state)
		{
			__state = 0;
			if (!FishSizeService.HasScalableCatch(__instance) || (FishSizeService.SpongeSkipsRandomWeight(__instance) && !FishSizeService.IsBoss(__instance)))
			{
				return;
			}
			if (FishSizeService.IsBoss(__instance) && !FishSizeService.SpongeWasLoadedFromSave(__instance))
			{
				__state = 3;
			}
			else if (!(Math.Abs(FishSizeService.ObtainRawWeight(__instance) - 1f) >= 0.0001f))
			{
				if (FishSizeService.SpongeWasLoadedFromSave(__instance))
				{
					FishSizeService.AssignSize(__instance, 1.0001f);
					__state = 2;
				}
				else
				{
					__state = 1;
				}
			}
		}

		private static void Postfix(Creature __instance, byte __state)
		{
			if (!FishSizeService.HasScalableCatch(__instance) || (FishSizeService.SpongeSkipsRandomWeight(__instance) && !FishSizeService.IsBoss(__instance)))
			{
				return;
			}
			switch (__state)
			{
			case 1:
			case 3:
				FishSizeService.AssignSize(__instance, SizeCurve.Roll(((NetworkBehaviour)__instance).ObjectId, RodTierService.ObtainLuckForCreature(__instance)));
				break;
			case 2:
				FishSizeService.AssignSize(__instance, 1f);
				break;
			default:
				if (FishSizeService.ObtainRawWeight(__instance) < 1f)
				{
					FishSizeService.AssignSize(__instance, 1f);
				}
				break;
			}
			FishSizeService.SpongeRefillHealth(__instance);
			if (FishSizeService.IsBoss(__instance))
			{
				GiantCatchModule.Instance?.SpongeScheduleBossHealthRefill(__instance);
			}
			FishSizeService.SetVisualScale(__instance);
			GiantCatchModule.Instance?.SpongeLogCatchSize(__instance);
			LeaderboardService.SpongeRecordCatch(__instance);
		}
	}
	[HarmonyPatch(typeof(Creature), "OnStartClient")]
	internal static class FishClientStartPatch
	{
		private static void Postfix(Creature __instance)
		{
			FishSizeService.SetVisualScale(__instance);
			FishHealthReadoutSystem.Attach(__instance);
		}
	}
	[HarmonyPatch(typeof(Creature), "get_MaxHp")]
	internal static class FishMaxHpPatch
	{
		private static void Postfix(Creature __instance, ref int __result)
		{
			if (FishSizeService.HasScalableCatch(__instance))
			{
				__result = FishSizeService.SpongeScaledInt(__result, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(Creature), "LoadFromSave")]
	internal static class FishRestorePatch
	{
		private static void Prefix(Creature __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && !FishSizeService.IsFlyingCreature(__instance))
			{
				FishSizeService.SpongeMarkLoadedFromSave(__instance);
			}
		}

		private static void Postfix(Creature __instance)
		{
			if (FishSizeService.HasScalableCatch(__instance) && FishSizeService.ObtainRawWeight(__instance) < 1f)
			{
				FishSizeService.AssignSize(__instance, 1f);
			}
			FishSizeService.SetVisualScale(__instance);
		}
	}
	[HarmonyPatch(typeof(Creature), "ServerChangeHp")]
	internal static class CatchLeaderboardPatch
	{
		private static void Postfix(Creature __instance)
		{
			try
			{
				if (FishSizeService.IsDead(__instance))
				{
					LeaderboardService.SpongeRecordCatch(__instance);
					LeaderboardService.BroadcastRankedDeath(__instance);
				}
			}
			catch (Exception error)
			{
				GiantCatchModule.Instance?.SpongeLogRankingError("death hook", error);
			}
		}
	}
	[HarmonyPatch(typeof(Item), "OnAttachedRodChange")]
	internal static class CatchOwnerPatch
	{
		private static void Postfix(Item __instance, FishingRod next)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.Creature == (Object)null) && !((Object)(object)next == (Object)null))
			{
				FishSizeService.SpongeRecordCatcher(__instance.Creature, next);
				FishSizeService.SetVisualScale(__instance.Creature);
			}
		}
	}
	[HarmonyPatch(typeof(Creature), "OnDeath")]
	internal static class CatchDeathAnnouncePatch
	{
		private static void Postfix(Creature __instance)
		{
			if (!LeaderboardAnnouncement.SpongeWasAnnounced(((NetworkBehaviour)__instance).ObjectId) && GiantCatchModule.Instance != null && FishSizeService.AttemptClaimLocalNotification(__instance, out var catcherName))
			{
				GiantCatchModule.Instance.DisplayCatchCard(__instance, catcherName);
			}
		}
	}
	[HarmonyPatch(typeof(AttackingFish), "DamageOnCollision")]
	internal static class AggressiveFishStrengthPatch
	{
		private static readonly FieldInfo DamageField = AccessTools.Field(typeof(AttackingFish), "_onHitDamage");

		private static void Prefix(AttackingFish __instance, out int __state)
		{
			__state = (int)DamageField.GetValue(__instance);
			DamageField.SetValue(__instance, FishSizeService.SpongeScaledInt(__state, (Creature)(object)__instance));
		}

		private static Exception Finalizer(AttackingFish __instance, int __state, Exception __exception)
		{
			DamageField.SetValue(__instance, __state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Pufferfish), "OnCollisionEnter")]
	internal static class PufferStrengthPatch
	{
		private static readonly FieldInfo DamageField = AccessTools.Field(typeof(Pufferfish), "_onHitDamage");

		private static void Prefix(Pufferfish __instance, out int __state)
		{
			__state = (int)DamageField.GetValue(__instance);
			DamageField.SetValue(__instance, FishSizeService.SpongeScaledInt(__state, (Creature)(object)__instance));
		}

		private static Exception Finalizer(Pufferfish __instance, int __state, Exception __exception)
		{
			DamageField.SetValue(__instance, __state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(BowheadWhale), "DamageOnCollision")]
	internal static class BowheadStrengthPatch
	{
		private static readonly FieldInfo DamageField = AccessTools.Field(typeof(AttackingFish), "_onHitDamage");

		private static void Prefix(BowheadWhale __instance, out int __state)
		{
			__state = (int)DamageField.GetValue(__instance);
			DamageField.SetValue(__instance, FishSizeService.SpongeScaledInt(__state, (Creature)(object)__instance));
		}

		private static Exception Finalizer(BowheadWhale __instance, int __state, Exception __exception)
		{
			DamageField.SetValue(__instance, __state);
			return __exception;
		}
	}
	[HarmonyPatch(typeof(Item), "get_TotalWorth")]
	internal static class RodSaleValuePatch
	{
		private static void Postfix(ref int __result)
		{
			__result = RodSaleBonusService.Apply(__result);
		}
	}
	[HarmonyPatch(typeof(MoneyManager), "SellItem")]
	internal static class RodSaleScopePatch
	{
		private static void Prefix()
		{
			RodSaleBonusService.Begin(Player.LocalPlayer);
		}

		private static Exception Finalizer(Exception __exception)
		{
			RodSaleBonusService.End();
			return __exception;
		}
	}
	internal sealed class LeaderboardRow
	{
		public string World;

		public string SteamId;

		public string DisplayName;

		public float Size;
	}
	internal struct LeaderboardMessage : IBroadcast
	{
		public string Payload;
	}
	internal struct CatchRecordMessage : IBroadcast
	{
		public int FishNetworkId;

		public float Size;

		public ulong AnglerSteamId;

		public string AnglerName;
	}
	internal static class LeaderboardService
	{
		private const int RecordsPerWorld = 50;

		private const int DisplayedRows = 3;

		private const float BroadcastInterval = 4f;

		private static readonly List<LeaderboardRow> AllEntries = new List<LeaderboardRow>();

		private static readonly List<LeaderboardRow> CurrentEntries = new List<LeaderboardRow>();

		private static ConfigEntry<string> _savedData;

		private static NetworkManager _registeredNetworkManager;

		private static string _currentWorld = string.Empty;

		private static bool _serializersReady;

		private static bool _initialized;

		private static bool _wasServerStarted;

		private static float _nextBroadcastTime;

		public static void Initialize(ConfigFile config)
		{
			if (!_initialized)
			{
				_savedData = config.Bind<string>("Giant Catches", "RankingRecords", string.Empty, "Persistent biggest-catch records. Managed by the mod.");
				SpongeLoadSavedData();
				AssignupSerializers();
				_initialized = true;
			}
		}

		public static void Tick()
		{
			RequireNetworkRegistration();
			bool isServerStarted = InstanceFinder.IsServerStarted;
			if (isServerStarted)
			{
				SpongeSelectCurrentWorld();
				if (!_wasServerStarted || Time.unscaledTime >= _nextBroadcastTime)
				{
					SpongeBroadcastCurrent();
					_nextBroadcastTime = Time.unscaledTime + 4f;
				}
			}
			_wasServerStarted = isServerStarted;
			LeaderboardHud.RequireVisible(CurrentEntries);
		}

		public static void Shutdown()
		{
			if ((Object)(object)_registeredNetworkManager != (Object)null)
			{
				try
				{
					_registeredNetworkManager.ClientManager.UnregisterBroadcast<LeaderboardMessage>((Action<LeaderboardMessage, Channel>)SpongeOnRankingBroadcast);
					_registeredNetworkManager.ClientManager.UnregisterBroadcast<CatchRecordMessage>((Action<CatchRecordMessage, Channel>)SpongeOnRankedCatchBroadcast);
				}
				catch
				{
				}
			}
			_registeredNetworkManager = null;
			_wasServerStarted = false;
			LeaderboardHud.Teardown();
		}

		public static void SpongeRecordCatch(Creature creature)
		{
			try
			{
				SpongeRecordCatchInternal(creature);
			}
			catch (Exception error)
			{
				GiantCatchModule.Instance?.SpongeLogRankingError("record", error);
			}
		}

		private static void SpongeRecordCatchInternal(Creature creature)
		{
			if (!_initialized || !InstanceFinder.IsServerStarted || (Object)(object)creature == (Object)null)
			{
				return;
			}
			FishScaleTracker component = ((Component)creature).GetComponent<FishScaleTracker>();
			if ((Object)(object)component == (Object)null || !component.WasHooked || component.RankingSubmitted)
			{
				return;
			}
			component.RankingSubmitted = true;
			Player val = component.Catcher;
			if ((Object)(object)val == (Object)null && (Object)(object)component.CatcherRod != (Object)null)
			{
				val = (((Object)(object)((Item)component.CatcherRod).SyncedHolder != (Object)null) ? ((Item)component.CatcherRod).SyncedHolder : ((Item)component.CatcherRod).Holder);
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			SpongeSelectCurrentWorld();
			float size = FishSizeService.ObtainDisplaySize(creature);
			string text = ((val.SteamID != 0L) ? val.SteamID.ToString(CultureInfo.InvariantCulture) : ("connection-" + ((NetworkBehaviour)val).OwnerId.ToString(CultureInfo.InvariantCulture)));
			string displayName = (string.IsNullOrWhiteSpace(val.SteamName) ? "Angler" : val.SteamName.Trim());
			LeaderboardRow leaderboardRow = new LeaderboardRow();
			leaderboardRow.World = _currentWorld;
			leaderboardRow.SteamId = text + "-" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture) + "-" + ((NetworkBehaviour)creature).ObjectId.ToString(CultureInfo.InvariantCulture);
			leaderboardRow.DisplayName = displayName;
			leaderboardRow.Size = size;
			LeaderboardRow leaderboardRow2 = leaderboardRow;
			AllEntries.Add(leaderboardRow2);
			component.RankingEntryId = leaderboardRow2.SteamId;
			foreach (LeaderboardRow item in (from candidate in AllEntries
				where candidate != null && candidate.World == _currentWorld
				orderby candidate.Size descending
				select candidate).Skip(50).ToList())
			{
				AllEntries.Remove(item);
			}
			RedrawCurrentEntries();
			SpongeSaveData();
			SpongeBroadcastCurrent();
		}

		public static void BroadcastRankedDeath(Creature creature)
		{
			try
			{
				if (!_initialized || !InstanceFinder.IsServerStarted || (Object)(object)creature == (Object)null)
				{
					return;
				}
				FishScaleTracker state = ((Component)creature).GetComponent<FishScaleTracker>();
				if ((Object)(object)state == (Object)null || state.RankingAnnouncementSent || string.IsNullOrEmpty(state.RankingEntryId))
				{
					return;
				}
				SpongeSelectCurrentWorld();
				LeaderboardRow leaderboardRow = CurrentEntries.FirstOrDefault((LeaderboardRow candidate) => candidate.SteamId == state.RankingEntryId);
				if (leaderboardRow != null)
				{
					Player val = state.Catcher;
					if ((Object)(object)val == (Object)null && (Object)(object)state.CatcherRod != (Object)null)
					{
						val = (((Object)(object)((Item)state.CatcherRod).SyncedHolder != (Object)null) ? ((Item)state.CatcherRod).SyncedHolder : ((Item)state.CatcherRod).Holder);
					}
					state.RankingAnnouncementSent = true;
					CatchRecordMessage catchRecordMessage = new CatchRecordMessage
					{
						FishNetworkId = ((NetworkBehaviour)creature).ObjectId,
						Size = leaderboardRow.Size,
						AnglerSteamId = (((Object)(object)val != (Object)null) ? val.SteamID : 0),
						AnglerName = leaderboardRow.DisplayName
					};
					if (InstanceFinder.IsClientStarted)
					{
						LeaderboardAnnouncement.SpongeReceive(catchRecordMessage);
					}
					InstanceFinder.ServerManager.Broadcast<CatchRecordMessage>(catchRecordMessage, true, (Channel)0);
				}
			}
			catch (Exception error)
			{
				GiantCatchModule.Instance?.SpongeLogRankingError("global announcement", error);
			}
		}

		public static void SpongeBroadcastCurrent()
		{
			try
			{
				if (_initialized && InstanceFinder.IsServerStarted && !((Object)(object)InstanceFinder.ServerManager == (Object)null))
				{
					SpongeSelectCurrentWorld();
					InstanceFinder.ServerManager.Broadcast<LeaderboardMessage>(new LeaderboardMessage
					{
						Payload = ComposeNetworkPayload(CurrentEntries)
					}, true, (Channel)0);
				}
			}
			catch (Exception error)
			{
				GiantCatchModule.Instance?.SpongeLogRankingError("broadcast", error);
			}
		}

		private static void AssignupSerializers()
		{
			if (!_serializersReady)
			{
				GenericWriter<LeaderboardMessage>.SetWrite((Action<Writer, LeaderboardMessage>)delegate(Writer writer, LeaderboardMessage value)
				{
					writer.WriteString(value.Payload);
				});
				GenericReader<LeaderboardMessage>.SetRead((Func<Reader, LeaderboardMessage>)((Reader reader) => new LeaderboardMessage
				{
					Payload = reader.ReadStringAllocated()
				}));
				GenericWriter<CatchRecordMessage>.SetWrite((Action<Writer, CatchRecordMessage>)delegate(Writer writer, CatchRecordMessage value)
				{
					writer.WriteInt32(value.FishNetworkId);
					writer.WriteSingle(value.Size);
					writer.WriteUInt64(value.AnglerSteamId);
					writer.WriteString(value.AnglerName);
				});
				GenericReader<CatchRecordMessage>.SetRead((Func<Reader, CatchRecordMessage>)((Reader reader) => new CatchRecordMessage
				{
					FishNetworkId = reader.ReadInt32(),
					Size = reader.ReadSingle(),
					AnglerSteamId = reader.ReadUInt64(),
					AnglerName = reader.ReadStringAllocated()
				}));
				_serializersReady = true;
			}
		}

		private static void RequireNetworkRegistration()
		{
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if ((Object)(object)networkManager == (Object)(object)_registeredNetworkManager)
			{
				return;
			}
			if ((Object)(object)_registeredNetworkManager != (Object)null)
			{
				try
				{
					_registeredNetworkManager.ClientManager.UnregisterBroadcast<LeaderboardMessage>((Action<LeaderboardMessage, Channel>)SpongeOnRankingBroadcast);
					_registeredNetworkManager.ClientManager.UnregisterBroadcast<CatchRecordMessage>((Action<CatchRecordMessage, Channel>)SpongeOnRankedCatchBroadcast);
				}
				catch
				{
				}
			}
			_registeredNetworkManager = networkManager;
			if (!((Object)(object)networkManager == (Object)null))
			{
				networkManager.ClientManager.RegisterBroadcast<LeaderboardMessage>((Action<LeaderboardMessage, Channel>)SpongeOnRankingBroadcast);
				networkManager.ClientManager.RegisterBroadcast<CatchRecordMessage>((Action<CatchRecordMessage, Channel>)SpongeOnRankedCatchBroadcast);
			}
		}

		private static void SpongeOnRankingBroadcast(LeaderboardMessage message, Channel channel)
		{
			try
			{
				if (!InstanceFinder.IsServerStarted)
				{
					CurrentEntries.Clear();
					SpongeParseNetworkPayload(message.Payload, CurrentEntries);
				}
			}
			catch (Exception error)
			{
				GiantCatchModule.Instance?.SpongeLogRankingError("receive", error);
			}
		}

		private static void SpongeOnRankedCatchBroadcast(CatchRecordMessage message, Channel channel)
		{
			LeaderboardAnnouncement.SpongeReceive(message);
		}

		private static void SpongeSelectCurrentWorld()
		{
			string text = ((SaveManager.CurServerSave != null && !string.IsNullOrWhiteSpace(SaveManager.CurServerSave.Name)) ? SaveManager.CurServerSave.Name.Trim() : "Current game");
			if (!(text == _currentWorld))
			{
				_currentWorld = text;
				RedrawCurrentEntries();
			}
		}

		private static void RedrawCurrentEntries()
		{
			CurrentEntries.Clear();
			CurrentEntries.AddRange((from entry in AllEntries
				where entry != null && entry.World == _currentWorld
				orderby entry.Size descending
				select entry).ThenBy<LeaderboardRow, string>((LeaderboardRow entry) => entry.DisplayName, StringComparer.OrdinalIgnoreCase).Take(3));
		}

		private static void SpongeLoadSavedData()
		{
			AllEntries.Clear();
			if (_savedData == null || string.IsNullOrWhiteSpace(_savedData.Value))
			{
				return;
			}
			string[] array = _savedData.Value.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(',');
				if (array2.Length == 4 && float.TryParse(array2[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					try
					{
						AllEntries.Add(new LeaderboardRow
						{
							World = Decode(array2[0]),
							SteamId = Decode(array2[1]),
							DisplayName = Decode(array2[2]),
							Size = result
						});
					}
					catch (FormatException)
					{
					}
				}
			}
		}

		private static void SpongeSaveData()
		{
			if (_savedData != null)
			{
				_savedData.Value = string.Join(";", from entry in AllEntries
					where entry != null
					select Encode(entry.World) + "," + Encode(entry.SteamId) + "," + Encode(entry.DisplayName) + "," + entry.Size.ToString("0.00", CultureInfo.InvariantCulture));
			}
		}

		private static string ComposeNetworkPayload(IEnumerable<LeaderboardRow> entries)
		{
			return string.Join(";", from entry in entries
				where entry != null
				select Encode(entry.DisplayName) + "," + entry.Size.ToString("0.00", CultureInfo.InvariantCulture));
		}

		private static void SpongeParseNetworkPayload(string payload, List<LeaderboardRow> destination)
		{
			if (string.IsNullOrWhiteSpace(payload))
			{
				return;
			}
			string[] array = payload.Split(new char[1] { ';' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(',');
				if (array2.Length == 2 && float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					try
					{
						destination.Add(new LeaderboardRow
						{
							DisplayName = Decode(array2[0]),
							Size = result
						});
					}
					catch (FormatException)
					{
					}
				}
			}
		}

		private static string Encode(string value)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(value ?? string.Empty));
		}

		private static string Decode(string value)
		{
			return Encoding.UTF8.GetString(Convert.FromBase64String(value));
		}
	}
	internal static class LeaderboardAnnouncement
	{
		private static readonly Dictionary<int, float> AnnouncedObjects = new Dictionary<int, float>();

		public static void SpongeReceive(CatchRecordMessage message)
		{
			if (GiantCatchModule.Instance != null && !SpongeWasAnnounced(message.FishNetworkId))
			{
				AnnouncedObjects[message.FishNetworkId] = Time.unscaledTime + 12f;
				CompendiumPlugin.Run(DisplayWhenAvailable(message));
			}
		}

		public static bool SpongeWasAnnounced(int objectId)
		{
			if (!AnnouncedObjects.TryGetValue(objectId, out var value))
			{
				return false;
			}
			if (Time.unscaledTime <= value)
			{
				return true;
			}
			AnnouncedObjects.Remove(objectId);
			return false;
		}

		private static IEnumerator DisplayWhenAvailable(CatchRecordMessage message)
		{
			float deadline = Time.unscaledTime + 2f;
			Creature found = null;
			while ((Object)(object)found == (Object)null && Time.unscaledTime < deadline)
			{
				Creature[] array = Object.FindObjectsByType<Creature>();
				foreach (Creature val in array)
				{
					if ((Object)(object)val != (Object)null && ((NetworkBehaviour)val).ObjectId == message.FishNetworkId)
					{
						found = val;
						break;
					}
				}
				if ((Object)(object)found == (Object)null)
				{
					yield return null;
				}
			}
			if (!((Object)(object)found == (Object)null) && GiantCatchModule.Instance != null)
			{
				Player localPlayer = Player.LocalPlayer;
				bool isLocalCatcher = (Object)(object)localPlayer != (Object)null && message.AnglerSteamId != 0L && localPlayer.SteamID == message.AnglerSteamId;
				GiantCatchModule.Instance.DisplayGlobalRankedCatch(found, string.IsNullOrWhiteSpace(message.AnglerName) ? "Angler" : message.AnglerName, message.Size, isLocalCatcher);
			}
		}
	}
	internal sealed class RodTierBench : MonoBehaviour
	{
		private static readonly Color Wood = new Color(0.34f, 0.19f, 0.1f);

		private static readonly Color DarkWood = new Color(0.19f, 0.09f, 0.045f);

		private static Material _sceneMaterial;

		private float _nextNativeRodRetry;

		public static RodTierBench Create(Vector3 position, float yaw)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SpongeMods_RodUpgradeTable");
			val.SetActive(false);
			RodTierBench result = val.AddComponent<RodTierBench>();
			val.transform.position = position;
			val.transform.rotation = Quaternion.Euler(0f, yaw, 0f);
			ComposeFurniture(val.transform);
			val.SetActive(true);
			return result;
		}

		private static GameObject ComposeFurniture(Transform root)
		{
			//IL_001a: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			LookupSceneMaterial();
			GameObject result = MakePart(root, "WorkbenchTop", new Vector3(0f, 1.05f, 0f), new Vector3(2.7f, 0.2f, 1.25f), Wood);
			MakePart(root, "Apron", new Vector3(0f, 0.84f, 0f), new Vector3(2.45f, 0.24f, 1.02f), DarkWood);
			float[] array = new float[2] { -1.05f, 1.05f };
			foreach (float num in array)
			{
				float[] array2 = new float[2] { -0.42f, 0.42f };
				foreach (float num2 in array2)
				{
					MakePart(root, "Leg", new Vector3(num, 0.46f, num2), new Vector3(0.22f, 0.92f, 0.22f), DarkWood);
				}
			}
			MakePart(root, "LowerBrace", new Vector3(0f, 0.3f, 0f), new Vector3(2.15f, 0.12f, 0.18f), Wood);
			MakeRodModel(root);
			return result;
		}

		private void Update()
		{
			if ((Object)(object)((Component)this).transform.Find("NativeFishingRodDisplay") != (Object)null || Time.unscaledTime < _nextNativeRodRetry)
			{
				return;
			}
			_nextNativeRodRetry = Time.unscaledTime + 1f;
			if (AttemptCreateNativeRodModel(((Component)this).transform))
			{
				Transform val = ((Component)this).transform.Find("DisplayFishingRod");
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
		}

		private static GameObject MakePart(Transform parent, string name, Vector3 localPosition, Vector3 localScale, Color colour)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = name;
			obj.transform.SetParent(parent, false);
			obj.transform.localPosition = localPosition;
			obj.transform.localScale = localScale;
			obj.GetComponent<Renderer>().sharedMaterial = MakeTintedMaterial(colour);
			return obj;
		}

		private static void MakeRodModel(Transform parent)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_003f: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0091: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			if (!AttemptCreateNativeRodModel(parent))
			{
				GameObject val = new GameObject("DisplayFishingRod");
				val.transform.SetParent(parent, false);
				val.transform.localPosition = new Vector3(0f, 1.28f, 0f);
				val.transform.localRotation = Quaternion.Euler(0f, 18f, -4f);
				MakeCylinder(val.transform, "RodBlank", Vector3.zero, new Vector3(0.045f, 1.05f, 0.045f), new Color(0.08f, 0.28f, 0.18f), Quaternion.Euler(0f, 0f, 90f));
				MakeCylinder(val.transform, "Handle", new Vector3(-1f, 0f, 0f), new Vector3(0.09f, 0.33f, 0.09f), new Color(0.18f, 0.08f, 0.04f), Quaternion.Euler(0f, 0f, 90f));
				MakeCylinder(val.transform, "Reel", new Vector3(-0.55f, -0.12f, 0f), new Vector3(0.16f, 0.08f, 0.16f), new Color(0.16f, 0.62f, 0.48f), Quaternion.Euler(90f, 0f, 0f));
			}
		}

		private static void MakeCylinder(Transform parent, string name, Vector3 position, Vector3 scale, Color colour, Quaternion rotation)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)2);
			((Object)obj).name = name;
			obj.transform.SetParent(parent, false);
			obj.transform.localPosition = position;
			obj.transform.localScale = scale;
			obj.transform.localRotation = rotation;
			obj.GetComponent<Renderer>().sharedMaterial = MakeTintedMaterial(colour);
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
		}

		private static bool AttemptCreateNativeRodModel(Transform parent)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			FishingRod val = ((IEnumerable<FishingRod>)Object.FindObjectsByType<FishingRod>()).FirstOrDefault((Func<FishingRod, bool>)((FishingRod rod) => (Object)(object)rod != (Object)null && ((Object)(object)((Item)rod).Mesh != (Object)null || ((Component)rod).GetComponentsInChildren<MeshFilter>(true).Length != 0)));
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			GameObject val2 = new GameObject("NativeFishingRodDisplay");
			val2.transform.SetParent(parent, false);
			val2.transform.localPosition = new Vector3(0f, 1.3f, 0f);
			if ((Object)(object)((Item)val).Mesh != (Object)null)
			{
				GameObject val3 = new GameObject("NativeRodMesh", new Type[2]
				{
					typeof(MeshFilter),
					typeof(MeshRenderer)
				});
				val3.transform.SetParent(val2.transform, false);
				val3.GetComponent<MeshFilter>().sharedMesh = ((Item)val).Mesh;
				Renderer val4 = ((IEnumerable<Renderer>)((Component)val).GetComponentsInChildren<Renderer>(true)).FirstOrDefault((Func<Renderer, bool>)((Renderer renderer) => (Object)(object)renderer != (Object)null && renderer.sharedMaterials.Length != 0));
				((Renderer)val3.GetComponent<MeshRenderer>()).sharedMaterials = (Material[])(((Object)(object)val4 != (Object)null) ? ((Array)val4.sharedMaterials) : ((Array)new Material[1] { MakeTintedMaterial(new Color(0.08f, 0.28f, 0.18f)) }));
				Bounds bounds = ((Item)val).Mesh.bounds;
				float num = Mathf.Max(new float[3]
				{
					((Bounds)(ref bounds)).size.x,
					((Bounds)(ref bounds)).size.y,
					((Bounds)(ref bounds)).size.z
				});
				float num2 = ((num > 0.001f) ? (2.25f / num) : 1f);
				Quaternion val5 = ((((Bounds)(ref bounds)).size.y >= ((Bounds)(ref bounds)).size.x && ((Bounds)(ref bounds)).size.y >= ((Bounds)(ref bounds)).size.z) ? Quaternion.Euler(0f, 0f, -90f) : ((!(((Bounds)(ref bounds)).size.z >= ((Bounds)(ref bounds)).size.x) || !(((Bounds)(ref bounds)).size.z >= ((Bounds)(ref bounds)).size.y)) ? Quaternion.identity : Quaternion.Euler(0f, 90f, 0f)));
				Quaternion val6 = Quaternion.Euler(0f, 12f, 0f) * val5;
				val3.transform.localRotation = val6;
				val3.transform.localScale = Vector3.one * num2;
				val3.transform.localPosition = -(val6 * (((Bounds)(ref bounds)).center * num2));
				return true;
			}
			val2.transform.localRotation = Quaternion.Euler(0f, 18f, -4f);
			GameObject val7 = new GameObject("Visuals");
			val7.transform.SetParent(val2.transform, false);
			int num3 = 0;
			MeshFilter[] componentsInChildren = ((Component)val).GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val8 in componentsInChildren)
			{
				MeshRenderer component = ((Component)val8).GetComponent<MeshRenderer>();
				if (!((Object)(object)component == (Object)null) && !((Object)(object)val8.sharedMesh == (Object)null))
				{
					GameObject val9 = new GameObject("Rod_" + ((Object)((Component)val8).gameObject).name, new Type[2]
					{
						typeof(MeshFilter),
						typeof(MeshRenderer)
					});
					val9.transform.SetParent(val7.transform, false);
					val9.transform.localPosition = ((Component)val).transform.InverseTransformPoint(((Component)val8).transform.position);
					val9.transform.localRotation = Quaternion.Inverse(((Component)val).transform.rotation) * ((Component)val8).transform.rotation;
					val9.transform.localScale = SpongeDivideScale(((Component)val8).transform.lossyScale, ((Component)val).transform.lossyScale);
					val9.GetComponent<MeshFilter>().sharedMesh = val8.sharedMesh;
					((Renderer)val9.GetComponent<MeshRenderer>()).sharedMaterials = ((Renderer)component).sharedMaterials;
					num3++;
				}
			}
			if (num3 == 0)
			{
				Object.Destroy((Object)(object)val2);
				return false;
			}
			Renderer[] componentsInChildren2 = val7.GetComponentsInChildren<Renderer>(true);
			Bounds bounds2 = componentsInChildren2[0].bounds;
			foreach (Renderer item in componentsInChildren2.Skip(1))
			{
				((Bounds)(ref bounds2)).Encapsulate(item.bounds);
			}
			Vector3 val10 = val2.transform.InverseTransformPoint(((Bounds)(ref bounds2)).center);
			float num5 = Mathf.Max(new float[3]
			{
				((Bounds)(ref bounds2)).size.x,
				((Bounds)(ref bounds2)).size.y,
				((Bounds)(ref bounds2)).size.z
			});
			float num6 = ((num5 > 0.001f) ? (2.25f / num5) : 1f);
			val7.transform.localScale = Vector3.one * num6;
			val7.transform.localPosition = -val10 * num6;
			return true;
		}

		private static Vector3 SpongeDivideScale(Vector3 value, Vector3 divisor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0012: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3((Mathf.Abs(divisor.x) > 0.0001f) ? (value.x / divisor.x) : value.x, (Mathf.Abs(divisor.y) > 0.0001f) ? (value.y / divisor.y) : value.y, (Mathf.Abs(divisor.z) > 0.0001f) ? (value.z / divisor.z) : value.z);
		}

		private static void LookupSceneMaterial()
		{
			if (!((Object)(object)_sceneMaterial != (Object)null) || !((Object)(object)_sceneMaterial.shader != (Object)null) || !_sceneMaterial.shader.isSupported)
			{
				Renderer val = (from renderer in Object.FindObjectsByType<Renderer>()
					where (Object)(object)renderer != (Object)null && (Object)(object)renderer.sharedMaterial != (Object)null && (Object)(object)renderer.sharedMaterial.shader != (Object)null && renderer.sharedMaterial.shader.isSupported && ((object)renderer).GetType().Name != "ParticleSystemRenderer" && !(renderer is LineRenderer)
					orderby SpongeMaterialScore(((Object)((Component)renderer).gameObject).name + " " + ((Object)renderer.sharedMaterial).name) descending
					select renderer).FirstOrDefault();
				if ((Object)(object)val != (Object)null)
				{
					_sceneMaterial = val.sharedMaterial;
				}
			}
		}

		private static int SpongeMaterialScore(string value)
		{
			string text = value.ToLowerInvariant();
			int num = 0;
			if (text.Contains("wood") || text.Contains("plank"))
			{
				num += 100;
			}
			if (text.Contains("dock") || text.Contains("pier"))
			{
				num += 80;
			}
			if (text.Contains("table") || text.Contains("bench"))
			{
				num += 70;
			}
			if (text.Contains("rock") || text.Contains("ground"))
			{
				num += 10;
			}
			if (text.Contains("water") || text.Contains("sky") || text.Contains("glass"))
			{
				num -= 100;
			}
			return num;
		}

		private static Material MakeTintedMaterial(Color colour)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_009a: 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_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Invalid comparison between Unknown and I4
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Invalid comparison between Unknown and I4
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			Material val = (((Object)(object)_sceneMaterial != (Object)null) ? new Material(_sceneMaterial.shader) : new Material(Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard") ?? Shader.Find("Sprites/Default")));
			((Object)val).name = "SpongeMods_TableMaterial";
			Texture2D val2 = new Texture2D(2, 2, (TextureFormat)4, false)
			{
				name = "SpongeMods_SolidWood",
				wrapMode = (TextureWrapMode)0,
				filterMode = (FilterMode)1
			};
			val2.SetPixels((Color[])(object)new Color[4] { colour, colour, colour, colour });
			val2.Apply(false, true);
			string[] array = new string[4] { "_BaseMap", "_MainTex", "_BaseColorMap", "_Albedo" };
			foreach (string text in array)
			{
				if (val.HasProperty(text))
				{
					val.SetTexture(text, (Texture)(object)val2);
				}
			}
			val.mainTexture = (Texture)(object)val2;
			array = new string[4] { "_BumpMap", "_NormalMap", "_MaskMap", "_MetallicGlossMap" };
			foreach (string text2 in array)
			{
				if (val.HasProperty(text2))
				{
					val.SetTexture(text2, (Texture)null);
				}
			}
			if (val.HasProperty("_BaseColor"))
			{
				val.SetColor("_BaseColor", colour);
			}
			if (val.HasProperty("_Color"))
			{
				val.SetColor("_Color", colour);
			}
			if (val.HasProperty("_Metallic"))
			{
				val.SetFloat("_Metallic", 0f);
			}
			if (val.HasProperty("_Smoothness"))
			{
				val.SetFloat("_Smoothness", 0.18f);
			}
			if (val.HasProperty("_Glossiness"))
			{
				val.SetFloat("_Glossiness", 0.18f);
			}
			Shader shader = val.shader;
			int num = 0;
			while ((Object)(object)shader != (Object)null && num < shader.GetPropertyCount())
			{
				string propertyName = shader.GetPropertyName(num);
				string text3 = propertyName.ToLowerInvariant();
				ShaderPropertyType propertyType = shader.GetPropertyType(num);
				if ((int)propertyType == 0)
				{
					val.SetColor(propertyName, colour);
				}
				else if ((int)propertyType == 1)
				{
					if (text3.Contains("color") || text3.Contains("tint"))
					{
						val.SetVector(propertyName, new Vector4(colour.r, colour.g, colour.b, colour.a));
					}
				}
				else if ((int)propertyType == 4)
				{
					bool flag = text3.Contains("normal") || text3.Contains("bump") || text3.Contains("mask") || text3.Contains("metal") || text3.Contains("rough");
					val.SetTexture(propertyName, (Texture)(object)(flag ? null : val2));
				}
				num++;
			}
			return val;
		}
	}
	internal static class RodTierHud
	{
		private static readonly Color Cyan = new Color(0.18f, 0.82f, 0.88f, 1f);

		private static GameObject _canvasRoot;

		private static GameObject _panel;

		private static TextMeshProUGUI _text;

		public static void AssignVisible(bool visible, string message)
		{
			if (!visible)
			{
				if ((Object)(object)_canvasRoot != (Object)null)
				{
					_canvasRoot.SetActive(false);
				}
				return;
			}
			TextMeshProUGUI canvasTextPrefab;
			try
			{
				canvasTextPrefab = PlayerUI.CanvasTextPrefab;
			}
			catch
			{
				return;
			}
			if (!((Object)(object)canvasTextPrefab == (Object)null))
			{
				if ((Object)(object)_canvasRoot == (Object)null || (Object)(object)_panel == (Object)null || (Object)(object)_text == (Object)null)
				{
					Teardown();
					Build();
				}
				_canvasRoot.SetActive(true);
				((TMP_Text)_text).text = message;
			}
		}

		public static void Teardown()
		{
			if ((Object)(object)_canvasRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasRoot);
			}
			_canvasRoot = null;
			_panel = null;
			_text = null;
		}

		private static void Build()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			_canvasRoot = UiSupport.CreateOverlayCanvas("SpongeMods_UpgradeCanvas", 5200);
			_panel = new GameObject("RodUpgradePanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Outline)
			});
			_panel.transform.SetParent(_canvasRoot.transform, false);
			RectTransform val = (RectTransform)_panel.transform;
			val.anchorMin = new Vector2(0.5f, 0f);
			val.anchorMax = new Vector2(0.5f, 0f);
			val.pivot = new Vector2(0.5f, 0f);
			val.anchoredPosition = new Vector2(0f, 185f);
			val.sizeDelta = new Vector2(800f, 150f);
			Image component = _panel.GetComponent<Image>();
			((Graphic)component).color = new Color(0.018f, 0.065f, 0.08f, 0.97f);
			((Graphic)component).raycastTarget = false;
			Outline component2 = _panel.GetComponent<Outline>();
			((Shadow)component2).effectColor = new Color(Cyan.r, Cyan.g, Cyan.b, 0.85f);
			((Shadow)component2).effectDistance = new Vector2(3f, -3f);
			GameObject val2 = new GameObject("Accent", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent(_panel.transform, false);
			RectTransform val3 = (RectTransform)val2.transform;
			val3.anchorMin = new Vector2(0f, 1f);
			val3.anchorMax = new Vector2(1f, 1f);
			val3.pivot = new Vector2(0.5f, 1f);
			val3.anchoredPosition = Vector2.zero;
			val3.sizeDelta = new Vector2(0f, 5f);
			Image component3 = val2.GetComponent<Image>();
			((Graphic)component3).color = Cyan;
			((Graphic)component3).raycastTarget = false;
			_text = Object.Instantiate<TextMeshProUGUI>(PlayerUI.CanvasTextPrefab, _panel.transform);
			((Object)((Component)_text).gameObject).name = "UpgradeMessage";
			RectTransform rectTransform = ((TMP_Text)_text).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(18f, 10f);
			rectTransform.offsetMax = new Vector2(-18f, -10f);
			((TMP_Text)_text).fontSize = 19f;
			((TMP_Text)_text).fontStyle = (FontStyles)1;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)514;
			((Graphic)_text).color = Color.white;
			((TMP_Text)_text).textWrappingMode = (TextWrappingModes)1;
			((Graphic)_text).raycastTarget = false;
		}
	}
	internal struct RodTierUpdate : IBroadcast
	{
		public ulong OwnerSteamId;

		public int Tier;
	}
	internal struct RodTierPurchaseRequest : IBroadcast
	{
		public ulong OwnerSteamId;
	}
	internal sealed class RodReelTierState : MonoBehaviour
	{
		public float BaseSpeed;

		public int AppliedLevel = -1;
	}
	internal static class RodTierService
	{
		private sealed class BenchPlacement
		{
			public Vector3 Position;

			public float Yaw;
		}

		public const int MaxLevel = 25;

		private static readonly int[] Costs = new int[25]
		{
			10, 35, 75, 175, 300, 1000, 2500, 4900, 10000, 17500,
			39000, 85000, 175000, 405000, 900000, 2000000, 4500000, 10000000, 22000000, 50000000,
			110000000, 250000000, 550000000, 1200000000, 2000000000
		};

		private static readonly int[] LuckGain = new int[25]
		{
			1, 1, 2, 2, 2, 3, 3, 3, 3, 4,
			4, 4, 5, 5, 5, 5, 5, 6, 6, 6,
			7, 7, 7, 8, 8
		};

		private static readonly int[] SaleGain = new int[25]
		{
			0, 10, 10, 10, 15, 15, 15, 20, 20, 25,
			25, 25, 30, 30, 35, 35, 40, 40, 45, 45,
			50, 50, 60, 75, 100
		};

		private const float InteractionRange = 4.5f;

		private const float InteractionRangeSquared = 20.25f;

		private const float SyncInterval = 4f;

		private const float RodApplyInterval = 1f;

		private const float TableSearchInterval = 2f;

		private const float ReelSpeedPerLevel = 0.05f;

		private static readonly Dictionary<ulong, int> Levels = new Dictionary<ulong, int>();

		private static readonly PropertyInfo SyncedCurItemProperty = AccessTools.Property(typeof(PlayerInventory), "SyncedCurItem");

		private static readonly FieldInfo ReelSpeedField = AccessTools.Field(typeof(FishingRod), "_holdReelSpeed");

		private static bool _personalWalletResolved;

		private static MethodInfo _personalWalletGet;

		private static MethodInfo _personalWalletRemove;

		private static ConfigEntry<string> _savedLevels;

		private static ConfigEntry<string> _savedPlacements;

		private static readonly Dictionary<string, BenchPlacement> Placements = new Dictionary<string, BenchPlacement>();

		private static NetworkManager _registeredManager;

		private static int _islandId = int.MinValue;

		private static RodTierBench _table;

		private static float _nextAutomaticPlacementAttempt;

		private static float _nextTableSearch;

		private static float _nextSync;

		private static float _nextRodApply;

		private static float _interactionReadyTime;

		private static string _currentPlacementKey;

		public static void Initialize(ConfigFile config)
		{
			_savedLevels = config.Bind<string>("Giant Catches", "RodUpgradeLevels", string.Empty, "Persistent fishing rod upgrade levels by Steam account. Managed by the mod.");
			_savedPlacements = config.Bind<string>("Giant Catches", "RodUpgradeTablePlacements", string.Empty, "Saved workbench coordinates by saved game and island. Managed by the mod.");
			Load();
			SpongeLoadPlacements();
			GenericWriter<RodTierUpdate>.SetWrite((Action<Writer, RodTierUpdate>)delegate(Writer writer, RodTierUpdate value)
			{
				writer.WriteUInt64(value.OwnerSteamId);
				writer.WriteInt32(value.Tier);
			});
			GenericReader<RodTierUpdate>.SetRead((Func<Reader, RodTierUpdate>)((Reader reader) => new RodTierUpdate
			{
				OwnerSteamId = reader.ReadUInt64(),
				Tier = reader.ReadInt32()
			}));
			GenericWriter<RodTierPurchaseRequest>.SetWrite((Action<Writer, RodTierPurchaseRequest>)delegate(Writer writer, RodTierPurchaseRequest value)
			{
				writer.WriteUInt64(value.OwnerSteamId);
			});
			GenericReader<RodTierPurchaseRequest>.SetRead((Func<Reader, RodTierPurchaseRequest>)((Reader reader) => new RodTierPurchaseRequest
			{
				OwnerSteamId = reader.ReadUInt64()
			}));
		}

		public static void Tick()
		{
			RequireNetworkHandlers();
			RequireTable();
			Player player;
			bool nearby = AttemptGetNearbyPlayer(out player);
			OnLocalInteraction(nearby, player);
			SyncInteractionHud(nearby, player);
			if (Time.unscaledTime >= _nextSync)
			{
				SpongeSyncLocalLevel();
				_nextSync = Time.unscaledTime + 4f;
			}
			if (Time.unscaledTime >= _nextRodApply)
			{
				SetReelSpeeds();
				_nextRodApply = Time.unscaledTime + 1f;
			}
		}

		public static void Shutdown()
		{
			if ((Object)(object)_registeredManager != (Object)null)
			{
				TryUnregister(delegate
				{
					_registeredManager.ServerManager.UnregisterBroadcast<RodTierUpdate>((Action<NetworkConnection, RodTierUpdate, Channel>)SpongeOnServerSync);
				});
				TryUnregister(delegate
				{
					_registeredManager.ServerManager.UnregisterBroadcast<RodTierPurchaseRequest>((Action<NetworkConnection, RodTierPurchaseRequest, Channel>)SpongeOnServerPurchase);
				});
				TryUnregister(delegate
				{
					_registeredManager.ClientManager.UnregisterBroadcast<RodTierUpdate>((Action<RodTierUpdate, Channel>)SpongeOnClientSync);
				});
			}
			if ((Object)(object)_table != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_table).gameObject);
			}
			_table = null;
			_registeredManager = null;
			RodTierHud.Teardown();
		}

		private static void TryUnregister(Action action)
		{
			try
			{
				action();
			}
			catch
			{
			}
		}

		public static int ObtainLevel(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return 0;
			}
			if (!Levels.TryGetValue(player.SteamID, out var value))
			{
				return 0;
			}
			return Mathf.Clamp(value, 0, 25);
		}

		public static int ObtainLuck(Player player)
		{
			return SpongeSumThrough(LuckGain, ObtainLevel(player));
		}

		public static int ObtainSaleBonus(Player player)
		{
			return SpongeSumThrough(SaleGain, ObtainLevel(player));
		}

		public static float ObtainReelMultiplier(Player player)
		{
			return 1f + (float)ObtainLevel(player) * 0.05f;
		}

		public static Player ObtainCatcherForCreature(Creature creature)
		{
			FishScaleTracker fishScaleTracker = (((Object)(object)creature != (Object)null) ? ((Component)creature).GetComponent<FishScaleTracker>() : null);
			if ((Object)(object)fishScaleTracker == (Object)null)
			{
				return null;
			}
			Player val = fishScaleTracker.Catcher;
			if ((Object)(object)val == (Object)null && (Object)(object)fishScaleTracker.CatcherRod != (Object)null)
			{
				val = (((Object)(object)((Item)fishScaleTracker.CatcherRod).SyncedHolder != (Object)null) ? ((Item)fishScaleTracker.CatcherRod).SyncedHolder : ((Item)fishScaleTracker.CatcherRod).Holder);
			}
			return val;
		}

		public static int ObtainLuckForCreature(Creature creature)
		{
			return ObtainLuck(ObtainCatcherForCreature(creature));
		}

		public static bool HasHoldingRod(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Inventory == (Object)null || SyncedCurItemProperty == null)
			{
				return false;
			}
			return SyncedCurItemProperty.GetValue(player.Inventory) is FishingRod;
		}

		public static int ObtainNextCost(Player player)
		{
			int num = ObtainLevel(player);
			if (num >= 25)
			{
				return 0;
			}
			return Costs[num];
		}

		public static string ObtainUpgradeDescription(Player player)
		{
			int num = ObtainLevel(player);
			if (num >= 25)
			{
				return "ROD AT MAXIMUM LEVEL\n" + $"CURRENT  -  Luck {ObtainLuck(player)}  -  Reel +{num * 5}%  -  Sale +{ObtainSaleBonus(player)}%";
			}
			string arg = (((Object)(object)MoneyManager.Instance != (Object)null && MoneyManager.CanAfford(Costs[num])) ? "Press [E] to upgrade" : $"NOT ENOUGH MONEY  -  You need ${Costs[num]:N0}");
			return $"CURRENT  -  Level {num}  -  Luck {ObtainLuck(player)}  -  " + $"Reel +{num * 5}%  -  Sale +{ObtainSaleBonus(player)}%\n" + $"UPGRADE {num + 1}  -  ${Costs[num]:N0}\n" + $"+{LuckGain[num]} luck   +5% reel   +{SaleGain[num]}% sale\n{arg}";
		}

		public static void AttemptPurchase(Player player)
		{
			if (!((Object)(object)player == (Object)null) && HasHoldingRod(player))
			{
				if (InstanceFinder.IsServerStarted)
				{
					SpongePurchaseOnServer(player);
				}
				else if (InstanceFinder.IsClientStarted && (Object)(object)InstanceFinder.ClientManager != (Object)null)
				{
					InstanceFinder.ClientManager.Broadcast<RodTierPurchaseRequest>(new RodTierPurchaseRequest
					{
						OwnerSteamId = player.SteamID
					}, (Channel)0);
				}
			}
		}

		private static void RequireNetworkHandlers()
		{
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if ((Object)(object)networkManager == (Object)(object)_registeredManager)
			{
				return;
			}
			if ((Object)(object)_registeredManager != (Object)null)
			{
				TryUnregister(delegate
				{
					_registeredManager.ServerManager.UnregisterBroadcast<RodTierUpdate>((Action<NetworkConnection, RodTierUpdate, Channel>)SpongeOnServerSync);
				});
				TryUnregister(delegate
				{
					_registeredManager.ServerManager.UnregisterBroadcast<RodTierPurchaseRequest>((Action<NetworkConnection, RodTierPurchaseRequest, Channel>)SpongeOnServerPurchase);
				});
				TryUnregister(delegate
				{
					_registeredManager.ClientManager.UnregisterBroadcast<RodTierUpdate>((Action<RodTierUpdate, Channel>)SpongeOnClientSync);
				});
			}
			_registeredManager = networkManager;
			if (!((Object)(object)networkManager == (Object)null))
			{
				networkManager.ServerManager.RegisterBroadcast<RodTierUpdate>((Action<NetworkConnection, RodTierUpdate, Channel>)SpongeOnServerSync, true);
				networkManager.ServerManager.RegisterBroadcast<RodTierPurchaseRequest>((Action<NetworkConnection, RodTierPurchaseRequest, Channel>)SpongeOnServerPurchase, true);
				networkManager.ClientManager.RegisterBroadcast<RodTierUpdate>((Action<RodTierUpdate, Channel>)SpongeOnClientSync);
			}
		}

		private static void SpongeOnServerSync(NetworkConnection connection, RodTierUpdate message, Channel channel)
		{
			if (message.OwnerSteamId != 0L)
			{
				int num = Mathf.Clamp(message.Tier, 0, 25);
				int value;
				int num2 = (Levels.TryGetValue(message.OwnerSteamId, out value) ? value : 0);
				Levels[message.OwnerSteamId] = Mathf.Max(num2, num);
			}
		}

		private static void SpongeOnServerPurchase(NetworkConnection connection, RodTierPurchaseRequest message, Channel channel)
		{
			Player[] source = Object.FindObjectsByType<Player>();
			Player val = ((IEnumerable<Player>)source).FirstOrDefault((Func<Player, bool>)((Player candidate) => (Object)(object)candidate != (Object)null && ((NetworkBehaviour)candidate).Owner == connection)) ?? ((IEnumerable<Player>)source).FirstOrDefault((Func<Player, bool>)((Player candidate) => (Object)(object)candidate != (Object)null && ((NetworkBehaviour)candidate).OwnerId == connection.ClientId)) ?? ((IEnumerable<Player>)source).FirstOrDefault((Func<Player, bool>)((Player candidate) => (Object)(object)candidate != (Object)null && message.OwnerSteamId != 0L && candidate.SteamID == message.OwnerSteamId));
			if ((Object)(object)val == (Object)null)
			{
				GiantCatchModule.Instance?.SpongeLogUpgradeRejection($"No player found for connection {connection.ClientId} (Steam {message.OwnerSteamId}).");
			}
			else if (message.OwnerSteamId != 0L && val.SteamID != 0L && val.SteamID != message.OwnerSteamId)
			{
				GiantCatchModule.Instance?.SpongeLogUpgradeRejection("The Steam identity received does not match " + val.SteamName + ".");
			}
			else
			{
				SpongePurchaseOnServer(val);
			}
		}

		private static void SpongePurchaseOnServer(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			if (!HasHoldingRod(player))
			{
				GiantCatchModule.Instance?.SpongeLogUpgradeRejection(player.SteamName + " does not have a rod selected according to the server.");
				return;
			}
			int num = ObtainLevel(player);
			if (num >= 25)
			{
				return;
			}
			int num2 = Costs[num];
			if (!AllowsPlayerAfford(player, num2))
			{
				GiantCatchModule.Instance?.SpongeLogUpgradeRejection($"{player.SteamName} does not have ${num2:N0} for upgrade {num + 1}.");
			}
			else if (SpongeChargePlayer(player, num2))
			{
				int num3 = num + 1;
				Levels[player.SteamID] = num3;
				Save();
				GiantCatchModule.Instance?.SpongeLogUpgradePurchase(player, num2, num3);
				RodTierUpdate rodTierUpdate = new RodTierUpdate
				{
					OwnerSteamId = player.SteamID,
					Tier = num3
				};
				if ((Object)(object)InstanceFinder.ServerManager != (Object)null)
				{
					InstanceFinder.ServerManager.Broadcast<RodTierUpdate>(rodTierUpdate, true, (Channel)0);
				}
				SpongeOnClientSync(rodTierUpdate, (Channel)0);
			}
		}

		private static bool AllowsPlayerAfford(Player player, int cost)
		{
			LookupPersonalWallet();
			if (_personalWalletGet != null)
			{
				try
				{
					return (int)_personalWalletGet.Invoke(null, new object[1] { player }) >= cost;
				}
				catch (Exception error)
				{
					GiantCatchModule.Instance?.SpongeLogUpgradeError("reading NoSharedMoney wallet", error);
					return false;
				}
			}
			if ((Object)(object)MoneyManager.Instance != (Object)null)
			{
				return MoneyManager.CanAfford(cost);
			}
			return false;
		}

		private static bool SpongeChargePlayer(Player player, int cost)
		{
			LookupPersonalWallet();
			if (_personalWalletRemove != null)
			{
				try
				{
					_personalWalletRemove.Invoke(null, new object[2] { player, cost });
					return true;
				}
				catch (Exception error)
				{
					GiantCatchModule.Instance?.SpongeLogUpgradeError("charging NoSharedMoney wallet", error);
					return false;
				}
			}
			if ((Object)(object)MoneyManager.Instance == (Object)null)
			{
				return false;
			}
			MoneyManager.RemoveMoney(cost, player);
			return true;
		}

		private static void LookupPersonalWallet()
		{
			if (_personalWalletResolved)
			{
				return;
			}
			_personalWalletResolved = true;
			Type type = Type.GetType("NoSharedMoney.Wallets, NoSharedMoney", throwOnError: false);
			if (!(type == null))
			{
				_personalWalletGet = type.GetMethod("Get", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(Player) }, null);
				_personalWalletRemove = type.GetMethod("Remove", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(Player),
					typeof(int)
				}, null);
				if (_personalWalletGet != null && _personalWalletRemove != null)
				{
					GiantCatchModule.Instance?.SpongeLogPersonalWalletCompatibility();
				}
			}
		}

		private static void SpongeOnClientSync(RodTierUpdate message, Channel channel)
		{
			if (message.OwnerSteamId != 0L)
			{
				Levels[message.OwnerSteamId] = Mathf.Clamp(message.Tier, 0, 25);
				if ((Object)(object)Player.LocalPlayer != (Object)null && Player.LocalPlayer.SteamID == message.OwnerSteamId)
				{
					Save();
				}
			}
		}

		private static void SpongeSyncLocalLevel()
		{
			Player localPlayer = Player.LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && localPlayer.SteamID != 0L)
			{
				RodTierUpdate rodTierUpdate = new RodTierUpdate
				{
					OwnerSteamId = localPlayer.SteamID,
					Tier = ObtainLevel(localPlayer)
				};
				if (InstanceFinder.IsServerStarted)
				{
					Levels[rodTierUpdate.OwnerSteamId] = rodTierUpdate.Tier;
				}
				else if (InstanceFinder.IsClientStarted && (Object)(object)InstanceFinder.ClientManager != (Object)null)
				{
					InstanceFinder.ClientManager.Broadcast<RodTierUpdate>(rodTierUpdate, (Channel)0);
				}
			}
		}

		private static void RequireTable()
		{
			//IL_0030: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			Island curIsland = Island.CurIsland;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)curIsland == (Object)null)
			{
				return;
			}
			int num = ((Object)curIsland).name.GetHashCode() ^ ((object)((Component)curIsland).transform.position/*cast due to .constrained prefix*/).GetHashCode();
			if (num != _islandId)
			{
				if ((Object)(object)_table != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)_table).gameObject);
				}
				_table = null;
				_islandId = num;
				_currentPlacementKey = ComposePlacementKey(curIsland);
				BenchPlacement placement;
				if (Placements.TryGetValue(_currentPlacementKey, out var value))
				{
					_table = RodTierBench.Create(value.Position, value.Yaw);
				}
				else if (AttemptGetBuiltInPlacement(curIsland, out placement))
				{
					_table = RodTierBench.Create(placement.Position, placement.Yaw);
				}
			}
			if (!((Object)(object)_table != (Object)null) && !(Time.unscaledTime < _nextAutomaticPlacementAttempt))
			{
				_nextAutomaticPlacementAttempt = Time.unscaledTime + 1f;
				if (AttemptFindAutomaticPlacement(localPlayer, out var placement2))
				{
					Placements[_currentPlacementKey] = placement2;
					SpongeSavePlacements();
					_table = RodTierBench.Create(placement2.Position, placement2.Yaw);
					_interactionReadyTime = Time.unscaledTime + 0.4f;
				}
			}
		}

		private static void OnLocalInteraction(bool nearby, Player player)
		{
			if (nearby && !(Time.unscaledTime < _interactionReadyTime) && Keyboard.current != null && ((ButtonControl)Keyboard.current.eKey).wasPressedThisFrame)
			{
				AttemptPurchase(player);
			}
		}

		private static void SyncInteractionHud(bool nearby, Player player)
		{
			if (!nearby)
			{
				RodTierHud.AssignVisible(visible: false, string.Empty);
				return;
			}
			string message = (HasHoldingRod(player) ? ObtainUpgradeDescription(player) : "ROD UPGRADE BENCH\nEquip a fishing rod or a crab rod");
			RodTierHud.AssignVisible(visible: true, message);
		}

		private static bool AttemptGetNearbyPlayer(out Player player)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			player = Player.LocalPlayer;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_table == (Object)null)
			{
				if (Time.unscaledTime < _nextTableSearch)
				{
					return false;
				}
				_nextTableSearch = Time.unscaledTime + 2f;
				_table = Object.FindAnyObjectByType<RodTierBench>();
				if ((Object)(object)_table == (Object)null)
				{
					return false;
				}
			}
			Vector3 position = ((Component)_table).transform.position;
			Vector3 val = ((Component)player).transform.position - position;
			float num = ((Vector3)(ref val)).sqrMagnitude;
			if ((Object)(object)player.CurCam != (Object)null)
			{
				float num2 = num;
				val = ((Component)player.CurCam).transform.position - position;
				num = Mathf.Min(num2, ((Vector3)(ref val)).sqrMagnitude);
			}
			return num <= 20.25f;
		}

		private static bool AttemptFindAutomaticPlacement(Player player, out BenchPlacement placement)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			placement = null;
			Transform anchor = (from box in Object.FindObjectsByType<SellBox>()
				where (Object)(object)box != (Object)null && ((Component)box).gameObject.activeInHierarchy
				orderby SpongeHorizontalSqrDistance(((Component)box).transform.position, ((Component)player).transform.position)
				select ((Component)box).transform).FirstOrDefault();
			if ((Object)(object)anchor == (Object)null)
			{
				anchor = (from npc in Object.FindObjectsByType<NPC>()
					where (Object)(object)npc != (Object)null && ((Component)npc).gameObject.activeInHierarchy
					orderby SpongeHorizontalSqrDistance(((Component)npc).transform.position, ((Component)player).transform.position)
					select ((Component)npc).transform).FirstOrDefault();
			}
			if ((Object)(object)anchor == (Object)null)
			{
				return false;
			}
			Vector3 right = anchor.right;
			right.y = 0f;
			((Vector3)(ref right)).Normalize();
			Vector3 forward = anchor.forward;
			forward.y = 0f;
			((Vector3)(ref forward)).Normalize();
			if (((Vector3)(ref right)).sqrMagnitude < 0.5f)
			{
				right = Vector3.right;
			}
			if (((Vector3)(ref forward)).sqrMagnitude < 0.5f)
			{
				forward = Vector3.forward;
			}
			Vector3[] obj = new Vector3[8]
			{
				right * 3.6f,
				-right * 3.6f,
				-forward * 3.8f,
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3)
			};
			Vector3 val = right - forward;
			obj[3] = ((Vector3)(ref val)).normalized * 4.2f;
			val = -right - forward;
			obj[4] = ((Vector3)(ref val)).normalized * 4.2f;
			obj[5] = forward * 4.5f;
			obj[6] = right * 5.2f;
			obj[7] = -right * 5.2f;
			int num = int.MaxValue;
			Vector3 val2 = default(Vector3);
			bool flag = false;
			Vector3[] array = (Vector3[])(object)obj;
			RaycastHit hit = default(RaycastHit);
			foreach (Vector3 val3 in array)
			{
				if (!Physics.Raycast(anchor.position + val3 + Vector3.up * 12f, Vector3.down, ref hit, 30f, -5, (QueryTriggerInteraction)1))
				{
					continue;
				}
				string text = (((Object)(object)((RaycastHit)(ref hit)).collider != (Object)null) ? ((Object)((Component)((RaycastHit)(ref hit)).collider).gameObject).name.ToLowerInvariant() : string.Empty);
				if (text.Contains("water") || text.Contains("ocean") || text.Contains("sea"))
				{
					continue;
				}
				Vector3 point = ((RaycastHit)(ref hit)).point;
				int num3 = Physics.OverlapBox(point + Vector3.up * 0.68f, new Vector3(1.55f, 0.52f, 0.82f), Quaternion.identity, -5, (QueryTriggerInteraction)1).Count((Collider collider) => (Object)(object)collider != (Object)null && (Object)(object)collider != (Object)(object)((RaycastHit)(ref hit)).collider && !((Component)collider).transform.IsChildOf(anchor) && !anchor.IsChildOf(((Component)collider).transform));
				if (num3 < num)
				{
					num = num3;
					val2 = point;
					flag = true;
					if (num3 == 0)
					{
						break;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			Vector3 val4 = anchor.position - val2;
			val4.y = 0f;
			float y;
			if (!(((Vector3)(ref val4)).sqrMagnitude > 0.01f))
			{
				y = anchor.eulerAngles.y;
			}
			else
			{
				Quaternion val5 = Quaternion.LookRotation(val4);
				y = ((Quaternion)(ref val5)).eulerAngles.y;
			}
			float yaw = y;
			placement = new BenchPlacement
			{
				Position = val2,
				Yaw = yaw
			};
			return true;
		}

		private static float SpongeHorizontalSqrDistance(Vector3 first, Vector3 second)
		{
			//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 = first.x - second.x;
			float num2 = first.z - second.z;
			return num * num + num2 * num2;
		}

		private static string ComposePlacementKey(Island island)
		{
			//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)
			string text = ((SaveManager.CurServerSave != null) ? SaveManager.CurServerSave.Name : "Current game");
			Vector3 position = ((Component)island).transform.position;
			return text + "|" + ((Object)island).name + "|" + position.x.ToString("0.0", CultureInfo.InvariantCulture) + "|" + position.z.ToString("0.0", CultureInfo.InvariantCulture);
		}

		private static bool AttemptGetBuiltInPlacement(Island island, out BenchPlacement placement)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)island).transform.position;
			if (Mathf.Abs(position.x - -200f) <= 2f && Mathf.Abs(position.z - 600f) <= 2f)
			{
				placement = new BenchPlacement
				{
					Position = new Vector3(-191.137f, 0.075f, 601.352f),
					Yaw = 180f
				};
				return true;
			}
			placement = null;
			return false;
		}

		private static void SetReelSpeeds()
		{
			if (ReelSpeedField == null)
			{
				return;
			}
			FishingRod[] array = Object.FindObjectsByType<FishingRod>();
			foreach (FishingRod val in array)
			{
				Player player = (((Object)(object)((Item)val).SyncedHolder != (Object)null) ? ((Item)val).SyncedHolder : ((Item)val).Holder);
				RodReelTierState rodReelTierState = ((Component)val).GetComponent<RodReelTierState>();
				if ((Object)(object)rodReelTierState == (Object)null)
				{
					rodReelTierState = ((Component)val).gameObject.AddComponent<RodReelTierState>();
					rodReelTierState.BaseSpeed = (float)ReelSpeedField.GetValue(val);
				}
				int num = ObtainLevel(player);
				if (rodReelTierState.AppliedLevel != num)
				{
					ReelSpeedField.SetValue(val, rodReelTierState.BaseSpeed * (1f + (float)num * 0.05f));
					rodReelTierState.AppliedLevel = num;
				}
			}
		}

		private static int SpongeSumThrough(int[] values, int level)
		{
			int num = 0;
			for (int i = 0; i < Mathf.Min(level, values.Length); i++)
			{
				num += values[i];
			}
			return num;
		}

		private static void Load()
		{
			Levels.Clear();
			if (_savedLevels == null || string.IsNullOrWhiteSpace(_savedLevels.Value))
			{
				return;
			}
			string[] array = _savedLevels.Value.Split(';');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(':');
				if (array2.Length == 2 && ulong.TryParse(array2[0], out var result) && int.TryParse(array2[1], out var result2))
				{
					Levels[result] = Mathf.Clamp(result2, 0, 25);
				}
			}
		}

		private static void Save()
		{
			if (_savedLevels != null)
			{
				_savedLevels.Value = string.Join(";", Levels.Select((KeyValuePair<ulong, int> pair) => pair.Key.ToString(CultureInfo.InvariantCulture) + ":" + pair.Value.ToString(CultureInfo.InvariantCulture)));
			}
		}

		private static void SpongeLoadPlacements()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			Placements.Clear();
			if (_savedPlacements == null || string.IsNullOrWhiteSpace(_savedPlacements.Value))
			{
				return;
			}
			string[] array = _savedPlacements.Value.Split(';');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(',');
				if (array2.Length != 5)
				{
					continue;
				}
				try
				{
					string key = Encoding.UTF8.GetString(Convert.FromBase64String(array2[0]));
					if (float.TryParse(array2[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && float.TryParse(array2[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array2[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3) && float.TryParse(array2[4], NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						Placements[key] = new BenchPlacement
						{
							Position = new Vector3(result, result2, result3),
							Yaw = result4
						};
					}
				}
				catch (FormatException)
				{
				}
			}
		}

		private static void SpongeSavePlacements()
		{
			if (_savedPlacements != null)
			{
				_savedPlacements.Value = string.Join(";", Placements.Select((KeyValuePair<string, BenchPlacement> pair) => Convert.ToBase64String(Encoding.UTF8.GetBytes(pair.Key)) + "," + pair.Value.Position.x.ToString("0.000", CultureInfo.InvariantCulture) + "," + pair.Value.Position.y.ToString("0.000", CultureInfo.InvariantCulture) + "," + pair.Value.Position.z.ToString("0.000", CultureInfo.InvariantCulture) + "," + pair.Value.Yaw.ToString("0.0", CultureInfo.InvariantCulture)));
			}
		}
	}
	internal static class RodSaleBonusService
	{
		[ThreadStatic]
		private static int _bonusPercent;

		public static void Begin(Player seller)
		{
			_bonusPercent = RodTierService.ObtainSaleBonus(seller);
		}

		public static void End()
		{
			_bonusPercent = 0;
		}

		public static int Apply(int original)
		{
			if (_bonusPercent <= 0 || original <= 0)
			{
				return original;
			}
			double value = (double)original * (1.0 + (double)_bonusPercent / 100.0);
			return (int)Math.Min(2147483647.0, Math.Round(value, MidpointRounding.AwayFromZero));
		}
	}
	internal sealed class FishScaleTracker : MonoBehaviour
	{
		public Vector3 OriginalScale;

		public bool LoadedFromSave;

		public bool WasHooked;

		public FishingRod CatcherRod;

		public Player Catcher;

		public string AnglerName;

		public bool NotificationShown;

		public bool RankingSubmitted;

		public string RankingEntryId;

		public bool RankingAnnouncementSent;

		public bool LuckRollApplied;

		public bool BossHealthInitialized;

		private Creature _creature;

		private bool? _isScalable;

		private const float ScaleEpsilon = 1E-06f;

		internal void InvalidateScalableCache()
		{
			_isScalable = null;
		}

		private void Awake()
		{
			//IL_0013: 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)
			_creature = ((Component)this).GetComponent<Creature>();
			OriginalScale = ((Component)this).transform.localScale;
		}

		private void LateUpdate()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_creature == (Object)null)
			{
				return;
			}
			if (!_isScalable.HasValue || !_isScalable.Value)
			{
				_isScalable = FishSizeService.HasScalableCatch(_creature);
			}
			if (_isScalable.Value)
			{
				Vector3 val = OriginalScale * FishSizeService.ObtainSize(_creature);
				Vector3 val2 = ((Component)this).transform.localScale - val;
				if (((Vector3)(ref val2)).sqrMagnitude > 1E-06f)
				{
					((Component)this).transform.localScale = val;
				}
			}
		}
	}
	public static class SizeCurve
	{
		public const float MinimumSize = 1f;

		public const float MaximumSize = 25f;

		private const double ProbabilityEpsilon = 1E-09;

		private static readonly double[] TailPercent = new double[5] { 30.0, 12.0, 1.0, 0.03, 0.0007 };

		private static readonly double[] Size = new double[5] { 1.01, 1.34, 2.0, 7.0, 25.0 };

		public static float Roll(int networkObjectId, int luck = 0)
		{
			return SpongeFromUnitRoll(new Random((networkObjectId * 397) ^ Environment.TickCount).NextDouble(), luck);
		}

		public static float SpongeFromUnitRoll(double roll, int luck = 0)
		{
			if (roll < 0.0 || roll >= 1.0)
			{
				throw new ArgumentOutOfRangeException("roll");
			}
			luck = Math.Max(0, luck);
			double num = Math.Max(0.05, 0.7 - (double)luck * 0.03);
			if (roll < num)
			{
				return 1f;
			}
			double num2 = (1.0 - num) / 0.3;
			double num3 = (1.0 - roll) * 100.0;
			double[] array = new double[5]
			{
				TailPercent[0] * num2,
				Math.Min(29.99 * num2, TailPercent[1] * (1.0 + (double)luck * 0.12)),
				TailPercent[2] * (1.0 + (double)luck * 0.25),
				TailPercent[3] * (1.0 + (double)luck * 0.9),
				TailPercent[4] * (1.0 + (double)luck * 1.2)
			};
			if (num3 <= array[^1] + 1E-09)
			{
				return 25f;
			}
			for (int i = 0; i < array.Length - 1; i++)
			{
				double num4 = array[i];
				double num5 = array[i + 1];
				if (!(num3 > num4 + 1E-09) && !(num3 <= num5 + 1E-09))
				{
					double num6 = (Math.Log(num4) - Math.Log(num3)) / (Math.Log(num4) - Math.Log(num5));
					return SpongeRoundInsideBand(Size[i] + (Size[i + 1] - Size[i]) * num6, Size[i], Size[i + 1] - 0.01);
				}
			}
			return 1f;
		}

		private static float SpongeRoundInsideBand(double value, double minimum, double maximum)
		{
			value = Math.Max(minimum, Math.Min(maximum, value));
			return (float)Math.Round(value, 2, MidpointRounding.AwayFromZero);
		}
	}
}
namespace SpongeMods.SpongeTweaks.Persistence
{
	internal static class BackupBrowser
	{
		private const float StarWidth = 26f;

		private const float TakenWidth = 116f;

		private const float NameWidth = 150f;

		private const float IslandWidth = 56f;

		private const float MoneyWidth = 74f;

		private const float PlayedWidth = 82f;

		private const float ModsWidth = 52f;

		private const float ActionsWidth = 112f;

		private static bool _failed;

		private static bool _built;

		private static ButtonManager _buttons;

		private static GameObject _infoHolder;

		private static Transform _screenParent;

		private static GameObject _buttonTemplate;

		private static GameObject _labelTemplate;

		private static GameObject _openButton;

		private static GameObject _panel;

		private static TMP_InputField _inputTemplate;

		private static Transform _content;

		private static TextMeshProUGUI _status;

		private static TextMeshProUGUI _pageLabel;

		private static string _selectedSave;

		private static bool _refreshing;

		private static int _page;

		private static string _armedPath;

		private static string _armedCompanion;

		public static void SpongeOnSaveSelected(string saveName)
		{
			if (_refreshing)
			{
				return;
			}
			_selectedSave = saveName;
			_page = 0;
			if (_failed)
			{
				return;
			}
			try
			{
				if (RequireBuilt())
				{
					_openButton.SetActive(!string.IsNullOrEmpty(saveName));
					Close();
				}
			}
			catch (Exception ex)
			{
				_failed = true;
				CompendiumPlugin.Log.LogError((object)("Backup UI failed, falling back to no UI: " + ex));
			}
		}

		public static void Close()
		{
			if (!_refreshing)
			{
				_armedPath = null;
				if ((Object)(object)_panel != (Object)null)
				{
					_panel.SetActive(false);
				}
				if ((Object)(object)_infoHolder != (Object)null && !string.IsNullOrEmpty(_selectedSave) && SaveManager.CurServerSave != null)
				{
					_infoHolder.SetActive(true);
				}
			}
		}

		public static void Tick()
		{
			if (!((Object)(object)_panel == (Object)null) && _panel.activeSelf && ((Object)(object)_infoHolder == (Object)null || !((Component)_infoHolder.transform.parent).gameObject.activeInHierarchy))
			{
				Close();
			}
		}

		public static void SpongeOnListRefreshed()
		{
			if (!_refreshing)
			{
				if (SaveManager.CurServerSave == null)
				{
					_selectedSave = null;
				}
				Close();
			}
		}

		private static bool RequireBuilt()
		{
			if (_built && (Object)(object)_openButton != (Object)null && (Object)(object)_panel != (Object)null)
			{
				return true;
			}
			_buttons = Object.FindAnyObjectByType<ButtonManager>();
			if ((Object)(object)_buttons == (Object)null)
			{
				return false;
			}
			object? obj = AccessTools.Field(typeof(ButtonManager), "_selectedSaveInfoHolder")?.GetValue(_buttons);
			_infoHolder = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)_infoHolder == (Object)null)
			{
				CompendiumPlugin.Log.LogError((object)"Could not find the save info panel in the load game screen.");
				_failed = true;
				return false;
			}
			_screenParent = _infoHolder.transform.parent;
			_buttonTemplate = LocateButtonTemplate(((Object)(object)_screenParent != (Object)null) ? _screenParent : _infoHolder.transform);
			if ((Object)(object)_buttonTemplate == (Object)null)
			{
				CompendiumPlugin.Log.LogError((object)"Could not find a menu button to copy the style from.");
				_failed = true;
				return false;
			}
			TextMeshProUGUI componentInChildren = _buttonTemplate.GetComponentInChildren<TextMeshProUGUI>(true);
			_labelTemplate = (((Object)(object)componentInChildren != (Object)null) ? ((Component)componentInChildren).gameObject : null);
			_openButton = SpongeCloneButton(_infoHolder.transform, "Backups", Open);
			SpongePlaceOpenButton();
			_panel = ComposePanel();
			_built = true;
			CompendiumPlugin.Log.LogInfo((object)"Backups button added to the load game screen.");
			return true;
		}

		private static void SpongePlaceOpenButton()
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			List<RectTransform> list = new List<RectTransform>();
			Transform val = null;
			Button[] componentsInChildren = _infoHolder.GetComponentsInChildren<Button>(true);
			foreach (Button val2 in componentsInChildren)
			{
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).gameObject == (Object)(object)_openButton || ((Object)val2).name.StartsWith("SpongeMods_"))
				{
					continue;
				}
				RectTransform component = ((Component)val2).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					if (val == null)
					{
						val = ((Transform)component).parent;
					}
					if ((Object)(object)((Transform)component).parent == (Object)(object)val)
					{
						list.Add(component);
					}
				}
			}
			if (list.Count < 2 || (Object)(object)val == (Object)null)
			{
				CompendiumPlugin.Log.LogWarning((object)($"Found {list.Count} existing button(s) on the save info panel, " + "falling back to a floating Backups button."));
				SpongeFloatOpenButton();
				return;
			}
			_openButton.transform.SetParent(val, false);
			GridLayoutGroup component2 = ((Component)val).GetComponent<GridLayoutGroup>();
			if ((Object)(object)component2 != (Object)null)
			{
				int num = list.Count + 1;
				float num2 = (component2.cellSize.x * (float)list.Count + component2.spacing.x * (float)(list.Count - 1) - component2.spacing.x * (float)(num - 1)) / (float)num;
				component2.constraint = (Constraint)1;
				component2.constraintCount = num;
				component2.cellSize = new Vector2(Mathf.Max(40f, num2), component2.cellSize.y);
				LayoutElement component3 = _openButton.GetComponent<LayoutElement>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.ignoreLayout = false;
				}
				CompendiumPlugin.Log.LogInfo((object)$"Backups button placed in the game's grid, {num} columns at {component2.cellSize.x:F0} wide.");
				return;
			}
			if ((Object)(object)((Component)val).GetComponent<HorizontalLayoutGroup>() != (Object)null)
			{
				LayoutElement obj = UiSupport.Ensure<LayoutElement>(_openButton);
				obj.ignoreLayout = false;
				obj.flexibleWidth = 1f;
				obj.minWidth = -1f;
				obj.preferredWidth = -1f;
				CompendiumPlugin.Log.LogInfo((object)"Backups button placed alongside Delete and Load in the game's horizontal layout.");
				return;
			}
			if ((Object)(object)((Component)val).GetComponent<LayoutGroup>() != (Object)null)
			{
				CompendiumPlugin.Log.LogWarning((object)"The save info buttons use a layout this feature cannot share, falling back to a floating Backups button.");
				SpongeFloatOpenButton();
				return;
			}
			list.Sort((RectTransform a, RectTransform b) => a.anchoredPosition.x.CompareTo(b.anchoredPosition.x));
			RectTransform val3 = list[0];
			RectTransform val4 = list[list.Count - 1];
			float x = val3.anchoredPosition.x;
			Rect rect = val3.rect;
			float num3 = x - ((Rect)(ref rect)).width * 0.5f;
			float x2 = val4.anchoredPosition.x;
			rect = val4.rect;
			float num4 = x2 + ((Rect)(ref rect)).width * 0.5f - num3;
			rect = val3.rect;
			float height = ((Rect)(ref rect)).height;
			int num5 = list.Count + 1;
			float value = SaveBackupModule.ButtonGap.Value;
			float num6 = (num4 - value * (float)(num5 - 1)) / (float)num5;
			if (num6 < 40f)
			{
				CompendiumPlugin.Log.LogWarning((object)"Not enough room beside Delete and Load, falling back to a floating Backups button.");
				SpongeFloatOpenButton();
				return;
			}
			RectTransform component4 = _openButton.GetComponent<RectTransform>();
			UiSupport.Ensure<LayoutElement>(_openButton).ignoreLayout = true;
			component4.anchorMin = val3.anchorMin;
			component4.anchorMax = val3.anchorMax;
			component4.pivot = val3.pivot;
			for (int num7 = 0; num7 < num5; num7++)
			{
				RectTransform obj2 = ((num7 < list.Count) ? list[num7] : component4);
				float num8 = num3 + num6 * 0.5f + (float)num7 * (num6 + value);
				obj2.sizeDelta = new Vector2(num6, height);
				obj2.anchoredPosition = new Vector2(num8, (num7 < list.Count) ? list[num7].anchoredPosition.y : val3.anchoredPosition.y);
			}
			CompendiumPlugin.Log.LogInfo((object)$"Backups button placed beside {list.Count} existing button(s); each is now {num6:F0} wide.");
		}

		private static void SpongeFloatOpenButton()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			UiSupport.Ensure<LayoutElement>(_openButton).ignoreLayout = true;
			RectTransform component = _buttonTemplate.GetComponent<RectTransform>();
			Rect rect;
			float num;
			if ((Object)(object)component != (Object)null)
			{
				rect = component.rect;
				if (((Rect)(ref rect)).height > 1f)
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).height;
					goto IL_0050;
				}
			}
			num = 44f;
			goto IL_0050;
			IL_0050:
			float num2 = num;
			float num3;
			if ((Object)(object)component != (Object)null)
			{
				rect = component.rect;
				if (((Rect)(ref rect)).width > 1f)
				{
					rect = component.rect;
					num3 = ((Rect)(ref rect)).width;
					goto IL_0086;
				}
			}
			num3 = 240f;
			goto IL_0086;
			IL_0086:
			float num4 = num3;
			RectTransform component2 = _openButton.GetComponent<RectTransform>();
			if (!((Object)(object)component2 == (Object)null))
			{
				component2.anchorMin = new Vector2(0.5f, 0f);
				component2.anchorMax = new Vector2(0.5f, 0f);
				component2.pivot = new Vector2(0.5f, 0f);
				component2.sizeDelta = new Vector2(num4, num2);
				component2.anchoredPosition = new Vector2(0f, num2 * 0.5f);
			}
		}

		private static GameObject LocateButtonTemplate(Transform root)
		{
			Button[] componentsInChildren = ((Component)root).GetComponentsInChildren<Button>(true);
			Button[] array = componentsInChildren;
			foreach (Button val in array)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).GetComponentInChildren<TextMeshProUGUI>(true) != (Object)null)
				{
					return ((Component)val).gameObject;
				}
			}
			if (componentsInChildren.Length != 0)
			{
				return ((Component)componentsInChildren[0]).gameObject;
			}
			return null;
		}

		private static Transform SpongePanelHost()
		{
			Transform result = (((Object)(object)_screenParent != (Object)null) ? _screenParent : _infoHolder.transform.parent);
			Canvas componentInParent = _infoHolder.GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return result;
			}
			return ((Component)(((Object)(object)componentInParent.rootCanvas != (Object)null) ? componentInParent.rootCanvas : componentInParent)).transform;
		}

		private static GameObject ComposePanel()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0050: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SpongeMods_BackupPanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(SpongePanelHost(), false);
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).localScale = Vector3.one;
			component.anchorMin = new Vector2(0.51f, 0.04f);
			component.anchorMax = new Vector2(0.98f, 0.96f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			TakeChrome(val.GetComponent<Image>());
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 4f;
			((LayoutGroup)obj).padding = new RectOffset(12, 12, 10, 10);
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			Transform val2 = MakeRow(val.transform, 34f);
			_pageLabel = MakeLabel(val2, "", 16f, (TextAlignmentOptions)513);
			if ((Object)(object)_pageLabel != (Object)null)
			{
				UiSupport.SetLayoutWidth(((Component)_pageLabel).gameObject, 56f, flexible: false);
				((Graphic)_pageLabel).color = UiSupport.WithAlpha(((Graphic)_pageLabel).color, 0.7f);
			}
			TextMeshProUGUI val3 = MakeLabel(val2, "Backups", 27f, (TextAlignmentOptions)514);
			if ((Object)(object)val3 != (Object)null)
			{
				UiSupport.SetLayoutWidth(((Component)val3).gameObject, 120f, flexible: true);
			}
			GameObject val4 = new GameObject("Spacer", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val2, false);
			UiSupport.SetLayoutWidth(val4, 56f, flexible: false);
			MakeDivider(val.transform);
			_status = MakeLabel(val.transform, "", 15f, (TextAlignmentOptions)514);
			if ((Object)(object)_status != (Object)null)
			{
				((Graphic)_status).color = UiSupport.WithAlpha(((Graphic)_status).color, 0.7f);
				((TMP_Text)_status).textWrappingMode = (TextWrappingModes)1;
				((TMP_Text)_status).overflowMode = (TextOverflowModes)0;
				LayoutElement component2 = ((Component)_status).GetComponent<LayoutElement>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.minWidth = -1f;
					component2.preferredWidth = -1f;
					component2.flexibleWidth = 1f;
					component2.minHeight = 20f;
					component2.preferredHeight = 20f;
				}
			}
			GameObject val5 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(val.transform, false);
			VerticalLayoutGroup obj2 = val5.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj2).spacing = 3f;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj2).childControlWidth = true;
			_content = val5.transform;
			val.SetActive(false);
			return val;
		}

		private static void Open()
		{
			if (!((Object)(object)_panel == (Object)null) && !string.IsNullOrEmpty(_selectedSave))
			{
				_page = 0;
				SpongeRefresh("");
				_panel.SetActive(true);
			}
		}

		private static void SpongeReloadAndReselect()
		{
			_refreshing = true;
			try
			{
				SaveManager.LoadAllServers();
				if (AccessTools.Field(typeof(ButtonManager), "_savedServerTexts")?.GetValue(_buttons) is List<TextMeshProUGUI> list)
				{
					foreach (TextMeshProUGUI item in list)
					{
						if ((Object)(object)item != (Object)null && ((Component)item).gameObject.activeInHierarchy && ((TMP_Text)item).text == _selectedSave)
						{
							_buttons.SelectServer(item);
							break;
						}
					}
				}
				if (SaveManager.CurServerSave == null)
				{
					SaveManager.SelectServer(_selectedSave);
				}
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not refresh the save list after restoring: " + ex));
			}
			finally
			{
				_refreshing = false;
			}
			if (SaveManager.CurServerSave == null)
			{
				CompendiumPlugin.Log.LogWarning((object)"The save list refreshed but no save is selected. Pick the save again before loading.");
			}
			if ((Object)(object)_panel != (Object)null)
			{
				_panel.SetActive(true);
			}
		}

		private static void SpongeRefresh(string status)
		{
			ResetChildren(_content);
			List<SnapshotInfo> list = SnapshotStore.List(_selectedSave);
			int num = Mathf.Max(1, SaveBackupModule.BackupsPerPage.Value);
			int num2 = Mathf.Max(1, Mathf.CeilToInt((float)list.Count / (float)num));
			_page = Mathf.Clamp(_page, 0, num2 - 1);
			int num3 = _page * num;
			int num4 = Mathf.Min(num3 + num, list.Count);
			if ((Object)(object)_pageLabel != (Object)null)
			{
				((TMP_Text)_pageLabel).text = ((list.Count > 0) ? $"{_page + 1}/{num2}" : "");
			}
			if (list.Count > 0)
			{
				Transform row = MakeRow(_content, 24f, (TextAnchor)3);
				FixedLabel(row, "", 26f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Taken", 116f, (TextAlignmentOptions)513, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Name", 150f, (TextAlignmentOptions)513, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Island", 56f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Money", 74f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Played", 82f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
				FixedLabel(row, "Mods", 52f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
				Spacer(row);
				FixedLabel(row, "", 112f, (TextAlignmentOptions)514, 13f, 0.55f, ellipsis: false);
			}
			for (int i = num3; i < num4; i++)
			{
				SnapshotInfo backup = list[i];
				Transform obj = MakeRow(_content, 30f, (TextAnchor)3);
				SpongeTintRow(obj, i);
				string when = backup.TakenUtc.ToLocalTime().ToString("MMM d  HH:mm");
				MakeStar(obj, backup);
				FixedLabel(obj, when, 116f, (TextAlignmentOptions)513, 16f, 1f, ellipsis: true);
				string text = ((!string.IsNullOrEmpty(backup.SaveLabel)) ? backup.SaveLabel : backup.SaveName);
				string text2 = SpongeKindLabel(backup.Kind);
				if (!string.IsNullOrEmpty(text2))
				{
					text = text + "  " + text2.Trim();
				}
				FixedLabel(obj, text, 150f, (TextAlignmentOptions)513, 16f, 0.85f, ellipsis: true);
				FixedLabel(obj, backup.Readable ? backup.Island.ToString() : "?", 56f, (TextAlignmentOptions)514, 16f, 0.78f, ellipsis: true);
				FixedLabel(obj, backup.Readable ? backup.Money.ToString() : "?", 74f, (TextAlignmentOptions)514, 16f, 0.78f, ellipsis: true);
				FixedLabel(obj, backup.Readable ? $"{(int)backup.Played.TotalHours}h {backup.Played.Minutes:D2}m" : "?", 82f, (TextAlignmentOptions)514, 16f, 0.78f, ellipsis: true);
				bool flag = backup.Companions.Count > 0;
				TextMeshProUGUI val = FixedLabel(obj, flag ? ("+" + backup.Companions.Count) : "", 52f, (TextAlignmentOptions)514, 16f, 0.78f, ellipsis: true);
				if ((Object)(object)val != (Object)null && flag)
				{
					((Graphic)val).raycastTarget = true;
					UiSupport.Ensure<HoverEffect>(((Component)val).gameObject).Text = () => SpongeCompanionTooltip(backup);
				}
				Spacer(obj);
				Transform obj2 = MakeRow(obj, 30f, (TextAnchor)5);
				UiSupport.SetLayoutWidth(((Component)obj2).gameObject, 112f, flexible: false);
				SpongeCloneIconButton(obj2, BackupIcons.Edit, "Edit", "Open this backup for editing", delegate
				{
					if (SaveRewriter.Open && SaveRewriter.Target == backup)
					{
						SaveRewriter.Cancel();
						SpongeRefresh("");
					}
					else
					{
						_armedPath = null;
						_armedCompanion = null;
						SaveRewriter.Begin(backup);
						SpongeRefresh(SaveRewriter.Open ? "" : "That backup could not be opened for editing.");
					}
				});
				SpongeCloneIconButton(obj2, BackupIcons.SpongeRestore, "SpongeRestore", "SpongeRestore this backup", delegate
				{
					RestoreOutcome restoreOutcome = SnapshotStore.SpongeRestore(backup);
					if (!restoreOutcome.Success)
					{
						SpongeRefresh("SpongeRestore failed, see the log.");
					}
					else
					{
						SpongeReloadAndReselect();
						SpongeRefresh(SpongeDescribeRestore(when, restoreOutcome));
					}
				});
				bool flag2 = _armedPath != null && _armedPath == backup.Path;
				GameObject button = SpongeCloneIconButton(obj2, BackupIcons.Delete, "Del", flag2 ? "Click again to delete" : "Delete this backup", delegate
				{
					if (_armedPath != backup.Path)
					{
						_armedPath = backup.Path;
						SpongeRefresh("Click the bin again to delete this backup.");
					}
					else
					{
						_armedPath = null;
						SnapshotStore.Delete(backup);
						SpongeRefresh("Deleted " + when + ".");
					}
				});
				if (flag2)
				{
					TintIcon(button);
				}
			}
			if (list.Count == 0)
			{
				MakeLabel(_content, "No backups yet for this save.", 19f, (TextAlignmentOptions)514);
			}
			if (list.Count > 0)
			{
				MakeDivider(_content);
				Transform val2 = MakeRow(_content, 32f);
				if (_page > 0)
				{
					UiSupport.SetLayoutWidth(SpongeCloneButton(val2, "<", delegate
					{
						_page--;
						_armedPath = null;
						SpongeRefresh("");
					}), 56f, flexible: false);
				}
				else
				{
					Pad(val2, 56f);
				}
				TextMeshProUGUI val3 = MakeLabel(val2, (list.Count == 1) ? "1 backup" : (list.Count + " backups"), 17f, (TextAlignmentOptions)514);
				if ((Object)(object)val3 != (Object)null)
				{
					UiSupport.SetLayoutWidth(((Component)val3).gameObject, 80f, flexible: true);
				}
				if (_page < num2 - 1)
				{
					UiSupport.SetLayoutWidth(SpongeCloneButton(val2, ">", delegate
					{
						_page++;
						_armedPath = null;
						SpongeRefresh("");
					}), 56f, flexible: false);
				}
				else
				{
					Pad(val2, 56f);
				}
			}
			if (SaveRewriter.Open)
			{
				PaintEditor();
			}
			MakeDivider(_content);
			Transform parent = MakeRow(_content, 38f);
			UiSupport.SetLayoutWidth(SpongeCloneButton(parent, "Back up now", delegate
			{
				_page = 0;
				_armedPath = null;
				SpongeRefresh(SnapshotStore.SpongeCapture(_selectedSave, SnapshotOrigin.Manual) ? "Backup taken." : "Could not take a backup, see the log.");
			}), 168f, flexible: false);
			UiSupport.SetLayoutWidth(SpongeCloneButton(parent, "Open folder", delegate
			{
				SpongeOpenFolder(SnapshotStore.SpongeFolderFor(_selectedSave));
				SpongeRefresh("Opened the backup folder.");
			}), 150f, flexible: false);
			UiSupport.SetLayoutWidth(SpongeCloneButton(parent, "Back", Close), 104f, flexible: false);
			if ((Object)(object)_status != (Object)null)
			{
				((TMP_Text)_status).text = (string.IsNullOrEmpty(status) ? "Restoring saves the current state first." : status);
			}
		}

		private static void PaintEditor()
		{
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			MutableSave draft = SaveRewriter.Draft;
			SnapshotInfo target = SaveRewriter.Target;
			MakeDivider(_content);
			Transform obj = MakeRow(_content, 30f, (TextAnchor)3);
			TextMeshProUGUI val = MakeLabel(obj, "Editing the backup from " + target.TakenUtc.ToLocalTime().ToString("MMM d  HH:mm"), 18f, (TextAlignmentOptions)513);
			if ((Object)(object)val != (Object)null)
			{
				UiSupport.SetLayoutWidth(((Component)val).gameObject, 240f, flexible: true);
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(draft.Playtime);
			FixedLabel(obj, (int)timeSpan.TotalHours + "h " + timeSpan.Minutes.ToString("D2") + "m played", 150f, (TextAlignmentOptions)516, 16f, 0.6f, ellipsis: true);
			FixedLabel(obj, (draft.Players == 1) ? "1 player" : (draft.Players + " players"), 110f, (TextAlignmentOptions)516, 16f, 0.6f, ellipsis: true);
			Transform row = MakeRow(_content, 36f, (TextAnchor)3);
			SpongeEditText(row, "Name", draft.Name, 200f, delegate(string value)
			{
				draft.Name = value;
			});
			SpongeEditNumber(row, "Money", draft.Money, 100f, delegate(int value)
			{
				draft.Money = value;
			});
			SpongeEditNumber(row, "Island", draft.Island, 74f, delegate(int value)
			{
				draft.Island = value;
			});
			SpongeEditNumber(row, "Furthest", draft.MaxIsland, 74f, delegate(int value)
			{
				draft.MaxIsland = value;
			});
			Transform obj2 = MakeRow(_content, 36f, (TextAnchor)3);
			SpongeEditNumber(obj2, "Motor", draft.MotorIndex, 74f, delegate(int value)
			{
				draft.MotorIndex = value;
			});
			SpongeEditNumber(obj2, "Boat skin", draft.BoatSkin, 74f, delegate(int value)
			{
				draft.BoatSkin = value;
			});
			TextMeshProUGUI val2 = MakeLabel(obj2, "Difficulty", 14f, (TextAlignmentOptions)516);
			if ((Object)(object)val2 != (Object)null)
			{
				UiSupport.SetLayoutWidth(((Component)val2).gameObject, 76f, flexible: false);
				((Graphic)val2).color = UiSupport.WithAlpha(((Graphic)val2).color, 0.6f);
			}
			GameObject obj3 = SpongeCloneButton(obj2, SaveRewriter.SpongeDifficultyName(draft.Difficulty), delegate
			{
				draft.Difficulty = (draft.Difficulty + 1) % 3;
				SpongeRefresh("");
			});
			UiSupport.SetLayoutWidth(obj3, 118f, flexible: false);
			SpongePinLabel(obj3, 1f);
			Spacer(obj2);
			Transform row2 = MakeRow(_content, 36f, (TextAnchor)3);
			SpongeEditToggle(row2, "Boat", draft.UnlockedBoat, delegate(bool value)
			{
				draft.UnlockedBoat = value;
			});
			SpongeEditToggle(row2, "Radar", draft.UnlockedBoatRadar, delegate(bool value)
			{
				draft.UnlockedBoatRadar = value;
			});
			SpongeEditToggle(row2, "Grill", draft.UnlockedGrill, delegate(bool value)
			{
				draft.UnlockedGrill = value;
			});
			SpongeEditToggle(row2, "Boss", draft.FinalBossKilled, delegate(bool value)
			{
				draft.FinalBossKilled = value;
			});
			SpongeEditToggle(row2, "Finished", draft.HasFinishedGame, delegate(bool value)
			{
				draft.HasFinishedGame = value;
			});
			Spacer(row2);
			PaintCompanions(target);
			Transform parent = MakeRow(_content, 38f, (TextAnchor)3);
			TextMeshProUGUI val3 = MakeLabel(parent, "Skins are stored in the game local file, which backups do not cover.", 13f, (TextAlignmentOptions)513);
			if ((Object)(object)val3 != (Object)null)
			{
				UiSupport.SetLayoutWidth(((Component)val3).gameObject, 200f, flexible: true);
				((Graphic)val3).color = UiSupport.WithAlpha(((Graphic)val3).color, 0.5f);
			}
			GameObject obj4 = SpongeCloneButton(parent, "Save changes", delegate
			{
				if (SaveRewriter.Commit(out var message))
				{
					SaveRewriter.Cancel();
				}
				SpongeRefresh(message);
			});
			UiSupport.SetLayoutWidth(obj4, 150f, flexible: false);
			SpongePinLabel(obj4, 1f);
			GameObject obj5 = SpongeCloneButton(parent, "Cancel", delegate
			{
				SaveRewriter.Cancel();
				SpongeRefresh("");
			});
			UiSupport.SetLayoutWidth(obj5, 104f, flexible: false);
			SpongePinLabel(obj5, 1f);
		}

		private static void PaintCompanions(SnapshotInfo target)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			MakeDivider(_content);
			Transform row = MakeRow(_content, 24f, (TextAnchor)3);
			FixedLabel(row, "Mod files", 200f, (TextAlignmentOptions)513, 13f, 0.55f, ellipsis: false);
			Spacer(row);
			if (target.Companions.Count == 0)
			{
				TextMeshProUGUI val = MakeLabel(MakeRow(_content, 26f, (TextAnchor)3), "This backup holds no mod files.", 14f, (TextAlignmentOptions)513);
				if ((Object)(object)val != (Object)null)
				{
					UiSupport.SetLayoutWidth(((Component)val).gameObject, 200f, flexible: true);
					((Graphic)val).color = UiSupport.WithAlpha(((Graphic)val).color, 0.5f);
				}
				return;
			}
			for (int i = 0; i < target.Companions.Count; i++)
			{
				CompanionEntry companion = target.Companions[i];
				if (companion == null)
				{
					continue;
				}
				Transform obj = MakeRow(_content, 28f, (TextAnchor)3);
				SpongeTintRow(obj, i);
				string text = (string.IsNullOrEmpty(companion.DisplayName) ? companion.Id : companion.DisplayName);
				FixedLabel(obj, text, 200f, (TextAlignmentOptions)513, 16f, 0.9f, ellipsis: true);
				FixedLabel(obj, companion.StoredName, 260f, (TextAlignmentOptions)513, 16f, 0.5f, ellipsis: true);
				FixedLabel(obj, SizeOf(target, companion), 84f, (TextAlignmentOptions)516, 16f, 0.5f, ellipsis: true);
				Spacer(obj);
				bool flag = _armedCompanion != null && _armedCompanion == companion.Id;
				GameObject button = SpongeCloneIconButton(obj, BackupIcons.Delete, "Del", flag ? "Click again to remove this file" : "Remove this mod file from the backup", delegate
				{
					if (_armedCompanion != companion.Id)
					{
						_armedCompanion = companion.Id;
						SpongeRefresh("Click the bin again to remove that mod file.");
					}
					else
					{
						_armedCompanion = null;
						SnapshotStore.DropCompanion(target, companion, out var message);
						SpongeRefresh(message);
					}
				});
				if (flag)
				{
					TintIcon(button);
				}
			}
		}

		private static string SizeOf(SnapshotInfo target, CompanionEntry record)
		{
			try
			{
				FileInfo fileInfo = new FileInfo(Path.Combine(target.Path, record.StoredName));
				if (!fileInfo.Exists)
				{
					return "missing";
				}
				return (fileInfo.Length < 1024) ? (fileInfo.Length + " B") : (((float)fileInfo.Length / 1024f).ToString("F1") + " KB");
			}
			catch
			{
				return "";
			}
		}

		private static string SpongeCompanionTooltip(SnapshotInfo info)
		{
			if (info == null || info.Companions.Count == 0)
			{
				return null;
			}
			string text = "Mod files in this backup";
			foreach (CompanionEntry companion in info.Companions)
			{
				string text2 = (string.IsNullOrEmpty(companion.DisplayName) ? companion.Id : companion.DisplayName);
				text = text + "\n  " + text2;
			}
			return text;
		}

		private static string SpongeKindLabel(SnapshotOrigin kind)
		{
			return kind switch
			{
				SnapshotOrigin.Manual => "  (manual)", 
				SnapshotOrigin.PreRestore => "  (before restore)", 
				_ => "", 
			};
		}

		private static string SpongeDescribeRestore(string when, RestoreOutcome outcome)
		{
			string text = "Restored " + when;
			if (outcome.CompanionsRestored > 0)
			{
				text = text + " with " + outcome.CompanionsRestored + " companion file(s)";
			}
			text += ".";
			if (outcome.Cleared.Count > 0)
			{
				text = text + " Cleared newer data for " + string.Join(", ", outcome.Cleared.ToArray()) + ".";
			}
			if (outcome.Missing.Count > 0)
			{
				text = text + " Data for " + string.Join(", ", outcome.Missing.ToArray()) + " was skipped because that feature is not loaded.";
			}
			return text;
		}

		private static void SpongeOpenFolder(string path)
		{
			try
			{
				Directory.CreateDirectory(path);
				Application.OpenURL(new Uri(path).AbsoluteUri);
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not open the backup folder: " + ex.Message));
			}
		}

		private static void MakeStar(Transform row, SnapshotInfo info)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			TextMeshProUGUI val = MakeLabel(row, "", 20f, (TextAlignmentOptions)514);
			if (!((Object)(object)val == (Object)null))
			{
				GameObject gameObject = ((Component)val).gameObject;
				((Object)gameObject).name = "Favourite";
				((Graphic)val).raycastTarget = true;
				SpongePaintStar(val, info.Favorite);
				UiSupport.SetLayoutWidth(gameObject, 26f, flexible: false);
				Button obj = UiSupport.Ensure<Button>(gameObject);
				((Selectable)obj).transition = (Transition)0;
				((Selectable)obj).targetGraphic = (Graphic)(object)val;
				((UnityEventBase)obj.onClick).RemoveAllListeners();
				((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
				{
					BackupFavorites.ToggleBinding(info);
					SpongeRefresh(info.Favorite ? "Pinned that backup, it will not be deleted automatically." : "Unpinned that backup.");
				});
				HoverEffect hoverEffect = UiSupport.Ensure<HoverEffect>(gameObject);
				hoverEffect.Scale = 1.18f;
				hoverEffect.Text = () => (!info.Favorite) ? "Click to keep this backup, so it is never deleted to make room." : "Favourite. This backup is kept until you unpin or delete it.";
			}
		}

		private static void SpongePaintStar(TextMeshProUGUI glyph, bool favorite)
		{
			//IL_0048: 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)
			((TMP_Text)glyph).text = (favorite ? "★" : "☆");
			((Graphic)glyph).color = (favorite ? new Color(1f, 0.83f, 0.2f, 1f) : new Color(1f, 1f, 1f, 0.45f));
		}

		private static TextMeshProUGUI MakeLabel(Transform parent, string text, float size, TextAlignmentOptions alignment)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			GameObject val;
			TextMeshProUGUI val2;
			if ((Object)(object)_labelTemplate != (Object)null)
			{
				val = Object.Instantiate<GameObject>(_labelTemplate, parent, false);
				UiSupport.StripLocalisation(val);
				val2 = val.GetComponent<TextMeshProUGUI>();
			}
			else
			{
				val = new GameObject("Label", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(parent, false);
				val2 = val.AddComponent<TextMeshProUGUI>();
			}
			((Object)val).name = "Label";
			val.SetActive(true);
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)val2).text = text;
				((TMP_Text)val2).fontSize = size;
				((TMP_Text)val2).alignment = alignment;
				((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
				((Graphic)val2).raycastTarget = false;
			}
			LayoutElement obj = UiSupport.Ensure<LayoutElement>(val);
			obj.minHeight = size + 4f;
			obj.preferredHeight = size + 4f;
			return val2;
		}

		private static GameObject SpongeCloneButton(Transform parent, string text, Action onClick)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			GameObject obj = Object.Instantiate<GameObject>(_buttonTemplate, parent, false);
			((Object)obj).name = "SpongeMods_Button_" + text;
			obj.SetActive(true);
			UiSupport.StripLocalisation(obj);
			Button component = obj.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				component.onClick = new ButtonClickedEvent();
				if (onClick != null)
				{
					((UnityEvent)component.onClick).AddListener((UnityAction)delegate
					{
						onClick();
					});
				}
				((Selectable)component).interactable = true;
			}
			TextMeshProUGUI componentInChildren = obj.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)componentInChildren).text = text;
			}
			return obj;
		}

		private static GameObject SpongeCloneIconButton(Transform parent, Sprite icon, string fallback, string tooltip, Action onClick)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = SpongeCloneButton(parent, ((Object)(object)icon != (Object)null) ? "" : fallback, onClick);
			((Object)val).name = "SpongeMods_Icon_" + fallback;
			UiSupport.SetLayoutWidth(val, 34f, flexible: false);
			if ((Object)(object)icon != (Object)null)
			{
				TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					GameObject val2 = new GameObject("Glyph", new Type[3]
					{
						typeof(RectTransform),
						typeof(CanvasRenderer),
						typeof(Image)
					});
					val2.transform.SetParent(val.transform, false);
					Image component = val2.GetComponent<Image>();
					component.sprite = icon;
					component.preserveAspect = true;
					((Graphic)component).raycastTarget = false;
					((Graphic)component).color = ((Graphic)componentInChildren).color;
					RectTransform component2 = val2.GetComponent<RectTransform>();
					component2.anchorMin = new Vector2(0.5f, 0.5f);
					component2.anchorMax = new Vector2(0.5f, 0.5f);
					component2.pivot = new Vector2(0.5f, 0.5f);
					component2.anchoredPosition = Vector2.zero;
					component2.sizeDelta = new Vector2(19f, 19f);
					((Component)componentInChildren).gameObject.SetActive(false);
				}
			}
			if (!string.IsNullOrEmpty(tooltip))
			{
				HoverEffect hoverEffect = UiSupport.Ensure<HoverEffect>(val);
				string captured = tooltip;
				hoverEffect.Text = () => captured;
			}
			return val;
		}

		private static void TintIcon(GameObject button)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			Image componentInChildren = button.GetComponentInChildren<Image>(true);
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.sprite != (Object)null)
			{
				((Graphic)componentInChildren).color = new Color(1f, 0.45f, 0.4f, 1f);
			}
		}

		private static void ResetChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
			}
		}

		private static void TakeChrome(Image target)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target == (Object)null))
			{
				Image val = (((Object)(object)_infoHolder != (Object)null) ? _infoHolder.GetComponent<Image>() : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.sprite != (Object)null)
				{
					target.sprite = val.sprite;
					target.type = val.type;
					((Graphic)target).color = ((Graphic)val).color;
					((Graphic)target).material = ((Graphic)val).material;
					target.pixelsPerUnitMultiplier = val.pixelsPerUnitMultiplier;
				}
				else
				{
					((Graphic)target).color = new Color(0.05f, 0.06f, 0.08f, 0.92f);
				}
			}
		}

		private static void MakeDivider(Transform parent)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Divider", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(1f, 1f, 1f, 0.18f);
			((Graphic)component).raycastTarget = false;
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.minHeight = 2f;
			obj.preferredHeight = 2f;
			obj.flexibleWidth = 1f;
		}

		private static void SpongeTintRow(Transform row, int index)
		{
			//IL_0040: 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)
			Image obj = UiSupport.Ensure<Image>(((Component)row).gameObject);
			((Graphic)obj).color = ((index % 2 == 0) ? new Color(1f, 1f, 1f, 0.05f) : new Color(0f, 0f, 0f, 0.12f));
			((Graphic)obj).raycastTarget = false;
		}

		private static Transform MakeRow(Transform parent, float height)
		{
			return MakeRow(parent, height, (TextAnchor)4);
		}

		private static Transform MakeRow(Transform parent, float height, TextAnchor alignment)
		{
			//IL_0018: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0066: 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)
			GameObject val = new GameObject("Row", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((LayoutGroup)obj).padding = new RectOffset(8, 8, 0, 0);
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((LayoutGroup)obj).childAlignment = alignment;
			LayoutElement obj2 = val.AddComponent<LayoutElement>();
			obj2.minHeight = height;
			obj2.preferredHeight = height;
			return val.transform;
		}

		private static TextMeshProUGUI FixedLabel(Transform row, string text, float width, TextAlignmentOptions alignment, float fontSize, float alpha, bool ellipsis)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = MakeLabel(row, text, fontSize, alignment);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			UiSupport.SetLayoutWidth(((Component)val).gameObject, width, flexible: false);
			((TMP_Text)val).textWrappingMode = (TextWrappingModes)0;
			if (ellipsis)
			{
				((TMP_Text)val).overflowMode = (TextOverflowModes)1;
			}
			((Graphic)val).color = UiSupport.WithAlpha(((Graphic)val).color, alpha);
			return val;
		}

		private static void SpongeEditText(Transform row, string caption, string value, float width, Action<string> onChange)
		{
			FixedLabel(row, caption, 76f, (TextAlignmentOptions)516, 14f, 0.6f, ellipsis: false);
			TMP_InputField obj = SpongeCloneInput(row, value, width, numeric: false);
			if (obj != null)
			{
				((UnityEvent<string>)(object)obj.onEndEdit).AddListener((UnityAction<string>)delegate(string typed)
				{
					onChange(typed);
				});
			}
		}

		private static void SpongeEditNumber(Transform row, string caption, int value, float width, Action<int> onChange)
		{
			FixedLabel(row, caption, 76f, (TextAlignmentOptions)516, 14f, 0.6f, ellipsis: false);
			TMP_InputField obj = SpongeCloneInput(row, value.ToString(), width, numeric: true);
			if (obj == null)
			{
				return;
			}
			((UnityEvent<string>)(object)obj.onEndEdit).AddListener((UnityAction<string>)delegate(string typed)
			{
				if (int.TryParse(typed, out var result))
				{
					onChange(result);
				}
			});
		}

		private static void SpongeEditToggle(Transform row, string caption, bool value, Action<bool> onChange)
		{
			GameObject obj = SpongeCloneButton(row, (value ? "[x] " : "[  ] ") + caption, delegate
			{
				onChange(!value);
				SpongeRefresh("");
			});
			UiSupport.SetLayoutWidth(obj, 132f, flexible: false);
			SpongePinLabel(obj, value ? 1f : 0.5f);
		}

		private static void SpongePinLabel(GameObject button, float alpha)
		{
			//IL_004a: 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)
			TextMeshProUGUI componentInChildren = button.GetComponentInChildren<TextMeshProUGUI>(true);
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				((TMP_Text)componentInChildren).enableAutoSizing = false;
				((TMP_Text)componentInChildren).fontSize = 17f;
				((TMP_Text)componentInChildren).fontSizeMin = 17f;
				((TMP_Text)componentInChildren).fontSizeMax = 17f;
				((TMP_Text)componentInChildren).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)componentInChildren).overflowMode = (TextOverflowModes)0;
				((Graphic)componentInChildren).color = UiSupport.WithAlpha(((Graphic)componentInChildren).color, alpha);
			}
		}

		private static TMP_InputField SpongeCloneInput(Transform parent, string value, float width, bool numeric)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_inputTemplate == (Object)null && (Object)(object)_buttons != (Object)null)
			{
				object? obj = AccessTools.Field(typeof(ButtonManager), "_serverNameInputField")?.GetValue(_buttons);
				_inputTemplate = (TMP_InputField)((obj is TMP_InputField) ? obj : null);
			}
			if ((Object)(object)_inputTemplate == (Object)null)
			{
				FixedLabel(parent, value, width, (TextAlignmentOptions)513, 16f, 1f, ellipsis: true);
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)_inputTemplate).gameObject, parent, false);
			((Object)val).name = "SpongeMods_Input";
			val.SetActive(true);
			UiSupport.StripLocalisation(val);
			TMP_InputField component = val.GetComponent<TMP_InputField>();
			if ((Object)(object)component != (Object)null)
			{
				component.onEndEdit = new SubmitEvent();
				component.onValueChanged = new OnChangeEvent();
				component.onValidateInput = null;
				component.inputValidator = null;
				component.characterValidation = (CharacterValidation)(numeric ? 2 : 0);
				component.contentType = (ContentType)9;
				component.lineType = (LineType)0;
				component.characterLimit = (numeric ? 9 : 40);
				component.text = value;
				((Selectable)component).interactable = true;
				if ((Object)(object)component.placeholder != (Object)null)
				{
					((Component)component.placeholder).gameObject.SetActive(false);
				}
			}
			TextMeshProUGUI[] componentsInChildren = val.GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI obj2 in componentsInChildren)
			{
				((TMP_Text)obj2).enableAutoSizing = false;
				((TMP_Text)obj2).fontSize = 17f;
				((TMP_Text)obj2).fontSizeMin = 17f;
				((TMP_Text)obj2).fontSizeMax = 17f;
				((TMP_Text)obj2).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)obj2).overflowMode = (TextOverflowModes)0;
				((TMP_Text)obj2).margin = new Vector4(6f, 0f, 6f, 0f);
			}
			Image obj3 = UiSupport.Ensure<Image>(val);
			((Behaviour)obj3).enabled = true;
			((Graphic)obj3).color = new Color(1f, 1f, 1f, 0.12f);
			UiSupport.SetLayoutWidth(val, width, flexible: false);
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.minHeight = 28f;
				component2.preferredHeight = 28f;
			}
			return component;
		}

		private static void Spacer(Transform row)
		{
			//IL_0018: 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_0035: Expected O, but got Unknown
			GameObject val = new GameObject("Gap", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(row, false);
			UiSupport.SetLayoutWidth(val, 0f, flexible: true);
		}

		private static void Pad(Transform row, float width)
		{
			//IL_0018: 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_0031: Expected O, but got Unknown
			GameObject val = new GameObject("Pad", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(row, false);
			UiSupport.SetLayoutWidth(val, width, flexible: false);
		}
	}
	internal static class BackupCaptureQueue
	{
		private static readonly Dictionary<string, bool> Pending = new Dictionary<string, bool>();

		private static bool _draining;

		internal static void Initialise()
		{
			Pending.Clear();
			_draining = false;
		}

		internal static void Queue(string saveName, bool automatic)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				return;
			}
			if (SaveBackupModule.DeferCapture == null || !SaveBackupModule.DeferCapture.Value)
			{
				SnapshotStore.SpongeCapture(saveName, automatic);
				return;
			}
			if (Pending.TryGetValue(saveName, out var value))
			{
				Pending[saveName] = value && automatic;
			}
			else
			{
				Pending[saveName] = automatic;
			}
			if (!_draining)
			{
				_draining = true;
				CompendiumPlugin.Run(DrainAtEndOfFrame());
			}
		}

		private static IEnumerator DrainAtEndOfFrame()
		{
			yield return (object)new WaitForEndOfFrame();
			SpongeDrainNow();
		}

		internal static void SpongeDrainNow()
		{
			if (Pending.Count == 0)
			{
				_draining = false;
				return;
			}
			Dictionary<string, bool> dictionary = new Dictionary<string, bool>(Pending);
			Pending.Clear();
			_draining = false;
			foreach (KeyValuePair<string, bool> item in dictionary)
			{
				SnapshotStore.SpongeCapture(item.Key, item.Value);
			}
		}
	}
	internal sealed class PinnedBackupsFile
	{
		[JsonProperty("Version")]
		public int FormatVersion = 1;

		[JsonProperty("Names")]
		public List<string> PinnedNames = new List<string>();
	}
	internal static class BackupFavorites
	{
		private const string FileName = "favorites.json";

		private static readonly Dictionary<string, HashSet<string>> BySave = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);

		private static string SpongePathFor(string saveName)
		{
			string text = SnapshotStore.SpongeFolderFor(saveName);
			if (!string.IsNullOrEmpty(text))
			{
				return Path.Combine(text, "favorites.json");
			}
			return null;
		}

		private static string KeyOf(SnapshotInfo info)
		{
			if (info == null || string.IsNullOrEmpty(info.Path))
			{
				return null;
			}
			return Path.GetFileName(info.Path.TrimEnd(Path.DirectorySeparatorChar));
		}

		private static HashSet<string> For(string saveName)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				return new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			}
			if (BySave.TryGetValue(saveName, out var value))
			{
				return value;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			try
			{
				string text = SpongePathFor(saveName);
				if (text != null && File.Exists(text))
				{
					PinnedBackupsFile pinnedBackupsFile = JsonConvert.DeserializeObject<PinnedBackupsFile>(File.ReadAllText(text));
					if (pinnedBackupsFile?.PinnedNames != null)
					{
						foreach (string pinnedName in pinnedBackupsFile.PinnedNames)
						{
							hashSet.Add(pinnedName);
						}
					}
				}
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not read the favourites list, starting empty: " + ex.Message));
			}
			BySave[saveName] = hashSet;
			return hashSet;
		}

		private static void Save(string saveName)
		{
			string text = SpongePathFor(saveName);
			if (text == null)
			{
				return;
			}
			try
			{
				Directory.CreateDirectory(SnapshotStore.SpongeFolderFor(saveName));
				PinnedBackupsFile pinnedBackupsFile = new PinnedBackupsFile();
				pinnedBackupsFile.PinnedNames.AddRange(For(saveName));
				string text2 = text + ".writing";
				File.WriteAllText(text2, JsonConvert.SerializeObject((object)pinnedBackupsFile, (Formatting)1));
				if (File.Exists(text))
				{
					File.Replace(text2, text, null);
				}
				else
				{
					File.Move(text2, text);
				}
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not write the favourites list: " + ex.Message));
			}
		}

		public static bool HasFavorite(SnapshotInfo info)
		{
			string text = KeyOf(info);
			if (text != null)
			{
				return For(info.SaveName).Contains(text);
			}
			return false;
		}

		public static bool ToggleBinding(SnapshotInfo info)
		{
			string text = KeyOf(info);
			if (text == null)
			{
				return false;
			}
			HashSet<string> hashSet = For(info.SaveName);
			bool flag;
			if (hashSet.Contains(text))
			{
				hashSet.Remove(text);
				flag = false;
			}
			else
			{
				hashSet.Add(text);
				flag = true;
			}
			Save(info.SaveName);
			info.Favorite = flag;
			CompendiumPlugin.Log.LogInfo((object)("Backup " + text + " is " + (flag ? "now a favourite and will not be deleted automatically" : "no longer a favourite") + "."));
			return flag;
		}

		public static void Forget(SnapshotInfo info)
		{
			string text = KeyOf(info);
			if (text != null && For(info.SaveName).Remove(text))
			{
				Save(info.SaveName);
			}
		}

		public static void SpongeInvalidate()
		{
			BySave.Clear();
		}
	}
	internal static class BackupIcons
	{
		private static readonly Dictionary<string, Sprite> Cache = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		public static Sprite Edit => Get("edit");

		public static Sprite SpongeRestore => Get("restore");

		public static Sprite Delete => Get("delete");

		private static Sprite Get(string name)
		{
			if (Cache.TryGetValue(name, out var value))
			{
				return value;
			}
			Sprite val = Load(name);
			Cache[name] = val;
			return val;
		}

		private static Sprite Load(string name)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				using Stream stream = typeof(BackupIcons).Assembly.GetManifestResourceStream("SpongeMods.SpongeTweaks." + name + ".png");
				if (stream == null)
				{
					CompendiumPlugin.Log.LogWarning((object)("Icon '" + name + "' is missing from the mod, so that button will show text instead."));
					return null;
				}
				byte[] array = new byte[stream.Length];
				int num;
				for (int i = 0; i < array.Length; i += num)
				{
					num = stream.Read(array, i, array.Length - i);
					if (num <= 0)
					{
						break;
					}
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					hideFlags = (HideFlags)61
				};
				if (!ImageConversion.LoadImage(val, array))
				{
					CompendiumPlugin.Log.LogWarning((object)("Icon '" + name + "' could not be decoded."));
					return null;
				}
				((Texture)val).filterMode = (FilterMode)1;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				Sprite obj = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
				((Object)obj).hideFlags = (HideFlags)61;
				return obj;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Icon '" + name + "' failed to load: " + ex.Message));
				return null;
			}
		}
	}
	internal sealed class HoverEffect : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public Func<string> Text;

		public float Scale = 1f;

		public float ScaleSpeed = 12f;

		private Vector3 _rest = Vector3.one;

		private bool _over;

		private bool _known;

		private void Awake()
		{
			SpongeRemember();
		}

		private void OnEnable()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			SpongeRemember();
			_over = false;
			((Component)this).transform.localScale = _rest;
		}

		private void SpongeRemember()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!_known)
			{
				_rest = ((Component)this).transform.localScale;
				_known = true;
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			_over = true;
			string text = Text?.Invoke();
			if (!string.IsNullOrEmpty(text))
			{
				Transform transform = ((Component)this).transform;
				BackupTooltip.Show(text, (RectTransform)(object)((transform is RectTransform) ? transform : null));
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			_over = false;
			BackupTooltip.Hide();
		}

		private void Update()
		{
			//IL_0024: 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_001c: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!Mathf.Approximately(Scale, 1f))
			{
				Vector3 val = (_over ? (_rest * Scale) : _rest);
				((Component)this).transform.localScale = Vector3.Lerp(((Component)this).transform.localScale, val, Time.unscaledDeltaTime * ScaleSpeed);
			}
		}

		private void OnDisable()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_over = false;
			((Component)this).transform.localScale = _rest;
			BackupTooltip.Hide();
		}
	}
	internal static class BackupTooltip
	{
		private static GameObject _root;

		private static RectTransform _rect;

		private static TextMeshProUGUI _text;

		public static void Reset()
		{
			_root = null;
			_rect = null;
			_text = null;
		}

		public static void Show(string body, RectTransform near)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)near == (Object)null)
			{
				return;
			}
			Canvas componentInParent = ((Component)near).GetComponentInParent<Canvas>();
			if (!((Object)(object)componentInParent == (Object)null))
			{
				Build(componentInParent);
				if (!((Object)(object)_root == (Object)null))
				{
					((TMP_Text)_text).text = body;
					_root.SetActive(true);
					_root.transform.SetAsLastSibling();
					LayoutRebuilder.ForceRebuildLayoutImmediate(_rect);
					Vector3[] array = (Vector3[])(object)new Vector3[4];
					near.GetWorldCorners(array);
					((Transform)_rect).position = array[1];
					Vector2 anchoredPosition = _rect.anchoredPosition;
					anchoredPosition.y += _rect.sizeDelta.y * 0.5f + 6f;
					_rect.anchoredPosition = anchoredPosition;
					Clamp(componentInParent);
				}
			}
		}

		public static void Hide()
		{
			if ((Object)(object)_root != (Object)null)
			{
				_root.SetActive(false);
			}
		}

		private static void Build(Canvas canvas)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root != (Object)null)
			{
				if ((Object)(object)_root.transform.parent != (Object)(object)((Component)canvas).transform)
				{
					_root.transform.SetParent(((Component)canvas).transform, false);
				}
				return;
			}
			_root = new GameObject("SpongeMods_Tooltip", new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ContentSizeFitter),
				typeof(VerticalLayoutGroup)
			});
			_root.transform.SetParent(((Component)canvas).transform, false);
			_root.layer = ((Component)canvas).gameObject.layer;
			_rect = _root.GetComponent<RectTransform>();
			_rect.pivot = new Vector2(0f, 0f);
			Image component = _root.GetComponent<Image>();
			((Graphic)component).color = new Color(0.05f, 0.05f, 0.07f, 0.94f);
			((Graphic)component).raycastTarget = false;
			VerticalLayoutGroup component2 = _root.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component2).padding = new RectOffset(10, 10, 6, 6);
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			ContentSizeFitter component3 = _root.GetComponent<ContentSizeFitter>();
			component3.horizontalFit = (FitMode)2;
			component3.verticalFit = (FitMode)2;
			GameObject val = new GameObject("Text", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(_root.transform, false);
			val.layer = _root.layer;
			_text = val.AddComponent<TextMeshProUGUI>();
			TextMeshProUGUI componentInChildren = ((Component)canvas).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null && (Object)(object)((TMP_Text)componentInChildren).font != (Object)null)
			{
				((TMP_Text)_text).font = ((TMP_Text)componentInChildren).font;
				((TMP_Text)_text).fontSharedMaterial = ((TMP_Text)componentInChildren).fontSharedMaterial;
			}
			((TMP_Text)_text).fontSize = 15f;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)257;
			((Graphic)_text).raycastTarget = false;
			((TMP_Text)_text).textWrappingMode = (TextWrappingModes)0;
			_root.SetActive(false);
		}

		private static void Clamp(Canvas canvas)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)canvas).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (!((Object)(object)val == (Object)null))
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				_rect.GetWorldCorners(array);
				Vector3[] array2 = (Vector3[])(object)new Vector3[4];
				val.GetWorldCorners(array2);
				float num = 0f;
				float num2 = 0f;
				if (array[2].x > array2[2].x)
				{
					num = array2[2].x - array[2].x;
				}
				if (array[0].x < array2[0].x)
				{
					num = array2[0].x - array[0].x;
				}
				if (array[1].y > array2[1].y)
				{
					num2 = array2[1].y - array[1].y;
				}
				RectTransform rect = _rect;
				((Transform)rect).position = ((Transform)rect).position + new Vector3(num, num2, 0f);
			}
		}
	}
	public sealed class CompanionSource
	{
		public string Id;

		public string DisplayName;

		public Func<string, string> PathForSave;
	}
	public sealed class CompanionEntry
	{
		public string Id = "";

		public string DisplayName = "";

		public string StoredName = "";
	}
	public static class CompanionRegistry
	{
		private static readonly Dictionary<string, CompanionSource> Providers = new Dictionary<string, CompanionSource>(StringComparer.OrdinalIgnoreCase);

		public static IEnumerable<CompanionSource> All => Providers.Values;

		public static int Count => Providers.Count;

		public static void SpongeRegister(string id, string displayName, Func<string, string> pathForSave)
		{
			if (string.IsNullOrEmpty(id) || pathForSave == null)
			{
				CompendiumPlugin.Log.LogWarning((object)"A companion file was registered with no id or no path builder; ignoring it.");
				return;
			}
			string text = SpongeSanitiseId(id);
			Providers[text] = new CompanionSource
			{
				Id = text,
				DisplayName = (string.IsNullOrEmpty(displayName) ? text : displayName),
				PathForSave = pathForSave
			};
			CompendiumPlugin.Log.LogInfo((object)("Companion registered: " + displayName + " (" + text + "). Its files will be included in every snapshot."));
		}

		public static void SpongeUnregister(string id)
		{
			if (!string.IsNullOrEmpty(id) && Providers.Remove(SpongeSanitiseId(id)))
			{
				CompendiumPlugin.Log.LogInfo((object)("Companion unregistered: " + id));
			}
		}

		public static bool HasRegistered(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				return Providers.ContainsKey(SpongeSanitiseId(id));
			}
			return false;
		}

		public static CompanionSource Get(string id)
		{
			if (string.IsNullOrEmpty(id))
			{
				return null;
			}
			if (!Providers.TryGetValue(SpongeSanitiseId(id), out var value))
			{
				return null;
			}
			return value;
		}

		public static string LookupPath(CompanionSource provider, string saveName)
		{
			if (provider == null || provider.PathForSave == null || string.IsNullOrEmpty(saveName))
			{
				return null;
			}
			try
			{
				return provider.PathForSave(saveName);
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Companion '" + provider.Id + "' threw while resolving its path: " + ex));
				return null;
			}
		}

		public static string SpongeSanitiseSaveName(string saveName)
		{
			return SnapshotStore.SpongeSanitiseSaveName(saveName);
		}

		private static string SpongeSanitiseId(string id)
		{
			char[] array = id.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (!char.IsLetterOrDigit(array[i]))
				{
					array[i] = '_';
				}
			}
			return new string(array).ToLowerInvariant();
		}
	}
	internal sealed class DroppedItemModule : FeatureModule
	{
		internal static ConfigEntry<bool> VerboseLogging;

		public override string DisplayName => "Sticky Items";

		public override void BindConfiguration(ConfigFile config)
		{
			ModuleEnabled = config.Bind<bool>("Sticky Items", "Enabled", true, "Persist dropped items and dead fish on the ground across save/load.");
			VerboseLogging = config.Bind<bool>("Sticky Items", "VerboseLogging", false, "Log every item captured, rejected and restored. Useful for bug reports, noisy otherwise.");
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(StickyItemsServerLoadedPatch));
			harmony.PatchAll(typeof(StickyItemsSaveServerPatch));
			harmony.PatchAll(typeof(StickyItemsStartClientPatch));
			harmony.PatchAll(typeof(StickyItemsStopClientPatch));
			CompendiumPlugin.Log.LogInfo((object)"Sticky Items active: dropped items and fish will persist across saves.");
		}
	}
	[Serializable]
	internal sealed class GroundItemFile
	{
		public List<SavedItem> Items = new List<SavedItem>();

		public List<Vector3> Positions = new List<Vector3>();

		public List<Quaternion> Rotations = new List<Quaternion>();
	}
	internal static class GroundItemStore
	{
		private static readonly MethodInfo ItemToSavedItemMethod = AccessTools.Method(typeof(SaveManager), "ItemToSavedItem", (Type[])null, (Type[])null);

		private static readonly FieldInfo ItemsSpawnedField = AccessTools.Field(typeof(ItemSpawner), "_itemsSpawned");

		private static bool _capturedForStop;

		private static bool _isHostingSession;

		private static string _cachedSaveName;

		private static bool _hasRestoredThisSession;

		private static readonly Dictionary<Item, SavedItem> LastGoodStates = new Dictionary<Item, SavedItem>();

		private static void Trace(string message)
		{
			if (DroppedItemModule.VerboseLogging != null && DroppedItemModule.VerboseLogging.Value)
			{
				CompendiumPlugin.Log.LogInfo((object)message);
			}
		}

		internal static string ObtainFilePath(string saveName)
		{
			return Path.Combine(Application.persistentDataPath, "Saves", saveName + "_stickyitems.json");
		}

		internal static bool HasFallenItem(Item item, out string reason, bool skipSyncVarChecks = false)
		{
			if (!Object.op_Implicit((Object)(object)item))
			{
				reason = "null/destroyed";
				return false;
			}
			if (item.IsDestroying)
			{
				reason = "IsDestroying";
				return false;
			}
			if (Object.op_Implicit((Object)(object)item.SyncedHolder))
			{
				reason = "SyncedHolder=" + (object)item.SyncedHolder;
				return false;
			}
			if (Object.op_Implicit((Object)(object)item.Holder))
			{
				reason = "Holder=" + (object)item.Holder;
				return false;
			}
			if (Object.op_Implicit((Object)(object)item.BirdHolder))
			{
				reason = "BirdHolder";
				return false;
			}
			if (Object.op_Implicit((Object)(object)item.DeadPlayer))
			{
				reason = "DeadPlayer";
				return false;
			}
			if (item.IsInInventory)
			{
				reason = "IsInInventory";
				return false;
			}
			if (!skipSyncVarChecks && Object.op_Implicit((Object)(object)item.Creature) && !item.Creature.IsDead)
			{
				reason = "Creature alive";
				return false;
			}
			reason = null;
			return true;
		}

		internal static SavedItem SpongeCaptureItem(Item item)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			return (SavedItem)ItemToSavedItemMethod.Invoke(null, new object[2]
			{
				(byte)0,
				item
			});
		}

		internal static HashSet<Item> ObtainSpawnerManagedItems()
		{
			HashSet<Item> hashSet = new HashSet<Item>();
			ItemSpawner[] array = Object.FindObjectsByType<ItemSpawner>((FindObjectsInactive)0);
			foreach (ItemSpawner obj in array)
			{
				if (!(ItemsSpawnedField.GetValue(obj) is List<Item> list))
				{
					continue;
				}
				foreach (Item item in list)
				{
					if (Object.op_Implicit((Object)(object)item))
					{
						hashSet.Add(item);
					}
				}
			}
			return hashSet;
		}

		internal static void SpongeResetStopFlag()
		{
			_capturedForStop = false;
		}

		internal static bool SpongeConsumeStopFlag()
		{
			bool capturedForStop = _capturedForStop;
			_capturedForStop = false;
			return capturedForStop;
		}

		internal static void SpongeCaptureBeforeStop()
		{
			_capturedForStop = true;
			SpongeSaveNow("OnStopClient-prefix", trustCachedHostFlag: true);
		}

		internal static void ResetHostingSession()
		{
			_isHostingSession = false;
			_cachedSaveName = null;
			LastGoodStates.Clear();
		}

		internal static void SpongeResetRestoreFlag()
		{
			_hasRestoredThisSession = false;
		}

		internal static void SpongeMarkHostingSession()
		{
			_isHostingSession = true;
			if (SaveManager.CurServerSave != null)
			{
				_cachedSaveName = SaveManager.CurServerSave.Name;
			}
		}

		internal static void AttemptRestore(string source)
		{
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (_hasRestoredThisSession)
			{
				return;
			}
			if (SaveManager.CurServerSave == null)
			{
				Trace("Sticky Items [" + source + "]: restore skipped, CurServerSave is null.");
				return;
			}
			if (!Object.op_Implicit((Object)(object)Server.Instance) || !((NetworkBehaviour)Server.Instance).IsServerInitialized)
			{
				Trace("Sticky Items [" + source + "]: restore skipped, server is not initialised.");
				return;
			}
			if (!Object.op_Implicit((Object)(object)ItemManager.Instance))
			{
				Trace("Sticky Items [" + source + "]: restore skipped, ItemManager.Instance is null.");
				return;
			}
			_hasRestoredThisSession = true;
			SpongeMarkHostingSession();
			string text = ObtainFilePath(SaveManager.CurServerSave.Name);
			if (!File.Exists(text))
			{
				Trace("Sticky Items [" + source + "]: no save file at '" + text + "'.");
				return;
			}
			try
			{
				GroundItemFile groundItemFile = JsonUtility.FromJson<GroundItemFile>(File.ReadAllText(text));
				if (groundItemFile?.Items == null)
				{
					return;
				}
				int num = 0;
				for (int i = 0; i < groundItemFile.Items.Count; i++)
				{
					SavedItem val = groundItemFile.Items[i];
					if (val == null || !val.Exists)
					{
						continue;
					}
					Item val2 = GameInfo.IDToItem(val.ItemID);
					if (!Object.op_Implicit((Object)(object)val2))
					{
						continue;
					}
					Item val3 = ItemManager.Instance.SpawnNewItem(val2, groundItemFile.Positions[i], groundItemFile.Rotations[i]);
					if (Object.op_Implicit((Object)(object)val3))
					{
						if (Object.op_Implicit((Object)(object)val3.Creature))
						{
							val3.Creature.ServerKillOnSpawn();
						}
						val3.LoadFromSave(val);
						val3.ServerSetSkin(val.SkinIndex);
						num++;
					}
				}
				CompendiumPlugin.Log.LogInfo((object)$"Sticky Items [{source}]: restored {num} of {groundItemFile.Items.Count} saved items.");
			}
			catch (Exception arg)
			{
				CompendiumPlugin.Log.LogError((object)$"Sticky Items [{source}]: AttemptRestore threw - {arg}");
			}
		}

		internal static void SpongeSaveNow(string source, bool trustCachedHostFlag = false)
		{
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (trustCachedHostFlag ? _isHostingSession : (Object.op_Implicit((Object)(object)Server.Instance) && ((NetworkBehaviour)Server.Instance).IsServerInitialized));
			string text = (trustCachedHostFlag ? _cachedSaveName : SaveManager.CurServerSave?.Name);
			if (text == null || !flag)
			{
				Trace(string.Format("Sticky Items [{0}]: skipped (saveName={1}, isHost={2}).", source, text ?? "null", flag));
				return;
			}
			if (!trustCachedHostFlag)
			{
				_isHostingSession = true;
				_cachedSaveName = text;
			}
			bool flag2 = trustCachedHostFlag;
			try
			{
				GroundItemFile groundItemFile = new GroundItemFile();
				HashSet<Item> hashSet = new HashSet<Item>();
				HashSet<Item> hashSet2 = ObtainSpawnerManagedItems();
				int num = 0;
				foreach (Item value2 in ItemManager.Items.Values)
				{
					if ((Object)(object)value2 != (Object)null && !hashSet.Add(value2))
					{
						continue;
					}
					num++;
					if ((Object)(object)value2 != (Object)null && hashSet2.Contains(value2))
					{
						Trace("Sticky Items [" + source + "]: rejected '" + ((Object)value2).name + "' - spawner managed.");
						continue;
					}
					SavedItem value = null;
					bool flag3 = flag2 && Object.op_Implicit((Object)(object)value2) && LastGoodStates.TryGetValue(value2, out value);
					if (!HasFallenItem(value2, out var reason, flag3))
					{
						Trace("Sticky Items [" + source + "]: rejected '" + (Object.op_Implicit((Object)(object)value2) ? ((Object)value2).name : "null") + "' - " + reason);
						continue;
					}
					if (!flag3)
					{
						value = SpongeCaptureItem(value2);
						LastGoodStates[value2] = value;
					}
					groundItemFile.Items.Add(value);
					groundItemFile.Positions.Add(((Component)value2).transform.position);
					groundItemFile.Rotations.Add(((Component)value2).transform.rotation);
					Trace($"Sticky Items [{source}]: captured '{((Object)value2).name}' at {((Component)value2).transform.position} " + (flag3 ? "(cached state)" : "(live state)"));
				}
				string path = ObtainFilePath(text);
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllText(path, JsonUtility.ToJson((object)groundItemFile));
				CompendiumPlugin.Log.LogInfo((object)$"Sticky Items [{source}]: wrote {groundItemFile.Items.Count} of {num} registered items.");
			}
			catch (Exception arg)
			{
				CompendiumPlugin.Log.LogError((object)$"Sticky Items [{source}]: SpongeSaveNow threw - {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SaveManager), "OnServerLoaded")]
	internal static class StickyItemsServerLoadedPatch
	{
		private static void Postfix()
		{
			GroundItemStore.SpongeResetStopFlag();
			GroundItemStore.ResetHostingSession();
			GroundItemStore.AttemptRestore("OnServerLoaded");
		}
	}
	[HarmonyPatch(typeof(SaveManager), "SaveServer")]
	internal static class StickyItemsSaveServerPatch
	{
		private static void Postfix()
		{
			if (!GroundItemStore.SpongeConsumeStopFlag())
			{
				GroundItemStore.SpongeSaveNow("SaveServer-postfix");
			}
		}
	}
	[HarmonyPatch(typeof(ItemManager), "OnStartClient")]
	internal static class StickyItemsStartClientPatch
	{
		private static void Postfix()
		{
			GroundItemStore.AttemptRestore("ItemManager.OnStartClient");
		}
	}
	[HarmonyPatch(typeof(ItemManager), "OnStopClient")]
	internal static class StickyItemsStopClientPatch
	{
		private static void Prefix()
		{
			GroundItemStore.SpongeCaptureBeforeStop();
		}

		private static void Postfix()
		{
			GroundItemStore.ResetHostingSession();
			GroundItemStore.SpongeResetRestoreFlag();
		}
	}
	internal sealed class SaveBackupModule : FeatureModule
	{
		internal static ConfigEntry<bool> BackupOnSave;

		internal static ConfigEntry<bool> BackupOnLoad;

		internal static ConfigEntry<bool> SkipUnchanged;

		internal static ConfigEntry<int> MaxAutomaticBackups;

		internal static ConfigEntry<int> MaxPreRestoreBackups;

		internal static ConfigEntry<int> BackupsPerPage;

		internal static ConfigEntry<float> ButtonGap;

		internal static ConfigEntry<bool> DeferCapture;

		public override string DisplayName => "Save Backups";

		public override bool WantsUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			ModuleEnabled = config.Bind<bool>("Save Backups", "Enabled", true, "Keep versioned backups of your saves and add a Backups button to the load screen.");
			BackupOnSave = config.Bind<bool>("Save Backups", "BackupOnSave", true, "Take a backup every time the game saves, which includes the five minute autosave.");
			BackupOnLoad = config.Bind<bool>("Save Backups", "BackupOnLoad", true, "Take a backup when a save is loaded, so you always have the state you started a session with.");
			SkipUnchanged = config.Bind<bool>("Save Backups", "SkipUnchanged", true, "Do not write an automatic backup when the save and its companion files are identical to the newest snapshot already stored.");
			MaxAutomaticBackups = config.Bind<int>("Save Backups", "MaxAutomaticBackups", 10, "How many automatic backups to keep per save. The oldest are deleted beyond this. Manual backups are never pruned. 0 keeps everything.");
			MaxPreRestoreBackups = config.Bind<int>("Save Backups", "MaxPreRestoreBackups", 5, "How many of the safety snapshots taken just before a restore to keep per save. These are made automatically every time you restore, so they are pruned like automatic backups rather than kept forever. 0 keeps them all.");
			BackupsPerPage = config.Bind<int>("Save Backups", "BackupsPerPage", 10, "How many backups to list per page. Use the arrows at the bottom of the panel to reach older ones.");
			ButtonGap = config.Bind<float>("Save Backups", "ButtonGap", 14f, "Gap in pixels between Delete, Load and Backups on the save info panel. The three share the width the game gave to two, so raise this if they look cramped.");
			DeferCapture = config.Bind<bool>("Save Backups", "DeferCapture", true, "Wait until the end of the frame before copying files. Other features write their own save data from the same game event and the order they run in is not guaranteed, so waiting makes sure a snapshot holds the save and its companion files from the same moment. Only turn this off to diagnose a problem.");
		}

		public override void Initialise(Harmony harmony)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			BackupCaptureQueue.Initialise();
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ButtonManager), "SelectServer", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SaveBackupPatches), "SelectServerPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(SaveManager), "SaveServer", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SaveBackupPatches), "SaveServerPostfix", (Type[])null)
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(SaveManager), "SelectServer", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SaveBackupPatches), "SelectedForLoadPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(SaveManager), "OnApplicationQuit", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SaveBackupPatches), "ApplicationQuitPostfix", (Type[])null)
			{
				priority = 0
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			harmony.Patch((MethodBase)AccessTools.Method(typeof(ButtonManager), "UpdateSavedServerButtons", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(SaveBackupPatches), "ListRefreshedPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			CompendiumPlugin.Log.LogInfo((object)("Save Backups active. Backups are kept in " + SnapshotStore.Root));
		}

		public override void Tick()
		{
			BackupBrowser.Tick();
		}
	}
	internal static class SaveBackupPatches
	{
		internal static void SelectServerPostfix(TextMeshProUGUI text)
		{
			BackupBrowser.SpongeOnSaveSelected(((Object)(object)text != (Object)null) ? ((TMP_Text)text).text : null);
		}

		internal static void ApplicationQuitPostfix()
		{
			BackupCaptureQueue.SpongeDrainNow();
		}

		internal static void ListRefreshedPostfix()
		{
			BackupBrowser.SpongeOnListRefreshed();
		}

		internal static void SaveServerPostfix()
		{
			if (SaveBackupModule.BackupOnSave.Value && SaveManager.CurServerSave != null)
			{
				BackupCaptureQueue.Queue(SaveManager.CurServerSave.Name, automatic: true);
			}
		}

		internal static void SelectedForLoadPostfix()
		{
			if (SaveBackupModule.BackupOnLoad.Value && SaveManager.CurServerSave != null)
			{
				BackupCaptureQueue.Queue(SaveManager.CurServerSave.Name, automatic: true);
			}
		}
	}
	internal sealed class MutableSave
	{
		public string Name = "";

		public int Money;

		public int Island = 1;

		public int MaxIsland = 1;

		public int Difficulty = 1;

		public int MotorIndex;

		public int BoatSkin;

		public bool UnlockedBoat;

		public bool UnlockedBoatRadar;

		public bool UnlockedGrill;

		public bool FinalBossKilled;

		public bool HasFinishedGame;

		public float Playtime;

		public int Players;
	}
	internal static class SaveRewriter
	{
		public static SnapshotInfo Target { get; private set; }

		public static MutableSave Draft { get; private set; }

		public static bool Open
		{
			get
			{
				if (Target != null)
				{
					return Draft != null;
				}
				return false;
			}
		}

		public static void Begin(SnapshotInfo backup)
		{
			Target = null;
			Draft = null;
			if (backup != null)
			{
				MutableSave mutableSave = Read(backup);
				if (mutableSave != null)
				{
					Target = backup;
					Draft = mutableSave;
				}
			}
		}

		public static void Cancel()
		{
			Target = null;
			Draft = null;
		}

		private static MutableSave Read(SnapshotInfo backup)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected I4, but got Unknown
			try
			{
				string saveFilePath = backup.SaveFilePath;
				if (!File.Exists(saveFilePath))
				{
					CompendiumPlugin.Log.LogWarning((object)"That backup has no save file to edit.");
					return null;
				}
				ServerSaveObject val = JsonUtility.FromJson<ServerSaveObject>(File.ReadAllText(saveFilePath));
				if (val == null)
				{
					CompendiumPlugin.Log.LogWarning((object)"That backup's save file could not be read, so it cannot be edited.");
					return null;
				}
				return new MutableSave
				{
					Name = (val.Name ?? ""),
					Money = val.Money,
					Island = val.SpawnedIsland + 1,
					MaxIsland = val.MaxIsland + 1,
					Difficulty = (int)val.Difficulty,
					MotorIndex = val.MotorIndex,
					BoatSkin = val.BoatSkin,
					UnlockedBoat = val.UnlockedBoat,
					UnlockedBoatRadar = val.UnlockedBoatRadar,
					UnlockedGrill = val.UnlockedGrill,
					FinalBossKilled = val.FinalBossKilled,
					HasFinishedGame = val.HasFinishedGame,
					Playtime = val.Playtime,
					Players = (val.Players?.Count ?? 0)
				};
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not read that backup for editing: " + ex));
				return null;
			}
		}

		public static bool Commit(out string message)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			message = "";
			if (!Open)
			{
				message = "Nothing is being edited.";
				return false;
			}
			string saveFilePath = Target.SaveFilePath;
			try
			{
				ServerSaveObject val = JsonUtility.FromJson<ServerSaveObject>(File.ReadAllText(saveFilePath));
				if (val == null)
				{
					message = "That save could not be read, nothing was changed.";
					return false;
				}
				val.Name = (string.IsNullOrEmpty(Draft.Name) ? val.Name : Draft.Name);
				val.Money = Mathf.Max(0, Draft.Money);
				val.SpawnedIsland = (byte)Mathf.Clamp(Draft.Island - 1, 0, 255);
				val.MaxIsland = (byte)Mathf.Clamp(Draft.MaxIsland - 1, 0, 255);
				val.Difficulty = (Difficulty)Mathf.Clamp(Draft.Difficulty, 0, 2);
				val.MotorIndex = (byte)Mathf.Clamp(Draft.MotorIndex, 0, 255);
				val.BoatSkin = (byte)Mathf.Clamp(Draft.BoatSkin, 0, 255);
				val.UnlockedBoat = Draft.UnlockedBoat;
				val.UnlockedBoatRadar = Draft.UnlockedBoatRadar;
				val.UnlockedGrill = Draft.UnlockedGrill;
				val.FinalBossKilled = Draft.FinalBossKilled;
				val.HasFinishedGame = Draft.HasFinishedGame;
				string text = JsonUtility.ToJson((object)val);
				if (string.IsNullOrEmpty(text) || text.Length < 20)
				{
					message = "The edited save came out empty, nothing was written.";
					return false;
				}
				string text2 = saveFilePath + ".pre-edit";
				File.Copy(saveFilePath, text2, overwrite: true);
				string text3 = saveFilePath + ".writing";
				File.WriteAllText(text3, text);
				if (JsonUtility.FromJson<ServerSaveObject>(File.ReadAllText(text3)) == null)
				{
					File.Delete(text3);
					message = "The edited save did not read back correctly, nothing was changed.";
					return false;
				}
				if (File.Exists(saveFilePath))
				{
					File.Delete(saveFilePath);
				}
				File.Move(text3, saveFilePath);
				CompendiumPlugin.Log.LogInfo((object)($"Edited backup '{Target.SaveName}' taken {Target.TakenUtc.ToLocalTime():g}. " + "The original was kept as " + Path.GetFileName(text2) + "."));
				message = "Saved. The original was kept alongside it.";
				return true;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not write the edited save: " + ex));
				message = "Could not write that save, see the log.";
				return false;
			}
		}

		public static string SpongeDifficultyName(int value)
		{
			return value switch
			{
				0 => "Easy", 
				2 => "Hard", 
				_ => "Default", 
			};
		}
	}
	public enum SnapshotOrigin
	{
		Automatic,
		Manual,
		PreRestore
	}
	public sealed class SnapshotEntry
	{
		public string SaveName = "";

		public string TakenUtc = "";

		public bool Automatic = true;

		public string Kind = "";

		public List<CompanionEntry> Companions = new List<CompanionEntry>();
	}
	public sealed class RestoreOutcome
	{
		public bool Success;

		public List<string> Missing = new List<string>();

		public List<string> Cleared = new List<string>();

		public int CompanionsRestored;
	}
	public sealed class SnapshotInfo
	{
		public string Path;

		public string SaveName;

		public DateTime TakenUtc;

		public SnapshotOrigin Kind;

		public bool Legacy;

		public string Summary = "";

		public string SaveLabel = "";

		public int Island = -1;

		public int Money = -1;

		public TimeSpan Played = TimeSpan.Zero;

		public bool Readable;

		public long Bytes;

		public List<CompanionEntry> Companions = new List<CompanionEntry>();

		public bool Favorite;

		public bool Automatic => Kind == SnapshotOrigin.Automatic;

		public string SaveFilePath
		{
			get
			{
				if (!Legacy)
				{
					return System.IO.Path.Combine(Path, "save.txt");
				}
				return Path;
			}
		}
	}
	public static class SnapshotStore
	{
		private const string StampFormat = "yyyyMMdd-HHmmss";

		private const string SaveEntry = "save.txt";

		private const string SnapshotEntry = "snapshot.json";

		private const string ManualTag = "manual";

		private const string PreRestoreTag = "prerestore";

		public static string SaveFolder => Path.Combine(Application.persistentDataPath, "Saves");

		public static string Root => Path.Combine(Application.persistentDataPath, "SaveBackups");

		public static string SpongeSavePath(string saveName)
		{
			return Path.Combine(SaveFolder, saveName + ".txt");
		}

		public static string SpongeFolderFor(string saveName)
		{
			return Path.Combine(Root, SpongeSanitiseSaveName(saveName));
		}

		public static string SpongeSanitiseSaveName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "unnamed";
			}
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				name = name.Replace(oldChar, '_');
			}
			return name;
		}

		private static string TagFor(SnapshotOrigin kind)
		{
			return kind switch
			{
				SnapshotOrigin.Manual => "-manual", 
				SnapshotOrigin.PreRestore => "-prerestore", 
				_ => "", 
			};
		}

		private static void EmitAtomic(string path, string content)
		{
			string directoryName = Path.GetDirectoryName(path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text = path + ".writing";
			File.WriteAllText(text, content);
			if (!File.Exists(path))
			{
				File.Move(text, path);
				return;
			}
			try
			{
				File.Replace(text, path, null);
			}
			catch (Exception)
			{
				File.Delete(path);
				File.Move(text, path);
			}
		}

		public static List<SnapshotInfo> List(string saveName)
		{
			return List(saveName, includeSummary: true);
		}

		public static List<SnapshotInfo> List(string saveName, bool includeSummary)
		{
			List<SnapshotInfo> list = new List<SnapshotInfo>();
			if (string.IsNullOrEmpty(saveName))
			{
				return list;
			}
			try
			{
				string path = SpongeFolderFor(saveName);
				if (!Directory.Exists(path))
				{
					return list;
				}
				string[] directories = Directory.GetDirectories(path);
				for (int i = 0; i < directories.Length; i++)
				{
					SnapshotInfo snapshotInfo = SpongeDescribeSnapshot(directories[i], saveName, includeSummary);
					if (snapshotInfo != null)
					{
						list.Add(snapshotInfo);
					}
				}
				directories = Directory.GetFiles(path, "*.txt");
				for (int i = 0; i < directories.Length; i++)
				{
					SnapshotInfo snapshotInfo2 = SpongeDescribeLegacy(directories[i], saveName, includeSummary);
					if (snapshotInfo2 != null)
					{
						list.Add(snapshotInfo2);
					}
				}
				foreach (SnapshotInfo item in list)
				{
					item.Favorite = BackupFavorites.HasFavorite(item);
				}
				list.Sort(delegate(SnapshotInfo a, SnapshotInfo b)
				{
					if (a.Favorite == b.Favorite)
					{
						return b.TakenUtc.CompareTo(a.TakenUtc);
					}
					return (!a.Favorite) ? 1 : (-1);
				});
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not list backups: " + ex));
			}
			return list;
		}

		private static bool SpongeParseStamp(string name, out DateTime taken, out SnapshotOrigin kind)
		{
			kind = SnapshotOrigin.Automatic;
			taken = DateTime.MinValue;
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string[] array = name.Split('-');
			if (array.Length < 2)
			{
				return false;
			}
			for (int i = 2; i < array.Length; i++)
			{
				if (string.Equals(array[i], "manual", StringComparison.OrdinalIgnoreCase))
				{
					kind = SnapshotOrigin.Manual;
				}
				else if (string.Equals(array[i], "prerestore", StringComparison.OrdinalIgnoreCase))
				{
					kind = SnapshotOrigin.PreRestore;
				}
			}
			if (DateTime.TryParseExact(array[0] + "-" + array[1], "yyyyMMdd-HHmmss", CultureInfo.InvariantCulture, DateTimeStyles.None, out taken))
			{
				taken = DateTime.SpecifyKind(taken, DateTimeKind.Utc);
				return true;
			}
			taken = DateTime.MinValue;
			return false;
		}

		public static bool DropCompanion(SnapshotInfo info, CompanionEntry record, out string message)
		{
			message = "";
			if (info == null || record == null)
			{
				message = "There is nothing to remove.";
				return false;
			}
			if (info.Legacy)
			{
				message = "Older backups do not hold mod files.";
				return false;
			}
			try
			{
				string path = Path.Combine(info.Path, record.StoredName);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
				string path2 = Path.Combine(info.Path, "snapshot.json");
				if (File.Exists(path2))
				{
					SnapshotEntry snapshotEntry = JsonConvert.DeserializeObject<SnapshotEntry>(File.ReadAllText(path2));
					if (snapshotEntry != null)
					{
						SnapshotEntry snapshotEntry2 = snapshotEntry;
						if (snapshotEntry2.Companions == null)
						{
							snapshotEntry2.Companions = new List<CompanionEntry>();
						}
						snapshotEntry.Companions.RemoveAll((CompanionEntry entry) => entry != null && entry.Id == record.Id);
						EmitAtomic(path2, JsonConvert.SerializeObject((object)snapshotEntry, (Formatting)1));
					}
				}
				info.Companions.RemoveAll((CompanionEntry entry) => entry != null && entry.Id == record.Id);
				string text = (string.IsNullOrEmpty(record.DisplayName) ? record.Id : record.DisplayName);
				message = "Removed the " + text + " file from that backup.";
				return true;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not remove a mod file from a backup: " + ex));
				message = "Could not remove that file, see the log.";
				return false;
			}
		}

		private static SnapshotOrigin SpongeKindFrom(SnapshotEntry snapshot, SnapshotOrigin fallback)
		{
			if (snapshot == null)
			{
				return fallback;
			}
			if (!string.IsNullOrEmpty(snapshot.Kind))
			{
				if (string.Equals(snapshot.Kind, SnapshotOrigin.Manual.ToString(), StringComparison.OrdinalIgnoreCase))
				{
					return SnapshotOrigin.Manual;
				}
				if (string.Equals(snapshot.Kind, SnapshotOrigin.PreRestore.ToString(), StringComparison.OrdinalIgnoreCase))
				{
					return SnapshotOrigin.PreRestore;
				}
				if (string.Equals(snapshot.Kind, SnapshotOrigin.Automatic.ToString(), StringComparison.OrdinalIgnoreCase))
				{
					return SnapshotOrigin.Automatic;
				}
			}
			if (!snapshot.Automatic)
			{
				return SnapshotOrigin.Manual;
			}
			return SnapshotOrigin.Automatic;
		}

		private static SnapshotInfo SpongeDescribeSnapshot(string folder, string saveName, bool includeSummary)
		{
			try
			{
				string text = Path.Combine(folder, "save.txt");
				if (!File.Exists(text))
				{
					return null;
				}
				if (!SpongeParseStamp(Path.GetFileName(folder), out var taken, out var kind))
				{
					taken = Directory.GetLastWriteTimeUtc(folder);
				}
				SnapshotInfo snapshotInfo = new SnapshotInfo
				{
					Path = folder,
					SaveName = saveName,
					TakenUtc = taken,
					Kind = kind,
					Legacy = false,
					Bytes = new FileInfo(text).Length
				};
				string path = Path.Combine(folder, "snapshot.json");
				if (File.Exists(path))
				{
					SnapshotEntry snapshotEntry = JsonConvert.DeserializeObject<SnapshotEntry>(File.ReadAllText(path));
					if (snapshotEntry != null)
					{
						if (!string.IsNullOrEmpty(snapshotEntry.SaveName) && snapshotEntry.SaveName != saveName)
						{
							return null;
						}
						snapshotInfo.Kind = SpongeKindFrom(snapshotEntry, kind);
						snapshotInfo.Companions = snapshotEntry.Companions ?? new List<CompanionEntry>();
						if (DateTime.TryParse(snapshotEntry.TakenUtc, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out var result))
						{
							snapshotInfo.TakenUtc = DateTime.SpecifyKind(result, DateTimeKind.Utc);
						}
					}
				}
				if (includeSummary)
				{
					string json = File.ReadAllText(text);
					snapshotInfo.Summary = SpongeSummarise(json);
					FetchDetails(snapshotInfo, json);
				}
				return snapshotInfo;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Skipping unreadable snapshot " + folder + ": " + ex.Message));
				return null;
			}
		}

		private static SnapshotInfo SpongeDescribeLegacy(string path, string saveName, bool includeSummary)
		{
			try
			{
				if (!SpongeParseStamp(Path.GetFileNameWithoutExtension(path), out var taken, out var kind))
				{
					taken = File.GetLastWriteTimeUtc(path);
				}
				SnapshotInfo snapshotInfo = new SnapshotInfo
				{
					Path = path,
					SaveName = saveName,
					TakenUtc = taken,
					Kind = kind,
					Legacy = true,
					Bytes = new FileInfo(path).Length
				};
				if (includeSummary)
				{
					string json = File.ReadAllText(path);
					snapshotInfo.Summary = SpongeSummarise(json);
					FetchDetails(snapshotInfo, json);
				}
				return snapshotInfo;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Skipping unreadable backup " + path + ": " + ex.Message));
				return null;
			}
		}

		private static string SpongeSummarise(string json)
		{
			try
			{
				ServerSaveObject val = JsonUtility.FromJson<ServerSaveObject>(json);
				if (val == null)
				{
					return "unreadable";
				}
				TimeSpan timeSpan = TimeSpan.FromSeconds(val.Playtime);
				return $"{val.Money} money, island {val.SpawnedIsland + 1}, " + $"{timeSpan.Hours}h {timeSpan.Minutes:D2}m played";
			}
			catch (Exception)
			{
				return "unreadable";
			}
		}

		private static void FetchDetails(SnapshotInfo info, string json)
		{
			try
			{
				ServerSaveObject val = JsonUtility.FromJson<ServerSaveObject>(json);
				if (val != null)
				{
					info.SaveLabel = val.Name ?? "";
					info.Island = val.SpawnedIsland + 1;
					info.Money = val.Money;
					info.Played = TimeSpan.FromSeconds(val.Playtime);
					info.Readable = true;
				}
			}
			catch (Exception)
			{
			}
		}

		private static string SpongeSignature(string saveContent, List<KeyValuePair<CompanionEntry, string>> companions)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(saveContent);
			companions.Sort((KeyValuePair<CompanionEntry, string> a, KeyValuePair<CompanionEntry, string> b) => string.CompareOrdinal(a.Key.Id, b.Key.Id));
			foreach (KeyValuePair<CompanionEntry, string> companion in companions)
			{
				stringBuilder.Append('\0').Append(companion.Key.Id).Append('\0')
					.Append(companion.Value);
			}
			return stringBuilder.ToString();
		}

		private static string SpongeSignatureOf(SnapshotInfo info)
		{
			try
			{
				string saveContent = File.ReadAllText(info.SaveFilePath);
				List<KeyValuePair<CompanionEntry, string>> list = new List<KeyValuePair<CompanionEntry, string>>();
				foreach (CompanionEntry companion in info.Companions)
				{
					string path = Path.Combine(info.Path, companion.StoredName);
					if (File.Exists(path))
					{
						list.Add(new KeyValuePair<CompanionEntry, string>(companion, File.ReadAllText(path)));
					}
				}
				return SpongeSignature(saveContent, list);
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static bool SpongeCapture(string saveName, bool automatic)
		{
			return SpongeCapture(saveName, (!automatic) ? SnapshotOrigin.Manual : SnapshotOrigin.Automatic);
		}

		public static bool SpongeCapture(string saveName, SnapshotOrigin kind)
		{
			if (string.IsNullOrEmpty(saveName))
			{
				return false;
			}
			try
			{
				string path = SpongeSavePath(saveName);
				if (!File.Exists(path))
				{
					CompendiumPlugin.Log.LogWarning((object)("No save file on disk for '" + saveName + "', nothing to back up."));
					return false;
				}
				string text = File.ReadAllText(path);
				if (string.IsNullOrEmpty(text))
				{
					CompendiumPlugin.Log.LogWarning((object)("Save file for '" + saveName + "' is empty, refusing to back it up."));
					return false;
				}
				List<KeyValuePair<CompanionEntry, string>> list = CollectCompanions(saveName);
				if (kind == SnapshotOrigin.Automatic && SaveBackupModule.SkipUnchanged.Value && SpongeMatchesNewest(saveName, SpongeSignature(text, list)))
				{
					return false;
				}
				string text2 = SpongeFolderFor(saveName);
				Directory.CreateDirectory(text2);
				string text3 = DateTime.UtcNow.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture);
				string text4 = Path.Combine(text2, text3 + TagFor(kind));
				int num = 2;
				while (Directory.Exists(text4) && num < 100)
				{
					text4 = Path.Combine(text2, text3 + "-" + num + TagFor(kind));
					num++;
				}
				Directory.CreateDirectory(text4);
				EmitAtomic(Path.Combine(text4, "save.txt"), text);
				SnapshotEntry snapshotEntry = new SnapshotEntry
				{
					SaveName = saveName,
					TakenUtc = DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
					Automatic = (kind == SnapshotOrigin.Automatic),
					Kind = kind.ToString()
				};
				foreach (KeyValuePair<CompanionEntry, string> item in list)
				{
					EmitAtomic(Path.Combine(text4, item.Key.StoredName), item.Value);
					snapshotEntry.Companions.Add(item.Key);
				}
				EmitAtomic(Path.Combine(text4, "snapshot.json"), JsonConvert.SerializeObject((object)snapshotEntry, (Formatting)1));
				Prune(saveName);
				string arg = ((list.Count > 0) ? $" with {list.Count} companion file(s)" : "");
				CompendiumPlugin.Log.LogInfo((object)$"Backed up '{saveName}' ({kind}){arg}.");
				return true;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Backup failed: " + ex));
				return false;
			}
		}

		private static List<KeyValuePair<CompanionEntry, string>> CollectCompanions(string saveName)
		{
			List<KeyValuePair<CompanionEntry, string>> list = new List<KeyValuePair<CompanionEntry, string>>();
			foreach (CompanionSource item in CompanionRegistry.All)
			{
				string text = CompanionRegistry.LookupPath(item, saveName);
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				try
				{
					if (!File.Exists(text))
					{
						continue;
					}
					string value = File.ReadAllText(text);
					if (!string.IsNullOrEmpty(value))
					{
						string text2 = Path.GetExtension(text);
						if (string.IsNullOrEmpty(text2))
						{
							text2 = ".dat";
						}
						list.Add(new KeyValuePair<CompanionEntry, string>(new CompanionEntry
						{
							Id = item.Id,
							DisplayName = item.DisplayName,
							StoredName = "companion." + item.Id + text2
						}, value));
					}
				}
				catch (Exception ex)
				{
					CompendiumPlugin.Log.LogWarning((object)("Could not read companion file for '" + item.Id + "': " + ex.Message));
				}
			}
			return list;
		}

		private static bool SpongeMatchesNewest(string saveName, string signature)
		{
			List<SnapshotInfo> list = List(saveName, includeSummary: false);
			if (list.Count != 0)
			{
				return SpongeSignatureOf(list[0]) == signature;
			}
			return false;
		}

		private static void Prune(string saveName)
		{
			List<SnapshotInfo> all = List(saveName, includeSummary: false);
			SpongePruneKind(all, SnapshotOrigin.Automatic, SaveBackupModule.MaxAutomaticBackups.Value);
			SpongePruneKind(all, SnapshotOrigin.PreRestore, SaveBackupModule.MaxPreRestoreBackups.Value);
		}

		private static void SpongePruneKind(List<SnapshotInfo> all, SnapshotOrigin kind, int keep)
		{
			if (keep <= 0)
			{
				return;
			}
			List<SnapshotInfo> list = new List<SnapshotInfo>();
			foreach (SnapshotInfo item in all)
			{
				if (item.Kind == kind && !item.Favorite)
				{
					list.Add(item);
				}
			}
			for (int i = keep; i < list.Count; i++)
			{
				Delete(list[i]);
			}
		}

		public static RestoreOutcome SpongeRestore(SnapshotInfo info)
		{
			RestoreOutcome restoreOutcome = new RestoreOutcome();
			if (info == null)
			{
				return restoreOutcome;
			}
			try
			{
				string saveFilePath = info.SaveFilePath;
				if (!File.Exists(saveFilePath))
				{
					CompendiumPlugin.Log.LogWarning((object)"That backup no longer exists on disk.");
					return restoreOutcome;
				}
				string text = File.ReadAllText(saveFilePath);
				if (string.IsNullOrEmpty(text))
				{
					CompendiumPlugin.Log.LogError((object)"That backup is empty, refusing to restore it.");
					return restoreOutcome;
				}
				SpongeCapture(info.SaveName, SnapshotOrigin.PreRestore);
				Directory.CreateDirectory(SaveFolder);
				EmitAtomic(SpongeSavePath(info.SaveName), text);
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				foreach (CompanionEntry companion in info.Companions)
				{
					string path = Path.Combine(info.Path, companion.StoredName);
					if (!File.Exists(path))
					{
						continue;
					}
					CompanionSource companionSource = CompanionRegistry.Get(companion.Id);
					if (companionSource == null)
					{
						string text2 = (string.IsNullOrEmpty(companion.DisplayName) ? companion.Id : companion.DisplayName);
						restoreOutcome.Missing.Add(text2);
						CompendiumPlugin.Log.LogWarning((object)("Snapshot contains data for '" + text2 + "' but that feature is not loaded, skipping it."));
						continue;
					}
					string text3 = CompanionRegistry.LookupPath(companionSource, info.SaveName);
					if (string.IsNullOrEmpty(text3))
					{
						restoreOutcome.Missing.Add(companionSource.DisplayName);
						continue;
					}
					EmitAtomic(text3, File.ReadAllText(path));
					hashSet.Add(companionSource.Id);
					restoreOutcome.CompanionsRestored++;
				}
				ResetUnrecordedCompanions(info, hashSet, restoreOutcome);
				restoreOutcome.Success = true;
				CompendiumPlugin.Log.LogInfo((object)($"Restored '{info.SaveName}' from {info.TakenUtc.ToLocalTime():g}, " + $"{restoreOutcome.CompanionsRestored} companion file(s) written, {restoreOutcome.Cleared.Count} removed."));
				return restoreOutcome;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("SpongeRestore failed: " + ex));
				return restoreOutcome;
			}
		}

		private static void ResetUnrecordedCompanions(SnapshotInfo info, HashSet<string> restored, RestoreOutcome result)
		{
			foreach (CompanionSource item in CompanionRegistry.All)
			{
				if (restored.Contains(item.Id))
				{
					continue;
				}
				try
				{
					string text = CompanionRegistry.LookupPath(item, info.SaveName);
					if (!string.IsNullOrEmpty(text) && File.Exists(text))
					{
						File.Delete(text);
						result.Cleared.Add(item.DisplayName);
						CompendiumPlugin.Log.LogInfo((object)("Removed current data for '" + item.DisplayName + "' because this snapshot predates it. The state before restoring was saved first."));
					}
				}
				catch (Exception ex)
				{
					CompendiumPlugin.Log.LogWarning((object)("Could not remove stale data for '" + item.Id + "': " + ex.Message));
				}
			}
		}

		public static bool Delete(SnapshotInfo info)
		{
			try
			{
				if (info == null)
				{
					return false;
				}
				BackupFavorites.Forget(info);
				if (info.Legacy)
				{
					if (!File.Exists(info.Path))
					{
						return false;
					}
					File.Delete(info.Path);
					return true;
				}
				if (Directory.Exists(info.Path))
				{
					Directory.Delete(info.Path, recursive: true);
					return true;
				}
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogError((object)("Could not delete backup: " + ex));
			}
			return false;
		}
	}
}
namespace SpongeMods.SpongeTweaks.Multiplayer
{
	internal sealed class LobbySizeModule : FeatureModule
	{
		internal static ConfigEntry<int> MaxPlayers;

		public static int Limit => MaxPlayers.Value;

		public override string DisplayName => "More Players";

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("More Players", "Enabled", true, "Raise the maximum lobby size when you host.");
			MaxPlayers = config.Bind<int>("More Players", "MaxPlayers", 32, new ConfigDescription("How many players can be in a lobby you host, counting you.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 250), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(SteamCreateLobbyPatch));
			harmony.PatchAll(typeof(OnlineLobbyPatch));
			CompendiumPlugin.Log.LogInfo((object)$"More Players active. MaxPlayers={MaxPlayers.Value}");
		}
	}
	[HarmonyPatch(typeof(SteamManager), "CreateLobby")]
	internal static class SteamCreateLobbyPatch
	{
		internal static bool Rewrote;

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(SteamMatchmaking), "CreateLobby", new Type[2]
			{
				typeof(ELobbyType),
				typeof(int)
			}, (Type[])null);
			int num = 1;
			while (methodInfo != null && num < list.Count)
			{
				if (CodeInstructionExtensions.Calls(list[num], methodInfo) && CodeInstructionExtensions.LoadsConstant(list[num - 1]))
				{
					list[num - 1].opcode = OpCodes.Call;
					list[num - 1].operand = AccessTools.PropertyGetter(typeof(LobbySizeModule), "Limit");
					Rewrote = true;
					break;
				}
				num++;
			}
			if (!Rewrote)
			{
				CompendiumPlugin.Log.LogWarning((object)"Could not rewrite the lobby size in SteamManager.CreateLobby; falling back to resizing the lobby once it exists.");
			}
			return list;
		}
	}
	[HarmonyPatch(typeof(ConnectionManager), "CreateOnlineLobby")]
	internal static class OnlineLobbyPatch
	{
		private static void Prefix(ref int maxPlayers)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			maxPlayers = LobbySizeModule.Limit;
			if (!SteamCreateLobbyPatch.Rewrote)
			{
				CSteamID currentLobbyID = SteamManager.CurrentLobbyID;
				if (!(currentLobbyID == CSteamID.Nil) && !SteamMatchmaking.SetLobbyMemberLimit(currentLobbyID, LobbySizeModule.Limit))
				{
					CompendiumPlugin.Log.LogWarning((object)$"Steam refused a member limit of {LobbySizeModule.Limit}.");
				}
			}
		}
	}
}
namespace SpongeMods.SpongeTweaks.Inventory
{
	internal sealed class StackingModule : FeatureModule
	{
		internal static ConfigEntry<int> MaxStackSize;

		public override string DisplayName => "Stackable Items";

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Stackable Items", "Enabled", true, "Allow identical items to stack in a single inventory slot.");
			MaxStackSize = config.Bind<int>("Stackable Items", "Max Stack Size", 64, new ConfigDescription("The maximum amount of objects you can have in a given slot. The more you have, the more data can be tracked per player.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(StackingPatches));
			CompanionRegistry.SpongeRegister("stackableitems", "Stackable Items", (string saveName) => StackSaveStore.ObtainPath(saveName));
			CompendiumPlugin.Log.LogInfo((object)"Stackable Items active.");
		}

		internal static bool IsModInstalled(string guid)
		{
			return Chainloader.PluginInfos.ContainsKey(guid);
		}
	}
	internal static class StackRegistry
	{
		public static Item ItemBeingStored;

		public static byte LastRemovedSlot = byte.MaxValue;

		public static readonly Dictionary<ulong, Dictionary<byte, List<Item>>> ServerStacks = new Dictionary<ulong, Dictionary<byte, List<Item>>>();

		public static readonly Dictionary<ulong, Dictionary<byte, List<Item>>> ClientStacks = new Dictionary<ulong, Dictionary<byte, List<Item>>>();

		public static int MaxStackSize => StackingModule.MaxStackSize.Value;

		private static ulong GetSteamId(PlayerInventory inventory)
		{
			Player player = inventory._player;
			if (player == null)
			{
				return 0uL;
			}
			return player.SteamID;
		}

		public static int ObtainStackCount(PlayerInventory inventory, byte index)
		{
			ulong steamId = GetSteamId(inventory);
			if (steamId == 0L)
			{
				return 0;
			}
			if (((NetworkBehaviour)inventory).IsServerInitialized && ServerStacks.TryGetValue(steamId, out var value) && value.TryGetValue(index, out var value2))
			{
				return value2.Count;
			}
			if (((NetworkBehaviour)inventory).Owner != (NetworkConnection)null && ((NetworkBehaviour)inventory).Owner.IsLocalClient && ClientStacks.TryGetValue(steamId, out var value3) && value3.TryGetValue(index, out var value4))
			{
				return value4.Count;
			}
			return 0;
		}

		public static bool SpongePushServerStack(PlayerInventory inventory, byte index, Item item)
		{
			ulong steamId = GetSteamId(inventory);
			if (steamId == 0L)
			{
				return false;
			}
			if (!ServerStacks.TryGetValue(steamId, out var value))
			{
				value = new Dictionary<byte, List<Item>>();
				ServerStacks[steamId] = value;
			}
			if (!value.TryGetValue(index, out var value2))
			{
				value2 = (value[index] = new List<Item>());
			}
			if (value2.Count >= MaxStackSize - 1 || (Object)(object)item.Weapon != (Object)null)
			{
				return false;
			}
			value2.Add(item);
			return true;
		}

		public static Item SpongePopServerStack(PlayerInventory inventory, byte index)
		{
			ulong steamId = GetSteamId(inventory);
			if (steamId == 0L)
			{
				return null;
			}
			if (!ServerStacks.TryGetValue(steamId, out var value) || !value.TryGetValue(index, out var value2))
			{
				return null;
			}
			while (value2.Count > 0)
			{
				Item val = value2[value2.Count - 1];
				value2.RemoveAt(value2.Count - 1);
				if (!((Object)(object)val == (Object)null) && !((NetworkBehaviour)val).IsDeinitializing)
				{
					if (!((Object)(object)val.SyncedHolder != (Object)(object)inventory._player))
					{
						return val;
					}
					CompendiumPlugin.Log.LogWarning((object)($"Discarded a stacked '{((Object)val).name}' in slot {index} that no longer " + "belongs to this player. It is loose in the world rather than in the stack."));
				}
			}
			return null;
		}

		public static void Forget(Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				Purge(ServerStacks, item);
				Purge(ClientStacks, item);
			}
		}

		private static void Purge(Dictionary<ulong, Dictionary<byte, List<Item>>> source, Item item)
		{
			foreach (Dictionary<byte, List<Item>> value in source.Values)
			{
				foreach (List<Item> value2 in value.Values)
				{
					for (int num = value2.Count - 1; num >= 0; num--)
					{
						if ((Object)(object)value2[num] == (Object)(object)item)
						{
							value2.RemoveAt(num);
						}
					}
				}
			}
		}

		public static void SpongeSyncClientStack(PlayerInventory inventory, byte index, Item newItem, Item oldItem)
		{
			ulong steamId = GetSteamId(inventory);
			if (steamId != 0L)
			{
				if (!ClientStacks.TryGetValue(steamId, out var value))
				{
					value = new Dictionary<byte, List<Item>>();
					ClientStacks[steamId] = value;
				}
				if (!value.TryGetValue(index, out var value2))
				{
					value2 = (value[index] = new List<Item>());
				}
				if ((Object)(object)newItem == (Object)null)
				{
					value2.Clear();
				}
				else if (value2.Count > 0 && (Object)(object)value2[value2.Count - 1] == (Object)(object)newItem)
				{
					value2.RemoveAt(value2.Count - 1);
				}
				else if ((Object)(object)oldItem != (Object)null && (Object)(object)oldItem != (Object)(object)newItem)
				{
					value2.Add(oldItem);
				}
			}
		}
	}
	[Serializable]
	public sealed class PlayerStackFile
	{
		public ulong SteamID { get; set; }

		public List<SavedItem> StackedItems { get; set; } = new List<SavedItem>();
	}
	[Serializable]
	public sealed class StackFile
	{
		public List<PlayerStackFile> Players { get; set; } = new List<PlayerStackFile>();
	}
	internal static class StackSaveStore
	{
		private static readonly string SaveFolder = Path.Combine(Paths.ConfigPath, "SpongeMods", "Stacks");

		private static readonly Dictionary<ulong, List<SavedItem>> PendingRestores = new Dictionary<ulong, List<SavedItem>>();

		public static void Save()
		{
			if (SaveManager.CurServerSave == null)
			{
				return;
			}
			foreach (Player player in PlayerManager.Players)
			{
				SavePlayer(player);
			}
		}

		public static void SavePlayer(Player player)
		{
			if (SaveManager.CurServerSave == null || (Object)(object)player == (Object)null)
			{
				return;
			}
			StackFile stackFile = FetchFile(SaveManager.CurServerSave.Name);
			stackFile.Players.RemoveAll((PlayerStackFile entry) => entry.SteamID == player.SteamID);
			PlayerStackFile playerStackFile = new PlayerStackFile
			{
				SteamID = player.SteamID
			};
			if (StackRegistry.ServerStacks.TryGetValue(player.SteamID, out var value))
			{
				foreach (KeyValuePair<byte, List<Item>> item in value)
				{
					foreach (Item item2 in item.Value)
					{
						if ((Object)(object)item2 != (Object)null)
						{
							playerStackFile.StackedItems.Add(SaveManager.ItemToSavedItem(item.Key, item2));
						}
					}
				}
			}
			if (playerStackFile.StackedItems.Count > 0)
			{
				stackFile.Players.Add(playerStackFile);
			}
			Write(SaveManager.CurServerSave.Name, stackFile);
		}

		public static void Load()
		{
			PendingRestores.Clear();
			if (SaveManager.CurServerSave == null)
			{
				return;
			}
			foreach (PlayerStackFile player in FetchFile(SaveManager.CurServerSave.Name).Players)
			{
				PendingRestores[player.SteamID] = new List<SavedItem>(player.StackedItems);
			}
		}

		private static StackFile FetchFile(string serverName)
		{
			string path = ObtainPath(serverName);
			if (!File.Exists(path))
			{
				return new StackFile();
			}
			try
			{
				return JsonConvert.DeserializeObject<StackFile>(File.ReadAllText(path)) ?? new StackFile();
			}
			catch
			{
				return new StackFile();
			}
		}

		public static List<SavedItem> TakePending(ulong steamId)
		{
			if (!PendingRestores.TryGetValue(steamId, out var value))
			{
				return null;
			}
			PendingRestores.Remove(steamId);
			return value;
		}

		public static void ApplyStats(Item item, SavedItem saved)
		{
			item._cookness.Value = saved.Cookness;
			item._bettingMultiplier.Value = saved.BettingMultiplier;
			item._killScoreMultiplier.Value = saved.KillScoreMultiplier;
			item._curSkin.Value = saved.SkinIndex;
			if ((Object)(object)item._weapon != (Object)null)
			{
				item._weapon._attachments._syncedSight.Value = saved.Sight;
				item._weapon._attachments._syncedBarrelAttachment.Value = saved.BarrelAttachment;
				item._weapon._attachments._syncedBulletIndex.Value = saved.AmmoType;
				item._weapon._attachments._syncedExtendedMag.Value = saved.ExtendedMag;
				item._weapon._attachments._syncedLaserSight.Value = saved.LaserSight;
			}
			if ((Object)(object)item._melee != (Object)null)
			{
				item._melee._syncedSharpnessIndex.Value = saved.Sharpness;
			}
			if ((Object)(object)item._creature != (Object)null)
			{
				((Item)item._creature)._syncedRandomWeight.Value = saved.Weight;
			}
		}

		public static void Delete(string serverName)
		{
			string path = ObtainPath(serverName);
			if (File.Exists(path))
			{
				File.Delete(path);
			}
		}

		private static void Write(string serverName, StackFile file)
		{
			try
			{
				Directory.CreateDirectory(SaveFolder);
				File.WriteAllText(ObtainPath(serverName), JsonConvert.SerializeObject((object)file, (Formatting)1));
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not write stacked item data: " + ex.Message));
			}
		}

		public static string ObtainPath(string serverName)
		{
			string text = serverName ?? "unnamed";
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				text = text.Replace(oldChar, '_');
			}
			return Path.Combine(SaveFolder, text + ".json");
		}
	}
	[HarmonyPatch]
	internal static class StackingPatches
	{
		private static Item Push(Item item)
		{
			Item itemBeingStored = StackRegistry.ItemBeingStored;
			StackRegistry.ItemBeingStored = item;
			return itemBeingStored;
		}

		private static void Pop(Item previous)
		{
			StackRegistry.ItemBeingStored = previous;
		}

		private static Item HeldItem(PlayerInventory inventory)
		{
			Player player = inventory._player;
			if (player == null)
			{
				return null;
			}
			PlayerHolding holding = player.Holding;
			if (holding == null)
			{
				return null;
			}
			return holding.HeldItem;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerTryStoreHeldItem")]
		public static void ServerTryStoreHeldItemPrefix(Item item, out Item __state)
		{
			__state = Push(item);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerTryStoreHeldItem")]
		public static void ServerTryStoreHeldItemPostfix(Item __state)
		{
			Pop(__state);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ResolveHeldItemReplacement")]
		public static void ResolveHeldItemReplacementPrefix(Item item, out Item __state)
		{
			__state = Push(item);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "ResolveHeldItemReplacement")]
		public static void ResolveHeldItemReplacementPostfix(Item __state)
		{
			Pop(__state);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "LocalTrySelectSlot")]
		public static void LocalTrySelectSlotPrefix(PlayerInventory __instance, out Item __state)
		{
			__state = Push(HeldItem(__instance));
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "LocalTrySelectSlot")]
		public static void LocalTrySelectSlotPostfix(Item __state)
		{
			Pop(__state);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "UpdateHeldItem")]
		public static void UpdateHeldItemPrefix(PlayerInventory __instance, out Item __state)
		{
			__state = Push(HeldItem(__instance));
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "UpdateHeldItem")]
		public static void UpdateHeldItemPostfix(Item __state)
		{
			Pop(__state);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "GetOpenSlot")]
		public static bool GetOpenSlot(PlayerInventory __instance, int selected, ref int __result)
		{
			if ((Object)(object)StackRegistry.ItemBeingStored == (Object)null)
			{
				return true;
			}
			string text = ((Object)StackRegistry.ItemBeingStored).name.Replace("(Clone)", "").Trim();
			for (byte b = 0; b < __instance._availableSlots.Count; b++)
			{
				Item val = __instance._items[b];
				if (!((Object)(object)val == (Object)null))
				{
					string text2 = ((Object)val).name.Replace("(Clone)", "").Trim();
					int num = 1 + StackRegistry.ObtainStackCount(__instance, b);
					if (text2 == text && num < StackRegistry.MaxStackSize && (Object)(object)val.Weapon == (Object)null)
					{
						__result = b;
						return false;
					}
				}
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "AddItem")]
		public static bool AddItem(PlayerInventory __instance, byte index, Item item)
		{
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)item == (Object)null)
			{
				return true;
			}
			if (!__instance._items.ContainsKey(index))
			{
				return true;
			}
			if ((Object)(object)item.SyncedHolder != (Object)(object)__instance._player)
			{
				return true;
			}
			foreach (KeyValuePair<byte, Item> item2 in __instance._items)
			{
				if ((Object)(object)item2.Value == (Object)(object)item)
				{
					return false;
				}
			}
			Item val = __instance._items[index];
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)item && !StackRegistry.SpongePushServerStack(__instance, index, val))
			{
				return false;
			}
			__instance._items[index] = item;
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "RemoveItem")]
		public static bool RemoveItem(PlayerInventory __instance, Item item, out int __state)
		{
			__state = -1;
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)item == (Object)null)
			{
				return true;
			}
			byte b = byte.MaxValue;
			foreach (KeyValuePair<byte, Item> item2 in __instance._items)
			{
				if ((Object)(object)item2.Value == (Object)(object)item)
				{
					b = item2.Key;
					break;
				}
			}
			StackRegistry.LastRemovedSlot = b;
			if (b == byte.MaxValue)
			{
				return true;
			}
			Item val = StackRegistry.SpongePopServerStack(__instance, b);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			__instance._items[b] = val;
			__state = b;
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "RemoveItem")]
		public static void RemoveItemPostfix(PlayerInventory __instance, int __state)
		{
			StackRegistry.LastRemovedSlot = byte.MaxValue;
			if (__state >= 0 && !(((NetworkBehaviour)__instance).Owner == (NetworkConnection)null) && ((NetworkBehaviour)__instance).Owner.IsLocalClient && __instance._localCurSlot != __state)
			{
				__instance.ApplySlot(__state);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "LoadFromSave")]
		public static void LoadFromSave(PlayerInventory __instance)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServerInitialized || (Object)(object)__instance._player == (Object)null)
			{
				return;
			}
			ulong steamID = __instance._player.SteamID;
			List<SavedItem> list = StackSaveStore.TakePending(steamID);
			if (list == null || list.Count == 0)
			{
				return;
			}
			if (!StackRegistry.ServerStacks.TryGetValue(steamID, out var value))
			{
				value = new Dictionary<byte, List<Item>>();
				StackRegistry.ServerStacks[steamID] = value;
			}
			foreach (SavedItem item in list)
			{
				Item spawnable = GameInfo.GetSpawnable(item.ItemID);
				if (!Object.op_Implicit((Object)(object)spawnable))
				{
					continue;
				}
				Item val = ItemManager.Instance.SpawnNewItem(spawnable, SpawnManager.PlayerSpawnPos, Quaternion.identity);
				StackSaveStore.ApplyStats(val, item);
				if ((Object)(object)val.Creature != (Object)null)
				{
					val.Creature.ServerKillOnSpawn();
					if (item.IsDripCreature)
					{
						val.Creature.SetDrip();
					}
				}
				if ((Object)(object)val.Weapon != (Object)null)
				{
					val.SetSyncedHolder(__instance._player, true);
					byte? b = null;
					for (byte b2 = 0; b2 < __instance._items.Count; b2++)
					{
						if ((Object)(object)__instance._items[b2] == (Object)null)
						{
							b = b2;
							break;
						}
					}
					if (b.HasValue)
					{
						__instance._items[b.Value] = val;
						continue;
					}
					val.Drop(false, default(Vector3), default(Vector3));
					CompendiumPlugin.Log.LogWarning((object)("Dropped stacked weapon for " + ((Object)__instance._player).name + " because inventory was full."));
				}
				else
				{
					val.SetSyncedHolder(__instance._player, true);
					val.PutInInventory();
					if (!value.TryGetValue(item.InventorySlot, out var value2))
					{
						value2 = new List<Item>();
						value[item.InventorySlot] = value2;
					}
					value2.Add(val);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Item), "DestroyByEating")]
		public static void DestroyByEating(Item __instance)
		{
			Player lastHolder = __instance.LastHolder;
			if (!((Object)(object)lastHolder == (Object)null) && !((Object)(object)Player.LocalPlayer != (Object)(object)lastHolder))
			{
				PlayerInventory inventory = lastHolder.Inventory;
				if (!((Object)(object)inventory == (Object)null) && !(((NetworkBehaviour)inventory).Owner == (NetworkConnection)null) && ((NetworkBehaviour)inventory).Owner.IsLocalClient)
				{
					inventory.ApplySlot(inventory._localCurSlot);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Item), "SetSyncedHolder")]
		public static void SetSyncedHolderPostfix(Item __instance)
		{
			if ((Object)(object)__instance.SyncedHolder == (Object)null)
			{
				StackRegistry.Forget(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Item), "OnStopServer")]
		public static void ItemStopServerPostfix(Item __instance)
		{
			StackRegistry.Forget(__instance);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ServerDropAll")]
		public static void ServerDropAll(PlayerInventory __instance, Vector3 pos, Quaternion rot)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServerInitialized || StackingModule.IsModInstalled("kvasir.keepinventory"))
			{
				return;
			}
			Player player = __instance._player;
			ulong num = ((player != null) ? player.SteamID : 0);
			if (num == 0L || !StackRegistry.ServerStacks.TryGetValue(num, out var value))
			{
				return;
			}
			Vector3 val = Vector3.zero;
			foreach (KeyValuePair<byte, List<Item>> item in value)
			{
				Item[] array = item.Value.ToArray();
				item.Value.Clear();
				Item[] array2 = array;
				foreach (Item val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						val += Vector3.up * val2.ModelHeight;
						val2.SetSyncedHolder((Player)null, false);
						if (!val2.RigidbodySync.IsSimulatedLocal)
						{
							val2.RigidbodySync.StartSimulateLocal(pos + val, rot);
						}
						else
						{
							((Component)val2).transform.position = pos + val;
							val2.Rig.linearVelocity = Vector3.zero;
							val2.Rig.angularVelocity = Vector3.zero;
						}
						val += Vector3.up * val2.ModelHeight;
					}
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "OnItemsChange")]
		public static void OnItemsChange(PlayerInventory __instance, SyncDictionaryOperation op, byte index, Item item, bool asServer)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if (!asServer && (int)op == 3 && !(((NetworkBehaviour)__instance).Owner == (NetworkConnection)null) && ((NetworkBehaviour)__instance).Owner.IsLocalClient)
			{
				Item item2 = __instance._itemSlots[index].Item;
				StackRegistry.SpongeSyncClientStack(__instance, index, item, item2);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "OnStopServer")]
		public static void InventoryStopServer(PlayerInventory __instance)
		{
			if (!((Object)(object)__instance._player == (Object)null))
			{
				StackSaveStore.SavePlayer(__instance._player);
				StackRegistry.ServerStacks.Remove(__instance._player.SteamID);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerInventory), "OnStopClient")]
		public static void InventoryStopClient(PlayerInventory __instance)
		{
			Player player = __instance._player;
			ulong num = ((player != null) ? player.SteamID : 0);
			if (num != 0L)
			{
				StackRegistry.ClientStacks.Remove(num);
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(200)]
		[HarmonyPatch(typeof(InventorySlot), "SetItem")]
		public static void SetItem(InventorySlot __instance, Item item)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				((TMP_Text)__instance._itemText).text = "";
			}
			else
			{
				if ((Object)(object)Player.LocalPlayer == (Object)null)
				{
					return;
				}
				PlayerInventory inventory = Player.LocalPlayer.Inventory;
				if ((Object)(object)inventory == (Object)null)
				{
					return;
				}
				byte b = byte.MaxValue;
				for (byte b2 = 0; b2 < inventory._itemSlots.Count; b2++)
				{
					if ((Object)(object)inventory._itemSlots[b2] == (Object)(object)__instance)
					{
						b = b2;
						break;
					}
				}
				if (b == byte.MaxValue)
				{
					return;
				}
				int num = StackRegistry.ObtainStackCount(inventory, b) + 1;
				if (num > 1)
				{
					((TMP_Text)__instance._itemText).text = (((Object)(object)item.Mesh == (Object)null) ? $"{((Object)item).name} ({num})" : num.ToString());
					((Component)__instance._itemText).gameObject.SetActive(true);
				}
				else if ((Object)(object)item.Mesh != (Object)null)
				{
					if ((int)item.Type == 2)
					{
						return;
					}
					((TMP_Text)__instance._itemText).text = "";
				}
				AmmoCounterPatches.StyleSlotText(__instance._itemText);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "SaveServer")]
		public static void SaveServer()
		{
			StackSaveStore.Save();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "OnServerLoaded")]
		public static void OnServerLoaded()
		{
			StackSaveStore.Load();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SaveManager), "DeleteServer")]
		public static void DeleteServer()
		{
			if (SaveManager.CurServerSave != null)
			{
				StackSaveStore.Delete(SaveManager.CurServerSave.Name);
			}
		}
	}
}
namespace SpongeMods.SpongeTweaks.Hud
{
	internal sealed class AmmoCounterModule : FeatureModule
	{
		public override string DisplayName => "Ammo Counter";

		public override void BindConfiguration(ConfigFile config)
		{
			ModuleEnabled = config.Bind<bool>("Ammo Counter", "Enabled", true, "Show the current and maximum ammo on weapon inventory slots.");
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(AmmoCounterPatches));
			CompendiumPlugin.Log.LogInfo((object)"Ammo Counter active.");
		}
	}
	[HarmonyPatch]
	internal static class AmmoCounterPatches
	{
		internal static void StyleSlotText(TextMeshProUGUI label)
		{
			//IL_0034: 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)
			((TMP_Text)label).verticalAlignment = (VerticalAlignmentOptions)1024;
			((TMP_Text)label).horizontalAlignment = (HorizontalAlignmentOptions)1;
			((TMP_Text)label).fontSize = 16f;
			((TMP_Text)label).fontSizeMax = 18f;
			((TMP_Text)label).fontSizeMin = 10f;
			((Graphic)label).color = Color.white;
			((TMP_Text)label).transform.localPosition = new Vector3(7.25f, 5f, 0f);
			((TMP_Text)label).transform.SetAsLastSibling();
		}

		private static string ObtainAmmoText(Weapon weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return string.Empty;
			}
			return $"{weapon.Ammo} / {weapon._attachments.AmmoPerMag}";
		}

		private static InventorySlot FindSlotByItem(PlayerInventory inventory, Item item)
		{
			foreach (InventorySlot availableSlot in inventory._availableSlots)
			{
				if ((Object)(object)availableSlot.Item == (Object)(object)item)
				{
					return availableSlot;
				}
			}
			return null;
		}

		private static void SyncAmmoText(Weapon weapon)
		{
			if (!((Object)(object)weapon == (Object)null) && !((Object)(object)Player.LocalPlayer == (Object)null) && !((Object)(object)Player.LocalPlayer.Inventory == (Object)null))
			{
				InventorySlot val = FindSlotByItem(Player.LocalPlayer.Inventory, (Item)(object)weapon);
				if (!((Object)(object)val == (Object)null))
				{
					((TMP_Text)val._itemText).text = ObtainAmmoText(weapon);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(InventorySlot), "SetItem")]
		public static void SetItem(InventorySlot __instance, Item item)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)item == (Object)null) && !(((object)item).GetType() != typeof(Weapon)))
			{
				Weapon val = (Weapon)item;
				if (!((Object)(object)val == (Object)null))
				{
					((TMP_Text)__instance._itemText).text = ObtainAmmoText(val);
					StyleSlotText(__instance._itemText);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerHolding), "SetUninitializedHeldItem")]
		public static void SetUninitializedHeldItem(PlayerHolding __instance, Item item)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)item == (Object)null) && (int)item.Type == 2)
			{
				SyncAmmoText((Weapon)item);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerHolding), "PickUpItem")]
		public static void PickUpItem(PlayerHolding __instance, Item item, bool calledFromLocal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (!((Object)(object)__instance == (Object)null) && calledFromLocal && !((Object)(object)item == (Object)null) && (int)item.Type == 2)
			{
				SyncAmmoText((Weapon)item);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Weapon), "Shoot")]
		public static void Shoot(Weapon __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				SyncAmmoText(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Weapon), "TryRefillAmmo")]
		public static void TryRefillAmmo(Weapon __instance)
		{
			if (!((Object)(object)__instance == (Object)null) && __instance._reloadAmmoRefilled)
			{
				SyncAmmoText(__instance);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Attachments), "OnMagChange")]
		public static void OnMagChange(Attachments __instance, bool prev, bool next, bool asServer)
		{
			if (!((Object)(object)__instance == (Object)null) && !((Object)(object)__instance.Weapon == (Object)null))
			{
				SyncAmmoText(__instance.Weapon);
			}
		}
	}
	internal sealed class BossHealthModule : FeatureModule
	{
		private static readonly FieldInfo BossHealthField = AccessTools.Field(typeof(BossUI), "_bossHealth");

		private static readonly FieldInfo BossNameField = AccessTools.Field(typeof(BossUI), "_bossNameText");

		private static readonly FieldInfo BossHpRotateField = AccessTools.Field(typeof(BossUI), "_bossHpToRotate");

		private ConfigEntry<bool> _showMaximum;

		private ConfigEntry<float> _scale;

		private ConfigEntry<float> _opacity;

		private ConfigEntry<string> _barColour;

		private ConfigEntry<float> _horizontalOffset;

		private ConfigEntry<float> _verticalOffset;

		private BossUI _nativeBossUi;

		private Image _nativeHealth;

		private RectTransform _nativeHudRoot;

		private TextMeshProUGUI _text;

		private Color _originalHealthColour;

		private bool _hasOriginalHealthColour;

		private readonly Vector3[] _healthCorners = (Vector3[])(object)new Vector3[4];

		public override string DisplayName => "Boss HP";

		public override bool WantsUpdate => true;

		public override bool WantsLateUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Boss HP", "Enabled", true, "Show exact boss HP beside the native boss health bar.");
			_showMaximum = config.Bind<bool>("Boss HP", "ShowMaximum", true, "Show current and maximum HP instead of current HP only.");
			_scale = config.Bind<float>("Boss HP", "Scale", 1f, new ConfigDescription("Boss HP text scale.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 1.8f), Array.Empty<object>()));
			_opacity = config.Bind<float>("Boss HP", "Opacity", 1f, new ConfigDescription("Boss HP text opacity.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1f), Array.Empty<object>()));
			_barColour = config.Bind<string>("Boss HP", "BarColor", "Default", "Official boss health fill color. Use Default or a hex value such as #800080 or #800080FF.");
			_horizontalOffset = config.Bind<float>("Boss HP Position", "HorizontalOffset", 18f, new ConfigDescription("Distance to the left of the native health bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 180f), Array.Empty<object>()));
			_verticalOffset = config.Bind<float>("Boss HP Position", "VerticalOffset", 0f, new ConfigDescription("Vertical adjustment relative to the native health bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(-80f, 80f), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			CompendiumPlugin.Log.LogInfo((object)"Boss HP active: reads synchronised boss state and attaches text to the native bar.");
		}

		public override void Tick()
		{
			Creature boss = BossManager.Boss;
			if ((Object)(object)boss == (Object)null || boss.IsDead || !UiSupport.BossHudVisible())
			{
				AssignVisible(visible: false);
				return;
			}
			if (!RequireAttached())
			{
				AssignVisible(visible: false);
				return;
			}
			int num = BossManager.BossMaxHp;
			if (num <= 0)
			{
				num = boss.MaxHp;
			}
			if (num <= 0)
			{
				AssignVisible(visible: false);
				return;
			}
			int value = Math.Max(0, Math.Min(boss.Hp, num));
			((TMP_Text)_text).text = (_showMaximum.Value ? (UiSupport.RenderHp(value) + " / " + UiSupport.RenderHp(num)) : UiSupport.RenderHp(value));
			SetLiveSettings();
			AssignVisible(visible: true);
		}

		public override void LateTick()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_nativeHealth == (Object)null) && !((Object)(object)_text == (Object)null) && ((Behaviour)_text).enabled)
			{
				((Graphic)_nativeHealth).color = UiSupport.ResolveColour(_barColour.Value, _hasOriginalHealthColour ? _originalHealthColour : Color.white);
			}
		}

		private bool RequireAttached()
		{
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nativeBossUi != (Object)null && (Object)(object)_nativeHealth != (Object)null && (Object)(object)_nativeHudRoot != (Object)null && (Object)(object)_text != (Object)null)
			{
				return true;
			}
			ResetAttachment();
			if (BossHealthField == null || BossHpRotateField == null)
			{
				return false;
			}
			BossUI[] array = Resources.FindObjectsOfTypeAll<BossUI>();
			foreach (BossUI val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					object? value = BossHealthField.GetValue(val);
					Image val2 = (Image)((value is Image) ? value : null);
					object? value2 = BossHpRotateField.GetValue(val);
					RectTransform val3 = (RectTransform)((value2 is RectTransform) ? value2 : null);
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Graphic)val2).rectTransform == (Object)null) && !((Object)(object)val3 == (Object)null))
					{
						_nativeBossUi = val;
						_nativeHealth = val2;
						_nativeHudRoot = val3;
						_originalHealthColour = ((Graphic)val2).color;
						_hasOriginalHealthColour = true;
						MakeText(val3, LocateTemplate(val));
						CompendiumPlugin.Log.LogInfo((object)"Attached numeric boss HP to the native shake-and-rotation transform.");
						return (Object)(object)_text != (Object)null;
					}
				}
			}
			return false;
		}

		private void MakeText(RectTransform hudRoot, TextMeshProUGUI template)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SpongeMods_BossHpText", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent((Transform)(object)hudRoot, false);
			val.transform.SetAsLastSibling();
			_text = val.GetComponent<TextMeshProUGUI>();
			RectTransform rectTransform = ((TMP_Text)_text).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(1f, 0.5f);
			rectTransform.sizeDelta = new Vector2(300f, 70f);
			if ((Object)(object)template != (Object)null && (Object)(object)((TMP_Text)template).font != (Object)null)
			{
				((TMP_Text)_text).font = ((TMP_Text)template).font;
				if ((Object)(object)((TMP_Text)template).fontSharedMaterial != (Object)null)
				{
					((TMP_Text)_text).fontSharedMaterial = ((TMP_Text)template).fontSharedMaterial;
				}
				((TMP_Text)_text).characterSpacing = ((TMP_Text)template).characterSpacing;
			}
			((TMP_Text)_text).fontSize = 30f;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)4100;
			((TMP_Text)_text).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)_text).overflowMode = (TextOverflowModes)0;
			((Graphic)_text).raycastTarget = false;
			((TMP_Text)_text).outlineColor = new Color32((byte)20, (byte)18, (byte)18, byte.MaxValue);
			((TMP_Text)_text).outlineWidth = 0.18f;
			((TMP_Text)_text).text = string.Empty;
		}

		private static TextMeshProUGUI LocateTemplate(BossUI bossUi)
		{
			object? obj = BossNameField?.GetValue(bossUi);
			TextMeshProUGUI val = (TextMeshProUGUI)((obj is TextMeshProUGUI) ? obj : null);
			if ((Object)(object)val != (Object)null && (Object)(object)((TMP_Text)val).font != (Object)null)
			{
				return val;
			}
			return UiSupport.FindFontDonor();
		}

		private void SetLiveSettings()
		{
			//IL_0028: 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)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			RectTransform rectTransform = ((TMP_Text)_text).rectTransform;
			((Graphic)_nativeHealth).rectTransform.GetWorldCorners(_healthCorners);
			Vector3 val = (_healthCorners[0] + _healthCorners[1]) * 0.5f;
			Vector3 val2 = ((Transform)_nativeHudRoot).InverseTransformPoint(val);
			((Transform)rectTransform).localPosition = new Vector3(val2.x - _horizontalOffset.Value, val2.y + _verticalOffset.Value, 0f);
			((Transform)rectTransform).localScale = Vector3.one * _scale.Value;
			((Graphic)_text).color = new Color(1f, 1f, 1f, _opacity.Value);
			((Graphic)_nativeHealth).color = UiSupport.ResolveColour(_barColour.Value, _hasOriginalHealthColour ? _originalHealthColour : Color.white);
		}

		private void AssignVisible(bool visible)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_text != (Object)null && ((Behaviour)_text).enabled != visible)
			{
				((Behaviour)_text).enabled = visible;
			}
			if (!visible && (Object)(object)_nativeHealth != (Object)null && _hasOriginalHealthColour)
			{
				((Graphic)_nativeHealth).color = _originalHealthColour;
			}
		}

		private void ResetAttachment()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nativeHealth != (Object)null && _hasOriginalHealthColour)
			{
				((Graphic)_nativeHealth).color = _originalHealthColour;
			}
			if ((Object)(object)_text != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_text).gameObject);
			}
			_text = null;
			_nativeHealth = null;
			_nativeHudRoot = null;
			_nativeBossUi = null;
			_hasOriginalHealthColour = false;
		}

		public override void Shutdown()
		{
			ResetAttachment();
		}
	}
	internal sealed class BossTimerModule : FeatureModule
	{
		private const float LegacyTopOffset = 125f;

		private const float DefaultTopOffset = 175f;

		private const float NativeBarsTopReference = 125f;

		private static readonly FieldInfo CountdownGroupField = AccessTools.Field(typeof(BossUI), "_countdownGroup");

		private static readonly FieldInfo BossHpRotateField = AccessTools.Field(typeof(BossUI), "_bossHpToRotate");

		private static readonly FieldInfo TimeLeftImageField = AccessTools.Field(typeof(BossUI), "_timeLeftImage");

		private static readonly FieldInfo CountdownTextField = AccessTools.Field(typeof(BossUI), "_timeCountdownText");

		private ConfigEntry<bool> _showLabel;

		private ConfigEntry<bool> _showTenths;

		private ConfigEntry<float> _scale;

		private ConfigEntry<float> _opacity;

		private ConfigEntry<float> _topOffset;

		private GameObject _root;

		private RectTransform _panel;

		private CanvasGroup _canvasGroup;

		private TextMeshProUGUI _text;

		private bool _nativeStyleApplied;

		private BossUI _nativeBossUi;

		private CanvasGroup _nativeCountdownGroup;

		private RectTransform _nativeShakeRoot;

		private Image _nativeTimeBar;

		private readonly Vector3[] _timeBarCorners = (Vector3[])(object)new Vector3[4];

		public override string DisplayName => "Boss Timer";

		public override bool WantsUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Boss Timer", "Enabled", true, "Show the boss departure countdown while a boss is active.");
			_showLabel = config.Bind<bool>("Boss Timer", "ShowLabel", true, "Show 'BOSS LEAVES IN' before the remaining time.");
			_showTenths = config.Bind<bool>("Boss Timer", "ShowTenths", true, "Show tenths of a second.");
			_scale = config.Bind<float>("Boss Timer", "Scale", 1f, new ConfigDescription("HUD scale.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 1.8f), Array.Empty<object>()));
			_opacity = config.Bind<float>("Boss Timer", "Opacity", 1f, new ConfigDescription("HUD opacity.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1f), Array.Empty<object>()));
			_topOffset = config.Bind<float>("Boss Timer", "TopOffset", 175f, new ConfigDescription("Distance from the top of the screen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(60f, 350f), Array.Empty<object>()));
			if (Mathf.Approximately(_topOffset.Value, 125f))
			{
				_topOffset.Value = 175f;
			}
		}

		public override void Initialise(Harmony harmony)
		{
			MakeHud();
			CompendiumPlugin.Log.LogInfo((object)"Boss Timer active: reads BossManager's synchronised leave tick.");
		}

		public override void Tick()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (!UiSupport.BossHudVisible() || !AttemptGetRemainingSeconds(out var seconds))
			{
				AssignVisible(visible: false);
				return;
			}
			if (!RequireNativeAttachment())
			{
				AssignVisible(visible: false);
				return;
			}
			SetNativeStyleWhenAvailable();
			SetLiveSettings();
			((TMP_Text)_text).text = (_showLabel.Value ? "BOSS LEAVES IN  " : string.Empty) + RenderRemaining(seconds);
			((Graphic)_text).color = CountdownColour(seconds, _opacity.Value);
			float num = ObtainNativeCountdownAlpha();
			_canvasGroup.alpha = ((num > 0.001f) ? Mathf.MoveTowards(_canvasGroup.alpha, 0f, Time.unscaledDeltaTime * 2f) : 1f);
			AssignVisible(_canvasGroup.alpha > 0.001f);
		}

		private static bool AttemptGetRemainingSeconds(out double seconds)
		{
			seconds = 0.0;
			if (MainMenuManager.IsInMenu)
			{
				return false;
			}
			Creature boss = BossManager.Boss;
			if ((Object)(object)boss == (Object)null || boss.IsDead)
			{
				return false;
			}
			TimeManager timeManager = InstanceFinder.TimeManager;
			if ((Object)(object)timeManager == (Object)null || timeManager.TickRate == 0)
			{
				return false;
			}
			uint bossTotalTimeInTicks = BossManager.BossTotalTimeInTicks;
			if (bossTotalTimeInTicks == 0)
			{
				return false;
			}
			uint num = BossManager.BossLeavesTick - timeManager.Tick;
			if (num > bossTotalTimeInTicks)
			{
				return false;
			}
			seconds = (double)num / (double)(int)timeManager.TickRate;
			return true;
		}

		private string RenderRemaining(double seconds)
		{
			if (_showTenths.Value)
			{
				double num = Math.Ceiling(Math.Max(0.0, seconds) * 10.0) / 10.0;
				int num2 = (int)(num / 60.0);
				double num3 = num - (double)num2 * 60.0;
				return string.Format(CultureInfo.InvariantCulture, "{0:00}:{1:00.0}", num2, num3);
			}
			int num4 = (int)Math.Ceiling(Math.Max(0.0, seconds));
			return string.Format(CultureInfo.InvariantCulture, "{0:00}:{1:00}", num4 / 60, num4 % 60);
		}

		private void MakeHud()
		{
			if ((Object)(object)_root == (Object)null)
			{
				_root = UiSupport.CreateOverlayCanvas("SpongeMods_BossTimerHud", 32761);
				Object.DontDestroyOnLoad((Object)(object)_root);
			}
			MakePanel(_root.transform);
			_root.SetActive(false);
		}

		private void MakePanel(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Anchor", new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasGroup)
			});
			val.transform.SetParent(parent, false);
			_panel = val.GetComponent<RectTransform>();
			_canvasGroup = val.GetComponent<CanvasGroup>();
			_panel.anchorMin = new Vector2(0.5f, 1f);
			_panel.anchorMax = new Vector2(0.5f, 1f);
			_panel.pivot = new Vector2(0.5f, 1f);
			_panel.sizeDelta = new Vector2(700f, 64f);
			GameObject val2 = new GameObject("Countdown", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(TextMeshProUGUI)
			});
			val2.transform.SetParent((Transform)(object)_panel, false);
			_text = val2.GetComponent<TextMeshProUGUI>();
			RectTransform rectTransform = ((TMP_Text)_text).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((TMP_Text)_text).fontSize = 31f;
			((TMP_Text)_text).alignment = (TextAlignmentOptions)258;
			((TMP_Text)_text).textWrappingMode = (TextWrappingModes)0;
			((Graphic)_text).raycastTarget = false;
			((TMP_Text)_text).overflowMode = (TextOverflowModes)0;
			((TMP_Text)_text).outlineColor = new Color32((byte)20, (byte)18, (byte)18, byte.MaxValue);
			((TMP_Text)_text).outlineWidth = 0.18f;
			_nativeStyleApplied = false;
		}

		private bool RequireNativeAttachment()
		{
			if ((Object)(object)_nativeBossUi != (Object)null && (Object)(object)_nativeCountdownGroup != (Object)null && (Object)(object)_nativeShakeRoot != (Object)null && (Object)(object)_nativeTimeBar != (Object)null && (Object)(object)_panel != (Object)null)
			{
				return true;
			}
			LocateNativeCountdownGroup();
			if ((Object)(object)_nativeBossUi != (Object)null && (Object)(object)_nativeCountdownGroup != (Object)null && (Object)(object)_nativeShakeRoot != (Object)null && (Object)(object)_nativeTimeBar != (Object)null)
			{
				return (Object)(object)_panel != (Object)null;
			}
			return false;
		}

		private float ObtainNativeCountdownAlpha()
		{
			RequireNativeAttachment();
			if ((Object)(object)_nativeCountdownGroup == (Object)null || !((Component)_nativeCountdownGroup).gameObject.activeInHierarchy)
			{
				return 0f;
			}
			return Mathf.Clamp01(_nativeCountdownGroup.alpha);
		}

		private void LocateNativeCountdownGroup()
		{
			_nativeBossUi = null;
			_nativeCountdownGroup = null;
			_nativeShakeRoot = null;
			_nativeTimeBar = null;
			if (CountdownGroupField == null || BossHpRotateField == null || TimeLeftImageField == null)
			{
				return;
			}
			BossUI[] array = Resources.FindObjectsOfTypeAll<BossUI>();
			foreach (BossUI val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					object? value = CountdownGroupField.GetValue(val);
					CanvasGroup val2 = (CanvasGroup)((value is CanvasGroup) ? value : null);
					object? value2 = BossHpRotateField.GetValue(val);
					RectTransform val3 = (RectTransform)((value2 is RectTransform) ? value2 : null);
					object? value3 = TimeLeftImageField.GetValue(val);
					Image val4 = (Image)((value3 is Image) ? value3 : null);
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null))
					{
						_nativeBossUi = val;
						_nativeCountdownGroup = val2;
						_nativeShakeRoot = val3;
						_nativeTimeBar = val4;
						BindPanelToNativeBars();
						break;
					}
				}
			}
		}

		private void BindPanelToNativeBars()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_nativeShakeRoot == (Object)null)
			{
				return;
			}
			if ((Object)(object)_panel == (Object)null)
			{
				if ((Object)(object)_root == (Object)null)
				{
					MakeHud();
				}
				else
				{
					MakePanel(_root.transform);
				}
			}
			if (!((Object)(object)_panel == (Object)null) && !((Object)(object)((Transform)_panel).parent == (Object)(object)_nativeShakeRoot))
			{
				((Transform)_panel).SetParent((Transform)(object)_nativeShakeRoot, false);
				((Transform)_panel).SetAsLastSibling();
				_panel.anchorMin = new Vector2(0.5f, 0.5f);
				_panel.anchorMax = new Vector2(0.5f, 0.5f);
				_panel.pivot = new Vector2(0.5f, 1f);
				CompendiumPlugin.Log.LogInfo((object)"Attached boss countdown to the native boss shake-and-rotation transform.");
			}
		}

		private void SetNativeStyleWhenAvailable()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (_nativeStyleApplied || (Object)(object)_text == (Object)null)
			{
				return;
			}
			TextMeshProUGUI val = LocateNativeCountdownText() ?? UiSupport.FindFontDonor();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)((TMP_Text)val).font == (Object)null))
			{
				((TMP_Text)_text).font = ((TMP_Text)val).font;
				if ((Object)(object)((TMP_Text)val).fontSharedMaterial != (Object)null)
				{
					((TMP_Text)_text).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
				}
				((TMP_Text)_text).characterSpacing = ((TMP_Text)val).characterSpacing;
				((TMP_Text)_text).outlineColor = new Color32((byte)20, (byte)18, (byte)18, byte.MaxValue);
				((TMP_Text)_text).outlineWidth = 0.18f;
				_nativeStyleApplied = true;
			}
		}

		private static TextMeshProUGUI LocateNativeCountdownText()
		{
			if (CountdownTextField == null)
			{
				return null;
			}
			BossUI[] array = Resources.FindObjectsOfTypeAll<BossUI>();
			foreach (BossUI val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					object? value = CountdownTextField.GetValue(val);
					TextMeshProUGUI val2 = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
					if (val2 != null)
					{
						return val2;
					}
				}
			}
			return null;
		}

		private void SetLiveSettings()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			((Transform)_panel).localScale = Vector3.one * _scale.Value;
			if ((Object)(object)_nativeShakeRoot != (Object)null && (Object)(object)_nativeTimeBar != (Object)null && (Object)(object)((Transform)_panel).parent == (Object)(object)_nativeShakeRoot)
			{
				((Graphic)_nativeTimeBar).rectTransform.GetWorldCorners(_timeBarCorners);
				Vector3 val = (_timeBarCorners[0] + _timeBarCorners[3]) * 0.5f;
				Vector3 val2 = ((Transform)_nativeShakeRoot).InverseTransformPoint(val);
				float num = Mathf.Max(0f, _topOffset.Value - 125f);
				((Transform)_panel).localPosition = new Vector3(val2.x, val2.y - num, 0f);
				((Transform)_panel).localRotation = Quaternion.identity;
			}
			else
			{
				_panel.anchoredPosition = new Vector2(0f, 0f - _topOffset.Value);
			}
		}

		private static Color CountdownColour(double seconds, float opacity)
		{
			//IL_001c: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			if (seconds <= 5.0)
			{
				return new Color(1f, 0.24f, 0.13f, opacity);
			}
			if (seconds <= 10.0)
			{
				return new Color(1f, 0.53f, 0.08f, opacity);
			}
			return new Color(1f, 1f, 1f, opacity);
		}

		private void AssignVisible(bool visible)
		{
			if ((Object)(object)_root != (Object)null && _root.activeSelf != visible)
			{
				_root.SetActive(visible);
			}
			if ((Object)(object)_panel != (Object)null && ((Component)_panel).gameObject.activeSelf != visible)
			{
				((Component)_panel).gameObject.SetActive(visible);
			}
		}

		public override void Shutdown()
		{
			if ((Object)(object)_panel != (Object)null && ((Object)(object)_root == (Object)null || (Object)(object)((Component)_panel).transform.parent != (Object)(object)_root.transform))
			{
				Object.Destroy((Object)(object)((Component)_panel).gameObject);
			}
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_panel = null;
			_root = null;
		}
	}
	internal sealed class CreatureHealthModule : FeatureModule
	{
		private sealed class HealthRow
		{
			internal Creature Target;

			internal RectTransform Root;

			internal CanvasGroup Group;

			internal RectTransform MoveRoot;

			internal RectTransform RotateRoot;

			internal TextMeshProUGUI NameText;

			internal TextMeshProUGUI HpText;

			internal Image Health;

			internal Image HealthLerped;

			internal Vector3 StartPosition;

			internal Vector3 Velocity;

			internal Vector3 AngularVelocity;

			internal int ShownHp = -1;

			internal int ShownMaxHp = -1;

			internal float PredictionUntil;

			internal bool Fading;

			internal float FadeStartedAt;
		}

		private const float ShakeForce = 750f;

		private const float PositionSpring = 1200f;

		private const float PositionDamping = 12f;

		private const float AngularShakeForce = 10f;

		private const float RotationSpring = 120f;

		private const float RotationDamping = 20f;

		private const float DeathFadeDuration = 0.5f;

		private static readonly FieldInfo MainCanvasField = AccessTools.Field(typeof(PlayerUI), "_mainCanvas");

		private static readonly FieldInfo BossNameField = AccessTools.Field(typeof(BossUI), "_bossNameText");

		private static readonly FieldInfo BossHealthField = AccessTools.Field(typeof(BossUI), "_bossHealth");

		private static readonly FieldInfo BossHealthLerpedField = AccessTools.Field(typeof(BossUI), "_bossHealthLerped");

		private static readonly FieldInfo LocalHpField = AccessTools.Field(typeof(Creature), "_localHp");

		internal static CreatureHealthModule Active;

		private ConfigEntry<float> _scale;

		private ConfigEntry<float> _opacity;

		private ConfigEntry<string> _barColour;

		private ConfigEntry<int> _maximumTargets;

		private ConfigEntry<float> _rowSpacing;

		private ConfigEntry<float> _leftOffset;

		private ConfigEntry<float> _topOffset;

		private CanvasGroup _mainCanvas;

		private RectTransform _container;

		private TextMeshProUGUI _nameTemplate;

		private Image _healthTemplate;

		private Image _lerpedTemplate;

		private readonly List<HealthRow> _rows = new List<HealthRow>();

		private float _nextTemplateSearch;

		private const float TemplateSearchInterval = 1f;

		public override string DisplayName => "Fish HP";

		public override bool WantsUpdate => true;

		public override bool WantsLateUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Fish HP", "Enabled", true, "Show health bars for living non-boss creatures damaged by the local player.");
			_scale = config.Bind<float>("Fish HP", "Scale", 0.58f, new ConfigDescription("HUD scale relative to the native boss bar.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.35f, 1f), Array.Empty<object>()));
			_opacity = config.Bind<float>("Fish HP", "Opacity", 1f, new ConfigDescription("HUD opacity.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 1f), Array.Empty<object>()));
			_barColour = config.Bind<string>("Fish HP", "BarColor", "Default", "Health fill color. Use Default or an HTML color such as #800080 or #A020F0FF.");
			_maximumTargets = config.Bind<int>("Fish HP", "MaximumTargets", 4, new ConfigDescription("Maximum number of living creature bars shown at once.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()));
			_rowSpacing = config.Bind<float>("Fish HP", "RowSpacing", 150f, new ConfigDescription("Vertical distance between creature rows before HUD scaling.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(110f, 240f), Array.Empty<object>()));
			_leftOffset = config.Bind<float>("Fish HP Position", "LeftOffset", 72f, new ConfigDescription("Distance from the left edge of the screen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 600f), Array.Empty<object>()));
			_topOffset = config.Bind<float>("Fish HP Position", "TopOffset", 54f, new ConfigDescription("Distance from the top edge of the screen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 500f), Array.Empty<object>()));
			if (Mathf.Abs(_leftOffset.Value - 36f) < 0.01f)
			{
				_leftOffset.Value = 72f;
				config.Save();
			}
		}

		public override void Initialise(Harmony harmony)
		{
			Active = this;
			harmony.PatchAll(typeof(LocalFishHitPatch));
			CompendiumPlugin.Log.LogInfo((object)"Fish HP active: tracks and vertically stacks multiple living non-boss targets.");
		}

		public override void Tick()
		{
			if (!UiSupport.GameplayHudVisible() || (Object)(object)Player.LocalPlayer == (Object)null)
			{
				AssignRootVisible(visible: false);
				return;
			}
			if (_rows.Count == 0)
			{
				AssignRootVisible(visible: false);
				return;
			}
			if ((Object)(object)_container == (Object)null)
			{
				ClearRows();
				AssignRootVisible(visible: false);
				return;
			}
			for (int num = _rows.Count - 1; num >= 0; num--)
			{
				HealthRow healthRow = _rows[num];
				if ((Object)(object)healthRow.Target == (Object)null || healthRow.Target.IsDead || healthRow.Target.Hp <= 0)
				{
					SpongeBeginDeathFade(healthRow);
				}
				if (healthRow.Fading)
				{
					float num2 = Mathf.Clamp01((Time.unscaledTime - healthRow.FadeStartedAt) / 0.5f);
					if ((Object)(object)healthRow.Group != (Object)null)
					{
						healthRow.Group.alpha = _opacity.Value * (1f - num2);
					}
					if (num2 >= 1f)
					{
						RemoveRowAt(num);
					}
				}
				else
				{
					UpdateRowValues(healthRow);
				}
			}
			TrimRows();
			SetLiveSettings();
			AssignRootVisible(_rows.Count > 0);
		}

		public override void LateTick()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			float deltaTime = Time.deltaTime;
			if (deltaTime <= 0f)
			{
				return;
			}
			foreach (HealthRow row in _rows)
			{
				if (!((Object)(object)row.MoveRoot == (Object)null) && !((Object)(object)row.RotateRoot == (Object)null) && ((Component)row.MoveRoot).gameObject.activeInHierarchy)
				{
					Vector3 val = row.StartPosition - ((Transform)row.MoveRoot).localPosition;
					row.Velocity += val * 1200f * deltaTime;
					row.Velocity -= row.Velocity * 12f * deltaTime;
					RectTransform moveRoot = row.MoveRoot;
					((Transform)moveRoot).localPosition = ((Transform)moveRoot).localPosition + row.Velocity * deltaTime;
					Quaternion localRotation = ((Transform)row.RotateRoot).localRotation;
					DazedUtils.SimulateSpringRotation(ref localRotation, ref row.AngularVelocity, Quaternion.identity, 120f, 20f);
					((Transform)row.RotateRoot).localRotation = localRotation;
				}
			}
		}

		internal void SpongeSelectTarget(Creature creature, int damage)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)creature == (Object)null || creature.IsDead || damage <= 0 || (int)creature.BossType != 0 || !RequireHud())
			{
				return;
			}
			HealthRow healthRow = FindRow(creature);
			if (healthRow == null)
			{
				healthRow = MakeRow(creature);
				if (healthRow == null)
				{
					return;
				}
				_rows.Insert(0, healthRow);
			}
			else
			{
				int num = _rows.IndexOf(healthRow);
				if (num > 0)
				{
					_rows.RemoveAt(num);
					_rows.Insert(0, healthRow);
				}
			}
			healthRow.Fading = false;
			if ((Object)(object)healthRow.Group != (Object)null)
			{
				healthRow.Group.alpha = _opacity.Value;
			}
			int num2 = Math.Max(1, creature.MaxHp);
			int num3 = Math.Max(0, Math.Min(creature.Hp, num2));
			int val = FetchLocalHp(creature, num3 - damage);
			val = Math.Max(0, Math.Min(val, num2));
			if (healthRow.ShownHp < 0 || healthRow.ShownMaxHp != num2)
			{
				float fillAmount = (float)num3 / (float)num2;
				healthRow.Health.fillAmount = fillAmount;
				healthRow.HealthLerped.fillAmount = fillAmount;
				healthRow.ShownHp = val;
				healthRow.ShownMaxHp = num2;
			}
			healthRow.PredictionUntil = Time.unscaledTime + 1f;
			SetHealth(healthRow, val, num2, shake: true);
			TrimRows();
			SetLiveSettings();
			AssignRootVisible(visible: true);
		}

		private HealthRow FindRow(Creature creature)
		{
			foreach (HealthRow row in _rows)
			{
				if ((Object)(object)row.Target == (Object)(object)creature)
				{
					return row;
				}
			}
			return null;
		}

		private static int FetchLocalHp(Creature creature, int fallback)
		{
			if (LocalHpField == null)
			{
				return fallback;
			}
			try
			{
				return (int)LocalHpField.GetValue(creature);
			}
			catch
			{
				return fallback;
			}
		}

		private void UpdateRowValues(HealthRow row)
		{
			int num = Math.Max(1, row.Target.MaxHp);
			int num2 = Math.Max(0, Math.Min(row.Target.Hp, num));
			((TMP_Text)row.NameText).text = SpongeSafeName(row.Target);
			if (!(Time.unscaledTime < row.PredictionUntil) || num2 <= row.ShownHp)
			{
				if (row.ShownMaxHp != num)
				{
					row.ShownMaxHp = num;
					row.ShownHp = num2;
					SyncHpText(row, num2, num);
					float fillAmount = (float)num2 / (float)num;
					row.Health.fillAmount = fillAmount;
					row.HealthLerped.fillAmount = fillAmount;
				}
				else if (row.ShownHp != num2)
				{
					SetHealth(row, num2, num, num2 < row.ShownHp);
				}
			}
		}

		private void SetHealth(HealthRow row, int current, int maximum, bool shake)
		{
			float num = Mathf.Clamp01((float)current / (float)Math.Max(1, maximum));
			float fillAmount = row.Health.fillAmount;
			row.Health.fillAmount = num;
			row.ShownHp = current;
			row.ShownMaxHp = maximum;
			SyncHpText(row, current, maximum);
			LeanTween.cancel(((Component)row.HealthLerped).gameObject);
			Image trail = row.HealthLerped;
			LeanTween.value(((Component)trail).gameObject, trail.fillAmount, num, 0.5f).setDelay(0.25f).setEase((LeanTweenType)9)
				.setOnUpdate((Action<float>)delegate(float value)
				{
					if ((Object)(object)trail != (Object)null)
					{
						trail.fillAmount = value;
					}
				});
			if (shake && num < fillAmount)
			{
				SetDamageShake(row, fillAmount - num);
			}
		}

		private static void SyncHpText(HealthRow row, int current, int maximum)
		{
			if (!((Object)(object)row.HpText == (Object)null))
			{
				((TMP_Text)row.HpText).text = UiSupport.RenderHp(current) + " / " + UiSupport.RenderHp(maximum);
			}
		}

		private static void SetDamageShake(HealthRow row, float healthLostRatio)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(healthLostRatio, 0.025f, 1f);
			Vector3 insideUnitSphere = Random.insideUnitSphere;
			Vector3 val = ((Vector3)(ref insideUnitSphere)).normalized * num;
			val *= ((Random.Range(0, 2) == 1) ? 1f : (-1f));
			row.Velocity = val * 750f;
			float num2 = ((Random.Range(0, 2) == 1) ? 1f : (-1f));
			row.AngularVelocity += new Vector3(0f, 0f, num2 * num * 10f);
		}

		private bool RequireHud()
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_container != (Object)null && (Object)(object)_nameTemplate != (Object)null && (Object)(object)_healthTemplate != (Object)null && (Object)(object)_lerpedTemplate != (Object)null)
			{
				return true;
			}
			if (Time.unscaledTime < _nextTemplateSearch)
			{
				return false;
			}
			SpongeDestroyHud();
			if (!AttemptFindTemplates(out var bossUi, out var mainCanvas))
			{
				_nextTemplateSearch = Time.unscaledTime + 1f;
				return false;
			}
			ref TextMeshProUGUI nameTemplate = ref _nameTemplate;
			object? value = BossNameField.GetValue(bossUi);
			nameTemplate = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
			ref Image healthTemplate = ref _healthTemplate;
			object? value2 = BossHealthField.GetValue(bossUi);
			healthTemplate = (Image)((value2 is Image) ? value2 : null);
			ref Image lerpedTemplate = ref _lerpedTemplate;
			object? value3 = BossHealthLerpedField.GetValue(bossUi);
			lerpedTemplate = (Image)((value3 is Image) ? value3 : null);
			if ((Object)(object)_nameTemplate == (Object)null || (Object)(object)_healthTemplate == (Object)null || (Object)(object)_lerpedTemplate == (Object)null)
			{
				_nextTemplateSearch = Time.unscaledTime + 1f;
				return false;
			}
			_mainCanvas = mainCanvas;
			GameObject val = new GameObject("SpongeMods_FishHpHud", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)mainCanvas).transform, false);
			_container = val.GetComponent<RectTransform>();
			_container.anchorMin = new Vector2(0f, 1f);
			_container.anchorMax = new Vector2(0f, 1f);
			_container.pivot = new Vector2(0f, 1f);
			_container.sizeDelta = new Vector2(1200f, 1200f);
			SetLiveSettings();
			return true;
		}

		private HealthRow MakeRow(Creature creature)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_container == (Object)null || (Object)(object)_nameTemplate == (Object)null || (Object)(object)_healthTemplate == (Object)null || (Object)(object)_lerpedTemplate == (Object)null)
			{
				return null;
			}
			HealthRow healthRow = new HealthRow
			{
				Target = creature
			};
			GameObject val = new GameObject("FishHp_" + SpongeSafeName(creature), new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasGroup)
			});
			val.transform.SetParent((Transform)(object)_container, false);
			healthRow.Root = val.GetComponent<RectTransform>();
			healthRow.Group = val.GetComponent<CanvasGroup>();
			healthRow.Root.anchorMin = new Vector2(0f, 1f);
			healthRow.Root.anchorMax = new Vector2(0f, 1f);
			healthRow.Root.pivot = new Vector2(0f, 1f);
			healthRow.Root.sizeDelta = new Vector2(1200f, 145f);
			healthRow.MoveRoot = UiSupport.MakeRect("FishHpMove", (Transform)(object)healthRow.Root);
			UiSupport.SpongeStretchToParent(healthRow.MoveRoot);
			healthRow.StartPosition = ((Transform)healthRow.MoveRoot).localPosition;
			healthRow.RotateRoot = UiSupport.MakeRect("FishHpRotate", (Transform)(object)healthRow.MoveRoot);
			UiSupport.SpongeStretchToParent(healthRow.RotateRoot);
			Rect rect = ((Graphic)_healthTemplate).rectTransform.rect;
			Vector2 size = ((Rect)(ref rect)).size;
			if (size.x < 100f)
			{
				size.x = 1065f;
			}
			if (size.y < 12f)
			{
				size.y = 38f;
			}
			healthRow.NameText = Object.Instantiate<TextMeshProUGUI>(_nameTemplate, (Transform)(object)healthRow.RotateRoot);
			((Object)healthRow.NameText).name = "FishName";
			SpongePrepareText(healthRow.NameText);
			((TMP_Text)healthRow.NameText).alignment = (TextAlignmentOptions)257;
			RectTransform rectTransform = ((TMP_Text)healthRow.NameText).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(0f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = new Vector2(Mathf.Max(200f, size.x - 340f), 48f);
			healthRow.HpText = Object.Instantiate<TextMeshProUGUI>(_nameTemplate, (Transform)(object)healthRow.RotateRoot);
			((Object)healthRow.HpText).name = "FishHpText";
			SpongePrepareText(healthRow.HpText);
			((TMP_Text)healthRow.HpText).alignment = (TextAlignmentOptions)260;
			RectTransform rectTransform2 = ((TMP_Text)healthRow.HpText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 1f);
			rectTransform2.anchorMax = new Vector2(0f, 1f);
			rectTransform2.pivot = new Vector2(1f, 1f);
			rectTransform2.anchoredPosition = new Vector2(size.x, 0f);
			rectTransform2.sizeDelta = new Vector2(320f, 48f);
			RectTransform val2 = UiSupport.MakeRect("FishHealthBar", (Transform)(object)healthRow.RotateRoot);
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(0f, 1f);
			val2.pivot = new Vector2(0f, 1f);
			val2.anchoredPosition = new Vector2(0f, -52f);
			val2.sizeDelta = size;
			Image obj = MakeNativeImage("Border", (Transform)(object)val2, _lerpedTemplate, filled: false);
			AssignImageRect(((Graphic)obj).rectTransform, new Vector2(-4f, -4f), new Vector2(4f, 4f));
			((Graphic)obj).color = Color.white;
			Image obj2 = MakeNativeImage("Background", (Transform)(object)val2, _healthTemplate, filled: false);
			AssignImageRect(((Graphic)obj2).rectTransform, Vector2.zero, Vector2.zero);
			((Graphic)obj2).color = new Color(0.055f, 0.075f, 0.12f, 0.9f);
			healthRow.HealthLerped = MakeNativeImage("DamageTrail", (Transform)(object)val2, _lerpedTemplate, filled: true);
			AssignImageRect(((Graphic)healthRow.HealthLerped).rectTransform, Vector2.zero, Vector2.zero);
			((Graphic)healthRow.HealthLerped).color = ((Graphic)_lerpedTemplate).color;
			healthRow.Health = MakeNativeImage("Health", (Transform)(object)val2, _healthTemplate, filled: true);
			AssignImageRect(((Graphic)healthRow.Health).rectTransform, Vector2.zero, Vector2.zero);
			((Graphic)healthRow.Health).color = UiSupport.ResolveColour(_barColour.Value, GameInfo.RedColor);
			((TMP_Text)healthRow.NameText).text = SpongeSafeName(creature);
			((TMP_Text)healthRow.HpText).text = string.Empty;
			healthRow.Group.alpha = _opacity.Value;
			return healthRow;
		}

		private static void SpongePrepareText(TextMeshProUGUI text)
		{
			//IL_0020: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			((Component)text).gameObject.SetActive(true);
			((Behaviour)text).enabled = true;
			((Graphic)text).raycastTarget = false;
			((Transform)((TMP_Text)text).rectTransform).localScale = Vector3.one;
			((Transform)((TMP_Text)text).rectTransform).localRotation = Quaternion.identity;
			((TMP_Text)text).margin = Vector4.zero;
			((TMP_Text)text).enableAutoSizing = false;
			((TMP_Text)text).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)text).overflowMode = (TextOverflowModes)0;
		}

		private static Image MakeNativeImage(string name, Transform parent, Image template, bool filled)
		{
			//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_007d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = template.sprite;
			component.overrideSprite = template.overrideSprite;
			((Graphic)component).material = ((Graphic)template).material;
			component.preserveAspect = false;
			((Graphic)component).raycastTarget = false;
			component.type = (Type)(filled ? 3 : ((int)SpongeBorderImageType(template)));
			if (filled)
			{
				component.fillMethod = (FillMethod)0;
				component.fillOrigin = 0;
				component.fillClockwise = true;
				component.fillAmount = 1f;
			}
			return component;
		}

		private static Type SpongeBorderImageType(Image template)
		{
			//IL_0014: 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 ((Object)(object)template.sprite != (Object)null)
			{
				Vector4 border = template.sprite.border;
				if (((Vector4)(ref border)).sqrMagnitude > 0f)
				{
					return (Type)1;
				}
			}
			return (Type)0;
		}

		private static void AssignImageRect(RectTransform rect, Vector2 minimumOffset, Vector2 maximumOffset)
		{
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = minimumOffset;
			rect.offsetMax = maximumOffset;
			((Transform)rect).localScale = Vector3.one;
			((Transform)rect).localRotation = Quaternion.identity;
		}

		private static bool AttemptFindTemplates(out BossUI bossUi, out CanvasGroup mainCanvas)
		{
			bossUi = null;
			mainCanvas = null;
			if (MainCanvasField == null || BossNameField == null || BossHealthField == null || BossHealthLerpedField == null)
			{
				return false;
			}
			PlayerUI[] array = Resources.FindObjectsOfTypeAll<PlayerUI>();
			foreach (PlayerUI val in array)
			{
				if (!((Object)(object)val == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					object? value = MainCanvasField.GetValue(val);
					CanvasGroup val2 = (CanvasGroup)((value is CanvasGroup) ? value : null);
					if (val2 != null)
					{
						mainCanvas = val2;
						break;
					}
				}
			}
			if ((Object)(object)mainCanvas == (Object)null)
			{
				return false;
			}
			BossUI[] array2 = Resources.FindObjectsOfTypeAll<BossUI>();
			foreach (BossUI val3 in array2)
			{
				if (!((Object)(object)val3 == (Object)null) && ((Component)val3).gameObject.activeInHierarchy && BossNameField.GetValue(val3) != null && BossHealthField.GetValue(val3) != null && BossHealthLerpedField.GetValue(val3) != null)
				{
					bossUi = val3;
					break;
				}
			}
			return (Object)(object)bossUi != (Object)null;
		}

		private static string SpongeSafeName(Creature creature)
		{
			try
			{
				string name = ((Item)creature).GetName();
				return string.IsNullOrEmpty(name) ? "Fish" : name;
			}
			catch
			{
				return "Fish";
			}
		}

		private void SetLiveSettings()
		{
			//IL_002c: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_container == (Object)null)
			{
				return;
			}
			_container.anchoredPosition = new Vector2(_leftOffset.Value, 0f - _topOffset.Value);
			((Transform)_container).localScale = Vector3.one * _scale.Value;
			Color color = UiSupport.ResolveColour(_barColour.Value, GameInfo.RedColor);
			for (int i = 0; i < _rows.Count; i++)
			{
				HealthRow healthRow = _rows[i];
				healthRow.Root.anchoredPosition = new Vector2(0f, (float)(-i) * _rowSpacing.Value);
				if (!healthRow.Fading)
				{
					healthRow.Group.alpha = _opacity.Value;
				}
				if ((Object)(object)healthRow.Health != (Object)null)
				{
					((Graphic)healthRow.Health).color = color;
				}
			}
		}

		private void SpongeBeginDeathFade(HealthRow row)
		{
			if (!row.Fading)
			{
				row.Fading = true;
				row.FadeStartedAt = Time.unscaledTime;
				if ((Object)(object)row.HealthLerped != (Object)null)
				{
					LeanTween.cancel(((Component)row.HealthLerped).gameObject);
				}
			}
		}

		private void TrimRows()
		{
			int num = Mathf.Clamp(_maximumTargets.Value, 1, 8);
			while (_rows.Count > num)
			{
				RemoveRowAt(_rows.Count - 1);
			}
		}

		private void RemoveRowAt(int index)
		{
			if (index >= 0 && index < _rows.Count)
			{
				HealthRow healthRow = _rows[index];
				_rows.RemoveAt(index);
				if ((Object)(object)healthRow.HealthLerped != (Object)null)
				{
					LeanTween.cancel(((Component)healthRow.HealthLerped).gameObject);
				}
				if ((Object)(object)healthRow.Root != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)healthRow.Root).gameObject);
				}
			}
		}

		private void ClearRows()
		{
			for (int num = _rows.Count - 1; num >= 0; num--)
			{
				RemoveRowAt(num);
			}
		}

		private void AssignRootVisible(bool visible)
		{
			if ((Object)(object)_container != (Object)null && ((Component)_container).gameObject.activeSelf != visible)
			{
				((Component)_container).gameObject.SetActive(visible);
			}
		}

		private void SpongeDestroyHud()
		{
			ClearRows();
			if ((Object)(object)_container != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_container).gameObject);
			}
			_mainCanvas = null;
			_container = null;
			_nameTemplate = null;
			_healthTemplate = null;
			_lerpedTemplate = null;
		}

		public override void Shutdown()
		{
			SpongeDestroyHud();
			if (Active == this)
			{
				Active = null;
			}
		}
	}
	[HarmonyPatch(typeof(Creature), "LocalHit")]
	internal static class LocalFishHitPatch
	{
		private static void Postfix(Creature __instance, Player player, int damage, bool fromNpc)
		{
			CreatureHealthModule active = CreatureHealthModule.Active;
			if (active == null || (Object)(object)__instance == (Object)null || (Object)(object)player == (Object)null || fromNpc || damage <= 0)
			{
				return;
			}
			try
			{
				if (((NetworkBehaviour)player).Owner == (NetworkConnection)null || !((NetworkBehaviour)player).Owner.IsLocalClient)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			active.SpongeSelectTarget(__instance, damage);
		}
	}
}
namespace SpongeMods.SpongeTweaks.Gameplay
{
	internal sealed class FairSlotsModule : FeatureModule
	{
		public override string DisplayName => "Fairer Slots";

		public override void BindConfiguration(ConfigFile config)
		{
			ModuleEnabled = config.Bind<bool>("Fairer Slots", "Enabled", true, "Reroll duplicate skins on the drip machine so a spin never gives you something you already own.");
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(SlotMachineRollPatch));
			CompendiumPlugin.Log.LogInfo((object)"Fairer Slots active: the drip machine will reroll duplicate skins.");
		}
	}
	[HarmonyPatch(typeof(SlotMachine), "Roll")]
	internal static class SlotMachineRollPatch
	{
		private const int MaximumRerollAttempts = 30;

		private static readonly FieldInfo LocalSaveField = AccessTools.Field(typeof(SaveManager), "_curLocalSave");

		private static void Prefix(Player roller, byte[] itemIDs, byte[] itemSkins, byte rolled)
		{
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)roller == (Object)null || ((NetworkBehaviour)roller).Owner == (NetworkConnection)null || !((NetworkBehaviour)roller).Owner.IsLocalClient || itemIDs == null || itemSkins == null || rolled >= itemIDs.Length || rolled >= itemSkins.Length)
			{
				return;
			}
			byte b = itemIDs[rolled];
			byte b2 = itemSkins[rolled];
			if (!HasAlreadyUnlocked(b, b2))
			{
				return;
			}
			object obj;
			if (b == byte.MaxValue)
			{
				obj = (Object.op_Implicit((Object)(object)BoatManager.Boat) ? BoatManager.Boat.SkinPreset : null);
			}
			else
			{
				Item obj2 = GameInfo.IDToItem(b);
				obj = ((obj2 != null) ? obj2.SkinPreset : null);
			}
			SkinPreset val = (SkinPreset)obj;
			if ((Object)(object)val == (Object)null || val.Skins == null || b2 >= val.Skins.Count)
			{
				return;
			}
			ItemSkin val2 = val.Skins[b2];
			Rarity rarity = ((ItemSkin)(ref val2)).Rarity;
			if (SlotMachine.AvailableItems == null)
			{
				return;
			}
			List<Item> list = new List<Item>(SlotMachine.AvailableItems);
			if (!SlotMachine.ExcludeBoat)
			{
				list.Add(null);
			}
			if (list.Count == 0)
			{
				return;
			}
			for (int i = 0; i < 30; i++)
			{
				Item val3 = list[Random.Range(0, list.Count)];
				SkinPreset val4 = (Object.op_Implicit((Object)(object)val3) ? val3.SkinPreset : (Object.op_Implicit((Object)(object)BoatManager.Boat) ? BoatManager.Boat.SkinPreset : null));
				if (!((Object)(object)val4 == (Object)null))
				{
					byte randomSkinIndex = val4.GetRandomSkinIndex(rarity);
					byte b3 = (Object.op_Implicit((Object)(object)val3) ? val3.ID : byte.MaxValue);
					if (!HasAlreadyUnlocked(b3, randomSkinIndex))
					{
						itemIDs[rolled] = b3;
						itemSkins[rolled] = randomSkinIndex;
						break;
					}
				}
			}
		}

		private static bool HasAlreadyUnlocked(byte itemId, byte skinIndex)
		{
			if (LocalSaveField == null)
			{
				return false;
			}
			object? value = LocalSaveField.GetValue(null);
			LocalSaveObject val = (LocalSaveObject)((value is LocalSaveObject) ? value : null);
			if (val == null)
			{
				return false;
			}
			if (itemId == byte.MaxValue)
			{
				if (val.UnlockedBoatSkins != null)
				{
					return val.UnlockedBoatSkins.Contains(skinIndex);
				}
				return false;
			}
			if (val.UnlockedItemSkins == null)
			{
				return false;
			}
			foreach (SavedItemSkin unlockedItemSkin in val.UnlockedItemSkins)
			{
				if (unlockedItemSkin.ID == itemId)
				{
					return unlockedItemSkin.SkinsUnlocked != null && unlockedItemSkin.SkinsUnlocked.Contains(skinIndex);
				}
			}
			return false;
		}
	}
	internal sealed class ShotgunJumpModule : FeatureModule
	{
		internal static ConfigEntry<float> KnockbackPower;

		public override string DisplayName => "Shotgun Jump";

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Shotgun Jump", "Enabled", true, "Give shotgun-style weapons enough recoil to launch yourself with.");
			KnockbackPower = config.Bind<float>("Shotgun Jump", "Power", 25f, new ConfigDescription("Recoil knockback applied to weapons that fire more than one projectile per shot.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 35f), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(ShotgunRecoilPatch));
			CompendiumPlugin.Log.LogInfo((object)"Shotgun Jump active.");
		}
	}
	[HarmonyPatch(typeof(Weapon), "Awake")]
	internal static class ShotgunRecoilPatch
	{
		[HarmonyPostfix]
		public static void Postfix(Weapon __instance)
		{
			if (Traverse.Create((object)__instance).Field<int>("_projectileCountPerShot").Value > 1)
			{
				float value = ShotgunJumpModule.KnockbackPower.Value;
				Traverse.Create((object)__instance).Field<int>("_recoilKnockback").Value = Mathf.RoundToInt(value);
			}
		}
	}
	internal sealed class SwimmingModule : FeatureModule
	{
		public enum ToggleBinding
		{
			Off,
			On
		}

		internal static ConfigEntry<ToggleBinding> ModEnabled;

		internal static ConfigEntry<ToggleBinding> DebugLogging;

		internal static ConfigEntry<ToggleBinding> HoldToSwim;

		internal static ConfigEntry<float> SwimUpSpeed;

		internal static ConfigEntry<float> DiveSpeed;

		internal static ConfigEntry<float> SwimAcceleration;

		internal static ConfigEntry<float> SwimSpeedMultiplier;

		internal static ConfigEntry<ToggleBinding> WaterSpeedClamp;

		internal static ConfigEntry<float> WaterSpeedHeadroom;

		internal static ConfigEntry<float> FloatDepth;

		internal static ConfigEntry<float> BuoyancySpeed;

		internal static ConfigEntry<float> SinkSpeed;

		internal static ConfigEntry<ToggleBinding> WaveAccurate;

		internal static ConfigEntry<ToggleBinding> UnlimitedStrokes;

		internal static ConfigEntry<float> StrokeForce;

		internal static ConfigEntry<float> StrokeSoundInterval;

		internal static ConfigEntry<int> UnderwaterDamage;

		internal static ConfigEntry<float> UnderwaterDamageDelay;

		public override string DisplayName => "Better Swimming";

		public override bool Enabled
		{
			get
			{
				if (ModEnabled != null)
				{
					return ModEnabled.Value == ToggleBinding.On;
				}
				return false;
			}
		}

		internal static bool IsEnabled
		{
			get
			{
				if (ModEnabled != null)
				{
					return ModEnabled.Value == ToggleBinding.On;
				}
				return false;
			}
		}

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Expected O, but got Unknown
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Expected O, but got Unknown
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Expected O, but got Unknown
			ModEnabled = config.Bind<ToggleBinding>("Swimming - General", "Enabled", ToggleBinding.On, "Turn the whole swimming rework off without unloading it.");
			DebugLogging = config.Bind<ToggleBinding>("Swimming - General", "Debug Logging", ToggleBinding.Off, "Dumps the swim clamp numbers to the log four times a second. Only for chasing bug reports.");
			HoldToSwim = config.Bind<ToggleBinding>("Swimming - Movement", "Hold To Swim Up", ToggleBinding.On, "Hold jump to rise instead of mashing it. Off falls back to vanilla strokes.");
			SwimUpSpeed = config.Bind<float>("Swimming - Movement", "Swim Up Speed", 3.5f, new ConfigDescription("Units per second you climb while holding jump.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 15f), Array.Empty<object>()));
			DiveSpeed = config.Bind<float>("Swimming - Movement", "Dive Speed", 3f, new ConfigDescription("Units per second you go down while holding crouch. Watch the drowning timer.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			SwimAcceleration = config.Bind<float>("Swimming - Movement", "Swim Acceleration", 25f, new ConfigDescription("How hard vertical speed chases its target. Has to beat the game's extra gravity, so do not go tiny.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 100f), Array.Empty<object>()));
			SwimSpeedMultiplier = config.Bind<float>("Swimming - Movement", "Swim Speed Multiplier", 1f, new ConfigDescription("Multiplies horizontal move speed while swimming (you cannot sprint in water).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 3f), Array.Empty<object>()));
			WaterSpeedClamp = config.Bind<ToggleBinding>("Swimming - Movement", "Water Speed Clamp", ToggleBinding.On, "Caps horizontal speed while you are swimming. Off lets slide and dash mods skate you across the water forever.");
			WaterSpeedHeadroom = config.Bind<float>("Swimming - Movement", "Water Speed Clamp Headroom", 1.25f, new ConfigDescription("Multiplier on your swim speed the clamp allows before it kicks in.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f), Array.Empty<object>()));
			FloatDepth = config.Bind<float>("Swimming - Buoyancy", "Float Depth", 0.4f, new ConfigDescription("How far under the surface you settle when you are not pressing anything.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			BuoyancySpeed = config.Bind<float>("Swimming - Buoyancy", "Buoyancy Speed", 1.5f, new ConfigDescription("Cap on how fast you get pushed back up to the float depth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			SinkSpeed = config.Bind<float>("Swimming - Buoyancy", "Sink Speed", 0.35f, new ConfigDescription("Idle drift downwards once you are at the float depth. Vanilla just sinks forever.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
			WaveAccurate = config.Bind<ToggleBinding>("Swimming - Buoyancy", "Wave Accurate Water Line", ToggleBinding.On, "Use the Gerstner wave height instead of the flat water plane, so swells actually lift you.");
			UnlimitedStrokes = config.Bind<ToggleBinding>("Swimming - Strokes", "Unlimited Strokes", ToggleBinding.On, "Kills the stroke decay. Only matters when Hold To Swim Up is off.");
			StrokeForce = config.Bind<float>("Swimming - Strokes", "Stroke Force", 3f, new ConfigDescription("Little kick a jump press gives while Hold To Swim Up is on.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 15f), Array.Empty<object>()));
			StrokeSoundInterval = config.Bind<float>("Swimming - Strokes", "Stroke Sound Interval", 0.55f, new ConfigDescription("Seconds between swim sounds while you hold jump. 0 spams it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			UnderwaterDamage = config.Bind<int>("Swimming - Drowning", "Underwater Damage", 10, new ConfigDescription("Damage per half second once your head has been under too long. 0 to never drown.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			UnderwaterDamageDelay = config.Bind<float>("Swimming - Drowning", "Underwater Damage Delay", 2f, new ConfigDescription("Grace period in seconds before the drowning damage starts.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 60f), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			harmony.PatchAll(typeof(SwimMovePatch));
			harmony.PatchAll(typeof(SwimJumpPatch));
			harmony.PatchAll(typeof(SwimMoveSpeedPatch));
			harmony.PatchAll(typeof(SwimUnderwaterCheckPatch));
			harmony.PatchAll(typeof(SwimFixedUpdatePatch));
			CompendiumPlugin.Log.LogInfo((object)"Better Swimming active.");
		}

		internal static bool HasLocal(PlayerMovement movement)
		{
			if ((Object)(object)Player.LocalPlayer != (Object)null)
			{
				return (Object)(object)movement._player == (Object)(object)Player.LocalPlayer;
			}
			return false;
		}
	}
	internal static class SwimToggleExtensions
	{
		public static bool IsOn(this SwimmingModule.ToggleBinding toggle)
		{
			return toggle == SwimmingModule.ToggleBinding.On;
		}

		public static bool IsOff(this SwimmingModule.ToggleBinding toggle)
		{
			return toggle == SwimmingModule.ToggleBinding.Off;
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "Move")]
	internal static class SwimMovePatch
	{
		private static PlayerInput _input;

		private static InputAction _jump;

		private static float _nextStroke;

		private static float _swimVelocity;

		private static bool _wasSwimming;

		internal static void RaiseSwimVelocity(float velocityY)
		{
			_swimVelocity = Mathf.Max(_swimVelocity, velocityY);
			_wasSwimming = true;
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			if (!SwimmingModule.IsEnabled || !SwimmingModule.HasLocal(__instance))
			{
				return;
			}
			if (!__instance._isSwimming || __instance.OnBoat)
			{
				_wasSwimming = false;
				return;
			}
			Rigidbody rig = __instance._rig;
			float num = WaterManager.GetWaterHeight(rig.position) - rig.position.y;
			bool flag = SwimmingModule.HoldToSwim.Value.IsOn() && SpongeJumpHeld();
			float num2;
			if (flag)
			{
				num2 = SwimmingModule.SwimUpSpeed.Value;
			}
			else if (__instance._crouchInput)
			{
				num2 = 0f - SwimmingModule.DiveSpeed.Value;
			}
			else
			{
				float num3 = num - SwimmingModule.FloatDepth.Value;
				num2 = ((num3 > 0f) ? Mathf.Min(num3 * 2f, SwimmingModule.BuoyancySpeed.Value) : (0f - SwimmingModule.SinkSpeed.Value));
			}
			if (!_wasSwimming)
			{
				_swimVelocity = Mathf.Max(rig.linearVelocity.y, -10f);
				_wasSwimming = true;
			}
			_swimVelocity = Mathf.MoveTowards(_swimVelocity, num2, SwimmingModule.SwimAcceleration.Value * Time.fixedDeltaTime);
			if (!__instance.Grounded || !(num2 <= 0f))
			{
				Vector3 linearVelocity = rig.linearVelocity;
				linearVelocity.y = _swimVelocity;
				rig.linearVelocity = linearVelocity;
				PlayStrokeSound(flag);
			}
		}

		private static bool SpongeJumpHeld()
		{
			PlayerInput input = GameInfo.Input;
			if (!Object.op_Implicit((Object)(object)input))
			{
				return false;
			}
			if ((Object)(object)_input == (Object)(object)input && _jump != null)
			{
				return _jump.IsPressed();
			}
			_input = input;
			_jump = input.actions["PlayerJump"];
			return _jump.IsPressed();
		}

		private static void PlayStrokeSound(bool swimmingUp)
		{
			if (!swimmingUp)
			{
				_nextStroke = 0f;
			}
			else if (!(Time.time < _nextStroke))
			{
				_nextStroke = Time.time + SwimmingModule.StrokeSoundInterval.Value;
				AudioManager.PlayRandomGlobalClip(GameInfo.WaterStepSound, 1, GameInfo.StepSoundCount, true, 0.2f, 0.1f);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "Jump")]
	internal static class SwimJumpPatch
	{
		private static bool Prefix(PlayerMovement __instance)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!SwimmingModule.IsEnabled)
			{
				return true;
			}
			if (!__instance._isSwimming || __instance.Grounded)
			{
				return true;
			}
			if (!SwimmingModule.HasLocal(__instance))
			{
				return true;
			}
			if (SwimmingModule.HoldToSwim.Value.IsOn() && WaterManager.GetWaterHeight(__instance._rig.position) - __instance._rig.position.y > SwimmingModule.FloatDepth.Value)
			{
				Vector3 linearVelocity = __instance._rig.linearVelocity;
				linearVelocity.y = Mathf.Max(linearVelocity.y, SwimmingModule.StrokeForce.Value);
				__instance._rig.linearVelocity = linearVelocity;
				return false;
			}
			if (SwimmingModule.UnlimitedStrokes.Value.IsOn())
			{
				__instance._swimJumpCount = 0;
			}
			return true;
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (SwimmingModule.IsEnabled && SwimmingModule.HasLocal(__instance) && __instance._isSwimming)
			{
				SwimMovePatch.RaiseSwimVelocity(__instance._rig.linearVelocity.y);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "UpdateMoveSpeed")]
	internal static class SwimMoveSpeedPatch
	{
		private static void Postfix(PlayerMovement __instance)
		{
			if (SwimmingModule.IsEnabled && __instance._isSwimming && SwimmingModule.HasLocal(__instance))
			{
				__instance._curMoveSpeed *= SwimmingModule.SwimSpeedMultiplier.Value;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "UnderWaterCheck")]
	internal static class SwimUnderwaterCheckPatch
	{
		private static void Prefix(PlayerMovement __instance)
		{
			if (SwimmingModule.IsEnabled && SwimmingModule.HasLocal(__instance))
			{
				__instance._damageFromWater = SwimmingModule.UnderwaterDamage.Value;
				__instance._underwaterDamageDelay = SwimmingModule.UnderwaterDamageDelay.Value;
			}
		}

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_002c: 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_0033: 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)
			if (SwimmingModule.IsEnabled && SwimmingModule.HasLocal(__instance) && !SwimmingModule.WaveAccurate.Value.IsOff())
			{
				Vector3 position = __instance._player.Transform.position;
				__instance._isSwimming = position.y <= WaterManager.GetWaterHeight(position);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerMovement), "FixedUpdate")]
	[HarmonyPriority(0)]
	[HarmonyAfter(new string[] { "com.hatsuneexo.htfslide" })]
	internal static class SwimFixedUpdatePatch
	{
		private static bool _waterLatched;

		private static float _nextLog;

		private static void Postfix(PlayerMovement __instance)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			if (!SwimmingModule.IsEnabled || SwimmingModule.WaterSpeedClamp.Value.IsOff() || !SwimmingModule.HasLocal(__instance))
			{
				return;
			}
			if (SwimmingModule.DebugLogging.Value.IsOn() && Time.time >= _nextLog)
			{
				_nextLog = Time.time + 0.25f;
				Vector3 linearVelocity = __instance._rig.linearVelocity;
				ManualLogSource log = CompendiumPlugin.Log;
				string text = $"swim={__instance._isSwimming} ground={__instance.Grounded} latch={_waterLatched} ";
				Vector2 val = new Vector2(linearVelocity.x, linearVelocity.z);
				log.LogInfo((object)(text + $"flat={((Vector2)(ref val)).magnitude:0.00} " + $"curMove={__instance._curMoveSpeed:0.00} walk={__instance._walkSpeed:0.00}"));
			}
			if (__instance.Grounded || __instance.OnBoat)
			{
				_waterLatched = false;
				return;
			}
			if (__instance._isSwimming)
			{
				_waterLatched = true;
			}
			if (_waterLatched)
			{
				SlideMomentumBridge.Kill(__instance);
				float num = Mathf.Max(Mathf.Min(__instance._curMoveSpeed, __instance._walkSpeed * SwimmingModule.SwimSpeedMultiplier.Value), 0.01f) * SwimmingModule.WaterSpeedHeadroom.Value;
				Vector3 linearVelocity2 = __instance._rig.linearVelocity;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(linearVelocity2.x, 0f, linearVelocity2.z);
				if (!(((Vector3)(ref val2)).sqrMagnitude <= num * num))
				{
					val2 = ((Vector3)(ref val2)).normalized * num;
					__instance._rig.linearVelocity = new Vector3(val2.x, linearVelocity2.y, val2.z);
					__instance._curVel = new Vector3(val2.x, __instance._curVel.y, val2.z);
				}
			}
		}
	}
	internal static class SlideMomentumBridge
	{
		private static bool _resolved;

		private static FieldInfo _airborne;

		private static FieldInfo _momentumSpeed;

		private static MethodInfo _endAirMomentum;

		internal static void Kill(PlayerMovement movement)
		{
			if (!_resolved)
			{
				SpongeResolve();
			}
			if (!(_airborne == null))
			{
				if ((bool)_airborne.GetValue(null) && _endAirMomentum != null)
				{
					_endAirMomentum.Invoke(null, new object[1] { movement });
				}
				_momentumSpeed?.SetValue(null, 0f);
			}
		}

		private static void SpongeResolve()
		{
			_resolved = true;
			Type type = AccessTools.TypeByName("HTFSlide.SlidePatch");
			if (!(type == null))
			{
				_airborne = AccessTools.Field(type, "_airborne");
				_momentumSpeed = AccessTools.Field(type, "_momentumSpeed");
				_endAirMomentum = AccessTools.Method(type, "EndAirMomentum", (Type[])null, (Type[])null);
			}
		}
	}
}
namespace SpongeMods.SpongeTweaks.Cosmetic
{
	internal sealed class LaserSightModule : FeatureModule
	{
		internal static ConfigEntry<Color> LaserColour;

		internal static ConfigEntry<float> LaserWidth;

		internal static ConfigEntry<float> EmissionIntensity;

		internal static ConfigEntry<KeyCode> CycleColourKey;

		internal static ConfigEntry<KeyCode> CycleIntensityKey;

		internal static ManualLogSource Log;

		private static readonly Color[] ColourPresets = (Color[])(object)new Color[7]
		{
			Color.red,
			Color.green,
			Color.blue,
			Color.yellow,
			Color.cyan,
			Color.magenta,
			Color.white
		};

		private static readonly string[] ColourPresetNames = new string[7] { "Red", "Green", "Blue", "Yellow", "Cyan", "Magenta", "White" };

		private static readonly float[] IntensityPresets = new float[5] { 1f, 3f, 6f, 10f, 15f };

		private int _colourIndex;

		private int _intensityIndex = 1;

		public override string DisplayName => "Laser Sight Editor";

		public override bool WantsUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			ModuleEnabled = config.Bind<bool>("Laser Sight", "Enabled", true, "Recolour the weapon laser sight and allow cycling presets with hotkeys.");
			LaserColour = config.Bind<Color>("Laser Sight", "Color", Color.green, "Laser sight color");
			LaserWidth = config.Bind<float>("Laser Sight", "Width", 0.02f, "Laser line width");
			EmissionIntensity = config.Bind<float>("Laser Sight", "EmissionIntensity", 3f, "HDR glow brightness multiplier");
			CycleColourKey = config.Bind<KeyCode>("Laser Sight Hotkeys", "CycleColorKey", (KeyCode)290, "Key to cycle through preset laser colors");
			CycleIntensityKey = config.Bind<KeyCode>("Laser Sight Hotkeys", "CycleIntensityKey", (KeyCode)291, "Key to cycle through preset glow intensities");
		}

		public override void Initialise(Harmony harmony)
		{
			Log = CompendiumPlugin.Log;
			harmony.PatchAll(typeof(LaserSightLinePatch));
			Log.LogInfo((object)"Laser Sight Editor active.");
		}

		public override void Tick()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown(CycleColourKey.Value))
			{
				_colourIndex = (_colourIndex + 1) % ColourPresets.Length;
				LaserColour.Value = ColourPresets[_colourIndex];
				Log.LogInfo((object)("Laser color changed to: " + ColourPresetNames[_colourIndex]));
			}
			if (Input.GetKeyDown(CycleIntensityKey.Value))
			{
				_intensityIndex = (_intensityIndex + 1) % IntensityPresets.Length;
				EmissionIntensity.Value = IntensityPresets[_intensityIndex];
				Log.LogInfo((object)("Laser glow intensity changed to: " + IntensityPresets[_intensityIndex]));
			}
		}
	}
	[HarmonyPatch(typeof(LaserSight), "SetLine")]
	internal static class LaserSightLinePatch
	{
		private static void Postfix(LaserSight __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer value = Traverse.Create((object)__instance).Field("_line").GetValue<LineRenderer>();
			if ((Object)(object)value == (Object)null)
			{
				return;
			}
			Color val = (value.endColor = (value.startColor = LaserSightModule.LaserColour.Value));
			value.widthMultiplier = LaserSightModule.LaserWidth.Value;
			Material[] materials = ((Renderer)value).materials;
			Material[] array = materials;
			foreach (Material val3 in array)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					if (val3.HasProperty("_Color"))
					{
						val3.SetColor("_Color", val);
					}
					if (val3.HasProperty("_Emission"))
					{
						val3.SetColor("_Emission", val * LaserSightModule.EmissionIntensity.Value);
					}
				}
			}
			((Renderer)value).materials = materials;
		}
	}
}
namespace SpongeMods.SpongeTweaks.Abilities
{
	internal static class BeamEffects
	{
		private static Material CreateMaterial(Color colour)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Sprites/Default"));
			string[] array = new string[3] { "_BaseColor", "_Color", "_EmissionColor" };
			foreach (string text in array)
			{
				if (val.HasProperty(text))
				{
					val.SetColor(text, colour);
				}
			}
			val.color = colour;
			if (val.HasProperty("_Surface"))
			{
				val.SetFloat("_Surface", 1f);
			}
			if (val.HasProperty("_Blend"))
			{
				val.SetFloat("_Blend", 1f);
			}
			if (val.HasProperty("_SrcBlend"))
			{
				val.SetFloat("_SrcBlend", 5f);
			}
			if (val.HasProperty("_DstBlend"))
			{
				val.SetFloat("_DstBlend", 1f);
			}
			if (val.HasProperty("_ZWrite"))
			{
				val.SetFloat("_ZWrite", 0f);
			}
			val.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
			val.EnableKeyword("_EMISSION");
			val.renderQueue = 3000;
			return val;
		}

		private static GameObject CreatePrimitive(PrimitiveType type, Color colour)
		{
			//IL_0000: 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)
			GameObject obj = GameObject.CreatePrimitive(type);
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Renderer component2 = obj.GetComponent<Renderer>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.material = CreateMaterial(colour);
			}
			return obj;
		}

		internal static GameObject SpongeSpawnCharge(Transform camera, Color colour)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_0097: Expected O, but got Unknown
			GameObject val = new GameObject("VoidBeamCharge");
			val.transform.SetParent(camera, false);
			val.transform.localPosition = new Vector3(0f, -0.18f, 1.1f);
			ComposeSphere(val.transform, new Color(1f, 0.16f, 0.22f));
			ComposeSphere(val.transform, new Color(0.24f, 0.45f, 1f));
			Light obj = val.AddComponent<Light>();
			obj.color = colour;
			obj.range = 10f;
			obj.intensity = 0f;
			return val;
		}

		private static void ComposeSphere(Transform parent, Color colour)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreatePrimitive((PrimitiveType)0, colour);
			val.transform.SetParent(parent, false);
			GameObject obj = CreatePrimitive((PrimitiveType)0, new Color(colour.r, colour.g, colour.b, 0.35f));
			obj.transform.SetParent(val.transform, false);
			obj.transform.localScale = Vector3.one * 1.9f;
		}

		internal static void TweenCharge(GameObject charge, float t)
		{
			//IL_006b: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)charge == (Object)null))
			{
				t = Mathf.Clamp01(t);
				float num = Mathf.Lerp(0.55f, 0.02f, t * t);
				float num2 = Mathf.Lerp(0.1f, 0.3f, t);
				float num3 = t * 900f;
				Transform transform = charge.transform;
				if (transform.childCount >= 2)
				{
					Vector3 val = new Vector3(Mathf.Cos(num3 * (MathF.PI / 180f)), Mathf.Sin(num3 * (MathF.PI / 180f)), 0f) * num;
					transform.GetChild(0).localPosition = val;
					transform.GetChild(1).localPosition = -val;
					transform.GetChild(0).localScale = Vector3.one * num2;
					transform.GetChild(1).localScale = Vector3.one * num2;
				}
				Light component = charge.GetComponent<Light>();
				if ((Object)(object)component != (Object)null)
				{
					component.intensity = Mathf.Lerp(0f, 14f, t * t);
				}
			}
		}

		internal static void SpongeSpawnOrb(Vector3 origin, Vector3 direction, Color colour, bool dealsDamage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreatePrimitive((PrimitiveType)0, colour);
			((Object)val).name = "VoidBeamOrb";
			val.transform.position = origin;
			val.transform.localScale = Vector3.one * VoidBeamModule.Radius.Value;
			TrailRenderer obj = val.AddComponent<TrailRenderer>();
			obj.time = 0.6f;
			obj.startWidth = VoidBeamModule.Radius.Value * 1.6f;
			obj.endWidth = 0f;
			((Renderer)obj).material = CreateMaterial(colour);
			obj.numCapVertices = 6;
			GameObject obj2 = CreatePrimitive((PrimitiveType)0, new Color(colour.r, colour.g, colour.b, 0.28f));
			obj2.transform.SetParent(val.transform, false);
			obj2.transform.localScale = Vector3.one * 2.1f;
			VoidOrb voidOrb = val.AddComponent<VoidOrb>();
			voidOrb.Direction = direction;
			voidOrb.Speed = VoidBeamModule.OrbSpeed.Value;
			voidOrb.Range = VoidBeamModule.Range.Value;
			voidOrb.Radius = VoidBeamModule.Radius.Value;
			voidOrb.DealsDamage = dealsDamage;
		}

		internal static void SpongeSpawnBeam(Vector3 origin, Vector3 direction, float range, float radius, Color colour, float seconds)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreatePrimitive((PrimitiveType)2, colour);
			((Object)obj).name = "VoidBeamShaft";
			obj.transform.position = origin + direction * (range * 0.5f);
			obj.transform.rotation = Quaternion.LookRotation(direction) * Quaternion.Euler(90f, 0f, 0f);
			obj.transform.localScale = new Vector3(radius * 0.5f, range * 0.5f, radius * 0.5f);
			Light obj2 = obj.AddComponent<Light>();
			obj2.color = colour;
			obj2.range = radius * 6f;
			obj2.intensity = 12f;
			obj.AddComponent<BeamFadeRoutine>().Seconds = seconds;
		}

		internal static void Teardown(GameObject target)
		{
			if ((Object)(object)target != (Object)null)
			{
				Object.Destroy((Object)(object)target);
			}
		}
	}
	internal sealed class VoidOrb : MonoBehaviour
	{
		internal Vector3 Direction;

		internal float Speed;

		internal float Range;

		internal float Radius;

		internal bool DealsDamage;

		private float _travelled;

		private Light _light;

		private readonly HashSet<object> _alreadyHit = new HashSet<object>();

		private void Start()
		{
			//IL_0034: 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)
			_light = ((Component)this).gameObject.AddComponent<Light>();
			Renderer component = ((Component)this).GetComponent<Renderer>();
			_light.color = (((Object)(object)component != (Object)null) ? component.material.color : Color.magenta);
			_light.range = Radius * 8f;
			_light.intensity = 14f;
		}

		private void Update()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			float num = Speed * Time.deltaTime;
			Transform transform = ((Component)this).transform;
			transform.position += Direction * num;
			_travelled += num;
			float num2 = 1f + _travelled / Mathf.Max(1f, Range) * 0.6f;
			((Component)this).transform.localScale = Vector3.one * Radius * num2;
			if (DealsDamage)
			{
				VoidAnnihilation.At(((Component)this).transform.position, Radius * num2, Direction, _alreadyHit);
			}
			if (_travelled >= Range)
			{
				Burst();
			}
		}

		private void Burst()
		{
			if ((Object)(object)_light != (Object)null)
			{
				_light.intensity = 30f;
			}
			((Component)this).gameObject.AddComponent<OrbFadeRoutine>().Seconds = 0.45f;
			Object.Destroy((Object)(object)this);
		}
	}
	internal sealed class OrbFadeRoutine : MonoBehaviour
	{
		internal float Seconds = 0.45f;

		private float _elapsed;

		private Vector3 _startScale;

		private Renderer _renderer;

		private Light _light;

		private void Start()
		{
			//IL_0007: 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)
			_startScale = ((Component)this).transform.localScale;
			_renderer = ((Component)this).GetComponent<Renderer>();
			_light = ((Component)this).GetComponent<Light>();
		}

		private void Update()
		{
			//IL_0036: 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)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			_elapsed += Time.deltaTime;
			float num = Mathf.Clamp01(_elapsed / Mathf.Max(0.01f, Seconds));
			((Component)this).transform.localScale = _startScale * Mathf.Lerp(1f, 2.6f, num);
			if ((Object)(object)_renderer != (Object)null)
			{
				Color color = _renderer.material.color;
				color.a = 1f - num;
				_renderer.material.color = color;
			}
			if ((Object)(object)_light != (Object)null)
			{
				_light.intensity = Mathf.Lerp(30f, 0f, num);
			}
			if (num >= 1f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	internal sealed class BeamFadeRoutine : MonoBehaviour
	{
		internal float Seconds = 1.4f;

		private float _elapsed;

		private Vector3 _startScale;

		private Renderer _renderer;

		private Light _light;

		private void Start()
		{
			//IL_0007: 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)
			_startScale = ((Component)this).transform.localScale;
			_renderer = ((Component)this).GetComponent<Renderer>();
			_light = ((Component)this).GetComponent<Light>();
		}

		private void Update()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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)
			_elapsed += Time.deltaTime;
			float num = Mathf.Clamp01(_elapsed / Mathf.Max(0.01f, Seconds));
			float num2 = Mathf.Lerp(1f, 2.2f, num);
			((Component)this).transform.localScale = new Vector3(_startScale.x * num2, _startScale.y, _startScale.z * num2);
			if ((Object)(object)_renderer != (Object)null)
			{
				Color color = _renderer.material.color;
				color.a = 1f - num;
				_renderer.material.color = color;
			}
			if ((Object)(object)_light != (Object)null)
			{
				_light.intensity = Mathf.Lerp(12f, 0f, num);
			}
			if (num >= 1f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
	internal static class BeamHands
	{
		private static bool _resolved;

		private static MethodInfo _setIkTarget;

		private static MethodInfo _moveToDefault;

		private static Type _armsType;

		private static Component _arms;

		private static Transform _rightTarget;

		private static Transform _leftTarget;

		private static bool _posing;

		private static void SpongeResolve()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			string[] array = new string[2] { "PlayerArms", "PlayerHands" };
			for (int i = 0; i < array.Length; i++)
			{
				Type type = AccessTools.TypeByName(array[i]);
				if (!(type == null))
				{
					MethodInfo methodInfo = AccessTools.Method(type, "SetIKTarget", (Type[])null, (Type[])null);
					if (!(methodInfo == null))
					{
						_armsType = type;
						_setIkTarget = methodInfo;
						_moveToDefault = AccessTools.Method(type, "MoveHandToDefault", (Type[])null, (Type[])null);
						break;
					}
				}
			}
			if (_setIkTarget == null)
			{
				CompendiumPlugin.Log.LogInfo((object)"No hand IK available: the void beam will have no pose.");
			}
		}

		private static Component ObtainArms()
		{
			if ((Object)(object)_arms != (Object)null)
			{
				return _arms;
			}
			if (_armsType == null)
			{
				return null;
			}
			_arms = LocalPlayerAccess.Part("Arms");
			if ((Object)(object)_arms == (Object)null)
			{
				object obj = LocalPlayerAccess.Player();
				Component val = (Component)((obj is Component) ? obj : null);
				if (val != null)
				{
					_arms = val.GetComponentInChildren(_armsType, true);
				}
			}
			return _arms;
		}

		internal static void Extend(Transform camera)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			SpongeResolve();
			if (_setIkTarget == null || !VoidBeamModule.PoseHands.Value || _posing)
			{
				return;
			}
			Component val = ObtainArms();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			_rightTarget = SpongeMakeTarget(camera, new Vector3(0.28f, -0.18f, 0.85f), "VoidBeamIkRight");
			_leftTarget = SpongeMakeTarget(camera, new Vector3(-0.28f, -0.18f, 0.85f), "VoidBeamIkLeft");
			try
			{
				_setIkTarget.Invoke(val, new object[2] { _rightTarget, _leftTarget });
				_posing = true;
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not pose the hands: " + (ex.InnerException?.Message ?? ex.Message)));
				Release();
			}
		}

		internal static void Push(float t)
		{
			//IL_004d: 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)
			if (_posing)
			{
				float num = Mathf.Lerp(0.85f, 1.35f, Mathf.Clamp01(t));
				float num2 = Mathf.Lerp(0.28f, 0.1f, Mathf.Clamp01(t));
				if ((Object)(object)_rightTarget != (Object)null)
				{
					_rightTarget.localPosition = new Vector3(num2, -0.18f, num);
				}
				if ((Object)(object)_leftTarget != (Object)null)
				{
					_leftTarget.localPosition = new Vector3(0f - num2, -0.18f, num);
				}
			}
		}

		internal static void Release()
		{
			_posing = false;
			Component val = ObtainArms();
			if ((Object)(object)val != (Object)null && _setIkTarget != null)
			{
				try
				{
					_setIkTarget.Invoke(val, new object[2]);
				}
				catch
				{
				}
				if (_moveToDefault != null)
				{
					try
					{
						_moveToDefault.Invoke(val, new object[1] { true });
						_moveToDefault.Invoke(val, new object[1] { false });
					}
					catch
					{
					}
				}
			}
			if ((Object)(object)_rightTarget != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_rightTarget).gameObject);
			}
			if ((Object)(object)_leftTarget != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_leftTarget).gameObject);
			}
			_rightTarget = null;
			_leftTarget = null;
		}

		private static Transform SpongeMakeTarget(Transform camera, Vector3 offset, string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(camera, false);
			val.transform.localPosition = offset;
			val.transform.localRotation = Quaternion.identity;
			return val.transform;
		}
	}
	internal static class EmbeddedAudioLoader
	{
		internal static readonly string[] SupportedExtensions = new string[3] { ".ogg", ".wav", ".mp3" };

		internal static bool HasSupported(string path)
		{
			string extension = Path.GetExtension(path);
			return Array.Exists(SupportedExtensions, (string candidate) => string.Equals(candidate, extension, StringComparison.OrdinalIgnoreCase));
		}

		internal static AudioType TypeOf(string path)
		{
			return (AudioType)(Path.GetExtension(path)?.ToLowerInvariant() switch
			{
				".ogg" => 14, 
				".wav" => 20, 
				".mp3" => 13, 
				_ => 0, 
			});
		}

		internal static IEnumerator Load(string source, bool stream, Action<AudioClip> onLoaded, Action<string> onError)
		{
			bool isRemote = source.StartsWith("http://", StringComparison.OrdinalIgnoreCase) || source.StartsWith("https://", StringComparison.OrdinalIgnoreCase);
			string text;
			if (isRemote)
			{
				text = source;
			}
			else
			{
				if (!File.Exists(source))
				{
					onError?.Invoke("File does not exist: " + source);
					yield break;
				}
				text = new Uri(Path.GetFullPath(source)).AbsoluteUri;
			}
			AudioType val = TypeOf(source);
			if ((int)val == 0)
			{
				onError?.Invoke("Unsupported format: " + source);
				yield break;
			}
			UnityWebRequest request = UnityWebRequestMultimedia.GetAudioClip(text, val);
			try
			{
				DownloadHandler downloadHandler = request.downloadHandler;
				DownloadHandlerAudioClip val2 = (DownloadHandlerAudioClip)(object)((downloadHandler is DownloadHandlerAudioClip) ? downloadHandler : null);
				if (val2 != null)
				{
					val2.streamAudio = stream || isRemote;
					val2.compressed = false;
				}
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					onError?.Invoke(request.error + " (" + source + ")");
					yield break;
				}
				AudioClip content;
				try
				{
					content = DownloadHandlerAudioClip.GetContent(request);
				}
				catch (Exception ex)
				{
					onError?.Invoke(ex.Message + " (" + source + ")");
					yield break;
				}
				if ((Object)(object)content == (Object)null || (int)content.loadState == 3)
				{
					onError?.Invoke("Unity could not decode " + Path.GetFileName(source) + ". If it is an MP3 with unusual tags, re-export it as OGG.");
					yield break;
				}
				((Object)content).name = (isRemote ? source : Path.GetFileNameWithoutExtension(source));
				onLoaded?.Invoke(content);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	internal static class VoidAnnihilation
	{
		private static bool _resolved;

		private static Type _creatureType;

		private static Type _creatureManagerType;

		private static Type _playerType;

		private static FieldInfo _aliveCreatures;

		private static FieldInfo _managerInstance;

		private static FieldInfo _localPlayer;

		private static MethodInfo _localHit;

		private static MethodInfo _hitCreature;

		private static MethodInfo _hitPlayer;

		private static PropertyInfo _serverInstance;

		private static PropertyInfo _dying;

		private static PropertyInfo _isDead;

		private static readonly Collider[] OverlapBuffer = (Collider[])(object)new Collider[256];

		private static void SpongeResolve()
		{
			if (!_resolved)
			{
				_resolved = true;
				_creatureType = AccessTools.TypeByName("Creature");
				_creatureManagerType = AccessTools.TypeByName("CreatureManager");
				_playerType = AccessTools.TypeByName("Player");
				if (_creatureType != null)
				{
					_localHit = AccessTools.Method(_creatureType, "LocalHit", (Type[])null, (Type[])null);
				}
				if (_creatureManagerType != null)
				{
					_aliveCreatures = AccessTools.Field(_creatureManagerType, "_aliveCreatures");
					_managerInstance = AccessTools.Field(_creatureManagerType, "_instance");
				}
				if (_playerType != null)
				{
					_localPlayer = AccessTools.Field(_playerType, "LocalPlayer");
					_dying = AccessTools.Property(_playerType, "Dying");
				}
				Type type = AccessTools.TypeByName("PlayerDying");
				if (type != null)
				{
					_isDead = AccessTools.Property(type, "IsDead");
				}
				Type type2 = AccessTools.TypeByName("Server");
				if (type2 != null)
				{
					_serverInstance = AccessTools.Property(type2, "Instance");
					_hitCreature = AccessTools.Method(type2, "HitCreature", (Type[])null, (Type[])null);
					_hitPlayer = AccessTools.Method(type2, "HitPlayer", (Type[])null, (Type[])null);
				}
				if (_hitCreature == null)
				{
					CompendiumPlugin.Log.LogWarning((object)"Cannot find Server.HitCreature: falling back to the local path, which only works properly as host.");
				}
				if (_hitPlayer == null && VoidBeamModule.HitPlayers.Value)
				{
					CompendiumPlugin.Log.LogWarning((object)"Cannot find Server.HitPlayer: the orb will not touch players.");
				}
			}
		}

		private static object SpongeServerInstance()
		{
			try
			{
				return _serverInstance?.GetValue(null);
			}
			catch
			{
				return null;
			}
		}

		private static object SpongeInstanceOf(Type type, FieldInfo field)
		{
			object obj = field?.GetValue(null);
			if (obj != null)
			{
				return obj;
			}
			if (!(type == null))
			{
				return Object.FindAnyObjectByType(type);
			}
			return null;
		}

		internal static void At(Vector3 center, float radius, Vector3 direction, HashSet<object> already)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			SpongeResolve();
			if (_creatureType == null)
			{
				return;
			}
			object obj = _localPlayer?.GetValue(null);
			int num = Physics.OverlapSphereNonAlloc(center, radius, OverlapBuffer, -1, (QueryTriggerInteraction)2);
			for (int i = 0; i < num; i++)
			{
				Collider val = OverlapBuffer[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Component componentInParent = ((Component)val).GetComponentInParent(_creatureType);
				if ((Object)(object)componentInParent != (Object)null)
				{
					if (!already.Contains(componentInParent) && (VoidBeamModule.KillBosses.Value || !IsBoss(componentInParent)))
					{
						already.Add(componentInParent);
						Hit(componentInParent, componentInParent.transform.position, direction, obj);
						VoidBeamModule.Hits++;
					}
					continue;
				}
				object obj2 = SpongeHittablePlayer(val, obj);
				if (obj2 != null && !already.Contains(obj2))
				{
					already.Add(obj2);
					HitPlayer(obj2, ((Component)obj2).transform.position, direction, obj);
					VoidBeamModule.Hits++;
				}
			}
			if (num == 0)
			{
				SpongeFromList(center, radius, direction, obj, already);
			}
		}

		private static object SpongeHittablePlayer(Collider collider, object self)
		{
			if (!VoidBeamModule.HitPlayers.Value || _playerType == null || _hitPlayer == null)
			{
				return null;
			}
			Component componentInParent = ((Component)collider).GetComponentInParent(_playerType);
			if ((Object)(object)componentInParent == (Object)null || componentInParent == self)
			{
				return null;
			}
			try
			{
				object obj = _dying?.GetValue(componentInParent);
				if (obj != null && _isDead != null && (bool)_isDead.GetValue(obj))
				{
					return null;
				}
			}
			catch
			{
			}
			return componentInParent;
		}

		private static void SpongeFromList(Vector3 center, float radius, Vector3 direction, object player, HashSet<object> already)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			if (_aliveCreatures == null)
			{
				return;
			}
			object obj = SpongeInstanceOf(_creatureManagerType, _managerInstance);
			if (obj == null || !(_aliveCreatures.GetValue(obj) is IEnumerable source))
			{
				return;
			}
			float num = radius * radius;
			foreach (object item in source.Cast<object>().ToList())
			{
				if (item == null || already.Contains(item))
				{
					continue;
				}
				Component val = (Component)((item is Component) ? item : null);
				if (val != null && !((Object)(object)val == (Object)null))
				{
					Vector3 position = val.transform.position;
					Vector3 val2 = position - center;
					if (!(((Vector3)(ref val2)).sqrMagnitude > num) && (VoidBeamModule.KillBosses.Value || !IsBoss(item)))
					{
						already.Add(item);
						Hit(item, position, direction, player);
						VoidBeamModule.Hits++;
					}
				}
			}
		}

		private static void Hit(object creature, Vector3 position, Vector3 direction, object player)
		{
			//IL_008a: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			object obj = SpongeServerInstance();
			if (_hitCreature != null && obj != null)
			{
				try
				{
					_hitCreature.Invoke(obj, new object[5]
					{
						creature,
						player,
						VoidBeamModule.Damage.Value,
						position,
						direction
					});
					return;
				}
				catch (Exception ex)
				{
					CompendiumPlugin.Log.LogWarning((object)("Server.HitCreature failed: " + (ex.InnerException?.Message ?? ex.Message)));
				}
			}
			SpongeHitLocally(creature, position, direction, player);
		}

		private static void HitPlayer(object victim, Vector3 position, Vector3 direction, object player)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			object obj = SpongeServerInstance();
			if (_hitPlayer == null || obj == null)
			{
				return;
			}
			try
			{
				_hitPlayer.Invoke(obj, new object[6]
				{
					victim,
					VoidBeamModule.Damage.Value,
					direction * VoidBeamModule.Knockback.Value,
					position,
					(byte)1,
					player
				});
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Server.HitPlayer failed: " + (ex.InnerException?.Message ?? ex.Message)));
			}
		}

		private static void SpongeHitLocally(object creature, Vector3 position, Vector3 direction, object player)
		{
			//IL_0039: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			if (_localHit == null)
			{
				return;
			}
			Component val = (Component)((creature is Component) ? creature : null);
			if (val == null || (Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				_localHit.Invoke(creature, new object[8]
				{
					val.transform,
					position,
					direction,
					player,
					VoidBeamModule.Damage.Value,
					true,
					direction * VoidBeamModule.Knockback.Value,
					false
				});
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not damage the target: " + (ex.InnerException?.Message ?? ex.Message)));
			}
		}

		private static bool IsBoss(object creature)
		{
			PropertyInfo propertyInfo = AccessTools.Property(creature.GetType(), "IsBoss");
			if (propertyInfo == null)
			{
				return false;
			}
			try
			{
				return (bool)propertyInfo.GetValue(creature);
			}
			catch
			{
				return false;
			}
		}
	}
	internal sealed class VoidBeamModule : FeatureModule
	{
		internal static ConfigEntry<Key> FireKey;

		internal static ConfigEntry<float> ChargeTime;

		internal static ConfigEntry<float> Cooldown;

		internal static ConfigEntry<float> Range;

		internal static ConfigEntry<float> Radius;

		internal static ConfigEntry<float> BeamSeconds;

		internal static ConfigEntry<string> BeamColour;

		internal static ConfigEntry<bool> KillBosses;

		internal static ConfigEntry<bool> UseGameExplosionEffects;

		internal static ConfigEntry<string> SoundFile;

		internal static ConfigEntry<float> SoundVolume;

		internal static ConfigEntry<string> RequiredItem;

		internal static ConfigEntry<int> Damage;

		internal static ConfigEntry<float> Knockback;

		internal static ConfigEntry<float> OrbSpeed;

		internal static ConfigEntry<bool> PoseHands;

		internal static ConfigEntry<bool> HitPlayers;

		internal static AudioClip Clip;

		internal static int Hits;

		private float _lastFired = -99f;

		private bool _busy;

		public override string DisplayName => "Void Beam";

		public override bool WantsUpdate => true;

		public override void BindConfiguration(ConfigFile config)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Expected O, but got Unknown
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Expected O, but got Unknown
			ModuleEnabled = config.Bind<bool>("Void Beam", "Enabled", true, "Charge two orbs and fire a beam that annihilates everything in front of you.");
			FireKey = config.Bind<Key>("Void Beam", "FireKey", (Key)22, "Key that charges and fires. Defaults to H because the game uses V for voice chat.");
			ChargeTime = config.Bind<float>("Void Beam", "ChargeTime", 1.1f, new ConfigDescription("Seconds of charge before the shot. This is when the two spheres meet.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
			Cooldown = config.Bind<float>("Void Beam", "Cooldown", 8f, new ConfigDescription("Seconds between shots.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 120f), Array.Empty<object>()));
			Range = config.Bind<float>("Void Beam", "Range", 120f, new ConfigDescription("Beam range, in metres.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 500f), Array.Empty<object>()));
			Radius = config.Bind<float>("Void Beam", "Radius", 6f, new ConfigDescription("Annihilation radius around the beam.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 40f), Array.Empty<object>()));
			OrbSpeed = config.Bind<float>("Void Beam", "OrbSpeed", 45f, new ConfigDescription("How fast the orb travels, in metres per second. Slower looks better; faster feels heavier.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 300f), Array.Empty<object>()));
			BeamSeconds = config.Bind<float>("Void Beam Visual", "BeamSeconds", 1.4f, new ConfigDescription("How long the beam stays on screen after firing.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.2f, 6f), Array.Empty<object>()));
			BeamColour = config.Bind<string>("Void Beam Visual", "BeamColor", "9B30FF", "Beam colour as hexadecimal RRGGBB.");
			UseGameExplosionEffects = config.Bind<bool>("Void Beam Visual", "UseGameExplosionEffects", true, "Also trigger the game's own explosion effects along the beam. This is what gives it real impact; turn it off if it clutters the screen.");
			PoseHands = config.Bind<bool>("Void Beam Visual", "PoseHands", true, "Extend the hands forward during the charge using the game's own inverse kinematics. It is not the exact anime pose, but it stops you firing with your arms down.");
			KillBosses = config.Bind<bool>("Void Beam Balance", "KillBosses", true, "Whether it also annihilates bosses. Note: killing a boss at the touch of a button affects everyone's game, not just yours.");
			RequiredItem = config.Bind<string>("Void Beam Balance", "RequiredItem", "", "Name of the item you must be holding to fire. Empty means no requirement. When you fire, the log tells you what you are holding, so you know what name to put here.");
			Damage = config.Bind<int>("Void Beam Balance", "Damage", 99999, new ConfigDescription("Damage per hit. Deliberately enormous: this is an annihilation, not a weapon.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 999999), Array.Empty<object>()));
			HitPlayers = config.Bind<bool>("Void Beam Balance", "HitPlayers", true, "The orb also reaches other players. This only does anything if the host has friendly fire enabled in the game settings: that decision is theirs, not this mod's.");
			Knockback = config.Bind<float>("Void Beam Balance", "Knockback", 40f, new ConfigDescription("How hard bodies are thrown.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 300f), Array.Empty<object>()));
			SoundFile = config.Bind<string>("Void Beam Audio", "SoundFile", "hollow-purple", "Sound file name, without extension. Searched for in the Sounds/ folder of any installed plugin, so this mod's own folder works, as does HTFSoundAPI's.");
			SoundVolume = config.Bind<float>("Void Beam Audio", "SoundVolume", 0.8f, new ConfigDescription("Volume of the firing sound.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
		}

		public override void Initialise(Harmony harmony)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			VoidBeamNetwork.RequireSerializers();
			harmony.PatchAll(typeof(ItemRegistryPatch));
			CompendiumPlugin.Run(SpongeLoadSound());
			CompendiumPlugin.Log.LogInfo((object)$"Void Beam ready. Press {FireKey.Value} to fire.");
		}

		private IEnumerator SpongeLoadSound()
		{
			yield return null;
			string text = SoundLibrary.Find(SoundFile.Value);
			if (text == null)
			{
				CompendiumPlugin.Log.LogInfo((object)("No sound: put '" + SoundFile.Value + ".mp3' in the mod's Sounds/ folder."));
				yield break;
			}
			yield return EmbeddedAudioLoader.Load(text, stream: false, delegate(AudioClip clip)
			{
				Clip = clip;
				CompendiumPlugin.Log.LogInfo((object)$"Sound loaded: {((Object)clip).name} ({clip.length:0.0}s)");
			}, delegate(string message)
			{
				CompendiumPlugin.Log.LogWarning((object)message);
			});
		}

		public override void Tick()
		{
			//IL_0012: 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)
			VoidBeamNetwork.Tick();
			if (_busy || (int)FireKey.Value == 0)
			{
				return;
			}
			Keyboard current = Keyboard.current;
			if (current == null)
			{
				return;
			}
			KeyControl val = current[FireKey.Value];
			if (val == null || !((ButtonControl)val).wasPressedThisFrame)
			{
				return;
			}
			if (Time.time - _lastFired < Cooldown.Value)
			{
				float num = Cooldown.Value - (Time.time - _lastFired);
				CompendiumPlugin.Log.LogInfo((object)$"Still on cooldown: {num:0.0}s.");
				return;
			}
			Camera val2 = BeamAim.ObtainCamera();
			if ((Object)(object)val2 == (Object)null)
			{
				CompendiumPlugin.Log.LogWarning((object)"Cannot find the camera; are you in a game?");
				return;
			}
			if (!HeldItems.SpongeAllowed())
			{
				CompendiumPlugin.Log.LogInfo((object)("You need to be holding '" + RequiredItem.Value + "'."));
				return;
			}
			_lastFired = Time.time;
			CompendiumPlugin.Run(FireSequence(val2));
		}

		private IEnumerator FireSequence(Camera camera)
		{
			_busy = true;
			Color colour = ParseColour(BeamColour.Value);
			GameObject charge = BeamEffects.SpongeSpawnCharge(((Component)camera).transform, colour);
			BeamHands.Extend(((Component)camera).transform);
			if ((Object)(object)Clip != (Object)null)
			{
				AudioSource.PlayClipAtPoint(Clip, ((Component)camera).transform.position, SoundVolume.Value);
			}
			float elapsed = 0f;
			while (elapsed < ChargeTime.Value)
			{
				elapsed += Time.deltaTime;
				float t = elapsed / Mathf.Max(0.01f, ChargeTime.Value);
				BeamEffects.TweenCharge(charge, t);
				BeamHands.Push(t);
				yield return null;
			}
			BeamEffects.Teardown(charge);
			Vector3 origin = ((Component)camera).transform.position + ((Component)camera).transform.forward * 1.2f;
			Vector3 forward = ((Component)camera).transform.forward;
			Hits = 0;
			VoidBeamNetwork.Fire(origin, forward, Range.Value, Radius.Value);
			yield return (object)new WaitForSecondsRealtime(0.35f);
			BeamHands.Release();
			yield return (object)new WaitForSeconds(Range.Value / Mathf.Max(1f, OrbSpeed.Value) + 0.6f);
			CompendiumPlugin.Log.LogInfo((object)((Hits > 0) ? $"The orb hit {Hits} target(s)." : "The orb did not touch anything."));
			_busy = false;
		}

		internal static Color ParseColour(string hex)
		{
			//IL_002c: 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)
			Color result = default(Color);
			if (ColorUtility.TryParseHtmlString("#" + hex.TrimStart('#'), ref result))
			{
				return result;
			}
			return new Color(0.61f, 0.19f, 1f);
		}

		public override void Shutdown()
		{
			BeamHands.Release();
		}
	}
	[HarmonyPatch]
	internal static class ItemRegistryPatch
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("Item");
			if (!(type == null))
			{
				return AccessTools.Method(type, "Awake", (Type[])null, (Type[])null);
			}
			return null;
		}

		private static bool Prepare()
		{
			return TargetMethod() != null;
		}

		private static void Postfix(object __instance)
		{
			if (__instance != null && !HeldItems.Items.Contains(__instance))
			{
				HeldItems.Items.Add(__instance);
			}
		}
	}
	internal static class BeamAim
	{
		private static Camera _cached;

		private static bool _logged;

		internal static Camera ObtainCamera()
		{
			if ((Object)(object)_cached != (Object)null && ((Behaviour)_cached).isActiveAndEnabled)
			{
				return _cached;
			}
			_cached = SpongeFromLocalPlayer() ?? Camera.main;
			if ((Object)(object)_cached == (Object)null)
			{
				_cached = (from camera in Camera.allCameras
					where (Object)(object)camera != (Object)null && ((Behaviour)camera).isActiveAndEnabled
					orderby camera.depth descending
					select camera).FirstOrDefault();
			}
			if ((Object)(object)_cached != (Object)null && !_logged)
			{
				_logged = true;
				CompendiumPlugin.Log.LogInfo((object)("Camera found: " + ((Object)_cached).name));
			}
			return _cached;
		}

		private static Camera SpongeFromLocalPlayer()
		{
			Component val = (Component)(((object)LocalPlayerAccess.Part("Camera")) ?? ((object)/*isinst with value type is only supported in some contexts*/));
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Camera val2 = (Camera)(object)((val is Camera) ? val : null);
			if (val2 != null)
			{
				return val2;
			}
			return (from child in val.GetComponentsInChildren<Camera>(true)
				where (Object)(object)child != (Object)null
				orderby ((Behaviour)child).isActiveAndEnabled descending
				select child).FirstOrDefault();
		}
	}
	internal static class LocalPlayerAccess
	{
		private static bool _resolved;

		private static Type _playerType;

		private static FieldInfo _localPlayer;

		private static void SpongeResolve()
		{
			if (!_resolved)
			{
				_resolved = true;
				_playerType = AccessTools.TypeByName("Player");
				if (_playerType != null)
				{
					_localPlayer = AccessTools.Field(_playerType, "LocalPlayer");
				}
				if (_localPlayer == null)
				{
					CompendiumPlugin.Log.LogWarning((object)"Cannot find Player.LocalPlayer: the void beam may target the wrong player.");
				}
			}
		}

		internal static object Player()
		{
			SpongeResolve();
			return _localPlayer?.GetValue(null);
		}

		internal static Component Part(string propertyName)
		{
			object obj = Player();
			if (obj == null || _playerType == null)
			{
				return null;
			}
			try
			{
				object? obj2 = AccessTools.Property(_playerType, propertyName)?.GetValue(obj);
				Component val = (Component)((obj2 is Component) ? obj2 : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	internal static class HeldItems
	{
		internal static readonly List<object> Items = new List<object>();

		private static bool _resolved;

		private static PropertyInfo _holder;

		private static MethodInfo _getName;

		private static FieldInfo _localPlayer;

		private static void SpongeResolve()
		{
			if (!_resolved)
			{
				_resolved = true;
				Type type = AccessTools.TypeByName("Item");
				Type type2 = AccessTools.TypeByName("Player");
				if (type != null)
				{
					_holder = AccessTools.Property(type, "Holder");
					_getName = AccessTools.Method(type, "GetName", (Type[])null, (Type[])null);
				}
				if (type2 != null)
				{
					_localPlayer = AccessTools.Field(type2, "LocalPlayer");
				}
			}
		}

		internal static string SpongeCurrentName()
		{
			SpongeResolve();
			if (_holder == null || _localPlayer == null)
			{
				return null;
			}
			object value = _localPlayer.GetValue(null);
			if (value == null)
			{
				return null;
			}
			Items.RemoveAll(delegate(object entry)
			{
				if (entry != null)
				{
					Object val = (Object)((entry is Object) ? entry : null);
					if (val != null)
					{
						return val == (Object)null;
					}
					return false;
				}
				return true;
			});
			foreach (object item in Items)
			{
				object value2;
				try
				{
					value2 = _holder.GetValue(item);
				}
				catch
				{
					continue;
				}
				if (value2 != value)
				{
					continue;
				}
				try
				{
					if (_getName?.Invoke(item, null) is string text && !string.IsNullOrEmpty(text))
					{
						return text;
					}
				}
				catch
				{
				}
				object obj3 = ((item is Component) ? item : null);
				return (obj3 != null) ? ((Object)((Component)obj3).gameObject).name : null;
			}
			return null;
		}

		internal static bool SpongeAllowed()
		{
			string value = VoidBeamModule.RequiredItem.Value;
			string text = SpongeCurrentName();
			CompendiumPlugin.Log.LogInfo((object)("Holding: " + (text ?? "nothing")));
			if (string.IsNullOrWhiteSpace(value))
			{
				return true;
			}
			if (text != null)
			{
				return text.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}
	}
	internal static class SoundLibrary
	{
		private static readonly string[] Extensions = new string[3] { ".mp3", ".ogg", ".wav" };

		internal static string Find(string nameWithoutExtension)
		{
			if (string.IsNullOrEmpty(nameWithoutExtension))
			{
				return null;
			}
			string pluginPath = Paths.PluginPath;
			if (!Directory.Exists(pluginPath))
			{
				return null;
			}
			try
			{
				return Directory.GetDirectories(pluginPath, "Sounds", SearchOption.AllDirectories).SelectMany((string directory) => Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories)).FirstOrDefault((string file) => string.Equals(Path.GetFileNameWithoutExtension(file), nameWithoutExtension, StringComparison.OrdinalIgnoreCase) && Extensions.Contains(Path.GetExtension(file).ToLowerInvariant()));
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not search for the sound: " + ex.Message));
				return null;
			}
		}
	}
	public struct VoidBeamShot : IBroadcast
	{
		public Vector3 Origin;

		public Vector3 Direction;

		public float Range;

		public float Radius;
	}
	public static class VoidBeamShotSerializer
	{
		public static void WriteVoidBeamShot(this Writer writer, VoidBeamShot value)
		{
			//IL_0006: 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)
			if (writer != null)
			{
				writer.WriteVector3(value.Origin);
				writer.WriteVector3(value.Direction);
				writer.WriteSingle(value.Range);
				writer.WriteSingle(value.Radius);
			}
		}

		public static VoidBeamShot ReadVoidBeamShot(this Reader reader)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			return new VoidBeamShot
			{
				Origin = reader.ReadVector3(),
				Direction = reader.ReadVector3(),
				Range = reader.ReadSingle(),
				Radius = reader.ReadSingle()
			};
		}
	}
	internal static class VoidBeamNetwork
	{
		private static bool _serializers;

		private static bool _clientReady;

		private static bool _serverReady;

		private static bool _broken;

		internal static bool IsHost => InstanceFinder.IsServerStarted;

		internal static void RequireSerializers()
		{
			if (_serializers || _broken)
			{
				return;
			}
			try
			{
				GenericWriter<VoidBeamShot>.SetWrite((Action<Writer, VoidBeamShot>)delegate(Writer writer, VoidBeamShot value)
				{
					writer.WriteVoidBeamShot(value);
				});
				GenericReader<VoidBeamShot>.SetRead((Func<Reader, VoidBeamShot>)((Reader reader) => reader.ReadVoidBeamShot()));
				_serializers = true;
			}
			catch (Exception ex)
			{
				_broken = true;
				CompendiumPlugin.Log.LogWarning((object)("Void beam networking unavailable: " + ex.Message + ". It will only work as host."));
			}
		}

		internal static void Tick()
		{
			if (_broken)
			{
				return;
			}
			if (!_clientReady && (Object)(object)InstanceFinder.ClientManager != (Object)null)
			{
				try
				{
					InstanceFinder.ClientManager.RegisterBroadcast<VoidBeamShot>((Action<VoidBeamShot, Channel>)SpongeOnClientReceived);
					_clientReady = true;
				}
				catch (Exception error)
				{
					Fail(error);
					return;
				}
			}
			if (_serverReady || (Object)(object)InstanceFinder.ServerManager == (Object)null)
			{
				return;
			}
			try
			{
				InstanceFinder.ServerManager.RegisterBroadcast<VoidBeamShot>((Action<NetworkConnection, VoidBeamShot, Channel>)SpongeOnServerReceived, true);
				_serverReady = true;
			}
			catch (Exception error2)
			{
				Fail(error2);
			}
		}

		private static void Fail(Exception error)
		{
			_broken = true;
			CompendiumPlugin.Log.LogWarning((object)("Could not register void beam networking: " + error.Message));
		}

		internal static void Fire(Vector3 origin, Vector3 direction, float range, float radius)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			VoidBeamShot voidBeamShot = new VoidBeamShot
			{
				Origin = origin,
				Direction = direction,
				Range = range,
				Radius = radius
			};
			BeamEffects.SpongeSpawnOrb(voidBeamShot.Origin, voidBeamShot.Direction, VoidBeamModule.ParseColour(VoidBeamModule.BeamColour.Value), dealsDamage: true);
			if (IsHost)
			{
				Relay(voidBeamShot, null);
				return;
			}
			if (_broken || !_clientReady)
			{
				CompendiumPlugin.Log.LogInfo((object)"No server connection: nobody else will see your orb.");
				return;
			}
			try
			{
				InstanceFinder.ClientManager.Broadcast<VoidBeamShot>(voidBeamShot, (Channel)0);
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not send the shot: " + ex.Message));
			}
		}

		private static void SpongeOnServerReceived(NetworkConnection sender, VoidBeamShot shot, Channel channel)
		{
			Relay(shot, sender);
		}

		private static void SpongeOnClientReceived(VoidBeamShot shot, Channel channel)
		{
			//IL_0009: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHost)
			{
				BeamEffects.SpongeSpawnOrb(shot.Origin, shot.Direction, VoidBeamModule.ParseColour(VoidBeamModule.BeamColour.Value), dealsDamage: false);
			}
		}

		private static void Relay(VoidBeamShot shot, NetworkConnection sender)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (sender != (NetworkConnection)null)
			{
				BeamEffects.SpongeSpawnOrb(shot.Origin, shot.Direction, VoidBeamModule.ParseColour(VoidBeamModule.BeamColour.Value), dealsDamage: false);
			}
			if (!_serverReady)
			{
				return;
			}
			try
			{
				foreach (NetworkConnection value in InstanceFinder.ServerManager.Clients.Values)
				{
					if (!(value == (NetworkConnection)null) && !(value == sender))
					{
						InstanceFinder.ServerManager.Broadcast<VoidBeamShot>(value, shot, true, (Channel)0);
					}
				}
			}
			catch (Exception ex)
			{
				CompendiumPlugin.Log.LogWarning((object)("Could not relay the shot: " + ex.Message));
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}