using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RavenwoodCrystals")]
[assembly: AssemblyDescription("Ravenwood Crystals Mod")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Ravenwood")]
[assembly: AssemblyProduct("RavenwoodCrystals")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8ad799d2-7e36-4098-b363-92c0f7924b6a")]
[assembly: AssemblyFileVersion("1.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Ravenwood.Crystals;

public class CrystalBreakVisual : MonoBehaviour
{
	private List<GameObject> parts = new List<GameObject>();

	private int currentIndex = 0;

	private float lastHealth;

	private WearNTear wear;

	private void Awake()
	{
		Transform[] componentsInChildren = ((Component)this).GetComponentsInChildren<Transform>(true);
		foreach (Transform val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)(object)((Component)this).transform)
			{
				parts.Add(((Component)val).gameObject);
			}
		}
		for (int j = 0; j < parts.Count; j++)
		{
			int index = Random.Range(j, parts.Count);
			GameObject value = parts[j];
			parts[j] = parts[index];
			parts[index] = value;
		}
		wear = ((Component)this).GetComponent<WearNTear>();
		if ((Object)(object)wear != (Object)null)
		{
			lastHealth = wear.m_health;
		}
	}

	private void Update()
	{
		if ((Object)(object)wear == (Object)null)
		{
			wear = ((Component)this).GetComponent<WearNTear>();
		}
		else if (wear.m_health < lastHealth)
		{
			RemoveOneChunk();
			lastHealth = wear.m_health;
		}
	}

	private void RemoveOneChunk()
	{
		if (currentIndex < parts.Count)
		{
			if ((Object)(object)parts[currentIndex] != (Object)null)
			{
				parts[currentIndex].SetActive(false);
			}
			currentIndex++;
		}
	}
}
public static class CrystalConfigFile
{
	public sealed class CrystalDefinition
	{
		public string PrefabName;

		public string DefaultBiomes;

		public float DefaultSpawnChance;

		public int DefaultMinPerZone;

		public int DefaultMaxPerZone;

		public float DefaultHealth;

		public string DefaultDropItem;

		public int DefaultDropMin;

		public int DefaultDropMax;

		public bool IsRavenCrystal;

		public ConfigEntry<bool> Enabled;

		public ConfigEntry<string> Biomes;

		public ConfigEntry<float> SpawnChance;

		public ConfigEntry<int> MinPerZone;

		public ConfigEntry<int> MaxPerZone;

		public ConfigEntry<float> Health;

		public ConfigEntry<string> DropItem;

		public ConfigEntry<int> DropMin;

		public ConfigEntry<int> DropMax;

		public ConfigEntry<string>[] RavenDropItems = new ConfigEntry<string>[4];

		public ConfigEntry<int>[] RavenDropMins = new ConfigEntry<int>[4];

		public ConfigEntry<int>[] RavenDropMaxs = new ConfigEntry<int>[4];
	}

	private const int RavenDropSlotCount = 4;

	private static readonly List<CrystalDefinition> CrystalDefinitions = new List<CrystalDefinition>();

	private static ConfigEntry<int> ResetEveryDays;

	private static ConfigEntry<float> ResetHour;

	private static ConfigEntry<int> ZoneLoadRadius;

	public static IReadOnlyList<CrystalDefinition> Definitions => CrystalDefinitions;

	public static int ResetEveryDaysValue => (ResetEveryDays != null) ? Mathf.Max(1, ResetEveryDays.Value) : 3;

	public static float ResetHourValue => (ResetHour != null) ? Mathf.Clamp(ResetHour.Value, 0f, 23.99f) : 6f;

	public static int ZoneLoadRadiusValue => (ZoneLoadRadius == null) ? 1 : Mathf.Max(0, ZoneLoadRadius.Value);

	public static void Initialize(ConfigFile config)
	{
		if (config != null)
		{
			ResetEveryDays = config.Bind<int>("Crystal.Reset", "ResetEveryDays", 48, "How many in-game days must pass before all crystal spawn keys are reset.");
			ResetHour = config.Bind<float>("Crystal.Reset", "ResetHour", 6f, "At which in-game hour the crystal reset is allowed to happen.");
			ZoneLoadRadius = config.Bind<int>("Crystal.General", "ZoneLoadRadius", 1, "How many zones around a newly loaded zone should be processed once for crystal spawning.");
			BuildCrystalDefinitions();
			BindCrystalConfigs(config);
		}
	}

	public static void BuildCrystalDefinitions()
	{
		if (CrystalDefinitions.Count <= 0)
		{
			CrystalDefinitions.Add(CreateCrystalDefinition("Poison_Crystal_Small", "BlackForest,Swamp", 0.24f, 0, 1, 100f, "Essence_Poison", 2, 2, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Poison_Crystal", "BlackForest,Swamp", 0.12f, 0, 1, 200f, "Essence_Poison", 5, 5, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Poison_Crystal_Large", "BlackForest,Swamp", 0.08f, 0, 1, 300f, "Essence_Poison", 10, 10, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Frost_Crystal_Small", "Mountain,DeepNorth", 0.24f, 0, 1, 100f, "Essence_Frost", 2, 2, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Frost_Crystal", "Mountain,DeepNorth", 0.12f, 0, 1, 200f, "Essence_Frost", 5, 5, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Frost_Crystal_Large", "Mountain,DeepNorth", 0.08f, 0, 1, 300f, "Essence_Frost", 10, 10, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Fire_Crystal_Small", "Plains,AshLands", 0.24f, 0, 1, 100f, "Essence_Fire", 2, 2, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Fire_Crystal", "Plains,AshLands", 0.12f, 0, 1, 200f, "Essence_Fire", 5, 5, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Fire_Crystal_Large", "Plains,AshLands", 0.08f, 0, 1, 300f, "Essence_Fire", 10, 10, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Lightning_Crystal_Small", "Meadows,Mistlands", 0.24f, 0, 1, 100f, "Essence_Lightning", 2, 2, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Lightning_Crystal", "Meadows,Mistlands", 0.12f, 0, 1, 200f, "Essence_Lightning", 5, 5, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Lightning_Crystal_Large", "Meadows,Mistlands", 0.08f, 0, 1, 300f, "Essence_Lightning", 10, 10, isRavenCrystal: false));
			CrystalDefinitions.Add(CreateCrystalDefinition("Raven_Crystal_Small", "Mistlands,AshLands,DeepNorth,Ocean", 0.05f, 0, 1, 100f, string.Empty, 2, 2, isRavenCrystal: true));
			CrystalDefinitions.Add(CreateCrystalDefinition("Raven_Crystal", "Mistlands,AshLands,DeepNorth,Ocean", 0.03f, 0, 1, 200f, string.Empty, 3, 3, isRavenCrystal: true));
			CrystalDefinitions.Add(CreateCrystalDefinition("Raven_Crystal_Large", "Mistlands,AshLands,DeepNorth,Ocean", 0.01f, 0, 1, 300f, string.Empty, 5, 5, isRavenCrystal: true));
		}
	}

	private static CrystalDefinition CreateCrystalDefinition(string prefabName, string defaultBiomes, float defaultSpawnChance, int defaultMinPerZone, int defaultMaxPerZone, float defaultHealth, string defaultDropItem, int defaultDropMin, int defaultDropMax, bool isRavenCrystal)
	{
		CrystalDefinition crystalDefinition = new CrystalDefinition();
		crystalDefinition.PrefabName = prefabName;
		crystalDefinition.DefaultBiomes = defaultBiomes;
		crystalDefinition.DefaultSpawnChance = defaultSpawnChance;
		crystalDefinition.DefaultMinPerZone = defaultMinPerZone;
		crystalDefinition.DefaultMaxPerZone = defaultMaxPerZone;
		crystalDefinition.DefaultHealth = defaultHealth;
		crystalDefinition.DefaultDropItem = defaultDropItem;
		crystalDefinition.DefaultDropMin = defaultDropMin;
		crystalDefinition.DefaultDropMax = defaultDropMax;
		crystalDefinition.IsRavenCrystal = isRavenCrystal;
		return crystalDefinition;
	}

	private static void BindCrystalConfigs(ConfigFile config)
	{
		for (int i = 0; i < CrystalDefinitions.Count; i++)
		{
			CrystalDefinition crystalDefinition = CrystalDefinitions[i];
			string text = "Crystal." + crystalDefinition.PrefabName;
			crystalDefinition.Enabled = config.Bind<bool>(text, "Enabled", true, "Enable or disable spawning for " + crystalDefinition.PrefabName + ".");
			crystalDefinition.Biomes = config.Bind<string>(text, "Biomes", crystalDefinition.DefaultBiomes, "Comma-separated biome list for " + crystalDefinition.PrefabName + ".");
			crystalDefinition.SpawnChance = config.Bind<float>(text, "SpawnChance", crystalDefinition.DefaultSpawnChance, "Chance for " + crystalDefinition.PrefabName + " to exist when a valid zone is first processed for the current reset cycle.");
			crystalDefinition.MinPerZone = config.Bind<int>(text, "MinPerZone", crystalDefinition.DefaultMinPerZone, "Minimum amount of " + crystalDefinition.PrefabName + " to spawn in a valid zone.");
			crystalDefinition.MaxPerZone = config.Bind<int>(text, "MaxPerZone", crystalDefinition.DefaultMaxPerZone, "Maximum amount of " + crystalDefinition.PrefabName + " to spawn in a valid zone.");
			crystalDefinition.Health = config.Bind<float>(text, "Health", crystalDefinition.DefaultHealth, "Health value applied to " + crystalDefinition.PrefabName + ".");
			if (!crystalDefinition.IsRavenCrystal)
			{
				crystalDefinition.DropItem = config.Bind<string>(text, "DropItem", crystalDefinition.DefaultDropItem, "Drop item prefab for " + crystalDefinition.PrefabName + ".");
				crystalDefinition.DropMin = config.Bind<int>(text, "DropMin", crystalDefinition.DefaultDropMin, "Minimum drop amount for " + crystalDefinition.PrefabName + ".");
				crystalDefinition.DropMax = config.Bind<int>(text, "DropMax", crystalDefinition.DefaultDropMax, "Maximum drop amount for " + crystalDefinition.PrefabName + ".");
				continue;
			}
			for (int j = 0; j < 4; j++)
			{
				string text2 = string.Empty;
				if (j == 0)
				{
					text2 = "Essence_Poison";
				}
				if (j == 1)
				{
					text2 = "Essence_Frost";
				}
				if (j == 2)
				{
					text2 = "Essence_Fire";
				}
				if (j == 3)
				{
					text2 = "Essence_Lightning";
				}
				crystalDefinition.RavenDropItems[j] = config.Bind<string>(text, "Drop" + (j + 1) + "Item", text2, "Drop item prefab for Raven drop slot " + (j + 1) + " on " + crystalDefinition.PrefabName + ". Leave blank to disable the slot.");
				crystalDefinition.RavenDropMins[j] = config.Bind<int>(text, "Drop" + (j + 1) + "Min", crystalDefinition.DefaultDropMin, "Minimum drop amount for Raven drop slot " + (j + 1) + " on " + crystalDefinition.PrefabName + ".");
				crystalDefinition.RavenDropMaxs[j] = config.Bind<int>(text, "Drop" + (j + 1) + "Max", crystalDefinition.DefaultDropMax, "Maximum drop amount for Raven drop slot " + (j + 1) + " on " + crystalDefinition.PrefabName + ".");
			}
		}
	}

	public static List<CrystalDropEntry> BuildDropEntries(CrystalDefinition crystal)
	{
		List<CrystalDropEntry> list = new List<CrystalDropEntry>();
		if (crystal == null)
		{
			return list;
		}
		if (crystal.IsRavenCrystal)
		{
			for (int i = 0; i < 4; i++)
			{
				string text = ((crystal.RavenDropItems[i] != null) ? crystal.RavenDropItems[i].Value : string.Empty);
				if (!string.IsNullOrWhiteSpace(text))
				{
					int num = ((crystal.RavenDropMins[i] != null) ? crystal.RavenDropMins[i].Value : crystal.DefaultDropMin);
					int num2 = ((crystal.RavenDropMaxs[i] != null) ? crystal.RavenDropMaxs[i].Value : crystal.DefaultDropMax);
					num = Mathf.Max(0, num);
					num2 = Mathf.Max(num, num2);
					list.Add(new CrystalDropEntry(text, num, num2));
				}
			}
			return list;
		}
		int num3 = ((crystal.DropMin != null) ? crystal.DropMin.Value : crystal.DefaultDropMin);
		int num4 = ((crystal.DropMax != null) ? crystal.DropMax.Value : crystal.DefaultDropMax);
		num3 = Mathf.Max(0, num3);
		num4 = Mathf.Max(num3, num4);
		string text2 = ((crystal.DropItem != null) ? crystal.DropItem.Value : crystal.DefaultDropItem);
		if (!string.IsNullOrWhiteSpace(text2))
		{
			list.Add(new CrystalDropEntry(text2, num3, num4));
		}
		return list;
	}

	public static CrystalDefinition FindCrystalDefinition(string prefabName)
	{
		for (int i = 0; i < CrystalDefinitions.Count; i++)
		{
			CrystalDefinition crystalDefinition = CrystalDefinitions[i];
			if (crystalDefinition != null && string.Equals(crystalDefinition.PrefabName, prefabName, StringComparison.Ordinal))
			{
				return crystalDefinition;
			}
		}
		return null;
	}
}
public sealed class CrystalDropEntry
{
	public string ItemName;

	public int Min;

	public int Max;

	public CrystalDropEntry(string itemName, int min, int max)
	{
		ItemName = itemName;
		Min = min;
		Max = max;
	}
}
public class CrystalHoverText : MonoBehaviour, Hoverable
{
	private string hoverName;

	private void Awake()
	{
		EnsureHoverName();
	}

	public void Configure(string prefabName)
	{
		hoverName = BuildHoverName(prefabName);
	}

	public string GetHoverText()
	{
		EnsureHoverName();
		return string.IsNullOrWhiteSpace(hoverName) ? "Crystal" : hoverName;
	}

	public string GetHoverName()
	{
		EnsureHoverName();
		return string.IsNullOrWhiteSpace(hoverName) ? "Crystal" : hoverName;
	}

	private void EnsureHoverName()
	{
		if (string.IsNullOrWhiteSpace(hoverName))
		{
			string text = (((Object)(object)((Component)this).gameObject != (Object)null) ? ((Object)((Component)this).gameObject).name : string.Empty);
			if (!string.IsNullOrWhiteSpace(text) && text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).Trim();
			}
			hoverName = BuildHoverName(text);
		}
	}

	private static string BuildHoverName(string prefabName)
	{
		if (string.IsNullOrWhiteSpace(prefabName))
		{
			return "Crystal";
		}
		string[] array = prefabName.Split(new char[1] { '_' }, StringSplitOptions.RemoveEmptyEntries);
		if (array.Length == 0)
		{
			return "Crystal";
		}
		string text = "Medium";
		List<string> list = new List<string>();
		foreach (string text2 in array)
		{
			if (string.Equals(text2, "Small", StringComparison.OrdinalIgnoreCase))
			{
				text = "Small";
			}
			else if (string.Equals(text2, "Large", StringComparison.OrdinalIgnoreCase))
			{
				text = "Large";
			}
			else if (!string.Equals(text2, "Crystal", StringComparison.OrdinalIgnoreCase))
			{
				list.Add(UppercaseFirst(text2));
			}
		}
		if (list.Count == 0)
		{
			return text + " Crystal";
		}
		return text + " " + string.Join(" ", list.ToArray()) + " Crystal";
	}

	private static string UppercaseFirst(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		if (value.Length == 1)
		{
			return value.ToUpperInvariant();
		}
		return char.ToUpperInvariant(value[0]) + value.Substring(1).ToLowerInvariant();
	}
}
public sealed class CrystalManager : MonoBehaviour
{
	private sealed class RaycastHitDistanceComparer : IComparer<RaycastHit>
	{
		public static readonly RaycastHitDistanceComparer Instance = new RaycastHitDistanceComparer();

		public int Compare(RaycastHit left, RaycastHit right)
		{
			return ((RaycastHit)(ref left)).distance.CompareTo(((RaycastHit)(ref right)).distance);
		}
	}

	private struct ZoneCoord : IEquatable<ZoneCoord>
	{
		public int X;

		public int Y;

		public ZoneCoord(int x, int y)
		{
			X = x;
			Y = y;
		}

		public bool Equals(ZoneCoord other)
		{
			return X == other.X && Y == other.Y;
		}

		public override bool Equals(object obj)
		{
			if (!(obj is ZoneCoord))
			{
				return false;
			}
			return Equals((ZoneCoord)obj);
		}

		public override int GetHashCode()
		{
			return (X * 397) ^ Y;
		}
	}

	private const float ZoneSize = 64f;

	private const float PlayerZoneCheckIntervalSeconds = 1f;

	private const float ResetCheckIntervalSeconds = 2f;

	private const int SpawnPointAttemptsPerCrystal = 25;

	private const int GroundPointAttempts = 40;

	private const float GroundProbeStartHeight = 2000f;

	private const float GroundProbeDistance = 4000f;

	private const float TerrainSpawnOffset = 0.05f;

	private static CrystalManager instance;

	private static AssetBundle assetBundle;

	private static bool prefabsRegistered;

	private static readonly Dictionary<string, GameObject> RegisteredCrystalPrefabs = new Dictionary<string, GameObject>();

	private static readonly HashSet<string> MissingPrefabWarnings = new HashSet<string>();

	private static readonly HashSet<string> MissingBiomeWarnings = new HashSet<string>();

	private static readonly Dictionary<string, HashSet<CrystalRuntimeState>> ActiveManagedCrystals = new Dictionary<string, HashSet<CrystalRuntimeState>>();

	private readonly Dictionary<long, ZoneCoord> lastPlayerZones = new Dictionary<long, ZoneCoord>();

	private float nextPlayerZoneCheckTime;

	private float nextResetCheckTime;

	public static void Initialize(BaseUnityPlugin plugin, AssetBundle bundle, ConfigFile config)
	{
		assetBundle = bundle;
		CrystalConfigFile.Initialize(config);
		CrystalRespawnState.Initialize();
		if ((Object)(object)instance == (Object)null)
		{
			instance = ((Component)plugin).GetComponent<CrystalManager>();
			if ((Object)(object)instance == (Object)null)
			{
				instance = ((Component)plugin).gameObject.AddComponent<CrystalManager>();
			}
		}
	}

	public static void RegisterCrystalPrefabs(AssetBundle bundle)
	{
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Expected O, but got Unknown
		if (prefabsRegistered || (Object)(object)bundle == (Object)null)
		{
			return;
		}
		CrystalConfigFile.BuildCrystalDefinitions();
		int num = 0;
		int num2 = 0;
		IReadOnlyList<CrystalConfigFile.CrystalDefinition> definitions = CrystalConfigFile.Definitions;
		for (int i = 0; i < definitions.Count; i++)
		{
			CrystalConfigFile.CrystalDefinition crystalDefinition = definitions[i];
			GameObject val = bundle.LoadAsset<GameObject>(crystalDefinition.PrefabName);
			if ((Object)(object)val == (Object)null)
			{
				num2++;
				Debug.LogWarning((object)("Crystal prefab missing from asset bundle: " + crystalDefinition.PrefabName));
				continue;
			}
			PrepareCrystalPrefab(val, crystalDefinition);
			PrefabManager.Instance.AddPrefab(new CustomPrefab(val, true));
			RegisteredCrystalPrefabs[crystalDefinition.PrefabName] = val;
			num++;
		}
		prefabsRegistered = true;
		Debug.Log((object)("Crystal prefab registration complete. Registered: " + num + ", Missing: " + num2));
	}

	private static void PrepareCrystalPrefab(GameObject prefab, CrystalConfigFile.CrystalDefinition crystal)
	{
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: 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)
		//IL_011c: 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_01c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d4: Expected O, but got Unknown
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Expected O, but got Unknown
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Expected O, but got Unknown
		if ((Object)(object)prefab == (Object)null || crystal == null)
		{
			return;
		}
		((Object)prefab).name = crystal.PrefabName;
		RemoveItemDrops(prefab);
		ZNetView val = prefab.GetComponent<ZNetView>();
		if ((Object)(object)val == (Object)null)
		{
			val = prefab.AddComponent<ZNetView>();
		}
		val.m_persistent = true;
		val.m_syncInitialScale = true;
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<ZSyncTransform>()))
		{
			prefab.AddComponent<ZSyncTransform>();
		}
		if ((Object)(object)prefab.GetComponentInChildren<Collider>(true) == (Object)null)
		{
			BoxCollider val2 = prefab.GetComponent<BoxCollider>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = prefab.AddComponent<BoxCollider>();
			}
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren.Length != 0)
			{
				Bounds bounds = componentsInChildren[0].bounds;
				for (int i = 1; i < componentsInChildren.Length; i++)
				{
					((Bounds)(ref bounds)).Encapsulate(componentsInChildren[i].bounds);
				}
				val2.center = prefab.transform.InverseTransformPoint(((Bounds)(ref bounds)).center);
				val2.size = ((Bounds)(ref bounds)).size;
			}
		}
		WearNTear val3 = prefab.GetComponent<WearNTear>();
		if ((Object)(object)val3 == (Object)null)
		{
			val3 = prefab.AddComponent<WearNTear>();
		}
		val3.m_health = ((crystal.Health != null) ? crystal.Health.Value : crystal.DefaultHealth);
		val3.m_noRoofWear = true;
		GameObject val4 = null;
		GameObject val5 = null;
		if ((Object)(object)ZNetScene.instance != (Object)null)
		{
			val4 = ZNetScene.instance.GetPrefab("vfx_destroyed");
			val5 = ZNetScene.instance.GetPrefab("sfx_clay_pot_break");
		}
		List<EffectData> list = new List<EffectData>();
		if ((Object)(object)val4 != (Object)null)
		{
			list.Add(new EffectData
			{
				m_prefab = val4,
				m_enabled = true
			});
		}
		if ((Object)(object)val5 != (Object)null)
		{
			list.Add(new EffectData
			{
				m_prefab = val5,
				m_enabled = true
			});
		}
		EffectList val6 = new EffectList();
		val6.m_effectPrefabs = list.ToArray();
		val3.m_destroyedEffect = val6;
		CrystalRuntimeState crystalRuntimeState = prefab.GetComponent<CrystalRuntimeState>();
		if ((Object)(object)crystalRuntimeState == (Object)null)
		{
			crystalRuntimeState = prefab.AddComponent<CrystalRuntimeState>();
		}
		crystalRuntimeState.Configure(CrystalConfigFile.BuildDropEntries(crystal));
		CrystalHoverText crystalHoverText = prefab.GetComponent<CrystalHoverText>();
		if ((Object)(object)crystalHoverText == (Object)null)
		{
			crystalHoverText = prefab.AddComponent<CrystalHoverText>();
		}
		crystalHoverText.Configure(crystal.PrefabName);
		if (!Object.op_Implicit((Object)(object)prefab.GetComponent<CrystalBreakVisual>()))
		{
			prefab.AddComponent<CrystalBreakVisual>();
		}
	}

	private static void RemoveItemDrops(GameObject root)
	{
		if ((Object)(object)root == (Object)null)
		{
			return;
		}
		ItemDrop[] componentsInChildren = root.GetComponentsInChildren<ItemDrop>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			if ((Object)(object)componentsInChildren[i] != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i], true);
			}
		}
	}

	public static bool TryRestoreExistingCrystalState(CrystalRuntimeState runtime)
	{
		//IL_0081: 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_00e4: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Invalid comparison between Unknown and I4
		//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)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)runtime == (Object)null || (Object)(object)((Component)runtime).gameObject == (Object)null)
		{
			return false;
		}
		CrystalConfigFile.BuildCrystalDefinitions();
		string text = CleanPrefabName(((Object)((Component)runtime).gameObject).name);
		if (string.IsNullOrWhiteSpace(text))
		{
			return false;
		}
		CrystalConfigFile.CrystalDefinition crystalDefinition = CrystalConfigFile.FindCrystalDefinition(text);
		if (crystalDefinition == null)
		{
			return false;
		}
		runtime.Configure(CrystalConfigFile.BuildDropEntries(crystalDefinition));
		ZoneCoord zone = GetZone(((Component)runtime).transform.position);
		Biome val = (Biome)0;
		if (WorldGenerator.instance != null)
		{
			val = WorldGenerator.instance.GetBiome(((Component)runtime).transform.position);
			if ((int)val == 0)
			{
				val = WorldGenerator.instance.GetBiome(GetZoneCenter(zone));
			}
		}
		runtime.ConfigureManagedSpawn(crystalDefinition.PrefabName, zone.X, zone.Y, val);
		return true;
	}

	private static string CleanPrefabName(string prefabName)
	{
		if (string.IsNullOrWhiteSpace(prefabName))
		{
			return string.Empty;
		}
		string text = prefabName.Trim();
		if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
		{
			text = text.Substring(0, text.Length - "(Clone)".Length).Trim();
		}
		return text;
	}

	private static GameObject GetSpawnPrefab(CrystalConfigFile.CrystalDefinition crystal)
	{
		if (crystal == null)
		{
			return null;
		}
		GameObject val = null;
		if ((Object)(object)ZNetScene.instance != (Object)null)
		{
			val = ZNetScene.instance.GetPrefab(crystal.PrefabName);
		}
		if ((Object)(object)val == (Object)null)
		{
			val = PrefabManager.Instance.GetPrefab(crystal.PrefabName);
		}
		if ((Object)(object)val == (Object)null && RegisteredCrystalPrefabs.ContainsKey(crystal.PrefabName))
		{
			val = RegisteredCrystalPrefabs[crystal.PrefabName];
		}
		if ((Object)(object)val == (Object)null && (Object)(object)assetBundle != (Object)null)
		{
			val = assetBundle.LoadAsset<GameObject>(crystal.PrefabName);
		}
		if ((Object)(object)val != (Object)null)
		{
			PrepareCrystalPrefab(val, crystal);
			RegisteredCrystalPrefabs[crystal.PrefabName] = val;
			return val;
		}
		if (!MissingPrefabWarnings.Contains(crystal.PrefabName))
		{
			MissingPrefabWarnings.Add(crystal.PrefabName);
			Debug.LogWarning((object)("Crystal prefab not available yet: " + crystal.PrefabName));
		}
		return null;
	}

	private void Update()
	{
		if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || WorldGenerator.instance == null)
		{
			return;
		}
		if (!prefabsRegistered && (Object)(object)assetBundle != (Object)null)
		{
			RegisterCrystalPrefabs(assetBundle);
		}
		if (Time.time >= nextPlayerZoneCheckTime)
		{
			nextPlayerZoneCheckTime = Time.time + 1f;
			ProcessPlayerEnteredZones();
		}
		if (Time.time >= nextResetCheckTime)
		{
			nextResetCheckTime = Time.time + 2f;
			if (CrystalRespawnState.ShouldRunResetNow())
			{
				CrystalRespawnState.ClearProcessedZonesForCurrentWorld();
				Debug.Log((object)"Crystal reset completed. Saved crystal zone decisions cleared for current world.");
			}
		}
	}

	private void ProcessPlayerEnteredZones()
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		List<Player> allPlayers = Player.GetAllPlayers();
		if (allPlayers == null || allPlayers.Count == 0)
		{
			lastPlayerZones.Clear();
			return;
		}
		HashSet<long> hashSet = new HashSet<long>();
		for (int i = 0; i < allPlayers.Count; i++)
		{
			Player val = allPlayers[i];
			if (!((Object)(object)val == (Object)null))
			{
				long playerKey = GetPlayerKey(val);
				hashSet.Add(playerKey);
				ZoneCoord zone = GetZone(((Component)val).transform.position);
				if (!lastPlayerZones.TryGetValue(playerKey, out var value) || !value.Equals(zone))
				{
					lastPlayerZones[playerKey] = zone;
					ProcessZone(zone);
				}
			}
		}
		List<long> list = new List<long>();
		foreach (KeyValuePair<long, ZoneCoord> lastPlayerZone in lastPlayerZones)
		{
			if (!hashSet.Contains(lastPlayerZone.Key))
			{
				list.Add(lastPlayerZone.Key);
			}
		}
		for (int j = 0; j < list.Count; j++)
		{
			lastPlayerZones.Remove(list[j]);
		}
	}

	private static long GetPlayerKey(Player player)
	{
		if ((Object)(object)player == (Object)null)
		{
			return 0L;
		}
		ZNetView component = ((Component)player).GetComponent<ZNetView>();
		if ((Object)(object)component != (Object)null && component.GetZDO() != null)
		{
			return ((ZDOID)(ref component.GetZDO().m_uid)).ID;
		}
		return ((Object)player).GetInstanceID();
	}

	private void ProcessZone(ZoneCoord zone)
	{
		IReadOnlyList<CrystalConfigFile.CrystalDefinition> definitions = CrystalConfigFile.Definitions;
		for (int i = 0; i < definitions.Count; i++)
		{
			ProcessCrystalInZone(zone, definitions[i]);
		}
	}

	private void ProcessCrystalInZone(ZoneCoord zone, CrystalConfigFile.CrystalDefinition crystal)
	{
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Invalid comparison between Unknown and I4
		//IL_01a1: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		if (crystal == null || crystal.Enabled == null || !crystal.Enabled.Value)
		{
			return;
		}
		string zoneKey = BuildZoneKey(crystal.PrefabName, zone.X, zone.Y);
		if (HasActiveManagedCrystal(zoneKey))
		{
			CrystalRespawnState.MarkZoneProcessed(zoneKey);
		}
		else
		{
			if (CrystalRespawnState.IsZoneProcessed(zoneKey))
			{
				return;
			}
			Biome val = ParseBiomes((crystal.Biomes != null) ? crystal.Biomes.Value : crystal.DefaultBiomes);
			if ((int)val == 0)
			{
				CrystalRespawnState.MarkZoneProcessed(zoneKey);
				return;
			}
			float num = ((crystal.SpawnChance != null) ? crystal.SpawnChance.Value : crystal.DefaultSpawnChance);
			int num2 = ((crystal.MinPerZone != null) ? crystal.MinPerZone.Value : crystal.DefaultMinPerZone);
			int num3 = ((crystal.MaxPerZone != null) ? crystal.MaxPerZone.Value : crystal.DefaultMaxPerZone);
			num2 = Mathf.Max(0, num2);
			num3 = Mathf.Max(num2, num3);
			int num4 = 0;
			if (Random.value <= Mathf.Clamp01(num))
			{
				num4 = Random.Range(num2, num3 + 1);
			}
			if (num4 <= 0)
			{
				CrystalRespawnState.MarkZoneProcessed(zoneKey);
				return;
			}
			GameObject spawnPrefab = GetSpawnPrefab(crystal);
			if ((Object)(object)spawnPrefab == (Object)null)
			{
				return;
			}
			int num5 = 0;
			int num6 = 0;
			int num7 = Mathf.Max(25, num4 * 25);
			while (num5 < num4 && num6 < num7)
			{
				num6++;
				if (!TryFindGroundPoint(zone, out var point))
				{
					continue;
				}
				Biome biomeAtPoint = GetBiomeAtPoint(zone, point);
				if (BiomeMatches(val, biomeAtPoint) && !IsInsidePlayerBaseSuppression(point))
				{
					GameObject val2 = Object.Instantiate<GameObject>(spawnPrefab, point, Quaternion.identity);
					PrepareCrystalPrefab(val2, crystal);
					CrystalRuntimeState component = val2.GetComponent<CrystalRuntimeState>();
					if ((Object)(object)component != (Object)null)
					{
						component.Configure(CrystalConfigFile.BuildDropEntries(crystal));
						component.ConfigureManagedSpawn(crystal.PrefabName, zone.X, zone.Y, biomeAtPoint);
					}
					num5++;
				}
			}
			CrystalRespawnState.MarkZoneProcessed(zoneKey);
			if (num5 > 0)
			{
				Debug.Log((object)("Spawned " + num5 + "x " + crystal.PrefabName + " in zone " + zone.X + "," + zone.Y + "."));
			}
		}
	}

	private static Biome GetBiomeAtPoint(ZoneCoord zone, Vector3 point)
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0020: Invalid comparison between Unknown and I4
		//IL_000f: 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_003b: 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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		if (WorldGenerator.instance == null)
		{
			return (Biome)0;
		}
		Biome biome = WorldGenerator.instance.GetBiome(point);
		if ((int)biome > 0)
		{
			return biome;
		}
		return WorldGenerator.instance.GetBiome(GetZoneCenter(zone));
	}

	private static bool TryFindGroundPoint(ZoneCoord zone, out Vector3 point)
	{
		//IL_0042: 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_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: 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_00ca: 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_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor((float)zone.X * 64f, 0f, (float)zone.Y * 64f);
		int num = LayerMask.NameToLayer("terrain");
		RaycastHit[] array = (RaycastHit[])(object)new RaycastHit[16];
		Vector3 val2 = default(Vector3);
		for (int i = 0; i < 40; i++)
		{
			float num2 = val.x + Random.Range(0f, 64f);
			float num3 = val.z + Random.Range(0f, 64f);
			((Vector3)(ref val2))..ctor(num2, 2000f, num3);
			int num4 = Physics.RaycastNonAlloc(val2, Vector3.down, array, 4000f, -1, (QueryTriggerInteraction)2);
			if (num4 <= 0)
			{
				continue;
			}
			Array.Sort(array, 0, num4, RaycastHitDistanceComparer.Instance);
			bool flag = false;
			for (int j = 0; j < num4; j++)
			{
				RaycastHit val3 = array[j];
				Collider collider = ((RaycastHit)(ref val3)).collider;
				if ((Object)(object)collider == (Object)null)
				{
					continue;
				}
				if (((Component)collider).gameObject.layer == num)
				{
					if (!flag)
					{
						point = ((RaycastHit)(ref val3)).point + Vector3.up * 0.05f;
						return true;
					}
					break;
				}
				if (!IsIgnorableGroundProbeCollider(collider))
				{
					flag = true;
					break;
				}
			}
		}
		point = Vector3.zero;
		return false;
	}

	private static bool IsIgnorableGroundProbeCollider(Collider collider)
	{
		if ((Object)(object)collider == (Object)null)
		{
			return false;
		}
		if (collider.isTrigger)
		{
			return true;
		}
		string text = LayerMask.LayerToName(((Component)collider).gameObject.layer);
		if (!string.IsNullOrWhiteSpace(text) && string.Equals(text, "water", StringComparison.OrdinalIgnoreCase))
		{
			return true;
		}
		string name = ((Object)((Component)collider).gameObject).name;
		if (!string.IsNullOrWhiteSpace(name) && name.IndexOf("water", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		return false;
	}

	private static bool IsInsidePlayerBaseSuppression(Vector3 point)
	{
		//IL_0001: 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_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Invalid comparison between Unknown and I4
		Collider[] array = Physics.OverlapSphere(point, 0.5f, -1, (QueryTriggerInteraction)2);
		foreach (Collider val in array)
		{
			if (!((Object)(object)val == (Object)null))
			{
				EffectArea val2 = ((Component)val).GetComponent<EffectArea>();
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).GetComponentInParent<EffectArea>();
				}
				if (!((Object)(object)val2 == (Object)null) && (val2.m_type & 4) > 0)
				{
					return true;
				}
			}
		}
		return false;
	}

	private static bool HasActiveManagedCrystal(string zoneKey)
	{
		if (string.IsNullOrWhiteSpace(zoneKey))
		{
			return false;
		}
		if (!ActiveManagedCrystals.TryGetValue(zoneKey, out var value) || value == null || value.Count == 0)
		{
			return false;
		}
		value.RemoveWhere((CrystalRuntimeState runtime) => (Object)(object)runtime == (Object)null);
		if (value.Count <= 0)
		{
			ActiveManagedCrystals.Remove(zoneKey);
			return false;
		}
		return true;
	}

	public static void RegisterManagedCrystalInstance(string zoneKey, CrystalRuntimeState runtime)
	{
		if (!string.IsNullOrWhiteSpace(zoneKey) && !((Object)(object)runtime == (Object)null))
		{
			if (!ActiveManagedCrystals.TryGetValue(zoneKey, out var value) || value == null)
			{
				value = new HashSet<CrystalRuntimeState>();
				ActiveManagedCrystals[zoneKey] = value;
			}
			value.Add(runtime);
		}
	}

	public static void NotifyManagedCrystalDestroyed(string zoneKey, CrystalRuntimeState runtime)
	{
		RemoveManagedCrystalInstance(zoneKey, runtime);
	}

	public static void NotifyManagedCrystalUnloaded(string zoneKey, CrystalRuntimeState runtime)
	{
		RemoveManagedCrystalInstance(zoneKey, runtime);
	}

	private static void RemoveManagedCrystalInstance(string zoneKey, CrystalRuntimeState runtime)
	{
		if (!string.IsNullOrWhiteSpace(zoneKey) && !((Object)(object)runtime == (Object)null) && ActiveManagedCrystals.TryGetValue(zoneKey, out var value) && value != null)
		{
			value.Remove(runtime);
			value.RemoveWhere((CrystalRuntimeState item) => (Object)(object)item == (Object)null);
			if (value.Count <= 0)
			{
				ActiveManagedCrystals.Remove(zoneKey);
			}
		}
	}

	public static string BuildZoneKey(string prefabName, int zoneX, int zoneY)
	{
		return "RWC_" + prefabName + "_" + zoneX + "_" + zoneY;
	}

	private static ZoneCoord GetZone(Vector3 pos)
	{
		//IL_0001: 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)
		return new ZoneCoord(Mathf.FloorToInt(pos.x / 64f), Mathf.FloorToInt(pos.z / 64f));
	}

	private static Vector3 GetZoneCenter(ZoneCoord zone)
	{
		//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_0034: Unknown result type (might be due to invalid IL or missing references)
		return new Vector3((float)zone.X * 64f + 32f, 0f, (float)zone.Y * 64f + 32f);
	}

	private static Biome ParseBiomes(string biomeList)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: 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_00ab: 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_005c: 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)
		Biome val = (Biome)0;
		if (string.IsNullOrWhiteSpace(biomeList))
		{
			return val;
		}
		string[] array = biomeList.Split(new char[1] { ',' });
		for (int i = 0; i < array.Length; i++)
		{
			string text = array[i].Trim();
			if (!string.IsNullOrEmpty(text))
			{
				if (Enum.TryParse<Biome>(text, ignoreCase: true, out Biome result))
				{
					val |= result;
				}
				else if (!MissingBiomeWarnings.Contains(text))
				{
					MissingBiomeWarnings.Add(text);
					Debug.LogWarning((object)("Crystal biome name could not be parsed from config: " + text));
				}
			}
		}
		return val;
	}

	private static bool BiomeMatches(Biome allowed, Biome biome)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: 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_0008: Invalid comparison between Unknown and I4
		return (int)allowed != 0 && (allowed & biome) > 0;
	}
}
public static class CrystalRespawnState
{
	[Serializable]
	private sealed class StateContainer
	{
		public string WorldName = string.Empty;

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

		public bool WorldClockInitialized;

		public float LastObservedDayFraction;

		public int DaysSinceReset;

		public bool ResetTriggeredForCurrentDay;
	}

	private const int ResetIntervalDays = 3;

	private const float ResetHour = 6f;

	private const float DayWrapThreshold = 0.15f;

	private static bool stateLoaded;

	private static string stateFilePath;

	private static readonly HashSet<string> ProcessedCrystalZoneKeys = new HashSet<string>();

	private static bool worldClockInitialized;

	private static float lastObservedDayFraction;

	private static int daysSinceReset;

	private static bool resetTriggeredForCurrentDay;

	public static void Initialize()
	{
		stateFilePath = Path.Combine(Paths.ConfigPath, "Ravenwood.Crystals.state.json");
		LoadState();
	}

	public static bool IsZoneProcessed(string zoneKey)
	{
		if (string.IsNullOrWhiteSpace(zoneKey))
		{
			return false;
		}
		return ProcessedCrystalZoneKeys.Contains(BuildWorldScopedKey(zoneKey));
	}

	public static void MarkZoneProcessed(string zoneKey)
	{
		if (!string.IsNullOrWhiteSpace(zoneKey) && ProcessedCrystalZoneKeys.Add(BuildWorldScopedKey(zoneKey)))
		{
			SaveState();
		}
	}

