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.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("Gorduan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0+7c8bde9391283b12125175d68f4632c4cf8f93b3")]
[assembly: AssemblyProduct("GC_ModSchalter")]
[assembly: AssemblyTitle("GC_ModSchalter_VPP")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 GC.Patcher
{
	public static class ModSchalter
	{
		public const string KernGuid = "gorduan.gc.kern";

		private static readonly string[] OldPackages = new string[3] { "gorduan.gc_server", "gorduan.gc_client", "gorduan.valheimplusplus" };

		public const string DataInstalled = "GC.ModSchalter.Installed";

		public const string DataBest = "GC.ModSchalter.Best";

		public const string DataAll = "GC.ModSchalter.All";

		public const string DataSkipped = "GC.ModSchalter.Skipped";

		public const string DataProtected = "GC.ModSchalter.Protected";

		public const string DataFile = "GC.ModSchalter.File";

		private static readonly ManualLogSource Log = Logger.CreateLogSource("GC_ModSchalter");

		public static IEnumerable<string> TargetDLLs { get; } = Array.Empty<string>();

		public static string ListFile => Path.Combine(Path.Combine(Paths.ConfigPath, "GC_Kern"), "aus.txt");

		private static Version Own => typeof(ModSchalter).Assembly.GetName().Version;

		public static void Patch(AssemblyDefinition assembly)
		{
		}

		public static void Initialize()
		{
			AppDomain currentDomain = AppDomain.CurrentDomain;
			if (!(currentDomain.GetData("GC.ModSchalter.Best") is Version version) || Own > version)
			{
				currentDomain.SetData("GC.ModSchalter.Best", Own);
			}
		}

		public static void Finish()
		{
			//IL_0092: 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_00b7: Expected O, but got Unknown
			AppDomain currentDomain = AppDomain.CurrentDomain;
			object data = currentDomain.GetData("GC.ModSchalter.Installed");
			bool flag = default(bool);
			int num;
			if (data is bool)
			{
				flag = (bool)data;
				num = 1;
			}
			else
			{
				num = 0;
			}
			if (((uint)num & (flag ? 1u : 0u)) != 0 || (currentDomain.GetData("GC.ModSchalter.Best") is Version version && Own < version))
			{
				return;
			}
			currentDomain.SetData("GC.ModSchalter.Installed", true);
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(TypeLoader), "FindPluginTypes", (Type[])null, (Type[])null).MakeGenericMethod(typeof(PluginInfo));
				new Harmony("gorduan.gc.modschalter").Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(ModSchalter), "FindPluginTypesPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				currentDomain.SetData("GC.ModSchalter.File", ListFile);
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Konnte sich nicht in BepInEx einhängen, alle Mods laden: {arg}");
			}
		}

		private static void FindPluginTypesPostfix(string cacheName, Dictionary<string, List<PluginInfo>> __result)
		{
			if (cacheName != "chainloader" || __result == null)
			{
				return;
			}
			try
			{
				List<PluginInfo> list = __result.Values.SelectMany((List<PluginInfo> result) => result).ToList();
				AppDomain.CurrentDomain.SetData("GC.ModSchalter.All", list);
				HashSet<string> hashSet = ReadList(ListFile);
				if (hashSet.Count == 0)
				{
					return;
				}
				if (!list.Any((PluginInfo info) => string.Equals(info.Metadata.GUID, "gorduan.gc.kern", StringComparison.OrdinalIgnoreCase)))
				{
					Log.LogWarning((object)"GC_Kern fehlt: aus.txt gilt nicht, alle Mods laden.");
					return;
				}
				if (list.Any((PluginInfo info) => OldPackages.Contains<string>(info.Metadata.GUID, StringComparer.OrdinalIgnoreCase)))
				{
					Log.LogWarning((object)"Ein altes GC-Sammelpaket liegt noch im Ordner, GC_Kern startet dann nicht: aus.txt gilt nicht, alle Mods laden.");
					return;
				}
				HashSet<string> hashSet2 = Protected(list);
				List<PluginInfo> list2 = new List<PluginInfo>();
				PropertyInfo propertyInfo = AccessTools.Property(typeof(PluginInfo), "Location");
				foreach (KeyValuePair<string, List<PluginInfo>> item in __result.ToList())
				{
					foreach (PluginInfo item2 in item.Value.ToList())
					{
						if (hashSet.Contains(item2.Metadata.GUID) && !hashSet2.Contains(item2.Metadata.GUID))
						{
							propertyInfo?.SetValue(item2, item.Key, null);
							item.Value.Remove(item2);
							list2.Add(item2);
							Log.LogMessage((object)$"Im Menü GC Option ausgeschaltet, wird nicht geladen: [{item2}]");
						}
					}
					if (item.Value.Count == 0)
					{
						__result.Remove(item.Key);
					}
				}
				AppDomain.CurrentDomain.SetData("GC.ModSchalter.Skipped", list2);
				AppDomain.CurrentDomain.SetData("GC.ModSchalter.Protected", hashSet2.ToArray());
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Ausgeschaltete Mods nicht gefiltert, alle Mods laden: {arg}");
			}
		}

		private static HashSet<string> Protected(List<PluginInfo> all)
		{
			//IL_0095: 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)
			Dictionary<string, PluginInfo> dictionary = new Dictionary<string, PluginInfo>(StringComparer.OrdinalIgnoreCase);
			foreach (PluginInfo item in all)
			{
				dictionary[item.Metadata.GUID] = item;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "gorduan.gc.kern" };
			Queue<string> queue = new Queue<string>(hashSet);
			while (queue.Count > 0)
			{
				if (!dictionary.TryGetValue(queue.Dequeue(), out var value))
				{
					continue;
				}
				foreach (BepInDependency dependency in value.Dependencies)
				{
					if ((dependency.Flags & 1) != 0 && hashSet.Add(dependency.DependencyGUID))
					{
						queue.Enqueue(dependency.DependencyGUID);
					}
				}
			}
			return hashSet;
		}

		public static HashSet<string> ReadList(string file)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (!File.Exists(file))
			{
				return hashSet;
			}
			string[] array = File.ReadAllLines(file);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0 && !text.StartsWith("#", StringComparison.Ordinal))
				{
					hashSet.Add(text);
				}
			}
			return hashSet;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GC.Shared;
