using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using OdinEye.Client.Counters;
using OdinEye.Client.Events;
using OdinEye.Client.Hud;
using OdinEye.Client.Patches;
using OdinEye.Client.Stats;
using OdinEye.Client.Submission;
using OdinEye.Models;
using OdinEye.Models.Api;
using Steamworks;
using UnityEngine;
using Utf8Json;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OdinEye.Client")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OdinEye.Client")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("2f6e4b8e-6a3f-4b1a-9b0e-8f6c5b4a3d2e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8.1", FrameworkDisplayName = ".NET Framework 4.8.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OdinEye.Client
{
	[BepInPlugin("org.bepinex.plugins.odineye.client", "odineye.client", "1.0.0.0")]
	public class OdinEyeClientPlugin : BaseUnityPlugin
	{
		private static readonly TimeSpan CheckInterval = TimeSpan.FromSeconds(30.0);

		private static readonly TimeSpan HeartbeatInterval = TimeSpan.FromMinutes(5.0);

		private static readonly TimeSpan EventFlushInterval = TimeSpan.FromSeconds(5.0);

		private static readonly TimeSpan OutpostScanInterval = TimeSpan.FromSeconds(60.0);

		private static readonly TimeSpan SeedTimeout = TimeSpan.FromSeconds(10.0);

		private static readonly TimeSpan ClockUpdateInterval = TimeSpan.FromSeconds(1.0);

		private IPlayerStatsSource statsSource;

		private IStatsSubmitter statsSubmitter;

		private ICheatStatusSubmitter cheatStatusSubmitter;

		private ChangeDrivenPolicy policy;

		private Guid? currentPlayerId;

		private Uri serverBaseUri;

		private HttpClient seedClient;

		private HttpEventSubmitter eventSubmitter;

		private CustomCounterStore counters;

		private OutpostAnchorStore outpostAnchors;

		private DateTime nextOutpostScanUtc;

		private IPlayerStatsSource fullStatsSource;

		private volatile bool seeded;

		private DateTime seedDeadlineUtc;

		private bool loginSubmitted;

		private DateTime nextEventFlushUtc;

		private volatile IReadOnlyDictionary<string, float> lastSubmittedStats;

		private ConfigEntry<bool> showClock;

		private ClockHudElement clockHud;

		private DateTime nextClockUpdateUtc;

		private void Awake()
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			showClock = ((BaseUnityPlugin)this).Config.Bind<bool>("Hud", "ShowClock", true, "Show a small in-game clock just below the minimap (VALSER-40/41's own \"temporal hours\" reading -- dawn is always 6:00 AM, dusk always 6:00 PM). Purely local/visual -- reads nothing from your character and sends nothing anywhere, unaffected by ServerUrl below.");
			clockHud = new ClockHudElement();
			ConfigEntry<string> val = ((BaseUnityPlugin)this).Config.Bind<string>("Server", "ServerUrl", string.Empty, "The OdinEye server's base URL to submit this character's lifetime stats to (e.g. http://yourserver.com:2469/). Leave empty to disable stats/cheat-status submission -- nothing is read from your character or sent anywhere unless this is set. Does not affect the HUD clock above.");
			if (string.IsNullOrWhiteSpace(val.Value))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"OdinEye client: ServerUrl not configured, character-stats submission is disabled.");
				return;
			}
			if (!Uri.TryCreate(EnsureTrailingSlash(val.Value), UriKind.Absolute, out Uri result))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("OdinEye client: ServerUrl '" + val.Value + "' is not a valid URL. Character-stats submission is disabled."));
				return;
			}
			serverBaseUri = result;
			statsSource = new PlayerProfileStatsSource();
			statsSubmitter = new HttpStatsSubmitter(result, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			cheatStatusSubmitter = new HttpCheatStatusSubmitter(result, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			policy = new ChangeDrivenPolicy(CheckInterval, HeartbeatInterval);
			seedClient = new HttpClient();
			eventSubmitter = new HttpEventSubmitter(result, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			ClientRuntime.LogWarning = delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			};
			ApplyPatches();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"OdinEye client: character-stats submission enabled, reporting to {result}");
		}

		private void ApplyPatches()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("org.bepinex.plugins.odineye.client");
			Type[] types = typeof(OdinEyeClientPlugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.IsDefined(typeof(HarmonyPatch), inherit: false))
				{
					try
					{
						val.CreateClassProcessor(type).Patch();
					}
					catch (Exception ex)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("OdinEye client: could not apply " + type.Name + " (" + ex.Message + "); the achievement it feeds will not progress until this is updated for the current game version."));
					}
				}
			}
		}

		private void OnDestroy()
		{
			EndSession();
			(statsSubmitter as IDisposable)?.Dispose();
			(cheatStatusSubmitter as IDisposable)?.Dispose();
			eventSubmitter?.Dispose();
			HttpClient obj = seedClient;
			if (obj != null)
			{
				((HttpMessageInvoker)obj).Dispose();
			}
		}

		private void EndSession()
		{
			ClientRuntime.Counters = null;
			counters?.Flush();
			counters = null;
			outpostAnchors?.Flush();
			outpostAnchors = null;
			fullStatsSource = null;
			currentPlayerId = null;
			loginSubmitted = false;
			lastSubmittedStats = null;
		}

		private void Update()
		{
			UpdateClock();
			if (statsSubmitter == null)
			{
				return;
			}
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				EndSession();
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!currentPlayerId.HasValue)
			{
				currentPlayerId = ComputeLocalPlayerId();
				if (!currentPlayerId.HasValue)
				{
					return;
				}
				BeginSession(currentPlayerId.Value, utcNow);
			}
			Guid value = currentPlayerId.Value;
			if (utcNow >= nextEventFlushUtc)
			{
				nextEventFlushUtc = utcNow + EventFlushInterval;
				eventSubmitter.Flush(value, ClientRuntime.Events);
			}
			if (utcNow >= nextOutpostScanUtc)
			{
				nextOutpostScanUtc = utcNow + OutpostScanInterval;
				OutpostTracking.Scan(outpostAnchors);
				outpostAnchors.Flush();
			}
			if (!loginSubmitted)
			{
				if (seeded || !(utcNow < seedDeadlineUtc))
				{
					loginSubmitted = true;
					policy.OnLogin(utcNow);
					SubmitAll(value, utcNow);
				}
			}
			else if (policy.IsCheckDue(utcNow))
			{
				counters?.Flush();
				IReadOnlyDictionary<string, float> stats = fullStatsSource.GetStats();
				if (policy.ShouldSubmit(utcNow, StatsChange.HasChanged(lastSubmittedStats, stats)))
				{
					SubmitAll(value, utcNow);
				}
			}
		}

		private void BeginSession(Guid playerId, DateTime nowUtc)
		{
			counters = new CustomCounterStore(Path.Combine(Paths.ConfigPath, $"odineye.client.counters.{playerId:N}.json"), delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			outpostAnchors = new OutpostAnchorStore(Path.Combine(Paths.ConfigPath, $"odineye.client.outposts.{playerId:N}.json"), delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			});
			fullStatsSource = new CounterAugmentedStatsSource(statsSource, counters, StationNames.Get, NorthTracking.CurrentNorthZ, NorthTracking.IsInDeepNorth, BoatTracking.IsOnBoat, SwampTracking.IsInSwamp, OvenTracking.IsNearOven);
			seeded = false;
			seedDeadlineUtc = nowUtc + SeedTimeout;
			loginSubmitted = false;
			lastSubmittedStats = null;
			nextEventFlushUtc = nowUtc + EventFlushInterval;
			nextOutpostScanUtc = nowUtc + OutpostScanInterval;
			CustomCounterStore store = counters;
			Task.Run(async delegate
			{
				Dictionary<string, float> serverValues = await StatsSeeder.FetchAsync(seedClient, serverBaseUri, playerId, SeedTimeout, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)message);
				}).ConfigureAwait(continueOnCapturedContext: false);
				store.SeedFrom(serverValues);
				if (counters == store)
				{
					seeded = true;
				}
			});
			ClientRuntime.Counters = counters;
		}

		private void SubmitAll(Guid playerId, DateTime nowUtc)
		{
			SubmitCurrentStats(playerId);
			SubmitCheatStatus(playerId);
			policy.MarkSubmitted(nowUtc);
		}

		private void UpdateClock()
		{
			if (!showClock.Value)
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (!(utcNow < nextClockUpdateUtc))
			{
				nextClockUpdateUtc = utcNow + ClockUpdateInterval;
				double? totalSeconds = EnvManTimeReader.GetTotalSeconds();
				if (totalSeconds.HasValue)
				{
					clockHud.SetText(TemporalClock.Format(totalSeconds.Value));
				}
			}
		}

		private void SubmitCurrentStats(Guid playerId)
		{
			//IL_0015: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			IReadOnlyDictionary<string, float> stats = fullStatsSource.GetStats();
			if (stats.Count == 0)
			{
				return;
			}
			SubmissionMeta meta = new SubmissionMeta
			{
				PlayerId = ClientRuntime.LocalPlayerId().ToString(),
				ClientVersion = typeof(OdinEyeClientPlugin).Assembly.GetName().Version.ToString()
			};
			CharacterStatsSubmission val = CharacterStatsPayloadBuilder.Build(stats, meta);
			if (val.Stats.Count == 0)
			{
				return;
			}
			lastSubmittedStats = stats;
			statsSubmitter.Submit(playerId, val, delegate(bool accepted)
			{
				if (!accepted)
				{
					lastSubmittedStats = null;
				}
			});
		}

		private void SubmitCheatStatus(Guid playerId)
		{
			bool? flag = CheatStatusReader.IsCheated();
			if (flag.HasValue)
			{
				cheatStatusSubmitter.Submit(playerId, flag.Value, CheatBypassReader.IsEnabled());
			}
		}

		private static Guid? ComputeLocalPlayerId()
		{
			//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)
			Game instance = Game.instance;
			PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
			if (val == null)
			{
				return null;
			}
			string name = val.GetName();
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			return NameBasedGuid.NewPlayerGuid(SteamUser.GetSteamID().m_SteamID.ToString(), name);
		}

		private static string EnsureTrailingSlash(string url)
		{
			if (!url.EndsWith("/", StringComparison.Ordinal))
			{
				return url + "/";
			}
			return url;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "OdinEye.Client";

		public const string PLUGIN_NAME = "";

		public const string PLUGIN_VERSION = "1.0.0.0";
	}
}
namespace OdinEye.Client.Patches
{
	[HarmonyPatch]
	public static class ArrowHitPatch
	{
		private static readonly FieldInfo OwnerField = AccessTools.Field(typeof(Projectile), "m_owner");