	public static bool ShouldRunResetNow()
	{
		if ((Object)(object)EnvMan.instance == (Object)null)
		{
			return false;
		}
		float num = Mathf.Repeat(EnvMan.instance.GetDayFraction(), 1f);
		float num2 = num * 24f;
		bool flag = false;
		if (!worldClockInitialized)
		{
			worldClockInitialized = true;
			lastObservedDayFraction = num;
			daysSinceReset = 0;
			resetTriggeredForCurrentDay = num2 >= 6f;
			SaveState();
			return false;
		}
		if (num + 0.15f < lastObservedDayFraction)
		{
			daysSinceReset++;
			resetTriggeredForCurrentDay = false;
			flag = true;
		}
		lastObservedDayFraction = num;
		if (!resetTriggeredForCurrentDay && daysSinceReset >= 3 && num2 >= 6f)
		{
			daysSinceReset = 0;
			resetTriggeredForCurrentDay = true;
			SaveState();
			return true;
		}
		if (flag)
		{
			SaveState();
		}
		return false;
	}

	public static void ClearProcessedZonesForCurrentWorld()
	{
		if (ProcessedCrystalZoneKeys.Count <= 0)
		{
			SaveState();
			return;
		}
		List<string> list = new List<string>();
		foreach (string processedCrystalZoneKey in ProcessedCrystalZoneKeys)
		{
			if (processedCrystalZoneKey.StartsWith(GetWorldNameSafe() + "|", StringComparison.Ordinal))
			{
				list.Add(processedCrystalZoneKey);
			}
		}
		for (int i = 0; i < list.Count; i++)
		{
			ProcessedCrystalZoneKeys.Remove(list[i]);
		}
		SaveState();
	}

