using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using AttackOnGiant.Patches;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("AttackOnGiant")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AttackOnGiant")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2f4e7db9-a7dc-4331-bef1-a81c3a6ba60f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AttackOnGiant
{
	[BepInPlugin("EerieXanthic.AttackOnGiant", "Attack on Giant", "1.0.0.0")]
	public class AttackOnGiantBase : BaseUnityPlugin
	{
		private const string modGUID = "EerieXanthic.AttackOnGiant";

		private const string modName = "Attack on Giant";

		private const string modVersion = "1.0.0.0";

		private readonly Harmony harmony = new Harmony("EerieXanthic.AttackOnGiant");

		private static AttackOnGiantBase I;

		internal ManualLogSource mls;

		internal static AudioClip newSFX;

		private void Awake()
		{
			if ((Object)(object)I == (Object)null)
			{
				I = this;
			}
			mls = Logger.CreateLogSource("EerieXanthic.AttackOnGiant");
			string location = ((BaseUnityPlugin)I).Info.Location;
			string text = "AttackOnGiant.dll";
			string text2 = location.TrimEnd(text.ToCharArray());
			string text3 = text2 + "attackongiantsound";
			mls.LogInfo((object)("Attack on Giant is loading from " + text3));
			AssetBundle val = AssetBundle.LoadFromFile(text3);
			if ((Object)(object)val == (Object)null)
			{
				mls.LogError((object)"Failed to load audio assets!");
				return;
			}
			newSFX = val.LoadAsset<AudioClip>("Assets/tunes to listen to while being eaten.mp3");
			if ((Object)(object)newSFX != (Object)null)
			{
				mls.LogInfo((object)"Attack on Giant is loaded. Run.");
			}
			harmony.PatchAll(typeof(AttackOnGiantBase));
			harmony.PatchAll(typeof(ForestGiantAIPatch));
		}
	}
}
namespace AttackOnGiant.Patches
{
	[HarmonyPatch(typeof(ForestGiantAI))]
	internal class ForestGiantAIPatch
	{
		[HarmonyPatch("EatPlayerAnimation")]
		[HarmonyPostfix]
		public static void hoarderBugAudioPatch(ref AudioSource ___creatureVoice)
		{
			___creatureVoice.PlayOneShot(AttackOnGiantBase.newSFX);
		}
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using TDP.CoilHeadStare.Patch;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("CoilHeadStare")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("CoilHeadStare")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9d96f0c2-6393-4d02-99d7-34538a0dad5c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace TDP.CoilHeadStare
{
	[BepInPlugin("TDP.CoilHeadStare", "CoilHeadStare", "1.0.3")]
	public class ModBase : BaseUnityPlugin
	{
		private const string modGUID = "TDP.CoilHeadStare";

		private const string modName = "CoilHeadStare";

		private const string modVersion = "1.0.3";

		private Harmony harmony;

		internal static ModBase instance;

		internal ManualLogSource mls;

		public static ConfigEntry<float> config_timeUntilStare;

		public static ConfigEntry<float> config_maxStareDistance;

		public static ConfigEntry<float> config_turnHeadSpeed;

		private void Awake()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
			ConfigFile();
			harmony = new Harmony("TDP.CoilHeadStare");
			harmony.PatchAll(typeof(CoilHeadPatch));
			mls = Logger.CreateLogSource("TDP.CoilHeadStare");
			mls.LogInfo((object)"CoilHeadStare 1.0.3 loaded.");
		}

		private void ConfigFile()
		{
			config_timeUntilStare = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Time Until Stare", 8f, "Time between moving and looking at closest player (in seconds)");
			config_maxStareDistance = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Max Stare Distance", 6f, "Coilhead will only stare at players closer than this (for reference: coilhead's height is ca. 4)");
			config_turnHeadSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("CoilHeadStare", "Head Turn Speed", 0.3f, "The speed at which the head turns towards the player");
			Stare.timeUntilStare = config_timeUntilStare.Value;
			Stare.maxStareDistance = config_maxStareDistance.Value;
			Stare.turnHeadSpeed = config_turnHeadSpeed.Value;
		}

		private void ConfigureDoorControls()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("HangarDoorButtonPanel");
			GameObject val2 = new GameObject("PlacementCollider");
			val2.transform.SetParent(val.transform, false);
			BoxCollider val3 = val2.AddComponent<BoxCollider>();
			val3.size = new Vector3(0.881444f, 0.147624f, 0.7243316f);
			val3.center = new Vector3(0.2525222f, 0.06033165f, -0.06168448f);
			PlaceableShipObject val4 = val2.AddComponent<PlaceableShipObject>();
			val4.unlockableID = 1212;
			val4.parentObject = val.AddComponent<AutoParentToShip>();
			val4.mainMesh = val.GetComponent<MeshFilter>();
			val4.mainTransform = val.transform;
			val4.placeObjectCollider = (Collider)(object)val3;
			val4.yOffset = 0f;
			val4.AllowPlacementOnWalls = true;
			val2.AddComponent<AudioSource>();
		}
	}
}
namespace TDP.CoilHeadStare.Patch
{
	internal class CoilHeadPatch
	{
		[HarmonyPatch(typeof(EnemyAI), "Start")]
		[HarmonyPostfix]
		private static void StartPostFix(EnemyAI __instance)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			if (__instance is SpringManAI)
			{
				Debug.Log((object)"CoilHead found. Adding stare script.");
				Stare stare = ((Component)__instance).gameObject.AddComponent<Stare>();
				stare.Initialize((SpringManAI)__instance);
			}
		}
	}
	public class Stare : MonoBehaviour
	{
		private SpringManAI coilHeadInstance;