		private static readonly FieldInfo SkillField = AccessTools.Field(typeof(Projectile), "m_skill");

		[HarmonyPrepare]
		private static bool Prepare()
		{
			if (TargetMethod() != null && OwnerField != null)
			{
				return SkillField != null;
			}
			return false;
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(Projectile), "OnHit", (Type[])null, (Type[])null);
		}

		[HarmonyPrefix]
		private static void Prefix(Projectile __instance, object[] __args)
		{
			ClientRuntime.Guard("arrow hit count", delegate
			{
				CustomCounterStore counters = ClientRuntime.Counters;
				if (counters != null && !((Object)(object)Player.m_localPlayer == (Object)null))
				{
					object obj = __args[0];
					object obj2 = ((obj is Component) ? obj : null);
					Character val = ((obj2 != null) ? ((Component)obj2).GetComponentInParent<Character>() : null);
					if (CounterRules.CountsAsArrowHitOnEnemy(OwnerField.GetValue(__instance) == Player.m_localPlayer, SkillField.GetValue(__instance)?.ToString(), (Object)(object)val != (Object)null, (Object)(object)val != (Object)null && val.IsPlayer(), (Object)(object)val != (Object)null && val.IsTamed(), (Object)(object)val != (Object)null && val.IsDead()))
					{
						counters.Increment("Custom:ArrowHitsEnemy");
					}
				}
			});
		}
	}
	public static class BedPatches
	{
		[HarmonyPatch(typeof(WearNTear), "Remove")]
		public static class BedRemovedPatch
		{
			private static readonly MethodInfo GetOwner = AccessTools.Method(typeof(Bed), "GetOwner", (Type[])null, (Type[])null);

			[HarmonyPrepare]
			private static bool Prepare()
			{
				return GetOwner != null;
			}

			[HarmonyPrefix]
			private static void Prefix(WearNTear __instance)
			{
				ClientRuntime.Guard("bed removal report", delegate
				{
					//IL_0037: Unknown result type (might be due to invalid IL or missing references)
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0053: 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_005f: Unknown result type (might be due to invalid IL or missing references)
					if (ClientRuntime.Counters != null)
					{
						Bed component = ((Component)__instance).GetComponent<Bed>();
						if (!((Object)(object)component == (Object)null))
						{
							ClientRuntime.Counters.Increment("Custom:BedsDestroyed");
							Vector3 spawnPoint = component.GetSpawnPoint();
							ClientEvent val = BedEvents.Removed((long)GetOwner.Invoke(component, null), ClientRuntime.LocalPlayerId(), spawnPoint.x, spawnPoint.y, spawnPoint.z);
							if (val != null)
							{
								ClientRuntime.Events.Enqueue(val);
							}
						}
					}
				});
			}
		}

		[HarmonyPatch(typeof(Game), "FindSpawnPoint")]
		public static class BedMissingPatch
		{
			[HarmonyPrefix]
			private static void Prefix(Game __instance, out object __state)
			{
				__state = null;
				object captured = null;
				ClientRuntime.Guard("respawn check", delegate
				{
					//IL_0022: Unknown result type (might be due to invalid IL or missing references)
					PlayerProfile playerProfile = __instance.GetPlayerProfile();
					if (ClientRuntime.Counters != null && playerProfile != null && playerProfile.HaveCustomSpawnPoint())
					{
						captured = playerProfile.GetCustomSpawnPoint();
					}
				});
				__state = captured;
			}

			[HarmonyPostfix]
			private static void Postfix(Game __instance, object __state)
			{
				if (__state == null)
				{
					return;
				}
				ClientRuntime.Guard("respawn report", delegate
				{
					//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: 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_0035: Unknown result type (might be due to invalid IL or missing references)
					PlayerProfile playerProfile = __instance.GetPlayerProfile();
					if (playerProfile != null && !playerProfile.HaveCustomSpawnPoint())
					{
						Vector3 val = (Vector3)__state;
						ClientRuntime.Events.Enqueue(BedEvents.MissingAtRespawn(val.x, val.y, val.z));
					}
				});
			}
		}
	}
	internal static class ClientRuntime
	{
		public static volatile CustomCounterStore Counters;

		public static readonly ClientEventQueue Events = new ClientEventQueue();

		public static Action<string> LogWarning = delegate
		{
		};

		public static long LocalPlayerId()
		{
			Game instance = Game.instance;
			long? obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				PlayerProfile playerProfile = instance.GetPlayerProfile();
				obj = ((playerProfile != null) ? new long?(playerProfile.GetPlayerID()) : ((long?)null));
			}
			long? num = obj;
			return num.GetValueOrDefault();
		}

		public static void Guard(string what, Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				LogWarning("OdinEye client: " + what + " failed: " + ex.Message);
			}
		}
	}
	public static class CookingStationPatches
	{
		[HarmonyPatch(typeof(CookingStation), "OnInteract")]
		public static class OnInteractPatch
		{
			[HarmonyPrepare]
			private static bool Prepare()
			{
				return Available;
			}

			[HarmonyPrefix]
			private static void Prefix(CookingStation __instance, Humanoid user)
			{
				ClientRuntime.Guard("cooking station check", delegate
				{
					nextRemovalProductName = null;
					nextRemovalIsBurnt = false;
					if (ClientRuntime.Counters != null && (object)user == Player.m_localPlayer)
					{
						(string, string)? tuple = NextFinishedSlot(__instance);
						if (tuple.HasValue)
						{
							if (tuple.Value.Item1 == "Burnt")
							{
								nextRemovalIsBurnt = true;
							}
							else
							{
								nextRemovalProductName = tuple.Value.Item2;
							}
						}
					}
				});
			}

			[HarmonyPostfix]
			private static void Postfix()
			{
				nextRemovalProductName = null;
				nextRemovalIsBurnt = false;
			}
		}

		[HarmonyPatch(typeof(ZNetView), "InvokeRPC", new Type[]
		{
			typeof(string),
			typeof(object[])
		})]
		public static class RemoveDoneItemPatch
		{
			[HarmonyPrefix]
			private static void Prefix(object[] __args)
			{
				if (!(__args[0] is string text) || text != "RPC_RemoveDoneItem" || (nextRemovalProductName == null && !nextRemovalIsBurnt))
				{
					return;
				}
				string productName = nextRemovalProductName;
				bool isBurnt = nextRemovalIsBurnt;
				nextRemovalProductName = null;
				nextRemovalIsBurnt = false;
				ClientRuntime.Guard("cooking station count", delegate
				{
					int amountTaken = ((!(__args[1] is object[] array) || array.Length <= 1) ? 1 : Convert.ToInt32(array[1]));
					if (productName != null)
					{
						int num = CounterRules.BreadToCount(itemIsDone: true, productName, amountTaken);
						if (num > 0)
						{
							ClientRuntime.Counters?.Increment("Custom:BreadCollected", num);
						}
						int num2 = CounterRules.CookedChickenMeatToCount(itemIsDone: true, productName, amountTaken);
						if (num2 > 0)
						{
							ClientRuntime.Counters?.Increment("Custom:ChickenMeatCooked", num2);
						}
						int num3 = CounterRules.LoxPieToCount(itemIsDone: true, productName, amountTaken);
						if (num3 > 0)
						{
							ClientRuntime.Counters?.Increment("Custom:LoxPiesCooked", num3);
						}
					}
					if (isBurnt)
					{
						int num4 = CounterRules.FoodBurntToCoal(isBurntStatus: true, amountTaken);
						if (num4 > 0)
						{
							ClientRuntime.Counters?.Increment("Custom:FoodBurntToCoal", num4);
						}
					}
				});
			}
		}

		private static string nextRemovalProductName;

		private static bool nextRemovalIsBurnt;

		private static readonly MethodInfo GetSlot = AccessTools.Method(typeof(CookingStation), "GetSlot", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetItemConversion = AccessTools.Method(typeof(CookingStation), "GetItemConversion", (Type[])null, (Type[])null);

		private static bool Available
		{
			get
			{
				if (GetSlot != null)
				{
					return GetItemConversion != null;
				}
				return false;
			}
		}

		private static (string Status, string ProductName)? NextFinishedSlot(CookingStation station)
		{
			for (int i = 0; i < station.m_slots.Length; i++)
			{
				object[] array = new object[5] { i, null, 0f, null, false };
				GetSlot.Invoke(station, array);
				string text = array[1] as string;
				string text2 = array[3]?.ToString();
				if (!string.IsNullOrEmpty(text) && (!(text2 != "Done") || !(text2 != "Burnt")))
				{
					if (text2 != "Done")
					{
						return ("Burnt", null);
					}
					object obj = GetItemConversion.Invoke(station, new object[1] { text });
					object? obj2 = obj?.GetType().GetField("m_to")?.GetValue(obj);
					Object val = (Object)((obj2 is Object) ? obj2 : null);
					return ("Done", (val != null) ? val.name : null);
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(Fermenter), "Interact")]
	public static class FermenterTapPatch
	{
		private static readonly MethodInfo GetStatus = AccessTools.Method(typeof(Fermenter), "GetStatus", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetContent = AccessTools.Method(typeof(Fermenter), "GetContent", (Type[])null, (Type[])null);

		private static bool Available
		{
			get
			{
				if (GetStatus != null)
				{
					return GetContent != null;
				}
				return false;
			}
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			return Available;
		}

		[HarmonyPrefix]
		private static void Prefix(Fermenter __instance, Humanoid user)
		{
			ClientRuntime.Guard("fermenter tap check", delegate
			{
				if (ClientRuntime.Counters != null && (object)user == Player.m_localPlayer)
				{
					bool flag = GetStatus.Invoke(__instance, null)?.ToString() == "Ready";
					int contentHash = (flag ? ((int)GetContent.Invoke(__instance, null)) : 0);
					int num = CounterRules.MeadsToCount(flag, ((contentHash == 0) ? null : __instance.m_conversion?.FirstOrDefault((Func<ItemConversion, bool>)((ItemConversion c) => (Object)(object)c?.m_from != (Object)null && StringExtensionMethods.GetStableHashCode(((Object)((Component)c.m_from).gameObject).name) == contentHash)))?.m_producedItems ?? 0);
					if (num > 0)
					{
						ClientRuntime.Counters.Increment("Custom:MeadsMade", num);
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Character), "ApplyDamage")]
	public static class IncomingHitPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance, HitData hit)
		{
			ClientRuntime.Guard("incoming hit count", delegate
			{
				if (ClientRuntime.Counters != null && hit != null && !((Object)(object)__instance == (Object)null) && (object)__instance == Player.m_localPlayer)
				{
					if (CounterRules.CountsAsPoisonDeath(targetIsLocalPlayer: true, __instance.IsDead(), hit.m_damage.m_poison))
					{
						ClientRuntime.Counters.Increment("Custom:PoisonDeaths");
					}
					Character attacker = hit.GetAttacker();
					string attackerPrefabName = (((Object)(object)attacker == (Object)null) ? null : Utils.GetPrefabName(((Component)attacker).gameObject));
					if (CounterRules.CountsAsLeechHit(targetIsLocalPlayer: true, attackerPrefabName))
					{
						ClientRuntime.Counters.Increment("Custom:LeechHits");
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup")]
	public static class ItemPickupPatch
	{
		[HarmonyPrefix]
		private static void Prefix(Humanoid __instance, GameObject go, out object __state)
		{
			__state = null;
			object captured = null;
			ClientRuntime.Guard("item pickup check", delegate
			{
				if (ClientRuntime.Counters != null && (object)__instance == Player.m_localPlayer && !((Object)(object)go == (Object)null))
				{
					ItemData val = go.GetComponent<ItemDrop>()?.m_itemData;
					if ((Object)(object)val?.m_dropPrefab != (Object)null)
					{
						captured = (Utils.GetPrefabName(val.m_dropPrefab), val.m_stack);
					}
				}
			});
			__state = captured;
		}

		[HarmonyPostfix]
		private static void Postfix(bool __result, object __state)
		{
			ClientRuntime.Guard("item pickup count", delegate
			{
				if (__result && __state is ValueTuple<string, int>)
				{
					(string, int) tuple = ((string, int))__state;
					string item = tuple.Item1;
					int item2 = tuple.Item2;
					CustomCounterStore counters = ClientRuntime.Counters;
					int num = CounterRules.DwarfEyesToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num > 0)
					{
						counters?.Increment("Custom:DwarfEyesTouched", num);
					}
					int num2 = CounterRules.GuckToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num2 > 0)
					{
						counters?.Increment("Custom:GuckCollected", num2);
					}
					int num3 = CounterRules.BloodBagToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num3 > 0)
					{
						counters?.Increment("Custom:BloodBagsCollected", num3);
					}
					int num4 = CounterRules.ElderBarkToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num4 > 0)
					{
						counters?.Increment("Custom:ElderBarkCollected", num4);
					}
					int num5 = CounterRules.WoodToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num5 > 0)
					{
						counters?.Increment("Custom:WoodCollected", num5);
					}
					int num6 = CounterRules.StoneToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num6 > 0)
					{
						counters?.Increment("Custom:StoneCollected", num6);
					}
					int num7 = CounterRules.ResinToCount(byLocalPlayer: true, pickupSucceeded: true, item, item2);
					if (num7 > 0)
					{
						counters?.Increment("Custom:ResinHandled", num7);
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(MineRock5), "DamageArea")]
	public static class MudPilePatch
	{
		[HarmonyPostfix]
		private static void Postfix(MineRock5 __instance, HitData hit, bool ___m_allDestroyed)
		{
			ClientRuntime.Guard("mud pile count", delegate
			{
				if (ClientRuntime.Counters != null && hit != null && !((Object)(object)__instance == (Object)null) && ___m_allDestroyed)
				{
					bool byLocalPlayer = (object)hit.GetAttacker() == Player.m_localPlayer;
					string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
					if (CounterRules.CountsAsMuddyScrapPileOpened(byLocalPlayer, nowFullyDestroyed: true, prefabName))
					{
						ClientRuntime.Counters.Increment("Custom:MuddyScrapPilesOpened");
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Smelter), "OnEmpty")]
	public static class SmelterEmptyPatch
	{
		[HarmonyPrefix]
		private static void Prefix(Humanoid user, ZNetView ___m_nview)
		{
			ClientRuntime.Guard("smelter empty count", delegate
			{
				if (ClientRuntime.Counters != null && !((Object)(object)___m_nview == (Object)null) && (object)user == Player.m_localPlayer)
				{
					ZDO zDO = ___m_nview.GetZDO();
					if (zDO != null)
					{
						string queuedOreName = zDO.GetString(ZDOVars.s_spawnOre, "");
						int queuedAmount = zDO.GetInt(ZDOVars.s_spawnAmount, 0);
						int num = CounterRules.IronToProcess(queuedOreName, queuedAmount);
						if (num > 0)
						{
							ClientRuntime.Counters.Increment("Custom:IronProcessed", num);
						}
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Tameable), "Tame")]
	public static class TameablePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Character ___m_character)
		{
			ClientRuntime.Guard("tame count", delegate
			{
				if (ClientRuntime.Counters != null && !((Object)(object)___m_character == (Object)null))
				{
					string text = CounterRules.TamedSpeciesCounterKey(Utils.GetPrefabName(((Component)___m_character).gameObject));
					if (text != null)
					{
						ClientRuntime.Counters.Increment(text);
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Player), "ConsumeItem")]
	public static class VomitBombPatch
	{
		[HarmonyPrefix]
		private static void Prefix(Player __instance, out object __state)
		{
			__state = null;
			object captured = null;
			ClientRuntime.Guard("vomit bomb pre-check", delegate
			{
				if (__instance == Player.m_localPlayer)
				{
					captured = __instance.GetFoods()?.Count ?? 0;
				}
			});
			__state = captured;
		}

		[HarmonyPostfix]
		private static void Postfix(ItemData item, bool __result, object __state)
		{
			ClientRuntime.Guard("vomit bomb count", delegate
			{
				if (ClientRuntime.Counters != null && __state is int)
				{
					int activeFoodCountBeforeEating = (int)__state;
					bool eatenSuccessfully = __result;
					ItemData obj = item;
					object itemSharedName;
					if (obj == null)
					{
						itemSharedName = null;
					}
					else
					{
						GameObject dropPrefab = obj.m_dropPrefab;
						itemSharedName = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
					}
					if (CounterRules.CountsAsVomitBomb(eatenSuccessfully, (string)itemSharedName, activeFoodCountBeforeEating))
					{
						ClientRuntime.Counters.Increment("Custom:VomitBombs");
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(Character), "ApplyDamage")]
	public static class WeaponKillPatch
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance, HitData hit)
		{
			ClientRuntime.Guard("weapon kill count", delegate
			{
				if (ClientRuntime.Counters != null && hit != null)
				{
					bool byLocalPlayer = (object)hit.GetAttacker() == Player.m_localPlayer;
					string skillName = ((object)Unsafe.As<SkillType, SkillType>(ref hit.m_skill)/*cast due to .constrained prefix*/).ToString();
					bool flag = (Object)(object)__instance != (Object)null;
					bool targetIsPlayer = flag && __instance.IsPlayer();
					bool targetIsTamed = flag && __instance.IsTamed();
					bool targetIsDeadNow = flag && __instance.IsDead();
					if (CounterRules.CountsAsWeaponKill(byLocalPlayer, skillName, "Unarmed", flag, targetIsPlayer, targetIsTamed, targetIsDeadNow))
					{
						ClientRuntime.Counters.Increment("Custom:FistKills");
					}
					if (CounterRules.CountsAsWeaponKill(byLocalPlayer, skillName, "Swords", flag, targetIsPlayer, targetIsTamed, targetIsDeadNow))
					{
						ClientRuntime.Counters.Increment("Custom:SwordKills");
					}
				}
			});
		}
	}
}
namespace OdinEye.Client.Events
{
	public static class BedEvents
	{
		public static ClientEvent Removed(long ownerPlayerId, long removerPlayerId, float x, float y, float z)
		{
			//IL_0009: 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_0019: 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_0033: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (ownerPlayerId == 0L || ownerPlayerId == removerPlayerId)
			{
				return null;
			}
			return new ClientEvent
			{
				Type = "BedRemoved",
				OwnerPlayerId = ownerPlayerId.ToString(),
				RemoverPlayerId = removerPlayerId.ToString(),
				X = x,
				Y = y,
				Z = z
			};
		}

		public static ClientEvent MissingAtRespawn(float x, float y, float z)
		{
			//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_0010: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return new ClientEvent
			{
				Type = "BedMissingAtRespawn",
				X = x,
				Y = y,
				Z = z
			};
		}
	}
	public sealed class ClientEventQueue
	{
		public const int DefaultCapacity = 100;

		private readonly object gate = new object();

		private readonly LinkedList<ClientEvent> items = new LinkedList<ClientEvent>();

		private readonly int capacity;

		public int Count
		{
			get
			{
				lock (gate)
				{
					return items.Count;
				}
			}
		}

		public ClientEventQueue(int capacity = 100)
		{
			this.capacity = ((capacity > 0) ? capacity : 100);
		}

		public void Enqueue(ClientEvent clientEvent)
		{
			if (clientEvent == null)
			{
				return;
			}
			lock (gate)
			{
				items.AddLast(clientEvent);
				Trim();
			}
		}

		public List<ClientEvent> TakeBatch(int max)
		{
			List<ClientEvent> list = new List<ClientEvent>();
			lock (gate)
			{
				while (items.Count > 0 && list.Count < max)
				{
					list.Add(items.First.Value);
					items.RemoveFirst();
				}
			}
			return list;
		}

		public void Requeue(List<ClientEvent> batch)
		{
			if (batch == null)
			{
				return;
			}
			lock (gate)
			{
				for (int num = batch.Count - 1; num >= 0; num--)
				{
					items.AddFirst(batch[num]);
				}
				Trim();
			}
		}

		private void Trim()
		{
			while (items.Count > capacity)
			{
				items.RemoveFirst();
			}
		}
	}
}
namespace OdinEye.Client.Submission
{
	public sealed class ChangeDrivenPolicy
	{
		private readonly TimeSpan checkInterval;

		private readonly TimeSpan heartbeatInterval;

		private DateTime? nextCheckAtUtc;

		private DateTime? lastSubmittedAtUtc;

		public ChangeDrivenPolicy(TimeSpan checkInterval, TimeSpan heartbeatInterval)
		{
			if (checkInterval <= TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("checkInterval", "Check interval must be positive.");
			}
			if (heartbeatInterval < checkInterval)
			{
				throw new ArgumentOutOfRangeException("heartbeatInterval", "The heartbeat cannot be more frequent than the change check.");
			}
			this.checkInterval = checkInterval;
			this.heartbeatInterval = heartbeatInterval;
		}

		public void OnLogin(DateTime nowUtc)
		{
			lastSubmittedAtUtc = nowUtc;
			nextCheckAtUtc = nowUtc + checkInterval;
		}

		public bool IsCheckDue(DateTime nowUtc)
		{
			if (nextCheckAtUtc.HasValue)
			{
				DateTime? dateTime = nextCheckAtUtc;
				if (!(nowUtc < dateTime))
				{
					nextCheckAtUtc = nowUtc + checkInterval;
					return true;
				}
			}
			return false;
		}

		public bool ShouldSubmit(DateTime nowUtc, bool changed)
		{
			if (lastSubmittedAtUtc.HasValue)
			{
				if (!changed)
				{
					return nowUtc - lastSubmittedAtUtc.Value >= heartbeatInterval;
				}
				return true;
			}
			return false;
		}

		public void MarkSubmitted(DateTime nowUtc)
		{
			lastSubmittedAtUtc = nowUtc;
		}
	}
	public sealed class HttpEventSubmitter : IDisposable
	{
		private const int BatchSize = 20;

		private readonly HttpClient httpClient = new HttpClient();

		private readonly Uri serverBaseUri;

		private readonly Action<string> logWarning;

		private int sending;

		public HttpEventSubmitter(Uri serverBaseUri, Action<string> logWarning)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			this.serverBaseUri = serverBaseUri ?? throw new ArgumentNullException("serverBaseUri");
			this.logWarning = logWarning ?? throw new ArgumentNullException("logWarning");
		}

		public async void Flush(Guid playerId, ClientEventQueue queue)
		{
			if (queue.Count == 0 || Interlocked.Exchange(ref sending, 1) == 1)
			{
				return;
			}
			try
			{
				while (queue.Count > 0)
				{
					List<ClientEvent> batch = queue.TakeBatch(20);
					if (!(await SendAsync(playerId, batch).ConfigureAwait(continueOnCapturedContext: false)))
					{
						queue.Requeue(batch);
						break;
					}
				}
			}
			finally
			{
				Interlocked.Exchange(ref sending, 0);
			}
		}

		private async Task<bool> SendAsync(Guid playerId, List<ClientEvent> batch)
		{
			try
			{
				byte[] array = JsonSerializer.Serialize<ClientEventsSubmission>(new ClientEventsSubmission
				{
					Events = batch
				});
				ByteArrayContent content = new ByteArrayContent(array);
				try
				{
					((HttpContent)content).Headers.ContentType = new MediaTypeHeaderValue("application/json")
					{
						CharSet = Encoding.UTF8.WebName
					};
					HttpResponseMessage val = await httpClient.PostAsync(new Uri(serverBaseUri, $"players/{playerId}/events"), (HttpContent)(object)content).ConfigureAwait(continueOnCapturedContext: false);
					if (val.IsSuccessStatusCode)
					{
						return true;
					}
					int statusCode = (int)val.StatusCode;
					logWarning($"OdinEye server did not accept {batch.Count} event(s): {statusCode} {val.ReasonPhrase}");
					return statusCode == 400;
				}
				finally
				{
					((IDisposable)content)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				logWarning("Failed to send events to OdinEye server: " + ex.Message);
				return false;
			}
		}

		public void Dispose()
		{
			((HttpMessageInvoker)httpClient).Dispose();
		}
	}
	public static class StatsSeeder
	{
		public static Dictionary<string, float> ParseOwnStats(string json, Guid playerId)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			if (string.IsNullOrWhiteSpace(json))
			{
				return dictionary;
			}
			try
			{
				Dictionary<string, Dictionary<string, float>> dictionary2 = JsonSerializer.Deserialize<Dictionary<string, Dictionary<string, float>>>(json);
				if (dictionary2 != null && dictionary2.TryGetValue(playerId.ToString(), out var value) && value != null)
				{
					foreach (KeyValuePair<string, float> item in value)
					{
						dictionary[item.Key] = item.Value;
					}
				}
			}
			catch
			{
			}
			return dictionary;
		}

		public static async Task<Dictionary<string, float>> FetchAsync(HttpClient client, Uri serverBaseUri, Guid playerId, TimeSpan timeout, Action<string> logWarning)
		{
			_ = 1;
			try
			{
				using CancellationTokenSource cts = new CancellationTokenSource(timeout);
				HttpResponseMessage val = await client.GetAsync(new Uri(serverBaseUri, "players/stats"), cts.Token).ConfigureAwait(continueOnCapturedContext: false);
				if (!val.IsSuccessStatusCode)
				{
					logWarning($"OdinEye server would not share existing counters: {(int)val.StatusCode}");
					return new Dictionary<string, float>();
				}
				return ParseOwnStats(await val.Content.ReadAsStringAsync().ConfigureAwait(continueOnCapturedContext: false), playerId);
			}
			catch (Exception ex)
			{
				logWarning("Could not read existing counters from OdinEye server: " + ex.Message);
				return new Dictionary<string, float>();
			}
		}
	}
	public sealed class HttpCheatStatusSubmitter : ICheatStatusSubmitter, IDisposable
	{
		private readonly HttpClient httpClient;

		private readonly Uri serverBaseUri;

		private readonly Action<string> logWarning;

		public HttpCheatStatusSubmitter(Uri serverBaseUri, Action<string> logWarning)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			this.serverBaseUri = serverBaseUri ?? throw new ArgumentNullException("serverBaseUri");
			this.logWarning = logWarning ?? throw new ArgumentNullException("logWarning");
			httpClient = new HttpClient();
		}

		public async void Submit(Guid playerId, bool cheated, bool bypassEnabled)
		{
			try
			{
				byte[] array = JsonSerializer.Serialize<CheatStatusSubmission>(new CheatStatusSubmission
				{
					Cheated = cheated,
					BypassEnabled = bypassEnabled
				});
				Uri uri = new Uri(serverBaseUri, $"players/{playerId}/cheatStatus");
				ByteArrayContent content = new ByteArrayContent(array);
				try
				{
					((HttpContent)content).Headers.ContentType = new MediaTypeHeaderValue("application/json")
					{
						CharSet = Encoding.UTF8.WebName
					};
					HttpResponseMessage val = await httpClient.PostAsync(uri, (HttpContent)(object)content).ConfigureAwait(continueOnCapturedContext: false);
					if (!val.IsSuccessStatusCode)
					{
						logWarning($"OdinEye server rejected cheat-status submission: {(int)val.StatusCode} {val.ReasonPhrase}");
					}
				}
				finally
				{
					((IDisposable)content)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				logWarning("Failed to submit cheat status to OdinEye server: " + ex.Message);
			}
		}

		public void Dispose()
		{
			((HttpMessageInvoker)httpClient).Dispose();
		}
	}
	public sealed class HttpStatsSubmitter : IStatsSubmitter, IDisposable
	{
		private readonly HttpClient httpClient;

		private readonly Uri serverBaseUri;

		private readonly Action<string> logWarning;

		public HttpStatsSubmitter(Uri serverBaseUri, Action<string> logWarning)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			this.serverBaseUri = serverBaseUri ?? throw new ArgumentNullException("serverBaseUri");
			this.logWarning = logWarning ?? throw new ArgumentNullException("logWarning");
			httpClient = new HttpClient();
		}

		public async void Submit(Guid playerId, CharacterStatsSubmission submission, Action<bool> onComplete = null)
		{
			bool accepted = false;
			try
			{
				byte[] array = JsonSerializer.Serialize<CharacterStatsSubmission>(submission);
				Uri uri = new Uri(serverBaseUri, $"players/{playerId}/stats");
				ByteArrayContent content = new ByteArrayContent(array);
				try
				{
					((HttpContent)content).Headers.ContentType = new MediaTypeHeaderValue("application/json")
					{
						CharSet = Encoding.UTF8.WebName
					};
					HttpResponseMessage val = await httpClient.PostAsync(uri, (HttpContent)(object)content).ConfigureAwait(continueOnCapturedContext: false);
					accepted = val.IsSuccessStatusCode;
					if (!accepted)
					{
						logWarning($"OdinEye server rejected character-stats submission: {(int)val.StatusCode} {val.ReasonPhrase}");
					}
				}
				finally
				{
					((IDisposable)content)?.Dispose();
				}
			}
			catch (Exception ex)
			{
				logWarning("Failed to submit character stats to OdinEye server: " + ex.Message);
			}
			try
			{
				onComplete?.Invoke(accepted);
			}
			catch
			{
			}
		}

		public void Dispose()
		{
			((HttpMessageInvoker)httpClient).Dispose();
		}
	}
	public interface ICheatStatusSubmitter
	{
		void Submit(Guid playerId, bool cheated, bool bypassEnabled);
	}
	public interface IStatsSubmitter
	{
		void Submit(Guid playerId, CharacterStatsSubmission submission, Action<bool> onComplete = null);
	}
	public sealed class SubmissionScheduler
	{
		private readonly TimeSpan interval;

		private DateTime? nextSubmissionAtUtc;

		public SubmissionScheduler(TimeSpan interval)
		{
			if (interval <= TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("interval", "Submission interval must be positive.");
			}
			this.interval = interval;
		}

		public void OnLogin(DateTime nowUtc)
		{
			nextSubmissionAtUtc = nowUtc + interval;
		}

		public bool IsDue(DateTime nowUtc)
		{
			if (nextSubmissionAtUtc.HasValue)
			{
				DateTime? dateTime = nextSubmissionAtUtc;
				if (!(nowUtc < dateTime))
				{
					nextSubmissionAtUtc = nowUtc + interval;
					return true;
				}
			}
			return false;
		}
	}
}
namespace OdinEye.Client.Stats
{
	public static class PieceStats
	{
		public const string PiecePlacedPrefix = "PiecePlaced:";

		public const string StationTotalKey = "Derived:StationOrUpgradePlaced";

		public static Dictionary<string, float> Prefix(IEnumerable<KeyValuePair<string, float>> placed)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			foreach (KeyValuePair<string, float> item in placed ?? Enumerable.Empty<KeyValuePair<string, float>>())
			{
				if (!string.IsNullOrEmpty(item.Key) && !float.IsNaN(item.Value) && !float.IsInfinity(item.Value) && item.Value >= 0f)
				{
					dictionary["PiecePlaced:" + item.Key] = item.Value;
				}
			}
			return dictionary;
		}

		public static float StationTotal(IEnumerable<KeyValuePair<string, float>> placed, ISet<string> stationNames)
		{
			if (placed == null || stationNames == null || stationNames.Count == 0)
			{
				return 0f;
			}
			return placed.Where((KeyValuePair<string, float> kv) => stationNames.Contains(kv.Key) && !float.IsNaN(kv.Value) && !float.IsInfinity(kv.Value) && kv.Value > 0f).Sum((KeyValuePair<string, float> kv) => kv.Value);
		}
	}
	public static class StatsChange
	{
		public static bool HasChanged(IReadOnlyDictionary<string, float> previous, IReadOnlyDictionary<string, float> current)
		{
			if (current == null)
			{
				return false;
			}
			if (previous == null || previous.Count != current.Count)
			{
				return true;
			}
			foreach (KeyValuePair<string, float> item in current)
			{
				if (!previous.TryGetValue(item.Key, out var value) || value != item.Value)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class BoatTracking
	{
		public static bool IsOnBoat()
		{
			return (Object)(object)Ship.GetLocalShip() != (Object)null;
		}
	}
	public sealed class CounterAugmentedStatsSource : IPlayerStatsSource
	{
		private static readonly TimeSpan MaxPlausibleBoatGap = TimeSpan.FromMinutes(5.0);

		private static readonly TimeSpan MaxPlausibleSwampGap = TimeSpan.FromMinutes(5.0);

		private static readonly TimeSpan MaxPlausibleBakeryGap = TimeSpan.FromMinutes(5.0);

		private readonly IPlayerStatsSource inner;

		private readonly CustomCounterStore store;

		private readonly Func<ISet<string>> stationNames;

		private readonly Func<float?> currentNorthZ;

		private readonly Func<bool> isInDeepNorth;

		private readonly Func<bool> isOnBoat;

		private readonly Func<bool> isInSwamp;

		private readonly Func<bool> isNearOven;

		private readonly Func<DateTime> nowUtc;

		private DateTime? lastBoatSampleUtc;

		private DateTime? lastSwampSampleUtc;

		private DateTime? lastBakerySampleUtc;

		public CounterAugmentedStatsSource(IPlayerStatsSource inner, CustomCounterStore store, Func<ISet<string>> stationNames, Func<float?> currentNorthZ = null, Func<bool> isInDeepNorth = null, Func<bool> isOnBoat = null, Func<bool> isInSwamp = null, Func<bool> isNearOven = null, Func<DateTime> nowUtc = null)
		{
			this.inner = inner ?? throw new ArgumentNullException("inner");
			this.store = store ?? throw new ArgumentNullException("store");
			this.stationNames = stationNames ?? ((Func<ISet<string>>)(() => (ISet<string>)null));
			this.currentNorthZ = currentNorthZ ?? ((Func<float?>)(() => (float?)null));
			this.isInDeepNorth = isInDeepNorth ?? ((Func<bool>)(() => false));
			this.isOnBoat = isOnBoat ?? ((Func<bool>)(() => false));
			this.isInSwamp = isInSwamp ?? ((Func<bool>)(() => false));
			this.isNearOven = isNearOven ?? ((Func<bool>)(() => false));
			this.nowUtc = nowUtc ?? ((Func<DateTime>)(() => DateTime.UtcNow));
		}

		public IReadOnlyDictionary<string, float> GetStats()
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			foreach (KeyValuePair<string, float> stat in inner.GetStats())
			{
				dictionary[stat.Key] = stat.Value;
			}
			if (dictionary.Count == 0)
			{
				return dictionary;
			}
			float num = PieceStats.StationTotal(from kv in dictionary
				where kv.Key.StartsWith("PiecePlaced:", StringComparison.Ordinal)
				select new KeyValuePair<string, float>(kv.Key.Substring("PiecePlaced:".Length), kv.Value), stationNames());
			if (num > 0f)
			{
				store.RaiseTo("Derived:StationOrUpgradePlaced", num);
			}
			float? num2 = currentNorthZ();
			if (num2.HasValue)
			{
				store.RaiseTo("Derived:FurthestNorthZ", CounterRules.NorthDistanceToRaise(num2.Value));
			}
			if (isInDeepNorth())
			{
				store.RaiseTo("Custom:ReachedDeepNorth", 1f);
			}
			DateTime dateTime = nowUtc();
			if (lastBoatSampleUtc.HasValue)
			{
				float elapsedSeconds = (float)(dateTime - lastBoatSampleUtc.Value).TotalSeconds;
				bool num3 = isOnBoat();
				TimeSpan maxPlausibleBoatGap = MaxPlausibleBoatGap;
				float num4 = CounterRules.BoatSecondsToAdd(num3, elapsedSeconds, (float)maxPlausibleBoatGap.TotalSeconds);
				if (num4 > 0f)
				{
					store.Increment("Custom:TimeOnBoatSeconds", num4);
				}
			}
			lastBoatSampleUtc = dateTime;
			if (lastSwampSampleUtc.HasValue)
			{
				float elapsedSeconds2 = (float)(dateTime - lastSwampSampleUtc.Value).TotalSeconds;
				bool num5 = isInSwamp();
				TimeSpan maxPlausibleBoatGap = MaxPlausibleSwampGap;
				float num6 = CounterRules.SwampSecondsToAdd(num5, elapsedSeconds2, (float)maxPlausibleBoatGap.TotalSeconds);
				if (num6 > 0f)
				{
					store.Increment("Custom:TimeInSwampSeconds", num6);
				}
			}
			lastSwampSampleUtc = dateTime;
			if (lastBakerySampleUtc.HasValue)
			{
				float elapsedSeconds3 = (float)(dateTime - lastBakerySampleUtc.Value).TotalSeconds;
				bool num7 = isNearOven();
				TimeSpan maxPlausibleBoatGap = MaxPlausibleBakeryGap;
				float num8 = CounterRules.BakerySecondsToAdd(num7, elapsedSeconds3, (float)maxPlausibleBoatGap.TotalSeconds);
				if (num8 > 0f)
				{
					store.Increment("Custom:TimeInBakerySeconds", num8);
				}
			}
			lastBakerySampleUtc = dateTime;
			foreach (KeyValuePair<string, float> item in store.Snapshot())
			{
				dictionary[item.Key] = item.Value;
			}
			return dictionary;
		}
	}
	public static class NorthTracking
	{
		public static float? CurrentNorthZ()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Player.m_localPlayer != (Object)null))
			{
				return null;
			}
			return ((Component)Player.m_localPlayer).transform.position.z;
		}

		public static bool IsInDeepNorth()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				return (int)Player.m_localPlayer.GetCurrentBiome() == 64;
			}
			return false;
		}
	}
	public sealed class OutpostAnchorStore
	{
		private readonly object gate = new object();

		private readonly string path;

		private readonly Action<string> logWarning;

		private readonly List<float[]> anchors = new List<float[]>();

		private bool dirty;

		public IReadOnlyList<(float X, float Z)> Anchors
		{
			get
			{
				lock (gate)
				{
					(float, float)[] array = new(float, float)[anchors.Count];
					for (int i = 0; i < anchors.Count; i++)
					{
						array[i] = (anchors[i][0], anchors[i][1]);
					}
					return array;
				}
			}
		}

		public OutpostAnchorStore(string path, Action<string> logWarning = null)
		{
			this.path = path ?? throw new ArgumentNullException("path");
			this.logWarning = logWarning ?? ((Action<string>)delegate
			{
			});
			Load();
		}

		public void Add(float x, float z)
		{
			if (float.IsNaN(x) || float.IsInfinity(x) || float.IsNaN(z) || float.IsInfinity(z))
			{
				return;
			}
			lock (gate)
			{
				anchors.Add(new float[2] { x, z });
				dirty = true;
			}
		}

		public bool Flush()
		{
			byte[] bytes;
			lock (gate)
			{
				if (!dirty)
				{
					return true;
				}
				bytes = JsonSerializer.Serialize<List<float[]>>(anchors);
			}
			try
			{
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrEmpty(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				string sourceFileName = path + ".tmp";
				File.WriteAllBytes(sourceFileName, bytes);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
				File.Move(sourceFileName, path);
				lock (gate)
				{
					dirty = false;
				}
				return true;
			}
			catch (Exception ex)
			{
				logWarning("OdinEye client: could not save outpost anchors to '" + path + "': " + ex.Message);
				return false;
			}
		}

		private void Load()
		{
			string sourceFileName = path + ".tmp";
			try
			{
				if (!File.Exists(path) && File.Exists(sourceFileName))
				{
					File.Move(sourceFileName, path);
				}
				if (!File.Exists(path))
				{
					return;
				}
				foreach (float[] item in JsonSerializer.Deserialize<List<float[]>>(File.ReadAllBytes(path)) ?? throw new InvalidDataException("outpost anchor file was empty"))
				{
					if (item != null && item.Length == 2 && !float.IsNaN(item[0]) && !float.IsNaN(item[1]))
					{
						anchors.Add(item);
					}
				}
			}
			catch (Exception ex)
			{
				logWarning("OdinEye client: outpost anchor file '" + path + "' was unreadable (" + ex.Message + "); starting fresh");
				try
				{
					string destFileName = path + ".bad";
					if (File.Exists(destFileName))
					{
						File.Delete(destFileName);
					}
					File.Move(path, destFileName);
				}
				catch
				{
				}
				anchors.Clear();
			}
		}
	}
	public static class OutpostTracking
	{
		public const float OutpostRadius = 15f;

		private const int OceanSampleSteps = 20;

		private static readonly MethodInfo GetOwner = AccessTools.Method(typeof(Bed), "GetOwner", (Type[])null, (Type[])null);

		private static bool Available => GetOwner != null;

		public static void Scan(OutpostAnchorStore anchors)
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (!Available || anchors == null || (Object)(object)Player.m_localPlayer == (Object)null || ClientRuntime.Counters == null)
			{
				return;
			}
			long num = ClientRuntime.LocalPlayerId();
			if (num == 0L)
			{
				return;
			}
			List<Piece> list = new List<Piece>();
			Bed[] array = Object.FindObjectsByType<Bed>((FindObjectsSortMode)0);
			foreach (Bed val in array)
			{
				if (!((Object)(object)val == (Object)null) && (long)GetOwner.Invoke(val, null) == num)
				{
					Vector3 pos = val.GetSpawnPoint();
					list.Clear();
					Piece.GetAllPiecesInRadius(pos, 15f, list);
					bool hasCraftingStationNearby = list.Any((Piece p) => (Object)(object)p != (Object)null && (Object)(object)((Component)p).GetComponent<CraftingStation>() != (Object)null);
					bool hasPortalNearby = list.Any((Piece p) => (Object)(object)p != (Object)null && (Object)(object)((Component)p).GetComponent<TeleportWorld>() != (Object)null);
					if (CounterRules.IsQualifyingOutpost(Cover.IsUnderRoof(pos), hasCraftingStationNearby, hasPortalNearby) && CounterRules.IsNewLandmass(anchors.Anchors.Select(((float X, float Z) a) => CrossesOcean(pos, a.X, a.Z))))
					{
						anchors.Add(pos.x, pos.z);
						ClientRuntime.Counters.Increment("Custom:OutpostLandmasses");
					}
				}
			}
		}

		private static bool CrossesOcean(Vector3 from, float toX, float toZ)
		{
			//IL_000c: 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_0026: 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_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_003c: Invalid comparison between Unknown and I4
			if (WorldGenerator.instance == null)
			{
				return false;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(toX, from.y, toZ);
			for (int i = 0; i <= 20; i++)
			{
				Vector3 val2 = Vector3.Lerp(from, val, (float)i / 20f);
				if ((int)WorldGenerator.instance.GetBiome(val2) == 256)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class OvenTracking
	{
		public const float OvenRadius = 10f;

		public const string OvenPieceName = "piece_oven";

		private static readonly List<Piece> nearby = new List<Piece>();

		public static bool IsNearOven()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return false;
			}
			nearby.Clear();
			Piece.GetAllPiecesInRadius(((Component)Player.m_localPlayer).transform.position, 10f, nearby);
			return nearby.Any((Piece p) => (Object)(object)p != (Object)null && Utils.GetPrefabName(((Component)p).gameObject) == "piece_oven");
		}
	}
	public static class StationNames
	{
		private static HashSet<string> cached;

		public static ISet<string> Get()
		{
			if (cached != null)
			{
				return cached;
			}
			ZNetScene instance = ZNetScene.instance;
			if ((Object)(object)instance == (Object)null || instance.m_prefabs == null || instance.m_prefabs.Count == 0)
			{
				return null;
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (GameObject prefab in instance.m_prefabs)
			{
				if (!((Object)(object)prefab == (Object)null))
				{
					Piece component = prefab.GetComponent<Piece>();
					if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.m_name) && ((Object)(object)prefab.GetComponent<CraftingStation>() != (Object)null || (Object)(object)prefab.GetComponent<StationExtension>() != (Object)null))
					{
						hashSet.Add(component.m_name);
					}
				}
			}
			if (hashSet.Count > 0)
			{
				cached = hashSet;
			}
			if (hashSet.Count <= 0)
			{
				return null;
			}
			return hashSet;
		}
	}
	public static class SwampTracking
	{
		public static bool IsInSwamp()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				return (int)Player.m_localPlayer.GetCurrentBiome() == 2;
			}
			return false;
		}
	}
	public static class CharacterStatsPayloadBuilder
	{
		public static CharacterStatsSubmission Build(IReadOnlyDictionary<string, float> rawStats, SubmissionMeta meta = null)
		{
			//IL_0077: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (rawStats == null)
			{
				throw new ArgumentNullException("rawStats");
			}
			Dictionary<string, float> stats = rawStats.Where((KeyValuePair<string, float> stat) => IsValidStatValue(stat.Value)).ToDictionary((KeyValuePair<string, float> stat) => stat.Key, (KeyValuePair<string, float> stat) => stat.Value);
			return new CharacterStatsSubmission
			{
				Stats = stats,
				Meta = meta
			};
		}

		private static bool IsValidStatValue(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return value >= 0f;
			}
			return false;
		}
	}
	public interface IPlayerStatsSource
	{
		IReadOnlyDictionary<string, float> GetStats();
	}
	public static class CheatBypassReader
	{
		private const string BypassKey = "bypasscheatchecks";

		public static bool IsEnabled()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			string text = default(string);
			if (localPlayer.TryGetUniqueKeyValue("bypasscheatchecks", ref text))
			{
				return text == "1";
			}
			return false;
		}
	}
	public static class CheatStatusReader
	{
		private static readonly Lazy<MethodInfo> IsCheatedAtAllMethod = new Lazy<MethodInfo>(() => typeof(PlayerProfile).Assembly.GetType("Achievements")?.GetMethod("IsCheatedAtAll", BindingFlags.Static | BindingFlags.Public));

		public static bool? IsCheated()
		{
			MethodInfo value = IsCheatedAtAllMethod.Value;
			if (value == null)
			{
				return null;
			}
			try
			{
				return (bool)value.Invoke(null, null);
			}
			catch
			{
				return null;
			}
		}
	}
	public sealed class PlayerProfileStatsSource : IPlayerStatsSource
	{
		public const string PlayTimeSecondsKey = "PlayTimeSeconds";

		public const string KnownWorldsCountKey = "KnownWorldsCount";

		public const string EnemyKillKeyPrefix = "EnemyKill:";

		private const int RawStatsIndex = 0;

		private static object GetFieldValue(object target, string fieldName)
		{
			return target?.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public)?.GetValue(target);
		}

		private static object GetRawPlayerStats(object profile)
		{
			if (!(GetFieldValue(profile, "m_playerStats") is Array { Length: >0 } array))
			{
				return null;
			}
			return array.GetValue(0);
		}

		public IReadOnlyDictionary<string, float> GetStats()
		{
			Game instance = Game.instance;
			PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
			if (val == null)
			{
				return new Dictionary<string, float>();
			}
			Dictionary<string, float> dictionary = new Dictionary<string, float>();
			object rawPlayerStats = GetRawPlayerStats(val);
			if (GetFieldValue(rawPlayerStats, "m_stats") is IDictionary dictionary2)
			{
				foreach (DictionaryEntry item in dictionary2)
				{
					dictionary[item.Key.ToString()] = Convert.ToSingle(item.Value);
				}
			}
			float num = 0f;
			int num2 = 0;
			if (GetFieldValue(rawPlayerStats, "m_knownWorlds") is IDictionary dictionary3)
			{
				num2 = dictionary3.Count;
				foreach (object value in dictionary3.Values)
				{
					num += Convert.ToSingle(value);
				}
			}
			dictionary["PlayTimeSeconds"] = num;
			dictionary["KnownWorldsCount"] = num2;
			if (GetFieldValue(rawPlayerStats, "m_enemyStats") is Array { Length: >0 } array && array.GetValue(0) is IDictionary dictionary4)
			{
				foreach (DictionaryEntry item2 in dictionary4)
				{
					dictionary["EnemyKill:" + item2.Key] = Convert.ToSingle(item2.Value);
				}
			}
			if (GetFieldValue(rawPlayerStats, "m_piecesPlacedStats") is IDictionary dictionary5)
			{
				Dictionary<string, float> dictionary6 = new Dictionary<string, float>();
				foreach (DictionaryEntry item3 in dictionary5)
				{
					dictionary6[item3.Key.ToString()] = Convert.ToSingle(item3.Value);
				}
				foreach (KeyValuePair<string, float> item4 in PieceStats.Prefix(dictionary6))
				{
					dictionary[item4.Key] = item4.Value;
				}
			}
			return dictionary;
		}
	}
}
namespace OdinEye.Client.Counters
{
	public sealed class CustomCounterStore
	{
		public static readonly string[] SeedablePrefixes = new string[2] { "Custom:", "Derived:" };

		private readonly object gate = new object();

		private readonly string path;

		private readonly Action<string> logWarning;

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

		private bool dirty;

		public bool IsDirty
		{
			get
			{
				lock (gate)
				{
					return dirty;
				}
			}
		}

		public CustomCounterStore(string path, Action<string> logWarning = null)
		{
			this.path = path ?? throw new ArgumentNullException("path");
			this.logWarning = logWarning ?? ((Action<string>)delegate
			{
			});
			Load();
		}

		public void Increment(string key, float amount = 1f)
		{
			if (string.IsNullOrEmpty(key) || float.IsNaN(amount) || float.IsInfinity(amount) || amount <= 0f)
			{
				return;
			}
			lock (gate)
			{
				values.TryGetValue(key, out var value);
				values[key] = value + amount;
				dirty = true;
			}
		}

		public float Get(string key)
		{
			lock (gate)
			{
				float value;
				return values.TryGetValue(key, out value) ? value : 0f;
			}
		}

		public IReadOnlyDictionary<string, float> Snapshot()
		{
			lock (gate)
			{
				return new Dictionary<string, float>(values);
			}
		}

		public float RaiseTo(string key, float value)
		{
			if (string.IsNullOrEmpty(key) || float.IsNaN(value) || float.IsInfinity(value) || value < 0f)
			{
				return Get(key);
			}
			lock (gate)
			{
				values.TryGetValue(key, out var value2);
				if (value > value2 || !values.ContainsKey(key))
				{
					values[key] = Math.Max(value, value2);
					dirty = true;
				}
				return values[key];
			}
		}

		public void SeedFrom(IEnumerable<KeyValuePair<string, float>> serverValues)
		{
			if (serverValues == null)
			{
				return;
			}
			lock (gate)
			{
				foreach (KeyValuePair<string, float> kv in serverValues)
				{
					if (SeedablePrefixes.Any((string p) => kv.Key != null && kv.Key.StartsWith(p, StringComparison.Ordinal)) && !float.IsNaN(kv.Value) && !float.IsInfinity(kv.Value) && !(kv.Value < 0f))
					{
						values.TryGetValue(kv.Key, out var value);
						if (kv.Value > value)
						{
							values[kv.Key] = kv.Value;
							dirty = true;
						}
					}
				}
			}
		}

		public bool Flush()
		{
			byte[] bytes;
			lock (gate)
			{
				if (!dirty)
				{
					return true;
				}
				bytes = JsonSerializer.Serialize<Dictionary<string, float>>(values);
			}
			try
			{
				string directoryName = Path.GetDirectoryName(path);
				if (!string.IsNullOrEmpty(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				string sourceFileName = path + ".tmp";
				File.WriteAllBytes(sourceFileName, bytes);
				if (File.Exists(path))
				{
					File.Delete(path);
				}
				File.Move(sourceFileName, path);
				lock (gate)
				{
					dirty = false;
				}
				return true;
			}
			catch (Exception ex)
			{
				logWarning("OdinEye client: could not save counters to '" + path + "': " + ex.Message);
				return false;
			}
		}

		private void Load()
		{
			string sourceFileName = path + ".tmp";
			try
			{
				if (!File.Exists(path) && File.Exists(sourceFileName))
				{
					File.Move(sourceFileName, path);
				}
				if (!File.Exists(path))
				{
					return;
				}
				foreach (KeyValuePair<string, float> item in JsonSerializer.Deserialize<Dictionary<string, float>>(File.ReadAllBytes(path)) ?? throw new InvalidDataException("counter file was empty"))
				{
					if (!float.IsNaN(item.Value) && !float.IsInfinity(item.Value) && item.Value >= 0f)
					{
						values[item.Key] = item.Value;
					}
				}
			}
			catch (Exception ex)
			{
				logWarning("OdinEye client: counter file '" + path + "' was unreadable (" + ex.Message + "); starting fresh and keeping the old one as .bad");
				try
				{
					string destFileName = path + ".bad";
					if (File.Exists(destFileName))
					{
						File.Delete(destFileName);
					}
					File.Move(path, destFileName);
				}
				catch
				{
				}
				values.Clear();
			}
		}
	}
	public static class CounterRules
	{
		public const string ArrowHitsEnemyKey = "Custom:ArrowHitsEnemy";

		public const string BreadCollectedKey = "Custom:BreadCollected";

		public const string DwarfEyesTouchedKey = "Custom:DwarfEyesTouched";

		public const string FoodBurntToCoalKey = "Custom:FoodBurntToCoal";

		public const string TimeOnBoatSecondsKey = "Custom:TimeOnBoatSeconds";

		public const string VomitBombsKey = "Custom:VomitBombs";

		public const string FistKillsKey = "Custom:FistKills";

		public const string SwordKillsKey = "Custom:SwordKills";

		public const string ChickenMeatCookedKey = "Custom:ChickenMeatCooked";

		public const string LoxPiesCookedKey = "Custom:LoxPiesCooked";

		public const string MeadsMadeKey = "Custom:MeadsMade";

		public const string OutpostLandmassesKey = "Custom:OutpostLandmasses";

		public const string PoisonDeathsKey = "Custom:PoisonDeaths";

		public const string LeechHitsKey = "Custom:LeechHits";

		public const string GuckCollectedKey = "Custom:GuckCollected";

		public const string BloodBagsCollectedKey = "Custom:BloodBagsCollected";

		public const string MuddyScrapPilesOpenedKey = "Custom:MuddyScrapPilesOpened";

		public const string ElderBarkCollectedKey = "Custom:ElderBarkCollected";

		public const string IronProcessedKey = "Custom:IronProcessed";

		public const string TimeInSwampSecondsKey = "Custom:TimeInSwampSeconds";

		public const string WoodCollectedKey = "Custom:WoodCollected";

		public const string BedsDestroyedKey = "Custom:BedsDestroyed";

		public const string StoneCollectedKey = "Custom:StoneCollected";

		public const string TimeInBakerySecondsKey = "Custom:TimeInBakerySeconds";

		public const string ResinHandledKey = "Custom:ResinHandled";

		public const string TamedBoarKey = "Custom:TamedBoar";

		public const string TamedWolfKey = "Custom:TamedWolf";

		public const string TamedLoxKey = "Custom:TamedLox";

		public const string FurthestNorthZKey = "Derived:FurthestNorthZ";

		public const string ReachedDeepNorthKey = "Custom:ReachedDeepNorth";

		public const string BreadItemName = "Bread";

		public const string DwarfEyeItemName = "GreydwarfEye";

		public const string VomitBombItemName = "Pukeberries";

		public const string CookedChickenItemName = "CookedChickenMeat";

		public const string LoxMeatPieItemName = "LoxMeatPie";

		public const string GuckItemName = "Guck";

		public const string BloodBagItemName = "Bloodbag";

		public const string ElderBarkItemName = "ElderBark";

		public static readonly HashSet<string> LeechPrefabNames = new HashSet<string> { "Leech", "Leech_cave" };

		public static readonly HashSet<string> MudPilePrefabNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "MudPile", "MudPile2" };

		public const string IronScrapItemName = "IronScrap";

		public static readonly HashSet<string> WoodItemNames = new HashSet<string> { "Wood", "RoundLog", "FineWood", "Blackwood", "Frostwood", "YggdrasilWood" };

		public static readonly HashSet<string> StoneItemNames = new HashSet<string> { "Stone", "Flint" };

		public const string ResinItemName = "Resin";

		public static bool CountsAsArrowHitOnEnemy(bool firedByLocalPlayer, string skillName, bool targetIsCharacter, bool targetIsPlayer, bool targetIsTamed, bool targetIsDead)
		{
			if (firedByLocalPlayer && skillName == "Bows" && targetIsCharacter && !targetIsPlayer && !targetIsTamed)
			{
				return !targetIsDead;
			}
			return false;
		}

		public static int BreadToCount(bool itemIsDone, string producedItemName, int amountTaken)
		{
			if (!itemIsDone || !(producedItemName == "Bread") || amountTaken <= 0)
			{
				return 0;
			}
			return amountTaken;
		}

		public static int FoodBurntToCoal(bool isBurntStatus, int amountTaken)
		{
			if (!isBurntStatus || amountTaken <= 0)
			{
				return 0;
			}
			return amountTaken;
		}

		public static int CookedChickenMeatToCount(bool itemIsDone, string producedItemName, int amountTaken)
		{
			if (!itemIsDone || !(producedItemName == "CookedChickenMeat") || amountTaken <= 0)
			{
				return 0;
			}
			return amountTaken;
		}

		public static int LoxPieToCount(bool itemIsDone, string producedItemName, int amountTaken)
		{
			if (!itemIsDone || !(producedItemName == "LoxMeatPie") || amountTaken <= 0)
			{
				return 0;
			}
			return amountTaken;
		}

		public static string TamedSpeciesCounterKey(string prefabName)
		{
			return prefabName switch
			{
				"Boar" => "Custom:TamedBoar", 
				"Wolf" => "Custom:TamedWolf", 
				"Lox" => "Custom:TamedLox", 
				_ => null, 
			};
		}

		public static int MeadsToCount(bool statusIsReady, int producedItems)
		{
			if (!statusIsReady || producedItems <= 0)
			{
				return 0;
			}
			return producedItems;
		}

		public static int DwarfEyesToCount(bool byLocalPlayer, bool pickupSucceeded, string itemSharedName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || !(itemSharedName == "GreydwarfEye") || stack <= 0)
			{
				return 0;
			}
			return stack;
		}

		public static float NorthDistanceToRaise(float positionZ)
		{
			if (!(positionZ > 0f))
			{
				return 0f;
			}
			return positionZ;
		}

		public static float BoatSecondsToAdd(bool isOnBoat, float elapsedSeconds, float maxPlausibleGapSeconds)
		{
			if (!isOnBoat || !(elapsedSeconds > 0f) || !(elapsedSeconds <= maxPlausibleGapSeconds))
			{
				return 0f;
			}
			return elapsedSeconds;
		}

		public static bool CountsAsVomitBomb(bool eatenSuccessfully, string itemSharedName, int activeFoodCountBeforeEating)
		{
			if (eatenSuccessfully && itemSharedName == "Pukeberries")
			{
				return activeFoodCountBeforeEating == 0;
			}
			return false;
		}

		public static bool IsQualifyingOutpost(bool bedIsCovered, bool hasCraftingStationNearby, bool hasPortalNearby)
		{
			return bedIsCovered && hasCraftingStationNearby && hasPortalNearby;
		}

		public static bool IsNewLandmass(IEnumerable<bool> oceanSeparatedFromEachKnownLandmass)
		{
			return oceanSeparatedFromEachKnownLandmass.All((bool separated) => separated);
		}

		public static bool CountsAsWeaponKill(bool byLocalPlayer, string skillName, string wantSkillName, bool targetIsCharacter, bool targetIsPlayer, bool targetIsTamed, bool targetIsDeadNow)
		{
			return byLocalPlayer && skillName == wantSkillName && targetIsCharacter && !targetIsPlayer && !targetIsTamed && targetIsDeadNow;
		}

		public static bool CountsAsPoisonDeath(bool targetIsLocalPlayer, bool targetIsDeadNow, float poisonDamageInHit)
		{
			if (targetIsLocalPlayer && targetIsDeadNow)
			{
				return poisonDamageInHit > 0f;
			}
			return false;
		}

		public static bool CountsAsLeechHit(bool targetIsLocalPlayer, string attackerPrefabName)
		{
			if (targetIsLocalPlayer && attackerPrefabName != null)
			{
				return LeechPrefabNames.Contains(attackerPrefabName);
			}
			return false;
		}

		public static int GuckToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || !(itemPrefabName == "Guck") || stack <= 0)
			{
				return 0;
			}
			return stack;
		}

		public static int BloodBagToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || !(itemPrefabName == "Bloodbag") || stack <= 0)
			{
				return 0;
			}
			return stack;
		}

		public static int ElderBarkToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || !(itemPrefabName == "ElderBark") || stack <= 0)
			{
				return 0;
			}
			return stack;
		}

		public static bool CountsAsMuddyScrapPileOpened(bool byLocalPlayer, bool nowFullyDestroyed, string prefabName)
		{
			if (byLocalPlayer && nowFullyDestroyed && prefabName != null)
			{
				return MudPilePrefabNames.Contains(prefabName);
			}
			return false;
		}

		public static int IronToProcess(string queuedOreName, int queuedAmount)
		{
			if (!(queuedOreName == "IronScrap") || queuedAmount <= 0)
			{
				return 0;
			}
			return queuedAmount;
		}

		public static float SwampSecondsToAdd(bool isInSwamp, float elapsedSeconds, float maxPlausibleGapSeconds)
		{
			if (!isInSwamp || !(elapsedSeconds > 0f) || !(elapsedSeconds <= maxPlausibleGapSeconds))
			{
				return 0f;
			}
			return elapsedSeconds;
		}

		public static int WoodToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || stack <= 0 || itemPrefabName == null || !WoodItemNames.Contains(itemPrefabName))
			{
				return 0;
			}
			return stack;
		}

		public static int StoneToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || stack <= 0 || itemPrefabName == null || !StoneItemNames.Contains(itemPrefabName))
			{
				return 0;
			}
			return stack;
		}

		public static float BakerySecondsToAdd(bool isNearOven, float elapsedSeconds, float maxPlausibleGapSeconds)
		{
			if (!isNearOven || !(elapsedSeconds > 0f) || !(elapsedSeconds <= maxPlausibleGapSeconds))
			{
				return 0f;
			}
			return elapsedSeconds;
		}

		public static int ResinToCount(bool byLocalPlayer, bool pickupSucceeded, string itemPrefabName, int stack)
		{
			if (!(byLocalPlayer && pickupSucceeded) || !(itemPrefabName == "Resin") || stack <= 0)
			{
				return 0;
			}
			return stack;
		}
	}
}
namespace OdinEye.Client.Hud
{
	public sealed class ClockHudElement
	{
		private static readonly Lazy<PropertyInfo> TmpTextProperty = new Lazy<PropertyInfo>(() => AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name == "Unity.TextMeshPro")?.GetType("TMPro.TMP_Text")?.GetProperty("text"));