	private static string BuildWorldScopedKey(string zoneKey)
	{
		return GetWorldNameSafe() + "|" + zoneKey;
	}

	private static string ExtractZoneKey(string worldScopedKey)
	{
		if (string.IsNullOrWhiteSpace(worldScopedKey))
		{
			return string.Empty;
		}
		string[] array = worldScopedKey.Split(new char[1] { '|' }, 2);
		if (array.Length != 2)
		{
			return string.Empty;
		}
		return array[1];
	}

	private static string GetWorldNameSafe()
	{
		if ((Object)(object)ZNet.instance != (Object)null)
		{
			return ZNet.instance.GetWorldName();
		}
		return "UnknownWorld";
	}

	private static void LoadState()
	{
		if (stateLoaded)
		{
			return;
		}
		stateLoaded = true;
		ProcessedCrystalZoneKeys.Clear();
		worldClockInitialized = false;
		lastObservedDayFraction = 0f;
		daysSinceReset = 0;
		resetTriggeredForCurrentDay = false;
		if (string.IsNullOrWhiteSpace(stateFilePath) || !File.Exists(stateFilePath))
		{
			return;
		}
		try
		{
			string text = File.ReadAllText(stateFilePath);
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			StateContainer stateContainer = JsonUtility.FromJson<StateContainer>(text);
			if (stateContainer == null || !string.Equals(stateContainer.WorldName, GetWorldNameSafe(), StringComparison.Ordinal))
			{
				return;
			}
			worldClockInitialized = stateContainer.WorldClockInitialized;
			lastObservedDayFraction = stateContainer.LastObservedDayFraction;
			daysSinceReset = Mathf.Max(0, stateContainer.DaysSinceReset);
			resetTriggeredForCurrentDay = stateContainer.ResetTriggeredForCurrentDay;
			if (stateContainer.ProcessedCrystalZoneKeys == null)
			{
				return;
			}
			for (int i = 0; i < stateContainer.ProcessedCrystalZoneKeys.Count; i++)
			{
				string text2 = stateContainer.ProcessedCrystalZoneKeys[i];
				if (!string.IsNullOrWhiteSpace(text2))
				{
					ProcessedCrystalZoneKeys.Add(BuildWorldScopedKey(text2));
				}
			}
		}
		catch (Exception ex)
		{
			Debug.LogWarning((object)("Failed to load crystal state: " + ex.Message));
		}
	}