		public static float timeUntilStare;

		public static float maxStareDistance;

		public static float turnHeadSpeed;

		private Transform head;

		private float timeSinceMoving;

		private bool isTurningHead;

		private PlayerControllerB stareTarget;

		public void Initialize(SpringManAI instance)
		{
			Debug.Log((object)"Initializing Stare on Coilhead.");
			coilHeadInstance = instance;
			head = ((Component)coilHeadInstance).transform.GetChild(0).GetChild(2).GetChild(0)
				.GetChild(0)
				.GetChild(0)
				.GetChild(0)
				.GetChild(0)
				.GetChild(2)
				.GetChild(0)
				.GetChild(0)
				.GetChild(1);
			if (((Object)head).name != "springBone.002_end")
			{
				Debug.LogError((object)"CoilHeadStare could not find head transform. Destroying script.");
				Object.Destroy((Object)(object)this);
			}
		}

		private void Update()
		{
			//IL_0088: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00bc: 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_00fb: 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_0181: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)coilHeadInstance == (Object)null)
			{
				return;
			}
			if ((Object)(object)head == (Object)null)
			{
				Debug.LogError((object)"CoilHeadStare head transform missing. Destroying script.");
				Object.Destroy((Object)(object)this);
				return;
			}
			if (!isTurningHead)
			{
				stareTarget = ((EnemyAI)coilHeadInstance).GetClosestPlayer(false, false, false);
			}
			if (!((Object)(object)stareTarget == (Object)null))
			{
				Vector3 val = ((Component)stareTarget.gameplayCamera).transform.position - head.position;
				float num = Vector3.Distance(head.position, ((Component)((EnemyAI)coilHeadInstance).GetClosestPlayer(false, false, false)).transform.position);
				if ((double)((EnemyAI)coilHeadInstance).creatureAnimator.GetFloat("walkSpeed") > 0.01 || num > maxStareDistance || Vector3.Angle(head.forward, val) < 5f)
				{
					timeSinceMoving = 0f;
				}
				else
				{
					timeSinceMoving += Time.deltaTime;
				}
				if (timeSinceMoving > timeUntilStare)
				{
					isTurningHead = true;
				}
				else
				{
					isTurningHead = false;
				}
				if (isTurningHead)
				{
					head.forward = Vector3.RotateTowards(head.forward, val, turnHeadSpeed * Time.deltaTime, 0f);
				}
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalRegeneration.config;
using LethalRegeneration.patches;
using LethalRegeneration.utils;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyCompany("LethalRegeneration")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Natural health regeneration mod with customizable parameters that syncs with host")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("LethalRegeneration")]
[assembly: AssemblyTitle("LethalRegeneration")]
[assembly: AssemblyVersion("1.2.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 LethalRegeneration
{
	[BepInPlugin("Toskan4134.LethalRegeneration", "LethalRegeneration", "1.2.0")]
	public class LethalRegenerationBase : BaseUnityPlugin
	{
		private const string modGUID = "Toskan4134.LethalRegeneration";

		private const string modName = "LethalRegeneration";

		private const string modVersion = "1.2.0";

		private readonly Harmony patcher = new Harmony("Toskan4134.LethalRegeneration");

		public static LethalRegenerationBase Instance;

		public static Configuration Config { get; internal set; }

		public static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Logger = Logger.CreateLogSource("LethalRegeneration");
			Config = new Configuration(((BaseUnityPlugin)this).Config);
			try
			{
				patcher.PatchAll(typeof(HUDManagerPatch));
				patcher.PatchAll(typeof(Configuration));
				patcher.PatchAll(typeof(TerminalPatch));
				patcher.PatchAll(typeof(GameNetworkManagerPatch));
				patcher.PatchAll(typeof(StartOfRoundPatch));
				patcher.PatchAll(typeof(StartMatchLeverPatch));
				Logger.LogInfo((object)"Loaded Succesfully\r\n      ___________________\r\n     /                   |\r\n    |_______      _______|\r\n     ___    |    |\r\n    |   |___|    |______\r\n    |                   \\\r\n     \\______      ___    |\r\n     ___    |    |   |   |\r\n    |   |__ |    | __|   |\r\n    |      ||    ||      |\r\n     \\_____||____||_____/\r\n   LethalRegeneration 1.2.0\r\n        By Toskan4134\r\n");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)ex);
			}
		}
	}
}
namespace LethalRegeneration.utils
{
	public class TerminalUtils
	{
		public static TerminalKeyword CreateTerminalKeyword(string word, bool isVerb = false, CompatibleNoun[] compatibleNouns = null, TerminalNode specialKeywordResult = null, TerminalKeyword defaultVerb = null, bool accessTerminalObjects = false)
		{
			TerminalKeyword val = ScriptableObject.CreateInstance<TerminalKeyword>();
			((Object)val).name = word;
			val.word = word;
			val.isVerb = isVerb;
			val.compatibleNouns = compatibleNouns;
			val.specialKeywordResult = specialKeywordResult;
			val.defaultVerb = defaultVerb;
			val.accessTerminalObjects = accessTerminalObjects;
			return val;
		}

		public static TerminalKeyword GetTerminalKeyword(Terminal __instance, string word)
		{
			return __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == word);
		}
	}
}
namespace LethalRegeneration.patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class GameNetworkManagerPatch
	{
		[HarmonyPatch("SaveGameValues")]
		[HarmonyPostfix]
		public static void SaveGameValuesPatch(GameNetworkManager __instance)
		{
			if (!__instance.isHostingGame)
			{
				return;
			}
			try
			{
				ES3.Save<bool>("LethalRegeneration_healingUpgradeUnlocked", ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked, __instance.currentSaveFileName);
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"Error while trying to save game values when disconnecting as host: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		private static PlayerControllerB playerControllerB;

		private static int currentTicksPerRegeneration;

		private static int currentTicksPerRegenerationOutsideShip;

		private static int ticksPerRegeneration => ConfigurationSync<Configuration>.Instance.TicksPerRegeneration;

		private static int regenerationPower => ConfigurationSync<Configuration>.Instance.RegenerationPower;

		private static bool regenerationOutsideShip => ConfigurationSync<Configuration>.Instance.RegenerationOutsideShip;

		private static int ticksPerRegenerationOutsideShip => ConfigurationSync<Configuration>.Instance.TicksPerRegenerationOutsideShip;

		private static int regenerationPowerOutsideShip => ConfigurationSync<Configuration>.Instance.RegenerationPowerOutsideShip;

		private static bool healingUpgradeUnlocked => ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked;

		private static bool healingUpgradeEnabled => ConfigurationSync<Configuration>.Instance.HealingUpgradeEnabled;

		private static int maxHealth => StartMatchLeverPatch.maxHealth;

		[HarmonyPatch("SetClock")]
		[HarmonyPostfix]
		public static void healingPostfix()
		{
			playerControllerB = GameNetworkManager.Instance.localPlayerController;
			if ((healingUpgradeEnabled && !healingUpgradeUnlocked) || !((NetworkBehaviour)playerControllerB).IsOwner || playerControllerB.isPlayerDead || !playerControllerB.AllowPlayerDeath() || playerControllerB.health >= maxHealth)
			{
				return;
			}
			if (playerControllerB.isInHangarShipRoom)
			{
				if (currentTicksPerRegeneration == 0)
				{
					currentTicksPerRegeneration = ticksPerRegeneration;
					LethalRegenerationBase.Logger.LogInfo((object)("Healed " + regenerationPower));
					int num = playerControllerB.health + regenerationPower;
					playerControllerB.health = ((num > maxHealth) ? maxHealth : num);
					HUDManager.Instance.UpdateHealthUI(playerControllerB.health, false);
					playerControllerB.DamagePlayerClientRpc(-regenerationPower, playerControllerB.health);
					if (playerControllerB.health >= 10 && playerControllerB.criticallyInjured)
					{
						playerControllerB.MakeCriticallyInjured(false);
					}
				}
				currentTicksPerRegeneration--;
			}
			else
			{
				if (!regenerationOutsideShip || playerControllerB.isInHangarShipRoom)
				{
					return;
				}
				if (currentTicksPerRegenerationOutsideShip == 0)
				{
					currentTicksPerRegenerationOutsideShip = ticksPerRegenerationOutsideShip;
					LethalRegenerationBase.Logger.LogInfo((object)("Healed " + regenerationPowerOutsideShip));
					int num2 = playerControllerB.health + regenerationPowerOutsideShip;
					playerControllerB.health = ((num2 > maxHealth) ? maxHealth : num2);
					HUDManager.Instance.UpdateHealthUI(playerControllerB.health, false);
					playerControllerB.DamagePlayerClientRpc(-regenerationPowerOutsideShip, playerControllerB.health);
					if (playerControllerB.health >= 10 && playerControllerB.criticallyInjured)
					{
						playerControllerB.MakeCriticallyInjured(false);
					}
				}
				currentTicksPerRegenerationOutsideShip--;
			}
		}
	}
	[HarmonyPatch(typeof(StartMatchLever))]
	public class StartMatchLeverPatch
	{
		public static int maxHealth = 100;

		[HarmonyPatch("PlayLeverPullEffectsClientRpc")]
		[HarmonyPostfix]
		public static void StartGameHpPostfix(ref StartOfRound ___playersManager, ref bool ___leverHasBeenPulled)
		{
			if (___leverHasBeenPulled)
			{
				maxHealth = ___playersManager.localPlayerController.health;
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("ResetShip")]
		[HarmonyPostfix]
		public static void ResetShip()
		{
			ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = false;
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	public class TerminalPatch
	{
		private static Item item;

		private static TerminalNode buyNode1;

		private static TerminalNode buyNode2;

		private static TerminalNode CannotAfford;

		private static TerminalNode AlreadyUnlocked;

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static void StartTerminalPatch(Terminal __instance)
		{
			//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_002f: 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_004b: Expected O, but got Unknown
			//IL_0380: 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_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Expected O, but got Unknown
			//IL_03c8: 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_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_040a: Expected O, but got Unknown
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: 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_0471: Expected O, but got Unknown
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_0595: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Expected O, but got Unknown
			if (ConfigurationSync<Configuration>.Instance.HealingUpgradeEnabled)
			{
				item = new Item
				{
					itemName = "Natural Regeneration",
					creditsWorth = ConfigurationSync<Configuration>.Instance.HealingUpgradePrice,
					saveItemVariable = true
				};
				TerminalKeyword terminalKeyword = TerminalUtils.GetTerminalKeyword(__instance, "buy");
				TerminalNode result = terminalKeyword.compatibleNouns[0].result.terminalOptions[1].result;
				CannotAfford = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)CannotAfford).name = "LethalRegeneration_CannotAfford";
				CannotAfford.displayText = $"You could not afford these items!\nYour balance is [playerCredits]. Total cost of these items is ${item.creditsWorth}\r\n\r\n";
				CannotAfford.clearPreviousText = false;
				CannotAfford.maxCharactersToType = 25;
				CannotAfford.playSyncedClip = 1;
				AlreadyUnlocked = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)AlreadyUnlocked).name = "LethalRegeneration_AlreadyUnlocked";
				AlreadyUnlocked.displayText = "This has already been unlocked for your ship!\r\n\r\n";
				AlreadyUnlocked.clearPreviousText = true;
				AlreadyUnlocked.maxCharactersToType = 25;
				AlreadyUnlocked.playSyncedClip = 1;
				TerminalKeyword terminalKeyword2 = TerminalUtils.GetTerminalKeyword(__instance, "info");
				string itemName = item.itemName;
				TerminalKeyword keyword3 = TerminalUtils.CreateTerminalKeyword(itemName.ToLowerInvariant().Replace(" ", "-"), isVerb: false, null, null, terminalKeyword);
				if (__instance.terminalNodes.allKeywords.Any((TerminalKeyword kw) => kw.word == keyword3.word))
				{
					LethalRegenerationBase.Logger.LogInfo((object)("Keyword " + keyword3.word + " already registed, skipping."));
				}
				int shipUnlockableID = StartOfRound.Instance.unlockablesList.unlockables.FindIndex((UnlockableItem unlockable) => unlockable.unlockableName == item.itemName);
				buyNode2 = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)buyNode2).name = "LethalRegeneration_" + itemName.Replace(" ", "-") + "BuyNode2";
				buyNode2.displayText = "Ordered the " + itemName + ". Your new balance is [playerCredits].\n\nFrom now on you will regenerate health as time goes by.\r\n\r\n";
				buyNode2.clearPreviousText = true;
				buyNode2.maxCharactersToType = 15;
				buyNode2.buyItemIndex = -1;
				buyNode2.shipUnlockableID = shipUnlockableID;
				buyNode2.buyUnlockable = true;
				buyNode2.creatureName = itemName;
				buyNode2.isConfirmationNode = false;
				buyNode2.itemCost = item.creditsWorth;
				buyNode2.playSyncedClip = 0;
				buyNode1 = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)buyNode1).name = "LethalRegeneration_" + itemName.Replace(" ", "-") + "BuyNode1";
				buyNode1.displayText = "You have requested to order the " + itemName + " upgrade.\nTotal cost of items: " + item.creditsWorth + ".\n\nPlease CONFIRM or DENY.\r\n\r\n";
				buyNode1.clearPreviousText = true;
				buyNode1.maxCharactersToType = 35;
				buyNode1.buyItemIndex = -1;
				buyNode1.shipUnlockableID = shipUnlockableID;
				buyNode1.creatureName = itemName;
				buyNode1.isConfirmationNode = true;
				buyNode1.overrideOptions = true;
				buyNode1.itemCost = item.creditsWorth;
				buyNode1.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
				{
					new CompatibleNoun
					{
						noun = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword2) => keyword2.word == "confirm"),
						result = buyNode2
					},
					new CompatibleNoun
					{
						noun = __instance.terminalNodes.allKeywords.First((TerminalKeyword keyword2) => keyword2.word == "deny"),
						result = result
					}
				};
				List<TerminalKeyword> list = __instance.terminalNodes.allKeywords.ToList();
				list.Add(keyword3);
				__instance.terminalNodes.allKeywords = list.ToArray();
				List<CompatibleNoun> list2 = terminalKeyword.compatibleNouns.ToList();
				list2.Add(new CompatibleNoun
				{
					noun = keyword3,
					result = buyNode1
				});
				terminalKeyword.compatibleNouns = list2.ToArray();
				TerminalNode val = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)val).name = "LethalRegeneration_" + itemName.Replace(" ", "-") + "InfoNode";
				if (ConfigurationSync<Configuration>.Instance.RegenerationOutsideShip)
				{
					val.displayText = $"Your health regenerates inside and outside the ship\n\nINSIDE THE SHIP\nThe healing is activated each {ConfigurationSync<Configuration>.Instance.TicksPerRegeneration} ticks\nThe healing power is {ConfigurationSync<Configuration>.Instance.RegenerationPower}hp per tick\n\nOUTSIDE THE SHIP\nThe healing is activated each {ConfigurationSync<Configuration>.Instance.TicksPerRegenerationOutsideShip} ticks\nThe healing power is {ConfigurationSync<Configuration>.Instance.RegenerationPowerOutsideShip}hp per tick\n\n";
				}
				else
				{
					val.displayText = $"Your health regenerates only inside the ship\n\nThe healing is activated each {ConfigurationSync<Configuration>.Instance.TicksPerRegeneration} ticks\nThe healing power is {ConfigurationSync<Configuration>.Instance.RegenerationPower}hp per tick\n\n";
				}
				val.clearPreviousText = true;
				val.maxCharactersToType = 25;
				__instance.terminalNodes.allKeywords = list.ToArray();
				List<CompatibleNoun> list3 = terminalKeyword2.compatibleNouns.ToList();
				list3.Add(new CompatibleNoun
				{
					noun = keyword3,
					result = val
				});
				terminalKeyword2.compatibleNouns = list3.ToArray();
				LethalRegenerationBase.Logger.LogInfo((object)("Registered " + itemName));
			}
		}

		[HarmonyPatch("TextPostProcess")]
		[HarmonyPrefix]
		public static void TextPostProcessPatch_Prefix(ref string modifiedDisplayText, TerminalNode node, ref string __result)
		{
			if (ConfigurationSync<Configuration>.Instance.HealingUpgradeEnabled && modifiedDisplayText.Contains("[buyableItemsList]") && modifiedDisplayText.Contains("[unlockablesSelectionList]"))
			{
				int num = modifiedDisplayText.IndexOf(":");
				string itemName = item.itemName;
				int creditsWorth = item.creditsWorth;
				string value = $"\n* {itemName}    //    Price: ${creditsWorth}";
				modifiedDisplayText = modifiedDisplayText.Insert(num + 1, value);
			}
		}

		[HarmonyPatch("LoadNewNode")]
		[HarmonyPrefix]
		public static void LoadNewNodePatch_Prefix(ref TerminalNode node, Terminal __instance)
		{
			if (!((Object)node).name.StartsWith("LethalRegeneration"))
			{
				return;
			}
			string text = ((Object)node).name.Split(new char[1] { '_' })[1];
			string text2 = text;
			string text3 = text2;
			if (!(text3 == "Natural-RegenerationBuyNode2"))
			{
				if (text3 == "Natural-RegenerationBuyNode1" && __instance.groupCredits < item.creditsWorth)
				{
					node = CannotAfford;
				}
				return;
			}
			if (ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked)
			{
				node = AlreadyUnlocked;
				return;
			}
			int num = __instance.groupCredits - item.creditsWorth;
			__instance.SyncGroupCreditsServerRpc(num, __instance.numberOfItemsInDropship);
			ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = true;
			ConfigurationSync<Configuration>.Synced = false;
			if (ConfigurationSync<Configuration>.IsHost)
			{
				ConfigurationSync<Configuration>.Instance.BroadcastHealingUpgradeStatusToClients();
			}
			else
			{
				ConfigurationSync<Configuration>.Instance.SendHealingUpgradeStatusToHost();
			}
		}
	}
}
namespace LethalRegeneration.config
{
	[Serializable]
	public class Configuration : ConfigurationSync<Configuration>
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnReceiveBroadcastedHealingUpgradeStatus;