		private static readonly FieldInfo BiomeNameSmallField = typeof(Minimap).GetField("m_biomeNameSmall", BindingFlags.Instance | BindingFlags.Public);

		private Component clockLabel;

		private bool triedToCreate;

		private Minimap ownerMinimap;

		public void SetText(string text)
		{
			Component val = EnsureCreated();
			PropertyInfo value = TmpTextProperty.Value;
			if ((Object)(object)val == (Object)null || value == null)
			{
				return;
			}
			try
			{
				value.SetValue(val, text);
			}
			catch
			{
			}
		}

		private Component EnsureCreated()
		{
			//IL_00b9: 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)
			if ((Object)(object)Minimap.instance != (Object)(object)ownerMinimap)
			{
				ownerMinimap = Minimap.instance;
				clockLabel = null;
				triedToCreate = false;
			}
			if ((Object)(object)clockLabel != (Object)null || triedToCreate || (Object)(object)Minimap.instance == (Object)null || BiomeNameSmallField == null)
			{
				return clockLabel;
			}
			triedToCreate = true;
			try
			{
				object? value = BiomeNameSmallField.GetValue(Minimap.instance);
				Component val = (Component)((value is Component) ? value : null);
				if (val == null)
				{
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val.gameObject, val.transform.parent);
				((Object)val2).name = "OdinEyeClockText";
				RectTransform component = val2.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.anchoredPosition += new Vector2(0f, -30f);
				}
				clockLabel = val2.GetComponent(((object)val).GetType());
			}
			catch
			{
				clockLabel = null;
			}
			return clockLabel;
		}
	}
	public static class EnvManTimeReader
	{
		private static readonly Lazy<FieldInfo> TotalSecondsField = new Lazy<FieldInfo>(() => typeof(EnvMan).GetField("m_totalSeconds", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));

		public static double? GetTotalSeconds()
		{
			EnvMan instance = EnvMan.instance;
			FieldInfo value = TotalSecondsField.Value;
			if ((Object)(object)instance == (Object)null || value == null)
			{
				return null;
			}
			try
			{
				return (double)value.GetValue(instance);
			}
			catch
			{
				return null;
			}
		}
	}
	public static class TemporalClock
	{
		private const double DayLengthSeconds = 1800.0;

		private const double DawnPhaseOffset = 270.0;

		private const double DaylightSeconds = 1260.0;

		private const double NightSeconds = 540.0;

		public static string Format(double totalSeconds)
		{
			double num = Mod(Mod(totalSeconds, 1800.0) - 270.0, 1800.0);
			double num2 = Mod((num < 1260.0) ? (6.0 + num / 1260.0 * 12.0) : (18.0 + (num - 1260.0) / 540.0 * 12.0), 24.0);
			int num3 = (int)num2;
			int num4 = (int)Math.Round((num2 - (double)num3) * 60.0);
			if (num4 == 60)
			{
				num4 = 0;
				num3 = (num3 + 1) % 24;
			}
			string arg = ((num3 < 12) ? "AM" : "PM");
			int num5 = num3 % 12;
			if (num5 == 0)
			{
				num5 = 12;
			}
			return $"{num5}:{num4:D2} {arg}";
		}

		private static double Mod(double value, double modulus)
		{
			double num = value % modulus;
			if (!(num < 0.0))
			{
				return num;
			}
			return num + modulus;
		}
	}
}