	private static void SaveState()
	{
		if (string.IsNullOrWhiteSpace(stateFilePath))
		{
			return;
		}
		try
		{
			StateContainer stateContainer = new StateContainer();
			stateContainer.WorldName = GetWorldNameSafe();
			stateContainer.WorldClockInitialized = worldClockInitialized;
			stateContainer.LastObservedDayFraction = lastObservedDayFraction;
			stateContainer.DaysSinceReset = daysSinceReset;
			stateContainer.ResetTriggeredForCurrentDay = resetTriggeredForCurrentDay;
			foreach (string processedCrystalZoneKey in ProcessedCrystalZoneKeys)
			{
				if (processedCrystalZoneKey.StartsWith(stateContainer.WorldName + "|", StringComparison.Ordinal))
				{
					string text = ExtractZoneKey(processedCrystalZoneKey);
					if (!string.IsNullOrWhiteSpace(text))
					{
						stateContainer.ProcessedCrystalZoneKeys.Add(text);
					}
				}
			}
			string contents = JsonUtility.ToJson((object)stateContainer, true);
			File.WriteAllText(stateFilePath, contents);
		}
		catch (Exception ex)
		{
			Debug.LogWarning((object)("Failed to save crystal state: " + ex.Message));
		}
	}
}
public class CrystalRuntimeState : MonoBehaviour
{
	[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
	private static class WearNTear_RPC_Damage_Patch
	{
		private static void Postfix(WearNTear __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				CrystalRuntimeState component = ((Component)__instance).GetComponent<CrystalRuntimeState>();
				if (!((Object)(object)component == (Object)null))
				{
					component.TryHandleDestroyed(fromOnDestroy: false);
				}
			}
		}
	}