			public static HandleNamedMessageDelegate <1>__OnRequestSync;

			public static HandleNamedMessageDelegate <2>__OnReceiveHealingUpgradeStatus;

			public static HandleNamedMessageDelegate <3>__OnReceiveSync;
		}

		public const int DefaultTicksPerRegeneration = 2;

		public const int DefaultRegenerationPower = 5;

		public const bool DefaultregenerationOutsideShip = false;

		public const bool DefaultHealingUpgradeEnabled = false;

		public const int DefaultHealingUpgradePrice = 800;

		[NonSerialized]
		private readonly ConfigFile configFile;

		public bool HealingUpgradeUnlocked { get; set; }

		public int TicksPerRegeneration { get; private set; }

		public int RegenerationPower { get; private set; }

		public bool RegenerationOutsideShip { get; private set; }

		public int TicksPerRegenerationOutsideShip { get; private set; }

		public int RegenerationPowerOutsideShip { get; private set; }

		public bool HealingUpgradeEnabled { get; private set; }

		public int HealingUpgradePrice { get; private set; }

		public Configuration(ConfigFile cfg)
		{
			ConfigurationSync<Configuration>.Instance = this;
			configFile = cfg;
			InitConfigEntries();
			LethalRegenerationBase.Logger.LogInfo((object)"Configuration Set");
		}

		private void InitConfigEntries()
		{
			RegenerationPower = NewEntry("Values", "Regeneration Power", 5, "Amount of health regenerated INSIDE the ship each time triggered (Between 1 an 100)");
			TicksPerRegeneration = NewEntry("Values", "Ticks Per Regeneration", 2, "Number of ticks until the regeneration is triggered INSIDE the ship (1 tick equals each time the minutes of the clock are changed)");
			RegenerationOutsideShip = NewEntry("Values", "Enable Regeneration Outside Ship", defaultVal: false, "Whether health is regenerated also outside the ship or only inside.");
			RegenerationPowerOutsideShip = NewEntry("Values", "Regeneration Power Outside Ship", 5, "Amount of health regenerated OUTSIDE the ship each time triggered, requires Regeneration Outside The Ship enabled (Between 1 an 100)");
			TicksPerRegenerationOutsideShip = NewEntry("Values", "Ticks Per Regeneration Outside Ship", 2, "Number of ticks until the regeneration is triggered OUTSIDE the ship, requires Regeneration Outside The Ship enabled (1 tick equals each time the minutes of the clock are changed)");
			HealingUpgradeEnabled = NewEntry("Values", "Regeneration As Upgrade", defaultVal: false, "Makes natural health regeneration an upgrade for the ship and has to be purchased to make it work.");
			HealingUpgradePrice = NewEntry("Values", "Upgrade Price", 800, "Changes the price of ship upgrade for health regeneration. Only works if ship upgrade is enabled");
			RegenerationPower = ((100 >= RegenerationPower && RegenerationPower > 0) ? RegenerationPower : 5);
			TicksPerRegeneration = ((TicksPerRegeneration > 0) ? TicksPerRegeneration : 2);
			RegenerationPowerOutsideShip = ((100 >= RegenerationPowerOutsideShip && RegenerationPowerOutsideShip > 0) ? RegenerationPowerOutsideShip : 5);
			TicksPerRegenerationOutsideShip = ((TicksPerRegenerationOutsideShip > 0) ? TicksPerRegenerationOutsideShip : 2);
			HealingUpgradePrice = ((HealingUpgradePrice > 0) ? HealingUpgradePrice : 800);
		}

		private T NewEntry<T>(string category, string key, T defaultVal, string desc)
		{
			return configFile.Bind<T>(category, key, defaultVal, desc).Value;
		}

		public static void RequestSync()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!ConfigurationSync<Configuration>.IsClient)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
			try
			{
				ConfigurationSync<Configuration>.MessageManager.SendNamedMessage("LethalRegeneration_OnRequestConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnRequestSync(ulong clientId, FastBufferReader _)
		{
			//IL_0051: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!ConfigurationSync<Configuration>.IsHost)
			{
				return;
			}
			LethalRegenerationBase.Logger.LogInfo((object)$"Config sync request received from client: {clientId}");
			byte[] array = ConfigurationSync<Configuration>.SerializeToBytes(ConfigurationSync<Configuration>.Instance);
			int num = array.Length;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(array.Length + 4, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				ConfigurationSync<Configuration>.MessageManager.SendNamedMessage("LethalRegeneration_OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
			}
			catch (Exception arg)
			{
				LethalRegenerationBase.Logger.LogInfo((object)$"Error occurred syncing config with client: {clientId}\n{arg}");
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveSync(ulong _, FastBufferReader reader)
		{
			//IL_0029: 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)
			if (!((FastBufferReader)(ref reader)).TryBeginRead(4))
			{
				LethalRegenerationBase.Logger.LogError((object)"Config sync error: Could not begin reading buffer.");
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			if (!((FastBufferReader)(ref reader)).TryBeginRead(num))
			{
				LethalRegenerationBase.Logger.LogError((object)"Config sync error: Host could not sync.");
				return;
			}
			byte[] data = new byte[num];
			((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
			ConfigurationSync<Configuration>.UpdateInstance(data);
			LethalRegenerationBase.Logger.LogInfo((object)"Successfully synced config with host.");
		}

		public void SendHealingUpgradeStatusToHost()
		{
			//IL_0028: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			if (ConfigurationSync<Configuration>.IsClient)
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
				try
				{
					int num = (HealingUpgradeUnlocked ? 1 : 0);
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
					ConfigurationSync<Configuration>.MessageManager.SendNamedMessage("LethalRegeneration_SendHealingUpgradeStatus", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
			}
		}

		public static void OnReceiveHealingUpgradeStatus(ulong _, FastBufferReader reader)
		{
			//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)
			if (ConfigurationSync<Configuration>.IsHost)
			{
				if (((FastBufferReader)(ref reader)).TryBeginRead(4))
				{
					int num = default(int);
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
					ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = num == 1;
					LethalRegenerationBase.Logger.LogInfo((object)$"Received sent HealingUpgrade status: {ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked}");
					ConfigurationSync<Configuration>.Instance.BroadcastHealingUpgradeStatusToClients();
				}
				else
				{
					LethalRegenerationBase.Logger.LogError((object)"Error reading healingUpgradeUnlocked status.");
				}
			}
		}

		public void BroadcastHealingUpgradeStatusToClients()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			if (!ConfigurationSync<Configuration>.IsHost)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
			try
			{
				int num = (HealingUpgradeUnlocked ? 1 : 0);
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				foreach (ulong key in NetworkManager.Singleton.ConnectedClients.Keys)
				{
					ConfigurationSync<Configuration>.MessageManager.SendNamedMessage("LethalRegeneration_BroadcastHealingUpgradeStatus", key, val, (NetworkDelivery)3);
				}
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}

		public static void OnReceiveBroadcastedHealingUpgradeStatus(ulong _, FastBufferReader reader)
		{
			//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)
			if (ConfigurationSync<Configuration>.IsClient && !ConfigurationSync<Configuration>.IsHost)
			{
				if (((FastBufferReader)(ref reader)).TryBeginRead(4))
				{
					int num = default(int);
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
					ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = num == 1;
					LethalRegenerationBase.Logger.LogInfo((object)$"Received broadcasted healingUpgradeUnlocked status: {ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked}");
					ConfigurationSync<Configuration>.Synced = true;
				}
				else
				{
					LethalRegenerationBase.Logger.LogError((object)"Error reading broadcasted healingUpgradeUnlocked status.");
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		public static void InitializeLocalPlayer()
		{
			//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_0037: Expected O, but got Unknown
			//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_00ee: Expected O, but got Unknown
			//IL_0064: 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_006f: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = false;
			CustomMessagingManager customMessagingManager = NetworkManager.Singleton.CustomMessagingManager;
			object obj = <>O.<0>__OnReceiveBroadcastedHealingUpgradeStatus;
			if (obj == null)
			{
				HandleNamedMessageDelegate val = OnReceiveBroadcastedHealingUpgradeStatus;
				<>O.<0>__OnReceiveBroadcastedHealingUpgradeStatus = val;
				obj = (object)val;
			}
			customMessagingManager.RegisterNamedMessageHandler("LethalRegeneration_BroadcastHealingUpgradeStatus", (HandleNamedMessageDelegate)obj);
			if (ConfigurationSync<Configuration>.IsHost)
			{
				CustomMessagingManager messageManager = ConfigurationSync<Configuration>.MessageManager;
				object obj2 = <>O.<1>__OnRequestSync;
				if (obj2 == null)
				{
					HandleNamedMessageDelegate val2 = OnRequestSync;
					<>O.<1>__OnRequestSync = val2;
					obj2 = (object)val2;
				}
				messageManager.RegisterNamedMessageHandler("LethalRegeneration_OnRequestConfigSync", (HandleNamedMessageDelegate)obj2);
				CustomMessagingManager messageManager2 = ConfigurationSync<Configuration>.MessageManager;
				object obj3 = <>O.<2>__OnReceiveHealingUpgradeStatus;
				if (obj3 == null)
				{
					HandleNamedMessageDelegate val3 = OnReceiveHealingUpgradeStatus;
					<>O.<2>__OnReceiveHealingUpgradeStatus = val3;
					obj3 = (object)val3;
				}
				messageManager2.RegisterNamedMessageHandler("LethalRegeneration_SendHealingUpgradeStatus", (HandleNamedMessageDelegate)obj3);
				ConfigurationSync<Configuration>.Synced = true;
				ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked = ES3.Load<bool>("LethalRegeneration_healingUpgradeUnlocked", GameNetworkManager.Instance.currentSaveFileName, false);
			}
			else
			{
				CustomMessagingManager messageManager3 = ConfigurationSync<Configuration>.MessageManager;
				object obj4 = <>O.<3>__OnReceiveSync;
				if (obj4 == null)
				{
					HandleNamedMessageDelegate val4 = OnReceiveSync;
					<>O.<3>__OnReceiveSync = val4;
					obj4 = (object)val4;
				}
				messageManager3.RegisterNamedMessageHandler("LethalRegeneration_OnReceiveConfigSync", (HandleNamedMessageDelegate)obj4);
				ConfigurationSync<Configuration>.Synced = false;
				RequestSync();
			}
		}
	}
	[Serializable]
	public class ConfigurationSync<T>
	{
		public static T Instance { get; internal set; }

		public static bool Synced { get; internal set; }

		internal static CustomMessagingManager MessageManager => NetworkManager.Singleton.CustomMessagingManager;

		internal static bool IsClient => NetworkManager.Singleton.IsClient;

		internal static bool IsHost => NetworkManager.Singleton.IsHost;

		internal static byte[] SerializeToBytes(T val)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream memoryStream = new MemoryStream();
			try
			{
				binaryFormatter.Serialize(memoryStream, val);
				return memoryStream.ToArray();
			}
			catch (Exception arg)
			{
				LethalRegenerationBase.Logger.LogError((object)$"Error serializing instance: {arg}");
				return null;
			}
		}

		internal static T DeserializeFromBytes(byte[] data)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			using MemoryStream serializationStream = new MemoryStream(data);
			try
			{
				return (T)binaryFormatter.Deserialize(serializationStream);
			}
			catch (Exception arg)
			{
				LethalRegenerationBase.Logger.LogError((object)$"Error deserializing instance: {arg}");
				return default(T);
			}
		}

		internal static void UpdateInstance(byte[] data)
		{
			Instance = DeserializeFromBytes(data);
			Synced = true;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PestControl")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PestControl")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d2469a2d-0fe3-463e-9f8c-ba7b095962cf")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace PestControl;

internal static class Config
{
	private static ConfigFile _configFile;

	private static string _configPath = Path.Combine(Paths.ConfigPath, "PestControl.cfg");

	public static Dictionary<string, Vector2> GetWeights(Terminal terminal)
	{
		//IL_0161: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
		CheckFile();
		HashSet<EnemyType> enemies = new HashSet<EnemyType>();
		SelectableLevel[] moonsCatalogueList = terminal.moonsCatalogueList;
		foreach (SelectableLevel obj in moonsCatalogueList)
		{
			Action<EnemyType> action = delegate(EnemyType x)
			{
				if (!enemies.TryGetValue(x, out var _))
				{
					enemies.Add(x);
				}
			};
			obj.Enemies.Select((SpawnableEnemyWithRarity x) => x.enemyType).ToList().ForEach(action);
			obj.DaytimeEnemies.Select((SpawnableEnemyWithRarity x) => x.enemyType).ToList().ForEach(action);
			obj.OutsideEnemies.Select((SpawnableEnemyWithRarity x) => x.enemyType).ToList().ForEach(action);
		}
		Dictionary<string, Vector2> dictionary = new Dictionary<string, Vector2>();
		foreach (EnemyType item in enemies)
		{
			string enemyName = item.enemyName;
			dictionary[enemyName] = new Vector2(_configFile.Bind<float>(enemyName, "Multiplier", 1f, "Scales spawn weight. Set to 0 to override with Addition.").Value, _configFile.Bind<float>(enemyName, "Addition", 0f, "Adjusts weight after Multiplier. Use for precise control.").Value);
			Plugin.Log.LogInfo((object)(enemyName + ":"));
			Plugin.Log.LogInfo((object)$"Multiplier:{dictionary[enemyName].x} Addition:{dictionary[enemyName].y}");
		}
		return dictionary;
	}

	private static void CheckFile()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		if (_configFile == null)
		{
			_configFile = new ConfigFile(_configPath, true);
		}
	}
}
internal static class Patch
{
	private static Dictionary<string, Vector2> weights = new Dictionary<string, Vector2>();

	[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
	[HarmonyTranspiler]
	private static IEnumerable<CodeInstruction> LoadNewLevel(IEnumerable<CodeInstruction> instructions)
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Expected O, but got Unknown
		Plugin.Log.LogInfo((object)"Started Transpiling [LoadNewLevel].");
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		int num = list.FindIndex((CodeInstruction x) => x.opcode == OpCodes.Stfld);
		list.InsertRange(num + 1, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[1]
		{
			new CodeInstruction(OpCodes.Call, (object)typeof(Patch).GetMethod("SetWeights", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public))
		});
		Plugin.Log.LogInfo((object)"Transpiled method successfully.");
		return list;
	}

	[HarmonyPatch(typeof(Terminal), "Start")]
	[HarmonyPostfix]
	private static void Start(Terminal __instance)
	{
		weights = Config.GetWeights(__instance);
	}

	public static void SetWeights()
	{
		//IL_0096: 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)
		SelectableLevel currentLevel = RoundManager.Instance.currentLevel;
		Plugin.Log.LogInfo((object)"Setting adjusted weights!");
		foreach (SpawnableEnemyWithRarity item in currentLevel.Enemies.Concat(currentLevel.DaytimeEnemies).Concat(currentLevel.OutsideEnemies).ToList())
		{
			foreach (KeyValuePair<string, Vector2> weight in weights)
			{
				string key = weight.Key;
				if (key == item.enemyType.enemyName)
				{
					int rarity = item.rarity;
					item.rarity = (int)((float)item.rarity * weight.Value.x + weight.Value.y);
					Plugin.Log.LogInfo((object)$"{key}, old rarity: {rarity}, new rariy: {item.rarity}");
					break;
				}
			}
		}
	}
}
[BepInPlugin("niceh.PestControl", "PestControl", "1.0.1")]
public class Plugin : BaseUnityPlugin
{
	public const string GUID = "niceh.PestControl";

	public const string Name = "PestControl";

	public static Plugin Instance { get; private set; }

	public static ManualLogSource Log { get; private set; }

	private void Awake()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		new Harmony("niceh.PestControl").PatchAll(typeof(Patch));
	}
}