using GC.ValheimPlusPlus.TreeRegrow;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("Gorduan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.5.1.0")]
[assembly: AssemblyInformationalVersion("1.5.1+7c8bde9391283b12125175d68f4632c4cf8f93b3")]
[assembly: AssemblyProduct("GC_Baeume")]
[assembly: AssemblyTitle("GC_Baeume")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 GC.ValheimPlusPlus
{
	internal static class VppPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.ValheimPlusPlus.TreeRegrow
{
	internal static class Plugin
	{
		public const string Guid = "gorduan.gc_treeregrow";

		public const string ModName = "GC_TreeRegrow";

		internal const string TreeKey = "gc_regrow_tree";

		internal const string TimeKey = "gc_regrow_at";

		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<float> OverrideMinutes = null;

		internal static ConfigEntry<float> FallbackMinutes = null;

		internal static ConfigEntry<float> Spread = null;

		internal static ConfigEntry<bool> ShowHover = null;

		internal static readonly Dictionary<string, List<string>> StubToTrees = new Dictionary<string, List<string>>();

		internal static readonly Dictionary<string, Plant> TreeToSapling = new Dictionary<string, Plant>();

		internal static string? PendingTree;

		internal static Vector3 PendingPosition;

		internal static bool Blocked => Chainloader.PluginInfos.ContainsKey("gorduan.gc_treeregrow");

		internal static bool On
		{
			get
			{
				if (Enabled.Value)
				{
					return !Blocked;
				}
				return false;
			}
		}

		internal static bool HoverOn
		{
			get
			{
				if (ShowHover.Value)
				{
					return !Blocked;
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			Log = VppPlugin.Log;
			Enabled = Gc.BindSynced<bool>(Config, "5 - Tree Regrow", "Enabled", true, "Baumstümpfe wachsen wieder zum Baum nach (wird vom Server vorgegeben).", (AcceptableValueBase)null);
			OverrideMinutes = Gc.BindSynced<float>(Config, "5 - Tree Regrow", "OverrideMinutes", 0f, "0 = Wachstumszeit des passenden Setzlings aus dem Spiel. Größer 0 = feste Minuten Spielzeit für alle Bäume (ein Valheim-Tag dauert 30 Minuten).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10080f));
			FallbackMinutes = Gc.BindSynced<float>(Config, "5 - Tree Regrow", "FallbackMinutes", 60f, "Minuten für Bäume, die keinen Setzling haben.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 10080f));
			Spread = Gc.BindSynced<float>(Config, "5 - Tree Regrow", "RandomSpread", 0.25f, "Zufällige Abweichung für feste Zeiten (Override und Fallback), 0.25 = plus/minus 25 %. Setzling-Zeiten haben schon eine eigene Spanne.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.9f));
			ShowHover = Gc.Bind<bool>(Config, "5 - Tree Regrow - Interface", "ShowHover", true, "Restzeit anzeigen, wenn man auf einen Stumpf schaut.", (AcceptableValueBase)null);
		}

		internal static double RegrowSeconds(string? tree)
		{
			if (OverrideMinutes.Value > 0f)
			{
				return (double)OverrideMinutes.Value * 60.0 * (1.0 + (double)Random.Range(0f - Spread.Value, Spread.Value));
			}
			if (tree != null && TreeToSapling.TryGetValue(tree, out Plant value) && (Object)(object)value != (Object)null)
			{
				float num = Mathf.Min(value.m_growTime, value.m_growTimeMax);
				float num2 = Mathf.Max(value.m_growTime, value.m_growTimeMax);
				return Mathf.Lerp(num, num2, Random.value);
			}
			return (double)FallbackMinutes.Value * 60.0 * (1.0 + (double)Random.Range(0f - Spread.Value, Spread.Value));
		}
	}
	[HarmonyPatch(typeof(ZNetScene), "Awake")]
	internal static class ZNetSceneAwakePatch
	{
		private static void Postfix(ZNetScene __instance)
		{
			if (Plugin.Blocked)
			{
				return;
			}
			Plugin.StubToTrees.Clear();
			Plugin.TreeToSapling.Clear();
			foreach (GameObject prefab in __instance.m_prefabs)
			{
				if ((Object)(object)prefab == (Object)null)
				{
					continue;
				}
				Plant component = prefab.GetComponent<Plant>();
				if ((Object)(object)component != (Object)null && component.m_grownPrefabs != null)
				{
					GameObject[] grownPrefabs = component.m_grownPrefabs;
					foreach (GameObject val in grownPrefabs)
					{
						if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<TreeBase>() != (Object)null && !Plugin.TreeToSapling.ContainsKey(((Object)val).name))
						{
							Plugin.TreeToSapling[((Object)val).name] = component;
						}
					}
				}
				TreeBase component2 = prefab.GetComponent<TreeBase>();
				if ((Object)(object)component2 == (Object)null || (Object)(object)component2.m_stubPrefab == (Object)null)
				{
					continue;
				}
				string name = ((Object)component2.m_stubPrefab).name;
				if (!Plugin.StubToTrees.TryGetValue(name, out List<string> value))
				{
					value = (Plugin.StubToTrees[name] = new List<string>());
				}
				value.Add(((Object)prefab).name);
				if (!((Object)(object)component2.m_stubPrefab.GetComponent<RegrowStub>() == (Object)null))
				{
					continue;
				}
				component2.m_stubPrefab.AddComponent<RegrowStub>();
				MonoBehaviour[] componentsInChildren = component2.m_stubPrefab.GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour val2 in componentsInChildren)
				{
					if (val2 is Hoverable && !(val2 is RegrowStub))
					{
						Plugin.Log.LogInfo((object)("Stumpf " + name + " hat schon " + ((object)val2).GetType().Name + " an " + ((Object)val2).name + ": Status kommt dort hin."));
					}
				}
			}
			string arg = string.Join(", ", from pair in Plugin.TreeToSapling
				orderby pair.Key
				select $"{pair.Key} {pair.Value.m_growTime / 60f:0}-{pair.Value.m_growTimeMax / 60f:0} Min.");
			Plugin.Log.LogInfo((object)$"Bäume wachsen nach: {Plugin.StubToTrees.Count} Stumpf-Arten, Setzling-Zeiten für {Plugin.TreeToSapling.Count} Bäume: {arg}");
		}
	}
	[HarmonyPatch(typeof(TreeBase), "SpawnLog")]
	internal static class SpawnLogPatch
	{
		private static void Prefix(TreeBase __instance)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Plugin.PendingTree = Utils.GetPrefabName(((Component)__instance).gameObject);
			Plugin.PendingPosition = ((Component)__instance).transform.position;
		}

		private static void Finalizer()
		{
			Plugin.PendingTree = null;
		}
	}
	public class RegrowStub : MonoBehaviour, Hoverable
	{
		private ZNetView? nview;

		private string? fellenTree;

		private float hoverCheckUntil;

		private bool hoverBlocked;

		private static int pieceMask;

		private long Now
		{
			get
			{
				if (!((Object)(object)ZNet.instance != (Object)null))
				{
					return 0L;
				}
				return ZNet.instance.GetTime().Ticks;
			}
		}

		private void Awake()
		{
			//IL_0007: 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 (Plugin.PendingTree != null && Vector3.Distance(Plugin.PendingPosition, ((Component)this).transform.position) < 1f)
			{
				fellenTree = Plugin.PendingTree;
			}
		}

		private void Start()
		{
			nview = ((Component)this).GetComponent<ZNetView>();
			if (!((Object)(object)nview == (Object)null) && nview.GetZDO() != null)
			{
				if (fellenTree != null && nview.IsOwner())
				{
					nview.GetZDO().Set("gc_regrow_tree", fellenTree);
				}
				((MonoBehaviour)this).InvokeRepeating("Check", Random.Range(3f, 10f), 15f);
			}
		}

		private void Check()
		{
			if (!Plugin.On || (Object)(object)nview == (Object)null || !nview.IsValid() || !nview.IsOwner() || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ZDO zDO = nview.GetZDO();
			string text = zDO.GetString("gc_regrow_tree", "");
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			long num = zDO.GetLong("gc_regrow_at", 0L);
			if (num == 0L)
			{
				zDO.Set("gc_regrow_at", Now + (long)(Plugin.RegrowSeconds(text) * 10000000.0));
			}
			else if (Now >= num)
			{
				if (Blocked())
				{
					zDO.Set("gc_regrow_at", Now + 6000000000L);
				}
				else
				{
					Regrow(zDO);
				}
			}
		}

		private bool Blocked()
		{
			//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_0057: Unknown result type (might be due to invalid IL or missing references)
			if (pieceMask == 0)
			{
				pieceMask = LayerMask.GetMask(new string[6] { "piece", "piece_nonsolid", "Default", "static_solid", "Default_small", "vehicle" });
			}
			Collider[] array = Physics.OverlapSphere(((Component)this).transform.position + Vector3.up, 1.2f, pieceMask, (QueryTriggerInteraction)1);
			for (int i = 0; i < array.Length; i++)
			{
				Piece componentInParent = ((Component)array[i]).GetComponentInParent<Piece>();
				if ((Object)(object)componentInParent != (Object)null && componentInParent.IsPlacedByPlayer())
				{
					return true;
				}
			}
			return false;
		}

		private void Regrow(ZDO zdo)
		{
			//IL_007c: 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_008d: 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_0099: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			string text = zdo.GetString("gc_regrow_tree", "");
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(text) : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)("Kein Baum für Stumpf " + Utils.GetPrefabName(((Component)this).gameObject) + " gefunden, Nachwachsen übersprungen."));
				zdo.Set("gc_regrow_at", Now + 36000000000L);
				return;
			}
			Vector3 position = ((Component)this).transform.position;
			Quaternion rotation = ((Component)this).transform.rotation;
			Vector3 localScale = ((Component)this).transform.localScale;
			ZNetScene.instance.Destroy(((Component)this).gameObject);
			GameObject obj = Object.Instantiate<GameObject>(val, position, rotation);
			ZNetView component = obj.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null)
			{
				component.SetLocalScale(localScale);
			}
			TreeBase component2 = obj.GetComponent<TreeBase>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.Grow();
			}
		}

		public string GetHoverText()
		{
			if (!Plugin.On || !Plugin.HoverOn || (Object)(object)nview == (Object)null || !nview.IsValid() || (Object)(object)ZNet.instance == (Object)null)
			{
				return "";
			}
			if (string.IsNullOrEmpty(nview.GetZDO().GetString("gc_regrow_tree", "")))
			{
				return "";
			}
			long num = nview.GetZDO().GetLong("gc_regrow_at", 0L);
			if (num == 0L)
			{
				return GcLoc.Get("gctr_hover_pending", Array.Empty<object>());
			}
			if (Time.time >= hoverCheckUntil)
			{
				hoverCheckUntil = Time.time + 1f;
				hoverBlocked = Blocked();
			}
			if (hoverBlocked)
			{
				return GcLoc.Get("gctr_hover_blocked", Array.Empty<object>());
			}
			long num2 = num - Now;
			if (num2 <= 0)
			{
				return GcLoc.Get("gctr_hover_soon", Array.Empty<object>());
			}
			long num3 = (long)Math.Ceiling((double)num2 / 10000000.0);
			string text = (num3 / 3600).ToString("00") + ":" + (num3 / 60 % 60).ToString("00") + ":" + (num3 % 60).ToString("00");
			return GcLoc.Get("gctr_hover_time", new object[1] { text });
		}

		public string GetHoverName()
		{
			return GcLoc.Get("gctr_name", Array.Empty<object>());
		}

		public float GetHoverOffset()
		{
			return 0f;
		}
	}
	[HarmonyPatch(typeof(HoverText), "GetHoverText")]
	internal static class HoverTextPatch
	{
		private static void Postfix(HoverText __instance, ref string __result)
		{
			RegrowStub regrowStub = (Plugin.On ? ((Component)__instance).GetComponentInParent<RegrowStub>() : null);
			if ((Object)(object)regrowStub != (Object)null)
			{
				string hoverText = regrowStub.GetHoverText();
				if (hoverText.Length > 0)
				{
					__result = hoverText;
				}
			}
		}
	}
}
namespace GC.ValheimPlusPlus.ModBaeume
{
	[BepInPlugin("gorduan.gc.baeume", "GC_Baeume", "1.5.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			VppPlugin.Log = ((BaseUnityPlugin)this).Logger;
			VppPlugin.Module = Module;
			Harmony val = new Harmony("gorduan.gc.baeume");
			GC.ValheimPlusPlus.TreeRegrow.Plugin.Init(((BaseUnityPlugin)this).Config, val);
			Module.TakeOverOldSettings();
			val.PatchAll(typeof(Plugin).Assembly);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("vpp_" + key, Array.Empty<object>())), (string)null).Main("treeregrow", (ConfigEntryBase)(object)GC.ValheimPlusPlus.TreeRegrow.Plugin.Enabled, (Func<bool>)(() => GC.ValheimPlusPlus.TreeRegrow.Plugin.Blocked), "GC_TreeRegrow", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null).Sub("treeregrow_override", (ConfigEntryBase)(object)GC.ValheimPlusPlus.TreeRegrow.Plugin.OverrideMinutes, 10.0, " min", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("treeregrow_fallback", (ConfigEntryBase)(object)GC.ValheimPlusPlus.TreeRegrow.Plugin.FallbackMinutes, 10.0, " min", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("treeregrow_spread", (ConfigEntryBase)(object)GC.ValheimPlusPlus.TreeRegrow.Plugin.Spread, 0.05, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("treeregrowhover", (ConfigEntryBase)(object)GC.ValheimPlusPlus.TreeRegrow.Plugin.ShowHover, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null);
		}
	}
	internal static class GcMod
	{
		public const string Id = "baeume";

		public const string Guid = "gorduan.gc.baeume";

		public const string Name = "GC_Baeume";

		public const string Version = "1.5.1";

		public const int Stufe = 4;

		public static GcModInfo Info => new GcModInfo
		{
			Id = "baeume",
			Guid = "gorduan.gc.baeume",
			Name = "GC_Baeume",
			Version = "1.5.1",
			Stufe = 4,
			Seite = (GcSeite)2,
			Braucht = Array.Empty<string>(),
			Partner = Array.Empty<string>(),
			Fremd = Array.Empty<string>(),
			AlteConfig = "gorduan.valheimplusplus.cfg",
			Ausgleich = 0f
		};
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GC.Shared;
using GC.ValheimPlusPlus.BaseFood;
using HarmonyLib;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("assembly_guiutils")]
[assembly: IgnoresAccessChecksTo("assembly_utils")]
[assembly: IgnoresAccessChecksTo("assembly_valheim")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: AssemblyCompany("Gorduan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.5.1.0")]
[assembly: AssemblyInformationalVersion("1.5.1+7c8bde9391283b12125175d68f4632c4cf8f93b3")]
[assembly: AssemblyProduct("GC_BasisEssen")]
[assembly: AssemblyTitle("GC_BasisEssen")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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 GC.ValheimPlusPlus
{
	internal static class VppPlugin
	{
		internal static ManualLogSource Log;

		internal static GcModule? Module;

		internal static bool Allowed
		{
			get
			{
				if (Module != null)
				{
					return Module.Allowed;
				}
				return true;
			}
		}

		internal static bool OnServer
		{
			get
			{
				if (Module != null)
				{
					return Module.OnServer;
				}
				return false;
			}
		}
	}
}
namespace GC.ValheimPlusPlus.ModBasisEssen
{
	[BepInPlugin("gorduan.gc.basisessen", "GC_BasisEssen", "1.5.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static GcModule Module;

		private void Awake()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			VppPlugin.Log = ((BaseUnityPlugin)this).Logger;
			VppPlugin.Module = Module;
			Harmony val = new Harmony("gorduan.gc.basisessen");
			GC.ValheimPlusPlus.BaseFood.Plugin.Init(((BaseUnityPlugin)this).Config, val);
			Module.TakeOverOldSettings();
			Module.IsOn = () => GC.ValheimPlusPlus.BaseFood.Plugin.On;
			val.PatchAll(typeof(Plugin).Assembly);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("vpp_" + key, Array.Empty<object>())), (string)null).Main("basefood", (ConfigEntryBase)(object)GC.ValheimPlusPlus.BaseFood.Plugin.Enabled, (Func<bool>)null, "", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null).Sub("basefood_workbench", (ConfigEntryBase)(object)GC.ValheimPlusPlus.BaseFood.Plugin.WorkbenchPercent, 10.0, " %", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("basefood_ward", (ConfigEntryBase)(object)GC.ValheimPlusPlus.BaseFood.Plugin.WardPercent, 10.0, " %", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("basefood_access", (ConfigEntryBase)(object)GC.ValheimPlusPlus.BaseFood.Plugin.WardNeedsAccess, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null);
		}
	}
	internal static class GcMod
	{
		public const string Id = "basisessen";

		public const string Guid = "gorduan.gc.basisessen";

		public const string Name = "GC_BasisEssen";

		public const string Version = "1.5.1";

		public const int Stufe = 4;

		public static GcModInfo Info => new GcModInfo
		{
			Id = "basisessen",
			Guid = "gorduan.gc.basisessen",
			Name = "GC_BasisEssen",
			Version = "1.5.1",
			Stufe = 4,
			Seite = (GcSeite)2,
			Braucht = Array.Empty<string>(),
			Partner = Array.Empty<string>(),
			Fremd = Array.Empty<string>(),
			AlteConfig = "gorduan.valheimplusplus.cfg",
			Ausgleich = 1f
		};
	}
}
namespace GC.ValheimPlusPlus.BaseFood
{
	internal static class Plugin
	{
		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<int> WorkbenchPercent = null;

		internal static ConfigEntry<int> WardPercent = null;

		internal static ConfigEntry<string> Stations = null;

		internal static ConfigEntry<bool> WardNeedsAccess = null;

		private static float nextCheck;

		private static float cached;

		private static HashSet<string>? stationSet;

		private static string stationText = "";

		internal static bool On => Enabled.Value;

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			Log = VppPlugin.Log;
			Enabled = Gc.BindSynced<bool>(Config, "6 - Base Hunger", "Enabled", true, "Weniger Hungerverlust im Bereich von Werkbänken und Wächtersteinen (wird vom Server vorgegeben).", (AcceptableValueBase)null);
			WorkbenchPercent = Gc.BindSynced<int>(Config, "6 - Base Hunger", "WorkbenchPercent", 50, "Um wie viel Prozent der Hungerverlust im Bereich einer Werkbank sinkt. 0 = wie Vanilla, 100 = kein Hungerverlust.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100));
			WardPercent = Gc.BindSynced<int>(Config, "6 - Base Hunger", "WardPercent", 50, "Um wie viel Prozent der Hungerverlust im Bereich eines aktiven Wächtersteins sinkt. 0 = wie Vanilla, 100 = kein Hungerverlust.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100));
			Stations = Gc.BindSynced<string>(Config, "6 - Base Hunger", "Stations", "piece_workbench", "Kommagetrennte Prefab-Namen der Stationen, deren Bereich zählt (z. B. piece_workbench, forge, piece_stonecutter, piece_artisanstation, blackforge, piece_magetable).", (AcceptableValueBase)null);
			WardNeedsAccess = Gc.BindSynced<bool>(Config, "6 - Base Hunger", "WardNeedsAccess", true, "Nur Wächtersteine zählen, auf die der Spieler Zugriff hat (eigene oder freigegebene).", (AcceptableValueBase)null);
		}

		internal static float Reduction(Player player)
		{
			//IL_0028: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time < nextCheck)
			{
				return cached;
			}
			nextCheck = Time.time + 1f;
			Vector3 position = ((Component)player).transform.position;
			int num = 0;
			if (WorkbenchPercent.Value > num && NearStation(position))
			{
				num = WorkbenchPercent.Value;
			}
			if (WardPercent.Value > num && InWard(position))
			{
				num = WardPercent.Value;
			}
			cached = Mathf.Clamp01((float)num / 100f);
			return cached;
		}

		private static bool NearStation(Vector3 position)
		{
			//IL_0070: 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_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_0094: Unknown result type (might be due to invalid IL or missing references)
			if (stationSet == null || stationText != Stations.Value)
			{
				stationText = Stations.Value;
				stationSet = Gc.ParseList(stationText);
			}
			foreach (CraftingStation allStation in CraftingStation.m_allStations)
			{
				if (!((Object)(object)allStation == (Object)null) && stationSet.Contains(Utils.GetPrefabName(((Component)allStation).gameObject)))
				{
					Vector3 val = position;
					val.y = ((Component)allStation).transform.position.y;
					if (Vector3.Distance(((Component)allStation).transform.position, val) < allStation.GetStationBuildRange())
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool InWard(Vector3 position)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			foreach (PrivateArea allArea in PrivateArea.m_allAreas)
			{
				if ((Object)(object)allArea != (Object)null && allArea.IsEnabled() && allArea.IsInside(position, 0f) && (!WardNeedsAccess.Value || allArea.HaveLocalAccess()))
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateFood")]
	internal static class UpdateFoodPatch
	{
		private static readonly List<KeyValuePair<Food, float>> Before = new List<KeyValuePair<Food, float>>();

		private static void Prefix(Player __instance, out bool __state)
		{
			__state = false;
			if (!Plugin.On || (Object)(object)__instance != (Object)(object)Player.m_localPlayer || __instance.m_foods.Count == 0 || Plugin.Reduction(__instance) <= 0f)
			{
				return;
			}
			Before.Clear();
			foreach (Food food in __instance.m_foods)
			{
				Before.Add(new KeyValuePair<Food, float>(food, food.m_time));
			}
			__state = true;
		}

		private static void Postfix(Player __instance, bool __state)
		{
			if (!__state)
			{
				return;
			}
			float num = Plugin.Reduction(__instance);
			foreach (KeyValuePair<Food, float> item in Before)
			{
				Food key = item.Key;
				float num2 = item.Value - key.m_time;
				if (!(num2 <= 0f) && __instance.m_foods.Contains(key))
				{
					key.m_time = Mathf.Min(item.Value, key.m_time + num2 * num);
				}
			}
			Before.Clear();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}