	private readonly List<CrystalDropEntry> dropEntries = new List<CrystalDropEntry>();

	private bool handledDestroyed;

	private bool registeredManagedInstance;

	private bool restoredExistingState;

	private bool suppressDropSpawn;

	private WearNTear wear;

	private ZNetView znv;

	private string managedPrefabName = string.Empty;

	private string managedBiomeName = string.Empty;

	private int managedZoneX = int.MinValue;

	private int managedZoneY = int.MinValue;

	public void Configure(List<CrystalDropEntry> entries)
	{
		dropEntries.Clear();
		if (entries == null)
		{
			return;
		}
		for (int i = 0; i < entries.Count; i++)
		{
			CrystalDropEntry crystalDropEntry = entries[i];
			if (crystalDropEntry != null)
			{
				dropEntries.Add(new CrystalDropEntry(crystalDropEntry.ItemName, crystalDropEntry.Min, crystalDropEntry.Max));
			}
		}
	}

	public void ConfigureManagedSpawn(string prefabName, int zoneX, int zoneY, Biome biome)
	{
		managedPrefabName = prefabName ?? string.Empty;
		managedZoneX = zoneX;
		managedZoneY = zoneY;
		managedBiomeName = ((object)(Biome)(ref biome)).ToString();
		znv = ((Component)this).GetComponent<ZNetView>();
		if ((Object)(object)znv != (Object)null && znv.GetZDO() != null)
		{
			znv.GetZDO().Set("RWC_CrystalPrefabName", managedPrefabName);
			znv.GetZDO().Set("RWC_CrystalZoneX", managedZoneX);
			znv.GetZDO().Set("RWC_CrystalZoneY", managedZoneY);
			znv.GetZDO().Set("RWC_CrystalBiome", managedBiomeName);
		}
		TryRegisterManagedInstance();
	}

