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_Server")]
[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.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.Client;
using GC.Client.Fields;
using GC.Server;
using GC.Server.Fields;
using GC.Shared;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;

[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.8.1.0")]
[assembly: AssemblyInformationalVersion("1.8.1+7c8bde9391283b12125175d68f4632c4cf8f93b3")]
[assembly: AssemblyProduct("GC_Felder")]
[assembly: AssemblyTitle("GC_Felder")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.8.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.Server
{
	internal static class ServerPlugin
	{
		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.Server.Fields
{
	public enum Removers
	{
		Everyone,
		CreatorOrAdmin,
		CreatorGuildLeadersOrAdmin,
		AdminOnly
	}
	internal static class Plugin
	{
		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<Removers> RemoveBy;

		internal static ConfigEntry<int> MaxPoints;

		internal static ConfigEntry<float> MaxEdge;

		internal static ConfigEntry<float> Reach;

		internal static ConfigEntry<float> Interval;

		internal static ConfigEntry<float> SpacingBush;

		internal static ConfigEntry<float> SpacingMushroom;

		internal static ConfigEntry<float> SpacingOther;

		internal static void Init(ConfigFile Config)
		{
			Log = ServerPlugin.Log;
			Enabled = Gc.BindSynced<bool>(Config, "11 - Fields", "Enabled", true, "Felder mit dem Kultivator markieren und automatisch in Reihen bepflanzen (Zeichnen und Pflanzen in GC_Client, wird vom Server vorgegeben).", (AcceptableValueBase)null);
			RemoveBy = Gc.BindSynced<Removers>(Config, "11 - Fields", "RemoveBy", Removers.Everyone, "Wer ein Feld aufheben darf: Everyone (alle), CreatorOrAdmin (Ersteller und Admins), CreatorGuildLeadersOrAdmin (Ersteller, Leiter und Co-Leiter seiner Gilde, Admins; ohne Gilden-Mod wie CreatorOrAdmin), AdminOnly (nur Admins). Die Pflanzen bleiben immer stehen.", (AcceptableValueBase)null);
			MaxPoints = Gc.BindSynced<int>(Config, "11 - Fields", "MaxPoints", 32, "Höchstzahl Eckpunkte je Feld, 0 = unbegrenzt.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000));
			MaxEdge = Gc.BindSynced<float>(Config, "11 - Fields", "MaxEdgeLength", 50f, "Höchstlänge einer Feldkante in Metern, 0 = unbegrenzt.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1000f));
			Reach = Gc.BindSynced<float>(Config, "11 - Fields", "Reach", 10f, "So weit vom Spieler werden Plätze im Feld bepflanzt (Meter). Man kann sich dabei bewegen.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 100f));
			Interval = Gc.BindSynced<float>(Config, "11 - Fields", "PlantInterval", 0.5f, "Sekunden zwischen zwei Pflanzen beim Halten von E (Valheim selbst braucht mindestens 0,4 s).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f));
			SpacingBush = Gc.BindSynced<float>(Config, "11 - Fields", "SpacingBush", 1.5f, "Abstand für Sträucher ohne eigene Wachstumsregel (z. B. Beerensträucher aus PlantEverything), in Metern.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 50f));
			SpacingMushroom = Gc.BindSynced<float>(Config, "11 - Fields", "SpacingMushroom", 0.5f, "Abstand für Pilze ohne eigene Wachstumsregel, in Metern.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 50f));
			SpacingOther = Gc.BindSynced<float>(Config, "11 - Fields", "SpacingOther", 1f, "Abstand für alles andere ohne eigene Wachstumsregel (Blumen, Disteln usw.), in Metern.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 50f));
			GcFields.Publish(new Dictionary<string, Func<object>>
			{
				["enabled"] = () => Enabled.Value,
				["removeBy"] = () => (int)RemoveBy.Value,
				["maxPoints"] = () => MaxPoints.Value,
				["maxEdge"] = () => MaxEdge.Value,
				["reach"] = () => Reach.Value,
				["interval"] = () => Interval.Value,
				["spacingBush"] = () => SpacingBush.Value,
				["spacingMushroom"] = () => SpacingMushroom.Value,
				["spacingOther"] = () => SpacingOther.Value
			});
			PrefabManager.OnVanillaPrefabsAvailable += CreatePrefab;
		}

		private static void CreatePrefab()
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			PrefabManager.OnVanillaPrefabsAvailable -= CreatePrefab;
			GameObject val = PrefabManager.Instance.CreateEmptyPrefab("GC_Field", true);
			if ((Object)(object)val == (Object)null)
			{
				Log.LogError((object)"Felder: Welt-Objekt GC_Field konnte nicht angelegt werden.");
				return;
			}
			Component[] components = val.GetComponents<Component>();
			foreach (Component val2 in components)
			{
				if (val2 is Collider || val2 is Renderer || val2 is MeshFilter)
				{
					Object.DestroyImmediate((Object)(object)val2);
				}
			}
			ZNetView component = val.GetComponent<ZNetView>();
			component.m_persistent = true;
			component.m_distant = true;
			PrefabManager.Instance.AddPrefab(new CustomPrefab(val, false));
			Log.LogInfo((object)"Felder: Welt-Objekt GC_Field angelegt.");
		}
	}
}
namespace GC.Mods.Felder
{
	[BepInPlugin("gorduan.gc.felder", "GC_Felder", "1.8.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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			Module = GcKern.Register((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, GcMod.Info);
			ClientPlugin.Log = ((BaseUnityPlugin)this).Logger;
			ClientPlugin.Module = Module;
			ServerPlugin.Log = ((BaseUnityPlugin)this).Logger;
			ServerPlugin.Module = Module;
			Harmony val = new Harmony("gorduan.gc.felder");
			GC.Client.Fields.Plugin.Init(((BaseUnityPlugin)this).Config, val);
			GC.Server.Fields.Plugin.Init(((BaseUnityPlugin)this).Config);
			Module.TakeOverOldSettings();
			val.PatchAll(typeof(Plugin).Assembly);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gcsv_" + key, Array.Empty<object>())), (string)null).Main("fields", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.Enabled, (Func<bool>)null, "", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null).Sub("fields_remove", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.RemoveBy, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_points", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.MaxPoints, 1.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_edge", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.MaxEdge, 5.0, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_reach", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.Reach, 1.0, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_interval", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.Interval, 0.1, " s", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_bush", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.SpacingBush, 0.1, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_mushroom", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.SpacingMushroom, 0.1, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_other", (ConfigEntryBase)(object)GC.Server.Fields.Plugin.SpacingOther, 0.1, " m", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null);
			Module.MenuGroup((Func<string, string>)((string key) => GcLoc.Get("gccm_" + key, Array.Empty<object>())), "gck_mod_felder_anzeige").Main("fields", (ConfigEntryBase)(object)GC.Client.Fields.Plugin.Enabled, (Func<bool>)null, "", (Func<string>)null, 0.0, "", (Func<bool>)null, (Func<bool>)null).Sub("fields_color", (ConfigEntryBase)(object)GC.Client.Fields.Plugin.Tint, 0.0, "", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_fill", (ConfigEntryBase)(object)GC.Client.Fields.Plugin.FillOpacity, 5.0, " %", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null)
				.Sub("fields_line", (ConfigEntryBase)(object)GC.Client.Fields.Plugin.LineOpacity, 5.0, " %", (Func<bool>)null, "", (Func<bool>)null, (Func<bool>)null);
		}

		private void Update()
		{
			if (!Gc.IsHeadless)
			{
				Module.Guard("Felder", (Action)GC.Client.Fields.Plugin.Update);
			}
		}
	}
	internal static class GcMod
	{
		public const string Id = "felder";

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

		public const string Name = "GC_Felder";

		public const string Version = "1.8.1";

		public const int Stufe = 3;

		public static GcModInfo Info => new GcModInfo
		{
			Id = "felder",
			Guid = "gorduan.gc.felder",
			Name = "GC_Felder",
			Version = "1.8.1",
			Stufe = 3,
			Seite = (GcSeite)1,
			Braucht = Array.Empty<string>(),
			Partner = Array.Empty<string>(),
			Fremd = Array.Empty<string>(),
			AlteConfig = "gorduan.gc_client.cfg;gorduan.gc_server.cfg",
			Ausgleich = 0f
		};
	}
}
namespace GC.Client
{
	internal static class ClientPlugin
	{
		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.Client.Fields
{
	internal sealed class Spec
	{
		public Piece Piece;

		public Plant? Plant;

		public float Radius;

		public float Body;

		public float Step;
	}
	internal struct Neighbour
	{
		public Vector3 Position;

		public float Radius;

		public float Body;
	}
	internal static class Planting
	{
		private enum Kind : byte
		{
			None,
			Plant,
			Pickable
		}

		private struct PrefabInfo
		{
			public Kind Kind;

			public float Radius;

			public float Body;
		}

		private const float Margin = 0.05f;

		private const float Slack = 0.02f;

		private const string PlantEasilyGuid = "advize.PlantEasily";

		private static readonly Dictionary<string, Spec> Specs = new Dictionary<string, Spec>();

		private static readonly Dictionary<string, float> Bodies = new Dictionary<string, float>();

		private static readonly Dictionary<int, PrefabInfo> Prefabs = new Dictionary<int, PrefabInfo>();

		private static Dictionary<string, float>? grownRadius;

		private static float cachesUntil;

		private static readonly List<Neighbour> Neighbours = new List<Neighbour>();

		private static readonly Dictionary<long, float> Failed = new Dictionary<long, float>();

		private static readonly List<long> Expired = new List<long>();

		private static readonly List<(Vector3 Position, Spec Spec, float Until)> Recent = new List<(Vector3, Spec, float)>();

		private static readonly Collider[] Hits = (Collider[])(object)new Collider[64];

		private static int roofMask;

		private static int spaceMask;

		private static bool inGhost;

		internal static bool Redirected;

		private static bool blocking;

		private static Vector3 target;

		private static PlacementStatus captured;

		private static Vector3 capturedPosition;

		private static bool lastValid;

		private static Vector3? slot;

		private static float searchUntil;

		private static FieldView? slotField;

		private static Spec? slotSpec;

		private static bool holding;

		private static bool noSeeds;

		private static float nextAuto;

		private static float autoClickUntil;

		private static float nextNoSlot;

		private static bool warnedPlantEasily;

		private static float Reach => GcFields.Get<float>("reach", 10f);

		internal static bool PlantEasily => Chainloader.PluginInfos.ContainsKey("advize.PlantEasily");

		internal static void ResetCaches()
		{
			Specs.Clear();
			Bodies.Clear();
			Prefabs.Clear();
			grownRadius = null;
			Recent.Clear();
			Failed.Clear();
			slot = null;
			slotField = null;
			slotSpec = null;
		}

		internal static bool IsPlantable(Piece? piece)
		{
			if ((Object)(object)piece != (Object)null && !Plugin.IsMarker(piece) && (Object)(object)((Component)piece).GetComponent<TerrainOp>() == (Object)null)
			{
				if (!((Object)(object)((Component)piece).GetComponent<Plant>() != (Object)null))
				{
					return (Object)(object)((Component)piece).GetComponent<Pickable>() != (Object)null;
				}
				return true;
			}
			return false;
		}

		private static void RefreshCaches()
		{
			if (!(Time.time < cachesUntil))
			{
				cachesUntil = Time.time + 30f;
				Specs.Clear();
				Prefabs.Clear();
				grownRadius = null;
			}
		}

		private static Spec SpecOf(Piece piece)
		{
			string name = ((Object)((Component)piece).gameObject).name;
			if (Specs.TryGetValue(name, out Spec value) && (Object)(object)value.Piece == (Object)(object)piece)
			{
				return value;
			}
			Plant component = ((Component)piece).GetComponent<Plant>();
			float num = BodyOf(name, ((Component)piece).gameObject);
			float num2 = (((Object)(object)component != (Object)null) ? component.m_growRadius : Mathf.Max(0.05f, Spacing(name) - num));
			value = new Spec
			{
				Piece = piece,
				Plant = component,
				Radius = num2,
				Body = num,
				Step = num2 + num + 0.05f + 0.02f
			};
			Specs[name] = value;
			return value;
		}

		private static float Spacing(string name)
		{
			string text = name.ToLowerInvariant();
			if (text.Contains("bush"))
			{
				return GcFields.Get<float>("spacingBush", 1.5f);
			}
			if (text.Contains("mushroom"))
			{
				return GcFields.Get<float>("spacingMushroom", 0.5f);
			}
			return GcFields.Get<float>("spacingOther", 1f);
		}

		private static float BodyOf(string name, GameObject? instance)
		{
			if (Bodies.TryGetValue(name, out var value))
			{
				return value;
			}
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(name) : null);
			GameObject val2 = (GameObject)(((Object)(object)val != (Object)null) ? ((object)val) : ((object)instance));
			value = (((Object)(object)val2 != (Object)null) ? ColliderRadius(val2) : 0.2f);
			Plant val3 = (((Object)(object)val2 != (Object)null) ? val2.GetComponent<Plant>() : null);
			if ((Object)(object)val3 != (Object)null && val3.m_grownPrefabs != null)
			{
				GameObject[] grownPrefabs = val3.m_grownPrefabs;
				foreach (GameObject val4 in grownPrefabs)
				{
					if ((Object)(object)val4 != (Object)null)
					{
						value = Mathf.Max(value, ColliderRadius(val4));
					}
				}
			}
			value = Mathf.Clamp(value, 0.05f, 1.5f);
			Bodies[name] = value;
			return value;
		}

		private static float ColliderRadius(GameObject go)
		{
			//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_003b: 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_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_006e: 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_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_00db: 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_00f1: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_0156: 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_016f: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: 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_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			Transform transform = go.transform;
			Collider[] componentsInChildren = go.GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (val.isTrigger)
				{
					continue;
				}
				Vector3 lossyScale = ((Component)val).transform.lossyScale;
				float num2 = Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Abs(lossyScale.z));
				Vector3 val2 = transform.InverseTransformPoint(((Component)val).transform.position);
				Vector2 val3 = new Vector2(val2.x, val2.z);
				float magnitude = ((Vector2)(ref val3)).magnitude;
				Collider val4 = val;
				CapsuleCollider val5 = (CapsuleCollider)(object)((val4 is CapsuleCollider) ? val4 : null);
				float num4;
				if (val5 == null)
				{
					SphereCollider val6 = (SphereCollider)(object)((val4 is SphereCollider) ? val4 : null);
					if (val6 == null)
					{
						BoxCollider val7 = (BoxCollider)(object)((val4 is BoxCollider) ? val4 : null);
						if (val7 == null)
						{
							MeshCollider val8 = (MeshCollider)(object)((val4 is MeshCollider) ? val4 : null);
							if (val8 != null && (Object)(object)val8.sharedMesh != (Object)null)
							{
								Bounds bounds = val8.sharedMesh.bounds;
								float num3 = ((Bounds)(ref bounds)).extents.x * Mathf.Abs(lossyScale.x);
								bounds = val8.sharedMesh.bounds;
								num4 = Mathf.Max(num3, ((Bounds)(ref bounds)).extents.z * Mathf.Abs(lossyScale.z));
							}
							else
							{
								num4 = 0f;
							}
						}
						else
						{
							float num5 = 0.5f * Mathf.Max(val7.size.x * Mathf.Abs(lossyScale.x), val7.size.z * Mathf.Abs(lossyScale.z));
							val3 = new Vector2(val7.center.x, val7.center.z);
							num4 = num5 + ((Vector2)(ref val3)).magnitude * num2;
						}
					}
					else
					{
						float num6 = val6.radius * num2;
						val3 = new Vector2(val6.center.x, val6.center.z);
						num4 = num6 + ((Vector2)(ref val3)).magnitude * num2;
					}
				}
				else
				{
					float num7 = val5.radius * num2;
					val3 = new Vector2(val5.center.x, val5.center.z);
					num4 = num7 + ((Vector2)(ref val3)).magnitude * num2;
				}
				float num8 = num4;
				num = Mathf.Max(num, num8 + magnitude);
			}
			return num;
		}

		private static float GrownRadius(string name)
		{
			if (grownRadius == null)
			{
				grownRadius = new Dictionary<string, float>();
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					foreach (GameObject prefab in ZNetScene.instance.m_prefabs)
					{
						Plant val = (((Object)(object)prefab != (Object)null) ? prefab.GetComponent<Plant>() : null);
						if (val?.m_grownPrefabs == null)
						{
							continue;
						}
						GameObject[] grownPrefabs = val.m_grownPrefabs;
						foreach (GameObject val2 in grownPrefabs)
						{
							if ((Object)(object)val2 != (Object)null && (!grownRadius.TryGetValue(((Object)val2).name, out var value) || val.m_growRadius > value))
							{
								grownRadius[((Object)val2).name] = val.m_growRadius;
							}
						}
					}
				}
			}
			if (!grownRadius.TryGetValue(name, out var value2))
			{
				return -1f;
			}
			return value2;
		}

		private static PrefabInfo InfoOf(int hash)
		{
			if (Prefabs.TryGetValue(hash, out var value))
			{
				return value;
			}
			value = new PrefabInfo
			{
				Kind = Kind.None
			};
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab(hash) : null);
			if ((Object)(object)val != (Object)null)
			{
				Plant component = val.GetComponent<Plant>();
				if ((Object)(object)component != (Object)null)
				{
					value = new PrefabInfo
					{
						Kind = Kind.Plant,
						Radius = component.m_growRadius,
						Body = BodyOf(((Object)val).name, val)
					};
				}
				else if ((Object)(object)val.GetComponent<Pickable>() != (Object)null)
				{
					float num = BodyOf(((Object)val).name, val);
					float num2 = GrownRadius(((Object)val).name);
					value = new PrefabInfo
					{
						Kind = Kind.Pickable,
						Radius = ((num2 >= 0f) ? num2 : Mathf.Max(0.05f, Spacing(((Object)val).name) - num)),
						Body = num
					};
				}
			}
			Prefabs[hash] = value;
			return value;
		}

		private static void CollectNeighbours(Vector3 around, float range)
		{
			//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_0049: 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_0057: 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_0097: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			Neighbours.Clear();
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				return;
			}
			float num = range * range;
			foreach (KeyValuePair<ZDO, ZNetView> instance in ZNetScene.instance.m_instances)
			{
				ZDO key = instance.Key;
				Vector3 position = key.GetPosition();
				float num2 = position.x - around.x;
				float num3 = position.z - around.z;
				if (!(num2 * num2 + num3 * num3 > num))
				{
					PrefabInfo prefabInfo = InfoOf(key.GetPrefab());
					if (prefabInfo.Kind != Kind.None)
					{
						Neighbours.Add(new Neighbour
						{
							Position = position,
							Radius = prefabInfo.Radius,
							Body = prefabInfo.Body
						});
					}
				}
			}
			for (int num4 = Recent.Count - 1; num4 >= 0; num4--)
			{
				if (Time.time > Recent[num4].Until)
				{
					Recent.RemoveAt(num4);
				}
				else
				{
					Neighbours.Add(new Neighbour
					{
						Position = Recent[num4].Position,
						Radius = Recent[num4].Spec.Radius,
						Body = Recent[num4].Spec.Body
					});
				}
			}
		}

		private static bool PairOk(Vector3 point, Spec spec)
		{
			//IL_003c: 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_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)
			foreach (Neighbour neighbour in Neighbours)
			{
				float num = Mathf.Max(spec.Radius + neighbour.Body, neighbour.Radius + spec.Body) + 0.05f;
				float num2 = neighbour.Position.x - point.x;
				float num3 = neighbour.Position.z - point.z;
				if (num2 * num2 + num3 * num3 < num * num)
				{
					return false;
				}
			}
			return true;
		}

		private static bool Grows(Vector3 point, Spec spec)
		{
			//IL_0021: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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_004e: 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_005a: 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_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_0136: 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_0085: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Invalid comparison between Unknown and I4
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//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_0110: 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: Invalid comparison between Unknown and I4
			if ((Object)(object)ZoneSystem.instance != (Object)null && point.y < ZoneSystem.instance.m_waterLevel)
			{
				return false;
			}
			Heightmap val = Heightmap.FindHeightmap(point);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Biome biome = val.GetBiome(point, 0.02f, false);
			if ((int)spec.Piece.m_onlyInBiome != 0 && (biome & spec.Piece.m_onlyInBiome) == 0)
			{
				return false;
			}
			Plant plant = spec.Plant;
			if ((Object)(object)plant != (Object)null)
			{
				if ((biome & plant.m_biome) == 0 || (plant.m_needCultivatedGround && !val.IsCultivated(point)) || plant.m_attachDistance > 0f)
				{
					return false;
				}
				bool flag = ShieldGenerator.IsInsideShield(point);
				if ((!plant.m_tolerateHeat && (int)biome == 32 && !flag) || (!plant.m_tolerateCold && ((int)biome == 64 || (int)biome == 4) && !flag))
				{
					return false;
				}
				if (roofMask == 0)
				{
					roofMask = LayerMask.GetMask(new string[3] { "Default", "static_solid", "piece" });
				}
				if (Physics.Raycast(point + Vector3.up * 0.1f, Vector3.up, 100f, roofMask))
				{
					return false;
				}
			}
			if (spec.Piece.m_cultivatedGroundOnly && !val.IsCultivated(point))
			{
				return false;
			}
			if (spaceMask == 0)
			{
				spaceMask = LayerMask.GetMask(new string[5] { "Default", "static_solid", "Default_small", "piece", "piece_nonsolid" });
			}
			int num = Physics.OverlapSphereNonAlloc(point, spec.Radius + 0.02f, Hits, spaceMask);
			for (int i = 0; i < num; i++)
			{
				Collider val2 = Hits[i];
				if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).GetComponentInParent<Plant>() == (Object)null && (Object)(object)((Component)val2).GetComponentInParent<Pickable>() == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		private static long Key(Vector3 point)
		{
			//IL_0000: 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)
			return ((long)Mathf.RoundToInt(point.x * 10f) << 32) ^ (uint)Mathf.RoundToInt(point.z * 10f);
		}

		private static bool IsFailed(Vector3 point)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (Failed.TryGetValue(Key(point), out var value))
			{
				return Time.time < value;
			}
			return false;
		}

		private static Vector3? Search(Player player, Field field, Spec spec)
		{
			//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_0012: 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_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_0086: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_0143: 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_016c: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: 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_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: 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_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: 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_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)player).transform.position;
			float reach = Reach;
			CollectNeighbours(position, reach + 4f);
			float step = spec.Step;
			float num = step * 0.8660254f;
			float num2 = Mathf.Min(spec.Body, 0.25f) + 0.05f;
			float num3 = float.MaxValue;
			float num4 = float.MinValue;
			float num5 = float.MaxValue;
			float num6 = float.MinValue;
			foreach (Vector3 point in field.Points)
			{
				Vector3 val = point - field.Origin;
				float num7 = val.x * field.Along.x + val.z * field.Along.z;
				float num8 = val.x * field.Inward.x + val.z * field.Inward.z;
				num3 = Mathf.Min(num3, num7);
				num4 = Mathf.Max(num4, num7);
				num5 = Mathf.Min(num5, num8);
				num6 = Mathf.Max(num6, num8);
			}
			Vector3 val2 = position - field.Origin;
			float num9 = val2.x * field.Along.x + val2.z * field.Along.z;
			float num10 = val2.x * field.Inward.x + val2.z * field.Inward.z;
			num3 = Mathf.Max(num3, num9 - reach);
			num4 = Mathf.Min(num4, num9 + reach);
			num5 = Mathf.Max(num5, num10 - reach);
			num6 = Mathf.Min(num6, num10 + reach);
			if (num3 > num4 || num5 > num6)
			{
				return null;
			}
			int num11 = Mathf.FloorToInt((num5 - num2) / num);
			int num12 = Mathf.CeilToInt((num6 - num2) / num);
			for (int i = num11; i <= num12; i++)
			{
				float num13 = num2 + (float)i * num;
				float num14 = (((i & 1) == 1) ? (step * 0.5f) : 0f);
				int num15 = Mathf.FloorToInt((num3 - num14) / step);
				int num16 = Mathf.CeilToInt((num4 - num14) / step);
				for (int j = num15; j <= num16; j++)
				{
					float num17 = (float)j * step + num14;
					Vector3 val3 = field.Origin + field.Along * num17 + field.Inward * num13;
					float num18 = val3.x - position.x;
					float num19 = val3.z - position.z;
					if (!(num18 * num18 + num19 * num19 > reach * reach) && field.Contains(val3) && !(field.EdgeDistance(val3) < num2))
					{
						val3.y = Geometry.Ground(val3);
						if (!IsFailed(val3) && PairOk(val3, spec) && Grows(val3, spec))
						{
							return val3;
						}
					}
				}
			}
			return null;
		}

		internal static void BeginGhost()
		{
			inGhost = true;
			Redirected = false;
			blocking = false;
		}

		internal static bool Redirect(Player player, bool hit, Vector3 aim, out Vector3 point)
		{
			//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_0071: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			point = Vector3.zero;
			if (!inGhost || (Object)(object)player != (Object)(object)Player.m_localPlayer || !Plugin.On || !Plugin.HoldsCultivator(player))
			{
				return false;
			}
			Piece selectedPiece = player.GetSelectedPiece();
			if (!IsPlantable(selectedPiece))
			{
				return false;
			}
			if (PlantEasily)
			{
				if (!warnedPlantEasily)
				{
					warnedPlantEasily = true;
					Plugin.Log.LogWarning((object)"Felder: PlantEasily ist installiert (setzt ganze Raster je Klick), deshalb pflanzen Felder nicht automatisch.");
				}
				return false;
			}
			RefreshCaches();
			FieldView fieldView = (hit ? Plugin.At(aim) : null);
			FieldView fieldView2 = fieldView;
			if ((Object)(object)fieldView2 == (Object)null && holding)
			{
				fieldView2 = Plugin.Nearest(((Component)player).transform.position, Reach);
			}
			Field field = (((Object)(object)fieldView2 != (Object)null) ? fieldView2.Data : null);
			if (field == null)
			{
				slot = null;
				return false;
			}
			Spec spec = SpecOf(selectedPiece);
			if ((Object)(object)fieldView2 != (Object)(object)slotField || spec != slotSpec || Time.time >= searchUntil)
			{
				slotField = fieldView2;
				slotSpec = spec;
				searchUntil = Time.time + 0.25f;
				slot = Search(player, field, spec);
			}
			if (!slot.HasValue)
			{
				blocking = (Object)(object)fieldView != (Object)null;
				return false;
			}
			point = slot.Value;
			target = point;
			Redirected = true;
			return true;
		}

		internal static void Capture(Player player)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (Redirected && (Object)(object)player.m_placementGhost != (Object)null)
			{
				captured = player.m_placementStatus;
				capturedPosition = player.m_placementGhost.transform.position;
			}
		}

		internal static void EndGhost(Player player, bool placing)
		{
			//IL_002d: 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_0037: 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_00d9: 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_007a: 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_007d: Invalid comparison between Unknown and I4
			//IL_0051: 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)
			//IL_0061: 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_006d: Invalid comparison between Unknown and I4
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			inGhost = false;
			GameObject placementGhost = player.m_placementGhost;
			lastValid = false;
			if ((Object)(object)placementGhost == (Object)null)
			{
				return;
			}
			if (Redirected)
			{
				Vector3 val = placementGhost.transform.position - capturedPosition;
				if (((Vector3)(ref val)).sqrMagnitude > 1E-06f)
				{
					placementGhost.transform.position = capturedPosition;
					player.m_placementStatus = captured;
					player.SetPlacementGhostValid((int)captured == 0);
				}
				PlacementStatus placementStatus = player.m_placementStatus;
				lastValid = (int)placementStatus == 0;
				if (!lastValid)
				{
					bool flag = (int)placementStatus == 4 || (int)placementStatus == 3;
					Failed[Key(target)] = Time.time + (flag ? 30f : 3f);
				}
			}
			else if (blocking || (placing && Time.time < autoClickUntil))
			{
				player.m_placementStatus = (PlacementStatus)5;
				player.SetPlacementGhostValid(false);
			}
		}

		internal static void Placed(Piece piece, Vector3 position)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (IsPlantable(piece))
			{
				Recent.Add((position, SpecOf(piece), Time.time + 3f));
				searchUntil = 0f;
				autoClickUntil = 0f;
			}
		}

		internal static void Update(Player? player, Piece? selected)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			Expire();
			if ((Object)(object)player == (Object)null || !IsPlantable(selected) || PlantEasily)
			{
				holding = false;
				noSeeds = false;
				return;
			}
			if (!ZInput.GetButton("Use") || Gc.TextInputActive() || InventoryGui.IsVisible() || Hud.IsPieceSelectionVisible() || Menu.IsVisible() || UnifiedPopup.IsVisible() || ((Character)player).IsDead() || (Object)(object)Plugin.Nearest(((Component)player).transform.position, Reach) == (Object)null)
			{
				holding = false;
				noSeeds = false;
				return;
			}
			holding = true;
			if (noSeeds || Time.time < nextAuto)
			{
				return;
			}
			if (!lastValid)
			{
				nextAuto = Time.time + 0.25f;
				if (Time.time >= nextNoSlot)
				{
					nextNoSlot = Time.time + 3f;
					Gc.TopLeft(GcLoc.Get("gccf_no_slot", Array.Empty<object>()));
				}
				return;
			}
			ItemData rightItem = ((Humanoid)player).GetRightItem();
			if (rightItem == null || !((Character)player).HaveStamina(rightItem.m_shared.m_attack.m_attackStamina))
			{
				if ((Object)(object)Hud.instance != (Object)null)
				{
					Hud.instance.StaminaBarEmptyFlash();
				}
				nextAuto = Time.time + 0.5f;
			}
			else if (!player.m_noPlacementCost && !player.HaveRequirements(selected, (RequirementMode)0))
			{
				noSeeds = true;
				Gc.TopLeft(GcLoc.Get("gccf_no_seeds", Array.Empty<object>()));
			}
			else
			{
				player.m_placePressedTime = Time.time;
				autoClickUntil = Time.time + 0.3f;
				nextAuto = Time.time + Mathf.Max(0.1f, GcFields.Get<float>("interval", 0.5f));
			}
		}

		private static void Expire()
		{
			Expired.Clear();
			foreach (KeyValuePair<long, float> item in Failed)
			{
				if (Time.time > item.Value)
				{
					Expired.Add(item.Key);
				}
			}
			foreach (long item2 in Expired)
			{
				Failed.Remove(item2);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
	internal static class FieldGhostPatch
	{
		private static void Prefix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				Planting.BeginGhost();
			}
		}

		[HarmonyPriority(800)]
		private static void Postfix(Player __instance)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				Planting.Capture(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
	internal static class FieldGhostLastPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Player __instance, bool flashGuardStone)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				Planting.EndGhost(__instance, flashGuardStone);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "PieceRayTest")]
	internal static class FieldRayPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(Player __instance, ref bool __result, ref Vector3 point, ref Vector3 normal, ref Piece piece, ref Heightmap heightmap, ref Collider waterSurface)
		{
			//IL_0004: 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_001b: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			if (Planting.Redirect(__instance, __result, point, out var point2))
			{
				point = point2;
				normal = Vector3.up;
				piece = null;
				heightmap = Heightmap.FindHeightmap(point2);
				waterSurface = null;
				__result = true;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "PlacePiece")]
	internal static class FieldPlacedPatch
	{
		private static void Postfix(Player __instance, Piece piece, Vector3 pos)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				Planting.Placed(piece, pos);
			}
		}
	}
	public enum FieldColor
	{
		Yellow,
		Orange,
		Red,
		Green,
		Turquoise,
		Blue,
		Purple,
		White
	}
	internal static class Plugin
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__CreateMarker;

			public static Action <1>__AttachView;

			public static PopupButtonCallback <2>__Pop;
		}

		internal const string MarkerName = "GC_FieldMarker";

		private const string CultivatorTable = "_CultivatorPieceTable";

		private const float CloseRadius = 1f;

		internal static ManualLogSource Log = null;

		internal static ConfigEntry<bool> Enabled = null;

		internal static ConfigEntry<FieldColor> Tint = null;

		internal static ConfigEntry<int> FillOpacity = null;

		internal static ConfigEntry<int> LineOpacity = null;

		internal static readonly List<Vector3> Draft = new List<Vector3>();

		private static LineRenderer? draftLine;

		private static bool shownFields;

		private static float nextHint;

		private static Piece? lastSelected;

		internal static Piece? MarkerPiece;

		private const float MaxRadius = 100f;

		internal static bool PrefabAvailable
		{
			get
			{
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					return (Object)(object)ZNetScene.instance.GetPrefab("GC_Field") != (Object)null;
				}
				return false;
			}
		}

		internal static bool On
		{
			get
			{
				if (Enabled.Value && GcFields.Get<bool>("enabled", true) && PrefabAvailable && ClientPlugin.Allowed)
				{
					return ClientPlugin.OnServer;
				}
				return false;
			}
		}

		internal static void Init(ConfigFile Config, Harmony harmony)
		{
			Log = ClientPlugin.Log;
			Enabled = Gc.Bind<bool>(Config, "12 - Fields", "Enabled", true, "Felder mit dem Kultivator anzeigen, markieren und in Reihen bepflanzen (die Regeln gibt GC_Server vor).", (AcceptableValueBase)null);
			Tint = Gc.Bind<FieldColor>(Config, "12 - Fields", "Color", FieldColor.Yellow, "Farbe von Fläche und Rand (Yellow = Valheim-Gelb).", (AcceptableValueBase)null);
			FillOpacity = Gc.Bind<int>(Config, "12 - Fields", "FillOpacity", 10, "Deckkraft der Fläche in Prozent (nachts automatisch gedämpft).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100));
			LineOpacity = Gc.Bind<int>(Config, "12 - Fields", "LineOpacity", 55, "Deckkraft des Rands in Prozent.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100));
			Tint.SettingChanged += delegate
			{
				Materials.Changed();
			};
			FillOpacity.SettingChanged += delegate
			{
				Materials.Changed();
			};
			LineOpacity.SettingChanged += delegate
			{
				Materials.Changed();
			};
			PrefabManager.OnVanillaPrefabsAvailable += CreateMarker;
			PrefabManager.OnPrefabsRegistered += AttachView;
		}

		private static void AttachView()
		{
			Planting.ResetCaches();
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab("GC_Field") : null);
			if ((Object)(object)val == (Object)null)
			{
				Log.LogWarning((object)"Felder: Welt-Objekt GC_Field fehlt (GC_Server zu alt oder nicht installiert), Felder bleiben aus.");
			}
			else if ((Object)(object)val.GetComponent<FieldView>() == (Object)null)
			{
				val.AddComponent<FieldView>();
			}
		}

		internal static bool HoldsCultivator(Player? player)
		{
			PieceTable val = (((Object)(object)player != (Object)null) ? ((Humanoid)player).GetRightItem() : null)?.m_shared?.m_buildPieces;
			if ((Object)(object)val != (Object)null)
			{
				return ((Object)val).name == "_CultivatorPieceTable";
			}
			return false;
		}

		internal static bool IsMarker(Piece? piece)
		{
			if ((Object)(object)piece != (Object)null)
			{
				return (Object)(object)((Component)piece).GetComponent<FieldMarker>() != (Object)null;
			}
			return false;
		}

		private static void CreateMarker()
		{
			//IL_00f4: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			PrefabManager.OnVanillaPrefabsAvailable -= CreateMarker;
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("GC_FieldMarker", "cultivate_v2");
			if ((Object)(object)val == (Object)null)
			{
				Log.LogError((object)"Felder: cultivate_v2 nicht gefunden, kein Menüeintrag „Feld markieren“.");
				return;
			}
			TerrainOp[] componentsInChildren = val.GetComponentsInChildren<TerrainOp>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
			}
			TerrainModifier[] componentsInChildren2 = val.GetComponentsInChildren<TerrainModifier>(true);
			for (int i = 0; i < componentsInChildren2.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren2[i]);
			}
			val.AddComponent<FieldMarker>();
			Piece? obj = (MarkerPiece = val.GetComponent<Piece>());
			obj.m_name = GcLoc.Get("gccf_marker_name", Array.Empty<object>());
			obj.m_description = GcLoc.Get("gccf_marker_desc", Array.Empty<object>());
			obj.m_icon = Icon();
			obj.m_resources = (Requirement[])(object)new Requirement[0];
			obj.m_craftingStation = null;
			obj.m_cultivatedGroundOnly = false;
			obj.m_vegetationGroundOnly = false;
			obj.m_onlyInBiome = (Biome)0;
			PieceManager.Instance.AddPiece(new CustomPiece(val, true, new PieceConfig
			{
				PieceTable = "_CultivatorPieceTable"
			}));
			Log.LogInfo((object)"Felder: Menüeintrag „Feld markieren“ im Kultivator angelegt.");
		}

		private static Sprite Icon()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_001e: 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)
			//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_004a: 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_0060: 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_007b: 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_0083: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			Vector2[] array = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(10f, 14f),
				new Vector2(54f, 10f),
				new Vector2(50f, 54f),
				new Vector2(14f, 46f)
			};
			List<Vector3> list = new List<Vector3>();
			Vector2[] array2 = array;
			foreach (Vector2 val2 in array2)
			{
				list.Add(new Vector3(val2.x, 0f, val2.y));
			}
			Color val3 = default(Color);
			for (int j = 0; j < 64; j++)
			{
				for (int k = 0; k < 64; k++)
				{
					((Color)(ref val3))..ctor(0f, 0f, 0f, 0f);
					if (Geometry.Contains(list, (float)k + 0.5f, (float)j + 0.5f))
					{
						((Color)(ref val3))..ctor(0.3f, 0.8f, 0.3f, 0.6f);
						if (j / 6 % 2 == 0 && k % 6 < 3)
						{
							((Color)(ref val3))..ctor(0.45f, 0.3f, 0.15f, 1f);
						}
					}
					if (Geometry.EdgeDistance(list, new Vector3((float)k + 0.5f, 0f, (float)j + 0.5f)) < 1.6f)
					{
						((Color)(ref val3))..ctor(0.4f, 1f, 0.4f, 1f);
					}
					array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						if (Vector2.Distance(array2[i], new Vector2((float)k, (float)j)) < 3.5f)
						{
							((Color)(ref val3))..ctor(1f, 0.9f, 0.3f, 1f);
						}
					}
					val.SetPixel(k, j, val3);
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
		}

		internal static void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)MarkerPiece != (Object)null && (Object)(object)localPlayer != (Object)null && MarkerPiece.m_enabled != On)
			{
				MarkerPiece.m_enabled = On;
				localPlayer.UpdateAvailablePiecesList();
			}
			int num;
			if ((Object)(object)localPlayer != (Object)null && On)
			{
				num = (HoldsCultivator(localPlayer) ? 1 : 0);
				if (num != 0)
				{
					Materials.Tick();
				}
			}
			else
			{
				num = 0;
			}
			ShowFields((byte)num != 0);
			if (num == 0)
			{
				if (Draft.Count > 0)
				{
					Draft.Clear();
				}
				UpdateDraftLine(null);
				Planting.Update(null, null);
				lastSelected = null;
				return;
			}
			Piece selectedPiece = localPlayer.GetSelectedPiece();
			if ((Object)(object)selectedPiece != (Object)(object)lastSelected)
			{
				lastSelected = selectedPiece;
				Hint(selectedPiece);
			}
			UpdateDraftLine(IsMarker(selectedPiece) ? localPlayer : null);
			Planting.Update(localPlayer, selectedPiece);
		}

		private static void ShowFields(bool show)
		{
			if (!show && !shownFields)
			{
				return;
			}
			shownFields = show;
			foreach (FieldView item in FieldView.All)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.Show(show);
				}
			}
		}

		private static void Hint(Piece? selected)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!(Time.time < nextHint) && !((Object)(object)selected == (Object)null))
			{
				if (IsMarker(selected))
				{
					nextHint = Time.time + 60f;
					Gc.TopLeft(GcLoc.Get("gccf_hint_marker", Array.Empty<object>()));
				}
				else if (Planting.IsPlantable(selected) && !Planting.PlantEasily && (Object)(object)Nearest(((Component)Player.m_localPlayer).transform.position, 30f) != (Object)null)
				{
					nextHint = Time.time + 120f;
					Gc.TopLeft(GcLoc.Get("gccf_hint_plant", Array.Empty<object>()));
				}
			}
		}

		private static void UpdateDraftLine(Player? player)
		{
			//IL_0040: 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_004b: Expected O, but got Unknown
			//IL_00a9: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_0102: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || Draft.Count == 0)
			{
				if ((Object)(object)draftLine != (Object)null)
				{
					((Renderer)draftLine).enabled = false;
				}
				return;
			}
			if ((Object)(object)draftLine == (Object)null)
			{
				GameObject val = new GameObject("GC_FieldDraft");
				Object.DontDestroyOnLoad((Object)val);
				draftLine = val.AddComponent<LineRenderer>();
				draftLine.useWorldSpace = true;
				draftLine.widthMultiplier = 0.07f;
				((Renderer)draftLine).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)draftLine).receiveShadows = false;
				((Renderer)draftLine).material = Materials.Draft;
			}
			List<Vector3> list = new List<Vector3>();
			foreach (Vector3 item in Draft)
			{
				list.Add(item + Vector3.up * 0.15f);
			}
			GameObject placementGhost = player.m_placementGhost;
			if ((Object)(object)placementGhost != (Object)null && placementGhost.activeSelf)
			{
				list.Add(placementGhost.transform.position + Vector3.up * 0.15f);
			}
			((Renderer)draftLine).enabled = true;
			draftLine.positionCount = list.Count;
			draftLine.SetPositions(list.ToArray());
		}

		internal static void Click(Player player)
		{
			//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_0027: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_010a: 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)
			GameObject placementGhost = player.m_placementGhost;
			if ((Object)(object)placementGhost == (Object)null || !placementGhost.activeSelf)
			{
				return;
			}
			Vector3 position = placementGhost.transform.position;
			position.y = Geometry.Ground(position);
			if (Draft.Count > 0 && Flat(position, Draft[0]) <= 1f)
			{
				if (Draft.Count >= 3)
				{
					Close(player);
				}
				else
				{
					Gc.TopLeft(GcLoc.Get("gccf_need_three", Array.Empty<object>()));
				}
				return;
			}
			if (Draft.Count == 0 && (Object)(object)At(position) != (Object)null)
			{
				Gc.TopLeft(GcLoc.Get("gccf_inside_other", Array.Empty<object>()));
				return;
			}
			int num = GcFields.Get<int>("maxPoints", 32);
			if (num > 0 && Draft.Count >= num)
			{
				Gc.TopLeft(GcLoc.Get("gccf_too_many", new object[1] { num }));
			}
			else if (Draft.Count <= 0 || EdgeAllowed(Draft[Draft.Count - 1], position, Draft.Count - 1))
			{
				Draft.Add(position);
			}
		}

		private static float Flat(Vector3 a, Vector3 b)
		{
			//IL_0016: 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)
			a.y = (b.y = 0f);
			return Vector3.Distance(a, b);
		}

		private static bool EdgeAllowed(Vector3 from, Vector3 to, int fromIndex, bool closing = false)
		{
			//IL_0048: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_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_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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)
			float num = GcFields.Get<float>("maxEdge", 50f);
			if (num > 0f && Flat(from, to) > num)
			{
				Gc.TopLeft(GcLoc.Get("gccf_too_long", new object[1] { num.ToString("0.#") }));
				return false;
			}
			if (Flat(from, to) < 0.3f)
			{
				return false;
			}
			for (int i = 0; i + 1 < Draft.Count; i++)
			{
				if (i != fromIndex - 1 && i + 1 != fromIndex && (!closing || i != 0) && Geometry.Crosses(Draft[i], Draft[i + 1], from, to))
				{
					Gc.TopLeft(GcLoc.Get("gccf_crossing", Array.Empty<object>()));
					return false;
				}
			}
			foreach (FieldView item in FieldView.All)
			{
				Field field = (((Object)(object)item != (Object)null) ? item.Data : null);
				if (field == null)
				{
					continue;
				}
				if (field.Contains(to))
				{
					Gc.TopLeft(GcLoc.Get("gccf_overlap", Array.Empty<object>()));
					return false;
				}
				int num2 = 0;
				int index = field.Points.Count - 1;
				while (num2 < field.Points.Count)
				{
					if (Geometry.Crosses(field.Points[index], field.Points[num2], from, to))
					{
						Gc.TopLeft(GcLoc.Get("gccf_overlap", Array.Empty<object>()));
						return false;
					}
					index = num2++;
				}
			}
			return true;
		}

		private static void Close(Player player)
		{
			//IL_0011: 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_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_007b: 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_0187: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: 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)
			if (!EdgeAllowed(Draft[Draft.Count - 1], Draft[0], Draft.Count - 1, closing: true))
			{
				return;
			}
			List<Vector3> list = new List<Vector3>(Draft);
			if (Mathf.Abs(Geometry.SignedArea(list)) < 1f)
			{
				Gc.TopLeft(GcLoc.Get("gccf_too_small", Array.Empty<object>()));
				return;
			}
			Vector3 b = Field.Centroid(list);
			foreach (Vector3 item in list)
			{
				if (Flat(item, b) > 100f)
				{
					Gc.TopLeft(GcLoc.Get("gccf_too_big", new object[1] { 100f.ToString("0") }));
					return;
				}
			}
			foreach (FieldView item2 in FieldView.All)
			{
				Field field = (((Object)(object)item2 != (Object)null) ? item2.Data : null);
				if (field != null && Geometry.Overlaps(list, field.Points))
				{
					Gc.TopLeft(GcLoc.Get("gccf_overlap", Array.Empty<object>()));
					return;
				}
			}
			GameObject val = (((Object)(object)ZNetScene.instance != (Object)null) ? ZNetScene.instance.GetPrefab("GC_Field") : null);
			if ((Object)(object)val == (Object)null)
			{
				Gc.TopLeft(GcLoc.Get("gccf_no_server", Array.Empty<object>()));
				return;
			}
			Vector3 val2 = Field.Centroid(list);
			val2.y = Geometry.Ground(val2);
			GameObject val3 = Object.Instantiate<GameObject>(val, val2, Quaternion.identity);
			ZNetView component = val3.GetComponent<ZNetView>();
			if ((Object)(object)component == (Object)null || !component.IsValid())
			{
				Object.Destroy((Object)(object)val3);
				return;
			}
			Field.Write(component.GetZDO(), list, player.GetPlayerID(), player.GetPlayerName(), GcGuildInfo.OwnGuildId());
			Draft.Clear();
			Gc.TopLeft(GcLoc.Get("gccf_closed", new object[1] { Mathf.RoundToInt(Mathf.Abs(Geometry.SignedArea(list))) }));
		}

		internal static bool RightClick(Player player)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_00a5: 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: Expected O, but got Unknown
			if (Draft.Count > 0)
			{
				Draft.RemoveAt(Draft.Count - 1);
				return true;
			}
			FieldView view = AimedField(player);
			if ((Object)(object)view == (Object)null)
			{
				return false;
			}
			Field data = view.Data;
			if (data == null)
			{
				return false;
			}
			string text = Denied(player, data);
			if (text != null)
			{
				Gc.TopLeft(text);
				return true;
			}
			string text2 = GcLoc.Get("gccf_remove_title", Array.Empty<object>());
			string text3 = GcLoc.Get("gccf_remove_text", Array.Empty<object>());
			PopupButtonCallback val = delegate
			{
				UnifiedPopup.Pop();
				Remove(view);
			};
			object obj = <>O.<2>__Pop;
			if (obj == null)
			{
				PopupButtonCallback val2 = UnifiedPopup.Pop;
				<>O.<2>__Pop = val2;
				obj = (object)val2;
			}
			UnifiedPopup.Push((PopupBase)new YesNoPopup(text2, text3, val, (PopupButtonCallback)obj, false, false));
			return true;
		}

		private static string? Denied(Player player, Field data)
		{
			bool canChangeServer = GcMenu.CanChangeServer;
			bool flag = data.Creator != 0L && data.Creator == player.GetPlayerID();
			bool flag2 = data.Guild >= 0 && GcGuildInfo.OwnGuildId() == data.Guild && GcGuildInfo.IsLeader();
			switch (GcFields.Get<int>("removeBy", 0))
			{
			case 1:
				if (!(flag || canChangeServer))
				{
					return GcLoc.Get("gccf_denied_creator", Array.Empty<object>());
				}
				return null;
			case 2:
				if (!(flag || canChangeServer || flag2))
				{
					return GcLoc.Get("gccf_denied_guild", Array.Empty<object>());
				}
				return null;
			case 3:
				if (!canChangeServer)
				{
					return GcLoc.Get("gccf_denied_admin", Array.Empty<object>());
				}
				return null;
			default:
				return null;
			}
		}

		private static void Remove(FieldView view)
		{
			if (!((Object)(object)view == (Object)null))
			{
				ZNetView view2 = view.View;
				if ((Object)(object)view2 != (Object)null && view2.IsValid())
				{
					view2.ClaimOwnership();
					ZNetScene.instance.Destroy(((Component)view).gameObject);
					Gc.TopLeft(GcLoc.Get("gccf_removed", Array.Empty<object>()));
				}
			}
		}

		internal static bool CancelDraft()
		{
			Player localPlayer = Player.m_localPlayer;
			if (Draft.Count == 0 || (Object)(object)localPlayer == (Object)null || !IsMarker(localPlayer.GetSelectedPiece()) || InventoryGui.IsVisible() || Minimap.IsOpen() || Console.IsVisible() || TextInput.IsVisible() || StoreGui.IsVisible() || Hud.IsPieceSelectionVisible() || UnifiedPopup.IsVisible() || Hud.InRadial() || ((Object)(object)Chat.instance != (Object)null && Chat.instance.m_wasFocused))
			{
				return false;
			}
			Draft.Clear();
			Gc.TopLeft(GcLoc.Get("gccf_cancel", Array.Empty<object>()));
			return true;
		}

		private static FieldView? AimedField(Player player)
		{
			//IL_001b: 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_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_0092: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameCamera.instance == (Object)null)
			{
				return null;
			}
			Transform transform = ((Component)GameCamera.instance).transform;
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(transform.position, transform.forward, ref val, 50f, player.m_placeRayMask))
			{
				return null;
			}
			Piece val2 = (((Object)(object)player.m_placementGhost != (Object)null) ? player.m_placementGhost.GetComponent<Piece>() : null);
			float num = player.m_maxPlaceDistance + (float)(((Object)(object)val2 != (Object)null) ? val2.m_extraPlacementDistance : 0);
			if (!(Vector3.Distance(((Character)player).m_eye.position, ((RaycastHit)(ref val)).point) <= num))
			{
				return null;
			}
			return At(((RaycastHit)(ref val)).point);
		}

		internal static FieldView? At(Vector3 point)
		{
			//IL_002b: 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_0047: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			foreach (FieldView item in FieldView.All)
			{
				Field field = (((Object)(object)item != (Object)null) ? item.Data : null);
				if (field != null && point.x >= field.MinX && point.x <= field.MaxX && point.z >= field.MinZ && point.z <= field.MaxZ && field.Contains(point))
				{
					return item;
				}
			}
			return null;
		}

		internal static FieldView? Nearest(Vector3 point, float range)
		{
			//IL_0034: 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_0056: 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_007a: 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)
			FieldView result = null;
			float num = range;
			foreach (FieldView item in FieldView.All)
			{
				Field field = (((Object)(object)item != (Object)null) ? item.Data : null);
				if (field != null && !(point.x < field.MinX - range) && !(point.x > field.MaxX + range) && !(point.z < field.MinZ - range) && !(point.z > field.MaxZ + range))
				{
					float num2 = (field.Contains(point) ? 0f : field.EdgeDistance(point));
					if (num2 <= num)
					{
						result = item;
						num = num2;
					}
				}
			}
			return result;
		}
	}
	public class FieldMarker : MonoBehaviour
	{
	}
	[HarmonyPatch(typeof(Player), "TryPlacePiece")]
	internal static class FieldClickPatch
	{
		[HarmonyPriority(800)]
		private static bool Prefix(Player __instance, Piece piece, ref bool __result)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Plugin.IsMarker(piece))
			{
				return true;
			}
			__result = false;
			if (Plugin.On)
			{
				Plugin.Click(__instance);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateBuildGuiInput")]
	internal static class FieldRightClickPatch
	{
		private static bool Prefix(Player __instance)
		{
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || !Plugin.On || !ZInput.GetButtonDown("BuildMenu") || Hud.IsPieceSelectionVisible() || PlayerController.HasInputDelay || Hud.InRadial() || !Plugin.IsMarker(__instance.GetSelectedPiece()))
			{
				return true;
			}
			return !Plugin.RightClick(__instance);
		}
	}
	[HarmonyPatch(typeof(Menu), "Update")]
	internal static class FieldEscapePatch
	{
		private static bool Prefix()
		{
			if (ZInput.GetKeyDown((KeyCode)27, true) && !Menu.IsVisible())
			{
				return !Plugin.CancelDraft();
			}
			return true;
		}
	}
	internal sealed class Field
	{
		public readonly List<Vector3> Points = new List<Vector3>();

		public long Creator;

		public string CreatorName = "";

		public int Guild = -1;

		public Vector3 Along;

		public Vector3 Inward;

		public float MinX;

		public float MaxX;

		public float MinZ;

		public float MaxZ;

		internal static readonly int PointsHash = StringExtensionMethods.GetStableHashCode("gc_field_pts");

		internal static readonly int CreatorHash = StringExtensionMethods.GetStableHashCode("gc_field_creator");

		internal static readonly int CreatorNameHash = StringExtensionMethods.GetStableHashCode("gc_field_creator_name");

		internal static readonly int GuildHash = StringExtensionMethods.GetStableHashCode("gc_field_guild");

		public Vector3 Origin => Points[0];

		public float Area => Mathf.Abs(Geometry.SignedArea(Points));

		public static Field? Read(ZDO zdo)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			byte[] byteArray = zdo.GetByteArray(PointsHash, (byte[])null);
			if (byteArray == null || byteArray.Length < 4)
			{
				return null;
			}
			Field field = new Field
			{
				Creator = zdo.GetLong(CreatorHash, 0L),
				CreatorName = zdo.GetString(CreatorNameHash, ""),
				Guild = zdo.GetInt(GuildHash, -1)
			};
			try
			{
				ZPackage val = new ZPackage(byteArray);
				int num = val.ReadInt();
				for (int i = 0; i < num && i < 4096; i++)
				{
					field.Points.Add(val.ReadVector3());
				}
			}
			catch
			{
				return null;
			}
			if (field.Points.Count < 3)
			{
				return null;
			}
			return field.Prepare();
		}

		public static void Write(ZDO zdo, List<Vector3> points, long creator, string creatorName, int guild)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001d: 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_0024: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(points.Count);
			foreach (Vector3 point in points)
			{
				val.Write(point);
			}
			zdo.Set(PointsHash, val.GetArray());
			zdo.Set(CreatorHash, creator);
			zdo.Set(CreatorNameHash, creatorName);
			zdo.Set(GuildHash, guild, false);
		}

		public Field? Prepare()
		{
			//IL_0007: 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_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_003d: 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_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_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_008c: 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_00ce: 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_00ed: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Points[1] - Points[0];
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return null;
			}
			Along = ((Vector3)(ref val)).normalized;
			Inward = new Vector3(0f - Along.z, 0f, Along.x);
			if (Geometry.SignedArea(Points) < 0f)
			{
				Inward = -Inward;
			}
			MinX = (MinZ = float.MaxValue);
			MaxX = (MaxZ = float.MinValue);
			foreach (Vector3 point in Points)
			{
				MinX = Mathf.Min(MinX, point.x);
				MaxX = Mathf.Max(MaxX, point.x);
				MinZ = Mathf.Min(MinZ, point.z);
				MaxZ = Mathf.Max(MaxZ, point.z);
			}
			return this;
		}

		public bool Contains(Vector3 point)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return Geometry.Contains(Points, point.x, point.z);
		}

		public float EdgeDistance(Vector3 point)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Geometry.EdgeDistance(Points, point);
		}

		public static Vector3 Centroid(List<Vector3> points)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.zero;
			foreach (Vector3 point in points)
			{
				val += point;
			}
			return val / (float)Mathf.Max(1, points.Count);
		}
	}
	internal static class Geometry
	{
		public static bool Contains(List<Vector3> polygon, float x, float z)
		{
			//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_001e: 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_0029: 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_003d: 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_004d: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			int num = 0;
			int index = polygon.Count - 1;
			while (num < polygon.Count)
			{
				Vector3 val = polygon[num];
				Vector3 val2 = polygon[index];
				if (val.z > z != val2.z > z && x < (val2.x - val.x) * (z - val.z) / (val2.z - val.z) + val.x)
				{
					flag = !flag;
				}
				index = num++;
			}
			return flag;
		}

		public static float SignedArea(List<Vector3> polygon)
		{
			//IL_0016: 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_002f: 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)
			float num = 0f;
			int num2 = 0;
			int index = polygon.Count - 1;
			while (num2 < polygon.Count)
			{
				num += polygon[index].x * polygon[num2].z - polygon[num2].x * polygon[index].z;
				index = num2++;
			}
			return num * 0.5f;
		}

		public static float EdgeDistance(List<Vector3> polygon, Vector3 point)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0039: 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)
			//IL_0060: 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_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_0083: 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_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_00a2: 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_00a5: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(point.x, point.z);
			int num2 = 0;
			int index = polygon.Count - 1;
			Vector2 val2 = default(Vector2);
			while (num2 < polygon.Count)
			{
				((Vector2)(ref val2))..ctor(polygon[index].x, polygon[index].z);
				Vector2 val3 = new Vector2(polygon[num2].x, polygon[num2].z) - val2;
				float num3 = ((((Vector2)(ref val3)).sqrMagnitude > 0f) ? Mathf.Clamp01(Vector2.Dot(val - val2, val3) / ((Vector2)(ref val3)).sqrMagnitude) : 0f);
				num = Mathf.Min(num, Vector2.Distance(val, val2 + val3 * num3));
				index = num2++;
			}
			return num;
		}

		public static bool Crosses(Vector3 a, Vector3 b, Vector3 c, Vector3 d)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			float num = Cross(c, d, a);
			float num2 = Cross(c, d, b);
			float num3 = Cross(a, b, c);
			float num4 = Cross(a, b, d);
			if ((num > 0f && num2 < 0f) || (num < 0f && num2 > 0f))
			{
				if (!(num3 > 0f) || !(num4 < 0f))
				{
					if (num3 < 0f)
					{
						return num4 > 0f;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static float Cross(Vector3 a, Vector3 b, Vector3 p)
		{
			//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)
			//IL_001b: 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_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)
			return (b.x - a.x) * (p.z - a.z) - (b.z - a.z) * (p.x - a.x);
		}

		public static bool Overlaps(List<Vector3> a, List<Vector3> b)
		{
			//IL_0060: 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_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_0023: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int index = a.Count - 1;
			while (num < a.Count)
			{
				int num2 = 0;
				int index2 = b.Count - 1;
				while (num2 < b.Count)
				{
					if (Crosses(a[index], a[num], b[index2], b[num2]))
					{
						return true;
					}
					index2 = num2++;
				}
				index = num++;
			}
			if (!Contains(b, a[0].x, a[0].z))
			{
				return Contains(a, b[0].x, b[0].z);
			}
			return true;
		}

		public static List<int> Triangulate(List<Vector3> polygon)
		{
			//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_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_00ac: 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_00b0: 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_00ee: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			bool flag = SignedArea(polygon) > 0f;
			for (int i = 0; i < polygon.Count; i++)
			{
				list2.Add(flag ? i : (polygon.Count - 1 - i));
			}
			int num = 0;
			while (list2.Count > 3 && num++ < 10000)
			{
				bool flag2 = false;
				for (int j = 0; j < list2.Count; j++)
				{
					int num2 = list2[(j + list2.Count - 1) % list2.Count];
					int num3 = list2[j];
					int num4 = list2[(j + 1) % list2.Count];
					Vector3 a = polygon[num2];
					Vector3 b = polygon[num3];
					Vector3 val = polygon[num4];
					if (Cross(a, b, val) <= 0f)
					{
						continue;
					}
					bool flag3 = true;
					foreach (int item in list2)
					{
						if (item != num2 && item != num3 && item != num4 && InTriangle(polygon[item], a, b, val))
						{
							flag3 = false;
							break;
						}
					}
					if (flag3)
					{
						list.Add(num2);
						list.Add(num3);
						list.Add(num4);
						list2.RemoveAt(j);
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					break;
				}
			}
			for (int k = 1; k + 1 < list2.Count; k++)
			{
				list.Add(list2[0]);
				list.Add(list2[k]);
				list.Add(list2[k + 1]);
			}
			return list;
		}

		private static bool InTriangle(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0011: 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_001f: 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)
			if (Cross(a, b, p) >= 0f && Cross(b, c, p) >= 0f)
			{
				return Cross(c, a, p) >= 0f;
			}
			return false;
		}

		public static float Ground(Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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)
			float result = default(float);
			if (Heightmap.GetHeight(point, ref result))
			{
				return result;
			}
			if (!((Object)(object)ZoneSystem.instance != (Object)null) || !ZoneSystem.instance.GetGroundHeight(point, ref result))
			{
				return point.y;
			}
			return result;
		}
	}
	public class FieldView : MonoBehaviour
	{
		internal static readonly List<FieldView> All = new List<FieldView>();

		private const float Lift = 0.12f;

		private const int MaxVertices = 6000;

		private static int heightFrame = -1;

		private ZNetView? nview;

		private Field? cached;

		private uint revision = uint.MaxValue;

		private GameObject? visual;

		private LineRenderer? outline;

		private Mesh? mesh;

		private bool shown;

		private bool topologyDirty = true;

		private bool heightsDone;

		private float nextHeights;

		private Vector3[] flatOutline = (Vector3[])(object)new Vector3[0];

		private Vector3[] vertices = (Vector3[])(object)new Vector3[0];

		private int[] triangles = new int[0];

		internal ZNetView? View => nview;

		internal Field? Data
		{
			get
			{
				if ((Object)(object)nview == (Object)null || !nview.IsValid())
				{
					return null;
				}
				ZDO zDO = nview.GetZDO();
				if (zDO.DataRevision != revision)
				{
					revision = zDO.DataRevision;
					cached = Field.Read(zDO);
					topologyDirty = true;
					heightsDone = false;
				}
				return cached;
			}
		}

		private void Awake()
		{
			nview = ((Component)this).GetComponent<ZNetView>();
			All.Add(this);
		}

		private void OnDestroy()
		{
			All.Remove(this);
			if ((Object)(object)visual != (Object)null)
			{
				Object.Destroy((Object)(object)visual);
			}
			if ((Object)(object)mesh != (Object)null)
			{
				Object.Destroy((Object)(object)mesh);
			}
		}

		internal void Show(bool show)
		{
			if (show != shown)
			{
				shown = show;
				if ((Object)(object)visual != (Object)null)
				{
					visual.SetActive(show && cached != null);
				}
			}
			if (!show)
			{
				return;
			}
			Field data = Data;
			if (data == null)
			{
				if ((Object)(object)visual != (Object)null)
				{
					visual.SetActive(false);
				}
				return;
			}
			if (topologyDirty)
			{
				BuildTopology(data);
			}
			RefreshHeights(data);
		}

		private void BuildTopology(Field data)
		{
			//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_003e: 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_0045: 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_0066: 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_0071: 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_00f0: 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_0183: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: 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_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Expected O, but got Unknown
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			topologyDirty = false;
			heightsDone = false;
			List<Vector3> list = new List<Vector3>();
			for (int i = 0; i < data.Points.Count; i++)
			{
				Vector3 val = data.Points[i];
				Vector3 val2 = data.Points[(i + 1) % data.Points.Count];
				int num = Mathf.Clamp(Mathf.CeilToInt(Vector3.Distance(val, val2)), 1, 200);
				for (int j = 0; j < num; j++)
				{
					list.Add(Vector3.Lerp(val, val2, (float)j / (float)num));
				}
			}
			flatOutline = list.ToArray();
			List<int> list2 = Geometry.Triangulate(data.Points);
			float num2 = 1f;
			for (int k = 0; k < 12; k++)
			{
				int num3 = 0;
				for (int l = 0; l + 2 < list2.Count; l += 3)
				{
					int num4 = Steps(data.Points[list2[l]], data.Points[list2[l + 1]], data.Points[list2[l + 2]], num2);
					num3 += (num4 + 1) * (num4 + 2) / 2;
				}
				if (num3 <= 6000)
				{
					break;
				}
				num2 *= Mathf.Sqrt((float)num3 / 6000f) * 1.05f;
			}
			List<Vector3> list3 = new List<Vector3>();
			List<int> list4 = new List<int>();
			for (int m = 0; m + 2 < list2.Count; m += 3)
			{
				Subdivide(data.Points[list2[m]], data.Points[list2[m + 1]], data.Points[list2[m + 2]], num2, list3, list4);
			}
			vertices = list3.ToArray();
			triangles = list4.ToArray();
			if ((Object)(object)visual == (Object)null)
			{
				visual = new GameObject("GC_FieldVisual");
				outline = visual.AddComponent<LineRenderer>();
				outline.useWorldSpace = true;
				outline.loop = true;
				outline.widthMultiplier = 0.05f;
				((Renderer)outline).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)outline).receiveShadows = false;
				((Renderer)outline).material = Materials.Line;
				GameObject val3 = new GameObject("fill");
				val3.transform.SetParent(visual.transform, false);
				mesh = new Mesh
				{
					name = "GC_FieldFill",
					indexFormat = (IndexFormat)1
				};
				val3.AddComponent<MeshFilter>().sharedMesh = mesh;
				MeshRenderer obj = val3.AddComponent<MeshRenderer>();
				((Renderer)obj).sharedMaterial = Materials.Fill;
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)obj).receiveShadows = false;
			}
			visual.SetActive(false);
		}

		private void RefreshHeights(Field data)
		{
			//IL_006f: 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_0077: 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_0091: 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)
			if ((!heightsDone || !(Time.time < nextHeights)) && heightFrame != Time.frameCount && (!heightsDone || Near(data)))
			{
				heightFrame = Time.frameCount;
				heightsDone = true;
				nextHeights = Time.time + 3f;
				Vector3[] array = (Vector3[])(object)new Vector3[flatOutline.Length];
				for (int i = 0; i < array.Length; i++)
				{
					Vector3 val = flatOutline[i];
					val.y = Geometry.Ground(val) + 0.12f + 0.02f;
					array[i] = val;
				}
				outline.positionCount = array.Length;
				outline.SetPositions(array);
				for (int j = 0; j < vertices.Length; j++)
				{
					vertices[j].y = Geometry.Ground(vertices[j]) + 0.12f;
				}
				mesh.Clear();
				mesh.vertices = vertices;
				mesh.triangles = triangles;
				mesh.RecalculateBounds();
				visual.SetActive(shown);
			}
		}

		private static bool Near(Field data)
		{
			//IL_0017: 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_001d: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			if (position.x >= data.MinX - 64f && position.x <= data.MaxX + 64f && position.z >= data.MinZ - 64f)
			{
				return position.z <= data.MaxZ + 64f;
			}
			return false;
		}

		private static int Steps(Vector3 a, Vector3 b, Vector3 c, float cell)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			return Mathf.Clamp(Mathf.CeilToInt(Mathf.Max(Vector3.Distance(a, b), Mathf.Max(Vector3.Distance(b, c), Vector3.Distance(c, a))) / cell), 1, 64);
		}

		private static void Subdivide(Vector3 a, Vector3 b, Vector3 c, float cell, List<Vector3> vertices, List<int> triangles)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing