using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Data;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Service;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Visualization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ESP")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+48d7c872a9d784a20cb3af6a7a8b2f093a4b2e45")]
[assembly: AssemblyProduct("ESP")]
[assembly: AssemblyTitle("ESP")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.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]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Visualization
{
	public class Draw
	{
		public const string TriggerLayer = "character_trigger";

		private static readonly Texture2D Texture = new Texture2D(1, 1);

		private static Shader? lineShader;

		private static string shaderName = "Sprites/Default";

		private static readonly Dictionary<Color, Material> materials = new Dictionary<Color, Material>();

		private static readonly Dictionary<string, Color> colors = new Dictionary<string, Color>();

		private static readonly Dictionary<string, int> lineWidths = new Dictionary<string, int>();

		private static Shader LineShader => lineShader ?? (lineShader = ((IEnumerable<Shader>)Resources.FindObjectsOfTypeAll<Shader>()).FirstOrDefault((Func<Shader, bool>)((Shader shader) => ((Object)shader).name == shaderName)) ?? ((IEnumerable<Shader>)Resources.FindObjectsOfTypeAll<Shader>()).FirstOrDefault((Func<Shader, bool>)((Shader shader) => ((Object)shader).name == "Sprites/Default")) ?? throw new Exception("Shader not found."));

		private static int GetSegments(float angle)
		{
			return (int)Math.Floor(32f * angle / 360f);
		}

		private static Vector3 GetArcSegmentX(float angle, float radius)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(0f, Mathf.Sin((float)Math.PI / 180f * angle) * radius, Mathf.Cos((float)Math.PI / 180f * angle) * radius);
		}

		private static Vector3 GetArcSegmentY(float angle, float radius)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(Mathf.Sin((float)Math.PI / 180f * angle) * radius, 0f, Mathf.Cos((float)Math.PI / 180f * angle) * radius);
		}

		private static Vector3 GetArcSegmentZ(float angle, float radius)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(Mathf.Sin((float)Math.PI / 180f * angle) * radius, Mathf.Cos((float)Math.PI / 180f * angle) * radius, 0f);
		}

		private static Vector3[] GetArcSegmentsX(Vector3 position, float angle, float radius)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			float num = (0f - angle) / 2f;
			int segments = GetSegments(angle);
			Vector3[] array = (Vector3[])(object)new Vector3[segments + 1];
			for (int i = 0; i <= segments; i++)
			{
				array[i] = position + GetArcSegmentX(num, radius);
				num += angle / (float)segments;
			}
			return array;
		}

		private static Vector3[] GetArcSegmentsY(Vector3 position, float angle, float radius)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			float num = (0f - angle) / 2f;
			int segments = GetSegments(angle);
			Vector3[] array = (Vector3[])(object)new Vector3[segments + 1];
			for (int i = 0; i <= segments; i++)
			{
				array[i] = position + GetArcSegmentY(num, radius);
				num += angle / (float)segments;
			}
			return array;
		}

		private static Vector3[] GetArcSegmentsZ(Vector3 position, float angle, float radius)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			float num = (0f - angle) / 2f;
			int segments = GetSegments(angle);
			Vector3[] array = (Vector3[])(object)new Vector3[segments + 1];
			for (int i = 0; i <= segments; i++)
			{
				array[i] = position + GetArcSegmentZ(num, radius);
				num += angle / (float)segments;
			}
			return array;
		}

		private static void UpdateArcX(LineRenderer renderer, Vector3 position, float radius, float angle, float width)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] arcSegmentsX = GetArcSegmentsX(position, angle, radius - width / 2f);
			renderer.positionCount = arcSegmentsX.Length;
			renderer.SetPositions(arcSegmentsX);
		}

		public static void DrawArcX(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			UpdateArcX(CreateRenderer(obj), position, radius, angle, GetLineWidth(((Object)obj).name));
		}

		private static void UpdateArcY(LineRenderer renderer, Vector3 position, float radius, float angle, float width)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] arcSegmentsY = GetArcSegmentsY(position, angle, radius - width / 2f);
			renderer.positionCount = arcSegmentsY.Length;
			renderer.SetPositions(arcSegmentsY);
		}

		public static void DrawArcY(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			UpdateArcY(CreateRenderer(obj), position, radius, angle, GetLineWidth(((Object)obj).name));
		}

		private static void UpdateArcZ(LineRenderer renderer, Vector3 position, float radius, float angle, float width)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] arcSegmentsZ = GetArcSegmentsZ(position, angle, radius - width / 2f);
			renderer.positionCount = arcSegmentsZ.Length;
			renderer.SetPositions(arcSegmentsZ);
		}

		public static void DrawArcZ(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			UpdateArcZ(CreateRenderer(obj), position, radius, angle, GetLineWidth(((Object)obj).name));
		}

		public static GameObject DrawArc(string tag, MonoBehaviour parent, Vector3 position, float radius, float angle)
		{
			//IL_0025: 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)
			GameObject obj = CreateObject(((Component)parent).gameObject, tag);
			DrawArcY(CreateObject(obj, tag), position, radius, angle);
			DrawArcX(CreateObject(obj, tag), position, radius, angle);
			AddMeshCollider(obj);
			return obj;
		}

		public static void DrawConeX(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0013: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer val = CreateRenderer(obj);
			float lineWidth = GetLineWidth(((Object)obj).name);
			Vector3[] arcSegmentsX = GetArcSegmentsX(position, angle, radius - lineWidth / 2f);
			val.positionCount = arcSegmentsX.Length + 2;
			val.SetPosition(0, position);
			for (int i = 0; i < arcSegmentsX.Length; i++)
			{
				val.SetPosition(i + 1, arcSegmentsX[i]);
			}
			val.SetPosition(arcSegmentsX.Length + 1, position);
		}

		public static void DrawConeY(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0013: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer val = CreateRenderer(obj);
			float lineWidth = GetLineWidth(((Object)obj).name);
			Vector3[] arcSegmentsY = GetArcSegmentsY(position, angle, radius - lineWidth / 2f);
			val.positionCount = arcSegmentsY.Length + 2;
			val.SetPosition(0, position);
			for (int i = 0; i < arcSegmentsY.Length; i++)
			{
				val.SetPosition(i + 1, arcSegmentsY[i]);
			}
			val.SetPosition(arcSegmentsY.Length + 1, position);
		}

		public static void DrawConeZ(GameObject obj, Vector3 position, float radius, float angle)
		{
			//IL_0013: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer val = CreateRenderer(obj);
			float lineWidth = GetLineWidth(((Object)obj).name);
			Vector3[] arcSegmentsZ = GetArcSegmentsZ(position, angle, radius - lineWidth / 2f);
			val.positionCount = arcSegmentsZ.Length + 2;
			val.SetPosition(0, position);
			for (int i = 0; i < arcSegmentsZ.Length; i++)
			{
				val.SetPosition(i + 1, arcSegmentsZ[i]);
			}
			val.SetPosition(arcSegmentsZ.Length + 1, position);
		}

		public static GameObject DrawCone(string tag, MonoBehaviour parent, Vector3 position, float radius, float angle)
		{
			//IL_0025: 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)
			GameObject obj = CreateObject(((Component)parent).gameObject, tag);
			DrawConeY(CreateObject(obj, tag), position, radius, angle);
			DrawConeX(CreateObject(obj, tag), position, radius, angle);
			AddMeshCollider(obj);
			return obj;
		}

		public static void SetShader(string name)
		{
			shaderName = name;
			lineShader = null;
			materials.Clear();
			Visualization[] visualizations = Utils.GetVisualizations();
			for (int i = 0; i < visualizations.Length; i++)
			{
				ChangeColor(((Component)visualizations[i]).gameObject);
			}
		}

		public static void Init()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Texture.SetPixel(0, 0, Color.gray);
		}

		private static GameObject CreateObject(GameObject parent, string tag, Quaternion? fixedRotation = null)
		{
			//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_0016: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject
			{
				layer = LayerMask.NameToLayer("character_trigger")
			};
			val.transform.parent = parent.transform;
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			if (tag != "")
			{
				((Object)val).name = tag;
				Visualization visualization = val.AddComponent<Visualization>();
				visualization.Tag = tag;
				if (fixedRotation.HasValue)
				{
					visualization.SetFixed(fixedRotation.Value);
				}
				val.SetActive(Visibility.IsTag(tag));
			}
			return val;
		}

		private static Material GetMaterial(Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002a: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			if (materials.ContainsKey(color))
			{
				return materials[color];
			}
			Material val = new Material(LineShader);
			val.SetColor("_Color", color);
			val.SetFloat("_BlendOp", 1f);
			val.SetTexture("_MainTex", (Texture)(object)Texture);
			materials[color] = val;
			return val;
		}

		private static LineRenderer CreateRenderer(GameObject obj)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer obj2 = obj.AddComponent<LineRenderer>();
			obj2.useWorldSpace = false;
			((Renderer)obj2).sharedMaterial = GetMaterial(GetColor(((Object)obj).name));
			((Renderer)obj2).shadowCastingMode = (ShadowCastingMode)0;
			obj2.widthMultiplier = GetLineWidth(((Object)obj).name);
			return obj2;
		}

		private static void ChangeColor(GameObject obj)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer component = obj.GetComponent<LineRenderer>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Renderer)component).sharedMaterial = GetMaterial(GetColor(((Object)obj).name));
			}
		}

		private static void ChangeLineWidth(GameObject obj)
		{
			float lineWidth = GetLineWidth(((Object)obj).name);
			LineRenderer component = obj.GetComponent<LineRenderer>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.widthMultiplier = lineWidth;
			}
		}

		public static void AddMeshCollider(GameObject obj)
		{
			GameObject obj2 = obj;
			Array.ForEach(obj2.GetComponentsInChildren<LineRenderer>(), delegate(LineRenderer renderer)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Expected O, but got Unknown
				MeshCollider obj3 = obj2.AddComponent<MeshCollider>();
				obj3.convex = true;
				((Collider)obj3).isTrigger = true;
				Mesh val = new Mesh();
				renderer.BakeMesh(val, false);
				obj3.sharedMesh = val;
			});
		}

		public static void AddText(GameObject obj, string title, string text)
		{
			StaticText staticText = obj.AddComponent<StaticText>();
			staticText.text = text;
			staticText.title = title;
		}

		public static LineRenderer[] GetRenderers(MonoBehaviour obj, string tag)
		{
			return GetRenderers(obj, new string[1] { tag });
		}

		public static LineRenderer[] GetRenderers(MonoBehaviour obj, string[] tags)
		{
			HashSet<string> set = tags.ToHashSet();
			return ((Component)obj).GetComponentsInChildren<LineRenderer>(true).Where(delegate(LineRenderer renderer)
			{
				Visualization component = ((Component)renderer).GetComponent<Visualization>();
				return Object.op_Implicit((Object)(object)component) && set.Contains(component.Tag);
			}).ToArray();
		}

		public static bool HasVisual(MonoBehaviour obj, string tag)
		{
			string tag2 = tag;
			return ((Component)obj).GetComponentsInChildren<Visualization>(true).Any((Visualization visualization) => visualization.Tag == tag2);
		}

		public static Color GetColor(string tag)
		{
			//IL_0019: 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)
			if (!colors.ContainsKey(tag))
			{
				return Color.white;
			}
			return colors[tag];
		}

		public static void SetColor(string tag, Color color)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			colors[tag] = color;
			Visualization[] visualizations = Utils.GetVisualizations();
			foreach (Visualization visualization in visualizations)
			{
				if (visualization.Tag == tag)
				{
					ChangeColor(((Component)visualization).gameObject);
				}
			}
		}

		public static float GetLineWidth(string tag)
		{
			return (float)Math.Max(1, lineWidths.ContainsKey(tag) ? lineWidths[tag] : 0) / 100f;
		}

		public static void SetLineWidth(string tag, int width)
		{
			lineWidths[tag] = width;
			Visualization[] visualizations = Utils.GetVisualizations();
			foreach (Visualization visualization in visualizations)
			{
				if (visualization.Tag == tag)
				{
					ChangeLineWidth(((Component)visualization).gameObject);
				}
			}
		}

		public static GameObject DrawCylinder(string tag, MonoBehaviour parent, float radius)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_0101: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateObject(((Component)parent).gameObject, tag);
			DrawArcY(CreateObject(obj, tag), Vector3.zero, radius, 360f);
			float lineWidth = GetLineWidth(tag);
			AddSphereCollider(obj, radius - lineWidth / 2f);
			Vector3 start = default(Vector3);
			((Vector3)(ref start))..ctor(radius, -500f, 0f);
			Vector3 end = default(Vector3);
			((Vector3)(ref end))..ctor(radius, 500f, 0f);
			AddBoxCollider(DrawLineSub(CreateObject(obj, tag), start, end));
			((Vector3)(ref start))..ctor(0f - radius, -500f, 0f);
			((Vector3)(ref end))..ctor(0f - radius, 500f, 0f);
			AddBoxCollider(DrawLineSub(CreateObject(obj, tag), start, end));
			((Vector3)(ref start))..ctor(0f, -500f, radius);
			((Vector3)(ref end))..ctor(0f, 500f, radius);
			AddBoxCollider(DrawLineSub(CreateObject(obj, tag), start, end));
			((Vector3)(ref start))..ctor(0f, -500f, 0f - radius);
			((Vector3)(ref end))..ctor(0f, 500f, 0f - radius);
			AddBoxCollider(DrawLineSub(CreateObject(obj, tag), start, end));
			return obj;
		}

		private static void AddBoxCollider(GameObject obj)
		{
			GameObject obj2 = obj;
			Array.ForEach(obj2.GetComponentsInChildren<LineRenderer>(), delegate(LineRenderer renderer)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//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_0031: 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_0033: 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_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_004d: 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_004f: 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_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				Vector3 position = renderer.GetPosition(0);
				Vector3 position2 = renderer.GetPosition(renderer.positionCount - 1);
				float widthMultiplier = renderer.widthMultiplier;
				BoxCollider obj3 = obj2.AddComponent<BoxCollider>();
				((Collider)obj3).isTrigger = true;
				obj3.center = position + (position2 - position) / 2f;
				Vector3 val = position2 - position;
				val.x = Math.Abs(val.x);
				val.y = Math.Abs(val.y);
				val.z = Math.Abs(val.z);
				obj3.size = val + 2f * new Vector3(widthMultiplier, widthMultiplier, widthMultiplier);
			});
		}

		private static void AddBoxCollider(GameObject obj, Vector3 center, Vector3 size)
		{
			//IL_000e: 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)
			BoxCollider obj2 = obj.AddComponent<BoxCollider>();
			((Collider)obj2).isTrigger = true;
			obj2.center = center;
			obj2.size = size;
		}

		private static GameObject DrawLineSub(GameObject obj, Vector3 start, Vector3 end)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer obj2 = CreateRenderer(obj);
			obj2.SetPosition(0, start);
			obj2.SetPosition(1, end);
			return obj;
		}

		public static GameObject DrawLine(string tag, MonoBehaviour parent, Vector3 start, Vector3 end)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = DrawLineSub(CreateObject(((Component)parent).gameObject, tag), start, end);
			AddBoxCollider(obj);
			return obj;
		}

		public static GameObject DrawLineWithFixedRotation(string tag, MonoBehaviour parent, Vector3 start, Vector3 end)
		{
			//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_0006: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.FromToRotation(Vector3.forward, end - start);
			GameObject obj = CreateObject(((Component)parent).gameObject, tag, val);
			Vector3 start2 = Quaternion.Inverse(val) * start;
			Vector3 end2 = Quaternion.Inverse(val) * end;
			GameObject obj2 = DrawLineSub(obj, start2, end2);
			AddBoxCollider(obj2);
			return obj2;
		}

		public static GameObject DrawMarkerLine(string tag, MonoBehaviour parent)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return DrawMarkerLine(tag, parent, Vector3.zero);
		}

		public static GameObject DrawMarkerLine(string tag, MonoBehaviour parent, Vector3 start)
		{
			//IL_0002: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 end = default(Vector3);
			((Vector3)(ref end))..ctor(start.x, 500f, start.z);
			GameObject obj = DrawLineSub(CreateObject(((Component)parent).gameObject, tag, Quaternion.identity), start, end);
			AddBoxCollider(obj);
			return obj;
		}

		public static GameObject DrawBox(string tag, MonoBehaviour parent, Vector3 size)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003a: 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_0051: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_0092: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = size / 2f;
			float num = GetLineWidth(tag) / 2f;
			if (num > val.x)
			{
				num = val.x;
			}
			if (num > val.y)
			{
				num = val.y;
			}
			if (num > val.z)
			{
				num = val.z;
			}
			Vector3[] array = (Vector3[])(object)new Vector3[8]
			{
				new Vector3(0f - val.x + num, 0f - val.y + num, 0f - val.z + num),
				new Vector3(0f - val.x + num, 0f - val.y + num, val.z - num),
				new Vector3(0f - val.x + num, val.y - num, 0f - val.z + num),
				new Vector3(0f - val.x + num, val.y - num, val.z - num),
				new Vector3(val.x - num, 0f - val.y + num, 0f - val.z + num),
				new Vector3(val.x - num, 0f - val.y + num, val.z - num),
				new Vector3(val.x - num, val.y - num, 0f - val.z + num),
				new Vector3(val.x - num, val.y - num, val.z - num)
			};
			GameObject val2 = CreateObject(((Component)parent).gameObject, tag);
			for (int i = 0; i < array.Length; i++)
			{
				Vector3 val3 = array[i];
				for (int j = i + 1; j < array.Length; j++)
				{
					Vector3 val4 = array[j];
					int num2 = 0;
					if (val3.x == val4.x)
					{
						num2++;
					}
					if (val3.y == val4.y)
					{
						num2++;
					}
					if (val3.z == val4.z)
					{
						num2++;
					}
					if (num2 == 2)
					{
						DrawLineSub(CreateObject(val2, tag), array[i], array[j]);
					}
				}
			}
			return val2;
		}

		public static void AddSphereCollider(GameObject obj, float radius)
		{
			GameObject obj2 = obj;
			Array.ForEach(obj2.GetComponentsInChildren<LineRenderer>(), delegate
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				SphereCollider obj3 = obj2.AddComponent<SphereCollider>();
				((Collider)obj3).isTrigger = true;
				obj3.center = Vector3.zero;
				obj3.radius = radius;
			});
		}

		public static void UpdateSphereCollider(MonoBehaviour obj, float radius)
		{
			Array.ForEach(((Component)obj).GetComponentsInChildren<SphereCollider>(), delegate(SphereCollider collider)
			{
				collider.radius = radius;
			});
		}

		public static void UpdateSphere(MonoBehaviour parent, float radius)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer[] componentsInChildren = ((Component)parent).GetComponentsInChildren<LineRenderer>();
			if (componentsInChildren.Length == 3)
			{
				float widthMultiplier = componentsInChildren[0].widthMultiplier;
				UpdateArcX(componentsInChildren[0], Vector3.zero, radius, 360f, widthMultiplier);
				UpdateArcY(componentsInChildren[1], Vector3.zero, radius, 360f, widthMultiplier);
				UpdateArcZ(componentsInChildren[2], Vector3.zero, radius, 360f, widthMultiplier);
				UpdateSphereCollider(parent, radius - widthMultiplier / 2f);
			}
		}

		public static GameObject DrawSphere(string tag, MonoBehaviour parent, float radius)
		{
			return DrawSphere(tag, ((Component)parent).gameObject, radius);
		}

		public static GameObject DrawSphere(string tag, GameObject parent, float radius)
		{
			//IL_0020: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateObject(parent, tag);
			DrawArcX(CreateObject(obj, tag), Vector3.zero, radius, 360f);
			float lineWidth = GetLineWidth(tag);
			AddSphereCollider(obj, radius - lineWidth / 2f);
			DrawArcY(CreateObject(obj, tag), Vector3.zero, radius, 360f);
			DrawArcZ(CreateObject(obj, tag), Vector3.zero, radius, 360f);
			return obj;
		}

		public static GameObject DrawCapsule(string tag, MonoBehaviour parent, float radius, float height)
		{
			return DrawCapsule(tag, ((Component)parent).gameObject, radius, height);
		}

		public static GameObject DrawCapsule(string tag, GameObject parent, float radius, float height)
		{
			//IL_0011: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0074: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: 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_010c: 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)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0150: 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_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: 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_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateObject(parent, tag);
			Vector3 val = Vector3.up * (height - radius);
			Vector3 val2 = Vector3.up * radius;
			float num = GetLineWidth(tag) / 2f;
			float num2 = Mathf.Max(0f, radius - num);
			DrawArcX(CreateObject(obj, tag), val, radius, 360f);
			DrawArcY(CreateObject(obj, tag), val, radius, 360f);
			DrawArcZ(CreateObject(obj, tag), val, radius, 360f);
			DrawArcX(CreateObject(obj, tag), val2, radius, 360f);
			DrawArcY(CreateObject(obj, tag), val2, radius, 360f);
			DrawArcZ(CreateObject(obj, tag), val2, radius, 360f);
			DrawLineSub(CreateObject(obj, tag), val + Vector3.left * num2, val2 + Vector3.left * num2);
			DrawLineSub(CreateObject(obj, tag), val + Vector3.right * num2, val2 + Vector3.right * num2);
			DrawLineSub(CreateObject(obj, tag), val + Vector3.forward * num2, val2 + Vector3.forward * num2);
			DrawLineSub(CreateObject(obj, tag), val + Vector3.back * num2, val2 + Vector3.back * num2);
			return obj;
		}
	}
	public static class CircleAreaManager
	{
		private sealed class Area
		{
			public CircleRuler Owner;

			public Vector3 Center;

			public float Radius;

			public Area(CircleRuler owner, Vector3 center, float radius)
			{
				//IL_0008: 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)
				Owner = owner;
				Center = center;
				Radius = radius;
				base..ctor();
			}
		}

		private static readonly Dictionary<CircleRuler, Area> Areas = new Dictionary<CircleRuler, Area>();

		public static void Register(CircleRuler owner, Vector3 center, float radius)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!Areas.ContainsKey(owner))
			{
				Areas[owner] = new Area(owner, center, radius);
			}
		}

		public static void UpdateRadius(CircleRuler owner, float radius, Vector3 centerIfMissing)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!Areas.TryGetValue(owner, out Area value))
			{
				Register(owner, centerIfMissing, radius);
			}
			else
			{
				value.Radius = radius;
			}
		}

		public static void Unregister(CircleRuler owner)
		{
			Areas.Remove(owner);
		}

		public static void RefreshColors()
		{
			foreach (Area value in Areas.Values)
			{
				value.Owner.ApplyColor();
			}
		}

		public static bool IsInsideOtherCircle(CircleRuler owner, Vector3 position)
		{
			//IL_0002: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(position.x, position.z);
			Vector2 val2 = default(Vector2);
			foreach (Area value in Areas.Values)
			{
				if (!((Object)(object)value.Owner == (Object)(object)owner))
				{
					((Vector2)(ref val2))..ctor(value.Center.x, value.Center.z);
					Vector2 val3 = val - val2;
					if (((Vector2)(ref val3)).sqrMagnitude <= value.Radius * value.Radius)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public abstract class BaseRuler : MonoBehaviour
	{
		private static LayerMask Mask = LayerMask.op_Implicit(LayerMask.GetMask(new string[1] { "terrain" }));

		private static readonly int ColorPropertyId = Shader.PropertyToID("_Color");

		private static GameObject? basePrefab;

		public static bool SnapToGround = true;

		public static bool Visible = true;

		protected List<GameObject> Segments = new List<GameObject>();

		private static GameObject BasePrefab => basePrefab ?? (basePrefab = GetBasePrefab());

		protected static Vector3 BaseScale => BasePrefab.transform.localScale;

		private static GameObject GetBasePrefab()
		{
			GameObject prefab = ZNetScene.instance.GetPrefab("piece_workbench");
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new InvalidOperationException("Error: Unable to find the workbench object.");
			}
			return prefab.GetComponentInChildren<CircleProjector>().m_prefab;
		}

		public void OnDestroy()
		{
			foreach (GameObject segment in Segments)
			{
				Object.Destroy((Object)(object)segment);
			}
			Segments.Clear();
		}

		public void Update()
		{
			if (!Visible)
			{
				CreateSegments(0);
				return;
			}
			CreateLines();
			if (SnapToGround)
			{
				Snap();
			}
		}

		protected void CreateSegments(int count)
		{
			if (Segments.Count == count)
			{
				return;
			}
			foreach (GameObject segment in Segments)
			{
				Object.Destroy((Object)(object)segment);
			}
			Segments.Clear();
			if (count != 0)
			{
				for (int i = 0; i < count; i++)
				{
					Segments.Add(Object.Instantiate<GameObject>(BasePrefab, ((Component)this).transform));
				}
				ApplyColor();
			}
		}

		internal void ApplyColor()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Color color = Draw.GetColor("EffectAreaPlayerBase");
			foreach (GameObject segment in Segments)
			{
				ApplyColor(segment, color);
			}
		}

		private static void ApplyColor(GameObject obj, Color color)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Renderer component = obj.GetComponent<Renderer>();
			if (Object.op_Implicit((Object)(object)component))
			{
				Material[] materials = component.materials;
				for (int i = 0; i < materials.Length; i++)
				{
					materials[i].SetColor(ColorPropertyId, color);
				}
			}
		}

		protected abstract void CreateLines();

		private void Snap()
		{
			//IL_0023: 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)
			foreach (GameObject segment in Segments)
			{
				segment.transform.position = Snap(segment.transform.position);
			}
		}

		private Vector3 Snap(Vector3 pos)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(pos + Vector3.up * 500f, Vector3.down, ref val, 1000f, ((LayerMask)(ref Mask)).value))
			{
				pos.y = ((RaycastHit)(ref val)).point.y;
			}
			return pos;
		}

		protected Transform Get(int index)
		{
			return Segments[index].transform;
		}

		protected void Set(int index, Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Get(index).localPosition = pos;
		}

		protected void SetRot(int index, Vector3 rot)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			Get(index).localRotation = Quaternion.LookRotation(rot, Vector3.up);
		}
	}
	public class CircleRuler : BaseRuler
	{
		[SerializeField]
		private float radius = 20f;

		private readonly float Speed = 0.1f;

		public float Radius
		{
			get
			{
				return radius;
			}
			set
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				radius = value;
				CircleAreaManager.UpdateRadius(this, radius, ((Component)this).transform.position);
			}
		}

		public void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			CircleAreaManager.Register(this, ((Component)this).transform.position, radius);
		}

		public new void OnDestroy()
		{
			CircleAreaManager.Unregister(this);
			base.OnDestroy();
		}

		protected override void CreateLines()
		{
			int count = Math.Max(3, (int)(Radius * 4f));
			CreateSegments(count);
			UpdateLines();
		}

		private void UpdateLines()
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00eb: 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_00f5: Unknown result type (might be due to invalid IL or missing references)
			int count = Segments.Count;
			float num = (float)Math.PI * 2f / (float)count;
			float num2 = Time.time * Speed;
			Vector3 pos = default(Vector3);
			for (int i = 0; i < count; i++)
			{
				float num3 = (float)i * num + num2;
				((Vector3)(ref pos))..ctor(Mathf.Sin(num3) * Radius, 0f, Mathf.Cos(num3) * Radius);
				Set(i, pos);
			}
			for (int j = 0; j < count; j++)
			{
				GameObject obj = ((j == 0) ? Segments[Segments.Count - 1] : Segments[j - 1]);
				GameObject val = ((j == Segments.Count - 1) ? Segments[0] : Segments[j + 1]);
				Vector3 val2 = obj.transform.localPosition - val.transform.localPosition;
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				SetRot(j, normalized);
			}
			for (int k = 0; k < count; k++)
			{
				Segments[k].SetActive(!CircleAreaManager.IsInsideOtherCircle(this, Segments[k].transform.position));
			}
		}
	}
	public class Utils
	{
		public static Visualization[] GetVisualizations()
		{
			return Resources.FindObjectsOfTypeAll<Visualization>();
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateHover")]
	public class Player_AddHoverForVisuals
	{
		private static void Postfix(ref GameObject ___m_hovering, ref GameObject ___m_hoveringCreature)
		{
			//IL_0037: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)___m_hovering) || Object.op_Implicit((Object)(object)___m_hoveringCreature))
			{
				return;
			}
			float num = 100f;
			int mask = LayerMask.GetMask(new string[1] { "character_trigger" });
			RaycastHit[] array = Physics.RaycastAll(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, num, mask);
			RaycastHit[] array2 = Physics.RaycastAll(((Component)GameCamera.instance).transform.position + ((Component)GameCamera.instance).transform.forward * num, -((Component)GameCamera.instance).transform.forward, num, mask);
			RaycastHit[] array3 = CollectionExtensions.AddRangeToArray<RaycastHit>(array, array2);
			Array.Sort(array3, (RaycastHit x, RaycastHit y) => ((RaycastHit)(ref x)).distance.CompareTo(((RaycastHit)(ref y)).distance));
			RaycastHit[] array4 = array3;
			for (int i = 0; i < array4.Length; i++)
			{
				RaycastHit val = array4[i];
				if ((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponent<Visualization>() != (Object)null)
				{
					___m_hovering = ((Component)((RaycastHit)(ref val)).collider).gameObject;
					break;
				}
			}
		}
	}
	public class StaticText : MonoBehaviour, Hoverable
	{
		public string title = "";

		public string text = "";

		public string GetHoverText()
		{
			return Format.String(title) + "\n" + text;
		}

		public string GetHoverName()
		{
			return title;
		}
	}
	public class Visualization : MonoBehaviour
	{
		public string Tag = "";

		private static readonly List<Visualization> Visualizations = new List<Visualization>();

		private Quaternion? FixedRotation;

		public static void SharedUpdate()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			foreach (Visualization visualization in Visualizations)
			{
				((Component)visualization).transform.rotation = visualization.FixedRotation.Value;
			}
		}

		public void OnDestroy()
		{
			if (Visualizations.Contains(this))
			{
				Visualizations.Remove(this);
			}
		}

		public void SetFixed(Quaternion rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			FixedRotation = rotation;
			Visualizations.Add(this);
		}
	}
	public class Visibility : Component
	{
		private static readonly Dictionary<string, string> combinedTags = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			["StructureCoverBlocked"] = "StructureCover",
			["PlayerCoverBlocked"] = "PlayerCover",
			["ZoneCornerAshlands"] = "ZoneCorner",
			["ZoneCornerBlackForest"] = "ZoneCorner",
			["ZoneCornerDeepNorth"] = "ZoneCorner",
			["ZoneCornerMeadows"] = "ZoneCorner",
			["ZoneCornerMistlands"] = "ZoneCorner",
			["ZoneCornerMountain"] = "ZoneCorner",
			["ZoneCornerOcean"] = "ZoneCorner",
			["ZoneCornerPlains"] = "ZoneCorner",
			["ZoneCornerSwamp"] = "ZoneCorner",
			["ZoneCornerUnknown"] = "ZoneCorner",
			["SpawnZoneAshlands"] = "SpawnZone",
			["SpawnZoneBlackForest"] = "SpawnZone",
			["SpawnZoneDeepNorth"] = "SpawnZone",
			["SpawnZoneMeadows"] = "SpawnZone",
			["SpawnZoneMistlands"] = "SpawnZone",
			["SpawnZoneMountain"] = "SpawnZone",
			["SpawnZoneOcean"] = "SpawnZone",
			["SpawnZonePlains"] = "SpawnZone",
			["SpawnZoneSwamp"] = "SpawnZone",
			["SpawnZoneUnknown"] = "SpawnZone"
		};

		private static readonly HashSet<int> enabledTags = new HashSet<int>();

		private static readonly HashSet<int> previousTags = new HashSet<int>();

		private static readonly HashSet<int> tagHashes = new HashSet<int>();

		private static readonly Dictionary<int, string> tags = new Dictionary<int, string>();

		private static readonly Dictionary<int, List<Action>> rebuilders = new Dictionary<int, List<Action>>();

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

		public static List<string> GetTags
		{
			get
			{
				Dictionary<int, string>.ValueCollection values = tags.Values;
				List<string> list = new List<string>(values.Count);
				list.AddRange(values);
				return list;
			}
		}

		public static int GetTagHash(string name)
		{
			if (tagHashCache.TryGetValue(name, out var value))
			{
				return value;
			}
			value = ((!combinedTags.TryGetValue(name, out string value2)) ? StringExtensionMethods.GetStableHashCode(name.ToLowerInvariant()) : StringExtensionMethods.GetStableHashCode(value2.ToLowerInvariant()));
			tagHashCache[name] = value;
			return value;
		}

		public static bool IsTag(string name)
		{
			int tagHash = GetTagHash(name);
			return PermissionManager.IsVisualFeatureEnabled(tagHash, enabledTags.Contains(tagHash));
		}

		public static void SetTag(string tag, bool visibility)
		{
			int tagHash = GetTagHash(tag);
			tagHashes.Add(tagHash);
			tags[tagHash] = tag;
			if (visibility)
			{
				enabledTags.Add(tagHash);
			}
			else
			{
				enabledTags.Remove(tagHash);
			}
			ApplyTagState(tagHash);
		}

		public static void RegisterRebuilder(string tag, Action rebuilder)
		{
			int tagHash = GetTagHash(tag);
			if (!rebuilders.TryGetValue(tagHash, out List<Action> value))
			{
				value = new List<Action>();
				rebuilders[tagHash] = value;
			}
			if (!value.Contains(rebuilder))
			{
				value.Add(rebuilder);
			}
		}

		private static void RebuildTag(string tag)
		{
			int tagHash = GetTagHash(tag);
			if (!rebuilders.TryGetValue(tagHash, out List<Action> value))
			{
				return;
			}
			foreach (Action item in value)
			{
				item();
			}
		}

		private static void DestroyTag(string name)
		{
			Visualization[] visualizations = Utils.GetVisualizations();
			foreach (Visualization visualization in visualizations)
			{
				if (!(visualization.Tag != name))
				{
					Object.Destroy((Object)(object)((Component)visualization).gameObject);
				}
			}
		}

		private static void UpdateTagVisibility(string name)
		{
			Visualization[] visualizations = Utils.GetVisualizations();
			foreach (Visualization visualization in visualizations)
			{
				if (!(visualization.Tag != name))
				{
					UpdateVisibility(visualization);
				}
			}
		}

		public static void Reload()
		{
			foreach (int tagHash in tagHashes)
			{
				ApplyTagState(tagHash);
			}
		}

		private static void ApplyTagState(int hash)
		{
			if (!tags.TryGetValue(hash, out string value))
			{
				return;
			}
			bool flag = previousTags.Contains(hash);
			bool flag2 = PermissionManager.IsVisualFeatureEnabled(hash, enabledTags.Contains(hash));
			if (flag2 != flag)
			{
				if (flag2)
				{
					previousTags.Add(hash);
				}
				else
				{
					previousTags.Remove(hash);
				}
				if (!flag2)
				{
					DestroyTag(value);
				}
				else if (!flag)
				{
					RebuildTag(value);
				}
				UpdateTagVisibility(value);
			}
		}

		private static void UpdateVisibility(Visualization obj)
		{
			GameObject gameObject = ((Component)obj).gameObject;
			bool flag = IsTag(obj.Tag);
			if (gameObject.activeSelf != flag)
			{
				gameObject.SetActive(flag);
			}
		}
	}
}
namespace Service
{
	public class Format
	{
		public const string FORMAT = "0.##";

		public static string GetValidColor(bool valid)
		{
			if (!valid)
			{
				return "#B2BEB5";
			}
			return "#FFFF00";
		}

		public static string String(string value, string color = "#FFFF00")
		{
			return "<color=" + color + ">" + value + "</color>";
		}

		public static string String(string value, bool valid)
		{
			return "<color=" + GetValidColor(valid) + ">" + value + "</color>";
		}

		public static string Float(double value, string format = "0.##", string color = "#FFFF00")
		{
			return String(value.ToString(format, CultureInfo.InvariantCulture), color);
		}

		public static string Multiplier(double value, string color = "#FFFF00")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + "x", color);
		}

		public static string Meters(double value, string color = "#FFFF00")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + " meters", color);
		}

		public static string Degrees(double value, string color = "#FFFF00")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + " degrees", color);
		}

		public static string Fixed(double value)
		{
			return String(value.ToString("N2", CultureInfo.InvariantCulture).PadLeft(5, '0'));
		}

		public static string Percent(double value, string color = "#FFFF00")
		{
			return String((100.0 * value).ToString("0.##", CultureInfo.InvariantCulture) + " %", color);
		}

		public static string PercentInt(double value, string color = "#FFFF00")
		{
			return String(value.ToString("P0", CultureInfo.InvariantCulture), color);
		}

		public static string Range(double min, double max, string color = "#FFFF00")
		{
			if (min == max)
			{
				return String(max.ToString("0.##", CultureInfo.InvariantCulture), color);
			}
			return String(min.ToString("0.##", CultureInfo.InvariantCulture), color) + "-" + String(max.ToString("0.##", CultureInfo.InvariantCulture), color);
		}

		public static string PercentRange(double min, double max)
		{
			if (min == max)
			{
				return max.ToString("P0", CultureInfo.InvariantCulture);
			}
			return min.ToString("P0", CultureInfo.InvariantCulture) + "-" + max.ToString("P0", CultureInfo.InvariantCulture);
		}

		public static string Progress(double value, double limit, bool percent = false)
		{
			return String(value.ToString("N0")) + "/" + String(limit.ToString("N0")) + (percent ? (" (" + PercentInt(value / limit) + ")") : "");
		}

		public static string Int(double value, string color = "#FFFF00")
		{
			return String(value.ToString("N0"), color);
		}

		public static string ProgressPercent(string header, double value, double limit)
		{
			return header + ": " + Progress(value, limit) + " seconds (" + Percent(value / limit) + ")";
		}

		public static string Coordinates(Vector3 coordinates, string format = "F0", string color = "#FFFF00")
		{
			//IL_000f: 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)
			string color2 = color;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(coordinates.x, coordinates.z, coordinates.y);
			return JoinRow(from value in ((Vector3)(ref val)).ToString(format).Replace("(", "").Replace(")", "")
					.Split(new char[1] { ',' })
				select String(value.Trim(), color2));
		}

		public static string JoinLines(IEnumerable<string> lines)
		{
			return string.Join("\n", lines.Where((string line) => line != ""));
		}

		public static string JoinRow(IEnumerable<string> lines)
		{
			return string.Join(", ", lines.Where((string line) => line != ""));
		}
	}
	public class Helper
	{
		private static T Get<T>(object obj, string field)
		{
			return Traverse.Create(obj).Field<T>(field).Value;
		}

		public static ZNetView Nview(MonoBehaviour obj)
		{
			return Get<ZNetView>(obj, "m_nview");
		}

		public static double GetElapsed(MonoBehaviour obj, string key, long defaultValue = 0L)
		{
			DateTime time = ZNet.instance.GetTime();
			DateTime dateTime = GetDateTime(obj, key, defaultValue);
			return (time - dateTime).TotalSeconds;
		}

		public static double GetElapsed(MonoBehaviour obj, int key, long defaultValue = 0L)
		{
			DateTime time = ZNet.instance.GetTime();
			DateTime dateTime = GetDateTime(obj, key, defaultValue);
			return (time - dateTime).TotalSeconds;
		}

		public static GameObject GetRoot(MonoBehaviour obj)
		{
			GameObject gameObject = ((Component)obj).gameObject;
			while ((Object)(object)gameObject.transform.parent != (Object)null)
			{
				gameObject = ((Component)gameObject.transform.parent).gameObject;
			}
			return gameObject;
		}

		public static DateTime GetDateTime(MonoBehaviour obj, string key, long defaultValue = 0L)
		{
			return new DateTime(GetLong(obj, key, defaultValue));
		}

		public static DateTime GetDateTime(MonoBehaviour obj, int key, long defaultValue = 0L)
		{
			return new DateTime(GetLong(obj, key, defaultValue));
		}

		public static float GetFloat(MonoBehaviour obj, string key, float defaultValue = 0f)
		{
			return Nview(obj).GetZDO().GetFloat(key, defaultValue);
		}

		public static long GetLong(MonoBehaviour obj, string key, long defaultValue = 0L)
		{
			return Nview(obj).GetZDO().GetLong(key, defaultValue);
		}

		public static long GetLong(MonoBehaviour obj, int key, long defaultValue = 0L)
		{
			return Nview(obj).GetZDO().GetLong(key, defaultValue);
		}

		public static int GetInt(MonoBehaviour obj, string key, int defaultValue = 0)
		{
			return Nview(obj).GetZDO().GetInt(key, defaultValue);
		}

		public static bool GetBool(MonoBehaviour obj, string key, bool defaultValue = false)
		{
			return Nview(obj).GetZDO().GetBool(key, defaultValue);
		}

		public static string GetString(MonoBehaviour obj, string key, string defaultValue = "")
		{
			return Nview(obj).GetZDO().GetString(key, defaultValue);
		}

		public static GameObject GetPrefab(MonoBehaviour obj)
		{
			return ZNetScene.instance.GetPrefab(Nview(obj).GetZDO().GetPrefab());
		}

		public static bool IsValid(MonoBehaviour obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return false;
			}
			ZNetView val = Nview(obj);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			return val.IsValid();
		}
	}
	public class Log
	{
		private static ManualLogSource Logger;

		public static void Init(ManualLogSource logger)
		{
			Logger = logger;
		}

		public static void Error(string message)
		{
			Logger.LogError((object)message);
		}

		public static void Warning(string message)
		{
			Logger.LogWarning((object)message);
		}

		public static void Info(string message)
		{
			Logger.LogInfo((object)message);
		}

		public static void Debug(string message)
		{
			Logger.LogDebug((object)message);
		}
	}
	[HarmonyPatch(typeof(Hud), "Awake")]
	public class HudAwake
	{
		private static void Postfix(Hud __instance)
		{
			//IL_000c: 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)
			RectTransform component = ((Component)__instance.m_hoverName).GetComponent<RectTransform>();
			component.sizeDelta += new Vector2(100f, 0f);
		}
	}
	[HarmonyPatch(typeof(MessageHud), "Update")]
	[HarmonyPriority(200)]
	public class MessageHud_UpdateMessage : MonoBehaviour
	{
		public static Func<List<string>> GetMessage = () => new List<string> { "Default message. Replace with your own function." };

		private static void Postfix(MessageHud __instance)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || Hud.IsUserHidden())
			{
				return;
			}
			__instance.m_messageText.alignment = (TextAlignmentOptions)257;
			string text = __instance.m_messageText.text;
			List<string> list = GetMessage();
			if (list.Count != 0)
			{
				if (text != "")
				{
					list.Add(" ");
					list.Add(text);
				}
				__instance.m_messageText.text = Format.JoinLines(list);
				((Graphic)__instance.m_messageText).CrossFadeAlpha(1f, 0f, true);
				((Graphic)__instance.m_messageIcon).canvasRenderer.SetAlpha(0f);
				((Graphic)__instance.m_messageIcon).CrossFadeAlpha(0f, 0f, true);
			}
		}
	}
	[HarmonyPatch(typeof(MessageHud), "UpdateMessage")]
	public class MessageHud_GetBaseMessage : MonoBehaviour
	{
		private static string BaseMessage = "";

		private static void Prefix(out string __state)
		{
			__state = MessageHud.instance.m_messageText.text;
		}

		private static void Postfix(MessageHud __instance, float ___m_msgQueueTimer, string __state)
		{
			if (__instance.m_messageText.text != __state)
			{
				BaseMessage = __instance.m_messageText.text;
			}
			if (___m_msgQueueTimer >= 4f)
			{
				BaseMessage = "";
			}
			__instance.m_messageText.text = BaseMessage;
		}
	}
	public class Range<T>
	{
		public T Min;

		public T Max;

		public bool Uniform = true;

		public Range(T value)
		{
			Min = value;
			Max = value;
		}

		public Range(T min, T max)
		{
			Min = min;
			Max = max;
		}
	}
	public static class Parse
	{
		public static List<string> ToList(string str, bool removeEmpty = true)
		{
			string[] array = Split(str, removeEmpty);
			List<string> list = new List<string>(array.Length);
			list.AddRange(array);
			return list;
		}

		public static Vector2i Vector2Int(string arg)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			string[] array = SplitWithEmpty(arg);
			return new Vector2i(Int(array[0]), (array.Length > 1) ? Int(array[1]) : 0);
		}

		public static int Int(string arg, int defaultValue = 0)
		{
			if (!TryInt(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static uint UInt(string arg, uint defaultValue = 0u)
		{
			if (!TryUInt(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static long Long(string arg, long defaultValue = 0L)
		{
			if (!long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static bool TryLong(string arg, out long result)
		{
			return long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static int Int(string[] args, int index, int defaultValue = 0)
		{
			if (args.Length <= index)
			{
				return defaultValue;
			}
			return Int(args[index], defaultValue);
		}

		public static bool TryUInt(string arg, out uint result)
		{
			return uint.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static bool TryInt(string arg, out int result)
		{
			return int.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static float Float(string arg, float defaultValue = 0f)
		{
			if (!TryFloat(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static float Float(string[] args, int index, float defaultValue = 0f)
		{
			if (args.Length <= index)
			{
				return defaultValue;
			}
			return Float(args[index], defaultValue);
		}

		public static bool TryFloat(string arg, out float result)
		{
			return float.TryParse(arg, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
		}

		public static bool TryBoolean(string arg, out bool result)
		{
			result = false;
			if (arg.ToLowerInvariant() == "true")
			{
				result = true;
				return true;
			}
			if (arg.ToLowerInvariant() == "false")
			{
				return true;
			}
			return false;
		}

		public static Quaternion AngleYXZ(string arg)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			return AngleYXZ(Split(arg), 0, Vector3.zero);
		}

		public static Quaternion AngleYXZ(string[] args, int index)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return AngleYXZ(args, index, Vector3.zero);
		}

		public static Quaternion AngleYXZ(string[] args, int index, Vector3 defaultValue)
		{
			//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_000a: 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_0036: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			zero.y = Float(args, index, defaultValue.y);
			zero.x = Float(args, index + 1, defaultValue.x);
			zero.z = Float(args, index + 2, defaultValue.z);
			return Quaternion.Euler(zero);
		}

		public static string[] Split(string arg, bool removeEmpty = true, char split = ',')
		{
			return (from s in arg.Split(new char[1] { split })
				select s.Trim() into s
				where !removeEmpty || s != ""
				select s).ToArray();
		}

		public static KeyValuePair<string, string> Kvp(string str, char separator = ',')
		{
			string[] array = str.Split(new char[1] { separator }, 2);
			if (array.Length < 2)
			{
				return new KeyValuePair<string, string>(array[0], "");
			}
			return new KeyValuePair<string, string>(array[0], array[1].Trim());
		}

		public static bool TryKvp(string str, out KeyValuePair<string, string> kvp, char separator = ',')
		{
			kvp = Kvp(str, separator);
			return kvp.Value != "";
		}

		public static string[] SplitWithEmpty(string arg, char split = ',')
		{
			return (from s in arg.Split(new char[1] { split })
				select s.Trim()).ToArray();
		}

		public static string[] SplitWithEscape(string arg, char separator = ',')
		{
			List<string> list = new List<string>();
			string[] array = arg.Split(new char[1] { separator });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].TrimStart(Array.Empty<char>());
				if (text.StartsWith("\""))
				{
					array[i] = text.Substring(1);
					int j;
					for (j = i; j < array.Length; j++)
					{
						text = array[j].TrimEnd(Array.Empty<char>());
						if (text.EndsWith("\""))
						{
							array[j] = text.Substring(0, text.Length - 1);
							break;
						}
					}
					list.Add(string.Join(separator.ToString(), array.Skip(i).Take(j - i + 1)));
					i = j;
				}
				else
				{
					list.Add(array[i].Trim());
				}
			}
			return list.ToArray();
		}

		public static string Name(string arg)
		{
			return arg.Split(new char[1] { ':' })[0];
		}

		public static Vector3 VectorXZY(string arg)
		{
			//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)
			return VectorXZY(arg, Vector3.zero);
		}

		public static Vector3 VectorXZY(string arg, Vector3 defaultValue)
		{
			//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)
			return VectorXZY(Split(arg), 0, defaultValue);
		}

		public static Vector3 VectorXZY(string[] args, int index)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return VectorXZY(args, index, Vector3.zero);
		}

		public static Vector3 VectorXZY(string[] args, int index, Vector3 defaultValue)
		{
			//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_000a: 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_0036: 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 zero = Vector3.zero;
			zero.x = Float(args, index, defaultValue.x);
			zero.z = Float(args, index + 1, defaultValue.z);
			zero.y = Float(args, index + 2, defaultValue.y);
			return zero;
		}

		public static Vector2 VectorXY(string arg)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			Vector2 zero = Vector2.zero;
			string[] args = Split(arg);
			zero.x = Float(args, 0);
			zero.y = Float(args, 1);
			return zero;
		}

		public static Vector3 Scale(string args)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Scale(Split(args), 0);
		}

		public static Vector3 Scale(string[] args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Scale(args, 0);
		}

		public static Vector3 Scale(string[] args, int index)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return SanityCheck(VectorXZY(args, index));
		}

		private static Vector3 SanityCheck(Vector3 scale)
		{
			//IL_0000: 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_0033: 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_004d: 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)
			if (scale.x == 0f)
			{
				scale.x = 1f;
			}
			if (scale.y == 0f)
			{
				scale.y = scale.x;
			}
			if (scale.z == 0f)
			{
				scale.z = scale.x;
			}
			return scale;
		}

		public static Range<string> StringRange(string arg)
		{
			List<string> list = arg.Split('-', ';').ToList();
			if (list.Count > 1 && list[0] == "")
			{
				list[0] = "-" + list[1];
				list.RemoveAt(1);
			}
			if (list.Count > 2 && list[1] == "")
			{
				list[1] = "-" + list[2];
				list.RemoveAt(2);
			}
			if (list.Count == 1)
			{
				return new Range<string>(list[0]);
			}
			return new Range<string>(list[0], list[1]);
		}

		public static Range<int> IntRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<int>(Int(range.Min), Int(range.Max));
		}

		public static Range<float> FloatRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<float>(Float(range.Min), Float(range.Max));
		}

		public static Range<long> LongRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<long>(Long(range.Min, 0L), Long(range.Max, 0L));
		}

		public static int? IntNull(string arg)
		{
			if (int.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static int? IntNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return IntNull(args[index]);
		}

		public static float? FloatNull(string arg)
		{
			if (float.TryParse(arg, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static float? FloatNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return FloatNull(args[index]);
		}

		public static long? LongNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return LongNull(args[index]);
		}

		public static long? LongNull(string arg)
		{
			if (long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static Vector3? VectorXZYNull(string? arg)
		{
			if (arg != null)
			{
				return VectorXZYNull(Split(arg));
			}
			return null;
		}

		public static Vector3? VectorXZYNull(string[] args)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			float? num = FloatNull(args, 0);
			float? num2 = FloatNull(args, 2);
			float? num3 = FloatNull(args, 1);
			if (!num.HasValue && !num2.HasValue && !num3.HasValue)
			{
				return null;
			}
			return new Vector3(num.GetValueOrDefault(), num2.GetValueOrDefault(), num3.GetValueOrDefault());
		}

		public static Quaternion? AngleYXZNull(string? arg)
		{
			if (arg != null)
			{
				return AngleYXZNull(Split(arg));
			}
			return null;
		}

		public static Quaternion? AngleYXZNull(string[] values)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			float? num = FloatNull(values, 0);
			float? num2 = FloatNull(values, 1);
			float? num3 = FloatNull(values, 2);
			if (!num.HasValue && !num2.HasValue && !num3.HasValue)
			{
				return null;
			}
			return Quaternion.Euler(new Vector3(num2.GetValueOrDefault(), num.GetValueOrDefault(), num3.GetValueOrDefault()));
		}

		public static string String(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return "";
			}
			return args[index];
		}

		public static int Hash(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return 0;
			}
			return StringExtensionMethods.GetStableHashCode(args[index]);
		}

		public static bool Boolean(string[] args, int index)
		{
			if (args.Length > index)
			{
				return Boolean(args[index]);
			}
			return false;
		}

		public static bool Boolean(string arg)
		{
			return arg.ToLowerInvariant() == "true";
		}

		public static bool BooleanTrue(string arg)
		{
			return arg.ToLowerInvariant() == "false";
		}

		public static ZDOID ZdoId(string arg)
		{
			//IL_0029: 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)
			string[] array = Split(arg, removeEmpty: true, ':');
			if (array.Length < 2)
			{
				return ZDOID.None;
			}
			return new ZDOID(Long(array[0], 0L), UInt(array[1]));
		}
	}
	public static class PermissionHash
	{
		public const string Section = "esp";

		public static readonly int Drops = StringExtensionMethods.GetStableHashCode("drops");

		public static readonly int Breeding = StringExtensionMethods.GetStableHashCode("breeding");

		public static readonly int Status = StringExtensionMethods.GetStableHashCode("status");

		public static readonly int Attacks = StringExtensionMethods.GetStableHashCode("attacks");

		public static readonly int Resistances = StringExtensionMethods.GetStableHashCode("resistances");

		public static readonly int ExtraInfo = StringExtensionMethods.GetStableHashCode("extrainfo");

		public static readonly int CustomOnly = StringExtensionMethods.GetStableHashCode("customonly");

		public static readonly int WeaponInfo = StringExtensionMethods.GetStableHashCode("weaponinfo");

		public static readonly int Progress = StringExtensionMethods.GetStableHashCode("progress");

		public static readonly int Support = StringExtensionMethods.GetStableHashCode("support");

		public static readonly int Structures = StringExtensionMethods.GetStableHashCode("structures");

		public static readonly int Creatures = StringExtensionMethods.GetStableHashCode("creatures");

		public static readonly int Destructibles = StringExtensionMethods.GetStableHashCode("destructibles");

		public static readonly int Pickables = StringExtensionMethods.GetStableHashCode("pickables");

		public static readonly int ItemDrops = StringExtensionMethods.GetStableHashCode("itemdrops");

		public static readonly int Ships = StringExtensionMethods.GetStableHashCode("ships");

		public static readonly int Locations = StringExtensionMethods.GetStableHashCode("locations");

		public static readonly int Vegetation = StringExtensionMethods.GetStableHashCode("vegetation");

		public static readonly int Hud = StringExtensionMethods.GetStableHashCode("hud");

		public static readonly int Ship = StringExtensionMethods.GetStableHashCode("ship");

		public static readonly int Time = StringExtensionMethods.GetStableHashCode("time");

		public static readonly int Position = StringExtensionMethods.GetStableHashCode("position");

		public static readonly int Altitude = StringExtensionMethods.GetStableHashCode("altitude");

		public static readonly int Forest = StringExtensionMethods.GetStableHashCode("forest");

		public static readonly int Blocked = StringExtensionMethods.GetStableHashCode("blocked");

		public static readonly int Stagger = StringExtensionMethods.GetStableHashCode("stagger");

		public static readonly int Heat = StringExtensionMethods.GetStableHashCode("heat");

		public static readonly int Speed = StringExtensionMethods.GetStableHashCode("speed");

		public static readonly int Stealth = StringExtensionMethods.GetStableHashCode("stealth");

		public static readonly int Weather = StringExtensionMethods.GetStableHashCode("weather");

		public static readonly int Wind = StringExtensionMethods.GetStableHashCode("wind");

		public static readonly int CreatureCollider = StringExtensionMethods.GetStableHashCode("creaturecollider");

		public static readonly int StructureCollider = StringExtensionMethods.GetStableHashCode("structurecollider");

		public static readonly int DestructibleCollider = StringExtensionMethods.GetStableHashCode("destructiblecollider");

		public static readonly int Attack = StringExtensionMethods.GetStableHashCode("attack");

		public static readonly int StructureCover = StringExtensionMethods.GetStableHashCode("structurecover");

		public static readonly int StructureCoverBlocked = StringExtensionMethods.GetStableHashCode("structurecoverblocked");

		public static readonly int StructureSupport = StringExtensionMethods.GetStableHashCode("structuresupport");

		public static readonly int CreatureNoise = StringExtensionMethods.GetStableHashCode("creaturenoise");

		public static readonly int CreatureHearRange = StringExtensionMethods.GetStableHashCode("creaturehearrange");

		public static readonly int CreatureViewRange = StringExtensionMethods.GetStableHashCode("creatureviewrange");

		public static readonly int CreatureAlertRange = StringExtensionMethods.GetStableHashCode("creaturealertrange");

		public static readonly int CreatureFireRange = StringExtensionMethods.GetStableHashCode("creaturefirerange");

		public static readonly int CreatureBreedingTotalRange = StringExtensionMethods.GetStableHashCode("creaturebreedingtotalrange");

		public static readonly int CreatureBreedingPartnerRange = StringExtensionMethods.GetStableHashCode("creaturebreedingpartnerrange");

		public static readonly int CreatureFoodSearchRange = StringExtensionMethods.GetStableHashCode("creaturefoodsearchrange");

		public static readonly int CreatureEatingRange = StringExtensionMethods.GetStableHashCode("creatureeatingrange");

		public static readonly int TrackedObject = StringExtensionMethods.GetStableHashCode("trackedobject");

		public static readonly int PickableOneTime = StringExtensionMethods.GetStableHashCode("pickableonetime");

		public static readonly int PickableRespawning = StringExtensionMethods.GetStableHashCode("pickablerespawning");

		public static readonly int EventZone = StringExtensionMethods.GetStableHashCode("eventzone");

		public static readonly int Location = StringExtensionMethods.GetStableHashCode("location");

		public static readonly int Chest = StringExtensionMethods.GetStableHashCode("chest");

		public static readonly int Tree = StringExtensionMethods.GetStableHashCode("tree");

		public static readonly int Ore = StringExtensionMethods.GetStableHashCode("ore");

		public static readonly int TrophySpeak = StringExtensionMethods.GetStableHashCode("trophyspeak");

		public static readonly int Destructible = StringExtensionMethods.GetStableHashCode("destructible");

		public static readonly int SpawnPointOneTime = StringExtensionMethods.GetStableHashCode("spawnpointonetime");

		public static readonly int SpawnPointRespawning = StringExtensionMethods.GetStableHashCode("spawnpointrespawning");

		public static readonly int SpawnerRay = StringExtensionMethods.GetStableHashCode("spawnerray");

		public static readonly int SpawnerTriggerRange = StringExtensionMethods.GetStableHashCode("spawnertriggerrange");

		public static readonly int SpawnerLimitRange = StringExtensionMethods.GetStableHashCode("spawnernearrange");

		public static readonly int SpawnerSpawnRange = StringExtensionMethods.GetStableHashCode("spawnerspawnrange");

		public static readonly int AltarRay = StringExtensionMethods.GetStableHashCode("altarray");

		public static readonly int AltarSpawnRadius = StringExtensionMethods.GetStableHashCode("altarspawnradius");

		public static readonly int AltarItemStandRange = StringExtensionMethods.GetStableHashCode("altaritemstandrange");

		public static readonly int ZoneCorner = StringExtensionMethods.GetStableHashCode("zonecorner");

		public static readonly int ZoneCornerAshlands = StringExtensionMethods.GetStableHashCode("zonecornerashlands");

		public static readonly int ZoneCornerBlackForest = StringExtensionMethods.GetStableHashCode("zonecornerblackforest");

		public static readonly int ZoneCornerDeepNorth = StringExtensionMethods.GetStableHashCode("zonecornerdeepnorth");

		public static readonly int ZoneCornerMeadows = StringExtensionMethods.GetStableHashCode("zonecornermeadows");

		public static readonly int ZoneCornerMistlands = StringExtensionMethods.GetStableHashCode("zonecornermistlands");

		public static readonly int ZoneCornerMountain = StringExtensionMethods.GetStableHashCode("zonecornermountain");

		public static readonly int ZoneCornerOcean = StringExtensionMethods.GetStableHashCode("zonecornerocean");

		public static readonly int ZoneCornerPlains = StringExtensionMethods.GetStableHashCode("zonecornerplains");

		public static readonly int ZoneCornerSwamp = StringExtensionMethods.GetStableHashCode("zonecornerswamp");

		public static readonly int ZoneCornerUnknown = StringExtensionMethods.GetStableHashCode("zonecornerunknown");

		public static readonly int SpawnZone = StringExtensionMethods.GetStableHashCode("spawnzone");

		public static readonly int SpawnZoneAshlands = StringExtensionMethods.GetStableHashCode("spawnzoneashlands");

		public static readonly int SpawnZoneBlackForest = StringExtensionMethods.GetStableHashCode("spawnzoneblackforest");

		public static readonly int SpawnZoneDeepNorth = StringExtensionMethods.GetStableHashCode("spawnzonedeepnorth");

		public static readonly int SpawnZoneMeadows = StringExtensionMethods.GetStableHashCode("spawnzonemeadows");

		public static readonly int SpawnZoneMistlands = StringExtensionMethods.GetStableHashCode("spawnzonemistlands");

		public static readonly int SpawnZoneMountain = StringExtensionMethods.GetStableHashCode("spawnzonemountain");

		public static readonly int SpawnZoneOcean = StringExtensionMethods.GetStableHashCode("spawnzoneocean");

		public static readonly int SpawnZonePlains = StringExtensionMethods.GetStableHashCode("spawnzoneplains");

		public static readonly int SpawnZoneSwamp = StringExtensionMethods.GetStableHashCode("spawnzoneswamp");

		public static readonly int SpawnZoneUnknown = StringExtensionMethods.GetStableHashCode("spawnzoneunknown");

		public static readonly int RandomEventSystem = StringExtensionMethods.GetStableHashCode("randomeventsystem");

		public static readonly int EffectAreaPrivateArea = StringExtensionMethods.GetStableHashCode("effectareaprivatearea");

		public static readonly int EffectAreaComfort = StringExtensionMethods.GetStableHashCode("effectareacomfort");

		public static readonly int EffectAreaBurning = StringExtensionMethods.GetStableHashCode("effectareaburning");

		public static readonly int EffectAreaHeat = StringExtensionMethods.GetStableHashCode("effectareaheat");

		public static readonly int EffectAreaFire = StringExtensionMethods.GetStableHashCode("effectareafire");

		public static readonly int EffectAreaNoMonsters = StringExtensionMethods.GetStableHashCode("effectareanomonsters");

		public static readonly int EffectAreaTeleport = StringExtensionMethods.GetStableHashCode("effectareateleport");

		public static readonly int EffectAreaPlayerBase = StringExtensionMethods.GetStableHashCode("effectareaplayerbase");

		public static readonly int EffectAreaOther = StringExtensionMethods.GetStableHashCode("effectareaother");

		public static readonly int EffectAreaCustomContainer = StringExtensionMethods.GetStableHashCode("effectareacustomcontainer");

		public static readonly int EffectAreaCustomCrafting = StringExtensionMethods.GetStableHashCode("effectareacustomcrafting");

		public static readonly int EffectAreaWarmCozy = StringExtensionMethods.GetStableHashCode("effectareawarmcozy");

		public static readonly int Smoke = StringExtensionMethods.GetStableHashCode("smoke");

		public static readonly int PlayerCover = StringExtensionMethods.GetStableHashCode("playercover");

		public static readonly int PlayerCoverBlocked = StringExtensionMethods.GetStableHashCode("playercoverblocked");

		public static readonly int Terrain = StringExtensionMethods.GetStableHashCode("terrain");
	}
	public static class SceneObjects
	{
		public static IEnumerable<T> FindLoaded<T>() where T : MonoBehaviour
		{
			HashSet<int> seen = new HashSet<int>();
			T val = default(T);
			foreach (ZNetView view in EnumerateViews())
			{
				if (!Object.op_Implicit((Object)(object)view))
				{
					continue;
				}
				Scene scene = ((Component)view).gameObject.scene;
				if (!((Scene)(ref scene)).IsValid())
				{
					continue;
				}
				if (((Component)view).TryGetComponent<T>(ref val) && Object.op_Implicit((Object)(object)val) && seen.Add(((Object)(object)val).GetInstanceID()))
				{
					yield return val;
				}
				T[] componentsInChildren = ((Component)view).GetComponentsInChildren<T>(true);
				T[] array = componentsInChildren;
				foreach (T val2 in array)
				{
					if (Object.op_Implicit((Object)(object)val2))
					{
						scene = ((Component)(object)val2).gameObject.scene;
						if (((Scene)(ref scene)).IsValid() && seen.Add(((Object)(object)val2).GetInstanceID()))
						{
							yield return val2;
						}
					}
				}
			}
		}

		private static IEnumerable<ZNetView> EnumerateViews()
		{
			if (!Object.op_Implicit((Object)(object)ZNetScene.instance))
			{
				yield break;
			}
			foreach (KeyValuePair<ZDO, ZNetView> instance in ZNetScene.instance.m_instances)
			{
				ZNetView value = instance.Value;
				if (Object.op_Implicit((Object)(object)value))
				{
					yield return value;
				}
			}
		}
	}
	public class Translate
	{
		public static string Name(string name, string color = "#FFFF00")
		{
			return Format.String(Localization.instance.Localize(name).Replace("(Clone)", ""), color);
		}

		public static string Name(Biome obj, string color = "#FFFF00")
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Name(Enum.GetName(typeof(Biome), obj), color);
		}

		private static string Name(Character obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.m_name;
		}

		public static string Name(ItemData obj, string color = "#FFFF00")
		{
			if (!Object.op_Implicit((Object)(object)obj?.m_dropPrefab))
			{
				return Name(obj?.m_shared?.m_name ?? "");
			}
			return Name(Utils.GetPrefabName(obj?.m_dropPrefab), color);
		}

		private static string Name(Pickable obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			if (!string.IsNullOrEmpty(obj.m_overrideName))
			{
				return obj.m_overrideName;
			}
			GameObject itemPrefab = obj.m_itemPrefab;
			return ((itemPrefab != null) ? ((Object)itemPrefab).name : null) ?? "";
		}

		public static string Name(CreatureSpawner obj)
		{
			if (!Object.op_Implicit((Object)(object)obj) || !Object.op_Implicit((Object)(object)obj.m_creaturePrefab))
			{
				return "";
			}
			return Utils.GetPrefabName(obj.m_creaturePrefab);
		}

		public static string Name(IEnumerable<GameObject> objs, string color = "#FFFF00")
		{
			string color2 = color;
			return Format.JoinRow(objs.Select((GameObject prefab) => Id(prefab, color2)));
		}

		public static string Name(IEnumerable<ItemDrop> objs, string color = "#FFFF00")
		{
			string color2 = color;
			return Format.JoinRow(objs.Select((ItemDrop prefab) => Name((MonoBehaviour)(object)prefab, color2)));
		}

		private static string Name(Bed obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.GetHoverName();
		}

		private static string Name(Piece obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.m_name;
		}

		private static string Name(TreeLog obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return ((Object)obj).name;
		}

		private static string Name(Location obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return ((Object)obj).name;
		}

		private static string Name(MineRock obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.m_name;
		}

		private static string Name(MineRock5 obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.m_name;
		}

		private static string Name(TreeBase obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return ((Object)obj).name;
		}

		private static string Name(Destructible obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return ((Object)obj).name;
		}

		private static string Name(Smoke obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return "Smoke";
		}

		private static string Name(HoverText obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return obj.m_text;
		}

		public static string Name(MonoBehaviour obj, string color = "yellow")
		{
			string text = "";
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<HoverText>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Smoke>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<CreatureSpawner>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Pickable>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Bed>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<TreeLog>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Location>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<MineRock>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<MineRock5>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<TreeBase>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Destructible>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Character>());
			}
			if (text == "")
			{
				text = Name(((Component)obj).GetComponentInParent<Piece>());
			}
			if (text == "")
			{
				text = Id(((Component)obj).gameObject, color);
			}
			return Name(text, color);
		}

		public static string Id(GameObject obj, string color = "yellow")
		{
			ZNetView componentInParent = obj.GetComponentInParent<ZNetView>();
			if (!Object.op_Implicit((Object)(object)componentInParent))
			{
				return Format.String(Utils.GetPrefabName(obj), color);
			}
			return Id(componentInParent, color);
		}

		public static string Id(ZNetView view, string color = "yellow")
		{
			ZDO zDO = view.GetZDO();
			int key = ((zDO != null) ? zDO.GetPrefab() : 0);
			if (ZNetScene.instance.m_namedPrefabs.TryGetValue(key, out var value))
			{
				return Format.String(((Object)value).name, color);
			}
			return "";
		}
	}
	public class Watcher
	{
		public static string BaseDirectory = Paths.ConfigPath;

		public static void SetupWatcher(ConfigFile config)
		{
			ConfigFile config2 = config;
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Path.GetDirectoryName(config2.ConfigFilePath), Path.GetFileName(config2.ConfigFilePath));
			fileSystemWatcher.Changed += delegate(object s, FileSystemEventArgs e)
			{
				ReadConfigValues(e.FullPath, config2);
			};
			fileSystemWatcher.Created += delegate(object s, FileSystemEventArgs e)
			{
				ReadConfigValues(e.FullPath, config2);
			};
			fileSystemWatcher.Renamed += delegate(object s, RenamedEventArgs e)
			{
				ReadConfigValues(e.FullPath, config2);
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private static void ReadConfigValues(string path, ConfigFile config)
		{
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				config.Reload();
			}
			catch
			{
				Log.Error("There was an issue loading your " + config.ConfigFilePath);
				Log.Error("Please check your config entries for spelling and format!");
			}
		}

		public static void SetupWatcher(string pattern, Action<string> action)
		{
			SetupWatcher(Paths.ConfigPath, pattern, action);
		}

		public static void SetupWatcher(string folder, string pattern, Action<string> action)
		{
			Action<string> action2 = action;
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folder, pattern);
			fileSystemWatcher.Created += delegate(object s, FileSystemEventArgs e)
			{
				action2(e.FullPath);
			};
			fileSystemWatcher.Changed += delegate(object s, FileSystemEventArgs e)
			{
				action2(e.FullPath);
			};
			fileSystemWatcher.Renamed += delegate(object s, RenamedEventArgs e)
			{
				action2(e.FullPath);
			};
			fileSystemWatcher.Deleted += delegate(object s, FileSystemEventArgs e)
			{
				action2(e.FullPath);
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public static void SetupWatcher(string folder, string pattern, Action action)
		{
			Action action2 = action;
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folder, pattern);
			fileSystemWatcher.Created += delegate
			{
				action2();
			};
			fileSystemWatcher.Changed += delegate
			{
				action2();
			};
			fileSystemWatcher.Renamed += delegate
			{
				action2();
			};
			fileSystemWatcher.Deleted += delegate
			{
				action2();
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public static void SetupWatcher(string pattern, Action action)
		{
			SetupWatcher(BaseDirectory, pattern, action);
		}
	}
	public class PermissionManager
	{
		private static MethodInfo? isFeatureEnabledByHashMethod;

		public static bool IsVisualFeatureEnabled(int featureHash, bool localConfigValue)
		{
			return IsFeatureEnabled("esp_visuals", featureHash, localConfigValue);
		}

		public static bool IsStatsFeatureEnabled(int featureHash, bool localConfigValue)
		{
			return IsFeatureEnabled("esp_stats", featureHash, localConfigValue);
		}

		public static bool IsHudFeatureEnabled(int featureHash, bool localConfigValue)
		{
			return IsFeatureEnabled("esp_hud", featureHash, localConfigValue);
		}

		private static bool IsFeatureEnabled(string sectionKey, int featureHash, bool localConfigValue)
		{
			if (isFeatureEnabledByHashMethod == null)
			{
				if (localConfigValue)
				{
					if (Object.op_Implicit((Object)(object)ZNet.instance))
					{
						return ZNet.instance.IsServer();
					}
					return true;
				}
				return false;
			}
			return (bool)isFeatureEnabledByHashMethod.Invoke(null, new object[3] { sectionKey, featureHash, localConfigValue });
		}

		public static void SetupSDC(Assembly assembly)
		{
			if (assembly == null)
			{
				return;
			}
			Type type = assembly.GetType("ServerDevcommands.PermissionApi");
			if (type == null)
			{
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "IsFeatureEnabledByHash", (Type[])null, (Type[])null);
			if (!(methodInfo == null))
			{
				isFeatureEnabledByHashMethod = methodInfo;
				MethodInfo methodInfo2 = AccessTools.Method(type, "Subscribe", new Type[1] { typeof(Action) }, (Type[])null);
				if (!(methodInfo2 == null))
				{
					Action action = Visibility.Reload;
					methodInfo2.Invoke(null, new object[1] { action });
				}
			}
		}
	}
}
namespace Data
{
	public class Calculator
	{
		public static Vector3 EvaluateVector3(string expression)
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.x = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.z = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.y = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Vector3 EvaluateVector3(string[] s, int index)
		{
			//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_0065: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.x = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.z = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.y = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Quaternion EvaluateQuaternion(string expression)
		{
			//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_0061: 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)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.y = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.x = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.z = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static Quaternion EvaluateQuaternion(string[] s, int index)
		{
			//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_0065: 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)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.y = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.x = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.z = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static int? EvaluateInt(string expression)
		{
			try
			{
				return (int?)EvaluateLong(expression);
			}
			catch
			{
				return null;
			}
		}

		public static float? EvaluateFloat(string expression)
		{
			try
			{
				return (float)EvaluateDouble(expression);
			}
			catch
			{
				return null;
			}
		}

		private static double EvaluateDouble(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				double num = 0.0;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvaluateDouble(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				double? num2 = null;
				for (int j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvaluateDouble(array3[j])) : new double?(EvaluateDouble(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				double num3 = 1.0;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvaluateDouble(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				double num4 = EvaluateDouble(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvaluateDouble(array5[k]);
				}
				return num4;
			}
			try
			{
				return double.Parse(expression.Trim(), NumberFormatInfo.InvariantInfo);
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}

		public static long? EvaluateLong(string expression)
		{
			try
			{
				return EvalLong(expression);
			}
			catch
			{
				return null;
			}
		}

		private static long EvalLong(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				long num = 0L;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvalLong(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				long? num2 = null;
				for (int j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvalLong(array3[j])) : new long?(EvalLong(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				long num3 = 1L;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvalLong(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				long num4 = EvalLong(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvalLong(array5[k]);
				}
				return num4;
			}
			try
			{
				return long.Parse(expression.Trim());
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}
	}
	public class Parameters
	{
		[CompilerGenerated]
		private string <prefab>P;

		[CompilerGenerated]
		private string <arg>P;

		[CompilerGenerated]
		private Vector3 <pos>P;

		public static Func<string, string?> ExecuteCode = (string key) => null;

		public static Func<string, string, string?> ExecuteCodeWithValue = (string key, string value) => null;

		protected string[]? args;

		private readonly double time;

		public Parameters(string prefab, string arg, Vector3 pos)
		{
			//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)
			<prefab>P = prefab;
			<arg>P = arg;
			<pos>P = pos;
			time = ZNet.instance.GetTimeSeconds();
			base..ctor();
		}

		public string Replace(string str)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < str.Length; i++)
			{
				if (str[i] == '<')
				{
					if (num == 0)
					{
						stringBuilder.Append(str.Substring(num2, i - num2));
						num2 = i;
					}
					num++;
				}
				if (str[i] == '>')
				{
					if (num == 1)
					{
						string str2 = str.Substring(num2, i - num2 + 1);
						stringBuilder.Append(ResolveParameters(str2));
						num2 = i + 1;
					}
					if (num > 0)
					{
						num--;
					}
				}
			}
			if (num2 < str.Length)
			{
				stringBuilder.Append(str.Substring(num2));
			}
			return stringBuilder.ToString();
		}

		private string ResolveParameters(string str)
		{
			int num;
			for (num = 0; num < str.Length; num++)
			{
				int num2 = str.IndexOf(">", num);
				if (num2 == -1)
				{
					break;
				}
				num = num2;
				int num3 = str.LastIndexOf("<", num2);
				if (num3 != -1)
				{
					int num4 = num2 - num3 + 1;
					if (TryReplaceParameter(str.Substring(num3, num4), out string resolved))
					{
						str = str.Remove(num3, num4);
						str = str.Insert(num3, resolved);
						num = num3 - 1;
					}
					else
					{
						num = num2;
					}
				}
			}
			return str;
		}

		private bool TryReplaceParameter(string key, out string resolved)
		{
			resolved = GetParameter(key) ?? key;
			return resolved != key;
		}

		protected virtual string? GetParameter(string key)
		{
			string text = ExecuteCode(key.Substring(1, key.Length - 2));
			if (text != null)
			{
				return text;
			}
			text = GetGeneralParameter(key);
			if (text != null)
			{
				return text;
			}
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(key, '_');
			if (keyValuePair.Value == "")
			{
				return null;
			}
			key = keyValuePair.Key.Substring(1);
			string str = keyValuePair.Value.Substring(0, keyValuePair.Value.Length - 1);
			KeyValuePair<string, string> keyValuePair2 = Parse.Kvp(str, '=');
			str = keyValuePair2.Key;
			string value = keyValuePair2.Value;
			text = ExecuteCodeWithValue(key, str);
			if (text != null)
			{
				return text;
			}
			return GetValueParameter(key, str, value);
		}

		private string? GetGeneralParameter(string key)
		{
			return key switch
			{
				"<prefab>" => <prefab>P, 
				"<par>" => <arg>P, 
				"<par0>" => GetArg(0), 
				"<par1>" => GetArg(1), 
				"<par2>" => GetArg(2), 
				"<par3>" => GetArg(3), 
				"<par4>" => GetArg(4), 
				"<par5>" => GetArg(5), 
				"<par6>" => GetArg(6), 
				"<par7>" => GetArg(7), 
				"<par8>" => GetArg(8), 
				"<par9>" => GetArg(9), 
				"<time>" => Format(time), 
				"<day>" => EnvMan.instance.GetDay(time).ToString(), 
				"<ticks>" => ((long)(time * 10000000.0)).ToString(), 
				"<x>" => Format(<pos>P.x), 
				"<y>" => Format(<pos>P.y), 
				"<z>" => Format(<pos>P.z), 
				"<snap>" => Format(WorldGenerator.instance.GetHeight(<pos>P.x, <pos>P.z)), 
				_ => null, 
			};
		}

		protected virtual string? GetValueParameter(string key, string value, string defaultValue)
		{
			float result;
			float result2;
			float result3;
			float result4;
			float result5;
			float result6;
			float result7;
			float result8;
			float result9;
			float result10;
			KeyValuePair<string, string> kvp;
			float result11;
			float result12;
			float result13;
			KeyValuePair<string, string> kvp2;
			float result14;
			float result15;
			KeyValuePair<string, string> kvp3;
			float result16;
			float result17;
			KeyValuePair<string, string> kvp4;
			float result18;
			float result19;
			KeyValuePair<string, string> kvp5;
			float result20;
			float result21;
			KeyValuePair<string, string> kvp6;
			float result22;
			float result23;
			KeyValuePair<string, string> kvp7;
			float result24;
			float result25;
			KeyValuePair<string, string> kvp8;
			float result26;
			float result27;
			KeyValuePair<string, string> kvp9;
			float result28;
			float result29;
			KeyValuePair<string, string> kvp10;
			int result30;
			int result31;
			int result32;
			int result33;
			return key switch
			{
				"sqrt" => Parse.TryFloat(value, out result) ? Mathf.Sqrt(result).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"round" => Parse.TryFloat(value, out result2) ? Mathf.Round(result2).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"ceil" => Parse.TryFloat(value, out result3) ? Mathf.Ceil(result3).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"floor" => Parse.TryFloat(value, out result4) ? Mathf.Floor(result4).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"abs" => Parse.TryFloat(value, out result5) ? Mathf.Abs(result5).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"sin" => Parse.TryFloat(value, out result6) ? Mathf.Sin(result6).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"cos" => Parse.TryFloat(value, out result7) ? Mathf.Cos(result7).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"tan" => Parse.TryFloat(value, out result8) ? Mathf.Tan(result8).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"asin" => Parse.TryFloat(value, out result9) ? Mathf.Asin(result9).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"acos" => Parse.TryFloat(value, out result10) ? Mathf.Acos(result10).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"atan" => Atan(value, defaultValue), 
				"pow" => (Parse.TryKvp(value, out kvp, '_') && Parse.TryFloat(kvp.Key, out result11) && Parse.TryFloat(kvp.Value, out result12)) ? Mathf.Pow(result11, result12).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"log" => Log(value, defaultValue), 
				"exp" => Parse.TryFloat(value, out result13) ? Mathf.Exp(result13).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"min" => (Parse.TryKvp(value, out kvp2, '_') && Parse.TryFloat(kvp2.Key, out result14) && Parse.TryFloat(kvp2.Value, out result15)) ? Mathf.Min(result14, result15).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"max" => (Parse.TryKvp(value, out kvp3, '_') && Parse.TryFloat(kvp3.Key, out result16) && Parse.TryFloat(kvp3.Value, out result17)) ? Mathf.Max(result16, result17).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"add" => (Parse.TryKvp(value, out kvp4, '_') && Parse.TryFloat(kvp4.Key, out result18) && Parse.TryFloat(kvp4.Value, out result19)) ? (result18 + result19).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"sub" => (Parse.TryKvp(value, out kvp5, '_') && Parse.TryFloat(kvp5.Key, out result20) && Parse.TryFloat(kvp5.Value, out result21)) ? (result20 - result21).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"mul" => (Parse.TryKvp(value, out kvp6, '_') && Parse.TryFloat(kvp6.Key, out result22) && Parse.TryFloat(kvp6.Value, out result23)) ? (result22 * result23).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"div" => (Parse.TryKvp(value, out kvp7, '_') && Parse.TryFloat(kvp7.Key, out result24) && Parse.TryFloat(kvp7.Value, out result25)) ? (result24 / result25).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"mod" => (Parse.TryKvp(value, out kvp8, '_') && Parse.TryFloat(kvp8.Key, out result26) && Parse.TryFloat(kvp8.Value, out result27)) ? (result26 % result27).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"randf" => (Parse.TryKvp(value, out kvp9, '_') && Parse.TryFloat(kvp9.Key, out result28) && Parse.TryFloat(kvp9.Value, out result29)) ? Random.Range(result28, result29).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"randi" => (Parse.TryKvp(value, out kvp10, '_') && Parse.TryInt(kvp10.Key, out result30) && Parse.TryInt(kvp10.Value, out result31)) ? Random.Range(result30, result31).ToString(CultureInfo.InvariantCulture) : defaultValue, 
				"hash" => Hash(value).ToString(), 
				"len" => value.Length.ToString(CultureInfo.InvariantCulture), 
				"lower" => value.ToLowerInvariant(), 
				"upper" => value.ToUpperInvariant(), 
				"trim" => value.Trim(), 
				"calcf" => Calculator.EvaluateFloat(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"calci" => Calculator.EvaluateInt(value)?.ToString(CultureInfo.InvariantCulture) ?? defaultValue, 
				"par" => Parse.TryInt(value, out result32) ? GetArg(result32, defaultValue) : defaultValue, 
				"rest" => Parse.TryInt(value, out result33) ? GetRest(result33, defaultValue) : defaultValue, 
				_ => null, 
			};
		}

		private string GetRest(int index, string defaultValue = "")
		{
			if (args == null)
			{
				args = <arg>P.Split(new char[1] { ' ' });
			}
			if (index < 0 || index >= args.Length)
			{
				return defaultValue;
			}
			return string.Join(" ", args, index, args.Length - index);
		}

		private string Atan(string value, string defaultValue)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '_');
			if (!Parse.TryFloat(keyValuePair.Key, out var result))
			{
				return defaultValue;
			}
			if (keyValuePair.Value == "")
			{
				return Mathf.Atan(result).ToString(CultureInfo.InvariantCulture);
			}
			if (!Parse.TryFloat(keyValuePair.Value, out var result2))
			{
				return defaultValue;
			}
			return Mathf.Atan2(result, result2).ToString(CultureInfo.InvariantCulture);
		}

		private string Log(string value, string defaultValue)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '_');
			if (!Parse.TryFloat(keyValuePair.Key, out var result))
			{
				return defaultValue;
			}
			if (keyValuePair.Value == "")
			{
				return Mathf.Log(result).ToString(CultureInfo.InvariantCulture);
			}
			if (!Parse.TryFloat(keyValuePair.Value, out var result2))
			{
				return defaultValue;
			}
			return Mathf.Log(result, result2).ToString(CultureInfo.InvariantCulture);
		}

		private string GetArg(int index, string defaultValue = "")
		{
			if (args == null)
			{
				args = <arg>P.Split(new char[1] { ' ' });
			}
			if (args.Length > index)
			{
				return args[index];
			}
			return defaultValue;
		}

		protected static string Format(float value)
		{
			return value.ToString("0.#####", NumberFormatInfo.InvariantInfo);
		}

		protected static string Format(double value)
		{
			return value.ToString("0.#####", NumberFormatInfo.InvariantInfo);
		}

		public static string PrintVectorXZY(Vector3 vector)
		{
			return vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.y.ToString("0.##", CultureInfo.InvariantCulture);
		}

		public static string PrintAngleYXZ(Quaternion quaternion)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return PrintVectorYXZ(((Quaternion)(ref quaternion)).eulerAngles);
		}

		private static string PrintVectorYXZ(Vector3 vector)
		{
			return vector.y.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture);
		}

		public static int Hash(string key)
		{
			if (Parse.TryInt(key, out var result))
			{
				return result;
			}
			if (key.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
			{
				int hash = ZSyncAnimation.GetHash(key.Substring(1));
				if (key == "$anim_speed")
				{
					return hash;
				}
				return 438569 + hash;
			}
			return StringExtensionMethods.GetStableHashCode(key);
		}

		public static string GetGlobalKey(string key)
		{
			string lower = key.ToLowerInvariant();
			return ZoneSystem.instance.m_globalKeysValues.FirstOrDefault((KeyValuePair<string, string> kvp) => kvp.Key.ToLowerInvariant() == lower).Value ?? "0";
		}
	}
	public class ObjectParameters : Parameters
	{
		[CompilerGenerated]
		private ZDO <zdo>P;

		private Inventory? inventory;

		public ObjectParameters(string prefab, string arg, ZDO zdo)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			<zdo>P = zdo;
			base..ctor(prefab, arg, <zdo>P.m_position);
		}

		protected override string? GetParameter(string key)
		{
			string parameter = base.GetParameter(key);
			if (parameter != null)
			{
				return parameter;
			}
			parameter = GetGeneralParameter(key);
			if (parameter != null)
			{
				return parameter;
			}
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(key, '_');
			if (keyValuePair.Value == "")
			{
				return null;
			}
			key = keyValuePair.Key.Substring(1);
			string str = keyValuePair.Value.Substring(0, keyValuePair.Value.Length - 1);
			KeyValuePair<string, string> keyValuePair2 = Parse.Kvp(str, '=');
			str = keyValuePair2.Key;
			string value = keyValuePair2.Value;
			parameter = Parameters.ExecuteCodeWithValue(key, str);
			if (parameter != null)
			{
				return parameter;
			}
			parameter = base.GetValueParameter(key, str, value);
			if (parameter != null)
			{
				return parameter;
			}
			return GetValueParameter(key, str, value);
		}

		private string? GetGeneralParameter(string key)
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			return key switch
			{
				"<zdo>" => ((object)(ZDOID)(ref <zdo>P.m_uid)).ToString(), 
				"<pos>" => Parameters.Format(<zdo>P.m_position.x) + "," + Parameters.Format(<zdo>P.m_position.z) + "," + Parameters.Format(<zdo>P.m_position.y), 
				"<i>" => ZoneSystem.GetZone(<zdo>P.m_position).x.ToString(), 
				"<j>" => ZoneSystem.GetZone(<zdo>P.m_position).y.ToString(), 
				"<a>" => Parameters.Format(<zdo>P.m_rotation.y), 
				"<rot>" => Parameters.Format(<zdo>P.m_rotation.y) + "," + Parameters.Format(<zdo>P.m_rotation.x) + "," + Parameters.Format(<zdo>P.m_rotation.z), 
				"<pid>" => GetPid(<zdo>P), 
				"<pname>" => GetPname(<zdo>P), 
				"<pchar>" => GetPchar(<zdo>P), 
				"<owner>" => <zdo>P.GetOwner().ToString(), 
				_ => null, 
			};
		}

		private static string GetPid(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return peer.m_rpc.GetSocket().GetHostName();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return "Server";
			}
			return "";
		}

		private static string GetPname(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return peer.m_playerName;
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return Player.m_localPlayer.GetPlayerName();
			}
			return "";
		}

		private static string GetPchar(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return ((object)(ZDOID)(ref peer.m_characterID)).ToString();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return Player.m_localPlayer.GetPlayerID().ToString();
			}
			return "";
		}

		private static ZNetPeer? GetPeer(ZDO zdo)
		{
			if (zdo.GetOwner() == 0L)
			{
				return null;
			}
			return ZNet.instance.GetPeer(zdo.GetOwner());
		}

		protected override string? GetValueParameter(string key, string value, string defaultValue)
		{
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			switch (key)
			{
			case "key":
				return Parameters.GetGlobalKey(value);
			case "string":
				return GetString(value, defaultValue);
			case "float":
				return GetFloat(value, defaultValue).ToString(CultureInfo.InvariantCulture);
			case "int":
				return GetInt(value, defaultValue).ToString(CultureInfo.InvariantCulture);
			case "long":
				return GetLong(value, defaultValue).ToString(CultureInfo.InvariantCulture);
			case "bool":
				return GetBool(value, defaultValue) ? "true" : "false";
			case "hash":
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(<zdo>P.GetInt(value, 0));
				return ((prefab != null) ? ((Object)prefab).name : null) ?? "";
			}
			case "vec":
				return Parameters.PrintVectorXZY(GetVec3(value, defaultValue));
			case "quat":
				return Parameters.PrintAngleYXZ(GetQuaternion(value, defaultValue));
			case "byte":
				return Convert.ToBase64String(<zdo>P.GetByteArray(value, (byte[])null));
			case "zdo":
			{
				ZDOID zDOID = <zdo>P.GetZDOID(value);
				return ((object)(ZDOID)(ref zDOID)).ToString();
			}
			case "item":
				return GetAmountOfItems(value).ToString();
			case "pos":
				return Parameters.PrintVectorXZY(GetPos(value));
			case "pdata":
				return GetPlayerData(<zdo>P, value);
			default:
				return null;
			}
		}

		private string GetString(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string result = default(string);
			if (!ZDOExtraData.s_strings.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetStringField(value, defaultValue);
			}
			return result;
		}

		private float GetFloat(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			float result = default(float);
			if (!ZDOExtraData.s_floats.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetFloatField(value, defaultValue);
			}
			return result;
		}

		private int GetInt(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			int result = default(int);
			if (!ZDOExtraData.s_ints.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetIntField(value, defaultValue);
			}
			return result;
		}

		private long GetLong(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			long result = default(long);
			if (!ZDOExtraData.s_longs.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetLongField(value, defaultValue);
			}
			return result;
		}

		private bool GetBool(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			if (!ZDOExtraData.s_ints.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref num))
			{
				return GetBoolField(value, defaultValue);
			}
			return num > 0;
		}

		private Vector3 GetVec3(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			if (!ZDOExtraData.s_vec3.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetVecField(value, defaultValue);
			}
			return result;
		}

		private Quaternion GetQuaternion(string value, string defaultValue)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Quaternion result = default(Quaternion);
			if (!ZDOExtraData.s_quats.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(Parameters.Hash(value), ref result))
			{
				return GetQuatField(value, defaultValue);
			}
			return result;
		}

		private string GetStringField(string value, string defaultValue)
		{
			if (!(GetField(value) is string result))
			{
				return defaultValue;
			}
			return result;
		}

		private float GetFloatField(string value, string defaultValue)
		{
			object field = GetField(value);
			if (field is float)
			{
				return (float)field;
			}
			return Parse.Float(defaultValue);
		}

		private int GetIntField(string value, string defaultValue)
		{
			object field = GetField(value);
			if (field is int)
			{
				return (int)field;
			}
			return Parse.Int(defaultValue);
		}

		private bool GetBoolField(string value, string defaultValue)
		{
			object field = GetField(value);
			if (field is bool)
			{
				return (bool)field;
			}
			return Parse.Boolean(defaultValue);
		}

		private long GetLongField(string value, string defaultValue)
		{
			object field = GetField(value);
			if (field is long)
			{
				return (long)field;
			}
			return Parse.Long(defaultValue, 0L);
		}

		private Vector3 GetVecField(string value, string defaultValue)
		{
			//IL_001a: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			object field = GetField(value);
			if (field is Vector3)
			{
				return (Vector3)field;
			}
			return Parse.VectorXZY(defaultValue);
		}

		private Quaternion GetQuatField(string value, string defaultValue)
		{
			//IL_001a: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			object field = GetField(value);
			if (field is Quaternion)
			{
				return (Quaternion)field;
			}
			return Parse.AngleYXZ(defaultValue);
		}

		private object? GetField(string value)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '.');
			if (keyValuePair.Value == "")
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(<zdo>P.m_prefab);
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			Component component = prefab.GetComponent(keyValuePair.Key);
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			string[] array = keyValuePair.Value.Split(new char[1] { '.' });
			object obj = component;
			string[] array2 = array;
			foreach (string name in array2)
			{
				FieldInfo field = obj.GetType().GetField(name);
				if (field == null)
				{
					return null;
				}
				obj = field.GetValue(obj);
				if (obj == null)
				{
					return null;
				}
			}
			return obj;
		}

		private int GetAmountOfItems(string prefab)
		{
			LoadInventory();
			if (inventory == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData item in inventory.m_inventory)
			{
				GameObject dropPrefab = item.m_dropPrefab;
				if ((((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? item.m_shared.m_name) == prefab)
				{
					num += item.m_stack;
				}
			}
			return num;
		}

		private void LoadInventory()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if (inventory == null)
			{
				string @string = <zdo>P.GetString(ZDOVars.s_items, "");
				if (!(@string == ""))
				{
					inventory = new Inventory("", (Sprite)null, 4, 2);
					inventory.Load(new ZPackage(@string));
				}
			}
		}

		private Vector3 GetPos(string value)
		{
			//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_000d: 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_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)
			Vector3 val = Parse.VectorXZY(value);
			return <zdo>P.GetPosition() + <zdo>P.GetRotation() * val;
		}

		public static string GetPlayerData(ZDO zdo, string key)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				if (!peer.m_serverSyncedPlayerData.TryGetValue(key, out var value))
				{
					return "";
				}
				return value;
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				if (!ZNet.instance.m_serverSyncedPlayerData.TryGetValue(key, out var value2))
				{
					return "";
				}
				return value2;
			}
			return "";
		}
	}
	public class PrefabHelper
	{
		private static readonly Dictionary<string, List<int>> ResultCache = new Dictionary<string, List<int>>();

		private static readonly Dictionary<int, List<int>> Groups = new Dictionary<int, List<int>>();

		private static readonly int WearNTearHash = StringExtensionMethods.GetStableHashCode("wearntear");

		private static readonly int HumanoidHash = StringExtensionMethods.GetStableHashCode("humanoid");

		private static readonly int CreatureHash = StringExtensionMethods.GetStableHashCode("creature");

		private static readonly int StructureHash = StringExtensionMethods.GetStableHashCode("structure");

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

		public static int? GetPrefab(string value)
		{
			List<int> prefabs = GetPrefabs(value);
			if (prefabs.Count == 0)
			{
				return null;
			}
			if (prefabs.Count == 1)
			{
				return prefabs[0];
			}
			return prefabs[Random.Range(0, prefabs.Count)];
		}

		public static void ClearCache()
		{
			ResultCache.Clear();
			PrefabCache.Clear();
			LoadGroups();
		}

		private static void LoadGroups()
		{
			if (Groups.Count > 0)
			{
				return;
			}
			foreach (KeyValuePair<int, GameObject> namedPrefab in ZNetScene.instance.m_namedPrefabs)
			{
				if (!Object.op_Implicit((Object)(object)namedPrefab.Value))
				{
					continue;
				}
				namedPrefab.Value.GetComponentsInChildren<MonoBehaviour>(ZNetView.m_tempComponents);
				foreach (MonoBehaviour tempComponent in ZNetView.m_tempComponents)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((object)tempComponent).GetType().Name.ToLowerInvariant());
					if (!Groups.ContainsKey(stableHashCode))
					{
						Groups[stableHashCode] = new List<int>();
					}
					Groups[stableHashCode].Add(namedPrefab.Key);
				}
			}
			Groups[CreatureHash] = Groups[HumanoidHash];
			Groups[StructureHash] = Groups[WearNTearHash];
		}

		public static List<int> GetPrefabs(string value)
		{
			if (ResultCache.ContainsKey(value))
			{
				return ResultCache[value];
			}
			List<int> prefabs = GetPrefabs(Parse.ToList(value));
			if (prefabs == null)
			{
				return new List<int>();
			}
			ResultCache[value] = prefabs;
			return prefabs;
		}

		public static List<int>? GetPrefabs(List<string> values)
		{
			if (values.Count == 0)
			{
				return null;
			}
			if (values.Count == 1)
			{
				return ParsePrefabs(values[0]);
			}
			List<List<int>> list = (from s in values.Select(ParsePrefabs)
				where s != null
				select s).ToList();
			HashSet<int> hashSet = new HashSet<int>();
			foreach (List<int> item in list)
			{
				if (item == null)
				{
					continue;
				}
				foreach (int item2 in item)
				{
					hashSet.Add(item2);
				}
			}
			if (hashSet.Count != 0)
			{
				HashSet<int> hashSet2 = hashSet;
				List<int> list2 = new List<int>(hashSet2.Count);
				list2.AddRange(hashSet2);
				return list2;
			}
			return null;
		}

		private static List<int>? ParsePrefabs(string prefab)
		{
			string p = prefab.ToLowerInvariant();
			if (PrefabCache.Count == 0)
			{
				PrefabCache = ZNetScene.instance.m_namedPrefabs.ToDictionary((KeyValuePair<int, GameObject> pair) => ((Object)pair.Value).name, (KeyValuePair<int, GameObject> pair) => pair.Key);
			}
			if (p == "*")
			{
				Dictionary<string, int>.ValueCollection values = PrefabCache.Values;
				List<int> list = new List<int>(values.Count);
				list.AddRange(values);
				return list;
			}
			if (p[0] == '*' && p[p.Length - 1] == '*')
			{
				p = p.Substring(1, p.Length - 2);
				return (from pair in PrefabCache
					where pair.Key.ToLowerInvariant().Contains(p)
					select pair.Value).ToList();
			}
			if (p[0] == '*')
			{
				p = p.Substring(1);
				return (from pair in PrefabCache
					where pair.Key.EndsWith(p, StringComparison.OrdinalIgnoreCase)
					select pair.Value).ToList();
			}
			if (p[p.Length - 1] == '*')
			{
				p = p.Substring(0, p.Length - 1);
				return (from pair in PrefabCache
					where pair.Key.StartsWith(p, StringComparison.OrdinalIgnoreCase)
					select pair.Value).ToList();
			}
			if (PrefabCache.ContainsKey(prefab))
			{
				return new List<int>(1) { PrefabCache[prefab] };
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(p);
			if (Groups.ContainsKey(stableHashCode))
			{
				return Groups[stableHashCode];
			}
			Log.Warning("Failed to resolve prefab: " + prefab);
			return null;
		}
	}
}
namespace ESP
{
	[BepInPlugin("esp", "ESP", "1.35")]
	public class ESP : BaseUnityPlugin
	{
		private const string GUID = "esp";

		private const string NAME = "ESP";

		private const string VERSION = "1.35";

		public void Awake()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			Log.Init(((BaseUnityPlugin)this).Logger);
			Settings.Init(((BaseUnityPlugin)this).Config);
			MessageHud_UpdateMessage.GetMessage = Hud.GetMessage;
			new Harmony("esp").PatchAll();
			Draw.Init();
			try
			{
				FormatLoading.SetupWatcher();
				Watcher.SetupWatcher(((BaseUnityPlugin)this).Config);
			}
			catch (Exception ex)
			{
				Log.Error(ex.StackTrace);
			}
		}

		public void Start()
		{
			if (Chainloader.PluginInfos.TryGetValue("org.bepinex.plugins.jewelcrafting", out var value))
			{
				JewelcraftingPatcher.DoPatching(((object)value.Instance).GetType().Assembly);
			}
			if (Chainloader.PluginInfos.TryGetValue("server_devcommands", out value))
			{
				PermissionManager.SetupSDC(((object)value.Instance).GetType().Assembly);
			}
		}

		public void LateUpdate()
		{
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				Texts.UpdateAverageSpeed(Ship.GetLocalShip());
			}
			global::Visualization.Visualization.SharedUpdate();
		}
	}
	[HarmonyPatch(typeof(Player), "SetupPlacementGhost")]
	[HarmonyPriority(0)]
	public class PlayerCleanGhost
	{
		private static void Postfix(Player __instance)
		{
			if (!Settings.IsDisabled("EffectAreaPlayerBase"))
			{
				GameObject placementGhost = __instance.m_placementGhost;
				if (Object.op_Implicit((Object)(object)placementGhost))
				{
					Object.DestroyImmediate((Object)(object)placementGhost.GetComponentInChildren<CircleRuler>(true));
				}
			}
		}
	}
	public class FormatLoading
	{
		private static readonly string GamePath = Path.GetFullPath(Path.Combine("BepInEx", "config"));

		private static readonly string ProfilePath = Path.GetFullPath(Paths.ConfigPath);

		public static Dictionary<string, Dictionary<int, List<string>>> Data = new Dictionary<string, Dictionary<int, List<string>>>();

		public static readonly Dictionary<int, List<string>> ValueGroups = new Dictionary<int, List<string>>();

		public static string Pattern = "esp*.yaml";

		public static List<string> Keys
		{
			get
			{
				Dictionary<string, Dictionary<int, List<string>>>.KeyCollection keys = Data.Keys;
				List<string> list = new List<string>(keys.Count);
				list.AddRange(keys);
				return list;
			}
		}

		public static List<string>? Get(string file, int prefab)
		{
			if (Data.ContainsKey(file))
			{
				if (!Data[file].TryGetValue(prefab, out List<string> value))
				{
					return null;
				}
				return value;
			}
			string text = file.ToLowerInvariant();
			if (file != text)
			{
				Settings.configCustom.Value = text;
				return Get(text, prefab);
			}
			if (!Data.TryGetValue("", out Dictionary<int, List<string>> value2))
			{
				return null;
			}
			if (!value2.TryGetValue(prefab, out var value3))
			{
				return null;
			}
			return value3;
		}

		public static void LoadEntries()
		{
			PrefabHelper.ClearCache();
			_ = Data;
			Data = new Dictionary<string, Dictionary<int, List<string>>>();
			foreach (KeyValuePair<string, Dictionary<string, List<string>>> item in Read(Directory.GetFiles(GamePath, "esp*.yaml").Concat(Directory.GetFiles(ProfilePath, "esp*.yaml")).Select(Path.GetFullPath)
				.Distinct()
				.ToList()))
			{
				LoadEntry(item.Key, item.Value);
			}
			Log.Info($"Loaded {Data.Count} format files.");
		}

		private static Dictionary<string, Dictionary<string, List<string>>> Read(List<string> files)
		{
			Dictionary<string, Dictionary<string, List<string>>> dictionary = new Dictionary<string, Dictionary<string, List<string>>>();
			foreach (string file in files)
			{
				Dictionary<string, List<string>> dictionary2 = new Dictionary<string, List<string>>();
				dictionary[Path.GetFileNameWithoutExtension(file)] = dictionary2;
				try
				{
					string[] array = File.ReadAllLines(file);
					string text = "";
					int num = 0;
					string[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						string text2 = array2[i].Trim();
						if (text2.Length == 0 || text2[0] == '#')
						{
							continue;
						}
						if (text2.EndsWith(":", StringComparison.Ordinal))
						{
							text = text2.Substring(0, text2.Length - 1).Trim();
							if (text == "\"*\"")
							{
								text = "*";
							}
							if (!dictionary2.ContainsKey(text))
							{
								dictionary2[text] = new List<string>();
							}
							continue;
						}
						if (text == "")
						{
							Log.Error($"Failed to read {Path.GetFileName(file)}, missing key on row {num}");
							break;
						}
						if (text2.StartsWith("- ", StringComparison.Ordinal))
						{
							string item = text2.Substring(2);
							dictionary2[text].Add(item);
						}
						else if (text2.StartsWith("-", StringComparison.Ordinal))
						{
							string item2 = text2.Substring(1);
							dictionary2[text].Add(item2);
						}
						else
						{
							Log.Error($"Failed to read {Path.GetFileName(file)}, invalid row {num}");
						}
					}
				}
				catch (Exception ex)
				{
					Log.Error("Failed to read " + Path.GetFileName(file) + ": " + ex.Message);
				}
			}
			return dictionary;
		}

		private static void LoadEntry(string file, Dictionary<string, List<string>> data)
		{
			string key = ((file.Length > 3 && file[3] == '_') ? file.Substring(4) : file.Substring(3)).ToLowerInvariant();
			if (Data.ContainsKey(key))
			{
				Log.Warning("Duplicate format file: " + file);
			}
			if (!Data.ContainsKey(key))
			{
				Data[key] = new Dictionary<int, List<string>>();
			}
			Dictionary<int, List<string>> dictionary = Data[key];
			foreach (KeyValuePair<string, List<string>> datum in data)
			{
				List<int> prefabs = PrefabHelper.GetPrefabs(datum.Key);
				if (prefabs == null)
				{
					continue;
				}
				foreach (int item in prefabs)
				{
					if (!dictionary.ContainsKey(item))
					{
						dictionary[item] = new List<string>();
					}
					dictionary[item].AddRange(datum.Value);
				}
			}
		}

		public static void SetupWatcher()
		{
			if (!Directory.Exists(GamePath))
			{
				Directory.CreateDirectory(GamePath);
			}
			if (!Directory.Exists(ProfilePath))
			{
				Directory.CreateDirectory(ProfilePath);
			}
			Watcher.SetupWatcher(GamePath, Pattern, LoadEntries);
			if (GamePath != ProfilePath)
			{
				Watcher.SetupWatcher(ProfilePath, Pattern, LoadEntries);
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Start")]
	[HarmonyPriority(100)]
	public class InitializeContent
	{
		private static void Postfix()
		{
			FormatLoading.LoadEntries();
		}
	}
	public class CustomHoverText : MonoBehaviour, Hoverable
	{
		private string title = "";

		public string GetHoverText()
		{
			string __result = "";
			Text.AddTexts(((Component)this).gameObject, ref __result);
			if (__result == "")
			{
				return "";
			}
			return GetHoverName() + __result;
		}

		public string GetHoverName()
		{
			if (title == "")
			{
				title = Translate.Name((MonoBehaviour)(object)this);
			}
			return title;
		}
	}
	public class Text
	{
		public static void AddText(GameObject obj)
		{
			obj.AddComponent<CustomHoverText>();
		}

		public static void AddText(GameObject obj, string text)
		{
			obj.AddComponent<HoverText>().m_text = text;
		}

		public static void AddHoverText(MonoBehaviour obj)
		{
			if (((Component)obj).gameObject.GetComponent<Hoverable>() == null)
			{
				((Component)obj).gameObject.AddComponent<CustomHoverText>();
			}
		}

		public static void AddTexts(GameObject obj, ref string __result)
		{
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ExtraInfo)
			{
				return;
			}
			ZNetView componentInParent = obj.GetComponentInParent<ZNetView>();
			if (!Object.op_Implicit((Object)(object)componentInParent) || !componentInParent.IsValid())
			{
				return;
			}
			List<string> list = new List<string>();
			Character componentInParent2 = obj.GetComponentInParent<Character>();
			BaseAI componentInParent3 = obj.GetComponentInParent<BaseAI>();
			string text = Texts.Get("", componentInParent.GetZDO());
			if (!Settings.CustomOnly || text == "")
			{
				list.Add("Id: " + Translate.Id(componentInParent));
			}
			list.Add(text);
			if (!Settings.CustomOnly || text == "")
			{
				list.Add(Texts.Get(obj.GetComponentInParent<TreeLog>()));
				list.Add(Texts.Get(obj.GetComponentInParent<TreeBase>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Destructible>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Pickable>()));
				list.Add(Texts.Get(obj.GetComponentInParent<CreatureSpawner>()));
				list.Add(Texts.Get(obj.GetComponentInParent<CraftingStation>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Beehive>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Bed>()));
				list.Add(Texts.Get(obj.GetComponentInParent<CookingStation>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Fermenter>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Fireplace>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Smelter>()));
				list.Add(Texts.Get(obj.GetComponentInParent<WearNTear>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Piece>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Plant>()));
				list.Add(Texts.Get(obj.GetComponentInParent<PrivateArea>()));
				list.Add(Texts.Get(obj.GetComponentInParent<MineRock>()));
				list.Add(Texts.Get(obj.GetComponentInParent<MineRock5>()));
				list.Add(Texts.Get(obj.GetComponentInParent<DropOnDestroyed>()));
				list.Add(Texts.Get(obj.GetComponentInParent<ItemDrop>()));
				list.Add(Texts.Get(obj.GetComponentInParent<SmokeSpawner>()));
				list.Add(Texts.Get(obj.GetComponentInChildren<SmokeSpawner>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Smoke>()));
				list.Add(Texts.Get(obj.GetComponentInParent<Container>()));
				list.Add(Texts.Get(obj.GetComponentInParent<LocationProxy>()));
				list.Add(Texts.Get(obj.GetComponentInParent<RandomSpawn>()));
				list.Add(Texts.Get(obj.GetComponentInParent<SpawnArea>()));
				list.Add(Texts.Get(obj.GetComponentInParent<OfferingBowl>()));
				list.Add(Texts.GetVegetation(obj));
				if (Settings.Ships)
				{
					list.Add(Texts.Get(obj.GetComponentInParent<Ship>()));
				}
				list.Add(Texts.Get(obj.GetComponentInParent<EffectArea>()));
				list.Add(Texts.Get(componentInParent2, componentInParent3, obj.GetComponentInParent<MonsterAI>()));
				list.Add(Texts.GetStatusStats(componentInParent2));
				list.Add(Texts.Get(obj.GetComponentInParent<Tameable>()));
				list.Add(Texts.Get(obj.GetComponentInParent<CharacterDrop>(), componentInParent2));
				list.Add(Texts.Get(componentInParent3, obj.GetComponentInParent<Growup>()));
				if (Object.op_Implicit((Object)(object)obj.GetComponentInParent<BaseAI>()))
				{
					list.Add(Texts.GetAttack(obj.GetComponentInParent<Humanoid>()));
				}
				list.Add("Coordinates: " + Format.Coordinates(obj.transform.position));
			}
			__result = __result + "\n" + Format.JoinLines(list);
		}

		public static string GetLevel(int min, int max, double chance, double limit = 0.0)
		{
			min--;
			max--;
			string text = Format.Range(min, max);
			string text2 = (text.Contains("-") ? (" (" + Format.Percent(chance / 100.0) + " per star)") : "");
			string text3 = ((limit > 0.0) ? (" after " + Format.Int(limit) + " meters") : "");
			return "Stars: " + text + text2 + text3;
		}

		public static string GetAttempt(double time, double limit, double chance)
		{
			return Format.ProgressPercent("Attempt", time, limit) + ", " + Format.Percent(chance / 100.0) + " chance";
		}

		public static string GetGlobalKeys(List<string> required, List<string> notRequired)
		{
			required = required.Select((string key) => Format.String(key, ZoneSystem.instance.GetGlobalKey(key))).ToList();
			notRequired = notRequired.Select((string key) => Format.String("not " + key, !ZoneSystem.instance.GetGlobalKey(key))).ToList();
			return Format.JoinRow(required.Concat(notRequired));
		}

		public static string GetHealth(double health, double limit)
		{
			if (health > 10000000000.0)
			{
				return "Health: Infinite/" + Format.Int(limit);
			}
			return "Health: " + Format.Progress(health, limit) + " (" + Format.Percent(health / limit) + ")";
		}

		public static string Radius(float radius)
		{
			return "Radius: " + Format.Float(radius);
		}
	}
	[HarmonyPatch(typeof(HoverText), "GetHoverText")]
	public class HoverText_GetHoverText
	{
		private static void Postfix(HoverText __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(SpawnArea), "Awake")]
	[HarmonyPriority(0)]
	public class SpawnArea_Awake_AddHover
	{
		private static void Postfix(SpawnArea __instance)
		{
			Text.AddHoverText((MonoBehaviour)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(Destructible), "Awake")]
	[HarmonyPriority(0)]
	public class Destructible_Awake_AddHover
	{
		private static void Postfix(Destructible __instance)
		{
			Text.AddHoverText((MonoBehaviour)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Awake")]
	[HarmonyPriority(0)]
	public class WearNTear_Awake_AddHover
	{
		private static void Postfix(WearNTear __instance)
		{
			Text.AddHoverText((MonoBehaviour)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(Beehive), "GetHoverText")]
	public class Beehive_GetHoverText
	{
		private static void Postfix(Beehive __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(ItemDrop), "GetHoverText")]
	public class ItemDrop_GetHoverText
	{
		private static void Postfix(Beehive __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(OfferingBowl), "GetHoverText")]
	public class OfferingBowl_GetHoverText
	{
		private static void Postfix(OfferingBowl __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Chair), "GetHoverText")]
	public class Chair_GetHoverText
	{
		private static void Postfix(Chair __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Container), "GetHoverText")]
	public class Container_GetHoverText
	{
		private static void Postfix(Container __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(CookingStation), "GetHoverText")]
	public class CookingStation_GetHoverText
	{
		private static void Postfix(CookingStation __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "GetHoverText")]
	public class CraftingStation_GetHoverText
	{
		private static void Postfix(CraftingStation __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Bed), "GetHoverText")]
	public class Bed_GetHoverText
	{
		private static void Postfix(Bed __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Door), "GetHoverText")]
	public class Door_GetHoverText
	{
		private static void Postfix(Door __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Fermenter), "GetHoverText")]
	public class Fermenter_GetHoverText
	{
		private static void Postfix(Fermenter __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Fireplace), "GetHoverText")]
	public class Fireplace_GetHoverText
	{
		private static void Postfix(Fireplace __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(MineRock), "GetHoverText")]
	public class MineRock_GetHoverText
	{
		private static void Postfix(MineRock __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(MineRock5), "GetHoverText")]
	public class MineRock5_GetHoverText
	{
		private static void Postfix(MineRock5 __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Pickable), "GetHoverText")]
	public class Pickable_GetHoverText
	{
		private static void Postfix(Pickable __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Plant), "GetHoverText")]
	public class Plant_GetHoverText
	{
		private static void Postfix(Plant __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "GetHoverText")]
	public class PrivateArea_GetHoverText
	{
		private static void Postfix(PrivateArea __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Sign), "GetHoverText")]
	public class Sign_GetHoverText
	{
		private static void Postfix(Sign __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(ItemStand), "GetHoverText")]
	public class ItemStand_GetHoverText
	{
		private static void Postfix(ItemStand __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(StationExtension), "GetHoverText")]
	public class StationExtension_GetHoverText
	{
		private static void Postfix(StationExtension __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Vagon), "GetHoverText")]
	public class Vagon_GetHoverText
	{
		private static void Postfix(Vagon __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(TeleportWorld), "GetHoverText")]
	public class TeleportWorld_GetHoverText
	{
		private static void Postfix(TeleportWorld __instance, ref string __result)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref __result);
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnHoverAddOre")]
	public class OnHoverAddOre
	{
		private static string Postfix(string result, Smelter __instance)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref result);
			return result;
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnHoverAddFuel")]
	public class OnHoverAddFuel
	{
		private static string Postfix(string result, Smelter __instance)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref result);
			return result;
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnHoverEmptyOre")]
	public class OnHoverEmptyOre
	{
		private static string Postfix(string result, Smelter __instance)
		{
			Text.AddTexts(((Component)__instance).gameObject, ref result);
			return result;
		}
	}
	public class Settings
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__RefreshColors;

			public static ConsoleOptionsFetcher <1>__OptionsFetcher;

			public static Action <2>__RebuildLoaded;

			public static Action <3>__RebuildLoaded;

			public static Action <4>__RebuildLoaded;

			public static Action <5>__RebuildLoaded;

			public static Action <6>__UpdateVisibility;

			public static Action <7>__RebuildLoaded;

			public static Action <8>__RebuildLoaded;

			public static Action <9>__RebuildLoaded;

			public static Action <10>__RebuildLoaded;

			public static Action <11>__RebuildLoaded;

			public static Action <12>__RebuildLoaded;

			public static Action <13>__RebuildLoaded;

			public static Action <14>__RebuildLoaded;

			public static Action <15>__RebuildLoaded;

			public static Action <16>__RebuildLoaded;

			public static Action <17>__RebuildLoaded;

			public static Action <18>__RebuildLoaded;

			public static Action <19>__RebuildLoaded;

			public static Action <20>__RebuildLoaded;

			public static Action <21>__RebuildLoaded;

			public static Action <22>__RebuildLoaded;

			public static Action <23>__RebuildLoaded;

			public static Action <24>__RebuildLoaded;

			public static Action <25>__RebuildLoaded;

			public static Action <26>__RebuildLoaded;

			public static Action <27>__RebuildLoaded;
		}

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

			public static EventHandler <>9__120_0;

			public static ConsoleEvent <>9__122_0;

			public static ConsoleEvent <>9__122_1;

			public static ConsoleEvent <>9__122_2;

			public static ConsoleEvent <>9__122_3;

			public static ConsoleEvent <>9__122_4;

			public static ConsoleEvent <>9__122_5;

			public static ConsoleEvent <>9__122_6;

			public static ConsoleOptionsFetcher <>9__122_7;

			public static ConsoleEvent <>9__122_8;

			public static ConsoleEvent <>9__122_9;

			public static Func<string, bool> <>9__123_0;

			public static EventHandler <>9__241_0;

			public static EventHandler <>9__241_1;

			internal void <InitHUD>b__120_0(object s, EventArgs e)
			{
				Draw.SetShader(configShader.Value);
			}

			internal void <InitCommands>b__122_0(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					args.Context.AddString("Missing name.");
					return;
				}
				List<string> list = args[1].Split(new char[1] { ' ' }).ToList();
				if (args[1] == "*")
				{
					list = OptionsFetcher();
				}
				foreach (string item in list)
				{
					SetEntry(item, value: true);
				}
			}

			internal void <InitCommands>b__122_1(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					args.Context.AddString("Missing name.");
					return;
				}
				List<string> list = args[1].Split(new char[1] { ' ' }).ToList();
				if (args[1] == "*")
				{
					list = OptionsFetcher();
				}
				foreach (string item in list)
				{
					ToggleEntry(item);
				}
			}

			internal void <InitCommands>b__122_2(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					args.Context.AddString("Missing name.");
					return;
				}
				List<string> list = args[1].Split(new char[1] { ' ' }).ToList();
				if (args[1] == "*")
				{
					list = OptionsFetcher();
				}
				foreach (string item in list)
				{
					SetEntry(item, value: false);
				}
			}

			internal void <InitCommands>b__122_3(ConsoleEventArgs args)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Vector3 position = ((Component)Player.m_localPlayer).transform.position;
					float radius = args.TryParameterFloat(1, 10f);
					Visual.DrawHeightmap(position, radius);
				}
			}

			internal void <InitCommands>b__122_4(ConsoleEventArgs args)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					Vector3 position = ((Component)Player.m_localPlayer).transform.position;
					float radius = args.TryParameterFloat(1, 10f);
					Visual.DrawPaintmap(position, radius);
				}
			}

			internal void <InitCommands>b__122_5(ConsoleEventArgs args)
			{
				//IL_008d: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)Player.m_localPlayer))
				{
					return;
				}
				if (args.Length < 2)
				{
					args.Context.AddString("Missing coordinates.");
					return;
				}
				string[] array = args[1].Split(new char[1] { ',' });
				if (array.Length < 2)
				{
					args.Context.AddString("Invalid coordinates.");
					return;
				}
				if (!float.TryParse(array[0], out var result) || !float.TryParse(array[1], out var result2))
				{
					args.Context.AddString("Invalid coordinates.");
					return;
				}
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(result, 0f, result2);
				Heightmap val2 = Heightmap.FindHeightmap(val);
				if (!Object.op_Implicit((Object)(object)val2))
				{
					args.Context.AddString("No heightmap found.");
					return;
				}
				float vegetationMask = val2.GetVegetationMask(val);
				bool flag = val2.IsLava(val, 0.6f);
				bool flag2 = val2.IsCultivated(val);
				bool flag3 = val2.IsCleared(val);
				args.Context.AddString($"Vegetation: {vegetationMask:F4}, Lava: {flag}, Cultivated: {flag2}, Cleared: {flag3}");
			}

			internal void <InitCommands>b__122_6(ConsoleEventArgs args)
			{
				if (args.Length < 2)
				{
					args.Context.AddString("Missing file.");
				}
				else if (!FormatLoading.Keys.Contains(args[1]))
				{
					args.Context.AddString("Invalid file.");
				}
				else
				{
					configCustom.Value = args[1];
				}
			}

			internal List<string> <InitCommands>b__122_7()
			{
				return FormatLoading.Keys;
			}

			internal void <InitCommands>b__122_8(ConsoleEventArgs args)
			{
				int num = FormatLoading.Keys.IndexOf(configCustom.Value);
				num = ((num >= 0) ? ((num != 0) ? (num - 1) : (FormatLoading.Keys.Count - 1)) : 0);
				configCustom.Value = FormatLoading.Keys[num];
			}

			internal void <InitCommands>b__122_9(ConsoleEventArgs args)
			{
				int num = FormatLoading.Keys.IndexOf(configCustom.Value);
				num = ((num >= 0) ? ((num != FormatLoading.Keys.Count - 1) ? (num + 1) : 0) : 0);
				configCustom.Value = FormatLoading.Keys[num];
			}

			internal bool <OptionsFetcher>b__123_0(string tag)
			{
				if (!tag.StartsWith("ZoneCorner") && !tag.StartsWith("SpawnZone"))
				{
					return !tag.StartsWith("Terrain");
				}
				return false;
			}

			internal void <InitVisuals>b__241_0(object s, EventArgs e)
			{
				SupportUtils.UpdateVisibility();
			}

			internal void <InitVisuals>b__241_1(object s, EventArgs e)
			{
				BaseRuler.Visible = configShowSpawnSuppression.Value;
			}
		}

		public static ConfigEntry<string> configCreatureCollidersColor;

		public static ConfigEntry<string> configStructureCollidersColor;

		public static ConfigEntry<string> configDestructibleCollidersColor;

		public static ConfigEntry<string> configAttackRayColor;

		public static ConfigEntry<string> configCreatureRayColor;

		public static ConfigEntry<string> configPickableOneTimeColor;

		public static ConfigEntry<string> configPickableRespawningColor;

		public static ConfigEntry<string> configLocationRayColor;

		public static ConfigEntry<string> configEventZoneRayColor;

		public static ConfigEntry<string> configChestRayColor;

		public static ConfigEntry<string> configOreRayColor;

		public static ConfigEntry<string> configTreeRayColor;

		public static ConfigEntry<string> configTrophySpeakColor;

		public static ConfigEntry<string> configDestructibleRayColor;

		public static ConfigEntry<string> configSpawnPointOneTimeColor;

		public static ConfigEntry<string> configSpawnPointRespawningColor;

		public static ConfigEntry<string> configNoiseColor;

		public static ConfigEntry<string> configCoverRayColor;

		public static ConfigEntry<string> configCoverRayBlockedColor;

		public static ConfigEntry<string> configCreatureHearColor;

		public static ConfigEntry<string> configCreatureViewColor;

		public static ConfigEntry<string> configCreatureAlertViewColor;

		public static ConfigEntry<string> configCreatureFireLimitColor;

		public static ConfigEntry<string> configCreatureTotalLimitColor;

		public static ConfigEntry<string> configCreaturePartnerCheckColor;

		public static ConfigEntry<string> configCreatureFoodCheckColor;

		public static ConfigEntry<string> configCreatureEatRangeColor;

		public static ConfigEntry<string> configSpawnerRayColor;

		public static ConfigEntry<string> configSpawnerTriggerColor;

		public static ConfigEntry<string> configSpawnerNearColor;

		public static ConfigEntry<string> configSpawnerSpawnColor;

		public static ConfigEntry<string> configAltarRayColor;

		public static ConfigEntry<string> configAltarItemStandRangeColor;

		public static ConfigEntry<string> configAltarSpawnRadiusColor;

		public static ConfigEntry<string> configEffectAreaPrivateAreaColor;

		public static ConfigEntry<string> configEffectAreaPlayerBaseColor;

		public static ConfigEntry<string> configEffectAreaComfortColor;

		public static ConfigEntry<string> configEffectAreaBurningColor;

		public static ConfigEntry<string> configEffectAreaHeatColor;

		public static ConfigEntry<string> configEffectAreaFireColor;

		public static ConfigEntry<string> configEffectAreaNoMonstersColor;

		public static ConfigEntry<string> configEffectAreaTeleportColor;

		public static ConfigEntry<string> configEffectAreaOtherColor;

		public static ConfigEntry<string> configEffectAreaWarmCozyColor;

		public static ConfigEntry<string> configEffectAreaCustomContainerColor;

		public static ConfigEntry<string> configEffectAreaCustomCraftingColor;

		public static ConfigEntry<string> configSmokeColor;

		public static ConfigEntry<string> configRandomEventSystemRayColor;

		public static ConfigEntry<string> configBiomeAshlandsColor;

		public static ConfigEntry<string> configBiomeBlackForestColor;

		public static ConfigEntry<string> configBiomeDeepNorthColor;

		public static ConfigEntry<string> configBiomeMeadowsColor;

		public static ConfigEntry<string> configBiomeMistlandsColor;

		public static ConfigEntry<string> configBiomeMountainColor;

		public static ConfigEntry<string> configBiomeOceanColor;

		public static ConfigEntry<string> configBiomePlainsColor;

		public static ConfigEntry<string> configBiomeSwampColor;

		public static ConfigEntry<string> configBiomeOtherColor;

		public static ConfigEntry<string> configExcludedCreatures;

		public static ConfigEntry<string> configExcludedCreatureSpawners;

		public static ConfigEntry<string> configExcludedSpawnSystems;

		public static ConfigEntry<string> configExcludedResources;

		public static ConfigEntry<bool> configShowShip;

		public static ConfigEntry<bool> configShowHud;

		public static ConfigEntry<bool> configShowTime;

		public static ConfigEntry<bool> configShowPosition;

		public static ConfigEntry<bool> configShowAltitude;

		public static ConfigEntry<bool> configShowForest;

		public static ConfigEntry<bool> configShowBlocked;

		public static ConfigEntry<string> configTrackedObjects;

		public static ConfigEntry<float> configTrackRadius;

		public static ConfigEntry<bool> configShowStagger;

		public static ConfigEntry<bool> configShowHeat;

		public static ConfigEntry<bool> configShowSpeed;

		public static ConfigEntry<bool> configShowStealth;

		public static ConfigEntry<bool> configShowWeather;

		public static ConfigEntry<bool> configShowWind;

		public static ConfigEntry<string> configShader;

		public static ConfigEntry<string> configCustom;

		public static ConfigEntry<bool> configDrops;

		public static ConfigEntry<bool> configBreeding;

		public static ConfigEntry<bool> configStatus;

		public static ConfigEntry<bool> configAttacks;

		public static ConfigEntry<bool> configResistances;

		public static ConfigEntry<bool> configExtraInfo;

		public static ConfigEntry<bool> configCustomOnly;

		public static ConfigEntry<bool> configWeaponInfo;

		public static ConfigEntry<bool> configShowProgress;

		public static ConfigEntry<bool> configSupport;

		public static ConfigEntry<bool> configStructures;

		public static ConfigEntry<bool> configCreatures;

		public static ConfigEntry<bool> configDestructibles;

		public static ConfigEntry<bool> configPickables;

		public static ConfigEntry<bool> configItemDrops;

		public static ConfigEntry<bool> configShips;

		public static ConfigEntry<bool> configLocations;

		public static ConfigEntry<bool> configVegetation;

		public static ConfigEntry<bool> configShowCreatureColliders;

		public static ConfigEntry<bool> configShowStructureColliders;

		public static ConfigEntry<bool> configShowDestructibleColliders;

		public static ConfigEntry<bool> configShowAttackRange;

		public static ConfigEntry<bool> configShowCreatureFireRange;

		public static ConfigEntry<bool> configShowTrackedObjects;

		public static ConfigEntry<bool> configShowCreatureBreedingTotalRange;

		public static ConfigEntry<bool> configShowCreatureBreedingPartnerRange;

		public static ConfigEntry<bool> configShowCreatureFoodSearchRange;

		public static ConfigEntry<bool> configShowCreatureEatingRange;

		public static ConfigEntry<bool> configShowStructureCover;

		public static ConfigEntry<bool> configShowPlayerCover;

		public static ConfigEntry<bool> configShowSmoke;

		public static ConfigEntry<bool> configShowCreatureAlertRange;

		public static ConfigEntry<bool> configShowCreatureNoise;

		public static ConfigEntry<bool> configShowCreatureHearRange;

		public static ConfigEntry<bool> configShowCreatureViewRange;

		public static ConfigEntry<bool> configShowSpawnZones;

		public static ConfigEntry<bool> configShowRandomEventSystem;

		public static ConfigEntry<bool> configShowSpawnerRays;

		public static ConfigEntry<bool> configShowSpawnerTriggerRanges;

		public static ConfigEntry<bool> configShowSpawnerLimitRanges;

		public static ConfigEntry<bool> configShowSpawnerSpawnRanges;

		public static ConfigEntry<bool> configShowAltarRays;

		public static ConfigEntry<bool> configShowAltarItemStandRange;

		public static ConfigEntry<bool> configShowAltarSpawnRadius;

		public static ConfigEntry<bool> configShowSpawnPointsOneTime;

		public static ConfigEntry<bool> configShowSpawnPointsRespawning;

		public static ConfigEntry<bool> configShowZoneCorners;

		public static ConfigEntry<bool> configShowPickablesOneTime;

		public static ConfigEntry<bool> configShowPickablesRespawning;

		public static ConfigEntry<bool> configShowEffectAreasPrivateArea;

		public static ConfigEntry<bool> configShowEffectAreasComfort;

		public static ConfigEntry<bool> configShowEffectAreasBurning;

		public static ConfigEntry<bool> configShowEffectAreasHeat;

		public static ConfigEntry<bool> configShowEffectAreasFire;

		public static ConfigEntry<bool> configShowEffectAreasNoMonsters;

		public static ConfigEntry<bool> configShowEffectAreasTeleport;

		public static ConfigEntry<bool> configShowSpawnSuppression;

		public static ConfigEntry<bool> configShowEffectAreasWarmCozy;

		public static ConfigEntry<bool> configShowEffectAreasOther;

		public static ConfigEntry<bool> configShowEffectAreasCustomContainer;

		public static ConfigEntry<bool> configShowEffectAreasCustomCrafting;

		public static ConfigEntry<bool> configShowChests;

		public static ConfigEntry<bool> configShowOres;

		public static ConfigEntry<bool> configShowTrees;

		public static ConfigEntry<bool> configShowDestructibles;

		public static ConfigEntry<bool> configShowTrophySpeaks;

		public static ConfigEntry<bool> configShowLocations;

		public static ConfigEntry<bool> configShowEventZones;

		public static ConfigEntry<bool> configShowStructureSupport;

		public static ConfigEntry<int> configCreatureCollidersLineWidth;

		public static ConfigEntry<int> configStructureCollidersLineWidth;

		public static ConfigEntry<int> configDestructibleCollidersLineWidth;

		public static ConfigEntry<int> configCreatureFireLineWidth;

		public static ConfigEntry<int> configTrackedObjectRayWidth;

		public static ConfigEntry<int> configBreedingLineWidth;

		public static ConfigEntry<int> configCoverRayWidth;

		public static ConfigEntry<int> configPlayerCoverRayWidth;

		public static ConfigEntry<int> configSmokeLineWidth;

		public static ConfigEntry<int> configSenseLineWidth;

		public static ConfigEntry<int> configNoiseLineWidth;

		public static ConfigEntry<int> configSpawnZoneRayWidth;

		public static ConfigEntry<int> configRandEventSystemRayWidth;

		public static ConfigEntry<int> configSpawnerRayWidth;

		public static ConfigEntry<int> configSpawnerTriggerRangeLineWidth;

		public static ConfigEntry<int> configSpawnerLimitRangeLineWidth;

		public static ConfigEntry<int> configSpawnerSpawnRangeLineWidth;

		public static ConfigEntry<int> configAltarRayWidth;

		public static ConfigEntry<int> configAltarItemStandRangeLineWidth;

		public static ConfigEntry<int> configAltarSpawnRadiusLineWidth;

		public static ConfigEntry<int> configSpawntPointOneTimeRayWidth;

		public static ConfigEntry<int> configSpawntPointRespawningRayWidth;

		public static ConfigEntry<int> configZoneCornerRayWidth;

		public static ConfigEntry<int> configPickableOneTimeRayWidth;

		public static ConfigEntry<int> configPickableRespawningRayWidth;

		public static ConfigEntry<int> configEffectAreaLineWidth;

		public static ConfigEntry<float> configCustomContainerEffectAreaRadius;

		public static ConfigEntry<float> configCustomCraftingEffectAreaRadius;

		public static ConfigEntry<int> configChestRayWidth;

		public static ConfigEntry<int> configOreRayWidth;

		public static ConfigEntry<int> configTreeRayWidth;

		public static ConfigEntry<int> configDestructibleRayWidth;

		public static ConfigEntry<int> configTrophySpeakSphereWidth;

		public static ConfigEntry<int> configLocationRayWidth;

		public static ConfigEntry<int> configEventZoneRayWidth;

		public static ConfigEntry<int> configTerrainRayWidth;

		public static string ExcludedCreatures => configExcludedCreatures.Value;

		public static string ExcludedCreatureSpawners => configExcludedCreatureSpawners.Value;

		public static string ExcludedSpawnZones => configExcludedSpawnSystems.Value;

		public static string ExcludedResources => configExcludedResources.Value;

		public static bool ShowShip => PermissionManager.IsHudFeatureEnabled(PermissionHash.Ship, configShowShip.Value);

		public static bool ShowHud => PermissionManager.IsHudFeatureEnabled(PermissionHash.Hud, configShowHud.Value);

		public static bool ShowTime => PermissionManager.IsHudFeatureEnabled(PermissionHash.Time, configShowTime.Value);

		public static bool ShowPosition => PermissionManager.IsHudFeatureEnabled(PermissionHash.Position, configShowPosition.Value);

		public static bool ShowAltitude => PermissionManager.IsHudFeatureEnabled(PermissionHash.Altitude, configShowAltitude.Value);

		public static bool ShowForest => PermissionManager.IsHudFeatureEnabled(PermissionHash.Forest, configShowForest.Value);

		public static bool ShowBlocked => PermissionManager.IsHudFeatureEnabled(PermissionHash.Blocked, configShowBlocked.Value);

		public static string TrackedObjects => configTrackedObjects.Value;

		public static float TrackRadius => configTrackRadius.Value;

		public static bool ShowStagger => PermissionManager.IsHudFeatureEnabled(PermissionHash.Stagger, configShowStagger.Value);

		public static bool ShowHeat => PermissionManager.IsHudFeatureEnabled(PermissionHash.Heat, configShowHeat.Value);

		public static bool ShowSpeed => PermissionManager.IsHudFeatureEnabled(PermissionHash.Speed, configShowSpeed.Value);

		public static bool ShowStealth => PermissionManager.IsHudFeatureEnabled(PermissionHash.Stealth, configShowStealth.Value);

		public static bool ShowWeather => PermissionManager.IsHudFeatureEnabled(PermissionHash.Weather, configShowWeather.Value);

		public static bool ShowWind => PermissionManager.IsHudFeatureEnabled(PermissionHash.Wind, configShowWind.Value);

		public static string Custom => configCustom.Value;

		public static bool Drops => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Drops, configDrops.Value);

		public static bool Breeding => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Breeding, configBreeding.Value);

		public static bool Status => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Status, configStatus.Value);

		public static bool Attacks => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Attacks, configAttacks.Value);

		public static bool Resistances => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Resistances, configResistances.Value);

		public static bool ExtraInfo => PermissionManager.IsStatsFeatureEnabled(PermissionHash.ExtraInfo, configExtraInfo.Value);

		public static bool CustomOnly => PermissionManager.IsStatsFeatureEnabled(PermissionHash.CustomOnly, configCustomOnly.Value);

		public static bool WeaponInfo => PermissionManager.IsStatsFeatureEnabled(PermissionHash.WeaponInfo, configWeaponInfo.Value);

		public static bool Progress => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Progress, configShowProgress.Value);

		public static bool Support => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Support, configSupport.Value);

		public static bool Structures => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Structures, configStructures.Value);

		public static bool Creatures => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Creatures, configCreatures.Value);

		public static bool Destructibles => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Destructibles, configDestructibles.Value);

		public static bool Pickables => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Pickables, configPickables.Value);

		public static bool ItemDrops => PermissionManager.IsStatsFeatureEnabled(PermissionHash.ItemDrops, configItemDrops.Value);

		public static bool Ships => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Ships, configShips.Value);

		public static bool Locations => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Locations, configLocations.Value);

		public static bool Vegetation => PermissionManager.IsStatsFeatureEnabled(PermissionHash.Vegetation, configVegetation.Value);

		public static float CustomContainerEffectAreaRadius => configCustomContainerEffectAreaRadius.Value;

		public static float CustomCraftingEffectAreaRadius => configCustomCraftingEffectAreaRadius.Value;

		public static Color ParseColor(string color)
		{
			//IL_000c: 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)
			Color result = default(Color);
			if (ColorUtility.TryParseHtmlString(color, ref result))
			{
				return result;
			}
			return Color.white;
		}

		private static void OnColorChanged(ConfigEntry<string> entry, string tag, Action onChanged = null)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			entry.SettingChanged += delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				Draw.SetColor(tag, ParseColor(entry.Value));
				onChanged?.Invoke();
			};
			Draw.SetColor(tag, ParseColor(entry.Value));
			onChanged?.Invoke();
		}

		private static void InitColors(ConfigFile config)
		{
			string text = "5. Colors (predefined, #RRGGBB, #RRGGBBAA)";
			configCreatureCollidersColor = config.Bind<string>(text, "Creature colliders", "magenta", "");
			OnColorChanged(configCreatureCollidersColor, "CreatureCollider");
			configStructureCollidersColor = config.Bind<string>(text, "Structure colliders", "magenta", "");
			OnColorChanged(configStructureCollidersColor, "StructureCollider");
			configDestructibleCollidersColor = config.Bind<string>(text, "Destructible colliders", "magenta", "");
			OnColorChanged(configDestructibleCollidersColor, "DestructibleCollider");
			configAttackRayColor = config.Bind<string>(text, "Attack ray", "magenta", "");
			OnColorChanged(configAttackRayColor, "Attack");
			configCreatureRayColor = config.Bind<string>(text, "Creature ray", "magenta", "");
			OnColorChanged(configCreatureRayColor, "TrackedObject");
			configPickableOneTimeColor = config.Bind<string>(text, "Pickable ray (one time)", "green", "");
			OnColorChanged(configPickableOneTimeColor, "PickableOneTime");
			configPickableRespawningColor = config.Bind<string>(text, "Pickable ray (respawning)", "blue", "");
			OnColorChanged(configPickableRespawningColor, "PickableRespawning");
			configLocationRayColor = config.Bind<string>(text, "Location ray", "black", "");
			OnColorChanged(configLocationRayColor, "Location");
			configEventZoneRayColor = config.Bind<string>(text, "Event zone ray", "black", "");
			OnColorChanged(configEventZoneRayColor, "EventZone");
			configChestRayColor = config.Bind<string>(text, "Chest ray", "white", "");
			OnColorChanged(configChestRayColor, "Chest");
			configOreRayColor = config.Bind<string>(text, "Ore ray", "gray", "");
			OnColorChanged(configOreRayColor, "Ore");
			configTreeRayColor = config.Bind<string>(text, "Tree ray", "white", "");
			OnColorChanged(configTreeRayColor, "Tree");
			configTrophySpeakColor = config.Bind<string>(text, "Trophy speak sphere", "magenta", "");
			OnColorChanged(configTrophySpeakColor, "TrophySpeak");
			configDestructibleRayColor = config.Bind<string>(text, "Destructible ray", "white", "");
			OnColorChanged(configDestructibleRayColor, "Destructible");
			configSpawnPointOneTimeColor = config.Bind<string>(text, "Spawn point ray (one time)", "red", "");
			OnColorChanged(configSpawnPointOneTimeColor, "SpawnPointOneTime");
			configSpawnPointRespawningColor = config.Bind<string>(text, "Spawn point ray (respawning)", "yellow", "");
			OnColorChanged(configSpawnPointRespawningColor, "SpawnPointRespawning");
			configNoiseColor = config.Bind<string>(text, "Noise sphere", "cyan", "");
			OnColorChanged(configNoiseColor, "CreatureNoise");
			configCoverRayColor = config.Bind<string>(text, "Cover ray", "green", "");
			OnColorChanged(configCoverRayColor, "StructureCover");
			OnColorChanged(configCoverRayColor, "PlayerCover");
			configCoverRayBlockedColor = config.Bind<string>(text, "Cover ray (blocked)", "red", "");
			OnColorChanged(configCoverRayBlockedColor, "StructureCoverBlocked");
			OnColorChanged(configCoverRayBlockedColor, "PlayerCoverBlocked");
			configCreatureHearColor = config.Bind<string>(text, "Creature hearing sphere", "green", "");
			OnColorChanged(configCreatureHearColor, "CreatureHearRange");
			configCreatureViewColor = config.Bind<string>(text, "Creature sight cone", "white", "");
			OnColorChanged(configCreatureViewColor, "CreatureViewRange");
			configCreatureAlertViewColor = config.Bind<string>(text, "Creature alert sight cone", "red", "");
			OnColorChanged(configCreatureAlertViewColor, "CreatureAlertRange");
			configCreatureFireLimitColor = config.Bind<string>(text, "Creature fire limit sphere", "magenta", "");
			OnColorChanged(configCreatureFireLimitColor, "CreatureFireRange");
			configCreatureTotalLimitColor = config.Bind<string>(text, "Creature total limit sphere", "cyan", "");
			OnColorChanged(configCreatureTotalLimitColor, "CreatureBreedingTotalRange");
			configCreaturePartnerCheckColor = config.Bind<string>(text, "Creature partner check sphere", "magenta", "");
			OnColorChanged(configCreaturePartnerCheckColor, "CreatureBreedingPartnerRange");
			configCreatureFoodCheckColor = config.Bind<string>(text, "Creature food check sphere", "gray", "");
			OnColorChanged(configCreatureFoodCheckColor, "CreatureFoodSearchRange");
			configCreatureEatRangeColor = config.Bind<string>(text, "Creature eat range sphere", "black", "");
			OnColorChanged(configCreatureEatRangeColor, "CreatureEatingRange");
			configSpawnerRayColor = config.Bind<string>(text, "Spawner ray", "red", "");
			OnColorChanged(configSpawnerRayColor, "SpawnerRay");
			configSpawnerTriggerColor = config.Bind<string>(text, "Spawner trigger sphere", "red", "");
			OnColorChanged(configSpawnerTriggerColor, "SpawnerTriggerRange");
			configSpawnerNearColor = config.Bind<string>(text, "Spawner near limit sphere", "white", "");
			OnColorChanged(configSpawnerNearColor, "SpawnerNearRange");
			configSpawnerSpawnColor = config.Bind<string>(text, "Spawner spawn sphere", "cyan", "");
			OnColorChanged(configSpawnerSpawnColor, "SpawnerSpawnRange");
			configAltarRayColor = config.Bind<string>(text, "Altar ray", "red", "");
			OnColorChanged(configAltarRayColor, "AltarRay");
			configAltarItemStandRangeColor = config.Bind<string>(text, "Altar item stand range sphere", "red", "");
			OnColorChanged(configAltarItemStandRangeColor, "AltarItemStandRange");
			configAltarSpawnRadiusColor = config.Bind<string>(text, "Altar spawn radius sphere", "red", "");
			OnColorChanged(configAltarSpawnRadiusColor, "AltarSpawnRadius");
			configEffectAreaPrivateAreaColor = config.Bind<string>(text, "Ward effect sphere", "gray", "");
			OnColorChanged(configEffectAreaPrivateAreaColor, "EffectAreaPrivateArea");
			configEffectAreaPlayerBaseColor = config.Bind<string>(text, "Spawn suppression circle", "white", "");
			OnColorChanged(configEffectAreaPlayerBaseColor, "EffectAreaPlayerBase", CircleAreaManager.RefreshColors);
			configEffectAreaComfortColor = config.Bind<string>(text, "Comfort effect sphere", "cyan", "");
			OnColorChanged(configEffectAreaComfortColor, "EffectAreaComfort");
			configEffectAreaBurningColor = config.Bind<string>(text, "Burning effect sphere", "yellow", "");
			OnColorChanged(configEffectAreaBurningColor, "EffectAreaBurning");
			configEffectAreaHeatColor = config.Bind<string>(text, "Heat effect sphere", "magenta", "");
			OnColorChanged(configEffectAreaHeatColor, "EffectAreaHeat");
			configEffectAreaFireColor = config.Bind<string>(text, "Fire effect sphere", "red", "");
			OnColorChanged(configEffectAreaFireColor, "EffectAreaFire");
			configEffectAreaNoMonstersColor = config.Bind<string>(text, "No monsters effect sphere", "green", "");
			OnColorChanged(configEffectAreaNoMonstersColor, "EffectAreaNoMonsters");
			configEffectAreaTeleportColor = config.Bind<string>(text, "Teleport effect sphere", "blue", "");
			OnColorChanged(configEffectAreaTeleportColor, "EffectAreaTeleport");
			configEffectAreaOtherColor = config.Bind<string>(text, "Unknown effect spheres", "black", "");
			OnColorChanged(configEffectAreaOtherColor, "EffectAreaOther");
			configEffectAreaWarmCozyColor = config.Bind<string>(text, "Warm and cozy effect sphere", "magenta", "");
			OnColorChanged(configEffectAreaWarmCozyColor, "EffectAreaWarmCozy");
			configEffectAreaCustomContainerColor = config.Bind<string>(text, "Custom container sphere", "yellow", "");
			OnColorChanged(configEffectAreaCustomContainerColor, "EffectAreaCustomContainer");
			configEffectAreaCustomCraftingColor = config.Bind<string>(text, "Custom crafting station sphere", "yellow", "");
			OnColorChanged(configEffectAreaCustomCraftingColor, "EffectAreaCustomCrafting");
			configSmokeColor = config.Bind<string>(text, "Smoke sphere", "black", "");
			OnColorChanged(configSmokeColor, "Smoke");
			configRandomEventSystemRayColor = config.Bind<string>(text, "Random even system ray", "black", "");
			OnColorChanged(configRandomEventSystemRayColor, "RandomEventSystem");
			configBiomeAshlandsColor = config.Bind<string>(text, "Ashlands color", "red", "");
			OnColorChanged(configBiomeAshlandsColor, "ZoneCornerAshlands");
			OnColorChanged(configBiomeAshlandsColor, "SpawnZoneAshlands");
			configBiomeBlackForestColor = config.Bind<string>(text, "Black Forest color", "magenta", "");
			OnColorChanged(configBiomeBlackForestColor, "ZoneCornerBlackForest");
			OnColorChanged(configBiomeBlackForestColor, "SpawnZoneBlackForest");
			configBiomeDeepNorthColor = config.Bind<string>(text, "Deep North color", "gray", "");
			OnColorChanged(configBiomeDeepNorthColor, "ZoneCornerDeepNorth");
			OnColorChanged(configBiomeDeepNorthColor, "SpawnZoneDeepNorth");
			configBiomeMeadowsColor = config.Bind<string>(text, "Meadows color", "green", "");
			OnColorChanged(configBiomeMeadowsColor, "ZoneCornerMeadows");
			OnColorChanged(configBiomeMeadowsColor, "SpawnZoneMeadows");
			configBiomeMistlandsColor = config.Bind<string>(text, "Mistlands color", "gray", "");
			OnColorChanged(configBiomeMistlandsColor, "ZoneCornerMistlands");
			OnColorChanged(configBiomeMistlandsColor, "SpawnZoneMistlands");
			configBiomeMountainColor = config.Bind<string>(text, "Mountain color", "white", "");
			OnColorChanged(configBiomeMountainColor, "ZoneCornerMountain");
			OnColorChanged(configBiomeMountainColor, "SpawnZoneMountain");
			configBiomeOceanColor = config.Bind<string>(text, "Ocean color", "blue", "");
			OnColorChanged(configBiomeOceanColor, "ZoneCornerOcean");
			OnColorChanged(configBiomeOceanColor, "SpawnZoneOcean");
			configBiomePlainsColor = config.Bind<string>(text, "Plains color", "yellow", "");
			OnColorChanged(configBiomePlainsColor, "ZoneCornerPlains");
			OnColorChanged(configBiomePlainsColor, "SpawnZonePlains");
			configBiomeSwampColor = config.Bind<string>(text, "Swamp color", "cyan", "");
			OnColorChanged(configBiomeSwampColor, "ZoneCornerSwamp");
			OnColorChanged(configBiomeSwampColor, "SpawnZoneSwamp");
			configBiomeOtherColor = config.Bind<string>(text, "Unknown biome color", "black", "");
			OnColorChanged(configBiomeOtherColor, "ZoneCornerUnknown");
			OnColorChanged(configBiomeOtherColor, "SpawnZoneUnknown");
		}

		public static void InitExcluded(ConfigFile config)
		{
			string text = "4. Excluded";
			configExcludedCreatures = config.Bind<string>(text, "Creatures", "", "List of creatures separated by ,");
			configExcludedSpawnSystems = config.Bind<string>(text, "Spawn systems", "Seagal,FireFlies", "List of creatures separated by , that are not visualized");
			configExcludedCreatureSpawners = config.Bind<string>(text, "Spawn points", "", "List of creatures separated by , that are not visualized");
			configExcludedResources = config.Bind<string>(text, "Resources", "Wood,Stone,Rock*,*RockPillar", "List of resources separated by , that are not visualized");
		}

		public static void InitHUD(ConfigFile config)
		{
			string text = "1. HUD";
			configShowHud = config.Bind<bool>(text, "Show HUD", false, "Show info and stats on HUD");
			configShowTime = config.Bind<bool>(text, "Show time", true, "Show time");
			configShowWeather = config.Bind<bool>(text, "Show weather", true, "Show weather");
			configShowWind = config.Bind<bool>(text, "Show wind", false, "Show wind");
			configShowPosition = config.Bind<bool>(text, "Show position", true, "Show position");
			configShowAltitude = config.Bind<bool>(text, "Show altitude", false, "Show altitude");
			configShowForest = config.Bind<bool>(text, "Show forest", false, "Show forest");
			configShowBlocked = config.Bind<bool>(text, "Show blocked", false, "Show whether the sky is blocked");
			configShowStagger = config.Bind<bool>(text, "Show stagger timer", false, "Shows stagger timer");
			configShowHeat = config.Bind<bool>(text, "Show heat", false, "Shows heat");
			configShowSpeed = config.Bind<bool>(text, "Show speed", false, "Shows speed");
			configShowStealth = config.Bind<bool>(text, "Show stealth", false, "Shows stealth");
			configShowShip = config.Bind<bool>(text, "Show ship stats", true, "Show ship stats on the hud");
			configTrackedObjects = config.Bind<string>(text, "Tracked objects", "Serpent", "List of objects to track (separated by ,)");
			configTrackRadius = config.Bind<float>(text, "Track radius", 500f, "Radius to find objects.");
			configShader = config.Bind<string>(text, "Shader", "Sprites/Default", "Shader for the lines.");
			configShader.SettingChanged += delegate
			{
				Draw.SetShader(configShader.Value);
			};
			Draw.SetShader(configShader.Value);
		}

		public static void Init(ConfigFile config)
		{
			InitHUD(config);
			InitTooltips(config);
			InitVisuals(config);
			InitExcluded(config);
			InitColors(config);
			InitVisualWidth(config);
			InitCommands();
		}

		private static void InitCommands()
		{
			//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_0029: Expected O, but got Unknown
			//IL_004c: 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_0049: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00ed: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0198: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			object obj = <>c.<>9__122_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (args.Length < 2)
					{
						args.Context.AddString("Missing name.");
						return;
					}
					List<string> list3 = args[1].Split(new char[1] { ' ' }).ToList();
					if (args[1] == "*")
					{
						list3 = OptionsFetcher();
					}
					foreach (string item in list3)
					{
						SetEntry(item, value: true);
					}
				};
				<>c.<>9__122_0 = val;
				obj = (object)val;
			}
			object obj2 = <>O.<1>__OptionsFetcher;
			if (obj2 == null)
			{
				ConsoleOptionsFetcher val2 = OptionsFetcher;
				<>O.<1>__OptionsFetcher = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("esp_enable", "[name1] [name2] [name3] ... - Enables given settings.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
			object obj3 = <>c.<>9__122_1;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					if (args.Length < 2)
					{
						args.Context.AddString("Missing name.");
						return;
					}
					List<string> list2 = args[1].Split(new char[1] { ' ' }).ToList();
					if (args[1] == "*")
					{
						list2 = OptionsFetcher();
					}
					foreach (string item2 in list2)
					{
						ToggleEntry(item2);
					}
				};
				<>c.<>9__122_1 = val3;
				obj3 = (object)val3;
			}
			object obj4 = <>O.<1>__OptionsFetcher;
			if (obj4 == null)
			{
				ConsoleOptionsFetcher val4 = OptionsFetcher;
				<>O.<1>__OptionsFetcher = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("esp_toggle", "[name1] [name2] [name3] ... - Toggles given settings.", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)obj4, false, false, false);
			object obj5 = <>c.<>9__122_2;
			if (obj5 == null)
			{
				ConsoleEvent val5 = delegate(ConsoleEventArgs args)
				{
					if (args.Length < 2)
					{
						args.Context.AddString("Missing name.");
						return;
					}
					List<string> list = args[1].Split(new char[1] { ' ' }).ToList();
					if (args[1] == "*")
					{
						list = OptionsFetcher();
					}
					foreach (string item3 in list)
					{
						SetEntry(item3, value: false);
					}
				};
				<>c.<>9__122_2 = val5;
				obj5 = (object)val5;
			}
			object obj6 = <>O.<1>__OptionsFetcher;
			if (obj6 == null)
			{
				ConsoleOptionsFetcher val6 = OptionsFetcher;
				<>O.<1>__OptionsFetcher = val6;
				obj6 = (object)val6;
			}
			new ConsoleCommand("esp_disable", "[name1] [name2] [name3] ... - Disables given settings.", (ConsoleEvent)obj5, false, false, false, false, false, (ConsoleOptionsFetcher)obj6, false, false, false);
			object obj7 = <>c.<>9__122_3;
			if (obj7 == null)
			{
				ConsoleEvent val7 = delegate(ConsoleEventArgs args)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						Vector3 position2 = ((Component)Player.m_localPlayer).transform.position;
						float radius2 = args.TryParameterFloat(1, 10f);
						Visual.DrawHeightmap(position2, radius2);
					}
				};
				<>c.<>9__122_3 = val7;
				obj7 = (object)val7;
			}
			new ConsoleCommand("esp_terrain", "[radius] - Inspects terrain.", (ConsoleEvent)obj7, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj8 = <>c.<>9__122_4;
			if (obj8 == null)
			{
				ConsoleEvent val8 = delegate(ConsoleEventArgs args)
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						Vector3 position = ((Component)Player.m_localPlayer).transform.position;
						float radius = args.TryParameterFloat(1, 10f);
						Visual.DrawPaintmap(position, radius);
					}
				};
				<>c.<>9__122_4 = val8;
				obj8 = (object)val8;
			}
			new ConsoleCommand("esp_paint", "[radius] - Inspects paint.", (ConsoleEvent)obj8, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj9 = <>c.<>9__122_5;
			if (obj9 == null)
			{
				ConsoleEvent val9 = delegate(ConsoleEventArgs args)
				{
					//IL_008d: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
					//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
					if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
					{
						if (args.Length < 2)
						{
							args.Context.AddString("Missing coordinates.");
						}
						else
						{
							string[] array = args[1].Split(new char[1] { ',' });
							float result;
							float result2;
							if (array.Length < 2)
							{
								args.Context.AddString("Invalid coordinates.");
							}
							else if (!float.TryParse(array[0], out result) || !float.TryParse(array[1], out result2))
							{
								args.Context.AddString("Invalid coordinates.");
							}
							else
							{
								Vector3 val14 = default(Vector3);
								((Vector3)(ref val14))..ctor(result, 0f, result2);
								Heightmap val15 = Heightmap.FindHeightmap(val14);
								if (!Object.op_Implicit((Object)(object)val15))
								{
									args.Context.AddString("No heightmap found.");
								}
								else
								{
									float vegetationMask = val15.GetVegetationMask(val14);
									bool flag = val15.IsLava(val14, 0.6f);
									bool flag2 = val15.IsCultivated(val14);
									bool flag3 = val15.IsCleared(val14);
									args.Context.AddString($"Vegetation: {vegetationMask:F4}, Lava: {flag}, Cultivated: {flag2}, Cleared: {flag3}");
								}
							}
						}
					}
				};
				<>c.<>9__122_5 = val9;
				obj9 = (object)val9;
			}
			new ConsoleCommand("esp_check", "[x,z] - Inspects terrain at specific coordinates.", (ConsoleEvent)obj9, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj10 = <>c.<>9__122_6;
			if (obj10 == null)
			{
				ConsoleEvent val10 = delegate(ConsoleEventArgs args)
				{
					if (args.Length < 2)
					{
						args.Context.AddString("Missing file.");
					}
					else if (!FormatLoading.Keys.Contains(args[1]))
					{
						args.Context.AddString("Invalid file.");
					}
					else
					{
						configCustom.Value = args[1];
					}
				};
				<>c.<>9__122_6 = val10;
				obj10 = (object)val10;
			}
			object obj11 = <>c.<>9__122_7;
			if (obj11 == null)
			{
				ConsoleOptionsFetcher val11 = () => FormatLoading.Keys;
				<>c.<>9__122_7 = val11;
				obj11 = (object)val11;
			}
			new ConsoleCommand("esp_custom", "[file] - Sets the custom text file.", (ConsoleEvent)obj10, false, false, false, false, false, (ConsoleOptionsFetcher)obj11, false, false, false);
			object obj12 = <>c.<>9__122_8;
			if (obj12 == null)
			{
				ConsoleEvent val12 = delegate
				{
					int num2 = FormatLoading.Keys.IndexOf(configCustom.Value);
					num2 = ((num2 >= 0) ? ((num2 != 0) ? (num2 - 1) : (FormatLoading.Keys.Count - 1)) : 0);
					configCustom.Value = FormatLoading.Keys[num2];
				};
				<>c.<>9__122_8 = val12;
				obj12 = (object)val12;
			}
			new ConsoleCommand("esp_custom_prev", "Sets the previous custom text file.", (ConsoleEvent)obj12, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj13 = <>c.<>9__122_9;
			if (obj13 == null)
			{
				ConsoleEvent val13 = delegate
				{
					int num = FormatLoading.Keys.IndexOf(configCustom.Value);
					num = ((num >= 0) ? ((num != FormatLoading.Keys.Count - 1) ? (num + 1) : 0) : 0);
					configCustom.Value = FormatLoading.Keys[num];
				};
				<>c.<>9__122_9 = val13;
				obj13 = (object)val13;
			}
			new ConsoleCommand("esp_custom_next", "Sets the next custom text file.", (ConsoleEvent)obj13, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}

		private static List<string> OptionsFetcher()
		{
			List<string> getTags = Visibility.GetTags;
			List<string> list = new List<string>(getTags.Count);
			list.AddRange(getTags);
			List<string> list2 = list.Where((string tag) => !tag.StartsWith("ZoneCorner") && !tag.StartsWith("SpawnZone") && !tag.StartsWith("Terrain")).ToList();
			list2.Add("ZoneCorner");
			list2.Add("SpawnZone");
			list2.Add("ExtraInfo");
			list2.Add("HUD");
			list2.Add("Time");
			list2.Add("Weather");
			list2.Add("Wind");
			list2.Add("Position");
			list2.Add("Altitude");
			list2.Add("Forest");
			list2.Add("Blocked");
			list2.Add("Stagger");
			list2.Add("Heat");
			list2.Add("Speed");
			list2.Add("Stealth");
			list2.Sort();
			return list2;
		}

		private static ConfigEntry<bool> GetOtherEntry(string name)
		{
			name = name.ToLower();
			if (name == "ExtraInfo".ToLower())
			{
				return configExtraInfo;
			}
			if (name == "HUD".ToLower())
			{
				return configShowHud;
			}
			if (name == "Time".ToLower())
			{
				return configShowTime;
			}
			if (name == "Weather".ToLower())
			{
				return configShowWeather;
			}
			if (name == "Wind".ToLower())
			{
				return configShowWind;
			}
			if (name == "Position".ToLower())
			{
				return configShowPosition;
			}
			if (name == "Altitude".ToLower())
			{
				return configShowAltitude;
			}
			if (name == "Forest".ToLower())
			{
				return configShowForest;
			}
			if (name == "Blocked".ToLower())
			{
				return configShowBlocked;
			}
			if (name == "Stagger".ToLower())
			{
				return configShowStagger;
			}
			if (name == "Heat".ToLower())
			{
				return configShowHeat;
			}
			if (name == "Speed".ToLower())
			{
				return configShowSpeed;
			}
			if (name == "Stealth".ToLower())
			{
				return configShowStealth;
			}
			throw new NotImplementedException(name);
		}

		private static void SetEntry(string name, bool value)
		{
			try
			{
				ConfigEntry<bool> tagEntry = GetTagEntry(name);
				if (tagEntry.Value != value)
				{
					tagEntry.Value = value;
				}
				return;
			}
			catch (NotImplementedException)
			{
			}
			try
			{
				ConfigEntry<bool> otherEntry = GetOtherEntry(name);
				if (otherEntry.Value != value)
				{
					otherEntry.Value = value;
				}
				return;
			}
			catch (NotImplementedException)
			{
			}
			throw new NotImplementedException(name);
		}

		private static void ToggleEntry(string name)
		{
			try
			{
				ConfigEntry<bool> tagEntry = GetTagEntry(name);
				tagEntry.Value = !tagEntry.Value;
				return;
			}
			catch (NotImplementedException)
			{
			}
			try
			{
				ConfigEntry<bool> otherEntry = GetOtherEntry(name);
				otherEntry.Value = !otherEntry.Value;
				return;
			}
			catch (NotImplementedException)
			{
			}
			throw new NotImplementedException(name);
		}

		public static void InitTooltips(ConfigFile config)
		{
			string text = "2. Tooltips";
			configExtraInfo = config.Bind<bool>(text, "Show extra info on tooltips", false, "Show extra info on tooltips and hover texts (toggle with O button in the game)");
			configResistances = config.Bind<bool>(text, "Resistances", true, "Show resistances for creatures and structures");
			configAttacks = config.Bind<bool>(text, "Attacks", false, "Show creature attacks");
			configStructures = config.Bind<bool>(text, "Structures", true, "Show structure stats (health, resistances, support, etc.)");
			configCreatures = config.Bind<bool>(text, "Creatures", true, "Show creature stats (health, resistances, drops, attacks, taming, etc.)");
			configDestructibles = config.Bind<bool>(text, "Destructibles", true, "Show destructible stats (health, resistances)");
			configPickables = config.Bind<bool>(text, "Pickables", true, "Show pickable stats (respawn, timer)");
			configItemDrops = config.Bind<bool>(text, "Item drops", true, "Show item drop stats (stack size, despawn timer)");
			configDrops = config.Bind<bool>(text, "Drops", true, "Show creature drops");
			configBreeding = config.Bind<bool>(text, "Breeding", true, "Show taming and breeding related information");
			configStatus = config.Bind<bool>(text, "Status effects", true, "Show creature status effects");
			configWeaponInfo = config.Bind<bool>(text, "Weapon info", true, "Show extra info on weapon tooltips");
			configShowProgress = config.Bind<bool>(text, "Show progress", true, "Show progress for plants and structures");
			configSupport = config.Bind<bool>(text, "Show stats", true, "Show support for structures");
			configLocations = config.Bind<bool>(text, "Locations", true, "Show generator stats for locations");
			configVegetation = config.Bind<bool>(text, "Vegetation", false, "Show generator stats for vegetation");
			configShips = config.Bind<bool>(text, "Show ship stats", true, "Show ship speed and wind direction on the ship");
			configCustomOnly = config.Bind<bool>(text, "Custom only", false, "Show only custom info when available");
			configCustom = config.Bind<string>(text, "Custom", "", "Custom text format");
		}

		private static ConfigEntry<bool> GetTagEntry(string name)
		{
			name = name.ToLower();
			if (name == "CreatureCollider".ToLower())
			{
				return configShowCreatureColliders;
			}
			if (name == "StructureCollider".ToLower())
			{
				return configShowStructureColliders;
			}
			if (name == "DestructibleCollider".ToLower())
			{
				return configShowDestructibleColliders;
			}
			if (name == "StructureCover".ToLower())
			{
				return configShowStructureCover;
			}
			if (name == "StructureCoverBlocked".ToLower())
			{
				return configShowStructureCover;
			}
			if (name == "StructureSupport".ToLower())
			{
				return configShowStructureSupport;
			}
			if (name == "CreatureNoise".ToLower())
			{
				return configShowCreatureNoise;
			}
			if (name == "CreatureHearRange".ToLower())
			{
				return configShowCreatureHearRange;
			}
			if (name == "CreatureViewRange".ToLower())
			{
				return configShowCreatureViewRange;
			}
			if (name == "CreatureAlertRange".ToLower())
			{
				return configShowCreatureAlertRange;
			}
			if (name == "Attack".ToLower())
			{
				return configShowAttackRange;
			}
			if (name == "CreatureFireRange".ToLower())
			{
				return configShowCreatureFireRange;
			}
			if (name == "CreatureBreedingTotalRange".ToLower())
			{
				return configShowCreatureBreedingTotalRange;
			}
			if (name == "CreatureBreedingPartnerRange".ToLower())
			{
				return configShowCreatureBreedingPartnerRange;
			}
			if (name == "CreatureFoodSearchRange".ToLower())
			{
				return configShowCreatureFoodSearchRange;
			}
			if (name == "CreatureEatingRange".ToLower())
			{
				return configShowCreatureEatingRange;
			}
			if (name == "TrackedObject".ToLower())
			{
				return configShowTrackedObjects;
			}
			if (name == "PickableOneTime".ToLower())
			{
				return configShowPickablesOneTime;
			}
			if (name == "PickableRespawning".ToLower())
			{
				return configShowPickablesRespawning;
			}
			if (name == "Location".ToLower())
			{
				return configShowLocations;
			}
			if (name == "EventZone".ToLower())
			{
				return configShowEventZones;
			}
			if (name == "Chest".ToLower())
			{
				return configShowChests;
			}
			if (name == "Tree".ToLower())
			{
				return configShowTrees;
			}
			if (name == "Ore".ToLower())
			{
				return configShowOres;
			}
			if (name == "Destructible".ToLower())
			{
				return configShowDestructibles;
			}
			if (name == "TrophySpeak".ToLower())
			{
				return configShowTrophySpeaks;
			}
			if (name == "SpawnPointOneTime".ToLower())
			{
				return configShowSpawnPointsOneTime;
			}
			if (name == "SpawnPointRespawning".ToLower())
			{
				return configShowSpawnPointsRespawning;
			}
			if (name == "SpawnerRay".ToLower())
			{
				return configShowSpawnerRays;
			}
			if (name == "SpawnerTriggerRange".ToLower())
			{
				return configShowSpawnerTriggerRanges;
			}
			if (name == "SpawnerNearRange".ToLower())
			{
				return configShowSpawnerLimitRanges;
			}
			if (name == "SpawnerSpawnRange".ToLower())
			{
				return configShowSpawnerSpawnRanges;
			}
			if (name == "AltarRay".ToLower())
			{
				return configShowAltarRays;
			}
			if (name == "AltarItemStandRange".ToLower())
			{
				return configShowAltarItemStandRange;
			}
			if (name == "AltarSpawnRadius".ToLower())
			{
				return configShowAltarSpawnRadius;
			}
			if (name == "ZoneCorner".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerAshlands".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerBlackForest".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerDeepNorth".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerMeadows".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerMistlands".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerMountain".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerOcean".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerPlains".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerSwamp".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "ZoneCornerUnknown".ToLower())
			{
				return configShowZoneCorners;
			}
			if (name == "SpawnZone".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneAshlands".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneBlackForest".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneDeepNorth".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneMeadows".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneMistlands".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneMountain".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneOcean".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZonePlains".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneSwamp".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "SpawnZoneUnknown".ToLower())
			{
				return configShowSpawnZones;
			}
			if (name == "RandomEventSystem".ToLower())
			{
				return configShowRandomEventSystem;
			}
			if (name == "EffectAreaBurning".ToLower())
			{
				return configShowEffectAreasBurning;
			}
			if (name == "EffectAreaComfort".ToLower())
			{
				return configShowEffectAreasComfort;
			}
			if (name == "EffectAreaCustomContainer".ToLower())
			{
				return configShowEffectAreasCustomContainer;
			}
			if (name == "EffectAreaCustomCrafting".ToLower())
			{
				return configShowEffectAreasCustomCrafting;
			}
			if (name == "EffectAreaFire".ToLower())
			{
				return configShowEffectAreasFire;
			}
			if (name == "EffectAreaHeat".ToLower())
			{
				return configShowEffectAreasHeat;
			}
			if (name == "EffectAreaNoMonsters".ToLower())
			{
				return configShowEffectAreasNoMonsters;
			}
			if (name == "EffectAreaOther".ToLower())
			{
				return configShowEffectAreasOther;
			}
			if (name == "EffectAreaPlayerBase".ToLower())
			{
				return configShowSpawnSuppression;
			}
			if (name == "EffectAreaWarmCozy".ToLower())
			{
				return configShowEffectAreasWarmCozy;
			}
			if (name == "EffectAreaPrivateArea".ToLower())
			{
				return configShowEffectAreasPrivateArea;
			}
			if (name == "EffectAreaTeleport".ToLower())
			{
				return configShowEffectAreasTeleport;
			}
			if (name == "Smoke".ToLower())
			{
				return configShowSmoke;
			}
			if (name == "PlayerCover".ToLower())
			{
				return configShowPlayerCover;
			}
			if (name == "PlayerCoverBlocked".ToLower())
			{
				return configShowPlayerCover;
			}
			throw new NotImplementedException(name);
		}

		public static bool IsDisabled(string name)
		{
			return !PermissionManager.IsVisualFeatureEnabled(Visibility.GetTagHash(name), GetTagEntry(name).Value);
		}

		public static bool IsHidden(string name)
		{
			return !PermissionManager.IsVisualFeatureEnabled(Visibility.GetTagHash(name), GetTagEntry(name).Value);
		}

		private static ConfigDescription CreateDescription()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new ConfigDescription("", (AcceptableValueBase)null, Array.Empty<object>());
		}

		private static void OnChanged(ConfigEntry<bool> entry, string tag, params Action[] rebuilds)
		{
			foreach (Action action in rebuilds)
			{
				if (action != null)
				{
					Visibility.RegisterRebuilder(tag, action);
				}
			}
			entry.SettingChanged += delegate
			{
				Visibility.SetTag(tag, entry.Value);
			};
			Visibility.SetTag(tag, entry.Value);
		}

		private static void InitVisuals(ConfigFile config)
		{
			string text = "3. Visuals";
			configShowCreatureColliders = config.Bind<bool>(text, "Creature colliders", false, CreateDescription());
			OnChanged(configShowCreatureColliders, "CreatureCollider", Character_Colliders.RebuildLoaded);
			configShowStructureColliders = config.Bind<bool>(text, "Structure colliders", false, CreateDescription());
			OnChanged(configShowStructureColliders, "StructureCollider", WearNTear_Colliders.RebuildLoaded);
			configShowDestructibleColliders = config.Bind<bool>(text, "Destructible colliders", false, CreateDescription());
			OnChanged(configShowDestructibleColliders, "DestructibleCollider", Destructible_Colliders.RebuildLoaded);
			configShowAttackRange = config.Bind<bool>(text, "Attack range", false, CreateDescription());
			OnChanged(configShowAttackRange, "Attack");
			configShowStructureCover = config.Bind<bool>(text, "Structure cover", false, CreateDescription());
			OnChanged(configShowStructureCover, "StructureCover", Piece_Visual.RebuildLoaded);
			OnChanged(configShowStructureCover, "StructureCoverBlocked", Piece_Visual.RebuildLoaded);
			configShowStructureCover.SettingChanged += delegate
			{
				SupportUtils.UpdateVisibility();
			};
			configShowStructureSupport = config.Bind<bool>(text, "Structure support", false, CreateDescription());
			OnChanged(configShowStructureSupport, "StructureSupport", SupportUtils.UpdateVisibility);
			configShowCreatureNoise = config.Bind<bool>(text, "Creature noise", false, CreateDescription());
			OnChanged(configShowCreatureNoise, "CreatureNoise", Character_Awake.RebuildLoaded);
			configShowCreatureHearRange = config.Bind<bool>(text, "Creature hear range", false, CreateDescription());
			OnChanged(configShowCreatureHearRange, "CreatureHearRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureViewRange = config.Bind<bool>(text, "Creature view range", false, CreateDescription());
			OnChanged(configShowCreatureViewRange, "CreatureViewRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureAlertRange = config.Bind<bool>(text, "Creature alert range", false, CreateDescription());
			OnChanged(configShowCreatureAlertRange, "CreatureAlertRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureFireRange = config.Bind<bool>(text, "Creature fire range", false, CreateDescription());
			OnChanged(configShowCreatureFireRange, "CreatureFireRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureBreedingTotalRange = config.Bind<bool>(text, "Creature breeding total range", false, CreateDescription());
			OnChanged(configShowCreatureBreedingTotalRange, "CreatureBreedingTotalRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureBreedingPartnerRange = config.Bind<bool>(text, "Creature breeding partner range", false, CreateDescription());
			OnChanged(configShowCreatureBreedingPartnerRange, "CreatureBreedingPartnerRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureEatingRange = config.Bind<bool>(text, "Creature eating range", false, CreateDescription());
			OnChanged(configShowCreatureEatingRange, "CreatureEatingRange", BaseAI_Awake.RebuildLoaded);
			configShowCreatureFoodSearchRange = config.Bind<bool>(text, "Creature food search range", false, CreateDescription());
			OnChanged(configShowCreatureFoodSearchRange, "CreatureFoodSearchRange", BaseAI_Awake.RebuildLoaded);
			configShowTrackedObjects = config.Bind<bool>(text, "Tracked object rays", false, CreateDescription());
			OnChanged(configShowTrackedObjects, "TrackedObject", ZNetView_Ray.RebuildLoaded);
			configShowPickablesOneTime = config.Bind<bool>(text, "Pickable rays (one time)", false, CreateDescription());
			OnChanged(configShowPickablesOneTime, "PickableOneTime", Pickable_Ray.RebuildLoaded);
			configShowPickablesRespawning = config.Bind<bool>(text, "Pickable rays (respawning)", false, CreateDescription());
			OnChanged(configShowPickablesRespawning, "PickableRespawning", Pickable_Ray.RebuildLoaded);
			configShowLocations = config.Bind<bool>(text, "Location rays", false, CreateDescription());
			OnChanged(configShowLocations, "Location", Location_Ray.RebuildLoaded);
			configShowEventZones = config.Bind<bool>(text, "Event zone rays", false, CreateDescription());
			OnChanged(configShowEventZones, "EventZone", EventZone_Ray.RebuildLoaded);
			configShowChests = config.Bind<bool>(text, "Chest rays", false, CreateDescription());
			OnChanged(configShowChests, "Chest", Container_Ray.RebuildLoaded);
			configShowTrees = config.Bind<bool>(text, "Tree rays", false, CreateDescription());
			OnChanged(configShowTrees, "Tree", TreeLog_Ray.RebuildLoaded, TreeBase_Ray.RebuildLoaded, MineRock_Ray.RebuildLoaded, MineRock5_Ray.RebuildLoaded, Destructible_Ray.RebuildLoaded);
			configShowOres = config.Bind<bool>(text, "Ore rays", false, CreateDescription());
			OnChanged(configShowOres, "Ore", MineRock_Ray.RebuildLoaded, MineRock5_Ray.RebuildLoaded, Destructible_Ray.RebuildLoaded);
			configShowTrophySpeaks = config.Bind<bool>(text, "Trophy speak spheres", false, CreateDescription());
			OnChanged(configShowTrophySpeaks, "TrophySpeak", RandomSpeak_Sphere.RebuildLoaded);
			configShowDestructibles = config.Bind<bool>(text, "Destructible rays", false, CreateDescription());
			OnChanged(configShowDestructibles, "Destructible", MineRock_Ray.RebuildLoaded, MineRock5_Ray.RebuildLoaded, Destructible_Ray.RebuildLoaded);
			configShowSpawnPointsOneTime = config.Bind<bool>(text, "Spawn points (one time)", false, CreateDescription());
			OnChanged(configShowSpawnPointsOneTime, "SpawnPointOneTime", CreatureSpawner_Ray.RebuildLoaded);
			configShowSpawnPointsRespawning = config.Bind<bool>(text, "Spawn points (respawning)", false, CreateDescription());
			OnChanged(configShowSpawnPointsRespawning, "SpawnPointRespawning", CreatureSpawner_Ray.RebuildLoaded);
			configShowSpawnerRays = config.Bind<bool>(text, "Creature spawner rays", false, CreateDescription());
			OnChanged(configShowSpawnerRays, "SpawnerRay", SpawnArea_Awake.RebuildLoaded);
			configShowSpawnerTriggerRanges = config.Bind<bool>(text, "Creature spawner trigger ranges", false, CreateDescription());
			OnChanged(configShowSpawnerTriggerRanges, "SpawnerTriggerRange", SpawnArea_Awake.RebuildLoaded);
			configShowSpawnerLimitRanges = config.Bind<bool>(text, "Creature spawner limit ranges", false, CreateDescription());
			OnChanged(configShowSpawnerLimitRanges, "SpawnerNearRange", SpawnArea_Awake.RebuildLoaded);
			configShowSpawnerSpawnRanges = config.Bind<bool>(text, "Creature spawner spawn ranges", false, CreateDescription());
			OnChanged(configShowSpawnerSpawnRanges, "SpawnerSpawnRange", SpawnArea_Awake.RebuildLoaded);
			configShowAltarRays = config.Bind<bool>(text, "Altar rays", false, CreateDescription());
			OnChanged(configShowAltarRays, "AltarRay", OfferingBowl_Awake.RebuildLoaded);
			configShowAltarItemStandRange = config.Bind<bool>(text, "Altar item stand range", false, CreateDescription());
			OnChanged(configShowAltarItemStandRange, "AltarItemStandRange", OfferingBowl_Awake.RebuildLoaded);
			configShowAltarSpawnRadius = config.Bind<bool>(text, "Altar spawn radius", false, CreateDescription());
			OnChanged(configShowAltarSpawnRadius, "AltarSpawnRadius", OfferingBowl_Awake.RebuildLoaded);
			configShowSpawnZones = config.Bind<bool>(text, "Spawn zones", false, CreateDescription());
			OnChanged(configShowSpawnZones, "SpawnZoneAshlands", SpawnSystem_Awake.RebuildLoaded);
			OnChanged(configShowSpawnZones, "SpawnZoneBlackForest");
			OnChanged(configShowSpawnZones, "SpawnZoneDeepNorth");
			OnChanged(configShowSpawnZones, "SpawnZoneMeadows");
			OnChanged(configShowSpawnZones, "SpawnZoneMistlands");
			OnChanged(configShowSpawnZones, "SpawnZoneMountain");
			OnChanged(configShowSpawnZones, "SpawnZoneOcean");
			OnChanged(configShowSpawnZones, "SpawnZonePlains");
			OnChanged(configShowSpawnZones, "SpawnZoneSwamp");
			OnChanged(configShowSpawnZones, "SpawnZoneUnknown");
			configShowZoneCorners = config.Bind<bool>(text, "Zone corner rays", false, CreateDescription());
			OnChanged(configShowZoneCorners, "ZoneCornerAshlands", SpawnSystem_Awake.RebuildLoaded);
			OnChanged(configShowZoneCorners, "ZoneCornerBlackForest");
			OnChanged(configShowZoneCorners, "ZoneCornerDeepNorth");
			OnChanged(configShowZoneCorners, "ZoneCornerMeadows");
			OnChanged(configShowZoneCorners, "ZoneCornerMistlands");
			OnChanged(configShowZoneCorners, "ZoneCornerMountain");
			OnChanged(configShowZoneCorners, "ZoneCornerOcean");
			OnChanged(configShowZoneCorners, "ZoneCornerPlains");
			OnChanged(configShowZoneCorners, "ZoneCornerSwamp");
			OnChanged(configShowZoneCorners, "ZoneCornerUnknown");
			configShowRandomEventSystem = config.Bind<bool>(text, "Random event system", false, CreateDescription());
			OnChanged(configShowRandomEventSystem, "RandomEventSystem", SpawnSystem_Awake.RebuildLoaded);
			configShowEffectAreasBurning = config.Bind<bool>(text, "Area effects: Burning", false, CreateDescription());
			OnChanged(configShowEffectAreasBurning, "EffectAreaBurning", EffectArea_Visual.RebuildLoaded);
			configShowEffectAreasComfort = config.Bind<bool>(text, "Area effects: Comfort", false, CreateDescription());
			OnChanged(configShowEffectAreasComfort, "EffectAreaComfort", Piece_Visual.RebuildLoaded);
			configShowEffectAreasCustomContainer = config.Bind<bool>(text, "Area effects: Custom container", false, CreateDescription());
			OnChanged(configShowEffectAreasCustomContainer, "EffectAreaCustomContainer", Piece_Visual.RebuildLoaded);
			configShowEffectAreasCustomCrafting = config.Bind<bool>(text, "Area effects: Custom crafting", false, CreateDescription());
			OnChanged(configShowEffectAreasCustomCrafting, "EffectAreaCustomCrafting", Piece_Visual.RebuildLoaded);
			configShowEffectAreasFire = config.Bind<bool>(text, "Area effects: Fire", false, CreateDescription());
			OnChanged(configShowEffectAreasFire, "EffectAreaFire", EffectArea_Visual.RebuildLoaded);
			configShowEffectAreasHeat = config.Bind<bool>(text, "Area effects: Heat", false, CreateDescription());
			OnChanged(configShowEffectAreasHeat, "EffectAreaHeat", EffectArea_Visual.RebuildLoaded);
			configShowEffectAreasNoMonsters = config.Bind<bool>(text, "Area effects: No monsters", false, CreateDescription());
			OnChanged(configShowEffectAreasNoMonsters, "EffectAreaNoMonsters", EffectArea_Visual.RebuildLoaded);
			configShowEffectAreasOther = config.Bind<bool>(text, "Area effects: Other", false, CreateDescription());
			OnChanged(configShowEffectAreasOther, "EffectAreaOther", EffectArea_Visual.RebuildLoaded);
			configShowSpawnSuppression = config.Bind<bool>(text, "Area effects: Spawn suppression", false, CreateDescription());
			configShowSpawnSuppression.SettingChanged += delegate
			{
				BaseRuler.Visible = configShowSpawnSuppression.Value;
			};
			BaseRuler.Visible = configShowSpawnSuppression.Value;
			configShowEffectAreasWarmCozy = config.Bind<bool>(text, "Area effects: Warm cozy", false, CreateDescription());
			OnChanged(configShowEffectAreasWarmCozy, "EffectAreaWarmCozy", EffectArea_Visual.RebuildLoaded);
			configShowEffectAreasPrivateArea = config.Bind<bool>(text, "Area effects: Private area", false, CreateDescription());
			OnChanged(configShowEffectAreasPrivateArea, "EffectAreaPrivateArea", PrivateArea_Visual.RebuildLoaded);
			configShowEffectAreasTeleport = config.Bind<bool>(text, "Area effects: Teleport", false, CreateDescription());
			OnChanged(configShowEffectAreasTeleport, "EffectAreaTeleport", EffectArea_Visual.RebuildLoaded);
			configShowSmoke = config.Bind<bool>(text, "Smoke", false, CreateDescription());
			OnChanged(configShowSmoke, "Smoke", Smoke_Visual.RebuildLoaded);
			configShowPlayerCover = config.Bind<bool>(text, "Player cover", false, CreateDescription());
			OnChanged(configShowPlayerCover, "PlayerCover", Player_Cover.RebuildLoaded);
			OnChanged(configShowPlayerCover, "PlayerCoverBlocked", Player_Cover.RebuildLoaded);
			Visibility.SetTag("Terrain", visibility: true);
		}

		private static void OnWidthChanged(ConfigEntry<int> entry, string tag)
		{
			entry.SettingChanged += delegate
			{
				Draw.SetLineWidth(tag, entry.Value);
			};
			Draw.SetLineWidth(tag, entry.Value);
		}

		public static void InitVisualWidth(ConfigFile config)
		{
			string text = "6. Width of visuals";
			configCustomContainerEffectAreaRadius = config.Bind<float>(text, "Custom radius for containers", 0f, "Custom effect area sphere for containers (0 to disable)");
			configCustomCraftingEffectAreaRadius = config.Bind<float>(text, "Custom radius for crafting stations", 0f, "Custom effect area sphere for crafting stations (0 to disable)");
			configCreatureCollidersLineWidth = config.Bind<int>(text, "Creature colliders", 2, "");
			OnWidthChanged(configCreatureCollidersLineWidth, "CreatureCollider");
			configStructureCollidersLineWidth = config.Bind<int>(text, "Structure colliders", 2, "");
			OnWidthChanged(configStructureCollidersLineWidth, "StructureCollider");
			configDestructibleCollidersLineWidth = config.Bind<int>(text, "Destructible colliders", 2, "");
			OnWidthChanged(configDestructibleCollidersLineWidth, "DestructibleCollider");
			configCreatureFireLineWidth = config.Bind<int>(text, "Creature fire alert range", 2, "");
			OnWidthChanged(configCreatureFireLineWidth, "CreatureFireRange");
			configSenseLineWidth = config.Bind<int>(text, "Creature senses", 2, "");
			OnWidthChanged(configSenseLineWidth, "CreatureAlertRange");
			OnWidthChanged(configSenseLineWidth, "CreatureHearRange");
			OnWidthChanged(configSenseLineWidth, "CreatureViewRange");
			configBreedingLineWidth = config.Bind<int>(text, "Breeding limits", 2, "");
			OnWidthChanged(configBreedingLineWidth, "CreatureBreedingPartnerRange");
			OnWidthChanged(configBreedingLineWidth, "CreatureBreedingTotalRange");
			OnWidthChanged(configBreedingLineWidth, "CreatureEatingRange");
			OnWidthChanged(configBreedingLineWidth, "CreatureFoodSearchRange");
			configCoverRayWidth = config.Bind<int>(text, "Cover rays", 2, "");
			OnWidthChanged(configCoverRayWidth, "StructureCover");
			OnWidthChanged(configCoverRayWidth, "StructureCoverBlocked");
			configPlayerCoverRayWidth = config.Bind<int>(text, "Player cover rays", 2, "");
			OnWidthChanged(configPlayerCoverRayWidth, "PlayerCover");
			OnWidthChanged(configPlayerCoverRayWidth, "PlayerCoverBlocked");
			configSmokeLineWidth = config.Bind<int>(text, "Smoke", 2, "");
			OnWidthChanged(configSmokeLineWidth, "Smoke");
			configTrackedObjectRayWidth = config.Bind<int>(text, "Tracted object rays", 10, "");
			OnWidthChanged(configTrackedObjectRayWidth, "TrackedObject");
			configSpawntPointOneTimeRayWidth = config.Bind<int>(text, "Spawn points (one time)", 2, "");
			OnWidthChanged(configSpawntPointOneTimeRayWidth, "SpawnPointOneTime");
			configSpawntPointRespawningRayWidth = config.Bind<int>(text, "Spawn points (respawning)", 2, "");
			OnWidthChanged(configSpawntPointRespawningRayWidth, "SpawnPointRespawning");
			configSpawnerRayWidth = config.Bind<int>(text, "Creature spawner rays", 2, "");
			OnWidthChanged(configSpawnerRayWidth, "SpawnerRay");
			configSpawnerTriggerRangeLineWidth = config.Bind<int>(text, "Creature spawner trigger range", 2, "");
			OnWidthChanged(configSpawnerTriggerRangeLineWidth, "SpawnerTriggerRange");
			configSpawnerLimitRangeLineWidth = config.Bind<int>(text, "Creature spawner limit range", 2, "");
			OnWidthChanged(configSpawnerLimitRangeLineWidth, "SpawnerNearRange");
			configSpawnerSpawnRangeLineWidth = config.Bind<int>(text, "Creature spawner spawn range", 2, "");
			OnWidthChanged(configSpawnerSpawnRangeLineWidth, "SpawnerSpawnRange");
			configAltarRayWidth = config.Bind<int>(text, "Boss altar rays", 2, "");
			OnWidthChanged(configAltarRayWidth, "AltarRay");
			configAltarItemStandRangeLineWidth = config.Bind<int>(text, "Boss altar item stand range", 2, "");
			OnWidthChanged(configAltarItemStandRangeLineWidth, "AltarItemStandRange");
			configAltarSpawnRadiusLineWidth = config.Bind<int>(text, "Boss altar spawn radius", 2, "");
			OnWidthChanged(configAltarSpawnRadiusLineWidth, "AltarSpawnRadius");
			configSpawnZoneRayWidth = config.Bind<int>(text, "Spawn zones", 10, "");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneAshlands");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneBlackForest");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneDeepNorth");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneMeadows");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneMistlands");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneMountain");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneOcean");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZonePlains");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneSwamp");
			OnWidthChanged(configSpawnZoneRayWidth, "SpawnZoneUnknown");
			configZoneCornerRayWidth = config.Bind<int>(text, "Zone corner rays", 10, "");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerAshlands");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerBlackForest");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerDeepNorth");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerMeadows");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerMistlands");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerMountain");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerOcean");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerPlains");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerSwamp");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerSwamp");
			OnWidthChanged(configZoneCornerRayWidth, "ZoneCornerUnknown");
			configRandEventSystemRayWidth = config.Bind<int>(text, "Random event system", 10, "");
			OnWidthChanged(configRandEventSystemRayWidth, "RandomEventSystem");
			configPickableOneTimeRayWidth = config.Bind<int>(text, "Pickable rays (one time)", 2, "");
			OnWidthChanged(configPickableOneTimeRayWidth, "PickableOneTime");
			configPickableRespawningRayWidth = config.Bind<int>(text, "Pickable rays (respawning)", 2, "");
			OnWidthChanged(configPickableRespawningRayWidth, "PickableRespawning");
			configChestRayWidth = config.Bind<int>(text, "Chest rays", 2, "");
			OnWidthChanged(configChestRayWidth, "Chest");
			configOreRayWidth = config.Bind<int>(text, "Ore rays", 2, "");
			OnWidthChanged(configOreRayWidth, "Ore");
			configTreeRayWidth = config.Bind<int>(text, "Tree rays", 2, "");
			OnWidthChanged(configTreeRayWidth, "Tree");
			configTrophySpeakSphereWidth = config.Bind<int>(text, "Trophy speak spheres", 10, "");
			OnWidthChanged(configTrophySpeakSphereWidth, "TrophySpeak");
			configDestructibleRayWidth = config.Bind<int>(text, "Destructible rays", 2, "");
			OnWidthChanged(configDestructibleRayWidth, "Destructible");
			configLocationRayWidth = config.Bind<int>(text, "Location rays", 10, "");
			OnWidthChanged(configLocationRayWidth, "Location");
			configEventZoneRayWidth = config.Bind<int>(text, "Event zone rays", 10, "");
			OnWidthChanged(configEventZoneRayWidth, "EventZone");
			configEffectAreaLineWidth = config.Bind<int>(text, "Area effects", 2, "");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaBurning");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaComfort");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaCustomContainer");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaCustomCrafting");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaFire");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaHeat");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaNoMonsters");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaOther");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaPrivateArea");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaTeleport");
			OnWidthChanged(configEffectAreaLineWidth, "EffectAreaWarmCozy");
			configNoiseLineWidth = config.Bind<int>(text, "Noise", 2, "");
			OnWidthChanged(configNoiseLineWidth, "CreatureNoise");
			configTerrainRayWidth = config.Bind<int>(text, "Terrain rays", 2, "");
			OnWidthChanged(configTerrainRayWidth, "Terrain");
		}
	}
	public class Texts
	{
		public static int[] IgnoredLayers = new int[3]
		{
			LayerMask.NameToLayer("character_trigger"),
			LayerMask.NameToLayer("viewblock"),
			LayerMask.NameToLayer("pathblocker")
		};

		private const int SPEED_COUNT = 2000;

		private static readonly Queue<float> shipForwardSpeeds = new Queue<float>(2001);

		private static readonly Queue<float> shipSpeeds = new Queue<float>(2001);

		private static int Respawn = StringExtensionMethods.GetStableHashCode("override_respawn");

		private static int SpawnTime = StringExtensionMethods.GetStableHashCode("spawn_time");

		public static string GetNames(Biome biome, Biome validBiome = -1)
		{
			//IL_0000: 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_000d: Expected I4, but got Unknown
			//IL_0026: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			if ((int)biome == 0)
			{
				return "None";
			}
			int num = 1;
			int num2 = (int)biome;
			List<string> list = new List<string>();
			while (num <= num2)
			{
				if ((num & num2) > 0)
				{
					list.Add(Format.String(Enum.GetName(typeof(Biome), biome), (validBiome & biome) > 0));
				}
				num *= 2;
			}
			return Format.JoinRow(list);
		}

		public static string Get(Biome obj)
		{
			//IL_000e: 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)
			string text = Translate.Name(obj) + "\n" + EnvUtils.GetTime() + ", " + EnvUtils.GetCurrentEnvironment();
			List<EnvEntry> availableEnvironments = EnvMan.instance.GetAvailableEnvironments(obj);
			float totalWeight = availableEnvironments.Sum((EnvEntry env) => env.m_weight);
			double value = ((IEnumerable<EnvEntry>)availableEnvironments).Sum((Func<EnvEntry, double>)EnvUtils.GetAvgWind) / (double)totalWeight;
			text = text + "\n" + EnvUtils.GetWind() + " (" + Format.Percent(value) + " on average), Current roll: " + EnvUtils.GetWindRoll();
			text = text + "\n\n" + EnvUtils.GetProgress() + ", Current roll: " + EnvUtils.GetEnvironmentRoll();
			IEnumerable<string> lines = availableEnvironments.Select((EnvEntry env) => EnvUtils.GetEnvironment(env, totalWeight));
			return text + "\n" + Format.JoinLines(lines);
		}

		public static string GetBiomes(Biome biome, BiomeArea area = 1, bool addLabel = true)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			string names = GetNames(biome, (Biome)(-1));
			if (names.Length == 0)
			{
				return "";
			}
			string obj = (addLabel ? "Biomes: " : "");
			bool flag = (area & 1) > 0;
			bool flag2 = (area & 2) > 0;
			string text = ((flag && flag2) ? "" : (flag2 ? ", only full biomes" : (flag ? ", only edge biomes" : "invalid biome area")));
			return obj + names + text;
		}

		private static string GetTargetName(AiTarget target)
		{
			//IL_0000: 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_000b: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if ((int)target == 0)
			{
				return "";
			}
			if ((int)target == 2)
			{
				return "Support";
			}
			if ((int)target == 1)
			{
				return "Heal";
			}
			return "";
		}

		private static string GetDamages(DamageTypes target, int tier)
		{
			string tooltipString = ((DamageTypes)(ref target)).GetTooltipString();
			tooltipString = tooltipString.Replace("<CHOP_TIER>", GetChopTier(tier));
			tooltipString = tooltipString.Replace("<PICKAXE_TIER>", GetPickaxeTier(tier));
			string text = Localization.instance.Localize(tooltipString.Replace("\n", ", "));
			if (text.Length > 0)
			{
				return text.Substring(2);
			}
			return text;
		}

		public static string GetAttack(Humanoid obj)
		{
			if (!Settings.Creatures || !Settings.Attacks || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			IEnumerable<ItemData> source = from item in obj.GetInventory().GetAllItems()
				where item.IsWeapon()
				select item;
			float time = Time.time;
			return Format.JoinLines((from weapon in source
				group weapon by GetDamages(weapon.GetDamage(), weapon.m_shared.m_toolTier) + weapon.m_shared.m_aiAttackInterval + weapon.m_shared.m_aiAttackRange).Select(delegate(IGrouping<string, ItemData> group)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Invalid comparison between Unknown and I4
				//IL_0049: 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)
				ItemData val = group.First();
				SharedData data = val.m_shared;
				Attack attack = data.m_attack;
				bool flag = (int)attack.m_attackType == 3;
				string text = Translate.Name(val, "orange");
				string targetName = GetTargetName(data.m_aiTargetType);
				if (targetName != "")
				{
					text = text + " (" + targetName + ")";
				}
				IEnumerable<string> lines = group.Select((ItemData item) => Format.Progress(Mathf.Min(time - item.m_lastAttackTime, data.m_aiAttackInterval), data.m_aiAttackInterval) + " s");
				text = text + ": " + Format.JoinRow(lines);
				string damages = GetDamages(val.GetDamage(), val.m_shared.m_toolTier);
				if (!flag && damages != "")
				{
					text = text + "\n" + damages;
				}
				text = text + "\nRange: " + Format.Range(data.m_aiAttackRangeMin, data.m_aiAttackRange) + " meters (" + Format.Int(data.m_aiAttackMaxAngle) + " degrees)";
				if (data.m_aiPrioritized)
				{
					text = text + ", " + Format.String("priority");
				}
				if (!flag)
				{
					text = text + ", " + GetAttackType(attack);
				}
				string hitboxText = GetHitboxText(attack);
				if (!flag && hitboxText != "")
				{
					text = text + ", " + hitboxText;
				}
				string projectileText = GetProjectileText(attack);
				if (!flag && projectileText != "")
				{
					text = text + ", " + projectileText;
				}
				if (!attack.m_lowerDamagePerHit)
				{
					text = text + ", " + Format.String("No multitarget penalty");
				}
				if (!flag && (!data.m_blockable || !data.m_dodgeable))
				{
					text += "\n";
					if (!data.m_blockable)
					{
						text += "Can't be blocked";
					}
					if (!data.m_blockable && !data.m_dodgeable)
					{
						text += ", ";
					}
					if (!data.m_dodgeable)
					{
						text += "Can't be dodged";
					}
				}
				return text;
			}));
		}

		public static string GetNoise(Character obj)
		{
			return "Noise: " + Format.Int(obj.m_noiseRange);
		}

		public static string GetStaggerText(float health, float staggerDamageFactor, float staggerDamage)
		{
			float num = staggerDamageFactor * health;
			if (num > 0f)
			{
				return "Stagger: " + Format.Progress(staggerDamage, num);
			}
			return "Stagger: " + Format.String("Immune");
		}

		private static string GetState(Character character, BaseAI baseAI, MonsterAI monsterAI)
		{
			List<string> list = new List<string>();
			if (Object.op_Implicit((Object)(object)monsterAI) && ((BaseAI)monsterAI).IsAlerted())
			{
				list.Add(Format.String("Alerted", "red"));
			}
			if (Object.op_Implicit((Object)(object)monsterAI) && ((BaseAI)monsterAI).HuntPlayer())
			{
				list.Add(Format.String("Hunt mode", "red"));
			}
			if (character.IsStaggering())
			{
				list.Add(Format.String("Staggering", "red"));
			}
			if (Object.op_Implicit((Object)(object)baseAI) && baseAI.IsSleeping())
			{
				list.Add(Format.String("Sleeping", "yellow"));
			}
			string text = Format.JoinRow(list);
			if (text != "")
			{
				return ", " + text;
			}
			return "";
		}

		public static string Get(Character obj, BaseAI baseAI, MonsterAI monsterAI)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Resistances || !Helper.IsValid((MonoBehaviour)(object)obj) || !Object.op_Implicit((Object)(object)baseAI))
			{
				return "";
			}
			List<string> list = new List<string>();
			float mass = obj.m_body.mass;
			if (Object.op_Implicit((Object)(object)monsterAI))
			{
				list.Add(GetState(obj, baseAI, monsterAI));
			}
			float maxHealth = obj.GetMaxHealth();
			list.Add(Text.GetHealth(obj.GetHealth(), maxHealth));
			float staggerDamageFactor = obj.m_staggerDamageFactor;
			if (obj.m_name == "Deathsquito")
			{
				staggerDamageFactor = 0f;
			}
			list.Add(GetStaggerText(maxHealth, staggerDamageFactor, obj.m_staggerDamage));
			Faction faction = obj.GetFaction();
			list.Add("Faction: " + ((object)(Faction)(ref faction)).ToString());
			list.Add("Mass: " + Format.Int(mass) + " (" + Format.Percent(1f - 5f / mass) + " knockback resistance)");
			DamageModifiers damageModifiers = obj.GetDamageModifiers((WeakSpot)null);
			list.Add(DamageModifierUtils.Get(damageModifiers, ignoreNeutral: true, ignoreIgnore: true));
			if (Object.op_Implicit((Object)(object)monsterAI) && ((BaseAI)monsterAI).IsSleeping())
			{
				List<string> list2 = new List<string>();
				if (monsterAI.m_wakeupRange > 0f)
				{
					list2.Add("Wake up range: " + Format.Float(monsterAI.m_wakeupRange) + " m");
				}
				if (monsterAI.m_noiseWakeup)
				{
					list2.Add("Wake up noise range: " + Format.Float(monsterAI.m_maxNoiseWakeupRange) + " m");
				}
				list.Add(Format.JoinRow(list2));
			}
			Vector3 val = default(Vector3);
			if (Object.op_Implicit((Object)(object)baseAI) && baseAI.GetPatrolPoint(ref val))
			{
				list.Add("Patrol: " + Format.String(((Vector3)(ref val)).ToString("F0")));
			}
			if (Object.op_Implicit((Object)(object)monsterAI) && monsterAI.m_consumeItems.Count > 0)
			{
				string item = Translate.Name((IEnumerable<ItemDrop>)monsterAI.m_consumeItems, "#FFFF00");
				list.Add(item);
			}
			return Format.JoinLines(list);
		}

		private static string Get(StatusEffect statusEffect)
		{
			return Localization.instance.Localize(statusEffect.m_name) + ": " + Format.Progress(statusEffect.GetRemaningTime(), statusEffect.m_ttl) + " seconds";
		}

		public static string GetStatusStats(Character character)
		{
			if (!Settings.Status || !Object.op_Implicit((Object)(object)character))
			{
				return "";
			}
			return Format.JoinLines(((IEnumerable<StatusEffect>)character.GetSEMan().GetStatusEffects()).Select((Func<StatusEffect, string>)Get));
		}

		public static string Get(BaseAI baseAI, Growup growup)
		{
			if (!Settings.Breeding || !Object.op_Implicit((Object)(object)baseAI) || !Object.op_Implicit((Object)(object)growup))
			{
				return "";
			}
			double totalSeconds = baseAI.GetTimeSinceSpawned().TotalSeconds;
			float growTime = growup.m_growTime;
			return Format.ProgressPercent("Progress", totalSeconds, growTime);
		}

		private static List<string> GetDropTexts(CharacterDrop characterDrop, Character character)
		{
			List<string> list = new List<string>();
			int num = ((!Object.op_Implicit((Object)(object)character)) ? 1 : Mathf.Max(1, (int)Mathf.Pow(2f, (float)(character.GetLevel() - 1))));
			foreach (Drop drop in characterDrop.m_drops)
			{
				if (!((Object)(object)drop.m_prefab == (Object)null))
				{
					float num2 = drop.m_chance;
					if (drop.m_levelMultiplier)
					{
						num2 *= (float)num;
					}
					int num3 = drop.m_amountMin;
					int num4 = Math.Max(num3, drop.m_amountMax - 1);
					if (drop.m_levelMultiplier)
					{
						num3 *= num;
						num4 *= num;
					}
					string text = "";
					if (num4 > 1 || (num4 == 1 && (double)num2 >= 1.0))
					{
						text = text + Format.Range(num3, num4) + " ";
					}
					text += ((Object)drop.m_prefab).name;
					if (drop.m_onePerPlayer)
					{
						text += " (per player)";
					}
					if ((double)num2 < 1.0)
					{
						text = text + " (" + Format.Percent(num2) + ")";
					}
					list.Add(text);
				}
			}
			return list;
		}

		public static string Get(CharacterDrop characterDrop, Character character)
		{
			if (!Settings.Drops || !Object.op_Implicit((Object)(object)characterDrop) || !Object.op_Implicit((Object)(object)character))
			{
				return "";
			}
			string text = Format.JoinRow(GetDropTexts(characterDrop, character));
			return "Drops: " + text;
		}

		private static string FireRange(BaseAI obj)
		{
			if (Settings.IsDisabled("CreatureFireRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			if (!obj.m_afraidOfFire && !obj.m_avoidFire)
			{
				return "";
			}
			return (obj.m_afraidOfFire ? "Fears fire" : "Avoids fire") + ": " + Format.Meters(3.0);
		}

		private static string ViewRange(BaseAI obj)
		{
			if (Settings.IsDisabled("CreatureViewRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "View range: " + Format.Meters(obj.m_viewRange) + "\nView angle: " + Format.Degrees(obj.m_viewAngle);
		}

		private static string Hearing(BaseAI obj)
		{
			if (Settings.IsDisabled("CreatureHearRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			float hearRange = obj.m_hearRange;
			return "Hear range: " + ((hearRange > 100f) ? Format.String("Infinite") : Format.Meters(hearRange));
		}

		private static string AlertRange(MonsterAI obj)
		{
			if (Settings.IsDisabled("CreatureAlertRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "Alert range: " + Format.Meters(obj.m_alertRange) + "\nAlert angle: " + Format.Degrees(((BaseAI)obj).m_viewAngle);
		}

		private static string BreedingLimit(Procreation obj)
		{
			if (Settings.IsDisabled("CreatureBreedingTotalRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "Breeding limit: " + Format.Meters(obj.m_totalCheckRange);
		}

		private static string PartnerSearch(Procreation obj)
		{
			if (Settings.IsDisabled("CreatureBreedingPartnerRange") || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "Partner search: " + Format.Meters(obj.m_partnerCheckRange);
		}

		private static string FoodLimit(MonsterAI obj)
		{
			if (Settings.IsDisabled("CreatureFoodSearchRange") || !Helper.IsValid((MonoBehaviour)(object)obj) || obj.m_consumeItems.Count == 0)
			{
				return "";
			}
			return "Food search: " + Format.Meters(obj.m_consumeSearchRange);
		}

		private static string GetEatRange(MonsterAI obj)
		{
			if (Settings.IsDisabled("CreatureEatingRange") || !Helper.IsValid((MonoBehaviour)(object)obj) || obj.m_consumeItems.Count == 0)
			{
				return "";
			}
			return "Eat range: " + Format.Meters(obj.m_consumeRange);
		}

		public static string GetSenses(BaseAI obj, MonsterAI monsterAI, Procreation procreation)
		{
			return Format.JoinLines(new List<string>(8)
			{
				FireRange(obj),
				ViewRange(obj),
				AlertRange(monsterAI),
				Hearing(obj),
				BreedingLimit(procreation),
				PartnerSearch(procreation),
				FoodLimit(monsterAI),
				GetEatRange(monsterAI)
			});
		}

		public static string Get(string id, ZDO zdo)
		{
			List<string> list = FormatLoading.Get(Settings.Custom, zdo.m_prefab);
			if (list == null || list.Count == 0)
			{
				return "";
			}
			ObjectParameters @object = new ObjectParameters(id, "", zdo);
			return Format.JoinLines(list.Select(@object.Replace));
		}

		public static string Get(ItemDrop obj)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || !Settings.ItemDrops)
			{
				return "";
			}
			List<string> list = new List<string>();
			double timeSinceSpawned = obj.GetTimeSinceSpawned();
			list.Add("Stack size: " + Format.Int(obj.m_itemData.m_shared.m_maxStackSize));
			bool flag = obj.IsInsideBase();
			bool flag2 = Player.IsPlayerInRange(((Component)obj).transform.position, 25f);
			list.Add(Format.ProgressPercent("Despawn timer", timeSinceSpawned, 3600.0));
			if (flag)
			{
				list.Add(Format.String("Despawn prevented by player base", "green"));
			}
			else if (timeSinceSpawned > 3600.0 && !flag && flag2)
			{
				list.Add(Format.String("Despawn prevented by a nearby player (25 meters)", "green"));
			}
			else
			{
				list.Add(Format.String("Despawning", "red"));
			}
			return Format.JoinLines(list);
		}

		private static string GetTime(CreatureSpawner obj)
		{
			if (!obj.m_spawnAtDay)
			{
				return "Only during " + Format.String("night");
			}
			if (!obj.m_spawnAtNight)
			{
				return "Only during " + Format.String("day");
			}
			return "";
		}

		private static string GetRespawnTime(CreatureSpawner obj)
		{
			if (obj.m_respawnTimeMinuts == 0f)
			{
				return "Never";
			}
			double elapsed = Helper.GetElapsed((MonoBehaviour)(object)obj, "alive_time", 0L);
			return ((elapsed == 0.0) ? "Alive" : elapsed.ToString("N0")) + " / " + (60f * obj.m_respawnTimeMinuts).ToString("N0") + " seconds";
		}

		private static string GetRespawnTime(Pickable obj)
		{
			if (obj.m_respawnTimeMinutes == 0f)
			{
				return "Never";
			}
			double value = Helper.GetElapsed((MonoBehaviour)(object)obj, "picked_time", 0L) / 60.0;
			return (Helper.GetBool((MonoBehaviour)(object)obj, "picked") ? Format.Int(value) : Format.String("Not picked")) + " / " + Format.Int(obj.m_respawnTimeMinutes) + " minutes";
		}

		public static string Get(Pickable obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || !Settings.Pickables)
			{
				return "";
			}
			List<string> list = new List<string>();
			string respawnTime = GetRespawnTime(obj);
			list.Add("Item: " + Format.String(Object.op_Implicit((Object)(object)obj.m_itemPrefab) ? Utils.GetPrefabName(obj.m_itemPrefab) : "None"));
			list.Add("Respawn: " + respawnTime);
			if (obj.m_amount > 1)
			{
				list.Add("Amount: " + Format.Int(obj.m_amount));
			}
			return Format.JoinLines(list);
		}

		public static string Get(CreatureSpawner obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			string respawnTime = GetRespawnTime(obj);
			string text = ((obj.m_triggerNoise > 0f) ? (" with noise of " + Format.Int(obj.m_triggerNoise)) : "");
			list.Add("Respawn: " + Format.String(respawnTime));
			list.Add(Text.GetLevel(obj.m_minLevel, obj.m_maxLevel, 10.0));
			string time = GetTime(obj);
			if (time.Length > 0)
			{
				list.Add(time);
			}
			if (obj.m_setPatrolSpawnPoint)
			{
				list.Add("Patrol point");
			}
			list.Add("Activates within " + Format.Int(obj.m_triggerDistance) + " meters" + text);
			return Format.JoinLines(list);
		}

		private static string GetEventText()
		{
			RandEventSystem instance = RandEventSystem.instance;
			return Text.GetAttempt(instance.m_eventTimer, instance.m_eventIntervalMin * 60f, instance.m_eventChance);
		}

		private static string GetEventsText()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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)
			RandEventSystem instance = RandEventSystem.instance;
			PlayerEventData val = default(PlayerEventData);
			val.baseValue = Player.m_localPlayer.m_baseValue;
			val.position = ((Component)Player.m_localPlayer).transform.position;
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string readyEvent in Player.m_localPlayer.m_readyEvents)
			{
				hashSet.Add(readyEvent);
			}
			val.possibleEvents = hashSet;
			PlayerEventData playerEventData = val;
			List<PlayerEventData> data = new List<PlayerEventData>(1) { playerEventData };
			Biome currentBiome = WorldGenerator.instance.GetBiome(((Component)Player.m_localPlayer).transform.position);
			return Format.JoinLines(instance.m_events.Where((RandomEvent randomEvent) => randomEvent.m_enabled && randomEvent.m_random).Select(delegate(RandomEvent randomEvent)
			{
				//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_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Invalid comparison between Unknown and I4
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				bool num = (currentBiome & randomEvent.m_biome) > 0;
				bool flag = instance.CheckBase(randomEvent, playerEventData);
				bool flag2 = instance.HaveGlobalKeys(randomEvent, data);
				bool valid = num && flag && flag2;
				List<string> lines = new List<string>(3)
				{
					GetNames(randomEvent.m_biome, currentBiome),
					Text.GetGlobalKeys(randomEvent.m_requiredGlobalKeys, randomEvent.m_notRequiredGlobalKeys),
					randomEvent.m_nearBaseOnly ? Format.String("player base", flag) : ""
				};
				return Format.String(randomEvent.m_name, valid) + ": " + Format.JoinRow(lines);
			}));
		}

		private static string GetSpawnerText(SpawnSystem obj, SpawnData spawnData, int stableHashCode)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			double elapsed = Helper.GetElapsed((MonoBehaviour)(object)obj, stableHashCode, 0L);
			string text = "";
			if (!spawnData.m_inForest)
			{
				text = ", only outside forests";
			}
			if (!spawnData.m_outsideForest)
			{
				text = ", only inside forests";
			}
			int nrOfInstances = SpawnSystem.GetNrOfInstances(spawnData.m_prefab, ((Component)Player.m_localPlayer).transform.position, 0f, true, false);
			string text2 = Format.ProgressPercent("Attempt", elapsed, spawnData.m_spawnInterval);
			string text3 = Format.Percent((double)spawnData.m_spawnChance / 100.0) + " chance";
			string text4 = Format.Progress(nrOfInstances, spawnData.m_maxSpawned);
			string text5 = Format.Int(spawnData.m_spawnDistance) + " meters";
			string level = Text.GetLevel(spawnData.m_minLevel, spawnData.m_maxLevel, 10.0, spawnData.m_levelUpMinCenterDistance);
			string text6 = Format.Range(spawnData.m_groupSizeMin, spawnData.m_groupSizeMax);
			string text7 = ((spawnData.m_groupSizeMax > spawnData.m_groupSizeMin) ? (" within " + Format.Int(spawnData.m_groupRadius) + " meters") : "");
			string text8 = Format.Range(spawnData.m_minAltitude, spawnData.m_maxAltitude);
			string text9 = ((spawnData.m_groundOffset > 0f) ? (", " + Format.Int(spawnData.m_groundOffset) + " meters off ground") : "");
			string text10 = Format.Range(spawnData.m_minTilt, spawnData.m_maxTilt);
			string text11 = Format.Range(spawnData.m_minOceanDepth, spawnData.m_maxOceanDepth);
			string text12 = (spawnData.m_huntPlayer ? ", forces hunt mode" : "");
			list.Add("Creature: " + Format.String(((Object)spawnData.m_prefab).name) + text12);
			list.Add("Altitude: " + text8 + text9 + ", Ocean depth: " + text11 + ", Tilt: " + text10);
			list.Add(text2 + ", " + text3);
			string biomes = GetBiomes(spawnData.m_biome, spawnData.m_biomeArea);
			if (biomes.Length > 0)
			{
				list.Add(biomes + text);
			}
			list.Add("Creature limit: " + text4 + ", Distance limit: " + text5);
			list.Add(level + ", Group size: " + text6 + text7);
			return Format.JoinLines(list);
		}

		public static string GetRandomEvent(SpawnSystem obj)
		{
			SpawnSystem obj2 = obj;
			RandEventSystem instance = RandEventSystem.instance;
			string text = GetEventText() + "\n\n";
			int num = 0;
			RandomEvent currentRandomEvent = instance.GetCurrentRandomEvent();
			if (currentRandomEvent == null || instance.GetCurrentSpawners() == null)
			{
				return text + GetEventsText();
			}
			text = text + Format.ProgressPercent(currentRandomEvent.m_name, currentRandomEvent.m_time, currentRandomEvent.m_duration) + "\n";
			IEnumerable<string> lines = instance.GetCurrentSpawners().Select(delegate(SpawnData spawnData)
			{
				num++;
				int stableHashCode = StringExtensionMethods.GetStableHashCode("e_" + ((Object)spawnData.m_prefab).name + num);
				return GetSpawnerText(obj2, spawnData, stableHashCode);
			});
			return text + Format.JoinLines(lines);
		}

		private static string GetZoneText(SpawnSystem obj)
		{
			//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_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_0051: 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)
			//IL_005d: 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_0064: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)obj).transform.position;
			Heightmap heightmap = obj.m_heightmap;
			Vector2i zone = ZoneSystem.GetZone(position);
			string text = "Zone: " + Format.String(zone.x + ";" + zone.y);
			Biome biome = heightmap.GetBiome(position, 0.02f, false);
			string text2 = (((int)heightmap.GetBiomeArea() == 2) ? ", full" : "");
			text = text + " (" + Translate.Name(biome) + text2 + ")";
			return text + "\n";
		}

		public static string Get(SpawnSystem obj, SpawnData spawnData, int stableHashCode)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			double elapsed = Helper.GetElapsed((MonoBehaviour)(object)obj, stableHashCode, 0L);
			list.Add(GetZoneText(obj));
			string text = "";
			if (!spawnData.m_spawnAtDay)
			{
				text = ", only during " + Format.String("night");
			}
			if (!spawnData.m_spawnAtNight)
			{
				text = ", only during " + Format.String("day");
			}
			string text2 = "";
			if (!spawnData.m_inForest)
			{
				text2 = ", only outside forests";
			}
			if (!spawnData.m_outsideForest)
			{
				text2 = ", only inside forests";
			}
			int nrOfInstances = SpawnSystem.GetNrOfInstances(spawnData.m_prefab, ((Component)Player.m_localPlayer).transform.position, 0f, false, false);
			string text3 = ((spawnData.m_requiredEnvironments.Count > 0) ? (", Weather: " + Format.String(Format.JoinRow(spawnData.m_requiredEnvironments))) : "");
			string text4 = ((spawnData.m_requiredGlobalKey != "") ? (", Bosses: " + Format.String(spawnData.m_requiredGlobalKey)) : "");
			string text5 = Format.Progress(nrOfInstances, spawnData.m_maxSpawned);
			string text6 = Format.Int(spawnData.m_spawnDistance) + " meters";
			string level = Text.GetLevel(spawnData.m_minLevel, spawnData.m_maxLevel, 10.0, spawnData.m_levelUpMinCenterDistance);
			string text7 = Format.Range(spawnData.m_groupSizeMin, spawnData.m_groupSizeMax);
			string text8 = ((spawnData.m_groupSizeMax > spawnData.m_groupSizeMin) ? (" within " + Format.Int(spawnData.m_groupRadius) + " meters") : "");
			string text9 = Format.Range(spawnData.m_minAltitude, spawnData.m_maxAltitude);
			string text10 = ((spawnData.m_groundOffset > 0f) ? (", " + Format.Int(spawnData.m_groundOffset) + " meters off ground") : "");
			string text11 = Format.Range(spawnData.m_minTilt, spawnData.m_maxTilt);
			string text12 = Format.Range(spawnData.m_minOceanDepth, spawnData.m_maxOceanDepth);
			string text13 = (spawnData.m_huntPlayer ? ", forces hunt mode" : "");
			string text14 = Format.Range((spawnData.m_spawnRadiusMin > 0f) ? spawnData.m_spawnRadiusMin : 40f, (spawnData.m_spawnRadiusMax > 0f) ? spawnData.m_spawnRadiusMax : 80f) + " meters";
			list.Add("Creature: " + Format.String(((Object)spawnData.m_prefab).name) + text13);
			list.Add(Text.GetAttempt(elapsed, spawnData.m_spawnInterval, spawnData.m_spawnChance));
			string biomes = GetBiomes(spawnData.m_biome, spawnData.m_biomeArea);
			list.Add(biomes + text2 + text2 + text3 + text4 + text);
			list.Add("Creature limit: " + text5 + ", Distance limit: " + text6 + ", From players: " + text14);
			list.Add(level + ", Group size: " + text7 + text8);
			list.Add("Altitude: " + text9 + text10 + ", Tilt: " + text11 + ", Water: " + text12);
			return Format.JoinLines(list);
		}

		private static string Get(ComfortGroup group)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			if ((int)group == 3)
			{
				return "Banner";
			}
			if ((int)group == 2)
			{
				return "Bed";
			}
			if ((int)group == 4)
			{
				return "Chair";
			}
			if ((int)group == 1)
			{
				return "Fire";
			}
			return "None";
		}

		public static string Get(TreeLog obj)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Invalid comparison between Unknown and I4
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Destructibles || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float health = obj.m_health;
			float @float = Helper.GetFloat((MonoBehaviour)(object)obj, "health", health);
			list.Add(Text.GetHealth(@float, health));
			list.Add("Hit noise: " + Format.Int(obj.m_hitNoise));
			if (Object.op_Implicit((Object)(object)obj.m_subLogPrefab))
			{
				list.Add("Destroy creates: " + Format.Int(obj.m_subLogPoints.Length) + " " + Translate.Id(obj.m_subLogPrefab));
			}
			list.Add(GetToolTier(obj.m_minToolTier, (int)obj.m_damages.m_chop != 3, (int)obj.m_damages.m_pickaxe != 3));
			list.Add(DamageModifierUtils.Get(obj.m_damages, ignoreNeutral: false, ignoreIgnore: false));
			list.Add(Get(obj.m_dropWhenDestroyed, 1));
			return Format.JoinLines(list);
		}

		public static string Get(DropTable obj, int areas)
		{
			if (obj == null || obj.m_drops.Count == 0)
			{
				return "";
			}
			List<string> list = new List<string>();
			if (obj.m_oneOfEach && obj.m_dropMin == obj.m_dropMax && obj.m_dropMin == obj.m_drops.Count)
			{
				list.Add("Drops:");
				IEnumerable<string> collection = obj.m_drops.Select(delegate(DropData drop)
				{
					//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_008a: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
					double num4 = (double)(drop.m_stackMin + drop.m_stackMax) / 2.0;
					string text5 = Format.Float(num4);
					if (areas > 1)
					{
						text5 = text5 + " * " + Format.Int(areas) + " = " + Format.Float((double)areas * num4);
					}
					return Translate.Id(drop.m_item, "white") + ": " + Format.Range(drop.m_stackMin, drop.m_stackMax) + " items (" + text5 + " on average)";
				});
				list.AddRange(collection);
			}
			else
			{
				string text = ((obj.m_dropChance == 1f) ? "" : (Format.Percent(obj.m_dropChance) + " chance for "));
				string text2 = "Drops: " + text + Format.Range(obj.m_dropMin, obj.m_dropMax) + " drops";
				if (obj.m_oneOfEach)
				{
					text2 += " (max one of each)";
				}
				list.Add(text2);
				double averageDrops = (double)(obj.m_dropChance * (float)(obj.m_dropMin + obj.m_dropMax)) / 2.0;
				float weight = obj.m_drops.Sum((DropData drop) => drop.m_weight);
				IEnumerable<string> collection2 = obj.m_drops.Select(delegate(DropData drop)
				{
					//IL_0014: 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_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_0103: Unknown result type (might be due to invalid IL or missing references)
					float num = ((weight > 0f) ? (drop.m_weight / weight) : 1f);
					int stackMin = drop.m_stackMin;
					int num2 = drop.m_stackMax;
					if (drop.m_dontScale && num2 > stackMin)
					{
						num2--;
					}
					double num3 = averageDrops * (double)num * (double)(stackMin + num2) / 2.0;
					string text3 = ((num == 1f) ? "" : (Format.Percent(num) + " chance for "));
					string text4 = Format.Float(num3);
					if (areas > 1)
					{
						text4 = text4 + " * " + Format.Int(areas) + " = " + Format.Float((double)areas * num3);
					}
					return Translate.Id(drop.m_item, "white") + ": " + text3 + Format.Range(stackMin, num2) + " items (" + text4 + " on average)";
				});
				list.AddRange(collection2);
			}
			return Format.JoinLines(list);
		}

		private static string GetBoundingBox(MonoBehaviour obj)
		{
			//IL_0083: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			string text = Format.JoinRow((from collider in (from collider in ((Component)obj).GetComponentsInChildren<Collider>()
					where !IgnoredLayers.Contains(((Component)collider).gameObject.layer)
					select collider).ToArray()
				select LayerMask.LayerToName(((Component)collider).gameObject.layer)).ToHashSet());
			if (!BoundsCache.Bounds.TryGetValue(Utils.GetPrefabName(((Component)obj).gameObject), out var value))
			{
				return "Bounds: Unknown.";
			}
			Vector3 lossyScale = ((Component)obj).transform.lossyScale;
			string text2 = Format.Coordinates(lossyScale, "F2");
			if (Math.Abs(lossyScale.x - lossyScale.y) < 0.01f && Math.Abs(lossyScale.x - lossyScale.z) < 0.01f)
			{
				if (Math.Abs(lossyScale.x - 1f) < 0.01f)
				{
					return "Bounds: " + Format.Coordinates(value, "F3") + " (" + text + ")";
				}
				text2 = Format.Float(lossyScale.x);
			}
			return "Bounds: " + Format.Coordinates(value, "F2") + " with scale " + text2 + " (" + text + ")";
		}

		public static string Get(TreeBase obj)
		{
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Invalid comparison between Unknown and I4
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Invalid comparison between Unknown and I4
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Destructibles || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float health = obj.m_health;
			float @float = Helper.GetFloat((MonoBehaviour)(object)obj, "health", health);
			list.Add(Text.GetHealth(@float, health));
			list.Add("Hit noise: " + Format.Int(100.0));
			if (Object.op_Implicit((Object)(object)obj.m_logPrefab))
			{
				list.Add("Destroy creates: " + Translate.Id(obj.m_logPrefab));
			}
			list.Add(GetToolTier(obj.m_minToolTier, (int)obj.m_damageModifiers.m_chop != 3, (int)obj.m_damageModifiers.m_pickaxe != 3));
			list.Add(DamageModifierUtils.Get(obj.m_damageModifiers, ignoreNeutral: false, ignoreIgnore: false));
			list.Add(Get(obj.m_dropWhenDestroyed, 1));
			list.Add(GetBoundingBox((MonoBehaviour)(object)obj));
			return Format.JoinLines(list);
		}

		public static string Get(Destructible obj)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Invalid comparison between Unknown and I4
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Destructibles || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float health = obj.m_health;
			float @float = Helper.GetFloat((MonoBehaviour)(object)obj, "health", health);
			list.Add(Text.GetHealth(@float, health));
			list.Add("Hit noise: " + Format.Int(obj.m_hitNoise));
			list.Add("Destroy noise: " + Format.Int(obj.m_destroyNoise));
			if (Object.op_Implicit((Object)(object)obj.m_spawnWhenDestroyed))
			{
				list.Add("Destroy creates: " + Translate.Id(obj.m_spawnWhenDestroyed));
			}
			list.Add(GetToolTier(obj.m_minToolTier, (int)obj.m_damages.m_chop != 3, (int)obj.m_damages.m_pickaxe != 3));
			list.Add(DamageModifierUtils.Get(obj.m_damages, ignoreNeutral: false, ignoreIgnore: false));
			return Format.JoinLines(list);
		}

		public static string Get(DropOnDestroyed obj)
		{
			if (!Settings.Destructibles || !Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return Format.JoinLines(new List<string>(1) { Get(obj.m_dropWhenDestroyed, 1) });
		}

		private static string GetMaterialName(MaterialType material)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if ((int)material == 3)
			{
				return "Hard wood";
			}
			if ((int)material == 1)
			{
				return "Stone";
			}
			if ((int)material == 2)
			{
				return "Iron";
			}
			if ((int)material == 0)
			{
				return "Wood";
			}
			return "Unknown";
		}

		public static string Get(WearNTear obj)
		{
			//IL_0040: 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)
			if (!Settings.Structures || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float health = obj.m_health;
			float @float = Helper.GetFloat((MonoBehaviour)(object)obj, "health", health);
			list.Add(Text.GetHealth(@float, health));
			list.Add(DamageModifierUtils.Get(obj.m_damages, ignoreNeutral: true, ignoreIgnore: false));
			if (SupportUtils.Enabled(obj))
			{
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				float num4 = default(float);
				obj.GetMaterialProperties(ref num, ref num2, ref num3, ref num4);
				float num5 = Math.Min(Helper.GetFloat((MonoBehaviour)(object)obj, "support", num), num);
				list.Add(Format.String(GetMaterialName(obj.m_materialType)) + ": " + Format.Progress(num5, num2) + " support");
				list.Add(Format.Percent(num3) + " horizontal loss, " + Format.Percent(num4) + " vertical loss");
			}
			list.Add(GetBoundingBox((MonoBehaviour)(object)obj));
			return Format.JoinLines(list);
		}

		public static string Get(Piece obj)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Structures || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			string text = "";
			if (obj.m_comfort > 0)
			{
				text = text + "Comfort: " + Format.Int(obj.m_comfort);
				if ((int)obj.m_comfortGroup != 0)
				{
					text = text + " (" + Get(obj.m_comfortGroup) + ")";
				}
			}
			return text;
		}

		public static string Get(Beehive obj)
		{
			if (!Settings.Structures || !Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float secPerUnit = obj.m_secPerUnit;
			if (secPerUnit > 0f)
			{
				float @float = Helper.GetFloat((MonoBehaviour)(object)obj, "product");
				list.Add(Format.ProgressPercent("Progress", @float, secPerUnit));
			}
			list.Add(GetCover(obj));
			return Format.JoinLines(list);
		}

		public static string GetCover(Beehive obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), obj.m_maxCover, checkRoof: false, minLimit: false);
		}

		public static string GetCover(Player obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), 0.800000011920929);
		}

		private static string GetItem(CookingStation obj, int slot)
		{
			return Helper.GetString((MonoBehaviour)(object)obj, "slot" + slot);
		}

		private static float GetTime(CookingStation obj, int slot)
		{
			return Helper.GetFloat((MonoBehaviour)(object)obj, "slot" + slot);
		}

		private static string GetSlotText(CookingStation obj, int slot)
		{
			string item = GetItem(obj, slot);
			float time = GetTime(obj, slot);
			if (item == "")
			{
				return "";
			}
			ItemConversion itemConversion = obj.GetItemConversion(item);
			if (itemConversion == null)
			{
				return "";
			}
			float cookTime = itemConversion.m_cookTime;
			if (cookTime == 0f)
			{
				return "";
			}
			float num = time;
			return Format.ProgressPercent("Progress", num, cookTime);
		}

		public static string Get(CookingStation obj)
		{
			if (!Settings.Structures || !Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			for (int i = 0; i < obj.m_slots.Length; i++)
			{
				list.Add(GetSlotText(obj, i));
			}
			return Format.JoinLines(list);
		}

		public static string Get(Fermenter obj)
		{
			if (!Settings.Structures || !Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float fermentationDuration = obj.m_fermentationDuration;
			if (fermentationDuration > 0f)
			{
				double fermentationTime = obj.GetFermentationTime();
				list.Add(Format.ProgressPercent("Progress", fermentationTime, fermentationDuration));
			}
			list.Add(GetCover(obj));
			return Format.JoinLines(list);
		}

		public static string GetCover(Fermenter obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), 0.699999988079071);
		}

		public static string Get(SmokeSpawner obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>(2);
			list.Add(GetSmokeLimit());
			list.Add("Produces smoke every " + Format.Float(obj.m_interval) + " s, unless smoke within " + Format.Float(obj.m_testRadius) + " m");
			return Format.JoinLines(list);
		}

		public static string Get(Smoke obj)
		{
			//IL_00d1: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			SphereCollider component = ((Component)obj).GetComponent<SphereCollider>();
			list.Add(": " + Format.Progress(Smoke.GetTotalSmoke(), 100.0, percent: true));
			list.Add(Format.ProgressPercent("Expires", obj.m_time, obj.m_ttl));
			if (Object.op_Implicit((Object)(object)component))
			{
				list.Add("Radius: " + Format.Float(component.radius * ((Component)obj).transform.lossyScale.x));
			}
			Rigidbody body = obj.m_body;
			list.Add("Mass: " + Format.Float(body.mass));
			Vector3 linearVelocity = body.linearVelocity;
			list.Add("Velocity: " + Format.String(((Vector3)(ref linearVelocity)).ToString("F3")));
			float num = 1f - Mathf.Clamp01(obj.m_time / obj.m_ttl);
			Vector3 vel = obj.m_vel;
			vel.y *= num;
			list.Add("Target: " + Format.String(((Vector3)(ref vel)).ToString("F3")));
			return Format.JoinLines(list);
		}

		private static string GetSmokeLimit()
		{
			return "Smoke: " + Format.Progress(Smoke.GetTotalSmoke(), 100.0, percent: true);
		}

		public static string Get(Fireplace obj)
		{
			if (!Settings.Structures || !Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float secPerFuel = obj.m_secPerFuel;
			if (secPerFuel > 0f)
			{
				float num = Helper.GetFloat((MonoBehaviour)(object)obj, "fuel") * secPerFuel;
				list.Add(Format.ProgressPercent("Progress", num, secPerFuel));
			}
			list.Add(GetCover(obj));
			return Format.JoinLines(list);
		}

		private static string GetWind(Fireplace obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || !CoverUtils.ChecksCover(obj))
			{
				return "";
			}
			float windIntensity = EnvMan.instance.GetWindIntensity();
			float num = 0.8f;
			bool flag = windIntensity >= num;
			return string.Concat("Wind (" + Format.Percent(num, flag ? "red" : "yellow") + ")", ": ", Format.Percent(windIntensity));
		}

		private static string GetDistanceFromRoof(Fireplace obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(CoverUtils.GetCoverPoint(obj), Vector3.up, ref val, 0.5f, Fireplace.m_solidRayMask))
			{
				float distance = ((RaycastHit)(ref val)).distance;
				return "Roof (" + Format.Float(0.5, "0.##", "red") + " m): " + Format.Float(distance) + " m";
			}
			return "";
		}

		public static string GetCover(Fireplace obj)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			if (CoverUtils.ChecksCover(obj))
			{
				list.Add(GetCover(CoverUtils.GetCoverPoint(obj), 0.699999988079071, checkRoof: false));
			}
			list.Add(GetWind(obj));
			list.Add(GetDistanceFromRoof(obj));
			return Format.JoinLines(list);
		}

		public static string Get(MineRock obj)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Invalid comparison between Unknown and I4
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			MineRock obj2 = obj;
			if (!Settings.Destructibles || !Helper.IsValid((MonoBehaviour)(object)obj2))
			{
				return "";
			}
			List<string> list = new List<string>();
			float maxHealth = obj2.m_health;
			Collider[] hitAreas = obj2.m_hitAreas;
			int index = 0;
			int num = hitAreas.Count(delegate
			{
				string key = "Health" + index;
				index++;
				return Helper.GetFloat((MonoBehaviour)(object)obj2, key, maxHealth) > 0f;
			});
			list.Add("Areas: " + Format.Progress(num, hitAreas.Length));
			list.Add("Health per area: " + Format.Int(maxHealth));
			list.Add("Hit noise: " + Format.Int(100.0));
			list.Add(GetToolTier(obj2.m_minToolTier, (int)obj2.m_damageModifiers.m_chop != 3, (int)obj2.m_damageModifiers.m_pickaxe != 3));
			list.Add(DamageModifierUtils.Get(obj2.m_damageModifiers, ignoreNeutral: false, ignoreIgnore: false));
			list.Add(Get(obj2.m_dropItems, hitAreas.Length));
			return Format.JoinLines(list);
		}

		public static string Get(MineRock5 obj)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Invalid comparison between Unknown and I4
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Destructibles || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float health = obj.m_health;
			List<HitArea> hitAreas = obj.m_hitAreas;
			int num = hitAreas.Count((HitArea area) => area.m_health > 0f);
			list.Add("Areas: " + Format.Progress(num, hitAreas.Count()));
			list.Add("Health per area: " + Format.Int(health));
			list.Add("Hit noise: " + Format.Int(100.0));
			list.Add(GetToolTier(obj.m_minToolTier, (int)obj.m_damageModifiers.m_chop != 3, (int)obj.m_damageModifiers.m_pickaxe != 3));
			list.Add(DamageModifierUtils.Get(obj.m_damageModifiers, ignoreNeutral: false, ignoreIgnore: false));
			list.Add(Get(obj.m_dropItems, hitAreas.Count()));
			return Format.JoinLines(list);
		}

		public static string Get(Plant obj)
		{
			if (!Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float growTime = obj.GetGrowTime();
			if (growTime > 0f)
			{
				double value = obj.TimeSincePlanted();
				list.Add(Format.ProgressPercent("Progress", value, growTime));
			}
			list.Add("Radius: " + Format.Meters(obj.m_growRadius));
			list.Add("Grows: " + Translate.Name((IEnumerable<GameObject>)obj.m_grownPrefabs, "#FFFF00"));
			if (obj.m_destroyIfCantGrow)
			{
				list.Add("Destroyed if can't grow");
			}
			return Format.JoinLines(list);
		}

		public static string Get(EffectArea obj)
		{
			//IL_0009: 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)
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || Settings.IsDisabled(Tag.GetEffectArea(obj.m_type)))
			{
				return "";
			}
			return EffectAreaUtils.GetTypeText(obj.m_type) + " " + Text.Radius(obj.GetRadius());
		}

		public static string Get(PrivateArea obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || Settings.IsDisabled("EffectAreaPrivateArea"))
			{
				return "";
			}
			return "Protection " + Text.Radius(obj.m_radius);
		}

		private static string GetProgressText(Smelter obj)
		{
			float secPerProduct = obj.m_secPerProduct;
			if (secPerProduct == 0f)
			{
				return "";
			}
			float bakeTimer = obj.GetBakeTimer();
			return Format.ProgressPercent("Progress", bakeTimer, secPerProduct);
		}

		private static string GetFuelText(Smelter obj)
		{
			int maxFuel = obj.m_maxFuel;
			float num = obj.m_secPerProduct / (float)obj.m_fuelPerProduct;
			if (maxFuel == 0)
			{
				return "";
			}
			float num2 = (float)maxFuel * num;
			if (num2 == 0f)
			{
				return "";
			}
			float num3 = obj.GetFuel() * num;
			return Format.ProgressPercent("Fuel", num3, num2);
		}

		private static string GetPowerText(Windmill obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			float num = Utils.LerpStep(obj.m_minWindSpeed, 1f, EnvMan.instance.GetWindIntensity());
			string text = "Power: " + Format.Percent(obj.GetPowerOutput());
			string text2 = Format.Percent(num) + " speed";
			string text3 = Format.Percent(obj.m_cover) + " cover";
			return text + " from " + text2 + " and " + text3;
		}

		public static string Get(Smelter obj)
		{
			if (!Settings.Structures || !Settings.Progress || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return Format.JoinLines(new List<string>(3)
			{
				GetProgressText(obj),
				GetFuelText(obj),
				Object.op_Implicit((Object)(object)obj.m_windmill) ? GetPowerText(obj.m_windmill) : GetSmokeLimit()
			});
		}

		private static float GetRelativeAngle(Ship ship)
		{
			//IL_0006: 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_0015: 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_0031: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)ship).transform.forward * 1f;
			val.y = 0f;
			Vector3 val2 = EnvMan.instance.GetWindDir() * 1f;
			val2.y = 0f;
			return Vector3.Angle(val, val2);
		}

		private static double GetWindPower(Ship ship)
		{
			float windIntensity = EnvMan.instance.GetWindIntensity();
			return Mathf.Lerp(0.25f, 1f, windIntensity) * ship.GetWindAngleFactor();
		}

		public static float GetShipForwardSpeed(Ship obj)
		{
			return obj.GetSpeed();
		}

		public static float GetShipSpeed(Ship obj)
		{
			//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)
			Vector3 linearVelocity = obj.m_body.linearVelocity;
			linearVelocity.y = 0f;
			return ((Vector3)(ref linearVelocity)).magnitude;
		}

		public static void UpdateAverageSpeed(Ship obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				shipSpeeds.Clear();
				shipForwardSpeeds.Clear();
				return;
			}
			shipSpeeds.Enqueue(GetShipSpeed(obj));
			if (shipSpeeds.Count > 2000)
			{
				shipSpeeds.Dequeue();
			}
			shipForwardSpeeds.Enqueue(Math.Abs(GetShipForwardSpeed(obj)));
			if (shipForwardSpeeds.Count > 2000)
			{
				shipForwardSpeeds.Dequeue();
			}
		}

		public static string Get(Ship obj)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			List<string> list = new List<string>();
			float shipForwardSpeed = GetShipForwardSpeed(obj);
			double value = 90.0 - (double)Mathf.Atan2(((Component)obj).transform.forward.z, ((Component)obj).transform.forward.x) / Math.PI * 180.0;
			string text = "";
			if (shipForwardSpeeds.Count > 0)
			{
				text = " (" + Format.Fixed(shipForwardSpeeds.Average()) + " avg)";
			}
			if (shipForwardSpeed < 0f)
			{
				list.Add("Speed: " + Format.Fixed(0f - shipForwardSpeed) + " m/s away from " + Format.Int(value) + " degrees " + text);
			}
			else
			{
				list.Add("Speed: " + Format.Fixed(shipForwardSpeed) + " m/s towards " + Format.Int(value) + " degrees " + text);
			}
			Vector3 linearVelocity = obj.m_body.linearVelocity;
			linearVelocity.y = 0f;
			double value2 = 90.0 - (double)Mathf.Atan2(linearVelocity.z, linearVelocity.x) / Math.PI * 180.0;
			float shipSpeed = GetShipSpeed(obj);
			if (shipSpeeds.Count > 0)
			{
				list.Add("Speed: " + Format.Fixed(shipSpeed) + " m/s towards " + Format.Int(value2) + " degrees (" + Format.Fixed(shipSpeeds.Average()) + " avg)");
			}
			list.Add(EnvUtils.GetWind());
			list.Add("Wind power: " + Format.Percent(GetWindPower(obj)) + " from " + Format.Int(GetRelativeAngle(obj)) + " degrees");
			return Format.JoinLines(list);
		}

		private static string GetCover(Vector3 startPos, double limit, bool checkRoof = true, bool minLimit = true)
		{
			//IL_0010: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			float num = 0.5f;
			int num2 = 0;
			int num3 = 0;
			float num4 = default(float);
			bool flag = default(bool);
			Cover.GetCoverForPoint(startPos, ref num4, ref flag, 0.5f);
			Vector3[] coverRays = Cover.m_coverRays;
			RaycastHit val2 = default(RaycastHit);
			foreach (Vector3 val in coverRays)
			{
				num2++;
				if (Physics.Raycast(startPos + val * num, val, ref val2, 30f - num, Cover.m_coverRayMask))
				{
					num3++;
				}
			}
			string text = "Cover";
			if (limit > 0.0)
			{
				bool flag2 = (minLimit ? ((double)num4 < limit) : ((double)num4 > limit));
				text = text + " (" + Format.Percent(limit, flag2 ? "red" : "yellow") + ")";
			}
			text = text + ": " + Format.Progress(num3, num2, percent: true);
			list.Add(text);
			if (checkRoof && !flag)
			{
				list.Add(Format.String("Not under roof!", "red"));
			}
			if ((double)Math.Abs(num4 - (float)num3 / (float)num2) > 0.01)
			{
				list.Add(Format.String("Error with cover calculation (" + num4 + ")!", "red"));
			}
			return Format.JoinLines(list);
		}

		public static string Get(Bed obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(obj);
		}

		public static string Get(Container obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return Get(obj.m_defaultItems, 1);
		}

		public static string GetCover(Bed obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), 0.800000011920929);
		}

		public static string Get(CraftingStation obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "\n" + GetCover(obj);
		}

		public static string GetCover(CraftingStation obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), 0.699999988079071);
		}

		public static string GetCover(Windmill obj)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return GetCover(CoverUtils.GetCoverPoint(obj), 0.0, checkRoof: false);
		}

		private static string GetFed(Tameable obj, MonsterAI monsterAI)
		{
			if (!Settings.Breeding)
			{
				return "";
			}
			long @long = Helper.GetLong((MonoBehaviour)(object)obj, "TameLastFeeding", 0L);
			double elapsed = Helper.GetElapsed((MonoBehaviour)(object)obj, "TameLastFeeding", 0L);
			double num = ((@long == 0L) ? 0.0 : ((double)obj.m_fedDuration - elapsed));
			if (num > 0.0)
			{
				return Format.ProgressPercent("Food", num, obj.m_fedDuration);
			}
			if (Object.op_Implicit((Object)(object)monsterAI))
			{
				num = monsterAI.m_consumeSearchTimer;
				return Format.ProgressPercent("Searching food", num, monsterAI.m_consumeSearchInterval);
			}
			return "";
		}

		private static string GetTaming(Tameable obj)
		{
			if (!Settings.Breeding)
			{
				return "";
			}
			float num = obj.m_tamingTime - obj.GetRemainingTime();
			float tamingTime = obj.m_tamingTime;
			return Format.ProgressPercent("Taming", num, tamingTime);
		}

		private static string GetPregnancy(Procreation obj)
		{
			if (!Settings.Breeding || !Helper.IsValid((MonoBehaviour)(object)obj) || !obj.IsPregnant())
			{
				return "";
			}
			double elapsed = Helper.GetElapsed((MonoBehaviour)(object)obj, "pregnant", 0L);
			float pregnancyDuration = obj.m_pregnancyDuration;
			return Format.ProgressPercent("Pregnancy", elapsed, pregnancyDuration);
		}

		private static string GetLove(Procreation obj)
		{
			if (!Settings.Breeding || !Helper.IsValid((MonoBehaviour)(object)obj) || obj.IsPregnant())
			{
				return "";
			}
			int @int = Helper.GetInt((MonoBehaviour)(object)obj, "lovePoints");
			int requiredLovePoints = obj.m_requiredLovePoints;
			return "Breeding: " + Format.Progress(@int, requiredLovePoints) + ", " + Format.Percent(obj.m_pregnancyChance) + " chance every " + Format.Int(obj.m_updateInterval) + " seconds";
		}

		private static string GetPartners(Procreation obj)
		{
			//IL_002a: 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)
			if (!Settings.Breeding || !Helper.IsValid((MonoBehaviour)(object)obj) || obj.IsPregnant())
			{
				return "";
			}
			GameObject prefab = Helper.GetPrefab((MonoBehaviour)(object)obj);
			int num = SpawnSystem.GetNrOfInstances(prefab, ((Component)obj).transform.position, obj.m_partnerCheckRange, false, false) - 1;
			int num2 = SpawnSystem.GetNrOfInstances(prefab, ((Component)obj).transform.position, obj.m_partnerCheckRange, false, true) - 1;
			return "Partners: " + Format.Int(num2) + " within " + obj.m_partnerCheckRange + " meters (" + Format.Int(num) + " possible)";
		}

		private static string GetLimit(Procreation obj)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.Breeding || !Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(Utils.GetPrefabName(obj.m_offspring));
			int nrOfInstances = SpawnSystem.GetNrOfInstances(Helper.GetPrefab((MonoBehaviour)(object)obj), ((Component)obj).transform.position, obj.m_totalCheckRange, false, false);
			int nrOfInstances2 = SpawnSystem.GetNrOfInstances(prefab, ((Component)obj).transform.position, obj.m_totalCheckRange, false, false);
			int num = nrOfInstances + nrOfInstances2;
			int maxCreatures = obj.m_maxCreatures;
			return "Limit: " + Format.Progress(num, maxCreatures) + " within " + obj.m_totalCheckRange + " meters";
		}

		public static string Get(Tameable obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			Procreation component = ((Component)obj).GetComponent<Procreation>();
			Character component2 = ((Component)obj).GetComponent<Character>();
			MonsterAI component3 = ((Component)obj).GetComponent<MonsterAI>();
			if (!Object.op_Implicit((Object)(object)component2))
			{
				return "";
			}
			List<string> list = new List<string>(1) { GetFed(obj, component3) };
			if (component2.IsTamed())
			{
				list.Add(GetLove(component));
				list.Add(GetPregnancy(component));
				list.Add(GetPartners(component));
				list.Add(GetLimit(component));
			}
			else
			{
				list.Add(GetTaming(obj));
			}
			return Format.JoinLines(list);
		}

		public static string GetChopTier(int tier)
		{
			if (tier > 6)
			{
				return "Berserker+";
			}
			return tier switch
			{
				6 => "Berserker", 
				5 => "Blackmetal+", 
				4 => "Blackmetal", 
				3 => "Iron", 
				2 => "Bronze", 
				1 => "Flint", 
				_ => "Stone", 
			};
		}

		public static string GetPickaxeTier(int tier)
		{
			if (tier > 5)
			{
				return "Battering ram+";
			}
			return tier switch
			{
				5 => "Battering ram", 
				4 => "Blackmetal+", 
				3 => "Blackmetal", 
				2 => "Iron", 
				1 => "Bronze", 
				_ => "Antler", 
			};
		}

		public static string GetToolTier(int tier, bool chop, bool pickaxe)
		{
			List<string> list = new List<string>();
			if (chop)
			{
				list.Add("Axe: " + Format.String(GetChopTier(tier)));
			}
			if (pickaxe)
			{
				list.Add("Pickaxe: " + Format.String(GetPickaxeTier(tier)));
			}
			return Format.JoinLines(list);
		}

		private static string GetAttackTypeName(AttackType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: 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_0015: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			if ((int)type == 4)
			{
				return "Horizontal";
			}
			if ((int)type == 0)
			{
				return "Horizontal";
			}
			if ((int)type == 2)
			{
				return "Projectile";
			}
			if ((int)type == 5)
			{
				return "TriggerProjectile";
			}
			if ((int)type == 1)
			{
				return "Vertical";
			}
			return "";
		}

		public static string GetAttackType(Attack attack, string color = "yellow")
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Format.String(GetAttackTypeName(attack.m_attackType), color);
		}

		public static string GetStaminaText(Attack attack, SkillType skillType)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (attack == null)
			{
				return "";
			}
			float attackStamina = attack.m_attackStamina;
			if (attackStamina == 0f)
			{
				return "";
			}
			float skillFactor = ((Character)Player.m_localPlayer).GetSkillFactor(skillType);
			float num = attackStamina * (1f - 0.33f * skillFactor);
			return "Stamina: " + Format.Int(attackStamina, "orange") + " " + Format.String("(" + Format.Float(num) + ")");
		}

		public static string GetEitrText(Attack attack, SkillType skillType)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (attack == null)
			{
				return "";
			}
			float attackEitr = attack.m_attackEitr;
			if (attackEitr == 0f)
			{
				return "";
			}
			float skillFactor = ((Character)Player.m_localPlayer).GetSkillFactor(skillType);
			float num = attackEitr * (1f - 0.33f * skillFactor);
			return "Eitr: " + Format.Int(attackEitr, "orange") + " " + Format.String("(" + Format.Float(num) + ")");
		}

		public static string GetHealthText(Attack attack, SkillType skillType)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (attack == null)
			{
				return "";
			}
			float attackHealth = attack.m_attackHealth;
			float num = attack.m_attackHealthPercentage / 100f;
			if (attackHealth == 0f && num == 0f)
			{
				return "";
			}
			float skillFactor = ((Character)Player.m_localPlayer).GetSkillFactor(skillType);
			float num2 = attackHealth * (1f - 0.33f * skillFactor);
			float num3 = num * (1f - 0.33f * skillFactor);
			if (attackHealth != 0f && num != 0f)
			{
				return "Health: " + Format.Int(attackHealth, "orange") + " + " + Format.PercentInt(num) + " " + Format.String("(" + Format.Float(num2) + " + " + Format.Percent(num3) + ")");
			}
			if (attackHealth != 0f)
			{
				return "Health: " + Format.Int(attackHealth, "orange") + " " + Format.String("(" + Format.Float(num2) + ")");
			}
			if (num != 0f)
			{
				return "Health: " + Format.PercentInt(num, "orange") + " " + Format.String("(" + Format.Percent(num3) + ")");
			}
			return "";
		}

		public static string GetHitboxText(Attack attack, string color = "yellow")
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (attack == null || (int)attack.m_attackType == 2)
			{
				return "";
			}
			List<string> list = new List<string>();
			if (attack.m_attackRange > 0f)
			{
				list.Add(Format.Float(attack.m_attackRange, "0.##", color) + " m");
			}
			if (attack.m_attackAngle > 0f)
			{
				list.Add(Format.Float(attack.m_attackAngle, "0.##", color) + " deg");
			}
			if (attack.m_attackHeight > 0f)
			{
				list.Add(Format.Float(attack.m_attackHeight, "0.##", color) + " h");
			}
			if (attack.m_attackRayWidth > 0f)
			{
				list.Add(Format.Float(attack.m_attackRayWidth, "0.##", color) + " ray");
			}
			if (attack.m_attackOffset > 0f)
			{
				list.Add(Format.Float(attack.m_attackOffset, "0.##", color) + " offset");
			}
			return "Hit: " + Format.JoinRow(list);
		}

		public static string GetProjectileText(Attack attack, float holdDuration = 0f, string color = "yellow")
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			if (attack == null || (int)attack.m_attackType != 2)
			{
				return "";
			}
			List<string> list = new List<string>();
			if (holdDuration > 0f)
			{
				list.Add("Spread: " + Format.Range(attack.m_projectileAccuracy, attack.m_projectileAccuracyMin, color));
				list.Add("Velocity: " + Format.Range(attack.m_projectileVelMin, attack.m_projectileVel, color));
			}
			else
			{
				list.Add("Spread: " + Format.Int(attack.m_projectileAccuracy, color));
				list.Add("Velocity: " + Format.Int(attack.m_projectileVel, color));
			}
			if (attack.m_projectileBursts > 1)
			{
				list.Add("Burst: " + Format.Multiplier(attack.m_projectileBursts, color));
			}
			if (attack.m_projectiles > 1)
			{
				list.Add("Projectiles: " + Format.Multiplier(attack.m_projectiles, color));
			}
			return Format.JoinRow(list);
		}

		public static string GetAttackSpeed(string animation, float holdDuration)
		{
			return animation switch
			{
				"atgeir_attack" => "2.98 s (0.84 + 0.86 + 1.28)", 
				"atgeir_secondary" => "1.54 s", 
				"battleaxe_attack" => "3.21 s (1.58 + 0.92 + 0.71)", 
				"battleaxe_secondary" => "0.84 s", 
				"bow_fire" => (0.8 + (double)holdDuration).ToString("0.##") + " s", 
				"emote_drink" => "", 
				"knife_stab" => "1.74 s (0.6 + 0.44 + 0.7)", 
				"knife_secondary" => "1.52 s", 
				"mace_secondary" => "1.72 s", 
				"spear_poke" => "0.68 s", 
				"spear_throw" => "1.57 s (includes picking up)", 
				"swing_axe" => "2.58 s (1.11 + 0.65 + 0.82)", 
				"swing_hammer" => "", 
				"swing_hoe" => "", 
				"swing_longsword" => "2.46 s (1.14 + 0.44 + 0.88)", 
				"swing_pickaxe" => "1.4 s", 
				"swing_sledge" => "2.12 s", 
				"sword_secondary" => "1.84 s", 
				_ => animation, 
			};
		}

		public static string GetAttackSpeed(Attack attack, float holdDuration = 0f, string color = "yellow")
		{
			if (attack == null)
			{
				return "";
			}
			string attackSpeed = GetAttackSpeed(attack.m_attackAnimation, holdDuration);
			if (attackSpeed == "")
			{
				return "";
			}
			attackSpeed = attackSpeed.Replace("(", "<color=#FFFF00>(");
			attackSpeed = attackSpeed.Replace(")", ")</color>");
			return "Speed: " + Format.String(attackSpeed, color);
		}

		public static string Get(LocationProxy obj)
		{
			//IL_00b0: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			if (!Helper.IsValid((MonoBehaviour)(object)obj) || !Settings.Locations)
			{
				return "";
			}
			string text = Utils.GetPrefabName(obj.m_instance).ToLower();
			List<string> list = new List<string>();
			Dictionary<Vector2i, LocationInstance> locationInstances = ZoneSystem.instance.m_locationInstances;
			foreach (ZoneLocation i in ZoneSystem.instance.m_locations)
			{
				if (i.m_enable && i.m_prefab.IsValid && !(i.m_prefabName.ToLower() != text))
				{
					i.m_prefab.Load();
					Location component = i.m_prefab.Asset.GetComponent<Location>();
					int num = locationInstances.Values.Where((LocationInstance instance) => instance.m_location.m_prefabName == i.m_prefabName).Count();
					list.Add("Placed: " + Format.Progress(num, i.m_quantity));
					if (i.m_group != "")
					{
						list.Add("Group: " + Format.String(i.m_group));
					}
					list.Add(GetBiomes(i.m_biome, i.m_biomeArea));
					if (i.m_maxDistance > 0f)
					{
						list.Add("Distance from center: " + Format.Range(i.m_minDistance, i.m_maxDistance));
					}
					if (i.m_minAltitude != i.m_maxAltitude)
					{
						list.Add("Altitude: " + Format.Range(i.m_minAltitude, i.m_maxAltitude));
					}
					if (i.m_minTerrainDelta != i.m_maxTerrainDelta)
					{
						list.Add("Terrain angle: " + Format.Range(i.m_minTerrainDelta, i.m_maxTerrainDelta));
					}
					if (i.m_inForest)
					{
						list.Add("Forest: " + Format.Range(i.m_forestTresholdMin, i.m_forestTresholdMax));
					}
					if (i.m_minDistanceFromSimilar > 0f)
					{
						list.Add("Distance from similar: " + Format.Meters(i.m_minDistanceFromSimilar));
					}
					if (component.m_exteriorRadius > 0f)
					{
						list.Add("Exterior radius: " + Format.Meters(component.m_exteriorRadius));
					}
					if (component.m_hasInterior)
					{
						list.Add("Interior radius: " + Format.Meters(component.m_interiorRadius));
					}
					List<string> list2 = new List<string>();
					if (i.m_prioritized)
					{
						list2.Add("Prioritized");
					}
					if (i.m_centerFirst)
					{
						list2.Add("Center first");
					}
					if (i.m_randomRotation)
					{
						list2.Add("Random rotation");
					}
					if (i.m_unique)
					{
						list2.Add("Unique");
					}
					if (i.m_iconAlways)
					{
						list2.Add("Always show icon");
					}
					if (component.m_applyRandomDamage)
					{
						list2.Add("Randomly damaged");
					}
					if (i.m_clearArea)
					{
						list2.Add("Clear area");
					}
					if (component.m_noBuild)
					{
						list2.Add("No build area");
					}
					i.m_prefab.Release();
					list.Add(Format.JoinRow(list2));
				}
			}
			return Format.JoinLines(list);
		}

		public static string GetVegetation(GameObject obj)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)obj) || !Settings.Vegetation)
			{
				return "";
			}
			string text = Utils.GetPrefabName((GameObject)(((Object)(object)obj.transform.parent == (Object)null) ? ((object)obj) : ((object)((Component)obj.transform.parent).gameObject))).ToLower();
			List<string> list = new List<string>();
			foreach (ZoneVegetation item in ZoneSystem.instance.m_vegetation)
			{
				if (item.m_enable && !(Utils.GetPrefabName(item.m_prefab).ToLower() != text))
				{
					if (item.m_max < 1f)
					{
						list.Add(Format.Percent(item.m_max) + " chance per zone");
					}
					else
					{
						list.Add(Format.Range(item.m_min, item.m_max) + " per zone");
					}
					List<string> list2 = list;
					int index = list.Count() - 1;
					list2[index] = list2[index] + " in " + GetBiomes(item.m_biome, item.m_biomeArea, addLabel: false);
					if (item.m_groupSizeMax > 1)
					{
						list.Add("Group size: " + Format.Range(item.m_groupSizeMin, item.m_groupSizeMax) + " within " + Format.Meters(item.m_groupRadius));
					}
					List<string> list3 = new List<string>();
					if (item.m_minAltitude != item.m_maxAltitude)
					{
						list3.Add("Altitude: " + Format.Range(item.m_minAltitude, item.m_maxAltitude));
					}
					if (item.m_minOceanDepth != item.m_maxOceanDepth)
					{
						list3.Add("Ocean depth: " + Format.Range(item.m_minOceanDepth, item.m_maxOceanDepth));
					}
					if (item.m_terrainDeltaRadius > 0f)
					{
						list3.Add("Terrain delta: " + Format.Range(item.m_minTerrainDelta, item.m_maxTerrainDelta) + " within " + Format.Meters(item.m_terrainDeltaRadius));
					}
					if (item.m_minTilt != item.m_maxTilt)
					{
						list3.Add("Terrain angle: " + Format.Range(item.m_minTilt, item.m_maxTilt));
					}
					if (item.m_inForest)
					{
						list3.Add("Forest: " + Format.Range(item.m_forestTresholdMin, item.m_forestTresholdMax));
					}
					list.Add(Format.JoinRow(list3));
					List<string> list4 = new List<string>();
					if (item.m_snapToWater)
					{
						list4.Add("Snaps to water");
					}
					if (item.m_forcePlacement)
					{
						list4.Add("Prioritized");
					}
					if (item.m_blockCheck)
					{
						list4.Add("Needs clear ground");
					}
					if (item.m_groundOffset > 0f)
					{
						list4.Add(Format.Meters(item.m_groundOffset) + " from ground");
					}
					if (item.m_chanceToUseGroundTilt >= 1f)
					{
						list4.Add("Ground tilt");
					}
					else if (item.m_chanceToUseGroundTilt > 0f)
					{
						list4.Add(Format.Percent(item.m_chanceToUseGroundTilt) + " for ground tilt");
					}
					if (item.m_randTilt > 0f)
					{
						list4.Add(Format.Float(item.m_randTilt) + " degrees random tilt");
					}
					if (item.m_scaleMin != item.m_scaleMax)
					{
						list4.Add("Random scale " + Format.Range(item.m_scaleMin, item.m_scaleMax));
					}
					list.Add(Format.JoinRow(list4));
				}
			}
			if (list.Count > 0)
			{
				list.Insert(0, " ");
			}
			return Format.JoinLines(list);
		}

		public static string Get(RandomSpawn obj)
		{
			if (!Helper.IsValid((MonoBehaviour)(object)obj))
			{
				return "";
			}
			return "Chance to spawn: " + Format.Percent(obj.m_chanceToSpawn);
		}

		private static string GetItem(OfferingBowl obj)
		{
			if (obj.m_useItemStands)
			{
				return "Item stands: " + obj.m_itemstandMaxRange + " m";
			}
			string text = obj.m_bossItems.ToString();
			ItemDrop bossItem = obj.m_bossItem;
			return "Item: " + text + " of " + (((bossItem != null) ? bossItem.GetHoverName() : null) ?? "nothing");
		}

		private static string GetRespawnTime(OfferingBowl obj)
		{
			ZNetView view = ((Component)obj).GetComponentInParent<ZNetView>();
			string ret = "";
			DataUtils.Float(view, Respawn, delegate(float respawn)
			{
				DataUtils.Long(view, SpawnTime, delegate(long spawnTime)
				{
					DateTime time = ZNet.instance.GetTime();
					DateTime dateTime = new DateTime(spawnTime);
					double totalMinutes = (time - dateTime).TotalMinutes;
					ret = "Cooldown: " + Format.Int(totalMinutes) + " / " + Format.Int(respawn) + " minutes";
				});
			});
			return ret;
		}

		public static string Get(OfferingBowl obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			return Format.JoinLines(new List<string>(4)
			{
				"Spawn: " + (Object.op_Implicit((Object)(object)obj.m_bossPrefab) ? Utils.GetPrefabName(obj.m_bossPrefab) : ""),
				GetItem(obj),
				GetRespawnTime(obj),
				"Area: " + Format.Int(obj.m_spawnBossMaxDistance) + " m"
			});
		}

		public static string Get(SpawnArea obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return "";
			}
			int num = default(int);
			int num2 = default(int);
			obj.GetInstances(ref num, ref num2);
			List<string> list = new List<string>(6);
			list.Add(Format.ProgressPercent("Timer", obj.m_spawnTimer, obj.m_spawnIntervalSec));
			list.Add("Area: " + Format.Int(obj.m_spawnRadius) + " m");
			list.Add("Level up: " + Format.Percent(obj.m_levelupChance / 100f));
			list.Add("Trigger: " + Format.Int(obj.m_triggerDistance) + " m");
			list.Add("Near limit: " + Format.Progress(num, obj.m_maxNear) + " within " + Format.Int(obj.m_nearRadius) + " m");
			list.Add("Far limit: " + Format.Progress(num2, obj.m_maxTotal) + " within " + Format.Int(obj.m_farRadius) + " m");
			List<string> list2 = list;
			if (obj.m_onGroundOnly)
			{
				list2.Add("Only on ground");
			}
			list2.Add(" ");
			float num3 = 0f;
			foreach (SpawnData prefab in obj.m_prefabs)
			{
				num3 += prefab.m_weight;
			}
			foreach (SpawnData prefab2 in obj.m_prefabs)
			{
				string text = Format.Range(prefab2.m_minLevel, prefab2.m_maxLevel);
				list2.Add(((Object)prefab2.m_prefab).name + ": " + Format.Percent(prefab2.m_weight / num3) + " with level " + text);
			}
			return Format.JoinLines(list2);
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	[HarmonyPriority(0)]
	public class BoundsCache
	{
		public static Dictionary<string, Vector3> Bounds = new Dictionary<string, Vector3>();

		private static void Postfix(ZNetView __instance)
		{
			//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_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_006e: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (!(((Component)__instance).transform.rotation == Quaternion.identity) || Bounds.ContainsKey(__instance.GetPrefabName()))
			{
				return;
			}
			Collider[] array = (from collider in ((Component)__instance).GetComponentsInChildren<Collider>()
				where !Texts.IgnoredLayers.Contains(((Component)collider).gameObject.layer)
				select collider).ToArray();
			if (array.Length == 0)
			{
				Bounds[__instance.GetPrefabName()] = Vector3.zero;
				return;
			}
			Bounds bounds = array[0].bounds;
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				((Bounds)(ref bounds)).Encapsulate(val.bounds);
			}
			Bounds[__instance.GetPrefabName()] = ((Bounds)(ref bounds)).size;
		}
	}
	public static class Hud
	{
		[HarmonyPatch(typeof(Character), "CustomFixedUpdate")]
		public class CreatureStagger
		{
			private static long StaggerStart = 0L;

			private static ZDOID Id = ZDOID.None;

			public static double StaggerDuration = 0.0;

			private static void Postfix(Character __instance)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				if (!Object.op_Implicit((Object)(object)__instance) || !Object.op_Implicit((Object)(object)__instance.m_nview) || !__instance.m_nview.IsValid())
				{
					StaggerStart = 0L;
					Id = ZDOID.None;
					return;
				}
				bool flag = __instance.IsStaggering();
				if (StaggerStart == 0 && flag)
				{
					StaggerStart = ZNet.instance.GetTime().Ticks;
					StaggerDuration = 0.0;
					Id = __instance.GetZDOID();
				}
				double totalSeconds = (ZNet.instance.GetTime() - new DateTime(StaggerStart)).TotalSeconds;
				if (Id == __instance.GetZDOID() && !flag)
				{
					StaggerDuration = totalSeconds;
					StaggerStart = 0L;
					Id = ZDOID.None;
				}
				if (totalSeconds > 10.0)
				{
					StaggerStart = 0L;
					Id = ZDOID.None;
				}
			}
		}

		private static readonly int[] MaxLengths = new int[13]
		{
			13, 15, 10, 25, 15, 15, 7, 15, 17, 11,
			10, 999, 999
		};

		private static float TrackUpdateTimer = 0f;

		private static float TrackUpdateLongTimer = 0f;

		private static readonly Dictionary<string, int> trackCache = new Dictionary<string, int>();

		public static List<string> GetMessage()
		{
			if (!Settings.ShowHud)
			{
				return new List<string>();
			}
			List<string> list = new List<string>();
			AddInfo(list);
			AddShipStats(list);
			return list;
		}

		private static void AddShipStats(List<string> lines)
		{
			if (!Settings.ShowShip)
			{
				return;
			}
			Ship localShip = Ship.GetLocalShip();
			if (Object.op_Implicit((Object)(object)localShip) && Settings.ShowShip)
			{
				lines.Add(" ");
				lines.AddRange(from line in Texts.Get(localShip).Split(new char[1] { '\n' })
					where line != ""
					select line);
			}
		}

		private static void AddInfo(List<string> lines)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			List<string> list = new List<string>(13)
			{
				GetTime(),
				GetWeather(),
				GetWind(),
				GetPosition(position),
				GetAltitude(position),
				GetForest(position),
				GetBlocked(position),
				GetSpeed(),
				GetNoise(),
				GetLight(),
				GetStaggerTracker(),
				GetHeat(Player.m_localPlayer),
				GetTrackedObjects()
			};
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				if (!(list[i] == ""))
				{
					if (lines.Count == 0)
					{
						lines.Add(list[i]);
						num = MaxLengths[i];
					}
					else if (num + MaxLengths[i] < 60)
					{
						int index = lines.Count - 1;
						lines[index] = lines[index] + ", " + list[i];
						num += MaxLengths[i];
					}
					else
					{
						lines.Add(list[i]);
						num = MaxLengths[i];
					}
				}
			}
		}

		private static string GetSpeed()
		{
			if (!Settings.ShowSpeed)
			{
				return "";
			}
			return "Speed: " + Format.Float(((Vector3)(ref ((Character)Player.m_localPlayer).m_currentVel)).magnitude, "0.#") + " m/s";
		}

		private static string GetNoise()
		{
			if (!Settings.ShowStealth)
			{
				return "";
			}
			return "Noise: " + Format.Int(((Character)Player.m_localPlayer).GetNoiseRange()) + " meters";
		}

		private static string GetLight()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowStealth)
			{
				return "";
			}
			return "Light: " + Format.Percent(StealthSystem.instance.GetLightFactor(((Character)Player.m_localPlayer).GetCenterPoint()));
		}

		private static string GetTime()
		{
			if (!Settings.ShowTime)
			{
				return "";
			}
			return EnvUtils.GetTime();
		}

		private static string GetWeather()
		{
			if (!Settings.ShowWeather)
			{
				return "";
			}
			return EnvUtils.GetCurrentEnvironment();
		}

		private static string GetWind()
		{
			if (!Settings.ShowWind)
			{
				return "";
			}
			return EnvUtils.GetWindHud();
		}

		private static string GetStaggerTracker()
		{
			if (!Settings.ShowStagger)
			{
				return "";
			}
			if (CreatureStagger.StaggerDuration == 0.0)
			{
				return "Stagger: ...";
			}
			return "Stagger: " + CreatureStagger.StaggerDuration;
		}

		private static string GetHeat(Player player)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowHeat)
			{
				return "";
			}
			float num = WorldGenerator.GetAshlandsOceanGradient(((Component)player).transform.position);
			if (!((Character)player).IsSwimming())
			{
				num *= ((Character)player).m_heatWaterTouchMultiplier;
			}
			num = Mathf.Clamp01(num);
			float equipmentHeatResistanceModifier = ((Character)player).GetEquipmentHeatResistanceModifier();
			num *= 1f - equipmentHeatResistanceModifier;
			num *= ((Character)player).m_heatBuildupWater;
			return "Heat gain: " + Format.Percent(num) + ", Resistance: " + Format.Percent(equipmentHeatResistanceModifier) + ", Total: " + Format.Percent(((Character)player).m_lavaHeatLevel);
		}

		private static string GetPosition(Vector3 position)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowPosition)
			{
				return "";
			}
			return EnvUtils.GetPosition(position);
		}

		private static string GetAltitude(Vector3 position)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowAltitude)
			{
				return "";
			}
			return EnvUtils.GetAltitude(position);
		}

		private static string GetForest(Vector3 position)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowForest)
			{
				return "";
			}
			return EnvUtils.GetForest(position);
		}

		private static string GetBlocked(Vector3 position)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ShowBlocked)
			{
				return "";
			}
			return EnvUtils.GetBlocked(position);
		}

		private static string GetTrackedObjects()
		{
			//IL_00d3: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.TrackedObjects == "")
			{
				return "";
			}
			TrackUpdateTimer += Time.deltaTime;
			TrackUpdateLongTimer += Time.deltaTime;
			string[] array = Settings.TrackedObjects.Split(new char[1] { ',' });
			if (TrackUpdateTimer >= 1f)
			{
				TrackUpdateTimer = 0f;
				List<ItemDrop> s_instances = ItemDrop.s_instances;
				string[] array2 = array;
				foreach (string text in array2)
				{
					GameObject prefab = ZNetScene.instance.GetPrefab(text);
					int num = 0;
					if ((Object)(object)prefab == (Object)null)
					{
						num = -1;
					}
					else if ((Object)(object)prefab.GetComponent<Character>() != (Object)null)
					{
						num = SpawnSystem.GetNrOfInstances(prefab, ((Component)Player.m_localPlayer).transform.position, 0f, false, false);
					}
					else if ((Object)(object)prefab.GetComponent<ItemDrop>() != (Object)null)
					{
						num = s_instances.Where((ItemDrop item) => ((Object)item).name.Replace("(Clone)", "") == ((Object)prefab).name).Sum((ItemDrop item) => item.m_itemData.m_stack);
					}
					else
					{
						if (TrackUpdateLongTimer < 5f)
						{
							continue;
						}
						int hash = StringExtensionMethods.GetStableHashCode(((Object)prefab).name);
						List<ZDO> source = ZDOMan.instance.m_objectsByID.Values.Where((ZDO zdo) => zdo.m_prefab == hash).ToList();
						Vector3 position = ((Component)Player.m_localPlayer).transform.position;
						num = ((!(Settings.TrackRadius < 0f)) ? source.Where((ZDO zdo) => Utils.DistanceXZ(zdo.GetPosition(), position) < Settings.TrackRadius).Count() : source.Count());
					}
					trackCache[text] = num;
				}
				if (TrackUpdateLongTimer >= 5f)
				{
					TrackUpdateLongTimer = 0f;
				}
			}
			return Format.JoinRow(array.Select(delegate(string name)
			{
				if (!trackCache.ContainsKey(name))
				{
					return "";
				}
				return (trackCache[name] < 0) ? (name + ": " + Format.String("Invalid ID", "red")) : (name + ": " + Format.Int(trackCache[name]));
			}));
		}
	}
	[HarmonyPatch(typeof(DamageTypes), "GetTooltipString", new Type[] { typeof(SkillType) })]
	public class DamageTypes_GetTooltipStringWithSkill
	{
		private static void Postfix(SkillType skillType, DamageTypes __instance, ref string __result)
		{
			//IL_001d: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: 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)
			if (Settings.ExtraInfo && Settings.WeaponInfo && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				float num = default(float);
				float num2 = default(float);
				((Character)Player.m_localPlayer).GetSkills().GetRandomSkillRange(ref num, ref num2, skillType);
				if (__instance.m_chop != 0f)
				{
					__result += string.Format("\n$inventory_chop: <color=orange>{0}</color> <color=#FFFF00>({1}-{2}) </color>, {3}", Mathf.RoundToInt(__instance.m_chop), Mathf.RoundToInt(__instance.m_chop * num), Mathf.RoundToInt(__instance.m_chop * num2), Format.String("<CHOP_TIER>", "orange"));
				}
				if (__instance.m_pickaxe != 0f)
				{
					__result += string.Format("\n$inventory_pickaxe: <color=orange>{0}</color> <color=#FFFF00>({1}-{2}) </color>, {3}", Mathf.RoundToInt(__instance.m_pickaxe), Mathf.RoundToInt(__instance.m_pickaxe * num), Mathf.RoundToInt(__instance.m_pickaxe * num2), Format.String("¤PICKAXE_TIER", "orange"));
				}
			}
		}
	}
	[HarmonyPatch(typeof(DamageTypes), "GetTooltipString", new Type[] { })]
	public class DamageTypes_GetTooltipString
	{
		private static void Postfix(DamageTypes __instance, ref string __result)
		{
			//IL_000f: 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_0032: 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)
			if (Settings.ExtraInfo && Settings.WeaponInfo)
			{
				if (__instance.m_chop != 0f)
				{
					__result = __result + "\n$inventory_chop: " + Format.Int(__instance.m_chop) + " " + Format.String("(<CHOP_TIER>)");
				}
				if (__instance.m_pickaxe != 0f)
				{
					__result = __result + "\n$inventory_pickaxe: " + Format.Int(__instance.m_pickaxe) + " " + Format.String("(<PICKAXE_TIER>)");
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemData), "GetTooltip", new Type[]
	{
		typeof(ItemData),
		typeof(int),
		typeof(bool),
		typeof(float),
		typeof(int)
	})]
	public class ItemDropItemData_GetTooltip
	{
		private static void Postfix(ItemData item, ref string __result)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.ExtraInfo || !Settings.WeaponInfo)
			{
				return;
			}
			SharedData shared = item.m_shared;
			__result = __result.Replace("<CHOP_TIER>", Texts.GetChopTier(shared.m_toolTier));
			__result = __result.Replace("<PICKAXE_TIER>", Texts.GetPickaxeTier(shared.m_toolTier));
			float num = default(float);
			float num2 = default(float);
			((Character)Player.m_localPlayer).GetSkills().GetRandomSkillRange(ref num, ref num2, shared.m_skillType);
			float skillFactor = ((Character)Player.m_localPlayer).GetSkillFactor(shared.m_skillType);
			int num3 = Mathf.RoundToInt(shared.m_attackForce * num);
			int num4 = Mathf.RoundToInt(shared.m_attackForce * num2);
			string knockback = " <color=#FFFF00>(" + num3 + "-" + num4 + ")</color>";
			List<string> list = __result.Split(new char[1] { '\n' }).ToList();
			item.GetDamage();
			float drawDurationMin = shared.m_attack.m_drawDurationMin;
			drawDurationMin = Mathf.Lerp(drawDurationMin, drawDurationMin * 0.2f, skillFactor);
			if (shared.m_attack != null && shared.m_attack.m_attackAnimation != "")
			{
				Attack attack = shared.m_attack;
				if ((double)attack.m_damageMultiplier != 1.0)
				{
					list.Add("Damage: " + Format.Multiplier(attack.m_damageMultiplier, "orange"));
				}
				if ((double)attack.m_staggerMultiplier != 1.0)
				{
					list.Add("Stagger: " + Format.Multiplier(attack.m_staggerMultiplier, "orange"));
				}
				if ((double)attack.m_forceMultiplier != 1.0)
				{
					list.Add("Knockback: " + Format.Multiplier(attack.m_forceMultiplier, "orange"));
				}
				list.Add(Texts.GetStaminaText(attack, shared.m_skillType));
				list.Add(Texts.GetEitrText(attack, shared.m_skillType));
				list.Add(Texts.GetHealthText(attack, shared.m_skillType));
				if (!attack.m_lowerDamagePerHit)
				{
					list.Add(Format.String("No multitarget penalty", "orange"));
				}
				list.Add(Texts.GetAttackSpeed(attack, drawDurationMin, "orange"));
				list.Add(Texts.GetAttackType(attack, "orange"));
				list.Add(Texts.GetProjectileText(attack, drawDurationMin, "orange"));
				list.Add(Texts.GetHitboxText(attack, "orange"));
				if ((double)attack.m_raiseSkillAmount != 1.0)
				{
					list.Add("Experience gain: " + Format.Multiplier(attack.m_raiseSkillAmount, "orange"));
				}
				if (attack.m_requiresReload && (double)attack.m_reloadTime != 1.0)
				{
					list.Add("Reload: " + Format.Float(Mathf.Lerp(attack.m_reloadTime, attack.m_reloadTime * 0.5f, skillFactor), "orange"));
				}
			}
			if (shared.m_secondaryAttack != null && shared.m_secondaryAttack.m_attackAnimation != "")
			{
				Attack secondaryAttack = shared.m_secondaryAttack;
				list.Add("Secondary");
				if ((double)secondaryAttack.m_damageMultiplier != 1.0)
				{
					list.Add("Damage: " + Format.Multiplier(secondaryAttack.m_damageMultiplier, "orange"));
				}
				if ((double)secondaryAttack.m_staggerMultiplier != 1.0)
				{
					list.Add("Stagger: " + Format.Multiplier(secondaryAttack.m_staggerMultiplier, "orange"));
				}
				if ((double)secondaryAttack.m_forceMultiplier != 1.0)
				{
					list.Add("Knockback: " + Format.Multiplier(secondaryAttack.m_forceMultiplier, "orange"));
				}
				list.Add(Texts.GetStaminaText(secondaryAttack, shared.m_skillType));
				list.Add(Texts.GetEitrText(secondaryAttack, shared.m_skillType));
				list.Add(Texts.GetHealthText(secondaryAttack, shared.m_skillType));
				if (!secondaryAttack.m_lowerDamagePerHit)
				{
					list.Add(Format.String("No multitarget penalty", "orange"));
				}
				list.Add(Texts.GetAttackType(secondaryAttack, "orange"));
				list.Add(Texts.GetAttackSpeed(secondaryAttack, drawDurationMin, "orange"));
				list.Add(Texts.GetProjectileText(secondaryAttack, drawDurationMin, "orange"));
				list.Add(Texts.GetHitboxText(secondaryAttack, "orange"));
				if ((double)secondaryAttack.m_raiseSkillAmount != 1.0)
				{
					list.Add("Experience gain: " + Format.Multiplier(secondaryAttack.m_raiseSkillAmount, "orange"));
				}
			}
			__result = Format.JoinLines(from line in list
				where line != ""
				select (!line.StartsWith("$item_knockback")) ? line : (line + knockback));
		}
	}
	public static class Constants
	{
		public const float CoverRayCastLength = 30f;

		public const float CoverRaycastStart = 0.5f;

		public const float CoverBedLimit = 0.8f;

		public const float CoverCraftingStationLimit = 0.7f;

		public const float CoverFermenterLimit = 0.7f;

		public const float CoverFireplaceLimit = 0.7f;

		public const float WindFireplaceLimit = 0.8f;

		public const float RoofFireplaceLimit = 0.5f;

		public const float CoverPlayerLimit = 0.8f;

		public const float SmokeAmountLimit = 100f;

		public const float ComfortRadius = 10f;

		public const float CreatureFireLimitRadius = 3f;
	}
	public static class Tag
	{
		public const string CreatureCollider = "CreatureCollider";

		public const string StructureCollider = "StructureCollider";

		public const string DestructibleCollider = "DestructibleCollider";

		public const string Attack = "Attack";

		public const string StructureCover = "StructureCover";

		public const string StructureCoverBlocked = "StructureCoverBlocked";

		public const string StructureSupport = "StructureSupport";

		public const string CreatureNoise = "CreatureNoise";

		public const string CreatureHearRange = "CreatureHearRange";

		public const string CreatureViewRange = "CreatureViewRange";

		public const string CreatureAlertRange = "CreatureAlertRange";

		public const string CreatureFireRange = "CreatureFireRange";

		public const string CreatureBreedingTotalRange = "CreatureBreedingTotalRange";

		public const string CreatureBreedingPartnerRange = "CreatureBreedingPartnerRange";

		public const string CreatureFoodSearchRange = "CreatureFoodSearchRange";

		public const string CreatureEatingRange = "CreatureEatingRange";

		public const string TrackedObject = "TrackedObject";

		public const string PickableOneTime = "PickableOneTime";

		public const string PickableRespawning = "PickableRespawning";

		public const string EventZone = "EventZone";

		public const string Location = "Location";

		public const string Chest = "Chest";

		public const string Tree = "Tree";

		public const string Ore = "Ore";

		public const string TrophySpeak = "TrophySpeak";

		public const string Destructible = "Destructible";

		public const string SpawnPointOneTime = "SpawnPointOneTime";

		public const string SpawnPointRespawning = "SpawnPointRespawning";

		public const string SpawnerRay = "SpawnerRay";

		public const string SpawnerTriggerRange = "SpawnerTriggerRange";

		public const string SpawnerLimitRange = "SpawnerNearRange";

		public const string SpawnerSpawnRange = "SpawnerSpawnRange";

		public const string AltarRay = "AltarRay";

		public const string AltarSpawnRadius = "AltarSpawnRadius";

		public const string AltarItemStandRange = "AltarItemStandRange";

		public const string ZoneCorner = "ZoneCorner";

		public const string ZoneCornerAshlands = "ZoneCornerAshlands";

		public const string ZoneCornerBlackForest = "ZoneCornerBlackForest";

		public const string ZoneCornerDeepNorth = "ZoneCornerDeepNorth";

		public const string ZoneCornerMeadows = "ZoneCornerMeadows";

		public const string ZoneCornerMistlands = "ZoneCornerMistlands";

		public const string ZoneCornerMountain = "ZoneCornerMountain";

		public const string ZoneCornerOcean = "ZoneCornerOcean";

		public const string ZoneCornerPlains = "ZoneCornerPlains";

		public const string ZoneCornerSwamp = "ZoneCornerSwamp";

		public const string ZoneCornerUnknown = "ZoneCornerUnknown";

		public const string SpawnZone = "SpawnZone";

		public const string SpawnZoneAshlands = "SpawnZoneAshlands";

		public const string SpawnZoneBlackForest = "SpawnZoneBlackForest";

		public const string SpawnZoneDeepNorth = "SpawnZoneDeepNorth";

		public const string SpawnZoneMeadows = "SpawnZoneMeadows";

		public const string SpawnZoneMistlands = "SpawnZoneMistlands";

		public const string SpawnZoneMountain = "SpawnZoneMountain";

		public const string SpawnZoneOcean = "SpawnZoneOcean";

		public const string SpawnZonePlains = "SpawnZonePlains";

		public const string SpawnZoneSwamp = "SpawnZoneSwamp";

		public const string SpawnZoneUnknown = "SpawnZoneUnknown";

		public const string RandomEventSystem = "RandomEventSystem";

		public const string EffectAreaPrivateArea = "EffectAreaPrivateArea";

		public const string EffectAreaComfort = "EffectAreaComfort";

		public const string EffectAreaBurning = "EffectAreaBurning";

		public const string EffectAreaHeat = "EffectAreaHeat";

		public const string EffectAreaFire = "EffectAreaFire";

		public const string EffectAreaNoMonsters = "EffectAreaNoMonsters";

		public const string EffectAreaTeleport = "EffectAreaTeleport";

		public const string EffectAreaPlayerBase = "EffectAreaPlayerBase";

		public const string EffectAreaOther = "EffectAreaOther";

		public const string EffectAreaCustomContainer = "EffectAreaCustomContainer";

		public const string EffectAreaCustomCrafting = "EffectAreaCustomCrafting";

		public const string EffectAreaWarmCozy = "EffectAreaWarmCozy";

		public const string Smoke = "Smoke";

		public const string PlayerCover = "PlayerCover";

		public const string PlayerCoverBlocked = "PlayerCoverBlocked";

		public const string Terrain = "Terrain";

		public static string GetZoneCorner(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			if ((int)biome == 32)
			{
				return "ZoneCornerAshlands";
			}
			if ((int)biome == 8)
			{
				return "ZoneCornerBlackForest";
			}
			if ((int)biome == 64)
			{
				return "ZoneCornerDeepNorth";
			}
			if ((int)biome == 1)
			{
				return "ZoneCornerMeadows";
			}
			if ((int)biome == 512)
			{
				return "ZoneCornerMistlands";
			}
			if ((int)biome == 4)
			{
				return "ZoneCornerMountain";
			}
			if ((int)biome == 256)
			{
				return "ZoneCornerOcean";
			}
			if ((int)biome == 16)
			{
				return "ZoneCornerPlains";
			}
			if ((int)biome == 2)
			{
				return "ZoneCornerSwamp";
			}
			return "ZoneCornerUnknown";
		}

		public static string GetSpawnZone(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			if ((int)biome == 32)
			{
				return "SpawnZoneAshlands";
			}
			if ((int)biome == 8)
			{
				return "SpawnZoneBlackForest";
			}
			if ((int)biome == 64)
			{
				return "SpawnZoneDeepNorth";
			}
			if ((int)biome == 1)
			{
				return "SpawnZoneMeadows";
			}
			if ((int)biome == 512)
			{
				return "SpawnZoneMistlands";
			}
			if ((int)biome == 4)
			{
				return "SpawnZoneMountain";
			}
			if ((int)biome == 256)
			{
				return "SpawnZoneOcean";
			}
			if ((int)biome == 16)
			{
				return "SpawnZonePlains";
			}
			if ((int)biome == 2)
			{
				return "SpawnZoneSwamp";
			}
			return "SpawnZoneUnknown";
		}

		public static string GetEffectArea(Type type)
		{
			//IL_0000: 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_000b: 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_0016: 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_0021: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0044: 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)
			if ((type & 8) != 0)
			{
				return "EffectAreaBurning";
			}
			if ((type & 1) != 0)
			{
				return "EffectAreaHeat";
			}
			if ((type & 2) != 0)
			{
				return "EffectAreaFire";
			}
			if ((type & 0x20) != 0)
			{
				return "EffectAreaNoMonsters";
			}
			if ((type & 0x10) != 0)
			{
				return "EffectAreaTeleport";
			}
			if ((type & 4) != 0)
			{
				return "EffectAreaPlayerBase";
			}
			if ((type & 0x40) != 0)
			{
				return "EffectAreaWarmCozy";
			}
			return "EffectAreaOther";
		}
	}
	public static class Tool
	{
		public const string ExtraInfo = "ExtraInfo";

		public const string Time = "Time";

		public const string Weather = "Weather";

		public const string Wind = "Wind";

		public const string Position = "Position";

		public const string Altitude = "Altitude";

		public const string Forest = "Forest";

		public const string Blocked = "Blocked";

		public const string HUD = "HUD";

		public const string Stagger = "Stagger";

		public const string Heat = "Heat";

		public const string Speed = "Speed";

		public const string Stealth = "Stealth";
	}
	public static class CoverUtils
	{
		public static Vector3 GetCoverPoint(CraftingStation obj)
		{
			//IL_0019: 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)
			if (!Object.op_Implicit((Object)(object)obj.m_roofCheckPoint))
			{
				return Vector3.zero;
			}
			return obj.m_roofCheckPoint.position;
		}

		public static Vector3 GetCoverPoint(Fermenter obj)
		{
			//IL_0019: 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)
			if (!Object.op_Implicit((Object)(object)obj.m_roofCheckPoint))
			{
				return Vector3.zero;
			}
			return obj.m_roofCheckPoint.position;
		}

		public static Vector3 GetCoverPoint(Beehive obj)
		{
			//IL_0019: 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)
			if (!Object.op_Implicit((Object)(object)obj.m_coverPoint))
			{
				return Vector3.zero;
			}
			return obj.m_coverPoint.position;
		}

		public static Vector3 GetCoverPoint(Fireplace obj)
		{
			//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_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)
			return ((Component)obj).transform.position + Vector3.up * obj.m_coverCheckOffset;
		}

		public static Vector3 GetCoverPoint(Bed obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return obj.GetSpawnPoint();
		}

		public static Vector3 GetCoverPoint(Windmill obj)
		{
			//IL_001e: 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)
			if (!Object.op_Implicit((Object)(object)obj.m_propeller))
			{
				return Vector3.zero;
			}
			return ((Component)obj.m_propeller).transform.position;
		}

		public static Vector3 GetCoverPoint(Player obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((Character)obj).GetCenterPoint();
		}

		public static bool ChecksCover(Fireplace obj)
		{
			if ((Object)(object)obj.m_enabledObjectLow != (Object)null)
			{
				return (Object)(object)obj.m_enabledObjectHigh != (Object)null;
			}
			return false;
		}
	}
	public class DamageModifierUtils
	{
		private static readonly DamageType[] DAMAGE_TYPES;

		public static string DamageTypeToString(DamageType damageType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			if ((int)damageType == 1)
			{
				return "Blunt";
			}
			if ((int)damageType == 8)
			{
				return "Chop";
			}
			if ((int)damageType == 32)
			{
				return "Fire";
			}
			if ((int)damageType == 64)
			{
				return "Frost";
			}
			if ((int)damageType == 128)
			{
				return "Lightning";
			}
			if ((int)damageType == 16)
			{
				return "Pickaxe";
			}
			if ((int)damageType == 4)
			{
				return "Pierce";
			}
			if ((int)damageType == 256)
			{
				return "Poison";
			}
			if ((int)damageType == 2)
			{
				return "Slash";
			}
			if ((int)damageType == 512)
			{
				return "Spirit";
			}
			return "";
		}

		private static string GetModifierText(DamageModifiers modifiers, DamageType damageType, bool ignoreNeutral, bool ignoreIgnore)
		{
			//IL_0000: 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_000f: 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_0015: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Invalid comparison between Unknown and I4
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			string text = DamageTypeToString(damageType);
			DamageModifier modifier = ((DamageModifiers)(ref modifiers)).GetModifier(damageType);
			if (ignoreNeutral && (int)modifier == 3)
			{
				return text + ": " + Format.String("x0");
			}
			if (ignoreNeutral && !ignoreIgnore && (int)modifier == 4)
			{
				return text + ": " + Format.String("x0");
			}
			if ((int)modifier == 1)
			{
				return text + ": " + Format.String("x0.5");
			}
			if ((int)modifier == 5)
			{
				return text + ": " + Format.String("x0.25");
			}
			if ((int)modifier == 2)
			{
				return text + ": " + Format.String("x1.5");
			}
			if ((int)modifier == 6)
			{
				return text + ": " + Format.String("x2");
			}
			if (!ignoreNeutral && (int)modifier == 0)
			{
				return text + ": " + Format.String("x1");
			}
			return "";
		}

		public static string Get(DamageModifiers modifiers, bool ignoreNeutral, bool ignoreIgnore)
		{
			//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)
			if (!Settings.Resistances)
			{
				return "";
			}
			return Format.JoinRow(from type in DAMAGE_TYPES
				select GetModifierText(modifiers, type, ignoreNeutral, ignoreIgnore) into text
				where text.Length > 0
				select text);
		}

		static DamageModifierUtils()
		{
			DamageType[] array = new DamageType[10];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			DAMAGE_TYPES = (DamageType[])(object)array;
		}
	}
	public class DataUtils
	{
		public static GameObject? GetPrefab(string hashStr)
		{
			if (int.TryParse(hashStr, out var result))
			{
				return GetPrefab(result);
			}
			return null;
		}

		public static GameObject? GetPrefab(int hash)
		{
			if (hash == 0)
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(hash);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return null;
			}
			return prefab;
		}

		public static void Float(ZNetView view, int hash, Action<float> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				float @float = view.GetZDO().GetFloat(hash, -1f);
				if (!(@float < 0f))
				{
					action(@float);
				}
			}
		}

		public static void Long(ZNetView view, int hash, Action<long> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				long @long = view.GetZDO().GetLong(hash, -1L);
				if (@long >= 0)
				{
					action(@long);
				}
			}
		}

		public static void Int(ZNetView view, int hash, Action<int> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				int @int = view.GetZDO().GetInt(hash, -1);
				if (@int >= 0)
				{
					action(@int);
				}
			}
		}

		public static void Bool(ZNetView view, int hash, Action<bool> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				bool @bool = view.GetZDO().GetBool(hash, false);
				action(@bool);
			}
		}

		public static void String(ZNetView view, int hash, Action<string> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				string @string = view.GetZDO().GetString(hash, "");
				if (!(@string == ""))
				{
					action(@string);
				}
			}
		}

		public static void Prefab(ZNetView view, int hash, Action<GameObject> action)
		{
			if (!((Object)(object)view == (Object)null) && view.IsValid())
			{
				GameObject prefab = GetPrefab(view.GetZDO().GetInt(hash, 0));
				if (!((Object)(object)prefab == (Object)null))
				{
					action(prefab);
				}
			}
		}
	}
	public class EffectAreaUtils
	{
		public static string GetTypeText(Type type)
		{
			//IL_0006: 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_0016: 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_0026: 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_0036: 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_004a: 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)
			//IL_005a: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			if ((type & 8) != 0)
			{
				list.Add("Burning");
			}
			if ((type & 1) != 0)
			{
				list.Add("Heat");
			}
			if ((type & 2) != 0)
			{
				list.Add("Fire");
			}
			if ((type & 0x20) != 0)
			{
				list.Add("No monsters");
			}
			if ((type & 0x10) != 0)
			{
				list.Add("Teleport");
			}
			if ((type & 4) != 0)
			{
				list.Add("Base");
			}
			if ((type & 0x40) != 0)
			{
				list.Add("Warm and cozy");
			}
			return Format.JoinRow(list);
		}
	}
	public class EnvUtils
	{
		public static string GetCurrentEnvironment()
		{
			return Format.String(EnvMan.instance.GetCurrentEnvironment().m_name);
		}

		public static string GetProgress()
		{
			long environmentDuration = EnvMan.instance.m_environmentDuration;
			double value = ZNet.instance.GetTimeSeconds() % (double)environmentDuration;
			return Format.ProgressPercent("Next", value, environmentDuration);
		}

		public static string GetEnvironmentRoll()
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			long num = (long)ZNet.instance.GetTimeSeconds() / EnvMan.instance.m_environmentDuration;
			State state = Random.state;
			Random.InitState((int)num);
			float num2 = Random.Range(0f, 1f);
			Random.state = state;
			return Format.Percent(num2) + " (seed " + num + ")";
		}

		private static string GetClock()
		{
			long dayLengthSec = EnvMan.instance.m_dayLengthSec;
			double num = ZNet.instance.GetTimeSeconds() % (double)dayLengthSec / (double)dayLengthSec * 3600.0 * 24.0;
			double num2 = Math.Floor(num / 3600.0);
			double num3 = Math.Floor((num - num2 * 3600.0) / 60.0);
			return num2.ToString().PadLeft(2, '0') + ":" + num3.ToString().PadLeft(2, '0');
		}

		public static string GetTime()
		{
			string value = (EnvMan.IsDay() ? "Day" : "Night");
			return Format.String(GetClock()) + " (" + Format.String(value) + ")";
		}

		public static string GetEnvironment(EnvEntry env, float totalWeight)
		{
			string name = EnvMan.instance.GetCurrentEnvironment().m_name;
			string text = Format.String(env.m_env.m_name, env.m_env.m_name == name);
			text = text + " (" + Format.Percent(env.m_weight / totalWeight) + "): ";
			text = text + Format.Range(env.m_env.m_windMin, env.m_env.m_windMax) + " wind";
			if (env.m_env.m_alwaysDark)
			{
				text = text + ", " + Format.String("Dark");
			}
			if (env.m_env.m_isFreezing)
			{
				text = text + ", " + Format.String("Freezing");
			}
			if (env.m_env.m_isFreezingAtNight)
			{
				text = text + ", " + Format.String("Freezing at night");
			}
			if (env.m_env.m_isCold)
			{
				text = text + ", " + Format.String("Cold");
			}
			if (!env.m_env.m_isColdAtNight)
			{
				text = text + ", " + Format.String("Never cold");
			}
			if (env.m_env.m_isWet)
			{
				text = text + ", " + Format.String("Wet");
			}
			return text;
		}

		public static string GetWindWithAngle()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			Vector3 windDir = EnvMan.instance.GetWindDir();
			double value = (double)Mathf.Atan2(windDir.x, windDir.z) / Math.PI * 180.0;
			return GetWind() + " from " + Format.Int(value) + " degrees";
		}

		public static string GetWind()
		{
			float windIntensity = EnvMan.instance.GetWindIntensity();
			return "Wind: " + Format.Percent(windIntensity);
		}

		public static string GetWindRoll()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			State state = Random.state;
			float num = 0f;
			float num2 = 0.5f;
			long num3 = (long)ZNet.instance.GetTimeSeconds();
			EnvMan.instance.AddWindOctave(num3, 1, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 2, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 4, ref num, ref num2);
			EnvMan.instance.AddWindOctave(num3, 8, ref num, ref num2);
			Random.state = state;
			return Format.Percent(num2) + " and " + Format.Degrees((double)(num * 180f) / Math.PI);
		}

		public static string GetWindHud()
		{
			float windIntensity = EnvMan.instance.GetWindIntensity();
			return "Wind: " + Format.Percent(windIntensity);
		}

		public static double GetAvgWind(EnvEntry env)
		{
			return (double)(env.m_env.m_windMin + env.m_env.m_windMax) / 2.0 * (double)env.m_weight;
		}

		public static string GetPosition(Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return "Pos: " + Format.Coordinates(position);
		}

		public static string GetAltitude(Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return "Altitude: " + Format.Int(position.y - ZoneSystem.instance.m_waterLevel);
		}

		public static string GetBlocked(Vector3 position)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!ZoneSystem.instance.IsBlocked(position))
			{
				return "";
			}
			return "blocked";
		}

		public static string GetForest(Vector3 position)
		{
			//IL_0000: 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)
			return (WorldGenerator.InForest(position) ? "Forest" : "No forest") + " (" + Format.Float(WorldGenerator.GetForestFactor(position)) + ")";
		}
	}
	[HarmonyPatch(typeof(Attack), "OnAttackTrigger")]
	public class AttackTrigger
	{
		private static void Postfix(Attack __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.m_character))
			{
				AttackUtils.DrawAttack(__instance.m_character, __instance);
			}
		}
	}
	public class AttackUtils
	{
		private static string GetText(Attack attack)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			List<string> values = new List<string>
			{
				$"Type: {attack.m_attackType}",
				"Height: " + Format.Meters(attack.m_attackHeight),
				"Offset: " + Format.Meters(attack.m_attackOffset),
				"Range: " + Format.Meters(attack.m_attackRange),
				"Angle: " + Format.Degrees(attack.m_attackAngle),
				"Ray: " + Format.Meters(attack.m_attackRayWidth)
			};
			return string.Join("\n", values);
		}

		public static void DrawAttack(Humanoid parent, Attack attack)
		{
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_007e: 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_0060: Invalid comparison between Unknown and I4
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Invalid comparison between Unknown and I4
			//IL_00ab: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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_00ef: 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_00c4: 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)
			AttackType attackType = attack.m_attackType;
			float attackHeight = attack.m_attackHeight;
			float attackOffset = attack.m_attackOffset;
			float attackRange = attack.m_attackRange;
			float attackRayWidth = attack.m_attackRayWidth;
			float attackAngle = attack.m_attackAngle;
			LineRenderer[] renderers = Draw.GetRenderers((MonoBehaviour)(object)parent, "Attack");
			for (int i = 0; i < renderers.Length; i++)
			{
				Object.Destroy((Object)(object)((Component)renderers[i]).gameObject);
			}
			if ((int)attackType != 0 && (int)attackType != 1)
			{
				return;
			}
			Vector3 val = Vector3.up * attackHeight + Vector3.right * attackOffset;
			float num = attackAngle / 2f;
			for (float num2 = 0f - num; num2 <= num; num2 += 4f)
			{
				Quaternion val2 = Quaternion.identity;
				if ((int)attackType == 0)
				{
					val2 = Quaternion.Euler(0f, 0f - num2, 0f);
				}
				else if ((int)attackType == 1)
				{
					val2 = Quaternion.Euler(num2, 0f, 0f);
				}
				Vector3 end = val + val2 * Vector3.forward * (attackRange - attackRayWidth);
				GameObject obj = Draw.DrawLine("Attack", (MonoBehaviour)(object)parent, val, end);
				string title = (Object.op_Implicit((Object)(object)attack.m_weapon.m_dropPrefab) ? Utils.GetPrefabName(attack.m_weapon.m_dropPrefab) : "");
				Draw.AddText(obj, title, GetText(attack));
				LineRenderer component = obj.GetComponent<LineRenderer>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.widthMultiplier = 2f * Mathf.Max(attackRayWidth, 0.01f);
				}
			}
		}
	}
	public class CharacterUtils
	{
		public static bool IsExcluded(Character instance)
		{
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return true;
			}
			string name = ((Object)instance).name;
			string name2 = instance.m_name;
			string name3 = Localization.instance.Localize(instance.m_name);
			string excludedCreatures = Settings.ExcludedCreatures;
			if (!LocationUtils.IsIn(excludedCreatures, name) && !LocationUtils.IsIn(excludedCreatures, name2))
			{
				return LocationUtils.IsIn(excludedCreatures, name3);
			}
			return true;
		}

		public static bool IsTracked(ZNetView instance)
		{
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return false;
			}
			string name = ((Object)instance).name;
			string text = name;
			Character val = default(Character);
			if (((Component)instance).TryGetComponent<Character>(ref val))
			{
				text = val.m_name;
			}
			string name2 = Localization.instance.Localize(text);
			string trackedObjects = Settings.TrackedObjects;
			if (!LocationUtils.IsIn(trackedObjects, name) && !LocationUtils.IsIn(trackedObjects, text))
			{
				return LocationUtils.IsIn(trackedObjects, name2);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	[HarmonyPriority(0)]
	public class Character_Awake
	{
		public static void RebuildLoaded()
		{
			foreach (Character item in SceneObjects.FindLoaded<Character>())
			{
				Postfix(item);
			}
		}

		private static void DrawNoise(Character instance)
		{
			if (!Settings.IsDisabled("CreatureNoise") && !CharacterUtils.IsExcluded(instance) && !Draw.HasVisual((MonoBehaviour)(object)instance, "CreatureNoise"))
			{
				Draw.DrawSphere("CreatureNoise", (MonoBehaviour)(object)instance, instance.m_noiseRange).AddComponent<NoiseText>().character = instance;
			}
		}

		private static void Postfix(Character __instance)
		{
			DrawNoise(__instance);
		}
	}
	[HarmonyPatch(typeof(Character), "UpdateNoise")]
	public class Character_UpdateNoise : Component
	{
		private static void Postfix(Character __instance)
		{
			if (!Settings.IsHidden("CreatureNoise") && !CharacterUtils.IsExcluded(__instance))
			{
				Draw.UpdateSphere((MonoBehaviour)(object)__instance, __instance.m_noiseRange);
			}
		}
	}
	public class NoiseText : MonoBehaviour, Hoverable
	{
		public Character? character;

		public string GetHoverText()
		{
			if (!((Object)(object)character == (Object)null))
			{
				return GetHoverName() + "\n" + Texts.GetNoise(character);
			}
			return "";
		}

		public string GetHoverName()
		{
			if (!((Object)(object)character == (Object)null))
			{
				return Translate.Name((MonoBehaviour)(object)character);
			}
			return "";
		}
	}
	[HarmonyPatch(typeof(Character), "GetHoverText")]
	public class Character_GetHoverText
	{
		private static void Postfix(Character __instance, ref string __result)
		{
			if (Settings.ExtraInfo)
			{
				Text.AddTexts(((Component)__instance).gameObject, ref __result);
			}
		}
	}
	public class Colliders
	{
		public static void DrawColliders(MonoBehaviour obj, string tag)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Collider[] componentsInChildren = ((Component)obj).GetComponentsInChildren<Collider>();
			foreach (Collider val in componentsInChildren)
			{
				if (!val.isTrigger)
				{
					BoxCollider val2 = (BoxCollider)(object)((val is BoxCollider) ? val : null);
					if (val2 != null)
					{
						Draw.DrawBox(tag, obj, val2.size);
					}
					SphereCollider val3 = (SphereCollider)(object)((val is SphereCollider) ? val : null);
					if (val3 != null)
					{
						Draw.DrawSphere(tag, obj, val3.radius);
					}
					CapsuleCollider val4 = (CapsuleCollider)(object)((val is CapsuleCollider) ? val : null);
					if (val4 != null)
					{
						Draw.DrawCapsule(tag, obj, val4.radius, val4.height);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Awake")]
	[HarmonyPriority(0)]
	public class Character_Colliders
	{
		public static void RebuildLoaded()
		{
			foreach (Character item in SceneObjects.FindLoaded<Character>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Character __instance)
		{
			if (!Settings.IsDisabled("CreatureCollider") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "CreatureCollider"))
			{
				Colliders.DrawColliders((MonoBehaviour)(object)__instance, "CreatureCollider");
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "Awake")]
	[HarmonyPriority(0)]
	public class Destructible_Colliders
	{
		public static void RebuildLoaded()
		{
			foreach (Destructible item in SceneObjects.FindLoaded<Destructible>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Destructible __instance)
		{
			if (!Settings.IsDisabled("DestructibleCollider") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "DestructibleCollider"))
			{
				Colliders.DrawColliders((MonoBehaviour)(object)__instance, "DestructibleCollider");
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Awake")]
	[HarmonyPriority(0)]
	public class WearNTear_Colliders
	{
		public static void RebuildLoaded()
		{
			foreach (WearNTear item in SceneObjects.FindLoaded<WearNTear>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(WearNTear __instance)
		{
			if (!Settings.IsDisabled("StructureCollider") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "StructureCollider"))
			{
				Colliders.DrawColliders((MonoBehaviour)(object)__instance, "StructureCollider");
			}
		}
	}
	public class Visual
	{
		private static readonly List<GameObject> renderers = new List<GameObject>();

		private static void DrawCover(MonoBehaviour obj, Vector3 startPos, string name, string text, bool isPlayer = false)
		{
			//IL_003e: 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_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_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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			string[] tags = ((!isPlayer) ? new string[2] { "StructureCover", "StructureCoverBlocked" } : new string[2] { "PlayerCover", "PlayerCoverBlocked" });
			if (Visualization.Draw.GetRenderers(obj, tags).Length != 0)
			{
				return;
			}
			Vector3 val = startPos - ((Component)obj).transform.position;
			float num = 0.5f;
			if (Cover.m_coverRays == null)
			{
				Cover.Setup();
			}
			if (Cover.m_coverRays == null)
			{
				return;
			}
			Vector3[] coverRays = Cover.m_coverRays;
			RaycastHit val3 = default(RaycastHit);
			foreach (Vector3 val2 in coverRays)
			{
				string tag = (isPlayer ? "PlayerCover" : "StructureCover");
				if (Physics.Raycast(startPos + val2 * num, val2, ref val3, 30f - num, Cover.m_coverRayMask))
				{
					tag = (isPlayer ? "PlayerCoverBlocked" : "StructureCoverBlocked");
				}
				Visualization.Draw.AddText(Visualization.Draw.DrawLineWithFixedRotation(tag, obj, val + val2 * num, val + val2 * 30f), name, text);
			}
		}

		public static void DrawCover(CraftingStation obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void Draw(Beehive obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void Draw(Fireplace obj)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover") && CoverUtils.ChecksCover(obj))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void Draw(Bed obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void Draw(Fermenter obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void Draw(Windmill obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj));
			}
		}

		public static void DrawCover(Player obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Helper.IsValid((MonoBehaviour)(object)obj) && !Settings.IsDisabled("PlayerCover"))
			{
				DrawCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Translate.Name((MonoBehaviour)(object)obj), Texts.GetCover(obj), isPlayer: true);
			}
		}

		private static void UpdateCover(MonoBehaviour obj, Vector3 startPos, string text, bool isPlayer = false)
		{
			//IL_0072: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return;
			}
			string[] tags = ((!isPlayer) ? new string[2] { "StructureCover", "StructureCoverBlocked" } : new string[2] { "PlayerCover", "PlayerCoverBlocked" });
			LineRenderer[] array = Visualization.Draw.GetRenderers(obj, tags);
			if (Cover.m_coverRays == null)
			{
				return;
			}
			Vector3[] coverRays = Cover.m_coverRays;
			if (array.Length != coverRays.Length)
			{
				return;
			}
			float num = 0.5f;
			int num2 = 0;
			Vector3[] array2 = coverRays;
			RaycastHit val2 = default(RaycastHit);
			foreach (Vector3 val in array2)
			{
				string tag = (isPlayer ? "PlayerCover" : "StructureCover");
				if (Physics.Raycast(startPos + val * num, val, ref val2, 30f - num, Cover.m_coverRayMask))
				{
					tag = (isPlayer ? "PlayerCoverBlocked" : "StructureCoverBlocked");
				}
				LineRenderer obj2 = array[num2];
				Color color = Visualization.Draw.GetColor(tag);
				((Renderer)obj2).material.SetColor("_Color", color);
				StaticText component = ((Component)obj2).GetComponent<StaticText>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.text = text;
				}
				num2++;
			}
		}

		public static void Update(CraftingStation obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Beehive obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Fireplace obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Bed obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Fermenter obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Windmill obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("StructureCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj));
			}
		}

		public static void Update(Player obj)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (Helper.IsValid((MonoBehaviour)(object)obj) && !Settings.IsDisabled("PlayerCover"))
			{
				UpdateCover((MonoBehaviour)(object)obj, CoverUtils.GetCoverPoint(obj), Texts.GetCover(obj), isPlayer: true);
			}
		}

		private static Vector3 CalcNormal(Heightmap hm, int x, int y)
		{
			//IL_0003: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_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_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_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_004b: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = hm.CalcVertex(x, y);
			Vector3 val3;
			if (x == hm.m_width)
			{
				Vector3 val2 = hm.CalcVertex(x - 1, y);
				val3 = val - val2;
			}
			else
			{
				val3 = hm.CalcVertex(x + 1, y) - val;
			}
			Vector3 val5;
			if (y == hm.m_width)
			{
				Vector3 val4 = hm.CalcVertex(x, y - 1);
				val5 = val - val4;
			}
			else
			{
				val5 = hm.CalcVertex(x, y + 1) - val;
			}
			Vector3 val6 = Vector3.Cross(val5, val3);
			return ((Vector3)(ref val6)).normalized;
		}

		public static void DrawHeightmap(Vector3 pos, float radius)
		{
			//IL_0006: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			List<Heightmap> list = new List<Heightmap>();
			Heightmap.FindHeightmap(pos, radius, list);
			foreach (GameObject renderer in renderers)
			{
				Object.Destroy((Object)(object)renderer);
			}
			renderers.Clear();
			foreach (Heightmap item in list)
			{
				int num = item.m_width + 1;
				TerrainComp val = TerrainComp.FindTerrainCompiler(((Component)item).transform.position);
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < num; j++)
					{
						Vector3 val2 = ((Component)item).transform.position + item.CalcVertex(j, i);
						Vector3 val3 = item.CalcVertex(j, i);
						if (!(Utils.DistanceXZ(val2, pos) > radius))
						{
							Vector3 val4 = CalcNormal(item, j, i);
							GameObject val5 = Visualization.Draw.DrawLineWithFixedRotation("Terrain", (MonoBehaviour)(object)item, val3, val3 + val4 * 1f);
							Color paintMask = item.GetPaintMask(j, i);
							((Renderer)val5.GetComponent<LineRenderer>()).material.SetColor("_Color", paintMask);
							renderers.Add(val5);
							string text = item.m_heights[j * num + i].ToString("F4", CultureInfo.InvariantCulture);
							string text2 = "";
							string text3 = "";
							int num2 = i * num + j;
							if (Object.op_Implicit((Object)(object)val))
							{
								text2 = val.m_levelDelta[num2].ToString("F4", CultureInfo.InvariantCulture);
								text3 = val.m_smoothDelta[num2].ToString("F4", CultureInfo.InvariantCulture);
							}
							string text4 = $"Index: {num2}, i: {i}, j: {j}\nHeight: {text}\nLevel: {text2}\nSmooth: {text3}\nPaint: {paintMask:F4}";
							Visualization.Draw.AddText(val5, "Terrain", text4);
						}
					}
				}
			}
		}

		public static void DrawPaintmap(Vector3 pos, float radius)
		{
			//IL_0006: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0141: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			List<Heightmap> list = new List<Heightmap>();
			Heightmap.FindHeightmap(pos, radius, list);
			foreach (GameObject renderer in renderers)
			{
				Object.Destroy((Object)(object)renderer);
			}
			renderers.Clear();
			float num6 = default(float);
			Vector3 val = default(Vector3);
			foreach (Heightmap item in list)
			{
				int num = item.m_width / 2;
				int num2 = item.m_width + 1;
				float num3 = (float)item.m_width / (float)num2;
				for (int i = -num; i <= num; i++)
				{
					for (int j = -num; j <= num; j++)
					{
						float num4 = (float)j * num3;
						float num5 = (float)i * num3;
						float num7 = (item.GetWorldHeight(new Vector3(((Component)item).transform.position.x + num4, 0f, ((Component)item).transform.position.z + num5), ref num6) ? num6 : 0f);
						((Vector3)(ref val))..ctor(num4, num7, num5);
						if (!(Utils.DistanceXZ(((Component)item).transform.position + val, pos) > radius))
						{
							GameObject val2 = Visualization.Draw.DrawLineWithFixedRotation("Terrain", (MonoBehaviour)(object)item, val, val + Vector3.up);
							int num8 = i + num;
							int num9 = j + num;
							Color paintMask = item.GetPaintMask(num9, num8);
							((Renderer)val2.GetComponent<LineRenderer>()).material.SetColor("_Color", paintMask);
							renderers.Add(val2);
							int num10 = num8 * num2 + num9;
							string text = $"Index: {num10}, i: {num8}, j: {num9}\nPaint: {paintMask:F4}";
							Visualization.Draw.AddText(val2, "Terrain", text);
						}
					}
				}
			}
		}

		public static void Draw(EffectArea obj)
		{
			//IL_001d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && Object.op_Implicit((Object)(object)obj.m_collider))
			{
				DrawPlayerBase(obj);
				string effectArea = Tag.GetEffectArea((Type)(obj.m_type & 0xFB));
				if (!Settings.IsDisabled(effectArea) && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, effectArea))
				{
					string typeText = EffectAreaUtils.GetTypeText(obj.m_type);
					float num = obj.GetRadius() * ((Component)obj).transform.lossyScale.x;
					Visualization.Draw.AddText(Visualization.Draw.DrawSphere(effectArea, (MonoBehaviour)(object)obj, Math.Max(0.5f, num)), typeText, Text.Radius(num));
				}
			}
		}

		private static void DrawPlayerBase(EffectArea obj)
		{
			//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_0009: Invalid comparison between Unknown and I4
			if ((obj.m_type & 4) > 0 && !Settings.IsDisabled("EffectAreaPlayerBase"))
			{
				GameObject root = Helper.GetRoot((MonoBehaviour)(object)obj);
				if (!Object.op_Implicit((Object)(object)root.GetComponent<CircleRuler>()))
				{
					root.gameObject.AddComponent<CircleRuler>().Radius = obj.GetRadius();
				}
			}
		}

		public static void Draw(PrivateArea obj)
		{
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("EffectAreaPrivateArea") && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, "EffectAreaPrivateArea"))
			{
				Visualization.Draw.AddText(Visualization.Draw.DrawCylinder("EffectAreaPrivateArea", (MonoBehaviour)(object)obj, obj.m_radius), "Protection", Text.Radius(obj.m_radius));
			}
		}

		public static void Draw(Container obj)
		{
			float customContainerEffectAreaRadius = Settings.CustomContainerEffectAreaRadius;
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("EffectAreaCustomContainer") && customContainerEffectAreaRadius != 0f && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, "EffectAreaCustomContainer"))
			{
				Visualization.Draw.AddText(Visualization.Draw.DrawSphere("EffectAreaCustomContainer", (MonoBehaviour)(object)obj, Math.Max(0.5f, customContainerEffectAreaRadius)), "Container", Text.Radius(customContainerEffectAreaRadius));
			}
		}

		public static void Draw(CraftingStation obj)
		{
			DrawCover(obj);
			DrawCustomEffectArea(obj);
		}

		public static void DrawCustomEffectArea(CraftingStation obj)
		{
			float customCraftingEffectAreaRadius = Settings.CustomCraftingEffectAreaRadius;
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("EffectAreaCustomCrafting") && customCraftingEffectAreaRadius != 0f && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, "EffectAreaCustomCrafting"))
			{
				Visualization.Draw.AddText(Visualization.Draw.DrawSphere("EffectAreaCustomCrafting", (MonoBehaviour)(object)obj, Math.Max(0.5f, customCraftingEffectAreaRadius)), "Crafting station", Text.Radius(customCraftingEffectAreaRadius));
			}
		}

		public static void Draw(Piece obj)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && obj.m_comfort != 0 && !Settings.IsDisabled("EffectAreaComfort") && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, "EffectAreaComfort"))
			{
				Visualization.Draw.AddText(Visualization.Draw.DrawSphere("EffectAreaComfort", (MonoBehaviour)(object)obj, 10f), $"Comfort {obj.m_comfort} {obj.m_comfortGroup}", Text.Radius(10f));
			}
		}

		public static void Draw(Smoke obj)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)obj) && !Settings.IsDisabled("Smoke") && !Visualization.Draw.HasVisual((MonoBehaviour)(object)obj, "Smoke"))
			{
				SphereCollider component = ((Component)obj).GetComponent<SphereCollider>();
				if (Object.op_Implicit((Object)(object)component))
				{
					Text.AddText(Visualization.Draw.DrawSphere("Smoke", (MonoBehaviour)(object)obj, component.radius * ((Component)obj).transform.lossyScale.x));
				}
			}
		}
	}
	[HarmonyPatch(typeof(BaseAI), "Awake")]
	[HarmonyPriority(0)]
	public class BaseAI_Awake
	{
		public static void RebuildLoaded()
		{
			foreach (BaseAI item in SceneObjects.FindLoaded<BaseAI>())
			{
				Postfix(item, ((Component)item).GetComponent<Character>());
			}
		}

		private static void DrawHearRange(BaseAI obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureHearRange") && Object.op_Implicit((Object)(object)obj) && !(obj.m_hearRange > 100f) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureHearRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureHearRange", (MonoBehaviour)(object)obj, obj.m_hearRange), name, text);
			}
		}

		private static void DrawViewRange(BaseAI obj, Vector3 eye, string name, string text)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.IsDisabled("CreatureViewRange") && Object.op_Implicit((Object)(object)obj) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureViewRange"))
			{
				Draw.AddText(Draw.DrawCone("CreatureViewRange", (MonoBehaviour)(object)obj, eye, obj.m_viewRange, obj.m_viewAngle), name, text);
			}
		}

		private static void DrawAlertRange(MonsterAI obj, Vector3 eye, string name, string text)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.IsDisabled("CreatureAlertRange") && Object.op_Implicit((Object)(object)obj) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureAlertRange"))
			{
				Draw.AddText(Draw.DrawArc("CreatureAlertRange", (MonoBehaviour)(object)obj, eye, obj.m_alertRange, ((BaseAI)obj).m_viewAngle), name, text);
			}
		}

		private static void DrawFireLimit(BaseAI obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureFireRange") && Object.op_Implicit((Object)(object)obj) && (obj.m_afraidOfFire || obj.m_avoidFire) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureFireRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureFireRange", (MonoBehaviour)(object)obj, 3f), name, text);
			}
		}

		private static void DrawTotalLimit(Procreation obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureBreedingTotalRange") && Object.op_Implicit((Object)(object)obj) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureBreedingTotalRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureBreedingTotalRange", (MonoBehaviour)(object)obj, obj.m_totalCheckRange), name, text);
			}
		}

		private static void DrawPartnerCheck(Procreation obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureBreedingPartnerRange") && Object.op_Implicit((Object)(object)obj) && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureBreedingPartnerRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureBreedingPartnerRange", (MonoBehaviour)(object)obj, obj.m_partnerCheckRange), name, text);
			}
		}

		private static void DrawFoodCheck(MonsterAI obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureFoodSearchRange") && Object.op_Implicit((Object)(object)obj) && obj.m_consumeItems.Count != 0 && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureFoodSearchRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureFoodSearchRange", (MonoBehaviour)(object)obj, obj.m_consumeSearchRange), name, text);
			}
		}

		private static void DrawEatRange(MonsterAI obj, string name, string text)
		{
			if (!Settings.IsDisabled("CreatureEatingRange") && Object.op_Implicit((Object)(object)obj) && obj.m_consumeItems.Count != 0 && !Draw.HasVisual((MonoBehaviour)(object)obj, "CreatureEatingRange"))
			{
				Draw.AddText(Draw.DrawSphere("CreatureEatingRange", (MonoBehaviour)(object)obj, obj.m_consumeRange), name, text);
			}
		}

		private static void Postfix(BaseAI __instance, Character ___m_character)
		{
			//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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)___m_character) && !CharacterUtils.IsExcluded(___m_character))
			{
				string name = Translate.Name((MonoBehaviour)(object)___m_character);
				MonsterAI component = ((Component)__instance).GetComponent<MonsterAI>();
				Procreation component2 = ((Component)__instance).GetComponent<Procreation>();
				string senses = Texts.GetSenses(__instance, component, component2);
				Vector3 localPosition = ___m_character.m_eye.localPosition;
				DrawHearRange(__instance, name, senses);
				DrawViewRange(__instance, localPosition, name, senses);
				DrawAlertRange(component, localPosition, name, senses);
				DrawFireLimit(__instance, name, senses);
				DrawTotalLimit(component2, name, senses);
				DrawPartnerCheck(component2, name, senses);
				DrawFoodCheck(component, name, senses);
				DrawEatRange(component, name, senses);
			}
		}
	}
	[HarmonyPatch(typeof(Heightmap))]
	public class TestPatches
	{
		private const float scale = 64f / 65f;

		private const int half = 32;

		[HarmonyPatch("WorldToVertexMask")]
		[HarmonyPrefix]
		private static bool PatchWorldToVertexMask(Heightmap __instance, Vector3 worldPos, ref int x, ref int y)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			WorldToVertexMask(__instance, worldPos, ref x, ref y);
			return false;
		}

		private static void WorldToVertexMask(Heightmap hm, Vector3 worldPos, ref int x, ref int y)
		{
			//IL_0000: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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)
			Vector3 val = worldPos - ((Component)hm).transform.position;
			x = Mathf.FloorToInt(val.x / (64f / 65f) + 0.5f) + 32;
			y = Mathf.FloorToInt(val.z / (64f / 65f) + 0.5f) + 32;
		}

		[HarmonyPatch("GetVegetationMask")]
		[HarmonyPrefix]
		private static bool PatchGetVegetationMask(Heightmap __instance, Vector3 worldPos, ref float __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			__result = GetVegetationMask(__instance, worldPos);
			return false;
		}

		private static float GetVegetationMask(Heightmap hm, Vector3 worldPos)
		{
			//IL_0001: 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)
			int num = default(int);
			int num2 = default(int);
			hm.WorldToVertexMask(worldPos, ref num, ref num2);
			return hm.m_paintMask.GetPixel(num, num2).a;
		}
	}
	public class JewelcraftingPatcher
	{
		public static void DoPatching(Assembly assembly)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			if (assembly == null)
			{
				return;
			}
			Harmony val = new Harmony("esp.jewelcrafting");
			MethodInfo methodInfo = AccessTools.Method(assembly.GetType("Jewelcrafting.DestructibleSetup+GemSpawner"), "Awake", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Log.Warning("\"Jewelcrafting\" detected. Unable to patch \"Awake\" for visual rays.");
				return;
			}
			Log.Info("\"Jewelcrafting\" detected. Patching \"Awake\" for visual rays.");
			MethodInfo methodInfo2 = SymbolExtensions.GetMethodInfo<MonoBehaviour>((Expression<Action<MonoBehaviour>>)((MonoBehaviour __instance) => Postfix(__instance)));
			val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		private static void Postfix(MonoBehaviour __instance)
		{
			Text.AddText(Draw.DrawMarkerLine("SpawnPointRespawning", __instance), Utils.GetPrefabName(((Component)__instance).gameObject));
		}
	}
	public class LocationUtils
	{
		public static bool IsIn(string arrayStr, string name)
		{
			string text = Localization.instance.Localize(name);
			string nameLower = text.ToLower().Replace("(clone)", "");
			return Array.Exists(arrayStr.ToLower().Split(new char[1] { ',' }), delegate(string item)
			{
				if (item.StartsWith("*") && item.EndsWith("*"))
				{
					return nameLower.Contains(item.Replace("*", ""));
				}
				if (item.StartsWith("*"))
				{
					return nameLower.EndsWith(item.Replace("*", ""));
				}
				return item.EndsWith("*") ? nameLower.StartsWith(item.Replace("*", "")) : (item == nameLower);
			});
		}

		private static bool IsResourceEnabled(string name)
		{
			return !IsIn(Settings.ExcludedResources, name);
		}

		public static bool IsEnabled(Pickable obj)
		{
			if (!Object.op_Implicit((Object)(object)obj.m_itemPrefab))
			{
				return false;
			}
			if (Settings.IsDisabled(GetTag(obj)))
			{
				return false;
			}
			return IsResourceEnabled(((Object)obj.m_itemPrefab).name);
		}

		public static bool IsEnabled(MineRock obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.IsDisabled(GetTag(obj.m_damageModifiers)))
			{
				return false;
			}
			HoverText component = ((Component)obj).GetComponent<HoverText>();
			if (Object.op_Implicit((Object)(object)component))
			{
				return IsResourceEnabled(component.m_text);
			}
			return IsResourceEnabled(obj.m_name);
		}

		public static bool IsEnabled(MineRock5 obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.IsDisabled(GetTag(obj.m_damageModifiers)))
			{
				return false;
			}
			HoverText component = ((Component)obj).GetComponent<HoverText>();
			if (Object.op_Implicit((Object)(object)component))
			{
				return IsResourceEnabled(component.m_text);
			}
			return IsResourceEnabled(obj.m_name);
		}

		public static bool IsEnabled(TreeLog obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.IsDisabled(GetTag(obj.m_damages)))
			{
				return false;
			}
			HoverText component = ((Component)obj).GetComponent<HoverText>();
			if (Object.op_Implicit((Object)(object)component))
			{
				return IsResourceEnabled(component.m_text);
			}
			return IsResourceEnabled(((Object)obj).name);
		}

		public static bool IsEnabled(TreeBase obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.IsDisabled(GetTag(obj.m_damageModifiers)))
			{
				return false;
			}
			HoverText component = ((Component)obj).GetComponent<HoverText>();
			if (Object.op_Implicit((Object)(object)component))
			{
				return IsResourceEnabled(component.m_text);
			}
			return IsResourceEnabled(((Object)obj).name);
		}

		public static bool IsEnabled(Destructible obj)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (Settings.IsDisabled(GetTag(obj.m_damages)))
			{
				return false;
			}
			HoverText component = ((Component)obj).GetComponent<HoverText>();
			if (Object.op_Implicit((Object)(object)component))
			{
				return IsResourceEnabled(component.m_text);
			}
			return IsResourceEnabled(((Object)obj).name);
		}

		public static string GetTag(DamageModifiers modifiers)
		{
			//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: Invalid comparison between Unknown and I4
			//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_0016: Invalid comparison between Unknown and I4
			if ((int)modifiers.m_chop == 3)
			{
				return "Ore";
			}
			if ((int)modifiers.m_pickaxe == 3)
			{
				return "Tree";
			}
			return "Destructible";
		}

		public static string GetTag(Pickable obj)
		{
			if (!Object.op_Implicit((Object)(object)obj.m_hideWhenPicked) || !(obj.m_respawnTimeMinutes > 0f))
			{
				return "PickableOneTime";
			}
			return "PickableRespawning";
		}
	}
	[HarmonyPatch(typeof(ZNetView), "Awake")]
	[HarmonyPriority(0)]
	public class ZNetView_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (ZNetView item in SceneObjects.FindLoaded<ZNetView>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(ZNetView __instance)
		{
			if (!Settings.IsDisabled("TrackedObject") && CharacterUtils.IsTracked(__instance) && !Draw.HasVisual((MonoBehaviour)(object)__instance, "TrackedObject"))
			{
				Text.AddText(Draw.DrawMarkerLine("TrackedObject", (MonoBehaviour)(object)__instance));
			}
		}
	}
	[HarmonyPatch(typeof(Pickable), "Awake")]
	[HarmonyPriority(0)]
	public class Pickable_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (Pickable item in SceneObjects.FindLoaded<Pickable>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Pickable __instance)
		{
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Location), "Awake")]
	[HarmonyPriority(0)]
	public class Location_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (Location item in SceneObjects.FindLoaded<Location>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Location __instance)
		{
			if (!Settings.IsDisabled("Location") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "Location"))
			{
				Text.AddText(Draw.DrawMarkerLine("Location", (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Awake")]
	[HarmonyPriority(0)]
	public class Container_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (Container item in SceneObjects.FindLoaded<Container>())
			{
				Postfix(item, item.m_piece);
			}
		}

		private static void Postfix(Container __instance, Piece ___m_piece)
		{
			if (!Settings.IsDisabled("Chest") && Object.op_Implicit((Object)(object)___m_piece) && !___m_piece.IsPlacedByPlayer() && !Draw.HasVisual((MonoBehaviour)(object)__instance, "Chest"))
			{
				string text = Format.String(__instance.GetHoverName());
				Text.AddText(Draw.DrawMarkerLine("Chest", (MonoBehaviour)(object)__instance), text);
			}
		}
	}
	[HarmonyPatch(typeof(MineRock), "Start")]
	public class MineRock_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (MineRock item in SceneObjects.FindLoaded<MineRock>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(MineRock __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance.m_damageModifiers);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(MineRock5), "Awake")]
	public class MineRock5_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (MineRock5 item in SceneObjects.FindLoaded<MineRock5>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(MineRock5 __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance.m_damageModifiers);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "Awake")]
	[HarmonyPriority(0)]
	public class Destructible_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (Destructible item in SceneObjects.FindLoaded<Destructible>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Destructible __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance.m_damages);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(TreeBase), "Awake")]
	[HarmonyPriority(0)]
	public class TreeBase_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (TreeBase item in SceneObjects.FindLoaded<TreeBase>())
			{
				Postfix(item);
			}
		}

		public static void Postfix(TreeBase __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance.m_damageModifiers);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(RandomSpeak), "Start")]
	[HarmonyPriority(0)]
	public class RandomSpeak_Sphere
	{
		public static void RebuildLoaded()
		{
			foreach (RandomSpeak item in SceneObjects.FindLoaded<RandomSpeak>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(RandomSpeak __instance)
		{
			if (!Settings.IsDisabled("TrophySpeak") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "TrophySpeak"))
			{
				Draw.DrawSphere("TrophySpeak", (MonoBehaviour)(object)__instance, __instance.m_triggerDistance);
			}
		}
	}
	[HarmonyPatch(typeof(TreeLog), "Awake")]
	[HarmonyPriority(0)]
	public class TreeLog_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (TreeLog item in SceneObjects.FindLoaded<TreeLog>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(TreeLog __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (LocationUtils.IsEnabled(__instance))
			{
				string tag = LocationUtils.GetTag(__instance.m_damages);
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name((MonoBehaviour)(object)__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(CreatureSpawner), "Awake")]
	[HarmonyPriority(0)]
	public class CreatureSpawner_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (CreatureSpawner item in SceneObjects.FindLoaded<CreatureSpawner>())
			{
				Postfix(item);
			}
		}

		private static bool IsEnabled(CreatureSpawner obj)
		{
			if (Settings.IsDisabled((obj.m_respawnTimeMinuts > 0f) ? "SpawnPointRespawning" : "SpawnPointOneTime"))
			{
				return false;
			}
			return !LocationUtils.IsIn(Settings.ExcludedCreatureSpawners, ((Object)obj).name);
		}

		[HarmonyPriority(0)]
		private static void Postfix(CreatureSpawner __instance)
		{
			if (IsEnabled(__instance))
			{
				string tag = ((__instance.m_respawnTimeMinuts > 0f) ? "SpawnPointRespawning" : "SpawnPointOneTime");
				if (!Draw.HasVisual((MonoBehaviour)(object)__instance, tag))
				{
					Text.AddText(Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)__instance), Translate.Name(__instance));
				}
			}
		}
	}
	[HarmonyPatch(typeof(TimedDestruction), "Awake")]
	[HarmonyPriority(0)]
	public class EventZone_Ray
	{
		public static void RebuildLoaded()
		{
			foreach (TimedDestruction item in SceneObjects.FindLoaded<TimedDestruction>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(TimedDestruction __instance)
		{
			if (!Settings.IsDisabled("EventZone"))
			{
				EventZone component = ((Component)__instance).GetComponent<EventZone>();
				if (Object.op_Implicit((Object)(object)component) && !Draw.HasVisual((MonoBehaviour)(object)component, "EventZone"))
				{
					GameObject obj = Draw.DrawMarkerLine("EventZone", (MonoBehaviour)(object)component);
					SphereCollider component2 = ((Component)component).GetComponent<SphereCollider>();
					float radius = ((component2 != null) ? component2.radius : 0f);
					GameObject obj2 = Draw.DrawSphere("EventZone", (MonoBehaviour)(object)component, radius);
					float timeout = __instance.m_timeout;
					string text = "Event: " + Format.String(component.m_event) + "\n" + Text.Radius(radius) + "\nDuration: " + Format.Int(timeout) + " seconds";
					Text.AddText(obj, text);
					Text.AddText(obj2, text);
				}
			}
		}
	}
	[HarmonyPatch(typeof(OfferingBowl), "Awake")]
	[HarmonyPriority(0)]
	public class OfferingBowl_Awake
	{
		public static void RebuildLoaded()
		{
			foreach (OfferingBowl item in SceneObjects.FindLoaded<OfferingBowl>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(OfferingBowl __instance)
		{
			if (!Settings.IsDisabled("AltarRay") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "AltarRay"))
			{
				Text.AddText(Draw.DrawMarkerLine("AltarRay", (MonoBehaviour)(object)__instance));
			}
			if (!Settings.IsDisabled("AltarItemStandRange") && __instance.m_useItemStands && !Draw.HasVisual((MonoBehaviour)(object)__instance, "AltarItemStandRange"))
			{
				Draw.DrawSphere("AltarItemStandRange", (MonoBehaviour)(object)__instance, __instance.m_itemstandMaxRange);
			}
			if (!Settings.IsDisabled("AltarSpawnRadius") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "AltarSpawnRadius"))
			{
				Draw.DrawSphere("AltarSpawnRadius", (MonoBehaviour)(object)__instance, __instance.m_spawnBossMaxDistance);
			}
		}
	}
	[HarmonyPatch(typeof(SpawnArea), "Awake")]
	[HarmonyPriority(0)]
	public class SpawnArea_Awake
	{
		public static void RebuildLoaded()
		{
			foreach (SpawnArea item in SceneObjects.FindLoaded<SpawnArea>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(SpawnArea __instance)
		{
			if (!Settings.IsDisabled("SpawnerRay") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "SpawnerRay"))
			{
				Text.AddText(Draw.DrawMarkerLine("SpawnerRay", (MonoBehaviour)(object)__instance));
			}
			if (!Settings.IsDisabled("SpawnerTriggerRange") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "SpawnerTriggerRange"))
			{
				Draw.DrawSphere("SpawnerTriggerRange", (MonoBehaviour)(object)__instance, __instance.m_triggerDistance);
			}
			if (!Settings.IsDisabled("SpawnerNearRange") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "SpawnerNearRange"))
			{
				Draw.DrawSphere("SpawnerNearRange", (MonoBehaviour)(object)__instance, __instance.m_nearRadius);
			}
			if (!Settings.IsDisabled("SpawnerSpawnRange") && !Draw.HasVisual((MonoBehaviour)(object)__instance, "SpawnerSpawnRange"))
			{
				Draw.DrawSphere("SpawnerSpawnRange", (MonoBehaviour)(object)__instance, __instance.m_spawnRadius);
			}
		}
	}
	[HarmonyPatch(typeof(SpawnSystem), "Awake")]
	[HarmonyPriority(0)]
	public class SpawnSystem_Awake
	{
		public static void RebuildLoaded()
		{
			foreach (SpawnSystem item in SceneObjects.FindLoaded<SpawnSystem>())
			{
				if (Object.op_Implicit((Object)(object)item.m_heightmap))
				{
					ClearSpawnSystemVisuals(item);
					Postfix(item);
				}
			}
		}

		private static bool IsSpawnSystemTag(string tag)
		{
			if (!(tag == "RandomEventSystem") && !tag.StartsWith("SpawnZone"))
			{
				return tag.StartsWith("ZoneCorner");
			}
			return true;
		}

		private static void ClearSpawnSystemVisuals(SpawnSystem obj)
		{
			global::Visualization.Visualization[] componentsInChildren = ((Component)obj).GetComponentsInChildren<global::Visualization.Visualization>(true);
			foreach (global::Visualization.Visualization visualization in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)visualization) && IsSpawnSystemTag(visualization.Tag))
				{
					Object.Destroy((Object)(object)((Component)visualization).gameObject);
				}
			}
		}

		private static void DrawBiomes(SpawnSystem obj)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_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_009e: 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)
			//IL_00b6: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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)
			Heightmap heightmap = obj.m_heightmap;
			float num = ZoneSystem.instance.m_zoneSize * 0.5f;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num, 0f, num);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(0f - num, 0f, num);
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(num, 0f, 0f - num);
			Vector3 val4 = default(Vector3);
			((Vector3)(ref val4))..ctor(0f - num, 0f, 0f - num);
			Biome biome = heightmap.GetBiome(((Component)obj).transform.position + val, 0.02f, false);
			Biome biome2 = heightmap.GetBiome(((Component)obj).transform.position + val2, 0.02f, false);
			Biome biome3 = heightmap.GetBiome(((Component)obj).transform.position + val3, 0.02f, false);
			Biome biome4 = heightmap.GetBiome(((Component)obj).transform.position + val4, 0.02f, false);
			DrawMarker((MonoBehaviour)(object)obj, val, biome);
			DrawMarker((MonoBehaviour)(object)obj, val2, biome2);
			DrawMarker((MonoBehaviour)(object)obj, val3, biome3);
			DrawMarker((MonoBehaviour)(object)obj, val4, biome4);
		}

		private static void DrawMarker(MonoBehaviour parent, Vector3 position, Biome biome)
		{
			//IL_0000: 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_001d: 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)
			string zoneCorner = Tag.GetZoneCorner(biome);
			if (!Settings.IsDisabled(zoneCorner))
			{
				Draw.DrawMarkerLine(zoneCorner, parent, position).AddComponent<BiomeText>().biome = biome;
			}
		}

		private static int GetTotalAmountOfSpawnSystems(SpawnSystem instance, Heightmap heightmap)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (SpawnSystemList spawnList in instance.m_spawnLists)
			{
				foreach (SpawnData spawner in spawnList.m_spawners)
				{
					if (spawner.m_enabled && heightmap.HaveBiome(spawner.m_biome) && (spawner.m_spawnAtDay || spawner.m_spawnAtNight))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static bool IsEnabled(SpawnData instance)
		{
			return !LocationUtils.IsIn(Settings.ExcludedSpawnZones, Utils.GetPrefabName(instance.m_prefab));
		}

		private static void DrawSpawnSystems(SpawnSystem obj)
		{
			//IL_004b: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			SpawnSystem obj2 = obj;
			Heightmap heightmap = obj2.m_heightmap;
			int totalAmountOfSpawnSystems = GetTotalAmountOfSpawnSystems(obj2, heightmap);
			int counter = -totalAmountOfSpawnSystems / 2;
			Biome biome = heightmap.GetBiome(((Component)obj2).transform.position, 0.02f, false);
			string tag = Tag.GetSpawnZone(biome);
			if (Settings.IsDisabled(tag))
			{
				return;
			}
			obj2.m_spawnLists.ForEach(delegate(SpawnSystemList list)
			{
				int num = 0;
				list.m_spawners.ForEach(delegate(SpawnData spawnData)
				{
					//IL_0024: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
					num++;
					if (spawnData.m_enabled && heightmap.HaveBiome(spawnData.m_biome) && (spawnData.m_spawnAtDay || spawnData.m_spawnAtNight) && IsEnabled(spawnData))
					{
						int stableHashCode = StringExtensionMethods.GetStableHashCode("b_" + ((Object)spawnData.m_prefab).name + num);
						Vector3 start = default(Vector3);
						((Vector3)(ref start))..ctor((float)counter * 3f * (float)Settings.configSpawnZoneRayWidth.Value / 100f, 0f, 0f);
						SpawnSystemText spawnSystemText = Draw.DrawMarkerLine(tag, (MonoBehaviour)(object)obj2, start).AddComponent<SpawnSystemText>();
						spawnSystemText.spawnSystem = obj2;
						spawnSystemText.spawnData = spawnData;
						spawnSystemText.stableHashCode = stableHashCode;
						int num2 = counter;
						counter = num2 + 1;
					}
				});
			});
		}

		private static void DrawRandEventSystem(SpawnSystem instance)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.IsDisabled("RandomEventSystem") && !Draw.HasVisual((MonoBehaviour)(object)instance, "RandomEventSystem"))
			{
				Draw.DrawMarkerLine("RandomEventSystem", (MonoBehaviour)(object)instance, new Vector3(0f, 0f, 5f)).AddComponent<RandEventSystemText>().spawnSystem = instance;
			}
		}

		private static void Postfix(SpawnSystem __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance.m_heightmap))
			{
				DrawBiomes(__instance);
				DrawSpawnSystems(__instance);
				DrawRandEventSystem(__instance);
			}
		}
	}
	public class RandEventSystemText : MonoBehaviour, Hoverable
	{
		public SpawnSystem? spawnSystem;

		public string GetHoverText()
		{
			if (!((Object)(object)spawnSystem != (Object)null))
			{
				return "";
			}
			return Texts.GetRandomEvent(spawnSystem);
		}

		public string GetHoverName()
		{
			return "Random events";
		}
	}
	public class SpawnSystemText : MonoBehaviour, Hoverable
	{
		public SpawnSystem? spawnSystem;

		public SpawnData? spawnData;

		public int stableHashCode;

		public string GetHoverText()
		{
			if (!((Object)(object)spawnSystem == (Object)null) && spawnData != null)
			{
				return Texts.Get(spawnSystem, spawnData, stableHashCode);
			}
			return "";
		}

		public string GetHoverName()
		{
			if (spawnData != null)
			{
				if (spawnData.m_name.Length <= 0)
				{
					return ((Object)spawnData.m_prefab).name;
				}
				return spawnData.m_name;
			}
			return "";
		}
	}
	public class BiomeText : MonoBehaviour, Hoverable
	{
		public Biome biome;

		public string GetHoverText()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Texts.Get(biome);
		}

		public string GetHoverName()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Translate.Name(biome);
		}
	}
	public static class SupportUtils
	{
		public static void UpdateVisibility()
		{
			WearNTear.s_allInstances.Where((WearNTear item) => item.m_supports).ToList().ForEach(delegate(WearNTear item)
			{
				if (VisualEnabled(item))
				{
					item.Highlight();
				}
				else
				{
					item.ResetHighlight();
				}
			});
		}

		public static bool Enabled(WearNTear obj)
		{
			if (!Object.op_Implicit((Object)(object)obj))
			{
				return false;
			}
			Piece component = ((Component)obj).GetComponent<Piece>();
			if (obj.m_supports)
			{
				if (Object.op_Implicit((Object)(object)component))
				{
					return !component.m_waterPiece;
				}
				return true;
			}
			return false;
		}

		public static bool VisualEnabled(WearNTear obj)
		{
			if (Visibility.IsTag("StructureSupport"))
			{
				return Enabled(obj);
			}
			return false;
		}

		public static void Update(WearNTear obj)
		{
			if (VisualEnabled(obj))
			{
				obj.Highlight();
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Awake")]
	[HarmonyPriority(0)]
	public class WearNTear_AutoHighlight
	{
		private static void Postfix(WearNTear __instance)
		{
			if (SupportUtils.VisualEnabled(__instance))
			{
				__instance.Highlight();
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Highlight")]
	public class WearNTear_Highlight
	{
		private static void Postfix(WearNTear __instance)
		{
			if (SupportUtils.VisualEnabled(__instance))
			{
				((MonoBehaviour)__instance).CancelInvoke("ResetHighlight");
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "UpdateSupport")]
	public class WearNTear_Update
	{
		private static void Postfix(WearNTear __instance)
		{
			SupportUtils.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(EffectArea), "Awake")]
	[HarmonyPriority(0)]
	public class EffectArea_Visual
	{
		public static void RebuildLoaded()
		{
			foreach (EffectArea item in SceneObjects.FindLoaded<EffectArea>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(EffectArea __instance)
		{
			Visual.Draw(__instance);
		}
	}
	[HarmonyPatch(typeof(PrivateArea), "Awake")]
	[HarmonyPriority(0)]
	public class PrivateArea_Visual
	{
		public static void RebuildLoaded()
		{
			foreach (PrivateArea item in SceneObjects.FindLoaded<PrivateArea>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(PrivateArea __instance)
		{
			Visual.Draw(__instance);
		}
	}
	[HarmonyPatch(typeof(Piece), "Awake")]
	[HarmonyPriority(0)]
	public class Piece_Visual
	{
		public static void RebuildLoaded()
		{
			foreach (Piece item in SceneObjects.FindLoaded<Piece>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Piece __instance)
		{
			Visual.Draw(__instance);
			Visual.Draw(((Component)__instance).GetComponent<CraftingStation>());
			Visual.Draw(((Component)__instance).GetComponent<Container>());
			Visual.Draw(((Component)__instance).GetComponent<Fermenter>());
			Visual.Draw(((Component)__instance).GetComponent<Bed>());
			Visual.Draw(((Component)__instance).GetComponent<Fireplace>());
			Visual.Draw(((Component)__instance).GetComponent<Beehive>());
			Visual.Draw(((Component)__instance).GetComponent<Windmill>());
		}
	}
	[HarmonyPatch(typeof(Smoke), "Awake")]
	[HarmonyPriority(0)]
	public class Smoke_Visual
	{
		public static void RebuildLoaded()
		{
			foreach (Smoke item in SceneObjects.FindLoaded<Smoke>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Smoke __instance)
		{
			Visual.Draw(__instance);
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "Start")]
	public class CraftingStation_Updater
	{
		private static void Postfix(CraftingStation __instance)
		{
			((MonoBehaviour)__instance).InvokeRepeating("GetHoverName", 2f, 2f);
		}
	}
	[HarmonyPatch(typeof(CraftingStation), "GetHoverName")]
	public class CraftingStation_Visual_Update
	{
		private static void Postfix(CraftingStation __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Fermenter), "SlowUpdate")]
	public class Fermenter_Visual_Update
	{
		private static void Postfix(Fermenter __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Beehive), "Awake")]
	[HarmonyPriority(0)]
	public class Beehive_Updater
	{
		private static void Postfix(Beehive __instance)
		{
			((MonoBehaviour)__instance).InvokeRepeating("GetHoverName", 2f, 2f);
		}
	}
	[HarmonyPatch(typeof(Beehive), "GetHoverName")]
	public class Beehive_Visual_Update
	{
		private static void Postfix(Beehive __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Fireplace), "UpdateFireplace")]
	public class Fireplace_Visual_Update
	{
		private static void Postfix(Fireplace __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Bed), "Awake")]
	[HarmonyPriority(0)]
	public class Bed_Updater
	{
		private static void Postfix(Bed __instance)
		{
			((MonoBehaviour)__instance).InvokeRepeating("GetHoverName", 2f, 2f);
		}
	}
	[HarmonyPatch(typeof(Bed), "GetHoverName")]
	public class Bed_Visual_Update
	{
		private static void Postfix(Bed __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Windmill), "CheckCover")]
	public class Windmill_Visual_Update
	{
		private static void Postfix(Windmill __instance)
		{
			Visual.Update(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "Awake")]
	[HarmonyPriority(0)]
	public class Player_Cover
	{
		public static void RebuildLoaded()
		{
			foreach (Player item in SceneObjects.FindLoaded<Player>())
			{
				Postfix(item);
			}
		}

		private static void Postfix(Player __instance)
		{
			Visual.DrawCover(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "LateUpdate")]
	public class Player_Cover_Update
	{
		private static void Postfix(Player __instance)
		{
			Visual.Update(__instance);
		}
	}
}