	public void BeginSilentRemoval()
	{
		suppressDropSpawn = true;
	}

	private void Awake()
	{
		wear = ((Component)this).GetComponent<WearNTear>();
		znv = ((Component)this).GetComponent<ZNetView>();
		LoadManagedSpawnData();
		TryRestoreExistingState();
		TryRegisterManagedInstance();
	}

	private void OnDestroy()
	{
		TryHandleDestroyed(fromOnDestroy: true);
		if (registeredManagedInstance)
		{
			CrystalManager.NotifyManagedCrystalUnloaded(GetManagedZoneKey(), this);
			registeredManagedInstance = false;
		}
	}

	private void LoadManagedSpawnData()
	{
		if (!((Object)(object)znv == (Object)null) && znv.GetZDO() != null)
		{
			managedPrefabName = znv.GetZDO().GetString("RWC_CrystalPrefabName", managedPrefabName);
			managedZoneX = znv.GetZDO().GetInt("RWC_CrystalZoneX", managedZoneX);
			managedZoneY = znv.GetZDO().GetInt("RWC_CrystalZoneY", managedZoneY);
			managedBiomeName = znv.GetZDO().GetString("RWC_CrystalBiome", managedBiomeName);
		}
	}

	private void TryRestoreExistingState()
	{
		if (!restoredExistingState)
		{
			restoredExistingState = CrystalManager.TryRestoreExistingCrystalState(this);
		}
	}

	private void TryRegisterManagedInstance()
	{
		if (!registeredManagedInstance)
		{
			string managedZoneKey = GetManagedZoneKey();
			if (!string.IsNullOrWhiteSpace(managedZoneKey))
			{
				CrystalManager.RegisterManagedCrystalInstance(managedZoneKey, this);
				registeredManagedInstance = true;
			}
		}
	}

	private string GetManagedZoneKey()
	{
		if (string.IsNullOrWhiteSpace(managedPrefabName) || managedZoneX == int.MinValue || managedZoneY == int.MinValue)
		{
			return string.Empty;
		}
		return CrystalManager.BuildZoneKey(managedPrefabName, managedZoneX, managedZoneY);
	}

	private void TryHandleDestroyed(bool fromOnDestroy)
	{
		if (handledDestroyed)
		{
			return;
		}
		if (suppressDropSpawn)
		{
			handledDestroyed = true;
		}
		else
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			wear = (((Object)(object)wear != (Object)null) ? wear : ((Component)this).GetComponent<WearNTear>());
			if ((Object)(object)wear == (Object)null)
			{
				if (fromOnDestroy)
				{
				}
			}
			else if (!(wear.m_health > 0f))
			{
				handledDestroyed = true;
				if (registeredManagedInstance)
				{
					CrystalManager.NotifyManagedCrystalDestroyed(GetManagedZoneKey(), this);
					registeredManagedInstance = false;
				}
				SpawnDrops();
			}
		}
	}

	private void SpawnDrops()
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: 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)(object)ZNetScene.instance == (Object)null || dropEntries.Count == 0)
		{
			return;
		}
		for (int i = 0; i < dropEntries.Count; i++)
		{
			CrystalDropEntry crystalDropEntry = dropEntries[i];
			if (crystalDropEntry == null || string.IsNullOrWhiteSpace(crystalDropEntry.ItemName))
			{
				continue;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(crystalDropEntry.ItemName);
			if ((Object)(object)prefab == (Object)null)
			{
				Debug.LogWarning((object)("Crystal drop prefab not found: " + crystalDropEntry.ItemName));
				continue;
			}
			int num = Mathf.Max(0, crystalDropEntry.Min);
			int num2 = Mathf.Max(num, crystalDropEntry.Max);
			int num3 = Random.Range(num, num2 + 1);
			for (int j = 0; j < num3; j++)
			{
				Object.Instantiate<GameObject>(prefab, ((Component)this).transform.position + Vector3.up, Random.rotation);
			}
		}
	}
}
public class LocalizeKey : MonoBehaviour
{
	public string Key;

	public void Awake()
	{
		if (!string.IsNullOrEmpty(Key))
		{
			string text = LocalizationCache.Get(Key);
		}
	}
}
public static class Localizer
{
	public static void Add(string key, string value)
	{
		LocalizationCache.Add(key, value);
	}

	public static void Register()
	{
		LocalizationCache.RegisterToJotunnLocalization();
	}
}
public class PlacementWatcher : MonoBehaviour
{
	public List<GameObject> RegisterList;

	private void Start()
	{
		if (RegisterList != null && !RegisterList.Contains(((Component)this).gameObject))
		{
			RegisterList.Add(((Component)this).gameObject);
		}
	}

	private void OnDestroy()
	{
		if (RegisterList != null)
		{
			RegisterList.Remove(((Component)this).gameObject);
		}
	}
}
public static class LocalizationCache
{
	private static Dictionary<string, string> translations = new Dictionary<string, string>();

	public static void Add(string key, string value)
	{
		translations[key] = value;
	}

	public static string Get(string key, string fallback = null)
	{
		if (translations.TryGetValue(key, out var value))
		{
			return value;
		}
		return fallback ?? key;
	}

