using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Management;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using GCValheimStats.Batch;
using GCValheimStats.Collect;
using GCValheimStats.Networking;
using GCValheimStats.Security;
using GCValheimStats.UI;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("GCValheimStats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.1.1")]
[assembly: AssemblyInformationalVersion("2.1.1+63a748d2ad7345c0a2740a861e60cd06b8d90bb1")]
[assembly: AssemblyProduct("GCValheimStats")]
[assembly: AssemblyTitle("GCValheimStats")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.1.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace GCValheimStats
{
	[BepInPlugin("com.gchallenger.valheimstats", "GCValheimStats", "2.1.1")]
	public class GCValheimStatsPlugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<string> <>9__17_1;

			public static Func<long> <>9__17_2;

			public static ConsoleEventFailable <>9__17_3;

			internal string <Awake>b__17_1()
			{
				return SessionManager.SessionId;
			}

			internal long <Awake>b__17_2()
			{
				return SessionManager.SessionStart;
			}

			internal object <Awake>b__17_3(ConsoleEventArgs args)
			{
				KillFeed.Instance.ShowAllIcons();
				return true;
			}
		}

		public static GCValheimStatsPlugin Instance;

		public static ModConfig Config;

		public static StatsTracker StatsTracker;

		public static EventQueue EventQueue;

		public static BatchBuilder BatchBuilder;

		public static BatchSender BatchSender;

		public static BatchTriggers BatchTriggers;

		public static SessionManager SessionManager;

		public static StatsHttpClient HttpClient;

		public static QueueStorage QueueStorage;

		public static MainMenuOverlay MainMenuOverlay;

		private byte[] _aesKey;

		private byte[] _hmacKey;

		private Harmony _harmony;

		private long _steamId;

		private int _updateCount;

		private bool _playerDetected;

		public long SteamId => _steamId;

		private void Awake()
		{
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			Instance = this;
			Config = new ModConfig(((BaseUnityPlugin)this).Config);
			StatsTracker = new StatsTracker();
			string persistentDataPath = Application.persistentDataPath;
			SessionManager = new SessionManager(persistentDataPath);
			SessionManager.StartSession();
			QueueStorage = new QueueStorage(persistentDataPath);
			EventQueue = new EventQueue();
			HttpClient = new StatsHttpClient();
			_steamId = 0L;
			(byte[], byte[]) tuple = GracefulDegradation.SafeDeriveKey(_steamId);
			_aesKey = tuple.Item1;
			_hmacKey = tuple.Item2;
			BatchBuilder = new BatchBuilder(EventQueue, () => _steamId.ToString(), GetWorldSeed, GetWorldName, GetWorldPreset, GetGameMode, GetWorldModifiers, GetIsServer, GetIsDedicated, GetPlayerCount, GetCharacterName, GetCharacterUid, () => SessionManager.SessionId, () => SessionManager.SessionStart);
			BatchSender = new BatchSender(QueueStorage, HttpClient, Config.ApiEndpoint.Value);
			BatchTriggers = new BatchTriggers(EventQueue, BatchBuilder, QueueStorage, BatchSender, SessionManager, HttpClient, Config.ApiEndpoint.Value, _aesKey, _hmacKey);
			GameObject val = new GameObject("StatsOverlay");
			val.AddComponent<StatsOverlay>();
			val.transform.SetParent(((Component)this).transform);
			GameObject val2 = new GameObject("TimerOverlay");
			val2.AddComponent<TimerOverlay>();
			val2.transform.SetParent(((Component)this).transform);
			GameObject val3 = new GameObject("MainMenuOverlay");
			MainMenuOverlay = val3.AddComponent<MainMenuOverlay>();
			MainMenuOverlay.Initialize(QueueStorage, HttpClient, _aesKey, _hmacKey, Config.ApiEndpoint.Value, _steamId.ToString());
			val3.transform.SetParent(((Component)this).transform);
			try
			{
				_harmony = new Harmony("com.gchallenger.valheimstats");
				_harmony.PatchAll(typeof(GCValheimStatsPlugin).Assembly);
				((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Harmony patches applied");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("[GCValheimStats] Harmony patch failed: " + ex.Message));
			}
			object obj = <>c.<>9__17_3;
			if (obj == null)
			{
				ConsoleEventFailable val4 = delegate
				{
					KillFeed.Instance.ShowAllIcons();
					return true;
				};
				<>c.<>9__17_3 = val4;
				obj = (object)val4;
			}
			new ConsoleCommand("gc_show_icons", "Show all mob kill icons", (ConsoleEventFailable)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Plugin v2.0 loaded");
		}

		private void Update()
		{
			try
			{
				_updateCount++;
				if (_updateCount % 300 == 1)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Update #{_updateCount}, player={(Object)(object)Player.m_localPlayer != (Object)null}, detected={_playerDetected}");
				}
				if (_steamId == 0L)
				{
					long safeSteamId = GetSafeSteamId();
					if (safeSteamId != 0L)
					{
						_steamId = safeSteamId;
						(_aesKey, _hmacKey) = GracefulDegradation.SafeDeriveKey(_steamId);
						((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Steam ID obtained: {_steamId}");
					}
				}
				if ((Object)(object)Player.m_localPlayer != (Object)null && !_playerDetected)
				{
					_playerDetected = true;
					if (_steamId == 0L)
					{
						_steamId = Player.m_localPlayer.GetPlayerID();
						(_aesKey, _hmacKey) = GracefulDegradation.SafeDeriveKey(_steamId);
					}
					StatsTracker.StartTracking(Player.m_localPlayer);
					ActivityLogger.Initialize(Player.m_localPlayer.GetPlayerName(), Player.m_localPlayer.GetPlayerID());
					KillFeed.Instance.ShowAllIcons();
					StartInventoryCoroutine();
					((BaseUnityPlugin)this).Logger.LogInfo((object)$"[GCValheimStats] Player detected, steamId={_steamId}");
				}
				else if ((Object)(object)Player.m_localPlayer == (Object)null && _playerDetected)
				{
					_playerDetected = false;
					KillFeed.Instance.Hide();
					TimerOverlay.Instance.StopTimer();
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[GCValheimStats] Player exited world, kill feed hidden");
				}
				BatchTriggers?.Update();
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"[GCValheimStats] Update error: {arg}");
			}
		}

		private void OnDestroy()
		{
			SendFinalStats();
		}

		private void OnApplicationQuit()
		{
			BatchTriggers?.OnApplicationQuit();
			SessionManager?.EndSession();
			SendFinalStats();
		}

		private void OnApplicationPause(bool pauseStatus)
		{
			if (pauseStatus)
			{
				BatchTriggers?.OnConsoleSend();
			}
		}

		private IEnumerator InventorySnapshotCoroutine()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(600f);
				if ((Object)(object)Player.m_localPlayer != (Object)null && !((Character)Player.m_localPlayer).IsDead())
				{
					BatchTriggers?.SendInventorySnapshot();
					BatchTriggers?.Update();
				}
			}
		}

		private void StartInventoryCoroutine()
		{
			((MonoBehaviour)this).StartCoroutine(InventorySnapshotCoroutine());
		}

		public static void SendFinalStats()
		{
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					StatsTracker.SaveStats();
				}
			}
			catch (Exception ex)
			{
				Log.E("SendFinalStats failed: " + ex.Message);
			}
		}

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

		private static string GetWorldPreset()
		{
			return WorldStatsCollector.GetWorldPreset();
		}

		private static string GetGameMode()
		{
			return WorldStatsCollector.GetGameMode();
		}

		private static List<string> GetWorldModifiers()
		{
			return WorldStatsCollector.GetWorldModifiers();
		}

		private static bool GetIsServer()
		{
			return WorldStatsCollector.IsServer();
		}

		private static bool GetIsDedicated()
		{
			return WorldStatsCollector.IsDedicated();
		}

		private static int GetPlayerCount()
		{
			return WorldStatsCollector.GetPlayerCount();
		}

		private static string GetWorldSeed()
		{
			if ((Object)(object)ZNet.instance == (Object)null)
			{
				return "UnknownSeed";
			}
			try
			{
				Type type = typeof(ZNet).Assembly.GetType("WorldGenerator");
				if (type == null)
				{
					return "UnknownSeed";
				}
				FieldInfo field = type.GetField("m_instance", BindingFlags.Static | BindingFlags.NonPublic);
				if (field == null)
				{
					return "UnknownSeed";
				}
				object value = field.GetValue(null);
				if (value == null)
				{
					return "UnknownSeed";
				}
				FieldInfo field2 = type.GetField("m_world", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field2 == null)
				{
					return "UnknownSeed";
				}
				object value2 = field2.GetValue(value);
				if (value2 == null)
				{
					return "UnknownSeed";
				}
				object obj = value2.GetType().GetField("m_seed")?.GetValue(value2);
				if (obj != null)
				{
					return obj.ToString();
				}
			}
			catch
			{
			}
			return "UnknownSeed";
		}

		private static string GetCharacterName()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerName();
				}
			}
			catch
			{
			}
			return "UnknownCharacter";
		}

		private static long GetCharacterUid()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerID();
				}
			}
			catch
			{
			}
			return 0L;
		}

		private static long GetSafeSteamId()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CSteamID steamID = SteamUser.GetSteamID();
				if (((CSteamID)(ref steamID)).IsValid())
				{
					return (long)(ulong)steamID;
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if ((Object)(object)Player.m_localPlayer != (Object)null)
				{
					return Player.m_localPlayer.GetPlayerID();
				}
			}
			catch
			{
			}
			return 0L;
		}
	}
	internal static class Log
	{
		private const string Prefix = "[GCValheimStats] ";

		[Conditional("DEBUG")]
		public static void D(string msg, [CallerMemberName] string caller = "")
		{
			Debug.Log((object)("[GCValheimStats] " + caller + ": " + msg));
		}

		[Conditional("DEBUG")]
		public static void D(string msg)
		{
			Debug.Log((object)("[GCValheimStats] " + msg));
		}

		public static void W(string msg)
		{
			Debug.LogWarning((object)("[GCValheimStats] " + msg));
		}

		public static void E(string msg)
		{
			Debug.LogError((object)("[GCValheimStats] " + msg));
		}
	}
	public class ModConfig
	{
		private readonly ConfigFile Config;

		public ConfigEntry<bool> EnableMod { get; private set; }

		public ConfigEntry<int> Verbosity { get; private set; }

		public ConfigEntry<string> ApiEndpoint { get; private set; }

		public ConfigEntry<string> ApiKey { get; private set; }

		public ConfigEntry<int> SendInterval { get; private set; }

		public ConfigEntry<bool> SendOnExit { get; private set; }

		public ConfigEntry<bool> TrackCombat { get; private set; }

		public ConfigEntry<bool> TrackExploration { get; private set; }

		public ConfigEntry<bool> TrackCrafting { get; private set; }

		public ConfigEntry<bool> TrackSurvival { get; private set; }

		public ConfigEntry<bool> ShowOnScreen { get; private set; }

		public ConfigEntry<bool> ShowSendStatus { get; private set; }

		public ConfigEntry<KeyboardShortcut> ToggleStatsKey { get; private set; }

		public ConfigEntry<KeyboardShortcut> ResetStatsKey { get; private set; }

		public ConfigEntry<int> BatchInterval { get; private set; }

		public ConfigEntry<bool> EnableEncryption { get; private set; }

		public ConfigEntry<bool> EnableHmac { get; private set; }

		public ConfigEntry<int> MaxQueueSize { get; private set; }

		public ConfigEntry<int> ServerPingInterval { get; private set; }

		public ModConfig(ConfigFile config)
		{
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			Config = config;
			EnableMod = config.Bind<bool>("General", "EnableMod", true, "Enable or disable the mod");
			Verbosity = config.Bind<int>("General", "Verbosity", 1, "Log verbosity level (0=Error, 1=Info, 2=Debug)");
			ApiEndpoint = config.Bind<string>("API", "Endpoint", "http://localhost:5000/api/batch", "Web API endpoint URL");
			ApiKey = config.Bind<string>("API", "ApiKey", "", "API key for authentication");
			SendInterval = config.Bind<int>("API", "SendInterval", 300, "Auto-send interval in seconds (0 = disabled)");
			SendOnExit = config.Bind<bool>("API", "SendOnExit", true, "Send statistics when game closes");
			TrackCombat = config.Bind<bool>("Statistics", "TrackCombat", true, "Track combat statistics");
			TrackExploration = config.Bind<bool>("Statistics", "TrackExploration", true, "Track exploration statistics");
			TrackCrafting = config.Bind<bool>("Statistics", "TrackCrafting", true, "Track crafting statistics");
			TrackSurvival = config.Bind<bool>("Statistics", "TrackSurvival", true, "Track survival statistics");
			ShowOnScreen = config.Bind<bool>("Display", "ShowOnScreen", true, "Show statistics overlay");
			ShowSendStatus = config.Bind<bool>("Display", "ShowSendStatus", true, "Show status when sending");
			ServerPingInterval = config.Bind<int>("Display", "ServerPingInterval", 30, new ConfigDescription("Server ping interval in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(5, 120), Array.Empty<object>()));
			ToggleStatsKey = config.Bind<KeyboardShortcut>("Keybindings", "ToggleStats", new KeyboardShortcut((KeyCode)288, Array.Empty<KeyCode>()), "Toggle stats display");
			ResetStatsKey = config.Bind<KeyboardShortcut>("Keybindings", "ResetStats", new KeyboardShortcut((KeyCode)289, (KeyCode[])(object)new KeyCode[1] { (KeyCode)306 }), "Reset stats (Ctrl+F8)");
			BatchInterval = config.Bind<int>("Batch", "Interval", 5, new ConfigDescription("Batch send interval in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 60), Array.Empty<object>()));
			EnableEncryption = config.Bind<bool>("Security", "EnableEncryption", true, "Encrypt batch files with AES-256-CBC");
			EnableHmac = config.Bind<bool>("Security", "EnableHmac", true, "Sign batches with HMAC-SHA256");
			MaxQueueSize = config.Bind<int>("Batch", "MaxQueueSize", 1000, new ConfigDescription("Maximum number of batch files in queue", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 10000), Array.Empty<object>()));
			Config.SettingChanged += OnSettingChanged;
		}

		private void OnSettingChanged(object sender, SettingChangedEventArgs args)
		{
		}
	}
	public class PlayerStats
	{
		public int playTime;

		public int maxDistance;

		public float damageDealt;

		public float damageTaken;

		public int playerKills;

		public int enemyKills;

		public int buildingBuilt;

		public int buildingBroken;

		public int portalUsed;

		public int deaths;

		public int treeChopped;

		public int mineRock;

		public int itemsPickedUp;

		public int foodConsumed;

		public int fishCaught;

		public int tamedCount;

		public int tradeCount;

		public int mapPinCount;

		public int sleepCount;

		public int skillUps;

		public float staminaUsed;

		public float hpHealed;

		public Dictionary<string, int> mobKills = new Dictionary<string, int>();

		public Dictionary<string, int> trophies = new Dictionary<string, int>();

		public PlayerStats DeepCopy()
		{
			return new PlayerStats
			{
				playTime = playTime,
				maxDistance = maxDistance,
				damageDealt = damageDealt,
				damageTaken = damageTaken,
				playerKills = playerKills,
				enemyKills = enemyKills,
				buildingBuilt = buildingBuilt,
				buildingBroken = buildingBroken,
				portalUsed = portalUsed,
				deaths = deaths,
				treeChopped = treeChopped,
				mineRock = mineRock,
				itemsPickedUp = itemsPickedUp,
				foodConsumed = foodConsumed,
				fishCaught = fishCaught,
				tamedCount = tamedCount,
				tradeCount = tradeCount,
				mapPinCount = mapPinCount,
				sleepCount = sleepCount,
				skillUps = skillUps,
				staminaUsed = staminaUsed,
				hpHealed = hpHealed,
				mobKills = new Dictionary<string, int>(mobKills),
				trophies = new Dictionary<string, int>(trophies)
			};
		}
	}
	public class DamageEvent
	{
		public string attackerName;

		public Dictionary<string, float> breakdown;

		public float healthAfter;

		public Vector3 position;

		public long timestamp;
	}
	public class TombstoneData
	{
		public List<Dictionary<string, object>> tombstoneItems;

		public List<Dictionary<string, object>> remainingItems;

		public Vector3 position;
	}
	public class StatsTracker
	{
		public static StatsTracker Instance;

		public PlayerStats lifetimeStats;

		public PlayerStats sessionStats;

		public PlayerStats previousSessionStats;

		public Player currentPlayer;

		private float previousHealth;

		private float previousStamina;

		private string currentBiome = "";

		private float _foodCheckTimer;

		private float _previousFoodCount;

		private Vector3 _lastPosition;

		private float _totalDistance;

		public TombstoneData lastTombstoneData;

		public string lastDeathCause = "Unknown";

		public string lastDeathAttacker = "none";

		private readonly List<DamageEvent> _recentDamage = new List<DamageEvent>();

		private const int MAX_RECENT_DAMAGE = 10;

		private const string OLD_KEY_MOB_KILLS = "gcsv_mobKills";

		private const string OLD_KEY_TROPHIES = "gcsv_trophies";

		public bool IsTracking => (Object)(object)currentPlayer != (Object)null;

		public StatsTracker()
		{
			Instance = this;
			lifetimeStats = new PlayerStats();
			sessionStats = new PlayerStats();
			previousSessionStats = new PlayerStats();
		}

		public void StartTracking(Player player)
		{
			//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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			currentPlayer = player;
			sessionStats = new PlayerStats();
			lifetimeStats = new PlayerStats();
			previousHealth = ((Character)player).GetHealth();
			previousStamina = player.GetStamina();
			currentBiome = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			_previousFoodCount = GetFoodCount();
			_lastPosition = ((Component)player).transform.position;
			_totalDistance = 0f;
			StatsCollector.LoadPlayerData();
			LoadPersistentData();
		}

		public void Update()
		{
			if (!((Object)(object)currentPlayer == (Object)null) && !((Character)currentPlayer).IsDead())
			{
				UpdatePlayTime();
				UpdateMaxDistance();
				UpdateHealthStaminaUsed();
				UpdateCurrentBiome();
			}
		}

		private void UpdatePlayTime()
		{
			if (Time.timeScale != 0f)
			{
				sessionStats.playTime++;
				lifetimeStats.playTime++;
			}
		}

		private void UpdateMaxDistance()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)currentPlayer).transform.position;
			float num = Vector3.Distance(_lastPosition, position);
			_totalDistance += num;
			_lastPosition = position;
			int num2 = (int)_totalDistance;
			if (num2 > sessionStats.maxDistance)
			{
				sessionStats.maxDistance = num2;
			}
			if (num2 > lifetimeStats.maxDistance)
			{
				lifetimeStats.maxDistance = num2;
			}
		}

		private void UpdateHealthStaminaUsed()
		{
			float health = ((Character)currentPlayer).GetHealth();
			float stamina = currentPlayer.GetStamina();
			if (health > previousHealth)
			{
				float num = health - previousHealth;
				sessionStats.hpHealed += num;
				lifetimeStats.hpHealed += num;
			}
			if (stamina < previousStamina)
			{
				float num2 = previousStamina - stamina;
				sessionStats.staminaUsed += num2;
				lifetimeStats.staminaUsed += num2;
			}
			previousHealth = health;
			previousStamina = stamina;
		}

		private void UpdateCurrentBiome()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string text = ((object)currentPlayer.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			if (!string.IsNullOrEmpty(text) && text != currentBiome)
			{
				currentBiome = text;
			}
		}

		private float GetFoodCount()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			if ((Object)(object)currentPlayer == (Object)null)
			{
				return 0f;
			}
			Inventory inventory = ((Humanoid)currentPlayer).GetInventory();
			if (inventory == null)
			{
				return 0f;
			}
			List<ItemData> allItems = inventory.GetAllItems();
			if (allItems == null)
			{
				return 0f;
			}
			float num = 0f;
			foreach (ItemData item in allItems)
			{
				if (item != null && item.m_shared != null && (int)item.m_shared.m_itemType == 2)
				{
					num += (float)item.m_stack;
				}
			}
			return num;
		}

		public void RecordDamageDealt(float damage)
		{
			sessionStats.damageDealt += damage;
			lifetimeStats.damageDealt += damage;
		}

		public void RecordDamageTaken(float damage)
		{
			sessionStats.damageTaken += damage;
			lifetimeStats.damageTaken += damage;
		}

		public void RecordEnemyKill(string mobId, string characterName, bool isBoss, bool isTamed, int level, string biome, string element = null)
		{
			sessionStats.enemyKills++;
			lifetimeStats.enemyKills++;
			if (!string.IsNullOrEmpty(mobId))
			{
				string key = BuildMobKey(characterName, biome, isBoss, isTamed, level, element);
				if (!sessionStats.mobKills.ContainsKey(key))
				{
					sessionStats.mobKills[key] = 0;
				}
				sessionStats.mobKills[key]++;
				if (!lifetimeStats.mobKills.ContainsKey(key))
				{
					lifetimeStats.mobKills[key] = 0;
				}
				lifetimeStats.mobKills[key]++;
				SavePersistentData();
			}
		}

		public int GetTotalKillsAcrossElements(string characterName, string biome, bool isBoss, bool isTamed, int level)
		{
			int num = 0;
			string value = (characterName ?? "Unknown") + " ";
			foreach (KeyValuePair<string, int> mobKill in sessionStats.mobKills)
			{
				if (mobKill.Key == characterName || mobKill.Key.StartsWith(value))
				{
					num += mobKill.Value;
				}
			}
			return num;
		}

		private static string BuildMobKey(string characterName, string biome, bool isBoss, bool isTamed, int level, string element = null)
		{
			List<string> list = new List<string>();
			list.Add(characterName ?? "Unknown");
			if (!string.IsNullOrEmpty(biome))
			{
				list.Add(biome);
			}
			if (isBoss)
			{
				list.Add("Boss");
			}
			if (isTamed)
			{
				list.Add("Tamed");
			}
			if (level > 1)
			{
				list.Add($"{level}*");
			}
			if (!string.IsNullOrEmpty(element))
			{
				list.Add(element);
			}
			return string.Join(" ", list);
		}

		public void RecordTrophy(string trophyName)
		{
			if (!string.IsNullOrEmpty(trophyName))
			{
				if (!sessionStats.trophies.ContainsKey(trophyName))
				{
					sessionStats.trophies[trophyName] = 0;
				}
				sessionStats.trophies[trophyName]++;
				if (!lifetimeStats.trophies.ContainsKey(trophyName))
				{
					lifetimeStats.trophies[trophyName] = 0;
				}
				lifetimeStats.trophies[trophyName]++;
				SavePersistentData();
			}
		}

		public void RecordBuilding(string pieceName)
		{
			sessionStats.buildingBuilt++;
			lifetimeStats.buildingBuilt++;
		}

		public void RecordPortalUse()
		{
			sessionStats.portalUsed++;
			lifetimeStats.portalUsed++;
		}

		public void RecordDeath(Vector3 position, string cause = "Unknown", string attacker = "none")
		{
			sessionStats.deaths++;
			lifetimeStats.deaths++;
			lastDeathCause = cause;
			lastDeathAttacker = attacker;
		}

		public void RecordTombstone(TombstoneData data)
		{
			lastTombstoneData = data;
		}

		public static string GetDeathCause(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return "Unknown";
			}
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return "Unknown";
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return "Unknown";
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_playerStats");
				if (field == null)
				{
					return "Unknown";
				}
				object value = field.GetValue(playerProfile);
				if (value == null)
				{
					return "Unknown";
				}
				PropertyInfo property = value.GetType().GetProperty("Item");
				if (property == null)
				{
					return "Unknown";
				}
				string[] array = new string[19]
				{
					"Undefined", "Enemy", "Player", "Fall", "Drowning", "Burning", "Freezing", "Poison", "Water", "Smoke",
					"EdgeOfWorld", "Impact", "Cart", "Tree", "Self", "Structural", "Turret", "Boat", "Stalagtite"
				};
				for (int i = 0; i < array.Length; i++)
				{
					try
					{
						if (Convert.ToSingle(property.GetValue(value, new object[1] { 86 + i })) > 0f)
						{
							return array[i];
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return "Unknown";
		}

		public void RecordDamageTakenFull(float damage, string attackerName, Dictionary<string, float> breakdown, Vector3 position)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			RecordDamageTaken(damage);
			DamageEvent item = new DamageEvent
			{
				attackerName = (attackerName ?? "none"),
				breakdown = (breakdown ?? new Dictionary<string, float>()),
				healthAfter = (((Object)(object)currentPlayer != (Object)null) ? ((Character)currentPlayer).GetHealth() : 0f),
				position = position,
				timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
			};
			_recentDamage.Add(item);
			if (_recentDamage.Count > 10)
			{
				_recentDamage.RemoveAt(0);
			}
		}

		public List<DamageEvent> GetRecentDamage()
		{
			return new List<DamageEvent>(_recentDamage);
		}

		public void RecordFishing(string fishName)
		{
			sessionStats.fishCaught++;
			lifetimeStats.fishCaught++;
		}

		public void RecordTaming(string creatureName)
		{
			sessionStats.tamedCount++;
			lifetimeStats.tamedCount++;
		}

		public void RecordTrade(string traderName)
		{
			sessionStats.tradeCount++;
			lifetimeStats.tradeCount++;
		}

		public void RecordMapPin(string pinType)
		{
			sessionStats.mapPinCount++;
			lifetimeStats.mapPinCount++;
		}

		public void RecordSleep()
		{
			sessionStats.sleepCount++;
			lifetimeStats.sleepCount++;
		}

		public void RecordSkillLevelUp(string skillName)
		{
			sessionStats.skillUps++;
			lifetimeStats.skillUps++;
		}

		public void RecordFoodConsumed()
		{
			sessionStats.foodConsumed++;
			lifetimeStats.foodConsumed++;
		}

		public void RecordPickup(string itemName)
		{
			sessionStats.itemsPickedUp++;
			lifetimeStats.itemsPickedUp++;
		}

		public void RecordChopping(string treeName)
		{
			sessionStats.treeChopped++;
			lifetimeStats.treeChopped++;
		}

		public void RecordMining(string rockName)
		{
			sessionStats.mineRock++;
			lifetimeStats.mineRock++;
		}

		public void ResetSession()
		{
			sessionStats = new PlayerStats();
		}

		public void SaveStats()
		{
			SavePersistentData();
			previousSessionStats = sessionStats.DeepCopy();
		}

		public void LoadFromData(PlayerStats stats)
		{
			lifetimeStats = stats.DeepCopy();
		}

		private static string GetKey(string baseKey)
		{
			Player localPlayer = Player.m_localPlayer;
			long num = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0);
			return $"gcsv_{num}_{baseKey}";
		}

		public void SavePersistentData()
		{
			try
			{
				if (!((Object)(object)Player.m_localPlayer == (Object)null))
				{
					Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
					if (customData != null)
					{
						customData[GetKey("playTime")] = sessionStats.playTime.ToString();
						customData[GetKey("maxDistance")] = sessionStats.maxDistance.ToString();
						customData[GetKey("damageDealt")] = sessionStats.damageDealt.ToString("F1");
						customData[GetKey("damageTaken")] = sessionStats.damageTaken.ToString("F1");
						customData[GetKey("enemyKills")] = sessionStats.enemyKills.ToString();
						customData[GetKey("playerKills")] = sessionStats.playerKills.ToString();
						customData[GetKey("deaths")] = sessionStats.deaths.ToString();
						customData[GetKey("buildingBuilt")] = sessionStats.buildingBuilt.ToString();
						customData[GetKey("buildingBroken")] = sessionStats.buildingBroken.ToString();
						customData[GetKey("treeChopped")] = sessionStats.treeChopped.ToString();
						customData[GetKey("mineRock")] = sessionStats.mineRock.ToString();
						customData[GetKey("itemsPickedUp")] = sessionStats.itemsPickedUp.ToString();
						customData[GetKey("foodConsumed")] = sessionStats.foodConsumed.ToString();
						customData[GetKey("fishCaught")] = sessionStats.fishCaught.ToString();
						customData[GetKey("tamedCount")] = sessionStats.tamedCount.ToString();
						customData[GetKey("tradeCount")] = sessionStats.tradeCount.ToString();
						customData[GetKey("portalUsed")] = sessionStats.portalUsed.ToString();
						customData[GetKey("sleepCount")] = sessionStats.sleepCount.ToString();
						customData[GetKey("skillUps")] = sessionStats.skillUps.ToString();
						customData[GetKey("staminaUsed")] = sessionStats.staminaUsed.ToString("F1");
						customData[GetKey("hpHealed")] = sessionStats.hpHealed.ToString("F1");
						customData[GetKey("mobKills")] = DictToKV(sessionStats.mobKills);
						customData[GetKey("trophies")] = DictToKV(sessionStats.trophies);
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("SavePersistentData failed: " + ex.Message);
			}
		}

		public void LoadPersistentData()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return;
				}
				Dictionary<string, string> customData = Player.m_localPlayer.m_customData;
				if (customData != null)
				{
					MigrateOldKey(customData, "gcsv_mobKills", GetKey("mobKills"));
					MigrateOldKey(customData, "gcsv_trophies", GetKey("trophies"));
					if (customData.TryGetValue(GetKey("playTime"), out var value) && int.TryParse(value, out var result))
					{
						sessionStats.playTime = result;
					}
					if (customData.TryGetValue(GetKey("maxDistance"), out var value2) && int.TryParse(value2, out var result2))
					{
						sessionStats.maxDistance = result2;
					}
					if (customData.TryGetValue(GetKey("damageDealt"), out var value3) && float.TryParse(value3, NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
					{
						sessionStats.damageDealt = result3;
					}
					if (customData.TryGetValue(GetKey("damageTaken"), out var value4) && float.TryParse(value4, NumberStyles.Float, CultureInfo.InvariantCulture, out var result4))
					{
						sessionStats.damageTaken = result4;
					}
					if (customData.TryGetValue(GetKey("enemyKills"), out var value5) && int.TryParse(value5, out var result5))
					{
						sessionStats.enemyKills = result5;
					}
					if (customData.TryGetValue(GetKey("playerKills"), out var value6) && int.TryParse(value6, out var result6))
					{
						sessionStats.playerKills = result6;
					}
					if (customData.TryGetValue(GetKey("deaths"), out var value7) && int.TryParse(value7, out var result7))
					{
						sessionStats.deaths = result7;
					}
					if (customData.TryGetValue(GetKey("buildingBuilt"), out var value8) && int.TryParse(value8, out var result8))
					{
						sessionStats.buildingBuilt = result8;
					}
					if (customData.TryGetValue(GetKey("buildingBroken"), out var value9) && int.TryParse(value9, out var result9))
					{
						sessionStats.buildingBroken = result9;
					}
					if (customData.TryGetValue(GetKey("treeChopped"), out var value10) && int.TryParse(value10, out var result10))
					{
						sessionStats.treeChopped = result10;
					}
					if (customData.TryGetValue(GetKey("mineRock"), out var value11) && int.TryParse(value11, out var result11))
					{
						sessionStats.mineRock = result11;
					}
					if (customData.TryGetValue(GetKey("itemsPickedUp"), out var value12) && int.TryParse(value12, out var result12))
					{
						sessionStats.itemsPickedUp = result12;
					}
					if (customData.TryGetValue(GetKey("foodConsumed"), out var value13) && int.TryParse(value13, out var result13))
					{
						sessionStats.foodConsumed = result13;
					}
					if (customData.TryGetValue(GetKey("fishCaught"), out var value14) && int.TryParse(value14, out var result14))
					{
						sessionStats.fishCaught = result14;
					}
					if (customData.TryGetValue(GetKey("tamedCount"), out var value15) && int.TryParse(value15, out var result15))
					{
						sessionStats.tamedCount = result15;
					}
					if (customData.TryGetValue(GetKey("tradeCount"), out var value16) && int.TryParse(value16, out var result16))
					{
						sessionStats.tradeCount = result16;
					}
					if (customData.TryGetValue(GetKey("portalUsed"), out var value17) && int.TryParse(value17, out var result17))
					{
						sessionStats.portalUsed = result17;
					}
					if (customData.TryGetValue(GetKey("sleepCount"), out var value18) && int.TryParse(value18, out var result18))
					{
						sessionStats.sleepCount = result18;
					}
					if (customData.TryGetValue(GetKey("skillUps"), out var value19) && int.TryParse(value19, out var result19))
					{
						sessionStats.skillUps = result19;
					}
					if (customData.TryGetValue(GetKey("staminaUsed"), out var value20) && float.TryParse(value20, NumberStyles.Float, CultureInfo.InvariantCulture, out var result20))
					{
						sessionStats.staminaUsed = result20;
					}
					if (customData.TryGetValue(GetKey("hpHealed"), out var value21) && float.TryParse(value21, NumberStyles.Float, CultureInfo.InvariantCulture, out var result21))
					{
						sessionStats.hpHealed = result21;
					}
					if (customData.TryGetValue(GetKey("mobKills"), out var value22) && !string.IsNullOrEmpty(value22))
					{
						KVToDict(value22, sessionStats.mobKills);
					}
					if (customData.TryGetValue(GetKey("trophies"), out var value23) && !string.IsNullOrEmpty(value23))
					{
						KVToDict(value23, sessionStats.trophies);
					}
				}
			}
			catch (Exception ex)
			{
				Log.W("LoadPersistentData failed: " + ex.Message);
			}
		}

		private static void MigrateOldKey(Dictionary<string, string> cd, string oldKey, string newKey)
		{
			if (cd.TryGetValue(oldKey, out string value) && !string.IsNullOrEmpty(value))
			{
				if (!cd.ContainsKey(newKey))
				{
					cd[newKey] = value;
				}
				cd.Remove(oldKey);
			}
		}

		private static string DictToKV(Dictionary<string, int> dict)
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> item in dict)
			{
				list.Add(string.Format("{0}={1}", item.Key.Replace("=", "\\="), item.Value));
			}
			return string.Join(";", list);
		}

		private static void KVToDict(string str, Dictionary<string, int> dict)
		{
			dict.Clear();
			if (string.IsNullOrEmpty(str))
			{
				return;
			}
			string[] array = str.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (string.IsNullOrEmpty(text))
				{
					continue;
				}
				int num = text.LastIndexOf('=');
				if (num >= 0)
				{
					string key = text.Substring(0, num).Replace("\\=", "=");
					if (int.TryParse(text.Substring(num + 1), out var result))
					{
						dict[key] = result;
					}
				}
			}
		}
	}
	public class StatsCollector
	{
		public static void LoadPlayerData()
		{
			try
			{
				if ((Object)(object)Game.instance == (Object)null || Game.instance.GetPlayerProfile() == null)
				{
					return;
				}
				Dictionary<string, float> historicalStats = GetHistoricalStats(Player.m_localPlayer);
				if (historicalStats == null || StatsTracker.Instance == null)
				{
					return;
				}
				PlayerStats playerStats = new PlayerStats();
				foreach (KeyValuePair<string, float> item in historicalStats)
				{
					switch (item.Key)
					{
					case "Deaths":
						playerStats.deaths = (int)item.Value;
						break;
					case "Builds":
						playerStats.buildingBuilt = (int)item.Value;
						break;
					case "Kills":
						playerStats.enemyKills = (int)item.Value;
						break;
					case "Trees_Cut":
						playerStats.treeChopped = (int)item.Value;
						break;
					case "Distance_Total":
						playerStats.maxDistance = (int)item.Value;
						break;
					}
				}
				StatsTracker.Instance.LoadFromData(playerStats);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GCValheimStats] LoadPlayerData failed: " + ex.Message));
			}
		}

		public static object CollectFullPlayerStats(Player player)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return null;
			}
			long playerID = player.GetPlayerID();
			string playerName = player.GetPlayerName();
			long timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
			float health = ((Character)player).GetHealth();
			float maxHealth = ((Character)player).GetMaxHealth();
			var position = new
			{
				((Component)player).transform.position.x,
				((Component)player).transform.position.y,
				((Component)player).transform.position.z
			};
			string? current_biome = ((object)player.GetCurrentBiome()/*cast due to .constrained prefix*/).ToString();
			Inventory inventory = ((Humanoid)player).GetInventory();
			return new
			{
				player_id = playerID,
				player_name = playerName,
				timestamp = timestamp,
				health = health,
				max_health = maxHealth,
				position = position,
				current_biome = current_biome,
				inventory_weight = ((inventory != null) ? inventory.GetTotalWeight() : 0f),
				max_carry_weight = player.GetMaxCarryWeight(),
				equipment = new
				{
					right_hand = GetItemInfo(GetPrivateField<ItemData>(player, "m_rightItem")),
					left_hand = GetItemInfo(GetPrivateField<ItemData>(player, "m_leftItem")),
					chest = GetItemInfo(GetPrivateField<ItemData>(player, "m_chestItem")),
					legs = GetItemInfo(GetPrivateField<ItemData>(player, "m_legItem")),
					helmet = GetItemInfo(GetPrivateField<ItemData>(player, "m_helmetItem")),
					shoulder = GetItemInfo(GetPrivateField<ItemData>(player, "m_shoulderItem")),
					utility = GetItemInfo(GetPrivateField<ItemData>(player, "m_utilityItem")),
					trinket = GetItemInfo(GetPrivateField<ItemData>(player, "m_trinketItem")),
					ammo = GetItemInfo(GetPrivateField<ItemData>(player, "m_ammoItem"))
				},
				stamina = player.GetStamina(),
				max_stamina = ((Character)player).GetMaxStamina(),
				eitr = player.GetEitr(),
				max_eitr = ((Character)player).GetMaxEitr(),
				active_foods = GetActiveFoods(player),
				top_skills = GetTopSkills(player),
				historical_stats = GetHistoricalStats(player)
			};
		}

		private static T GetPrivateField<T>(object obj, string fieldName) where T : class
		{
			if (obj == null)
			{
				return null;
			}
			return obj.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj) as T;
		}

		private static object GetItemInfo(ItemData item)
		{
			if (item == null)
			{
				return null;
			}
			return new
			{
				name = item.m_shared.m_name,
				quality = item.m_quality,
				durability = item.m_durability,
				max_durability = item.GetMaxDurability(),
				weight = item.m_shared.m_weight,
				value = item.m_shared.m_value,
				stack = item.m_stack,
				max_stack = item.m_shared.m_maxStackSize,
				type = ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString(),
				skill = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_shared.m_skillType)/*cast due to .constrained prefix*/).ToString(),
				block_power = item.m_shared.m_blockPower,
				deflection_force = item.m_shared.m_deflectionForce,
				timed_block_bonus = item.m_shared.m_timedBlockBonus,
				movement_modifier = item.m_shared.m_movementModifier,
				jump_stamina_modifier = item.m_shared.m_jumpStaminaModifier,
				attack_stamina_modifier = item.m_shared.m_attackStaminaModifier,
				block_stamina_modifier = item.m_shared.m_blockStaminaModifier,
				dodge_stamina_modifier = item.m_shared.m_dodgeStaminaModifier
			};
		}

		private static List<object> GetActiveFoods(Player player)
		{
			List<object> list = new List<object>();
			IList privateField = GetPrivateField<IList>(player, "m_foods");
			if (privateField == null)
			{
				return list;
			}
			foreach (object item in privateField)
			{
				if (item == null)
				{
					continue;
				}
				try
				{
					object? obj = item.GetType().GetField("m_item")?.GetValue(item);
					ItemDrop val = (ItemDrop)((obj is ItemDrop) ? obj : null);
					float remaining_time = Convert.ToSingle(item.GetType().GetField("m_time")?.GetValue(item) ?? ((object)0f));
					float health = Convert.ToSingle(item.GetType().GetField("m_health")?.GetValue(item) ?? ((object)0f));
					float stamina = Convert.ToSingle(item.GetType().GetField("m_stamina")?.GetValue(item) ?? ((object)0f));
					float eitr = Convert.ToSingle(item.GetType().GetField("m_eitr")?.GetValue(item) ?? ((object)0f));
					if (val?.m_itemData?.m_shared != null)
					{
						list.Add(new
						{
							name = val.m_itemData.m_shared.m_name,
							remaining_time = remaining_time,
							health = health,
							stamina = stamina,
							eitr = eitr
						});
					}
				}
				catch
				{
				}
			}
			return list;
		}

		private static List<object> GetTopSkills(Player player)
		{
			List<object> list = new List<object>();
			Skills privateField = GetPrivateField<Skills>(player, "m_skills");
			if ((Object)(object)privateField == (Object)null)
			{
				return list;
			}
			List<Skill> skillList = privateField.GetSkillList();
			if (skillList == null)
			{
				return list;
			}
			foreach (Skill item in (from s in skillList
				where s != null && s.m_level > 0f
				orderby s.m_level descending
				select s).Take(5))
			{
				float level = item.m_level;
				float progress = 0f;
				try
				{
					MethodInfo method = ((object)item).GetType().GetMethod("GetNextLevelRequirement");
					if (method != null)
					{
						float num = Convert.ToSingle(method.Invoke(item, null));
						if (num > 0f)
						{
							progress = item.m_accumulator / num;
						}
					}
				}
				catch
				{
				}
				list.Add(new
				{
					name = ((object)Unsafe.As<SkillType, SkillType>(ref item.m_info.m_skill)/*cast due to .constrained prefix*/).ToString(),
					level = level,
					progress = progress
				});
			}
			return list;
		}

		private static Dictionary<string, float> GetHistoricalStats(Player player)
		{
			Dictionary<string, float> stats = new Dictionary<string, float>();
			try
			{
				if ((Object)(object)Game.instance == (Object)null)
				{
					return stats;
				}
				PlayerProfile playerProfile = Game.instance.GetPlayerProfile();
				if (playerProfile == null)
				{
					return stats;
				}
				FieldInfo field = typeof(PlayerProfile).GetField("m_playerStats");
				if (field == null)
				{
					return stats;
				}
				object playerStats = field.GetValue(playerProfile);
				if (playerStats == null)
				{
					return stats;
				}
				PropertyInfo indexer = playerStats.GetType().GetProperty("Item");
				if (indexer == null)
				{
					return stats;
				}
				AddStat("deaths", GetStat(0));
				AddStat("crafts", GetStat(1));
				AddStat("builds", GetStat(2));
				AddStat("jumps", GetStat(3));
				AddStat("hits", GetStat(5));
				AddStat("kills", GetStat(6));
				AddStat("pvp_hits", GetStat(8));
				AddStat("pvp_kills", GetStat(9));
				AddStat("hits_taken", GetStat(10));
				AddStat("items_picked_up", GetStat(12));
				AddStat("portals", GetStat(15));
				AddStat("distance_total", GetStat(16));
				AddStat("distance_walked", GetStat(17));
				AddStat("distance_run", GetStat(18));
				AddStat("distance_sailed", GetStat(19));
				AddStat("distance_air", GetStat(20));
				AddStat("time_in_base", GetStat(21));
				AddStat("time_out_base", GetStat(22));
				AddStat("sleep_time", GetStat(23));
				AddStat("world_loads", GetStat(26));
				AddStat("trees_cut", GetStat(27));
				AddStat("mines", GetStat(37));
				AddStat("food_eaten", GetStat(49));
				AddStat("arrows_shot", GetStat(51));
				AddStat("doors_opened", GetStat(74));
				AddStat("bees_harvested", GetStat(76));
				AddStat("bosses_killed", GetStat(85));
				AddStat("death_undefined", GetStat(86));
				AddStat("death_enemy", GetStat(87));
				AddStat("death_player", GetStat(88));
				AddStat("death_fall", GetStat(89));
				AddStat("death_drowning", GetStat(90));
				AddStat("death_burning", GetStat(91));
				AddStat("death_freezing", GetStat(92));
				AddStat("death_poison", GetStat(93));
				AddStat("death_water", GetStat(94));
				AddStat("death_smoke", GetStat(95));
				AddStat("death_edge_of_world", GetStat(96));
				AddStat("death_impact", GetStat(97));
				AddStat("death_cart", GetStat(98));
				AddStat("death_tree", GetStat(99));
				AddStat("death_self", GetStat(100));
				AddStat("death_structural", GetStat(101));
				AddStat("death_turret", GetStat(102));
				AddStat("death_boat", GetStat(103));
				AddStat("death_stalagtite", GetStat(104));
				AddStat("guardian_power_use_total", GetStat(105));
				AddStat("power_eikthyr_use", GetStat(106));
				AddStat("power_elder_use", GetStat(107));
				AddStat("power_bonemass_use", GetStat(108));
				AddStat("power_moder_use", GetStat(109));
				AddStat("power_yagluth_use", GetStat(110));
				AddStat("power_queen_use", GetStat(111));
				AddStat("power_ashlands_use", GetStat(112));
				AddStat("power_deep_north_use", GetStat(113));
				float GetStat(int index)
				{
					try
					{
						return Convert.ToSingle(indexer.GetValue(playerStats, new object[1] { index }));
					}
					catch
					{
						return 0f;
					}
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("[GCValheimStats] Error getting historical stats: " + ex.Message));
			}
			return stats;
			void AddStat(string key, float value)
			{
				stats[key] = value;
			}
		}
	}
	public static class ActivityLogger
	{
		private static string _playerName = "";

		private static long _playerID;

		private static string _steamId = "";

		public static void Initialize(string playerName, long playerID)
		{
			_playerName = playerName;
			_playerID = playerID;
			_steamId = playerID.ToString();
		}

		public static string GetSteamId()
		{
			return _steamId;
		}

		public static string FormatEvent(string eventName, string parameters = "")
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Player.m_localPlayer == (Object)null)
			{
				return null;
			}
			Vector3 position = ((Component)Player.m_localPlayer).transform.position;
			string text = $"({position.x:0.0} {position.y:0.0} {position.z:0.0})";
			string text2 = DateTime.UtcNow.ToString("G", CultureInfo.InvariantCulture);
			if (string.IsNullOrEmpty(parameters))
			{
				return "[" + text2 + "] " + _steamId + " " + text + " " + eventName;
			}
			return "[" + text2 + "] " + _steamId + " " + text + " " + eventName + " " + parameters;
		}

		public static string FormatEventPosition(string eventName, Vector3 position, string parameters = "")
		{
			//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_001b: Unknown result type (might be due to invalid IL or missing references)
			string text = $"({position.x:0.0} {position.y:0.0} {position.z:0.0})";
			string text2 = DateTime.UtcNow.ToString("G", CultureInfo.InvariantCulture);
			if (string.IsNullOrEmpty(parameters))
			{
				return "[" + text2 + "] " + _steamId + " " + text + " " + eventName;
			}
			return "[" + text2 + "] " + _steamId + " " + text + " " + eventName + " " + parameters;
		}

		public static string FormatPlayer()
		{
			return $"{_playerName}({_playerID})";
		}

		public static string FormatItem(ItemData item, int amount = 1)
		{
			if (item == null)
			{
				return "null";
			}
			string text = item.m_shared?.m_name ?? "Unknown";
			string text2 = "";
			if (item.m_crafterID != 0L)
			{
				text2 = $" crafter:{item.m_crafterName}({item.m_crafterID})";
			}
			string text3 = "";
			if (item.m_customData != null && item.m_customData.Count > 0)
			{
				StringBuilder stringBuilder = new StringBuilder(" data:");
				foreach (KeyValuePair<string, string> customDatum in item.m_customData)
				{
					stringBuilder.Append("[" + customDatum.Key + "]:[" + customDatum.Value + "]");
				}
				text3 = stringBuilder.ToString();
			}
			return $"{text} x{amount} quality:{item.m_quality}{text2}{text3}";
		}

		public static string FormatDamage(HitData hit)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0048: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (hit == null)
			{
				return "";
			}
			DamageTypes damage = hit.m_damage;
			return $"damage:{hit.GetTotalDamage():0.0} blunt:{damage.m_blunt:0.0} slash:{damage.m_slash:0.0} pierce:{damage.m_pierce:0.0} fire:{damage.m_fire:0.0} frost:{damage.m_frost:0.0} lightning:{damage.m_lightning:0.0} poison:{damage.m_poison:0.0} spirit:{damage.m_spirit:0.0} chop:{damage.m_chop:0.0} pickaxe:{damage.m_pickaxe:0.0}";
		}

		public static string FormatItemContainer(Inventory inv, string containerName)
		{
			if (inv == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine(containerName);
			List<ItemData> allItems = inv.GetAllItems();
			if (allItems != null)
			{
				foreach (ItemData item in allItems)
				{
					if (item != null)
					{
						stringBuilder.AppendLine(FormatItem(item));
					}
				}
			}
			return stringBuilder.ToString();
		}

		public static void SendEvent(string logLine)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(logLine))
			{
				return;
			}
			try
			{
				StatsWebClient.Instance.SendLogEvent(logLine);
			}
			catch (Exception ex)
			{
				Log.E("SendEvent failed: " + ex.Message);
			}
			try
			{
				if (GCValheimStatsPlugin.EventQueue != null && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					EventEntry entry = new EventEntry
					{
						Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
						EventType = ExtractEventType(logLine),
						Parameters = new Dictionary<string, object> { ["raw"] = logLine },
						Position = new float[3]
						{
							((Component)Player.m_localPlayer).transform.position.x,
							((Component)Player.m_localPlayer).transform.position.y,
							((Component)Player.m_localPlayer).transform.position.z
						}
					};
					GCValheimStatsPlugin.EventQueue.Enqueue(entry);
				}
			}
			catch
			{
			}
		}

		private static string ExtractEventType(string logLine)
		{
			if (string.IsNullOrEmpty(logLine))
			{
				return "unknown";
			}
			int num = logLine.LastIndexOf(' ');
			if (num >= 0 && num < logLine.Length - 1)
			{
				return logLine.Substring(num + 1).Split(new char[1] { ' ' })[0];
			}
			return "unknown";
		}
	}
	public static class GracefulDegradation
	{
		public static (byte[] aesKey, byte[] hmacKey) SafeDeriveKey(long steamId)
		{
			try
			{
				return KeyDeriver.DeriveKey(steamId);
			}
			catch (Exception ex)
			{
				Log.W("Key derivation failed: " + ex.Message + ". Running without encryption.");
				return (aesKey: null, hmacKey: null);
			}
		}

		public static void SafeSaveBatch(QueueStorage storage, BatchData batch, byte[] aesKey, byte[] hmacKey)
		{
			try
			{
				if (aesKey != null && hmacKey != null)
				{
					storage.SaveBatch(batch, aesKey, hmacKey);
				}
				else
				{
					SaveBatchUnencrypted(storage, batch);
				}
			}
			catch (Exception ex)
			{
				Log.W("Failed to save batch: " + ex.Message);
			}
		}

		public static async Task<int> SafeSendAll(BatchSender sender, byte[] aesKey, byte[] hmacKey)
		{
			try
			{
				return await sender.SendAllPending(aesKey, hmacKey);
			}
			catch (Exception ex)
			{
				Log.W("Send failed: " + ex.Message);
				return 0;
			}
		}

		public static string GetSafeSteamId()
		{
			try
			{
				if ((Object)(object)Player.m_localPlayer == (Object)null)
				{
					return "local";
				}
				return Player.m_localPlayer.GetPlayerID().ToString();
			}
			catch
			{
				return "local";
			}
		}

		private static void SaveBatchUnencrypted(QueueStorage storage, BatchData batch)
		{
			try
			{
				string contents = batch.ToJson();
				string path = Path.Combine(Path.GetDirectoryName(typeof(QueueStorage).Assembly.Location), "queue", batch.BatchId + ".json");
				Directory.CreateDirectory(Path.GetDirectoryName(path));
				File.WriteAllText(path, contents);
			}
			catch (Exception ex)
			{
				Log.W("Unencrypted save also failed: " + ex.Message);
			}
		}
	}
	public static class MobIcons
	{
		public const int IconSize = 32;

		public const int TrophySize = 32;

		public static readonly string[] OrderedNames = new string[66]
		{
			"Boar", "Deer", "Neck", "Greyling", "Eikthyr", "Greydwarf", "Greydwarf Brute", "Greydwarf Shaman", "Rancid Remains", "Skeleton",
			"Ghost", "Troll", "Bear", "Brenna", "The Elder", "Serpent", "Abomination", "Blob", "Oozer", "Draugr",
			"Draugr Elite", "Leech", "Surtling", "Wraith", "Kvastur", "Bonemass", "Wolf", "Drake", "Fenring", "Stone Golem",
			"Bat", "Ulv", "Cultist", "Geirrhafa", "Moder", "Deathsquito", "Fuling", "Fuling Berserker", "Fuling Shaman", "Growth",
			"Lox", "Vile", "Zil", "Thunder", "Yagluth", "Hare", "Seeker", "Seeker Soldier", "Seeker Brood", "Tick",
			"Gjall", "Dvergr Rogue", "Dvergr Mage", "The Queen", "Bonemaw", "Lava Blob", "Fallen Valkyrie", "Charred Warlock", "Charred Warrior", "Charred Marksman",
			"Charred Twitcher", "Volture", "Morgen", "Asksvin", "Lord Reto", "Fader"
		};

		public static readonly Dictionary<string, string> Icons = new Dictionary<string, string>
		{
			["Boar"] = "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",
			["Deer"] = "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",
			["Neck"] = "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",
			["Greyling"] = "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",
			["Eikthyr"] = "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",
			["Greydwarf"] = "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",
			["Greydwarf Brute"] = "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",
			["Greydwarf Shaman"] = "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