	public static void RegisterToJotunnLocalization()
	{
		CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
		foreach (KeyValuePair<string, string> translation in translations)
		{
			string text = "English";
			string key = translation.Key;
			localization.AddTranslation(ref text, ref key, translation.Value);
		}
	}
}
[BepInPlugin("Ravenwood.Crystals", "Ravenwood Crystals", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class RavenwoodCrystals : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <DelayedRegister>d__7 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public AssetBundle bundle;

		public RavenwoodCrystals <>4__this;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedRegister>d__7(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if ((Object)(object)ZNetScene.instance == (Object)null)
			{
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			RelicRegistrar.RegisterAllRelics(bundle);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public const string PluginGUID = "Ravenwood.Crystals";

	public const string PluginName = "Ravenwood Crystals";

	public const string PluginVersion = "1.0.0";

	private AssetBundle gatesBundle;

	private static readonly List<GameObject> placedObjects = new List<GameObject>();

	public static ConfigEntry<string> PlayerPreferredCategory;

	private void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("ravenwood.crystals.scalingdebug").PatchAll();
		string resourcePath = "RavenwoodCrystals.ravenwoodcrystals";
		gatesBundle = EmbeddedAssetBundleLoader.LoadBundle(resourcePath);
		if ((Object)(object)gatesBundle == (Object)null)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)"Failed to load embedded AssetBundle.");
			return;
		}
		TrackAllPrefabsInBundle(gatesBundle);
		PlayerPreferredCategory = ((BaseUnityPlugin)this).Config.Bind<string>("General", "CustomHammerTab", "RavenwoodCrystals", "Set the hammer tab where this mod's build pieces should appear (e.g., Building, Furniture, RavenwoodCrystals)");
		foreach (string allCategory in RelicRegistrar.GetAllCategories())
		{
			PieceManager.Instance.AddPieceCategory(allCategory);
		}
		CrystalManager.Initialize((BaseUnityPlugin)(object)this, gatesBundle, ((BaseUnityPlugin)this).Config);
		CrystalManager.RegisterCrystalPrefabs(gatesBundle);
		PrefabManager.OnPrefabsRegistered += delegate
		{
			((MonoBehaviour)this).StartCoroutine(DelayedRegister(gatesBundle));
		};
	}

	[IteratorStateMachine(typeof(<DelayedRegister>d__7))]
	private IEnumerator DelayedRegister(AssetBundle bundle)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedRegister>d__7(0)
		{
			<>4__this = this,
			bundle = bundle
		};
	}

	public static void TrackAllPrefabsInBundle(AssetBundle bundle)
	{
		GameObject[] array = bundle.LoadAllAssets<GameObject>();
		foreach (GameObject val in array)
		{
			if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<PlacementWatcher>() == (Object)null)
			{
				val.AddComponent<PlacementWatcher>().RegisterList = placedObjects;
			}
		}
	}
}
public static class EmbeddedAssetBundleLoader
{
	public static AssetBundle LoadBundle(string resourcePath)
	{
		Assembly executingAssembly = Assembly.GetExecutingAssembly();
		using Stream stream = executingAssembly.GetManifestResourceStream(resourcePath);
		if (stream == null)
		{
			Debug.LogError((object)("AssetBundle resource not found: " + resourcePath));
			return null;
		}
		byte[] array = new byte[stream.Length];
		stream.Read(array, 0, array.Length);
		return AssetBundle.LoadFromMemory(array);
	}
}
public class RelicRegistration
{
	public string PrefabName;

	public string DisplayName;

	public RequirementConfig[] Requirements;

	public string Description;

	public string Category;

	public int Comfort;

	public string CraftingStation;

	public RelicRegistration(string prefab, string display, RequirementConfig[] reqs, string desc, string cat, int comfort = 0, string craftingStation = "Workbench")
	{
		PrefabName = prefab;
		DisplayName = display;
		Requirements = reqs;
		Description = desc;
		Category = cat;
		Comfort = comfort;
		CraftingStation = craftingStation;
	}
}
public static class RelicRegistrar
{
	private static bool wasAlreadyRegistered = false;

	public static readonly List<RelicRegistration> AllRegistrations = new List<RelicRegistration>();

	public static IEnumerable<string> GetAllCategories()
	{
		return AllRegistrations.Select((RelicRegistration r) => CategoryToTab(r.Category)).Distinct();
	}

	private static string CategoryToTab(string category)
	{
		string text = category.ToLower();
		string text2 = text;
		string text3 = text2;
		if (text3 == "building")
		{
			return RavenwoodCrystals.PlayerPreferredCategory.Value;
		}
		return category;
	}

	public static void RegisterAllRelics(AssetBundle bundle)
	{
		if (wasAlreadyRegistered)
		{
			return;
		}
		foreach (RelicRegistration allRegistration in AllRegistrations)
		{
			RegisterRelic(bundle, allRegistration);
		}
		wasAlreadyRegistered = true;
	}

	private static void RegisterRelic(AssetBundle bundle, RelicRegistration reg)
	{
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0149: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Expected O, but got Unknown
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Expected O, but got Unknown
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Expected O, but got Unknown
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Expected O, but got Unknown
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_023a: Expected O, but got Unknown
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_0231: Expected O, but got Unknown
		//IL_027c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0283: Expected O, but got Unknown
		//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d2: Expected O, but got Unknown
		if ((Object)(object)bundle == (Object)null)
		{
			return;
		}
		GameObject val = bundle.LoadAsset<GameObject>(reg.PrefabName);
		if (!((Object)(object)val == (Object)null))
		{
			((Object)val).name = reg.PrefabName;
			ZNetView val2 = val.GetComponent<ZNetView>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = val.AddComponent<ZNetView>();
			}
			val2.m_persistent = true;
			val2.m_syncInitialScale = true;
			if (!Object.op_Implicit((Object)(object)val.GetComponent<ZSyncTransform>()))
			{
				val.AddComponent<ZSyncTransform>();
			}
			Piece val3 = val.GetComponent<Piece>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = val.AddComponent<Piece>();
			}
			val3.m_name = reg.DisplayName;
			val3.m_description = reg.Description;
			val3.m_groundOnly = false;
			GameObject val4 = null;
			GameObject val5 = null;
			GameObject val6 = null;
			GameObject val7 = null;
			if ((Object)(object)ZNetScene.instance != (Object)null)
			{
				val4 = ZNetScene.instance.GetPrefab("vfx_Place_stone");
				val5 = ZNetScene.instance.GetPrefab("sfx_build_hammer_stone");
				val6 = ZNetScene.instance.GetPrefab("vfx_destroyed");
				val7 = ZNetScene.instance.GetPrefab("sfx_clay_pot_break");
			}
			List<EffectData> list = new List<EffectData>();
			if ((Object)(object)val4 != (Object)null)
			{
				list.Add(new EffectData
				{
					m_prefab = val4,
					m_enabled = true
				});
			}
			if ((Object)(object)val5 != (Object)null)
			{
				list.Add(new EffectData
				{
					m_prefab = val5,
					m_enabled = true
				});
			}
			EffectList val8 = new EffectList();
			val8.m_effectPrefabs = list.ToArray();
			val3.m_placeEffect = val8;
			WearNTear val9 = val.GetComponent<WearNTear>();
			if ((Object)(object)val9 == (Object)null)
			{
				val9 = val.AddComponent<WearNTear>();
			}
			val9.m_health = 1000f;
			val9.m_noRoofWear = true;
			List<EffectData> list2 = new List<EffectData>();
			if ((Object)(object)val6 != (Object)null)
			{
				list2.Add(new EffectData
				{
					m_prefab = val6,
					m_enabled = true
				});
			}
			if ((Object)(object)val7 != (Object)null)
			{
				list2.Add(new EffectData
				{
					m_prefab = val7,
					m_enabled = true
				});
			}
			EffectList val10 = new EffectList();
			val10.m_effectPrefabs = list2.ToArray();
			val9.m_destroyedEffect = val10;
			Sprite val11 = bundle.LoadAsset<Sprite>(reg.PrefabName.ToLowerInvariant());
			if ((Object)(object)val11 != (Object)null)
			{
				val3.m_icon = val11;
			}
			PieceConfig val12 = new PieceConfig();
			val12.PieceTable = "Hammer";
			val12.Category = CategoryToTab(reg.Category);
			val12.CraftingStation = reg.CraftingStation;
			val12.Requirements = reg.Requirements;
			PieceManager.Instance.AddPiece(new CustomPiece(val, true, val12));
		}
	}
}