using System;
using System.Buffers.Binary;
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.Net.WebSockets;
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.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using RankedPeak.Live;
using RankedPeak.Localization;
using RankedPeak.Models;
using RankedPeak.Patches;
using RankedPeak.Seeds;
using RankedPeak.Services;
using RankedPeak.Timer;
using RankedPeak.Tracking;
using RankedPeak.Ui;
using RankedPeak.Ui.Menu;
using RankedPeak.Ui.Native;
using RankedPeak.Utils;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.ControllerSupport;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.UI;
using Zorro.UI.Modal;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ThomasAusHH")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("PEAK RANKED - Ranked ELO ladder, monthly seasons, daily cup and 1v1 ghost duels for PEAK, with a speedrun timer underneath. Feedback and bug reports welcome on Discord - the channel is linked in the description below")]
[assembly: AssemblyFileVersion("0.10.3.0")]
[assembly: AssemblyInformationalVersion("0.10.3+5107b4bcc1527fc8dc7195e63ee5fb1142b2248b")]
[assembly: AssemblyProduct("RankedPeak")]
[assembly: AssemblyTitle("RankedPeak")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://discord.gg/nKUHvzdmVp")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.10.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RankedPeak
{
	public enum RankedLogLevel
	{
		Error,
		Warning,
		Info,
		Debug
	}
	internal static class RankedLog
	{
		public static void Error(string message)
		{
			if (Enabled(RankedLogLevel.Error))
			{
				Plugin.Log.LogError((object)message);
			}
		}

		public static void Warning(string message)
		{
			if (Enabled(RankedLogLevel.Warning))
			{
				Plugin.Log.LogWarning((object)message);
			}
		}

		public static void Info(string message)
		{
			if (Enabled(RankedLogLevel.Info))
			{
				Plugin.Log.LogInfo((object)message);
			}
		}

		public static void Debug(string message)
		{
			if (Enabled(RankedLogLevel.Debug))
			{
				Plugin.Log.LogDebug((object)message);
			}
		}

		private static bool Enabled(RankedLogLevel level)
		{
			return level <= (Plugin.LogLevel?.Value ?? RankedLogLevel.Info);
		}
	}
	[BepInPlugin("com.rankedpeak.mod", "PEAK RANKED", "0.10.3")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.rankedpeak.mod";

		public const string PluginName = "PEAK RANKED";

		public const string PluginVersion = "0.10.3";

		public const string VersionLabel = "Beta";

		private Harmony _harmony;

		private RunStorageService _storageService;

		private RaceTimer _raceTimer;

		private ClimbStorageService _climbStorageService;

		private SeedService _seedService;

		public static string DisplayVersion
		{
			get
			{
				if (!string.IsNullOrEmpty("Beta"))
				{
					return "0.10.3 Beta";
				}
				return "0.10.3";
			}
		}

		internal static ManualLogSource Log { get; private set; }

		internal static ConfigEntry<KeyCode> OverlayToggleKey { get; private set; }

		internal static ConfigEntry<float> OverlayPositionX { get; private set; }

		internal static ConfigEntry<float> OverlayPositionY { get; private set; }

		internal static ConfigEntry<KeyCode> RunResetKey { get; private set; }

		internal static ConfigEntry<GameMode> SelectedMode { get; private set; }

		internal static ConfigEntry<bool> DebugSpawnLogging { get; private set; }

		internal static ConfigEntry<RankedLogLevel> LogLevel { get; private set; }

		internal static ConfigEntry<KeyCode> RaceMenuKey { get; private set; }

		internal static ConfigEntry<bool> GhostEnabled { get; private set; }

		internal static ConfigEntry<float> GhostOpacity { get; private set; }

		internal static ConfigEntry<bool> GhostItemsEnabled { get; private set; }

		internal static ConfigEntry<bool> RaceHudEnabled { get; private set; }

		internal static ConfigEntry<float> RaceHudX { get; private set; }

		internal static ConfigEntry<float> RaceHudY { get; private set; }

		internal static ConfigEntry<bool> ComparisonManual { get; private set; }

		internal static ConfigEntry<bool> GhostPanelEnabled { get; private set; }

		internal static ConfigEntry<float> GhostPanelX { get; private set; }

		internal static ConfigEntry<float> GhostPanelY { get; private set; }

		internal static ConfigEntry<bool> UseNativeTimer { get; private set; }

		internal static ConfigEntry<bool> ShowRunSummary { get; private set; }

		internal static ConfigEntry<bool> SummaryMinimized { get; private set; }

		internal static ConfigEntry<KeyCode> SettingsMenuKey { get; private set; }

		internal static ConfigFile ConfigFile { get; private set; }

		internal static RunStorageService StorageService { get; private set; }

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)("PEAK RANKED " + DisplayVersion + " geladen. API: https://followme-peak.ddns.net"));
			InitializeConfig();
			Loc.Initialize();
			InitializeServices();
			ApplyHarmonyPatches();
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void InitializeConfig()
		{
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			ConfigFile = ((BaseUnityPlugin)this).Config;
			OverlayToggleKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Overlay", "ToggleKey", (KeyCode)289, "Hotkey zum Ein-/Ausblenden des Timer-Overlays.");
			OverlayPositionX = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "PositionX", 10f, "Overlay X-Position in Pixeln (von links).");
			OverlayPositionY = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "PositionY", 10f, "Overlay Y-Position in Pixeln (von oben).");
			UseNativeTimer = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "UseNativeTimer", true, "true = natives uGUI-Timer-Panel (E4.3) statt IMGUI-Overlay. Position (PositionX/Y) und Toggle (F8) gelten fuer beide.");
			RunResetKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Controls", "RunResetKey", (KeyCode)0, "Soft-Reset-Hotkey (E1.5): verwirft den laufenden Run und armiert den Timer neu (State -> Armed). KeyCode.None = deaktiviert. Kein hartes Level-Reload - das waere ein Spiel-Logik-Eingriff und bleibt bewusst aussen vor.");
			SelectedMode = ((BaseUnityPlugin)this).Config.Bind<GameMode>("Ranked", "GameMode", GameMode.StaticDaily, "Modus des naechsten Runs. Setzen die Schilder im Hauptmenue - der Wert hier dient nur als Ausgangswert und zur Diagnose.");
			DebugSpawnLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "SpawnLogging", false, "true = loggt jeden Spawn-Vorgang (Spawner, Position, Items) ins BepInEx-Log. Fuer die Seed-Verifikation (docs/seed-spike.md §8): zwei Runs mit gleichem Seed muessen identische Logs liefern. Eigener Schalter, unabhaengig von LogLevel.");
			LogLevel = ((BaseUnityPlugin)this).Config.Bind<RankedLogLevel>("Debug", "LogLevel", RankedLogLevel.Info, "Schwellenwert fuer alle Log-Zeilen des Mods (RankedLog): Error = nur Fehler, Warning = zusaetzlich Warnungen, Info = zusaetzlich normale Ablaufmeldungen (Vorgabe), Debug = zusaetzlich ausfuehrliche Diagnosemeldungen. Wirkt sofort, kein Neustart noetig. Der Start-Banner und das SpawnLogging-Protokoll haengen bewusst nicht an dieser Stufe.");
			RaceMenuKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Controls", "RaceMenuKey", (KeyCode)287, "Hotkey fuer das Race-Menue (Code, Teilnehmer, Verlassen) - auch im Flughafen und waehrend eines Rennens. KeyCode.None = deaktiviert.");
			SettingsMenuKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Controls", "SettingsMenuKey", (KeyCode)288, "Hotkey fuer das Einstellungsfenster (RankedSettingsModal) - im Hauptmenue wie auf dem Berg. Alle Werte dieser Datei lassen sich dort im Spiel setzen; das Fenster ist die eigentliche Bedienung, diese Datei nur ihr Speicherort. KeyCode.None = deaktiviert (dann bleibt das Schild EINSTELLUNGEN im Hauptmenue der einzige Weg).");
			GhostEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Ranked", "GhostEnabled", true, "true = waehrend eines Runs laeuft der eigene PB-Ghost mit (E5.5): ein durchsichtiger, nicht-kollidierender Marker auf dem Pfad des schnellsten eigenen Completed-Climbs (gleiche Map + Modus, lokale climbs.json).");
			GhostOpacity = ((BaseUnityPlugin)this).Config.Bind<float>("Ranked", "GhostOpacity", 0.6f, new ConfigDescription("Deckkraft des Ghosts: 0 = unsichtbar, 1 = undurchsichtig. Wirkt sofort, auch waehrend ein Ghost laeuft. Das Einstellungsfenster bietet drei Stufen an (0.35 / 0.6 / 0.85); hier ist jeder Wert dazwischen erlaubt.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1f), Array.Empty<object>()));
			GhostItemsEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Ranked", "GhostItemsEnabled", true, "true = der Ghost haelt das Item in der Hand, das der Laeufer an dieser Stelle hielt. Aus, wenn das im Rennen zu viel Bewegung im Bild ist - die Aufzeichnung laeuft unabhaengig davon weiter und das Ghost-Panel zeigt das Inventar ohnehin.");
			ComparisonManual = ((BaseUnityPlugin)this).Config.Bind<bool>("Ranked", "ComparisonManual", false, "false = der Vergleich im Timer ist automatisch der schnellste eigene Lauf auf derselben Karte und Strecke. true = es gilt der Lauf, den du in der Rangliste unter MEINE LAEUFE festgenagelt hast; ohne Wahl greift wieder die Automatik.");
			RaceHudEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "RaceHudEnabled", true, "true = waehrend eines Rennens zeigt die Renn-Anzeige den Zwischenstand: Platz, Name, Fortschritt, Leisten und Items je Teilnehmer.");
			RaceHudX = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "RaceHudPositionX", 1510f, "X-Position der Renn-Anzeige in Canvas-Einheiten, von links. Bequemer ueber das Einstellungsfenster zu setzen: dort haengt sich die Anzeige an die Maus.");
			RaceHudY = ((BaseUnityPlugin)this).Config.Bind<float>("Overlay", "RaceHudPositionY", 20f, "Y-Position der Renn-Anzeige in Canvas-Einheiten, von oben.");
			GhostPanelEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Ranked", "GhostPanelEnabled", true, "true = waehrend eines Laufs gegen einen fremden Ghost zeigt ein kleines Panel dessen Uhr, Ausdauer, Statuswerte und Inventar (E5.7).");
			GhostPanelX = ((BaseUnityPlugin)this).Config.Bind<float>("Ranked", "GhostPanelPositionX", 10f, "X-Position des Ghost-Panels in Canvas-Einheiten, von links. Bequemer ueber das Einstellungsfenster zu setzen: dort haengt sich das Panel an die Maus.");
			GhostPanelY = ((BaseUnityPlugin)this).Config.Bind<float>("Ranked", "GhostPanelPositionY", 260f, "Y-Position des Ghost-Panels in Canvas-Einheiten, von oben.");
			SummaryMinimized = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "SummaryMinimized", false, "true = der Ergebnis-Screen erscheint zusammengeklappt als schmale Leiste am unteren Bildrand und gibt den Pfadfinderbericht des Spiels frei. Der Knopf in der Titelleiste des Fensters schreibt diesen Wert - wer einmal zuklappt, bekommt es beim naechsten Lauf gleich klein.");
			ShowRunSummary = ((BaseUnityPlugin)this).Config.Bind<bool>("Overlay", "ShowRunSummary", true, "true = nach Run-Ende erscheint der Summary-Screen (E4.4): Ergebnis, Gesamtzeit, Splits, PB-Vergleich, Upload-Status und Daily-Board-Platzierung. Schliesst automatisch beim naechsten Run.");
		}

		private void InitializeServices()
		{
			//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_0042: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			_storageService = new RunStorageService();
			StorageService = _storageService;
			_raceTimer = new RaceTimer(_storageService);
			_raceTimer.Arm();
			GameObject val = new GameObject("RankedPeak_TimerOverlay");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<TimerOverlay>().Initialize(_raceTimer, _storageService);
			GameObject val2 = new GameObject("RankedPeak_NativeTimerPanel");
			Object.DontDestroyOnLoad((Object)val2);
			val2.AddComponent<NativeTimerPanel>().Initialize(_raceTimer, _storageService);
			GameObject val3 = new GameObject("RankedPeak_RunSummary");
			Object.DontDestroyOnLoad((Object)val3);
			val3.AddComponent<RunSummaryPanel>().Initialize(_raceTimer, _storageService);
			GameObject val4 = new GameObject("RankedPeak_Settings");
			Object.DontDestroyOnLoad((Object)val4);
			val4.AddComponent<RankedSettingsModal>();
			GameObject val5 = new GameObject("RankedPeak_Help");
			Object.DontDestroyOnLoad((Object)val5);
			val5.AddComponent<RankedHelpModal>();
			GameObject val6 = new GameObject("RankedPeak_RunUpload");
			Object.DontDestroyOnLoad((Object)val6);
			RunUploadService uploadService = val6.AddComponent<RunUploadService>();
			GameObject val7 = new GameObject("RankedPeak_RunSentinel");
			Object.DontDestroyOnLoad((Object)val7);
			val7.AddComponent<RunSentinel>();
			_climbStorageService = new ClimbStorageService();
			GameObject val8 = new GameObject("RankedPeak_ClimbTracking");
			Object.DontDestroyOnLoad((Object)val8);
			val8.AddComponent<ClimbTrackingService>().Initialize(_raceTimer, _climbStorageService, uploadService);
			GameObject val9 = new GameObject("RankedPeak_GhostStatus");
			Object.DontDestroyOnLoad((Object)val9);
			val9.AddComponent<GhostStatusPanel>();
			GameObject val10 = new GameObject("RankedPeak_GhostPlayback");
			Object.DontDestroyOnLoad((Object)val10);
			val10.AddComponent<GhostPlaybackService>().Initialize(_raceTimer, _climbStorageService);
			_seedService = new SeedService();
			GameObject val11 = new GameObject("RankedPeak_DailySeed");
			Object.DontDestroyOnLoad((Object)val11);
			val11.AddComponent<DailySeedService>().RefreshIfStale();
			GameObject val12 = new GameObject("RankedPeak_ModAllowlist");
			Object.DontDestroyOnLoad((Object)val12);
			val12.AddComponent<ModAllowlistService>().RefreshIfStale();
			GameObject val13 = new GameObject("RankedPeak_RatingService");
			Object.DontDestroyOnLoad((Object)val13);
			val13.AddComponent<RatingService>();
			GameObject val14 = new GameObject("RankedPeak_DuelService");
			Object.DontDestroyOnLoad((Object)val14);
			val14.AddComponent<DuelService>();
			GameObject val15 = new GameObject("RankedPeak_RaceService");
			Object.DontDestroyOnLoad((Object)val15);
			val15.AddComponent<RaceService>();
			GameObject val16 = new GameObject("RankedPeak_RaceHud");
			Object.DontDestroyOnLoad((Object)val16);
			val16.AddComponent<RaceHudOverlay>();
			val16.AddComponent<RaceCountdownOverlay>();
			GameObject val17 = new GameObject("RankedPeak_AiDisclosureBanner");
			Object.DontDestroyOnLoad((Object)val17);
			val17.AddComponent<AiDisclosureHudBanner>();
			GameObject val18 = new GameObject("RankedPeak_RaceLive");
			Object.DontDestroyOnLoad((Object)val18);
			val18.AddComponent<RaceLiveConnection>();
			GameObject val19 = new GameObject("RankedPeak_LiveGhosts");
			Object.DontDestroyOnLoad((Object)val19);
			val19.AddComponent<LiveGhostManager>();
			GameObject val20 = new GameObject("RankedPeak_UpdateCheck");
			Object.DontDestroyOnLoad((Object)val20);
			val20.AddComponent<UpdateCheckService>();
			RankedLog.Info("Services initialisiert (RaceTimer, RunStorageService, TimerOverlay, ClimbTrackingService, RunUploadService, SeedService, DailySeedService, ModAllowlistService, GhostPlaybackService, RatingService, DuelService, RaceService).");
		}

		private void ApplyHarmonyPatches()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("com.rankedpeak.mod");
			try
			{
				_harmony.PatchAll(typeof(RunLifecyclePatches));
				RunLifecyclePatches.ApplyEndGamePatches(_harmony);
				_harmony.PatchAll(typeof(SeedScopePatches.TrySpawnItemsPatch));
				_harmony.PatchAll(typeof(SeedScopePatches.SpawnItemsPatch));
				_harmony.PatchAll(typeof(SeedScopePatches.GetSpawnSpotsPatch));
				_harmony.PatchAll(typeof(SeedScopePatches.GroundPlaceSpawnerPatch));
				_harmony.PatchAll(typeof(SeedScopePatches.BerryBushPatch));
				_harmony.PatchAll(typeof(SeedScopePatches.BerryVinePatch));
				_harmony.PatchAll(typeof(SeedScopePatches.TempleSeedPatch));
				_harmony.PatchAll(typeof(MainMenuPatches.PageInjectionPatch));
				_harmony.PatchAll(typeof(MainMenuPatches.SignpostPatch));
				_harmony.PatchAll(typeof(BoardingPassPatch));
				_harmony.PatchAll(typeof(RaceInputLockPatch));
				_harmony.PatchAll(typeof(RunSettingsPatch));
				_harmony.PatchAll(typeof(SteamLobbyCreatedPatch));
				SentinelPatches.Apply(_harmony);
				RankedLog.Info("Harmony-Patches angewendet.");
			}
			catch (Exception arg)
			{
				RankedLog.Error($"Harmony-Patching fehlgeschlagen: {arg}");
			}
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			Loc.Refresh();
			try
			{
				if (_raceTimer == null)
				{
					return;
				}
				MapCatalog.LogDiagnostics("Szene '" + ((Scene)(ref scene)).name + "'");
				SentinelPatches.ApplyConsoleGuards(_harmony);
				if (((Scene)(ref scene)).name.StartsWith("Level_"))
				{
					_seedService?.ResetForNewScene();
					if ((Object)(object)DailySeedService.Instance != (Object)null)
					{
						DailySeedService.Instance.RefreshIfStale();
					}
				}
				if ((_raceTimer.State == TimerState.Running || _raceTimer.State == TimerState.WaitingForInput) && !((Scene)(ref scene)).name.StartsWith("Level_"))
				{
					RankedLog.Info("[Plugin] Szenenwechsel nach '" + ((Scene)(ref scene)).name + "' bei aktivem Run - Run abgebrochen.");
					_raceTimer.AbortRun();
				}
				if (!((Scene)(ref scene)).name.StartsWith("Level_"))
				{
					RatingService.Instance?.RefreshRating();
					ModAllowlistService.Instance?.RefreshIfStale();
					RankedGameLauncher.ReapplyForcedLevel();
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[Plugin] Fehler in OnSceneLoaded: {arg}");
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	internal static class BuildInfo
	{
		public const string Version = "0.10.3";

		public const string Label = "Beta";

		public const string ProductName = "PEAK RANKED";

		public const string LanServerUrl = "http://localhost:3000";
	}
}
namespace RankedPeak.Utils
{
	public static class ClimbDataCrusher
	{
		private static class NanCodes
		{
			internal const byte AbsoluteReposition = 1;

			internal const byte AsHalfFloats = 2;
		}

		public static void WriteClimbData(MemoryStream dataStream, List<Vector3> points)
		{
			//IL_0014: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			if (points.Count < 2)
			{
				return;
			}
			byte[] array = new byte[14];
			Vector3 val = points[0];
			EncodePointAsFloats(array, val);
			dataStream.Write(array.AsSpan(0, 12));
			for (int i = 1; i < points.Count; i++)
			{
				Vector3 val2 = points[i];
				QuarterFloat quarter = QuarterFloat.FromFloat(val2.x - val.x);
				QuarterFloat quarter2 = QuarterFloat.FromFloat(val2.y - val.y);
				QuarterFloat quarter3 = QuarterFloat.FromFloat(val2.z - val.z);
				if (quarter.IsInfinity() || quarter2.IsInfinity() || quarter3.IsInfinity())
				{
					HalfFloat half = HalfFloat.FromFloat(val2.x - val.x);
					HalfFloat half2 = HalfFloat.FromFloat(val2.y - val.y);
					HalfFloat half3 = HalfFloat.FromFloat(val2.z - val.z);
					if (half.IsInfinity() || half2.IsInfinity() || half3.IsInfinity())
					{
						EncodeQuarterFloat(array.AsSpan(0, 1), QuarterFloat.EncodeNaN(1));
						EncodePointAsFloats(array.AsSpan(1, 12), val2);
						val = val2;
						dataStream.Write(array.AsSpan(0, 13));
						continue;
					}
					EncodeQuarterFloat(array.AsSpan(0, 1), QuarterFloat.EncodeNaN(2));
					EncodeHalfFloat(array.AsSpan(1, 2), half);
					EncodeHalfFloat(array.AsSpan(3, 2), half2);
					EncodeHalfFloat(array.AsSpan(5, 2), half3);
					val.x += half.ToFloat();
					val.y += half2.ToFloat();
					val.z += half3.ToFloat();
					dataStream.Write(array.AsSpan(0, 7));
				}
				else
				{
					if (quarter.IsZero() && quarter2.IsZero())
					{
						quarter3.IsZero();
					}
					EncodeQuarterFloat(array.AsSpan(0, 1), quarter);
					EncodeQuarterFloat(array.AsSpan(1, 1), quarter2);
					EncodeQuarterFloat(array.AsSpan(2, 1), quarter3);
					val.x += quarter.ToFloat();
					val.y += quarter2.ToFloat();
					val.z += quarter3.ToFloat();
					dataStream.Write(array.AsSpan(0, 3));
				}
			}
		}

		public static List<Vector3> ReadClimbData(byte[] data)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			if (data == null || data.Length < 12)
			{
				return list;
			}
			Vector3 item = DecodePointFromFloats(data.AsSpan(0, 12));
			list.Add(item);
			int num = 12;
			while (num < data.Length)
			{
				QuarterFloat quarterFloat = DecodeQuarterFloat(data.AsSpan(num, 1));
				if (quarterFloat.IsNaN())
				{
					switch (quarterFloat.DecodeNaN())
					{
					case 1:
						item = DecodePointFromFloats(data.AsSpan(num + 1, 12));
						list.Add(item);
						num += 13;
						break;
					case 2:
						item.x += DecodeHalfFloat(data.AsSpan(num + 1, 2)).ToFloat();
						item.y += DecodeHalfFloat(data.AsSpan(num + 3, 2)).ToFloat();
						item.z += DecodeHalfFloat(data.AsSpan(num + 5, 2)).ToFloat();
						list.Add(item);
						num += 7;
						break;
					default:
						throw new InvalidOperationException($"Unexpected NaN code in climb data: {quarterFloat.DecodeNaN()}");
					}
				}
				else
				{
					item.x += quarterFloat.ToFloat();
					item.y += DecodeQuarterFloat(data.AsSpan(num + 1, 1)).ToFloat();
					item.z += DecodeQuarterFloat(data.AsSpan(num + 2, 1)).ToFloat();
					list.Add(item);
					num += 3;
				}
			}
			return list;
		}

		private static void EncodePointAsFloats(Span<byte> span, Vector3 firstPoint)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			EncodeFloat(span.Slice(0, 4), firstPoint.x);
			EncodeFloat(span.Slice(4, 4), firstPoint.y);
			EncodeFloat(span.Slice(8, 4), firstPoint.z);
		}

		private static Vector3 DecodePointFromFloats(Span<byte> data)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(DecodeFloat(data.Slice(0, 4)), DecodeFloat(data.Slice(4, 4)), DecodeFloat(data.Slice(8, 4)));
		}

		private static void EncodeFloat(Span<byte> span, float value)
		{
			BinaryPrimitives.WriteInt32LittleEndian(span, BitConverter.SingleToInt32Bits(value));
		}

		private static float DecodeFloat(Span<byte> span)
		{
			return BitConverter.Int32BitsToSingle(BinaryPrimitives.ReadInt32LittleEndian(span));
		}

		private static void EncodeHalfFloat(Span<byte> span, HalfFloat half)
		{
			BinaryPrimitives.WriteUInt16LittleEndian(span, half.RawValue);
		}

		private static HalfFloat DecodeHalfFloat(Span<byte> span)
		{
			return new HalfFloat
			{
				RawValue = BinaryPrimitives.ReadUInt16LittleEndian(span)
			};
		}

		private static void EncodeQuarterFloat(Span<byte> span, QuarterFloat quarter)
		{
			span[0] = quarter.RawValue;
		}

		private static QuarterFloat DecodeQuarterFloat(Span<byte> span)
		{
			return new QuarterFloat
			{
				RawValue = span[0]
			};
		}
	}
	public struct HalfFloat
	{
		public const byte TotalNumBits = 16;

		public const byte NumExponentBits = 4;

		public const byte NumMantissaBits = 11;

		public const byte SignBitPos = 15;

		private const ushort SignBit = 32768;

		private const ushort ExponentMask = 30720;

		private const ushort MantissaMask = 2047;

		private const ushort ExponentInfinity = 15;

		private const int ExponentBias = 7;

		private const int SingleExponentBias = 127;

		private const byte SingleNumExponentBits = 8;

		private const byte SingleNumMantissaBits = 23;

		private const byte SingleSignBitPos = 31;

		private const uint SingleExponentMask = 2139095040u;

		private const uint SingleMantissaMask = 8388607u;

		private const uint SingleExponentInfinity = 255u;

		public ushort RawValue;

		public static HalfFloat NaN => new HalfFloat
		{
			RawValue = 30721
		};

		public ushort ExponentBits => (ushort)((uint)(RawValue & 0x7800) >> 11);

		public ushort MantissaBits => (ushort)(RawValue & 0x7FF);

		public static HalfFloat FromFloat(float value)
		{
			int num = BitConverter.SingleToInt32Bits(value);
			uint num2 = (uint)num >> 31;
			uint num3 = (uint)(num & 0x7F800000) >> 23;
			uint num4 = (uint)(num & 0x7FFFFF);
			int num5 = (int)(num3 - 127 + 7);
			if (num5 == -11)
			{
				num4 = 0u;
				num5++;
			}
			else if (num5 > -11)
			{
				uint num6 = (uint)(1 << 11 + Math.Max(0, 1 - num5));
				if ((num4 & num6) != 0)
				{
					num4 += num6;
					if ((num4 & 0xFF800000u) != 0)
					{
						num4 = 0u;
						num5++;
					}
				}
			}
			if (num5 >= 15)
			{
				if (num4 != 0 && num3 == 255)
				{
					return NaN;
				}
				num5 = 15;
				num4 = 0u;
			}
			else if (num5 <= 0)
			{
				if (num5 > -11)
				{
					num4 |= 0x800000;
					int num7 = 1 - num5;
					num4 >>= num7;
					num5 = 0;
				}
				else
				{
					num5 = 0;
					num4 = 0u;
				}
			}
			ushort num8 = (ushort)(num2 << 15);
			ushort num9 = (ushort)(num5 << 11);
			ushort num10 = (ushort)(num4 >> 12);
			return new HalfFloat
			{
				RawValue = (ushort)(num8 | num9 | num10)
			};
		}

		public float ToFloat()
		{
			uint num = (uint)((RawValue & 0x8000) << 16);
			uint exponentBits = ExponentBits;
			uint num2 = MantissaBits;
			if (exponentBits == 0 && num2 == 0)
			{
				return BitConverter.Int32BitsToSingle((int)num);
			}
			uint num3 = exponentBits + 127 - 7;
			if (exponentBits == 15)
			{
				num3 = 255u;
			}
			else if (exponentBits == 0)
			{
				while ((num2 & 0x800) == 0)
				{
					num2 <<= 1;
					num3--;
				}
				num2 &= 0x7FF;
				num3++;
			}
			return BitConverter.Int32BitsToSingle((int)(num | (num3 << 23) | (num2 << 12)));
		}

		public static HalfFloat EncodeNaN(ushort value)
		{
			value++;
			ushort num = (ushort)((uint)value >> 11);
			if (num > 1)
			{
				throw new ArgumentOutOfRangeException("value", "Value too large to encode as NaN");
			}
			ushort num2 = (ushort)(value & 0x7FF);
			return new HalfFloat
			{
				RawValue = (ushort)((num << 15) | 0x7800 | num2)
			};
		}

		public ushort DecodeNaN()
		{
			if (!IsNaN())
			{
				throw new InvalidOperationException("Not a NaN value");
			}
			ushort num = (ushort)((RawValue & 0x8000) >>> 15);
			ushort num2 = (ushort)(RawValue & 0x7FF);
			return (ushort)(((num << 11) | num2) - 1);
		}

		public bool IsNaN()
		{
			if (ExponentBits == 15)
			{
				return MantissaBits != 0;
			}
			return false;
		}

		public bool IsInfinity()
		{
			if (ExponentBits == 15)
			{
				return MantissaBits == 0;
			}
			return false;
		}

		public bool IsPositiveInfinity()
		{
			if (IsInfinity())
			{
				return (RawValue & 0x8000) == 0;
			}
			return false;
		}

		public bool IsNegativeInfinity()
		{
			if (IsInfinity())
			{
				return (RawValue & 0x8000) != 0;
			}
			return false;
		}

		public bool IsZero()
		{
			return (RawValue & -32769) == 0;
		}

		public bool IsPositiveZero()
		{
			return RawValue == 0;
		}

		public bool IsNegativeZero()
		{
			return RawValue == 32768;
		}

		public bool IsDenormalized()
		{
			if (ExponentBits == 0)
			{
				return MantissaBits != 0;
			}
			return false;
		}

		public override string ToString()
		{
			return ToFloat().ToString(CultureInfo.InvariantCulture);
		}
	}
	public struct QuarterFloat
	{
		public const byte TotalNumBits = 8;

		public const byte NumExponentBits = 2;

		public const byte NumMantissaBits = 5;

		public const byte SignBitPos = 7;

		private const byte SignBit = 128;

		private const byte ExponentMask = 96;

		private const byte MantissaMask = 31;

		private const byte ExponentInfinity = 3;

		private const int ExponentBias = 1;

		private const int SingleExponentBias = 127;

		private const byte SingleNumExponentBits = 8;

		private const byte SingleNumMantissaBits = 23;

		private const byte SingleSignBitPos = 31;

		private const uint SingleExponentMask = 2139095040u;

		private const uint SingleMantissaMask = 8388607u;

		private const uint SingleExponentInfinity = 255u;

		public byte RawValue;

		public static QuarterFloat NaN => new QuarterFloat
		{
			RawValue = 97
		};

		public byte ExponentBits => (byte)((uint)(RawValue & 0x60) >> 5);

		public byte MantissaBits => (byte)(RawValue & 0x1F);

		public static QuarterFloat FromFloat(float value)
		{
			int num = BitConverter.SingleToInt32Bits(value);
			uint num2 = (uint)num >> 31;
			uint num3 = (uint)(num & 0x7F800000) >> 23;
			uint num4 = (uint)(num & 0x7FFFFF);
			int num5 = (int)(num3 - 127 + 1);
			if (num5 == -5)
			{
				num4 = 0u;
				num5++;
			}
			else if (num5 > -5)
			{
				uint num6 = (uint)(1 << 17 + Math.Max(0, 1 - num5));
				if ((num4 & num6) != 0)
				{
					num4 += num6;
					if ((num4 & 0xFF800000u) != 0)
					{
						num4 = 0u;
						num5++;
					}
				}
			}
			if (num5 >= 3)
			{
				if (num4 != 0 && num3 == 255)
				{
					return NaN;
				}
				num5 = 3;
				num4 = 0u;
			}
			else if (num5 <= 0)
			{
				if (num5 > -5)
				{
					num4 |= 0x800000;
					int num7 = 1 - num5;
					num4 >>= num7;
					num5 = 0;
				}
				else
				{
					num5 = 0;
					num4 = 0u;
				}
			}
			byte b = (byte)(num2 << 7);
			byte b2 = (byte)(num5 << 5);
			byte b3 = (byte)(num4 >> 18);
			return new QuarterFloat
			{
				RawValue = (byte)(b | b2 | b3)
			};
		}

		public float ToFloat()
		{
			uint num = (uint)((RawValue & 0x80) << 24);
			uint exponentBits = ExponentBits;
			uint num2 = MantissaBits;
			if (exponentBits == 0 && num2 == 0)
			{
				return BitConverter.Int32BitsToSingle((int)num);
			}
			uint num3 = exponentBits + 127 - 1;
			if (exponentBits == 3)
			{
				num3 = 255u;
			}
			else if (exponentBits == 0)
			{
				while ((num2 & 0x20) == 0)
				{
					num2 <<= 1;
					num3--;
				}
				num2 &= 0x1F;
				num3++;
			}
			return BitConverter.Int32BitsToSingle((int)(num | (num3 << 23) | (num2 << 18)));
		}

		public static QuarterFloat EncodeNaN(byte value)
		{
			value++;
			byte b = (byte)((uint)value >> 5);
			if (b > 1)
			{
				throw new ArgumentOutOfRangeException("value", "Value too large to encode as NaN");
			}
			byte b2 = (byte)(value & 0x1F);
			return new QuarterFloat
			{
				RawValue = (byte)((b << 7) | 0x60 | b2)
			};
		}

		public byte DecodeNaN()
		{
			if (!IsNaN())
			{
				throw new InvalidOperationException("Not a NaN value");
			}
			byte num = (byte)((RawValue & 0x80) >>> 7);
			byte b = (byte)(RawValue & 0x1F);
			return (byte)(((num << 5) | b) - 1);
		}

		public bool IsNaN()
		{
			if (ExponentBits == 3)
			{
				return MantissaBits != 0;
			}
			return false;
		}

		public bool IsInfinity()
		{
			if (ExponentBits == 3)
			{
				return MantissaBits == 0;
			}
			return false;
		}

		public bool IsPositiveInfinity()
		{
			if (IsInfinity())
			{
				return (RawValue & 0x80) == 0;
			}
			return false;
		}

		public bool IsNegativeInfinity()
		{
			if (IsInfinity())
			{
				return (RawValue & 0x80) != 0;
			}
			return false;
		}

		public bool IsZero()
		{
			return (RawValue & -129) == 0;
		}

		public bool IsPositiveZero()
		{
			return RawValue == 0;
		}

		public bool IsNegativeZero()
		{
			return RawValue == 128;
		}

		public bool IsDenormalized()
		{
			if (ExponentBits == 0)
			{
				return MantissaBits != 0;
			}
			return false;
		}

		public override string ToString()
		{
			return ToFloat().ToString(CultureInfo.InvariantCulture);
		}
	}
	public static class MenuHierarchyDump
	{
		public static void Dump(MainMenuMainPage page)
		{
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[MenuDump] === Title-Menue-Hierarchie ===");
				stringBuilder.AppendLine($"[MenuDump] MainPage '{((Object)page).name}' {RectInfo(((Component)page).transform)} children={((Component)page).transform.childCount}:");
				DumpChildren(stringBuilder, ((Component)page).transform, 1, 1);
				TMP_SpriteAsset[] array = Resources.FindObjectsOfTypeAll<TMP_SpriteAsset>();
				if (array != null && array.Length != 0)
				{
					TMP_SpriteAsset[] array2 = array;
					foreach (TMP_SpriteAsset val in array2)
					{
						string text = ((val.spriteCharacterTable != null) ? string.Join(", ", val.spriteCharacterTable.Select((TMP_SpriteCharacter c) => c.name)) : "keine");
						stringBuilder.AppendLine("[MenuDump] SpriteAsset '" + ((Object)val).name + "': " + text);
					}
				}
				DumpLogoDetail(stringBuilder, ((Component)page).transform.Find("Logo"), "Logo");
				DumpLogoDetail(stringBuilder, ((Component)page).transform.Find("LogoBlack"), "LogoBlack");
				Transform val2 = (((Object)(object)page.m_playButton != (Object)null) ? ((Component)page.m_playButton).transform.parent : null);
				if ((Object)(object)val2 != (Object)null)
				{
					stringBuilder.AppendLine("[MenuDump] Linker Original-Mast (Sign-Container): '" + ((Object)val2).name + "' " + RectInfo(val2));
					DumpChildren(stringBuilder, val2, 1, 4);
					if ((Object)(object)val2.parent != (Object)null && (Object)(object)val2.parent != (Object)(object)((Component)page).transform)
					{
						stringBuilder.AppendLine("[MenuDump] Linker Mast-Parent: '" + ((Object)val2.parent).name + "' " + RectInfo(val2.parent));
						DumpChildren(stringBuilder, val2.parent, 1, 2);
					}
				}
				Transform val3 = ((Component)page).transform.Find("RankedSignpostContainer") ?? (((Object)(object)((val2 != null) ? val2.parent : null) != (Object)null) ? val2.parent.Find("RankedSignpostContainer") : null);
				if ((Object)(object)val3 != (Object)null)
				{
					stringBuilder.AppendLine("[MenuDump] Rechter Ranked-Mast: '" + ((Object)val3).name + "' " + RectInfo(val3));
					DumpChildren(stringBuilder, val3, 1, 2);
				}
				else
				{
					stringBuilder.AppendLine("[MenuDump] Rechter Ranked-Mast: noch nicht gefunden.");
				}
				RankedLog.Debug(stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[MenuDump] Fehler beim Hierarchie-Dump: " + ex.Message);
			}
		}

		private static void DumpLogoDetail(StringBuilder sb, Transform root, string label)
		{
			if ((Object)(object)root == (Object)null)
			{
				sb.AppendLine("[MenuDump] " + label + ": nicht gefunden.");
				return;
			}
			sb.AppendLine("[MenuDump] === " + label + " im Detail ===");
			DumpLogoNode(sb, root, 0);
		}

		private static void DumpLogoNode(StringBuilder sb, Transform node, int indent)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			string text = new string(' ', indent * 2);
			sb.AppendLine($"{text}'{((Object)node).name}' {RectInfo(node)} active={((Component)node).gameObject.activeSelf} ({Components(node)})");
			Graphic component = ((Component)node).GetComponent<Graphic>();
			if ((Object)(object)component != (Object)null)
			{
				Material materialForRendering = component.materialForRendering;
				string text2 = (((Object)(object)materialForRendering != (Object)null && (Object)(object)materialForRendering.shader != (Object)null) ? ((Object)materialForRendering.shader).name : "-");
				string text3 = (((Object)(object)materialForRendering != (Object)null) ? ((Object)materialForRendering).name : "-");
				sb.AppendLine($"{text}  -> Graphic {((object)component).GetType().Name}: color={component.color} material='{text3}' shader='{text2}'");
				Image val = (Image)(object)((component is Image) ? component : null);
				if (val != null)
				{
					string text4 = (((Object)(object)val.sprite != (Object)null) ? ((Object)val.sprite).name : "-");
					string text5 = (((Object)(object)val.sprite != (Object)null && (Object)(object)val.sprite.texture != (Object)null) ? ((Object)val.sprite.texture).name : "-");
					sb.AppendLine($"{text}  -> Image: sprite='{text4}' texture='{text5}' type={val.type} fill={val.fillAmount}");
				}
				if ((Object)(object)materialForRendering != (Object)null)
				{
					string[] texturePropertyNames = materialForRendering.GetTexturePropertyNames();
					if (texturePropertyNames != null && texturePropertyNames.Length != 0)
					{
						sb.AppendLine(text + "  -> Textur-Slots: " + string.Join(", ", texturePropertyNames));
					}
				}
			}
			Mask component2 = ((Component)node).GetComponent<Mask>();
			if ((Object)(object)component2 != (Object)null)
			{
				sb.AppendLine($"{text}  -> Mask: showMaskGraphic={component2.showMaskGraphic}");
			}
			Animator component3 = ((Component)node).GetComponent<Animator>();
			if ((Object)(object)component3 != (Object)null)
			{
				RuntimeAnimatorController runtimeAnimatorController = component3.runtimeAnimatorController;
				string text6 = (((Object)(object)runtimeAnimatorController != (Object)null && runtimeAnimatorController.animationClips != null) ? string.Join(", ", runtimeAnimatorController.animationClips.Select((AnimationClip c) => (!((Object)(object)c != (Object)null)) ? "?" : $"{((Object)c).name} ({c.length:0.##}s, loop={((Motion)c).isLooping})")) : "keine");
				sb.AppendLine(string.Format("{0}  -> Animator: controller='{1}' clips=[{2}] enabled={3} speed={4}", text, ((Object)(object)runtimeAnimatorController != (Object)null) ? ((Object)runtimeAnimatorController).name : "-", text6, ((Behaviour)component3).enabled, component3.speed));
			}
			for (int num = 0; num < node.childCount; num++)
			{
				DumpLogoNode(sb, node.GetChild(num), indent + 1);
			}
		}

		private static void DumpChildren(StringBuilder sb, Transform parent, int indent, int maxDepth)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			string text = new string(' ', indent * 2);
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				TextMeshProUGUI componentInChildren = ((Component)child).GetComponentInChildren<TextMeshProUGUI>(true);
				string text2 = (((Object)(object)componentInChildren != (Object)null) ? (" text='" + ((TMP_Text)componentInChildren).text + "'") : string.Empty);
				Image component = ((Component)child).GetComponent<Image>();
				string text3 = (((Object)(object)component != (Object)null && (Object)(object)component.sprite != (Object)null) ? $" sprite='{((Object)component.sprite).name}' type={component.type}" : string.Empty);
				sb.AppendLine($"{text}[{i}] '{((Object)child).name}' {RectInfo(child)} active={((Component)child).gameObject.activeSelf}{text2}{text3} ({Components(child)})");
				if (indent < maxDepth)
				{
					DumpChildren(sb, child, indent + 1, maxDepth);
				}
			}
		}

		private static string RectInfo(Transform t)
		{
			//IL_0075: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			if (val != null)
			{
				return $"pos={val.anchoredPosition} size={val.sizeDelta} scale={((Transform)val).localScale} pivot={val.pivot} anchorMin={val.anchorMin} anchorMax={val.anchorMax}";
			}
			return $"localPos={t.localPosition} scale={t.localScale}";
		}

		private static string Components(Transform t)
		{
			Component[] components = ((Component)t).GetComponents<Component>();
			string[] array = new string[components.Length];
			for (int i = 0; i < components.Length; i++)
			{
				array[i] = (((Object)(object)components[i] != (Object)null) ? ((object)components[i]).GetType().Name : "?");
			}
			return string.Join(",", array);
		}
	}
}
namespace RankedPeak.Ui
{
	internal static class AiDisclosure
	{
		private static readonly string[] Keys = new string[7] { "aiDisclosure.1", "aiDisclosure.2", "aiDisclosure.3", "aiDisclosure.4", "aiDisclosure.5", "aiDisclosure.6", "aiDisclosure.7" };

		public static int Count => Keys.Length;

		public static string Label => Loc.T("aiDisclosure.label");

		public static string Get(int index)
		{
			return Loc.T(Keys[(index % Keys.Length + Keys.Length) % Keys.Length]);
		}
	}
	public class AiDisclosureHudBanner : MonoBehaviour
	{
		private const float RotateSeconds = 9f;

		private const float PaddingX = 10f;

		private const float PaddingY = 6f;

		private const float Gap = 4f;

		private const float StandaloneWidth = 340f;

		private static readonly Color Background = new Color(0.05f, 0.06f, 0.08f, 0.82f);

		private static readonly Color TextColor = new Color(0.62f, 0.66f, 0.72f);

		private const string LabelColorTag = "#FAB84D";

		private RectTransform _root;

		private TextMeshProUGUI _label;

		private bool _attached;

		private int _index;

		private float _nextRotateAt;

		private string _shown;

		private void Update()
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			RectTransform currentPanel = NativeTimerPanel.CurrentPanel;
			bool flag = (Object)(object)currentPanel != (Object)null;
			if ((Object)(object)_root == (Object)null || flag != _attached || (flag && (Object)(object)((Transform)_root).parent != (Object)(object)currentPanel))
			{
				Build(currentPanel);
			}
			if (!_attached)
			{
				bool visible = TimerOverlay.Visible;
				if (visible)
				{
					NativeUiFactory.EnsureCanvasAlive();
				}
				if (((Component)_root).gameObject.activeSelf != visible)
				{
					((Component)_root).gameObject.SetActive(visible);
				}
				if (!visible)
				{
					return;
				}
			}
			if (Time.time >= _nextRotateAt)
			{
				_index++;
				_nextRotateAt = Time.time + 9f;
				_shown = null;
			}
			string text = "<color=#FAB84D>" + AiDisclosure.Label + "</color>\n" + AiDisclosure.Get(_index);
			if (!(text == _shown))
			{
				_shown = text;
				((TMP_Text)_label).text = text;
				float num = ((TMP_Text)_label).preferredHeight + 12f;
				_root.sizeDelta = (_attached ? new Vector2(0f, num) : new Vector2(340f, num));
			}
		}

		private void Build(RectTransform panel)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_root).gameObject);
			}
			_attached = (Object)(object)panel != (Object)null;
			Image val = PeakWindowStyle.CreateSurface((Transform)(_attached ? ((object)panel) : ((object)(RectTransform)((Component)NativeUiFactory.GetCanvas()).transform)), "RankedPeak_AiDisclosureBanner", Background, 8);
			_root = (RectTransform)((Component)val).transform;
			if (_attached)
			{
				_root.anchorMin = new Vector2(0f, 0f);
				_root.anchorMax = new Vector2(1f, 0f);
				_root.pivot = new Vector2(0.5f, 1f);
				_root.anchoredPosition = new Vector2(0f, -4f);
				_root.sizeDelta = new Vector2(0f, 34f);
			}
			else
			{
				_root.anchorMin = new Vector2(0.5f, 0f);
				_root.anchorMax = new Vector2(0.5f, 0f);
				_root.pivot = new Vector2(0.5f, 0f);
				_root.anchoredPosition = new Vector2(0f, 22f);
				_root.sizeDelta = new Vector2(340f, 34f);
				((Component)_root).gameObject.SetActive(false);
			}
			_label = PeakWindowStyle.CreateText((Transform)(object)_root, "Text", string.Empty, 13f, TextColor, (TextAlignmentOptions)257);
			((TMP_Text)_label).textWrappingMode = (TextWrappingModes)1;
			RectTransform val2 = (RectTransform)((TMP_Text)_label).transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = new Vector2(10f, 6f);
			val2.offsetMax = new Vector2(-10f, -6f);
			_shown = null;
			_nextRotateAt = Time.time + 9f;
		}
	}
	public class CustomRunModal : MenuWindow
	{
		private enum RaceView
		{
			RoleSelect,
			HostSetup,
			JoinEntry
		}

		private const float WindowWidth = 1180f;

		private const float TitleBarHeight = 82f;

		private const float WindowPadding = 26f;

		private const float BoxPadding = 24f;

		private const float BoxGap = 14f;

		private const float BodyBottomPadding = 18f;

		private const int MinSeed = 100000000;

		private const int MaxSeed = 999999999;

		private const int MaxParticipantRows = 8;

		private const float ModeRowY = 8f;

		private const float ModeRowHeight = 44f;

		private const float MountainBoxHeight = 194f;

		private const float RandomBoxHeight = 96f;

		private const float AscentBoxHeight = 128f;

		private const float RouteBoxHeight = 146f;

		private const float RaceBoxHeight = 214f;

		private const float RoleBoxHeight = 170f;

		private const float FooterHeight = 52f;

		private const float SeedRowY = 50f;

		private const float MapRowY = 112f;

		private const float MapHintY = 160f;

		private const float RaceRow1Y = 50f;

		private const float RaceRow2Y = 104f;

		private const float RaceRow3Y = 160f;

		private static CustomRunModal _speedrunInstance;

		private static CustomRunModal _raceInstance;

		private RaceView _view;

		private RectTransform _root;

		private PeakWindowStyle.WindowParts _window;

		private TMP_InputField _seedInput;

		private TMP_InputField _codeInput;

		private TextMeshProUGUI _ascentDescriptionLabel;

		private TextMeshProUGUI _routeDescriptionLabel;

		private TextMeshProUGUI _summaryLabel;

		private TextMeshProUGUI _levelLabel;

		private TextMeshProUGUI _levelDescriptionLabel;

		private TextMeshProUGUI _playersLabel;

		private TextMeshProUGUI _codeLabel;

		private TextMeshProUGUI _modeHintLabel;

		private TextMeshProUGUI _joinHintLabel;

		private RectTransform _mountainBox;

		private RectTransform _randomBox;

		private RectTransform _ascentBox;

		private RectTransform _routeBox;

		private RectTransform _raceBox;

		private RectTransform _roleBox;

		private Button _staticModeButton;

		private Button _randomModeButton;

		private Button _dailyButton;

		private Button _copySeedButton;

		private Button _levelPrevButton;

		private Button _levelNextButton;

		private Button _todayButton;

		private Button _playersPrevButton;

		private Button _playersNextButton;

		private Button _autoStartButton;

		private Button _rivalsButton;

		private Button _startButton;

		private Button _cancelButton;

		private Button _backButton;

		private Button _createButton;

		private Button _hostStartButton;

		private Button _leaveButton;

		private Button _copyCodeButton;

		private Button _waitingAreaButton;

		private Button _joinButton;

		private readonly List<Button> _ascentPills = new List<Button>();

		private readonly List<Button> _routePills = new List<Button>();

		private readonly List<TextMeshProUGUI> _participantRows = new List<TextMeshProUGUI>();

		private bool _built;

		private bool _raceMode;

		private bool _randomMode;

		private int _seed = 100000000;

		private int _ascent;

		private int _routeIndex;

		private int _levelSlot;

		private int _maxPlayers = 4;

		private bool _autoStart = true;

		private bool _showRivals;

		private GameObject _panelPlaceholder;

		public override bool openOnStart => false;

		public override bool selectOnOpen => false;

		public override GameObject panel
		{
			get
			{
				if (!((Object)(object)_root != (Object)null))
				{
					return _panelPlaceholder;
				}
				return ((Component)_root).gameObject;
			}
		}

		private void Awake()
		{
			_seed = Random.Range(100000000, 999999999);
		}

		public override void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_panelPlaceholder = new GameObject("PanelPlaceholder");
			_panelPlaceholder.transform.SetParent(((Component)this).transform, false);
			_panelPlaceholder.SetActive(false);
		}

		public static void OpenSpeedrun()
		{
			OpenModal(raceMode: false);
		}

		public static void OpenRace()
		{
			OpenModal(raceMode: true);
		}

		private static void OpenModal(bool raceMode)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (RaceService.Instance?.CurrentRace != null)
			{
				raceMode = true;
			}
			CustomRunModal customRunModal = (raceMode ? _raceInstance : _speedrunInstance);
			if ((Object)(object)customRunModal == (Object)null)
			{
				Canvas canvas = NativeUiFactory.GetCanvas();
				GameObject val = new GameObject(raceMode ? "RankedPeak_RaceModal" : "RankedPeak_SpeedrunModal");
				val.transform.SetParent(((Component)canvas).transform, false);
				customRunModal = val.AddComponent<CustomRunModal>();
				customRunModal._raceMode = raceMode;
				if (raceMode)
				{
					_raceInstance = customRunModal;
				}
				else
				{
					_speedrunInstance = customRunModal;
				}
			}
			CustomRunModal customRunModal2 = (raceMode ? _speedrunInstance : _raceInstance);
			if ((Object)(object)customRunModal2 != (Object)null && (Object)(object)customRunModal2 != (Object)(object)customRunModal)
			{
				customRunModal2.CloseModal();
			}
			customRunModal.ShowModal();
		}

		public void ShowModal()
		{
			if (!_built || (Object)(object)_root == (Object)null)
			{
				BuildUi();
			}
			if (_raceMode && RaceService.Instance?.CurrentRace == null)
			{
				_view = RaceView.RoleSelect;
			}
			_levelSlot = MapCatalog.SlotOf(MapCatalog.CurrentLevelIndex);
			RefreshDisplay();
			((MenuWindow)this).Open();
			NativeUiFactory.EnsureTopMost();
		}

		public void CloseModal()
		{
			((MenuWindow)this).Close();
		}

		private void OnEnable()
		{
			RaceService.RaceUpdated += OnRaceUpdated;
			Loc.LanguageChanged += OnLanguageChanged;
		}

		private void OnDisable()
		{
			RaceService.RaceUpdated -= OnRaceUpdated;
			Loc.LanguageChanged -= OnLanguageChanged;
		}

		private void OnLanguageChanged()
		{
			if (_built)
			{
				bool isOpen = ((MenuWindow)this).isOpen;
				if (isOpen)
				{
					CloseModal();
				}
				if ((Object)(object)_root != (Object)null)
				{
					((Component)_root).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)_root).gameObject);
					_root = null;
				}
				_built = false;
				_ascentPills.Clear();
				_routePills.Clear();
				_participantRows.Clear();
				if (isOpen)
				{
					ShowModal();
				}
			}
		}

		private void OnRaceUpdated(RaceInfo race)
		{
			if (_raceMode)
			{
				RefreshDisplay();
				if (race != null && (race.Status == "loading" || race.Status == "countdown"))
				{
					CloseModal();
				}
			}
		}

		public override void Update()
		{
			if (((MenuWindow)this).isOpen && !((Object)(object)_root == (Object)null))
			{
				bool flag = ((Object)(object)_seedInput != (Object)null && _seedInput.isFocused) || ((Object)(object)_codeInput != (Object)null && _codeInput.isFocused);
				if (Input.GetKeyDown((KeyCode)27) && !flag)
				{
					CloseModal();
				}
			}
		}

		private void BuildUi()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0054: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			_built = true;
			Canvas canvas = NativeUiFactory.GetCanvas();
			GameObject val = new GameObject("CustomModalRoot", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)canvas).transform, false);
			_root = (RectTransform)val.transform;
			_root.anchorMin = Vector2.zero;
			_root.anchorMax = Vector2.one;
			_root.offsetMin = Vector2.zero;
			_root.offsetMax = Vector2.zero;
			PeakWindowStyle.CreateBackdrop((Transform)(object)_root, "Backdrop");
			_window = PeakWindowStyle.CreateWindow((Transform)(object)_root, "CustomWindow", 1180f, 900f, 82f, Loc.T(_raceMode ? "mode.liveRace" : "mode.speedrun"), Loc.T(_raceMode ? "run.race.subtitle" : "run.speedrun.subtitle"));
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)_window.TitleBar, "BtnClose", "X", 1094f, 20f, 48f, 42f, 24f);
			Image component = ((Component)obj).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(1f, 1f, 1f, 0.22f);
			}
			((UnityEvent)obj.onClick).AddListener(new UnityAction(CloseModal));
			RectTransform body = _window.Body;
			float innerWidth = 1128f;
			if (_raceMode)
			{
				BuildRoleBox(body, innerWidth);
			}
			BuildModeRow(body, innerWidth);
			BuildMountainBox(body, innerWidth);
			BuildRandomBox(body, innerWidth);
			BuildAscentBox(body, innerWidth);
			BuildRouteBox(body, innerWidth);
			if (_raceMode)
			{
				BuildRaceBox(body, innerWidth);
			}
			BuildFooter(body, innerWidth);
		}

		private void BuildRoleBox(RectTransform body, float innerWidth)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			_roleBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxRole", Loc.T("race.role.box"), 26f, 0f, innerWidth, 170f);
			float num = innerWidth - 48f;
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)_roleBox, "BtnRoleHost", Loc.T("race.role.host"), 24f, 52f, num / 2f - 7f, 56f, 21f).onClick).AddListener((UnityAction)delegate
			{
				_view = RaceView.HostSetup;
				RefreshDisplay();
			});
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)_roleBox, "BtnRoleJoin", Loc.T("race.role.join"), 24f + num / 2f + 7f, 52f, num / 2f - 7f, 56f, 21f);
			PeakWindowStyle.SetPillSelected(obj, selected: false);
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				_view = RaceView.JoinEntry;
				RefreshDisplay();
			});
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)_roleBox, "RoleHint", Loc.T("race.role.hint"), 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513)).transform, 24f, 120f, num, 34f);
		}

		private void BuildModeRow(RectTransform body, float innerWidth)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			_staticModeButton = PeakWindowStyle.CreatePill((Transform)(object)body, "ModeStatic", Loc.T("run.mode.static"), 26f, 8f, 220f, 44f);
			((UnityEvent)_staticModeButton.onClick).AddListener((UnityAction)delegate
			{
				SetRandomMode(randomMode: false);
			});
			_randomModeButton = PeakWindowStyle.CreatePill((Transform)(object)body, "ModeRandom", Loc.T("run.mode.random"), 254f, 8f, 220f, 44f);
			((UnityEvent)_randomModeButton.onClick).AddListener((UnityAction)delegate
			{
				SetRandomMode(randomMode: true);
			});
			_modeHintLabel = PeakWindowStyle.CreateText((Transform)(object)body, "ModeHint", Loc.T("run.mode.hint"), 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_modeHintLabel).transform, 494f, 8f, innerWidth - 468f, 44f);
		}

		private void BuildMountainBox(RectTransform body, float innerWidth)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Expected O, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Expected O, but got Unknown
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Expected O, but got Unknown
			_mountainBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxMountain", Loc.T("run.box.mountain"), 26f, 0f, innerWidth, 194f);
			float num = innerWidth - 48f;
			_seedInput = PeakWindowStyle.CreateInputField((Transform)(object)_mountainBox, "SeedInput", _seed.ToString(), 24f, 50f, 340f, 52f, 30f);
			_seedInput.characterLimit = 9;
			((UnityEvent<string>)(object)_seedInput.onValueChanged).AddListener((UnityAction<string>)OnSeedTyped);
			((UnityEvent<string>)(object)_seedInput.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				PushRaceConfig();
			});
			_dailyButton = PeakWindowStyle.CreatePill((Transform)(object)_mountainBox, "BtnDailySeed", Loc.T("run.btn.daily"), 380f, 50f, 150f, 52f, 19f);
			((UnityEvent)_dailyButton.onClick).AddListener(new UnityAction(UseDailySeed));
			_copySeedButton = PeakWindowStyle.CreatePill((Transform)(object)_mountainBox, "BtnCopySeed", Loc.T("run.btn.copySeed"), 540f, 50f, 180f, 52f, 19f);
			((UnityEvent)_copySeedButton.onClick).AddListener(new UnityAction(CopySeed));
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)_mountainBox, "SeedHint", Loc.T("run.seed.hint"), 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513)).transform, 736f, 50f, num - 712f, 52f);
			_levelPrevButton = PeakWindowStyle.CreatePill((Transform)(object)_mountainBox, "BtnLevelPrev", "<", 24f, 112f, 52f, 42f);
			((UnityEvent)_levelPrevButton.onClick).AddListener((UnityAction)delegate
			{
				StepLevel(-1);
			});
			_levelLabel = PeakWindowStyle.CreateText((Transform)(object)_mountainBox, "LevelLabel", string.Empty, 20f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)514);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_levelLabel).transform, 82f, 112f, 200f, 42f);
			_levelNextButton = PeakWindowStyle.CreatePill((Transform)(object)_mountainBox, "BtnLevelNext", ">", 288f, 112f, 52f, 42f);
			((UnityEvent)_levelNextButton.onClick).AddListener((UnityAction)delegate
			{
				StepLevel(1);
			});
			_todayButton = PeakWindowStyle.CreatePill((Transform)(object)_mountainBox, "BtnLevelToday", Loc.T("run.btn.today"), 348f, 112f, 120f, 42f, 18f);
			((UnityEvent)_todayButton.onClick).AddListener((UnityAction)delegate
			{
				_levelSlot = MapCatalog.SlotOf(MapCatalog.CurrentLevelIndex);
				PushRaceConfig();
				RefreshDisplay();
			});
			_levelDescriptionLabel = PeakWindowStyle.CreateText((Transform)(object)_mountainBox, "LevelDescription", string.Empty, 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_levelDescriptionLabel).transform, 24f, 160f, num, 24f);
		}

		private void BuildRandomBox(RectTransform body, float innerWidth)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			_randomBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxRandom", Loc.T("run.box.random"), 26f, 0f, innerWidth, 96f);
			float width = innerWidth - 48f;
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)_randomBox, "RandomHint", Loc.T(_raceMode ? "run.random.hint.race" : "run.random.hint.solo"), 21f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513)).transform, 24f, 52f, width, 34f);
		}

		private void BuildAscentBox(RectTransform body, float innerWidth)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			_ascentBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxAscent", Loc.T("run.box.ascent"), 26f, 0f, innerWidth, 128f);
			float num = innerWidth - 48f;
			int num2 = Mathf.Max(1, RunConfigService.MaxAscent);
			int num3 = num2 + 2;
			float num4 = Mathf.Clamp((num - 140f - 110f - 8f * (float)(num3 - 1)) / (float)num2, 44f, 110f);
			float num5 = 24f;
			for (int i = -1; i <= RunConfigService.MaxAscent; i++)
			{
				float num6 = i switch
				{
					0 => 110f, 
					-1 => 140f, 
					_ => num4, 
				};
				int value = i;
				Button val = PeakWindowStyle.CreatePill((Transform)(object)_ascentBox, $"Ascent{i}", RunConfigService.GetAscentShortName(i), num5, 46f, num6, 44f, 19f);
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					_ascent = value;
					PushRaceConfig();
					RefreshDisplay();
				});
				_ascentPills.Add(val);
				num5 += num6 + 8f;
			}
			_ascentDescriptionLabel = PeakWindowStyle.CreateText((Transform)(object)_ascentBox, "AscentDescription", string.Empty, 20f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_ascentDescriptionLabel).transform, 24f, 96f, num, 28f);
		}

		private void BuildRouteBox(RectTransform body, float innerWidth)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			_routeBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxRoute", Loc.T("run.box.route"), 26f, 0f, innerWidth, 146f);
			float width = innerWidth - 48f;
			float num = 24f;
			for (int i = 0; i < RunConfigService.RouteCount; i++)
			{
				float num2 = ((i == 0) ? 220f : 145f);
				int value = i;
				Button val = PeakWindowStyle.CreatePill((Transform)(object)_routeBox, $"Route{i}", RunConfigService.GetRouteName(i), num, 46f, num2, 44f, 19f);
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					_routeIndex = value;
					PushRaceConfig();
					RefreshDisplay();
				});
				_routePills.Add(val);
				num += num2 + 8f;
			}
			_routeDescriptionLabel = PeakWindowStyle.CreateText((Transform)(object)_routeBox, "RouteDescription", string.Empty, 20f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_routeDescriptionLabel).transform, 24f, 94f, width, 26f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)_routeBox, "RouteLimitHint", Loc.T("run.route.limitHint", RunConfigService.MiniRunBiomeCount), 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513)).transform, 24f, 118f, width, 24f);
		}

		private void BuildRaceBox(RectTransform body, float innerWidth)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Expected O, but got Unknown
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Expected O, but got Unknown
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Expected O, but got Unknown
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Expected O, but got Unknown
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Expected O, but got Unknown
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Expected O, but got Unknown
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Expected O, but got Unknown
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_056b: Expected O, but got Unknown
			_raceBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxRace", Loc.T("run.box.race"), 26f, 0f, innerWidth, 214f);
			float num = innerWidth - 48f;
			_playersPrevButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnPlayersPrev", "-", 24f, 50f, 52f, 42f);
			((UnityEvent)_playersPrevButton.onClick).AddListener((UnityAction)delegate
			{
				_maxPlayers = Mathf.Max(2, _maxPlayers - 1);
				PushRaceConfig();
				RefreshDisplay();
			});
			_playersLabel = PeakWindowStyle.CreateText((Transform)(object)_raceBox, "PlayersLabel", string.Empty, 20f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)514);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_playersLabel).transform, 82f, 50f, 150f, 42f);
			_playersNextButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnPlayersNext", "+", 238f, 50f, 52f, 42f);
			((UnityEvent)_playersNextButton.onClick).AddListener((UnityAction)delegate
			{
				_maxPlayers = Mathf.Min(8, _maxPlayers + 1);
				PushRaceConfig();
				RefreshDisplay();
			});
			_autoStartButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnAutoStart", Loc.T("run.btn.autoStart"), 314f, 50f, 200f, 42f, 18f);
			((UnityEvent)_autoStartButton.onClick).AddListener((UnityAction)delegate
			{
				_autoStart = !_autoStart;
				PushRaceConfig();
				RefreshDisplay();
			});
			_rivalsButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnRivals", Loc.T("run.btn.rivals"), 524f, 50f, 240f, 42f, 16f);
			((UnityEvent)_rivalsButton.onClick).AddListener((UnityAction)delegate
			{
				_showRivals = !_showRivals;
				PushRaceConfig();
				RefreshDisplay();
			});
			_codeLabel = PeakWindowStyle.CreateText((Transform)(object)_raceBox, "CodeLabel", string.Empty, 30f, PeakWindowStyle.Heading, (TextAlignmentOptions)516, display: false, 8f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_codeLabel).transform, 24f + num - 320f, 50f, 320f, 42f);
			_joinHintLabel = PeakWindowStyle.CreateText((Transform)(object)_raceBox, "JoinHint", Loc.T("race.join.hint"), 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_joinHintLabel).transform, 24f, 50f, num, 42f);
			_codeInput = PeakWindowStyle.CreateInputField((Transform)(object)_raceBox, "CodeInput", string.Empty, 24f, 104f, 200f, 46f, 24f);
			_codeInput.characterLimit = 6;
			_codeInput.contentType = (ContentType)4;
			_joinButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnJoin", Loc.T("run.btn.join"), 236f, 104f, 190f, 46f, 19f);
			((UnityEvent)_joinButton.onClick).AddListener(new UnityAction(JoinRace));
			_createButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnCreateRace", Loc.T("run.btn.create"), 444f, 104f, 300f, 46f, 19f);
			((UnityEvent)_createButton.onClick).AddListener(new UnityAction(CreateRace));
			_copyCodeButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnCopyCode", Loc.T("run.btn.copyCode"), 24f, 104f, 240f, 46f, 18f);
			((UnityEvent)_copyCodeButton.onClick).AddListener(new UnityAction(CopyInviteCode));
			_waitingAreaButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnWaitingArea", Loc.T("run.btn.airport"), 274f, 104f, 260f, 46f, 18f);
			((UnityEvent)_waitingAreaButton.onClick).AddListener(new UnityAction(GoToWaitingArea));
			_hostStartButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnHostStart", Loc.T("run.btn.startRace"), 544f, 104f, 270f, 46f, 19f);
			((UnityEvent)_hostStartButton.onClick).AddListener((UnityAction)delegate
			{
				RaceService.Instance?.StartRace(delegate(string err)
				{
					SetSummary(Loc.T("run.msg.startFailed", err));
				});
			});
			_leaveButton = PeakWindowStyle.CreatePill((Transform)(object)_raceBox, "BtnLeaveRace", Loc.T("run.btn.leave"), 824f, 104f, 240f, 46f, 19f);
			PeakWindowStyle.SetPillSelected(_leaveButton, selected: false);
			((UnityEvent)_leaveButton.onClick).AddListener((UnityAction)delegate
			{
				RaceService.Instance?.LeaveRace();
				SetSummary(Loc.T("run.msg.left"));
			});
			for (int num2 = 0; num2 < 8; num2++)
			{
				TextMeshProUGUI val = PeakWindowStyle.CreateText((Transform)(object)_raceBox, $"Participant{num2}", string.Empty, 18f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val).transform, 24f + (float)(num2 % 4) * (num / 4f), 160f + (float)(num2 / 4) * 22f, num / 4f, 22f);
				((Component)val).gameObject.SetActive(false);
				_participantRows.Add(val);
			}
		}

		private void StepLevel(int direction)
		{
			int slotCount = MapCatalog.SlotCount;
			if (slotCount > 0)
			{
				_levelSlot = ((_levelSlot + direction) % slotCount + slotCount) % slotCount;
				PushRaceConfig();
				RefreshDisplay();
			}
		}

		private void BuildFooter(RectTransform body, float innerWidth)
		{
			//IL_0011: 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_0090: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			_summaryLabel = PeakWindowStyle.CreateText((Transform)(object)body, "Summary", string.Empty, 21f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
			_backButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnBack", Loc.T("run.btn.back"), 26f, 0f, 200f, 52f);
			PeakWindowStyle.SetPillSelected(_backButton, selected: false);
			((UnityEvent)_backButton.onClick).AddListener((UnityAction)delegate
			{
				_view = RaceView.RoleSelect;
				RefreshDisplay();
			});
			_cancelButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnCancel", Loc.T("run.btn.cancel"), 26f, 0f, 220f, 52f);
			PeakWindowStyle.SetPillSelected(_cancelButton, selected: false);
			((UnityEvent)_cancelButton.onClick).AddListener(new UnityAction(CloseModal));
			_startButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnStart", Loc.T("run.btn.start"), 26f, 0f, 270f, 52f, 22f);
			((UnityEvent)_startButton.onClick).AddListener(new UnityAction(StartSoloRun));
		}

		private void SetRandomMode(bool randomMode)
		{
			_randomMode = randomMode;
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			if (randomMode && raceInfo != null)
			{
				RaceService instance = RaceService.Instance;
				if (instance != null && instance.IsHost && raceInfo.Status == "lobby")
				{
					RollRandomIfNeeded();
				}
			}
			PushRaceConfig();
			RefreshDisplay();
		}

		private void OnSeedTyped(string value)
		{
			if (int.TryParse(value, out var result))
			{
				_seed = result;
				RefreshSummary();
			}
		}

		private void SetSeed(int seed)
		{
			_seed = seed;
			if ((Object)(object)_seedInput != (Object)null)
			{
				_seedInput.SetTextWithoutNotify(_seed.ToString());
			}
			RefreshSummary();
		}

		private void UseDailySeed()
		{
			if ((Object)(object)DailySeedService.Instance != (Object)null && DailySeedService.Instance.HasValidServerSeed)
			{
				SetSeed(DailySeedService.Instance.ServerSeed);
				PushRaceConfig();
			}
			else
			{
				SetSummary(Loc.T("run.msg.noDailySeed"));
			}
		}

		private void CopySeed()
		{
			GUIUtility.systemCopyBuffer = _seed.ToString();
			SetSummary(Loc.T("run.msg.seedCopied", _seed));
		}

		private void RollRandomIfNeeded()
		{
			if (_randomMode)
			{
				_seed = Random.Range(100000000, 999999999);
				int slotCount = MapCatalog.SlotCount;
				_levelSlot = ((slotCount > 0) ? Random.Range(0, slotCount) : 0);
			}
		}

		private void PushRaceConfig()
		{
			RaceService instance = RaceService.Instance;
			RaceInfo raceInfo = instance?.CurrentRace;
			if (_raceMode && !((Object)(object)instance == (Object)null) && raceInfo != null && instance.IsHost && !(raceInfo.Status != "lobby"))
			{
				instance.UpdateRaceConfig(_seed, _levelSlot, _ascent, _routeIndex, _maxPlayers, _autoStart, _showRivals, _randomMode, delegate(string err)
				{
					SetSummary(Loc.T("run.msg.configFailed", err));
				});
			}
		}

		private void StartSoloRun()
		{
			RollRandomIfNeeded();
			string sceneName = MapCatalog.GetSceneName(_levelSlot);
			RankedLog.Info("[CustomRun] Starte Speedrun (" + (_randomMode ? "RANDOM" : "STATIC") + ") - " + $"Seed {_seed}, Karte {sceneName} " + $"(Slot {_levelSlot}, Spiel {MapCatalog.GameVersion}), " + RunConfigService.GetAscentName(_ascent) + ", " + RunConfigService.GetRouteName(_routeIndex));
			SeedService.Instance?.SetOverrideSeed(_seed);
			if (!RankedRunGate.Select(GameMode.Speedrun, _levelSlot, _randomMode))
			{
				SeedService.Instance?.ClearOverrideSeed();
				RankedNoticeModal.Show(Loc.T("gate.mapAltered.title"), RankedRunGate.LastRefusal);
				return;
			}
			RunConfigService.ApplyCustomRun(_ascent, _routeIndex);
			RankedGameLauncher.ForceLevelIndex(_levelSlot);
			GhostPlaybackService.Instance?.ClearExternalGhost();
			CloseModal();
			RankedGameLauncher.LaunchDirectToIsland();
		}

		private void CreateRace()
		{
			RollRandomIfNeeded();
			SetSummary(Loc.T("run.msg.creating"));
			RaceService.Instance?.CreateRace(_seed, _levelSlot, _ascent, _routeIndex, _maxPlayers, _autoStart, _showRivals, _randomMode, delegate(RaceInfo race)
			{
				SetSummary(Loc.T("run.msg.created", race.InviteCode));
			}, delegate(string err)
			{
				SetSummary(Loc.T("run.msg.createFailed", err));
			});
		}

		private void JoinRace()
		{
			string text = (((Object)(object)_codeInput != (Object)null) ? _codeInput.text.Trim() : string.Empty);
			if (text.Length < 4)
			{
				SetSummary(Loc.T("run.msg.codeTooShort"));
				return;
			}
			SetSummary(Loc.T("run.msg.joining", text.ToUpperInvariant()));
			RaceService.Instance?.JoinRace(text, delegate(RaceInfo race)
			{
				SetSummary(Loc.T("run.msg.joined", race.Participants.Count, race.MaxPlayers));
			}, delegate(string err)
			{
				SetSummary(Loc.T("run.msg.joinFailed", err));
			});
		}

		private void GoToWaitingArea()
		{
			CloseModal();
			RaceService.Instance?.EnterWaitingArea();
		}

		private void CopyInviteCode()
		{
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			if (raceInfo != null)
			{
				GUIUtility.systemCopyBuffer = raceInfo.InviteCode;
				SetSummary(Loc.T("run.msg.codeCopied", raceInfo.InviteCode));
			}
		}

		private void RefreshDisplay()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			if (!_built)
			{
				return;
			}
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			bool flag = raceInfo != null;
			bool flag2 = RaceService.Instance?.IsHost ?? false;
			if (_raceMode && flag)
			{
				_seed = raceInfo.Seed;
				_levelSlot = raceInfo.LevelIndex;
				_ascent = raceInfo.Ascent;
				_routeIndex = raceInfo.Route;
				_maxPlayers = raceInfo.MaxPlayers;
				_autoStart = raceInfo.AutoStart;
				_showRivals = raceInfo.GhostsVisible;
				_randomMode = raceInfo.SecretSeed;
			}
			bool interactable = !_raceMode || (!flag && _view == RaceView.HostSetup) || (flag && flag2 && raceInfo.Status == "lobby");
			PeakWindowStyle.SetPillSelected(_staticModeButton, !_randomMode);
			PeakWindowStyle.SetPillSelected(_randomModeButton, _randomMode, PeakWindowStyle.PillAccent);
			((Selectable)_staticModeButton).interactable = interactable;
			((Selectable)_randomModeButton).interactable = interactable;
			RefreshLayout();
			((Component)_startButton).gameObject.SetActive(!_raceMode);
			if ((Object)(object)_seedInput != (Object)null)
			{
				((Selectable)_seedInput).interactable = interactable;
				if (!_seedInput.isFocused)
				{
					_seedInput.SetTextWithoutNotify(_seed.ToString());
				}
			}
			for (int i = 0; i < _ascentPills.Count; i++)
			{
				PeakWindowStyle.SetPillSelected(_ascentPills[i], -1 + i == _ascent);
				((Selectable)_ascentPills[i]).interactable = interactable;
			}
			for (int j = 0; j < _routePills.Count; j++)
			{
				PeakWindowStyle.SetPillSelected(_routePills[j], j == _routeIndex);
				((Selectable)_routePills[j]).interactable = interactable;
			}
			((Selectable)_levelPrevButton).interactable = interactable;
			((Selectable)_levelNextButton).interactable = interactable;
			((Selectable)_todayButton).interactable = interactable;
			((Selectable)_dailyButton).interactable = interactable;
			((Selectable)_copySeedButton).interactable = interactable;
			((TMP_Text)_ascentDescriptionLabel).text = "<color=#" + ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Heading) + ">" + RunConfigService.GetAscentName(_ascent) + "</color>   " + RunConfigService.GetAscentDescription(_ascent);
			((TMP_Text)_routeDescriptionLabel).text = RunConfigService.GetRouteDescription(_routeIndex);
			RefreshLevelDisplay();
			if (_raceMode)
			{
				RefreshRaceSection(raceInfo, flag, flag2);
			}
			RefreshSummary();
		}

		private void RefreshLayout()
		{
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Expected O, but got Unknown
			//IL_0326: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Expected O, but got Unknown
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Expected O, but got Unknown
			float num = 1128f;
			bool flag = RaceService.Instance?.CurrentRace != null;
			bool flag2 = _raceMode && !flag && _view == RaceView.RoleSelect;
			bool flag3 = _raceMode && !flag && _view == RaceView.JoinEntry;
			bool flag4 = !_raceMode || flag || _view == RaceView.HostSetup;
			((Component)_staticModeButton).gameObject.SetActive(flag4);
			((Component)_randomModeButton).gameObject.SetActive(flag4);
			((Component)_modeHintLabel).gameObject.SetActive(flag4);
			if ((Object)(object)_roleBox != (Object)null)
			{
				((Component)_roleBox).gameObject.SetActive(flag2);
			}
			bool flag5 = !flag2 && !flag3;
			((Component)_mountainBox).gameObject.SetActive(flag5 && !_randomMode);
			((Component)_randomBox).gameObject.SetActive(flag5 && _randomMode);
			((Component)_ascentBox).gameObject.SetActive(flag5);
			((Component)_routeBox).gameObject.SetActive(flag5);
			if ((Object)(object)_raceBox != (Object)null)
			{
				((Component)_raceBox).gameObject.SetActive(_raceMode && !flag2);
			}
			float num2 = 8f;
			if (flag2)
			{
				NativeUiFactory.Place(_roleBox, 26f, num2, num, 170f);
				num2 += 184f;
			}
			else if (flag3)
			{
				NativeUiFactory.Place(_raceBox, 26f, num2, num, 214f);
				num2 += 228f;
			}
			else
			{
				if (flag4)
				{
					num2 += 58f;
				}
				if (_randomMode)
				{
					NativeUiFactory.Place(_randomBox, 26f, num2, num, 96f);
					num2 += 110f;
				}
				else
				{
					NativeUiFactory.Place(_mountainBox, 26f, num2, num, 194f);
					num2 += 208f;
				}
				NativeUiFactory.Place(_ascentBox, 26f, num2, num, 128f);
				num2 += 142f;
				NativeUiFactory.Place(_routeBox, 26f, num2, num, 146f);
				num2 += 160f;
				if (_raceMode && (Object)(object)_raceBox != (Object)null)
				{
					NativeUiFactory.Place(_raceBox, 26f, num2, num, 214f);
					num2 += 228f;
				}
			}
			bool flag6 = _raceMode && !flag && _view != RaceView.RoleSelect;
			if ((Object)(object)_backButton != (Object)null)
			{
				((Component)_backButton).gameObject.SetActive(flag6);
				if (flag6)
				{
					NativeUiFactory.Place((RectTransform)((Component)_backButton).transform, 26f + num - 730f, num2, 200f, 52f);
				}
			}
			NativeUiFactory.Place((RectTransform)((TMP_Text)_summaryLabel).transform, 26f, num2, num - (flag6 ? 760f : 520f), 52f);
			NativeUiFactory.Place((RectTransform)((Component)_cancelButton).transform, 26f + num - 500f, num2, 220f, 52f);
			NativeUiFactory.Place((RectTransform)((Component)_startButton).transform, 26f + num - 270f, num2, 270f, 52f);
			float num3 = num2 + 52f + 18f;
			PeakWindowStyle.ResizeWindow(_window, 1180f, num3 + 82f + 14f, 82f);
		}

		private void RefreshLevelDisplay()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_levelLabel == (Object)null)
			{
				return;
			}
			string sceneName = MapCatalog.GetSceneName(_levelSlot);
			((TMP_Text)_levelLabel).text = (string.IsNullOrEmpty(sceneName) ? Loc.T("run.level.slot", _levelSlot) : sceneName);
			if (!((Object)(object)_levelDescriptionLabel == (Object)null))
			{
				int slotCount = MapCatalog.SlotCount;
				if (slotCount <= 0)
				{
					((TMP_Text)_levelDescriptionLabel).text = Loc.T("run.level.noCatalog");
					return;
				}
				string text = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted);
				bool flag = _levelSlot == MapCatalog.SlotOf(MapCatalog.CurrentLevelIndex);
				string text2 = ((!MapCatalog.IsSlotAuthentic(_levelSlot)) ? ("   <color=#" + text + ">·</color>   <color=#" + ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Danger) + ">" + Loc.T("run.level.swapped", MapCatalog.ExpectedSceneName(_levelSlot)) + "</color>") : string.Empty);
				((TMP_Text)_levelDescriptionLabel).text = Loc.T("run.level.map", _levelSlot + 1, slotCount) + "   <color=#" + text + ">·</color>   " + Loc.T("run.level.biomes", MapCatalog.GetBiomeLabel(_levelSlot)) + "   <color=#" + text + ">·</color>   " + Loc.T("run.level.version", MapCatalog.GameVersion, MapCatalog.MapSetHash) + (flag ? ("   <color=#" + text + ">·</color>   " + Loc.T("run.level.today")) : string.Empty) + text2;
			}
		}

		private void RefreshRaceSection(RaceInfo race, bool inRace, bool isHost)
		{
			bool flag = !inRace && _view == RaceView.JoinEntry;
			bool flag2 = !inRace && _view == RaceView.HostSetup;
			bool flag3 = inRace && isHost && race.Status == "lobby";
			((TMP_Text)_playersLabel).text = Loc.T("run.players", inRace ? race.MaxPlayers : _maxPlayers);
			((Component)_playersLabel).gameObject.SetActive(!flag);
			((Component)_playersPrevButton).gameObject.SetActive(flag2 || flag3);
			((Component)_playersNextButton).gameObject.SetActive(flag2 || flag3);
			((Component)_autoStartButton).gameObject.SetActive(flag2 || inRace);
			((Selectable)_autoStartButton).interactable = flag2 || flag3;
			PeakWindowStyle.SetPillSelected(_autoStartButton, inRace ? race.AutoStart : _autoStart);
			((Component)_rivalsButton).gameObject.SetActive(flag2 || inRace);
			((Selectable)_rivalsButton).interactable = flag2 || flag3;
			PeakWindowStyle.SetPillSelected(_rivalsButton, inRace ? race.GhostsVisible : _showRivals);
			((Component)_joinHintLabel).gameObject.SetActive(flag);
			((TMP_Text)_codeLabel).text = (inRace ? race.InviteCode : string.Empty);
			((Component)_codeLabel).gameObject.SetActive(inRace);
			((Component)_codeInput).gameObject.SetActive(flag);
			((Component)_joinButton).gameObject.SetActive(flag);
			((Component)_createButton).gameObject.SetActive(flag2);
			((Component)_copyCodeButton).gameObject.SetActive(inRace);
			((Component)_waitingAreaButton).gameObject.SetActive(inRace);
			((Component)_hostStartButton).gameObject.SetActive(inRace && isHost);
			((Component)_leaveButton).gameObject.SetActive(inRace);
			for (int i = 0; i < _participantRows.Count; i++)
			{
				bool flag4 = inRace && i < race.Participants.Count;
				((Component)_participantRows[i]).gameObject.SetActive(flag4);
				if (flag4)
				{
					RaceParticipant raceParticipant = race.Participants[i];
					bool flag5 = raceParticipant.SteamId == race.HostSteamId;
					((TMP_Text)_participantRows[i]).text = raceParticipant.PlayerName + (flag5 ? (" (" + Loc.T("common.host") + ")") : string.Empty);
				}
			}
		}

		private void SetSummary(string text)
		{
			if ((Object)(object)_summaryLabel != (Object)null)
			{
				((TMP_Text)_summaryLabel).text = text;
			}
			RankedLog.Info("[Custom] " + text);
		}

		private void RefreshSummary()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_summaryLabel == (Object)null))
			{
				string text = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted);
				string text2 = "<color=#" + text + ">" + Loc.T("run.summary.seed") + "</color>";
				string text3 = (_randomMode ? (text2 + " ???   <color=#" + text + ">·</color>   ???") : ($"{text2} {_seed}   " + "<color=#" + text + ">·</color>   " + MapCatalog.GetSceneName(_levelSlot)));
				((TMP_Text)_summaryLabel).text = text3 + "   <color=#" + text + ">·</color>   " + RunConfigService.GetAscentName(_ascent) + "   <color=#" + text + ">·</color>   " + RunConfigService.GetRouteName(_routeIndex);
			}
		}
	}
	public class EndScreenTakeover : MonoBehaviour
	{
		private const float StandingsRefreshSeconds = 0.5f;

		private TMP_Text _timeLabel;

		private string _timeText = string.Empty;

		private TMP_Text[] _bannerLabels = Array.Empty<TMP_Text>();

		private string _bannerText = string.Empty;

		private RectTransform _standingsContent;

		private TMP_Text _standingsTemplate;

		private readonly List<TextMeshProUGUI> _standingRows = new List<TextMeshProUGUI>();

		private float _nextStandingsRefresh;

		public void Initialize(TMP_Text timeLabel, string timeText, TMP_Text[] bannerLabels, string bannerText)
		{
			_timeLabel = timeLabel;
			_timeText = timeText;
			_bannerLabels = bannerLabels ?? Array.Empty<TMP_Text>();
			_bannerText = bannerText;
		}

		private void RefreshBannerText()
		{
			RaceService instance = RaceService.Instance;
			RaceInfo raceInfo = instance?.CurrentRace ?? instance?.LastFinishedRace;
			if (raceInfo != null)
			{
				RaceParticipant raceParticipant = raceInfo.Participants.Find((RaceParticipant p) => p.SteamId == SteamIdentity.GetSteamId64());
				if (raceParticipant != null && raceParticipant.Rank.HasValue)
				{
					_bannerText = ((raceParticipant.Rank == 1) ? Loc.T("verdict.raceWon") : Loc.T("verdict.placeN", raceParticipant.Rank));
				}
			}
		}

		public void TrackStandings(RectTransform content, TMP_Text template, List<TextMeshProUGUI> rows)
		{
			_standingsContent = content;
			_standingsTemplate = template;
			_standingRows.Clear();
			_standingRows.AddRange(rows);
		}

		private void LateUpdate()
		{
			if ((Object)(object)_timeLabel != (Object)null && _timeLabel.text != _timeText)
			{
				_timeLabel.text = _timeText;
			}
			TMP_Text[] bannerLabels = _bannerLabels;
			foreach (TMP_Text val in bannerLabels)
			{
				if ((Object)(object)val != (Object)null && val.text != _bannerText)
				{
					val.text = _bannerText;
				}
			}
			if (!((Object)(object)_standingsContent == (Object)null) && !(Time.unscaledTime < _nextStandingsRefresh))
			{
				_nextStandingsRefresh = Time.unscaledTime + 0.5f;
				RefreshBannerText();
				RefreshStandings();
			}
		}

		private void RefreshStandings()
		{
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			RaceService instance = RaceService.Instance;
			RaceInfo raceInfo = instance?.CurrentRace ?? instance?.LastFinishedRace;
			if (raceInfo == null)
			{
				return;
			}
			List<RaceParticipant> list = new List<RaceParticipant>(raceInfo.Participants);
			list.Sort(CompareStandings);
			string steamId = SteamIdentity.GetSteamId64();
			for (int i = 0; i < _standingRows.Count; i++)
			{
				bool flag = i < list.Count;
				((Component)_standingRows[i]).gameObject.SetActive(flag);
				if (flag)
				{
					RaceParticipant raceParticipant = list[i];
					string text = (raceParticipant.Rank.HasValue ? $"#{raceParticipant.Rank.Value}" : "-");
					string state = raceParticipant.State;
					string text2 = ((state == "finished") ? (raceParticipant.TotalMs.HasValue ? FormatTime(raceParticipant.TotalMs.Value) : Loc.T("state.finished")) : ((!(state == "dnf")) ? $"{Mathf.RoundToInt(raceParticipant.Progress * 100f)} %" : Loc.T("state.dnf")));
					string text3 = text2;
					((TMP_Text)_standingRows[i]).text = text + "<pos=45%>" + raceParticipant.PlayerName + "<pos=80%>" + text3;
					Color color = (Color)(((Object)(object)_standingsTemplate != (Object)null) ? ((Graphic)_standingsTemplate).color : new Color(0.25f, 0.22f, 0.19f));
					color.a = ((raceParticipant.SteamId == steamId) ? 1f : 0.8f);
					((Graphic)_standingRows[i]).color = color;
				}
			}
		}

		private static int CompareStandings(RaceParticipant a, RaceParticipant b)
		{
			int num = Weight(a).CompareTo(Weight(b));
			if (num != 0)
			{
				return num;
			}
			if (Weight(a) == 0)
			{
				return (a.Rank ?? int.MaxValue).CompareTo(b.Rank ?? int.MaxValue);
			}
			return b.Progress.CompareTo(a.Progress);
			static int Weight(RaceParticipant p)
			{
				if (!(p.State == "finished"))
				{
					if (!(p.State == "dnf"))
					{
						return 1;
					}
					return 2;
				}
				return 0;
			}
		}

		private static string FormatTime(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			return $"{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}
	}
	public class GhostStatusPanel : MonoBehaviour
	{
		private const float PanelWidth = 214f;

		private const float Padding = 10f;

		private const float BarHeight = 7f;

		private const float IconSize = 26f;

		private const float IconGap = 3f;

		private const int TopSlots = 4;

		private const int BottomSlots = 5;

		private static readonly Color Background = new Color(0.05f, 0.06f, 0.08f, 0.82f);

		private static readonly Color TextPrimary = new Color(0.94f, 0.95f, 0.97f);

		private static readonly Color TextMuted = new Color(0.62f, 0.66f, 0.72f);

		private static readonly Color Accent = new Color(0.45f, 0.72f, 1f);

		private static readonly Color Ahead = new Color(0.35f, 0.85f, 0.45f);

		private static readonly Color Behind = new Color(0.95f, 0.45f, 0.35f);

		private RectTransform _panel;

		private TextMeshProUGUI _nameLabel;

		private TextMeshProUGUI _clockLabel;

		private TextMeshProUGUI _deltaLabel;

		private StatusBarStrip _statusBar;

		private HudBar _adrenalineBar;

		private ItemIconRow _topIcons;

		private ItemIconRow _bottomIcons;

		private float _heightWithoutBottomRow;

		private bool _built;

		private readonly List<float> _statusBuffer = new List<float>();

		public static bool PreviewMode { get; set; }

		private void Update()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (_built && (Object)(object)_panel == (Object)null)
			{
				_built = false;
			}
			if (!_built)
			{
				BuildPanel();
			}
			GhostPlaybackService instance = GhostPlaybackService.Instance;
			bool flag = Plugin.GhostPanelEnabled.Value && (Object)(object)instance != (Object)null && instance.IsGhostRunning && instance.IsExternalGhostActive && TimerOverlay.Visible;
			bool flag2 = flag || PreviewMode;
			((Component)_panel).gameObject.SetActive(flag2);
			if (flag2)
			{
				NativeUiFactory.EnsureCanvasAlive();
				_panel.anchoredPosition = new Vector2(Plugin.GhostPanelX.Value, 0f - Plugin.GhostPanelY.Value);
				if (flag)
				{
					Refresh(instance);
				}
				else
				{
					RefreshPreview();
				}
			}
		}

		private void BuildPanel()
		{
			//IL_0016: 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_0033: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			_built = true;
			Image val = PeakWindowStyle.CreateSurface(((Component)NativeUiFactory.GetCanvas()).transform, "RankedPeak_GhostStatus", Background, 8);
			_panel = (RectTransform)((Component)val).transform;
			_panel.anchorMin = new Vector2(0f, 1f);
			_panel.anchorMax = new Vector2(0f, 1f);
			_panel.pivot = new Vector2(0f, 1f);
			float num = 10f;
			float num2 = 194f;
			_nameLabel = PeakWindowStyle.CreateText((Transform)(object)_panel, "Name", string.Empty, 15f, Accent, (TextAlignmentOptions)513, display: false, 1f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_nameLabel).transform, 10f, num, num2, 18f);
			num += 19f;
			_clockLabel = PeakWindowStyle.CreateText((Transform)(object)_panel, "Clock", string.Empty, 21f, TextPrimary, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_clockLabel).transform, 10f, num, num2 * 0.56f, 24f);
			_deltaLabel = PeakWindowStyle.CreateText((Transform)(object)_panel, "Delta", string.Empty, 15f, TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_deltaLabel).transform, 10f + num2 * 0.56f, num + 5f, num2 * 0.44f, 20f);
			num += 27f;
			_statusBar = StatusBarStrip.Create((Transform)(object)_panel, "StatusBar", 10f, num, num2, 7f);
			num += 10f;
			_adrenalineBar = HudBar.Create((Transform)(object)_panel, "Adrenaline", 10f, num, num2 * 0.5f, 7f);
			num += 14f;
			_topIcons = ItemIconRow.Create((Transform)(object)_panel, "Held", 10f, num, 26f, 3f, 4);
			num += 26f;
			_heightWithoutBottomRow = num + 10f;
			_bottomIcons = ItemIconRow.Create((Transform)(object)_panel, "Pack", 10f, num + 3f, 26f, 3f, 5, 0);
			_panel.sizeDelta = new Vector2(214f, _heightWithoutBottomRow);
			((Component)_panel).gameObject.SetActive(false);
		}

		private void Refresh(GhostPlaybackService ghost)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			string text = (string.IsNullOrEmpty(ghost.CurrentGhostPlayerName) ? Loc.T("ghostPanel.title") : ghost.CurrentGhostPlayerName.ToUpperInvariant());
			((TMP_Text)_nameLabel).text = Loc.T("ghostPanel.nameSuffix", text);
			((TMP_Text)_clockLabel).text = FormatTime(ghost.GhostElapsedMs);
			((Graphic)_clockLabel).color = (ghost.GhostFinished ? TextMuted : TextPrimary);
			RefreshDelta(ghost);
			RefreshBars(ghost.CurrentBars);
			RefreshIcons(ghost.CurrentInventory);
		}

		private void RefreshPreview()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_nameLabel).text = Loc.T("ghostPanel.nameSuffix", Loc.T("ghostPanel.title"));
			((TMP_Text)_clockLabel).text = "12:34.5";
			((Graphic)_clockLabel).color = TextPrimary;
			((Component)_deltaLabel).gameObject.SetActive(true);
			((TMP_Text)_deltaLabel).text = Loc.T("ghostPanel.remaining", "1:20");
			((Graphic)_deltaLabel).color = Ahead;
			_statusBuffer.Clear();
			for (int i = 0; i < GhostStateTrack.StatusCount; i++)
			{
				_statusBuffer.Add(i switch
				{
					1 => 0.12f, 
					2 => 0.18f, 
					_ => 0f, 
				});
			}
			_statusBar.SetActive(active: true);
			_statusBar.Set(0.55f, _statusBuffer);
			_adrenalineBar.SetActive(active: true);
			_adrenalineBar.Set(0.4f, AfflictionPalette.Adrenaline);
			_topIcons.ShowSlots(4);
			for (int j = 0; j < 4; j++)
			{
				_topIcons.Set(j, ushort.MaxValue, j == 0);
			}
			_bottomIcons.ShowSlots(5);
			for (int k = 0; k < 5; k++)
			{
				_bottomIcons.Set(k, ushort.MaxValue);
			}
			_panel.sizeDelta = new Vector2(214f, _heightWithoutBottomRow + 26f + 3f);
		}

		private void RefreshDelta(GhostPlaybackService ghost)
		{
			//IL_00a3: 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)
			if (ghost.CurrentGhostTotalMs <= 0)
			{
				((Component)_deltaLabel).gameObject.SetActive(false);
				return;
			}
			((Component)_deltaLabel).gameObject.SetActive(true);
			if (ghost.GhostFinished)
			{
				((TMP_Text)_deltaLabel).text = "+" + FormatShort(ghost.OwnElapsedMs - ghost.CurrentGhostTotalMs);
				((Graphic)_deltaLabel).color = Behind;
			}
			else
			{
				((TMP_Text)_deltaLabel).text = Loc.T("ghostPanel.remaining", FormatShort(ghost.CurrentGhostTotalMs - ghost.GhostElapsedMs));
				((Graphic)_deltaLabel).color = Ahead;
			}
		}

		private void RefreshBars(byte[] bars)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			bool flag = bars != null;
			_statusBar.SetActive(flag);
			if (!flag)
			{
				_adrenalineBar.SetActive(active: false);
				return;
			}
			_statusBuffer.Clear();
			for (int i = 0; i < GhostStateTrack.StatusCount; i++)
			{
				_statusBuffer.Add(GhostStateTrack.StatusFrom(bars, (STATUSTYPE)i));
			}
			_statusBar.Set(GhostStateTrack.StaminaFrom(bars), _statusBuffer);
			float num = GhostStateTrack.ExtraStaminaFrom(bars);
			_adrenalineBar.SetActive(num > 0.001f);
			_adrenalineBar.Set(num, AfflictionPalette.Adrenaline);
		}

		private void RefreshIcons(InventorySnapshot inventory)
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (inventory == null)
			{
				ShowHeldOnly();
				return;
			}
			_topIcons.ShowSlots(4);
			_topIcons.Set(0, inventory.Hand, isHand: true);
			for (int i = 0; i < 3; i++)
			{
				_topIcons.Set(1 + i, inventory.Belt[i]);
			}
			if (inventory.BackpackType == 0)
			{
				_bottomIcons.ShowSlots(0);
				_panel.sizeDelta = new Vector2(214f, _heightWithoutBottomRow);
				return;
			}
			int num = Mathf.Clamp((int)inventory.BackpackSlots, 0, 4);
			_bottomIcons.ShowSlots(1 + num);
			_bottomIcons.SetBackpack(0, inventory.BackpackType);
			for (int j = 0; j < num; j++)
			{
				_bottomIcons.Set(1 + j, inventory.BackpackItems[j]);
			}
			_panel.sizeDelta = new Vector2(214f, _heightWithoutBottomRow + 26f + 3f);
		}

		private void ShowHeldOnly()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			_topIcons.ShowSlots(4);
			for (int i = 0; i < 4; i++)
			{
				_topIcons.Set(i, ushort.MaxValue, i == 0);
			}
			_bottomIcons.ShowSlots(0);
			_panel.sizeDelta = new Vector2(214f, _heightWithoutBottomRow);
		}

		private static string FormatTime(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			return $"{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds / 100}";
		}

		private static string FormatShort(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(Math.Abs(ms));
			if (!(timeSpan.TotalMinutes >= 1.0))
			{
				return $"{timeSpan.Seconds}.{timeSpan.Milliseconds / 100}s";
			}
			return $"{(int)timeSpan.TotalMinutes}:{timeSpan.Seconds:00}";
		}
	}
	public class NativeTimerPanel : MonoBehaviour
	{
		private class SplitRow
		{
			public RectTransform Root;

			public TextMeshProUGUI Name;

			public TextMeshProUGUI Delta;

			public TextMeshProUGUI Time;
		}

		private const float PanelWidth = 340f;

		private const float Padding = 12f;

		private const float MetaLineHeight = 20f;

		private const float SplitRowHeight = 26f;

		private const float TimeHeight = 56f;

		private const int MaxSplitRows = 8;

		private const string MonoDigits = "<mspace=0.58em>";

		private static readonly Color Background = new Color(0.05f, 0.06f, 0.08f, 0.82f);

		private static readonly Color RowBackground = new Color(1f, 1f, 1f, 0.05f);

		private static readonly Color TextPrimary = new Color(0.94f, 0.95f, 0.97f);

		private static readonly Color TextMuted = new Color(0.62f, 0.66f, 0.72f);

		private static readonly Color Ahead = new Color(0.35f, 0.85f, 0.45f);

		private static readonly Color Behind = new Color(0.94f, 0.42f, 0.38f);

		private static readonly Color Gold = new Color(1f, 0.82f, 0.25f);

		private static readonly Color Accent = new Color(0.45f, 0.72f, 1f);

		private static readonly Color Warning = new Color(0.98f, 0.72f, 0.3f);

		private RaceTimer _timer;

		private RunStorageService _storage;

		private RectTransform _panel;

		private TextMeshProUGUI _titleLabel;

		private TextMeshProUGUI _metaLabel;

		private TextMeshProUGUI _timeLabel;

		private TextMeshProUGUI _comparisonLabel;

		private TextMeshProUGUI _sobLabel;

		private TextMeshProUGUI _statusLabel;

		private readonly List<SplitRow> _splitRows = new List<SplitRow>();

		private bool _built;

		private bool _wasActive;

		private SplitComparison _comparison;

		private string _comparisonKey;

		public static bool PreviewMode { get; set; }

		public static RectTransform CurrentPanel { get; private set; }

		public void Initialize(RaceTimer timer, RunStorageService storage)
		{
			_timer = timer;
			_storage = storage;
		}

		private void Update()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (_timer != null)
			{
				if (_built && (Object)(object)_panel == (Object)null)
				{
					_built = false;
					_splitRows.Clear();
				}
				if (!_built)
				{
					BuildPanel();
				}
				bool flag = (Plugin.UseNativeTimer.Value && TimerOverlay.Visible) || PreviewMode;
				if (flag)
				{
					NativeUiFactory.EnsureCanvasAlive();
				}
				((Component)_panel).gameObject.SetActive(flag);
				if (flag && !_wasActive)
				{
					NativeUiFactory.EnsureTopMost();
				}
				_wasActive = flag;
				if (((Component)_panel).gameObject.activeSelf)
				{
					_panel.anchoredPosition = new Vector2(Plugin.OverlayPositionX.Value, 0f - Plugin.OverlayPositionY.Value);
					RefreshContent();
				}
			}
		}

		private void BuildPanel()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			_built = true;
			Image val = PeakWindowStyle.CreateSurface(((Component)NativeUiFactory.GetCanvas()).transform, "RankedPeak_TimerPanel", Background, 10);
			_panel = (RectTransform)((Component)val).transform;
			NativeUiFactory.Place(_panel, 10f, 10f, 340f, 400f);
			CurrentPanel = _panel;
			float num = 316f;
			_titleLabel = CreateLabel("Title", 19f, TextPrimary, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_titleLabel).transform, 12f, 12f, num, 24f);
			_metaLabel = CreateLabel("Meta", 14f, TextMuted, (TextAlignmentOptions)513);
			((TMP_Text)_metaLabel).textWrappingMode = (TextWrappingModes)1;
			NativeUiFactory.Place((RectTransform)((TMP_Text)_metaLabel).transform, 12f, 36f, num, 40f);
			for (int i = 0; i < 8; i++)
			{
				_splitRows.Add(CreateSplitRow(i, num));
			}
			_timeLabel = CreateLabel("Time", 44f, TextPrimary, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_timeLabel).transform, 12f, 0f, num, 56f);
			_comparisonLabel = CreateLabel("Comparison", 15f, TextMuted, (TextAlignmentOptions)513);
			_sobLabel = CreateLabel("SumOfBest", 15f, TextMuted, (TextAlignmentOptions)513);
			_statusLabel = CreateLabel("Status", 16f, Accent, (TextAlignmentOptions)513);
		}

		private SplitRow CreateSplitRow(int index, float contentWidth)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			Image obj = PeakWindowStyle.CreateSurface((Transform)(object)_panel, $"Split{index}", Color.clear, 6);
			RectTransform val = (RectTransform)((Component)obj).transform;
			NativeUiFactory.Place(val, 8f, 0f, contentWidth + 8f, 26f);
			TextMeshProUGUI val2 = CreateLabel("Name", 16f, TextPrimary, (TextAlignmentOptions)513, (Transform)(object)val);
			NativeUiFactory.Place((RectTransform)((TMP_Text)val2).transform, 6f, 0f, contentWidth * 0.52f, 26f);
			TextMeshProUGUI val3 = CreateLabel("Delta", 15f, TextMuted, (TextAlignmentOptions)516, (Transform)(object)val);
			NativeUiFactory.Place((RectTransform)((TMP_Text)val3).transform, contentWidth * 0.45f, 0f, contentWidth * 0.22f, 26f);
			TextMeshProUGUI val4 = CreateLabel("Time", 16f, TextPrimary, (TextAlignmentOptions)516, (Transform)(object)val);
			NativeUiFactory.Place((RectTransform)((TMP_Text)val4).transform, contentWidth * 0.66f, 0f, contentWidth * 0.34f, 26f);
			((Component)obj).gameObject.SetActive(false);
			return new SplitRow
			{
				Root = val,
				Name = val2,
				Delta = val3,
				Time = val4
			};
		}

		private TextMeshProUGUI CreateLabel(string name, float fontSize, Color color, TextAlignmentOptions alignment, Transform parent = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI obj = PeakWindowStyle.CreateText((Transform)(((object)parent) ?? ((object)_panel)), name, string.Empty, fontSize, color, alignment);
			((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)0;
			return obj;
		}

		private void RefreshContent()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			GameMode gameMode = ((_timer.State == TimerState.Running || _timer.State == TimerState.Finished) ? _timer.CurrentMode : Plugin.SelectedMode.Value);
			EnsureComparison(gameMode);
			float num = 316f;
			float num2 = 12f;
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			string text = ((raceInfo != null) ? ("RACE " + raceInfo.InviteCode) : ModeName(gameMode));
			string text2 = ((gameMode == GameMode.Vanilla) ? Hex(Warning) : Hex(TextMuted));
			((TMP_Text)_titleLabel).text = ((gameMode == GameMode.Vanilla) ? ("PEAK RANKED  <color=#" + text2 + ">·  " + text + "</color>") : ("PEAK RANKED  <color=#" + text2 + ">·</color>  " + text));
			num2 += 24f;
			string text3 = ((raceInfo != null) ? ("   " + RunConfigService.GetRouteName(raceInfo.Route)) : string.Empty);
			string text4 = ((_timer.CurrentSeed >= 0) ? _timer.CurrentSeed.ToString() : "-");
			string text5 = ((gameMode == GameMode.Vanilla) ? (Loc.T("hud.meta.ascent", _timer.CurrentAscentLevel) + "   " + _timer.CurrentMapName + text3 + "\n<color=#" + Hex(Warning) + ">" + Loc.T("hud.vanilla.note") + "</color>") : (Loc.T("hud.meta.seed", text4) + "   " + Loc.T("hud.meta.ascent", _timer.CurrentAscentLevel) + "   " + _timer.CurrentMapName + text3 + "\nRTA · PEAK RANKED " + Plugin.DisplayVersion));
			((TMP_Text)_metaLabel).text = text5;
			NativeUiFactory.Place((RectTransform)((TMP_Text)_metaLabel).transform, 12f, num2, num, 40f);
			num2 += 44f;
			num2 = RefreshSplits(num2, num);
			((TMP_Text)_timeLabel).text = "<mspace=0.58em>" + FormatTime(_timer.CurrentElapsedMs);
			((Graphic)_timeLabel).color = CurrentTimeColor();
			NativeUiFactory.Place((RectTransform)((TMP_Text)_timeLabel).transform, 12f, num2, num, 56f);
			num2 += 56f;
			num2 = RefreshFooter(num2, num, gameMode);
			_panel.sizeDelta = new Vector2(340f, num2 + 12f);
		}

		private float PreviewSplits(float y, float contentWidth)
		{
			for (int i = 0; i < _splitRows.Count; i++)
			{
				SplitRow splitRow = _splitRows[i];
				bool flag = i < 4;
				((Component)splitRow.Root).gameObject.SetActive(flag);
				if (flag)
				{
					NativeUiFactory.Place(splitRow.Root, 8f, y, contentWidth + 8f, 26f);
					y += 26f;
					((TMP_Text)splitRow.Name).text = Loc.T("hud.preview.segment", i + 1);
					((TMP_Text)splitRow.Delta).text = string.Empty;
					((TMP_Text)splitRow.Time).text = "--:--";
				}
			}
			return y;
		}

		private float RefreshSplits(float y, float contentWidth)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			if (PreviewMode)
			{
				return PreviewSplits(y, contentWidth);
			}
			IReadOnlyList<SplitRecord> splits = _timer.Splits;
			bool flag = _timer.State == TimerState.Running;
			int num = splits.Count + (flag ? 1 : 0);
			int num2 = Math.Max(0, num - 8);
			for (int i = 0; i < _splitRows.Count; i++)
			{
				SplitRow splitRow = _splitRows[i];
				int num3 = num2 + i;
				if (num3 >= num)
				{
					((Component)splitRow.Root).gameObject.SetActive(false);
					continue;
				}
				((Component)splitRow.Root).gameObject.SetActive(true);
				NativeUiFactory.Place(splitRow.Root, 8f, y, contentWidth + 8f, 26f);
				y += 26f;
				Image component = ((Component)splitRow.Root).GetComponent<Image>();
				if (flag && num3 == splits.Count)
				{
					if ((Object)(object)component != (Object)null)
					{
						((Graphic)component).color = RowBackground;
					}
					((TMP_Text)splitRow.Name).text = "…";
					((Graphic)splitRow.Name).color = TextMuted;
					((TMP_Text)splitRow.Time).text = string.Empty;
					SetLiveDelta(splitRow, num3);
					continue;
				}
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = Color.clear;
				}
				SplitRecord splitRecord = splits[num3];
				long num4 = ((num3 > 0) ? splits[num3 - 1].ElapsedMs : 0);
				long num5 = splitRecord.ElapsedMs - num4;
				((TMP_Text)splitRow.Name).text = splitRecord.SegmentName;
				((Graphic)splitRow.Name).color = TextPrimary;
				((TMP_Text)splitRow.Time).text = "<mspace=0.58em>" + FormatTime(splitRecord.ElapsedMs);
				long? num6 = _comparison?.GetBestSegmentMs(num3);
				bool flag2 = num6.HasValue && num5 <= num6.Value;
				long? num7 = _comparison?.GetReferenceElapsedMs(num3);
				if (num7.HasValue)
				{
					long num8 = splitRecord.ElapsedMs - num7.Value;
					((TMP_Text)splitRow.Delta).text = FormatDelta(num8);
					((Graphic)splitRow.Delta).color = (flag2 ? Gold : ((num8 <= 0) ? Ahead : Behind));
					((Graphic)splitRow.Time).color = (flag2 ? Gold : TextPrimary);
				}
				else
				{
					((TMP_Text)splitRow.Delta).text = "<mspace=0.58em>" + FormatTime(num5);
					((Graphic)splitRow.Delta).color = (flag2 ? Gold : TextMuted);
					((Graphic)splitRow.Time).color = TextPrimary;
				}
			}
			return y + 4f;
		}

		private void SetLiveDelta(SplitRow row, int index)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			long? num = _comparison?.GetReferenceElapsedMs(index);
			if (!num.HasValue)
			{
				((TMP_Text)row.Delta).text = string.Empty;
				return;
			}
			long num2 = _timer.CurrentElapsedMs - num.Value;
			if (num2 <= 0)
			{
				((TMP_Text)row.Delta).text = string.Empty;
				return;
			}
			((TMP_Text)row.Delta).text = FormatDelta(num2);
			((Graphic)row.Delta).color = Behind;
		}

		private float RefreshFooter(float y, float contentWidth, GameMode mode)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			long? num = ((_comparison != null && _comparison.HasReference) ? new long?(_comparison.ReferenceTotalMs) : ((long?)null));
			string text = ((_comparison != null && _comparison.IsPinned) ? Loc.T("hud.compare.pinned") : Loc.T("hud.compare"));
			((TMP_Text)_comparisonLabel).text = (num.HasValue ? (text + "<mspace=0.58em><pos=58%>" + FormatTime(num.Value)) : (text + "<pos=58%>-"));
			NativeUiFactory.Place((RectTransform)((TMP_Text)_comparisonLabel).transform, 12f, y, contentWidth, 20f);
			y += 20f;
			long? num2 = _comparison?.GetSumOfBest();
			((TMP_Text)_sobLabel).text = (num2.HasValue ? (Loc.T("hud.sob") + "<mspace=0.58em><pos=58%>" + FormatTime(num2.Value)) : (Loc.T("hud.sob") + "<pos=58%>-"));
			NativeUiFactory.Place((RectTransform)((TMP_Text)_sobLabel).transform, 12f, y, contentWidth, 20f);
			y += 20f;
			(string, Color) tuple = BuildStatusLine();
			((Component)_statusLabel).gameObject.SetActive(tuple.Item1 != null);
			if (tuple.Item1 != null)
			{
				((TMP_Text)_statusLabel).text = tuple.Item1;
				((Graphic)_statusLabel).color = tuple.Item2;
				NativeUiFactory.Place((RectTransform)((TMP_Text)_statusLabel).transform, 12f, y + 2f, contentWidth, 22f);
				y += 24f;
			}
			return y;
		}

		private (string Text, Color Color) BuildStatusLine()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			if (_timer.State == TimerState.WaitingForInput)
			{
				return (Text: Loc.T("hud.ready"), Color: Accent);
			}
			GhostPlaybackService instance = GhostPlaybackService.Instance;
			if (_timer.State == TimerState.Running && (Object)(object)instance != (Object)null && instance.IsExternalGhostActive)
			{
				string text = Loc.T(instance.IsDuelActive ? "hud.vs" : "hud.ghost");
				return (Text: text + " " + instance.CurrentGhostPlayerName + "  " + FormatTime(instance.CurrentGhostTotalMs), Color: Accent);
			}
			if (_timer.State == TimerState.Finished && _timer.LastRunRecord != null)
			{
				switch (_timer.LastRunRecord.Result)
				{
				case RunResult.Completed:
					if (!_timer.LastRunWasPersonalBest)
					{
						return (Text: Loc.T("hud.finish", FormatDelta(_timer.LastRunDeltaToPbMs)), Color: (_timer.LastRunDeltaToPbMs <= 0) ? Ahead : Behind);
					}
					return (Text: Loc.T("hud.newPb"), Color: Gold);
				case RunResult.Died:
					return (Text: Loc.T("hud.died"), Color: Behind);
				case RunResult.Aborted:
					return (Text: Loc.T("hud.aborted"), Color: Behind);
				}
			}
			return (Text: null, Color: TextMuted);
		}

		private Color CurrentTimeColor()
		{
			//IL_006f: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (_timer.State == TimerState.Finished && _timer.LastRunRecord != null)
			{
				if (_timer.LastRunRecord.Result != RunResult.Completed)
				{
					return Behind;
				}
				if (!_timer.LastRunWasPersonalBest)
				{
					return TextPrimary;
				}
				return Gold;
			}
			if (_timer.State != TimerState.Running || _comparison == null || !_comparison.HasReference)
			{
				return TextPrimary;
			}
			long? referenceElapsedMs = _comparison.GetReferenceElapsedMs(_timer.Splits.Count);
			if (!referenceElapsedMs.HasValue)
			{
				return TextPrimary;
			}
			if (_timer.CurrentElapsedMs <= referenceElapsedMs.Value)
			{
				return Ahead;
			}
			return Behind;
		}

		private void EnsureComparison(GameMode mode)
		{
			string text = $"{mode}|{_timer.CurrentMapName}|{_timer.CurrentRouteIndex}";
			if (!(_comparisonKey == text) || _comparison == null)
			{
				_comparisonKey = text;
				_comparison = new SplitComparison(_storage, mode, _timer.CurrentMapName, _timer.CurrentRouteIndex);
			}
		}

		private static string ModeName(GameMode mode)
		{
			return mode switch
			{
				GameMode.StaticDaily => Loc.T("mode.staticDaily"), 
				GameMode.Speedrun => Loc.T("mode.speedrun"), 
				GameMode.LiveRace => Loc.T("mode.liveRace"), 
				GameMode.RankedDuel => Loc.T("mode.rankedDuel"), 
				GameMode.GhostTraining => Loc.T("mode.ghostTraining"), 
				GameMode.Vanilla => Loc.T("mode.vanilla"), 
				_ => Loc.T("mode.custom"), 
			};
		}

		private static string Hex(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ColorUtility.ToHtmlStringRGB(color);
		}

		private static string FormatTime(long ms)
		{
			bool num = ms < 0;
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(num ? (-ms) : ms);
			string text = (num ? "-" : string.Empty);
			return $"{text}{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}

		private static string FormatDelta(long deltaMs)
		{
			return ((double)deltaMs / 1000.0).ToString("+0.0;-0.0", CultureInfo.InvariantCulture);
		}
	}
	public class RaceCountdownOverlay : MonoBehaviour
	{
		private const float GoDisplaySeconds = 1.2f;

		private static readonly Color CountColor = new Color(1f, 1f, 1f, 0.95f);

		private static readonly Color GoColor = new Color(0.35f, 0.9f, 0.45f, 1f);

		private static readonly Color CaptionColor = new Color(0.75f, 0.82f, 0.9f, 0.85f);

		private RectTransform _root;

		private TextMeshProUGUI _numberLabel;

		private TextMeshProUGUI _captionLabel;

		private bool _built;

		private float _hideGoAt;

		private void Update()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (_built && (Object)(object)_root == (Object)null)
			{
				_built = false;
			}
			if (!_built)
			{
				Build();
			}
			long? num = RaceService.Instance?.MsUntilStart;
			if (!num.HasValue)
			{
				Hide();
			}
			else if (num.Value > 0)
			{
				Show($"{Mathf.CeilToInt((float)num.Value / 1000f)}", Loc.T("race.countdown.caption"), CountColor);
				_hideGoAt = Time.realtimeSinceStartup + 1.2f;
			}
			else if (Time.realtimeSinceStartup < _hideGoAt)
			{
				Show(Loc.T("race.countdown.go"), string.Empty, GoColor);
			}
			else
			{
				Hide();
			}
		}

		private void Show(string number, string caption, Color color)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			NativeUiFactory.EnsureCanvasAlive();
			if (!((Component)_root).gameObject.activeSelf)
			{
				((Component)_root).gameObject.SetActive(true);
				NativeUiFactory.EnsureTopMost();
			}
			((TMP_Text)_numberLabel).text = number;
			((Graphic)_numberLabel).color = color;
			((TMP_Text)_captionLabel).text = caption;
			((Component)_captionLabel).gameObject.SetActive(!string.IsNullOrEmpty(caption));
		}

		private void Hide()
		{
			if ((Object)(object)_root != (Object)null && ((Component)_root).gameObject.activeSelf)
			{
				((Component)_root).gameObject.SetActive(false);
			}
		}

		private void Build()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			_built = true;
			Canvas canvas = NativeUiFactory.GetCanvas();
			GameObject val = new GameObject("RankedPeak_RaceCountdown", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)canvas).transform, false);
			_root = (RectTransform)val.transform;
			_root.anchorMin = new Vector2(0.5f, 0.5f);
			_root.anchorMax = new Vector2(0.5f, 0.5f);
			_root.pivot = new Vector2(0.5f, 0.5f);
			_root.anchoredPosition = new Vector2(0f, 60f);
			_root.sizeDelta = new Vector2(900f, 320f);
			_captionLabel = PeakWindowStyle.CreateText((Transform)(object)_root, "Caption", string.Empty, 34f, CaptionColor, (TextAlignmentOptions)514, display: false, 8f);
			RectTransform val2 = (RectTransform)((TMP_Text)_captionLabel).transform;
			val2.anchorMin = new Vector2(0f, 1f);
			val2.anchorMax = new Vector2(1f, 1f);
			val2.pivot = new Vector2(0.5f, 1f);
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = new Vector2(0f, 44f);
			_numberLabel = PeakWindowStyle.CreateText((Transform)(object)_root, "Number", string.Empty, 200f, CountColor, (TextAlignmentOptions)514, display: true);
			RectTransform val3 = (RectTransform)((TMP_Text)_numberLabel).transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = new Vector2(0f, 0f);
			val3.offsetMax = new Vector2(0f, -50f);
			((Component)_root).gameObject.SetActive(false);
		}
	}
	public class RaceHudOverlay : MonoBehaviour
	{
		private const float PanelWidth = 380f;

		private const float Padding = 12f;

		private const float RowHeight = 42f;

		private const float BarHeight = 6f;

		private const float IconSize = 18f;

		private const float IconGap = 2f;

		private const float IconIndent = 20f;

		private const int IconsPerRow = 9;

		private const int PackStart = 4;

		private const float NameWidth = 150f;

		private const int MaxRows = 8;

		private static readonly Color Background = new Color(0.05f, 0.06f, 0.08f, 0.82f);

		private static readonly Color TextPrimary = new Color(0.94f, 0.95f, 0.97f);

		private static readonly Color TextMuted = new Color(0.62f, 0.66f, 0.72f);

		private static readonly Color Accent = new Color(0.45f, 0.72f, 1f);

		private static readonly Color Ahead = new Color(0.35f, 0.85f, 0.45f);

		private RectTransform _panel;

		private TextMeshProUGUI _headlineLabel;

		private TextMeshProUGUI _hintLabel;

		private readonly List<TextMeshProUGUI> _rows = new List<TextMeshProUGUI>();

		private readonly List<StatusBarStrip> _statusBars = new List<StatusBarStrip>();

		private readonly List<HudBar> _adrenalineBars = new List<HudBar>();

		private readonly List<ItemIconRow> _iconRows = new List<ItemIconRow>();

		private readonly List<float> _statusBuffer = new List<float>();

		private bool _built;

		public static bool PreviewMode { get; set; }

		private void Update()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (_built && (Object)(object)_panel == (Object)null)
			{
				_built = false;
				_rows.Clear();
				_statusBars.Clear();
				_adrenalineBars.Clear();
				_iconRows.Clear();
			}
			if (!_built)
			{
				BuildPanel();
			}
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			KeyCode value = Plugin.RaceMenuKey.Value;
			if ((int)value != 0 && !ModalGuard.CapturingKey && Input.GetKeyDown(value))
			{
				if (raceInfo != null)
				{
					CustomRunModal.OpenRace();
				}
				else
				{
					RankedLog.Info($"[RaceHud] {value} gedrueckt, aber kein Rennen aktiv - " + "das Renn-Fenster bleibt zu.");
				}
			}
			bool flag = (Plugin.RaceHudEnabled.Value && raceInfo != null && TimerOverlay.HudVisible) || PreviewMode;
			((Component)_panel).gameObject.SetActive(flag);
			if (flag)
			{
				NativeUiFactory.EnsureCanvasAlive();
				_panel.anchoredPosition = new Vector2(Plugin.RaceHudX.Value, 0f - Plugin.RaceHudY.Value);
				if (raceInfo != null)
				{
					Refresh(raceInfo);
				}
				else
				{
					RefreshPreview();
				}
			}
		}

		private void BuildPanel()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			_built = true;
			Image val = PeakWindowStyle.CreateSurface(((Component)NativeUiFactory.GetCanvas()).transform, "RankedPeak_RaceHud", Background, 10);
			_panel = (RectTransform)((Component)val).transform;
			_panel.anchorMin = new Vector2(0f, 1f);
			_panel.anchorMax = new Vector2(0f, 1f);
			_panel.pivot = new Vector2(0f, 1f);
			_panel.sizeDelta = new Vector2(380f, 200f);
			_headlineLabel = PeakWindowStyle.CreateText((Transform)(object)_panel, "Headline", string.Empty, 22f, Accent, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_headlineLabel).transform, 12f, 12f, 356f, 28f);
			_hintLabel = PeakWindowStyle.CreateText((Transform)(object)_panel, "Hint", string.Empty, 16f, TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_hintLabel).transform, 12f, 42f, 356f, 22f);
			float num = 356f - 150f;
			float num2 = num * 0.74f;
			float width = num - num2 - 4f;
			for (int i = 0; i < 8; i++)
			{
				float num3 = 66f + (float)i * 42f;
				TextMeshProUGUI val2 = PeakWindowStyle.CreateText((Transform)(object)_panel, $"Row{i}", string.Empty, 16f, TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val2).transform, 12f, num3, 150f, 20f);
				((TMP_Text)val2).textWrappingMode = (TextWrappingModes)0;
				_rows.Add(val2);
				float y = num3 + 7f;
				float num4 = 162f;
				_statusBars.Add(StatusBarStrip.Create((Transform)(object)_panel, $"Row{i}_Status", num4, y, num2, 6f));
				_adrenalineBars.Add(HudBar.Create((Transform)(object)_panel, $"Row{i}_Adrenaline", num4 + num2 + 4f, y, width, 6f));
				_iconRows.Add(ItemIconRow.Create((Transform)(object)_panel, $"Row{i}_Items", 32f, num3 + 21f, 18f, 2f, 9, 1, 4));
				SetRowActive(i, active: false);
			}
			((Component)_panel).gameObject.SetActive(false);
		}

		private void Refresh(RaceInfo race)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			RaceService instance = RaceService.Instance;
			long? num = instance?.MsUntilStart;
			if (num.HasValue && num.Value > 0)
			{
				((TMP_Text)_headlineLabel).text = Loc.T("race.hud.aboutToStart");
				((Graphic)_headlineLabel).color = Accent;
				((Component)_hintLabel).gameObject.SetActive(false);
				RefreshRows(race);
				return;
			}
			switch (race.Status)
			{
			case "loading":
				((TMP_Text)_headlineLabel).text = Loc.T("race.hud.waiting");
				((Graphic)_headlineLabel).color = Accent;
				break;
			case "countdown":
				((TMP_Text)_headlineLabel).text = Loc.T("race.hud.go");
				((Graphic)_headlineLabel).color = Ahead;
				break;
			case "finished":
				((TMP_Text)_headlineLabel).text = Loc.T("race.hud.finished");
				((Graphic)_headlineLabel).color = TextMuted;
				break;
			case "lobby":
			{
				bool flag = instance?.IsHost ?? false;
				((TMP_Text)_headlineLabel).text = "RACE " + race.InviteCode + "   " + $"{race.Participants.Count}/{race.MaxPlayers}";
				((Graphic)_headlineLabel).color = Accent;
				((TMP_Text)_hintLabel).text = (flag ? Loc.T("race.hud.hintHost", Plugin.RaceMenuKey.Value) : Loc.T("race.hud.hintGuest", Plugin.RaceMenuKey.Value));
				break;
			}
			default:
				((TMP_Text)_headlineLabel).text = "RACE  " + race.InviteCode;
				((Graphic)_headlineLabel).color = Accent;
				break;
			}
			((Component)_hintLabel).gameObject.SetActive(race.Status == "lobby");
			RefreshRows(race);
		}

		private void RefreshPreview()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_headlineLabel).text = "RACE ------";
			((Graphic)_headlineLabel).color = Accent;
			((Component)_hintLabel).gameObject.SetActive(false);
			for (int i = 0; i < _rows.Count; i++)
			{
				SetRowActive(i, active: true);
				((TMP_Text)_rows[i]).text = string.Format("{0}. {1} {2}   {3} %", i + 1, Loc.T("race.hud.previewName"), i + 1, 90 - i * 9);
				((Graphic)_rows[i]).color = ((i == 0) ? Accent : TextPrimary);
				_statusBuffer.Clear();
				for (int j = 0; j < GhostStateTrack.StatusCount; j++)
				{
					_statusBuffer.Add((j == 2) ? 0.15f : 0f);
				}
				_statusBars[i].SetActive(active: true);
				_statusBars[i].Set(0.7f - (float)i * 0.05f, _statusBuffer);
				_adrenalineBars[i].SetActive(active: true);
				_adrenalineBars[i].Set(0.5f, AfflictionPalette.Adrenaline);
				_iconRows[i].ShowSlots(9);
				for (int k = 0; k < 9; k++)
				{
					_iconRows[i].Set(k, ushort.MaxValue, k == 0);
				}
				_iconRows[i].SetBackpack(4, 1);
			}
			_panel.sizeDelta = new Vector2(380f, 414f);
		}

		private void RefreshRows(RaceInfo race)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			List<RaceParticipant> list = new List<RaceParticipant>(race.Participants);
			list.Sort(CompareParticipants);
			string steamId = SteamIdentity.GetSteamId64();
			for (int i = 0; i < _rows.Count; i++)
			{
				bool flag = i < list.Count;
				SetRowActive(i, flag);
				if (flag)
				{
					RaceParticipant raceParticipant = list[i];
					bool flag2 = raceParticipant.SteamId == steamId;
					((TMP_Text)_rows[i]).text = $"{i + 1}. {ShortName(raceParticipant.PlayerName)}   {DescribeState(raceParticipant)}";
					((Graphic)_rows[i]).color = (flag2 ? Accent : ((raceParticipant.State == "dnf") ? TextMuted : TextPrimary));
					RefreshBars(i, raceParticipant);
					RefreshIcons(i, raceParticipant);
				}
			}
			_panel.sizeDelta = new Vector2(380f, 78f + (float)list.Count * 42f);
		}

		private void SetRowActive(int index, bool active)
		{
			((Component)_rows[index]).gameObject.SetActive(active);
			if (!active)
			{
				_statusBars[index].SetActive(active: false);
				_adrenalineBars[index].SetActive(active: false);
				_iconRows[index].ShowSlots(0);
			}
		}

		private void RefreshIcons(int index, RaceParticipant p)
		{
			if (!(p.State != "finished") || !(p.State != "dnf"))
			{
				_iconRows[index].ShowSlots(0);
				return;
			}
			_iconRows[index].Set(0, (ushort)(p.HandItem ?? 65535), isHand: true);
			for (int i = 0; i < 3; i++)
			{
				ushort itemId = ((p.Belt != null && i < p.Belt.Length) ? ((ushort)p.Belt[i]) : ushort.MaxValue);
				_iconRows[index].Set(1 + i, itemId);
			}
			if (p.BackpackType.GetValueOrDefault() == 0)
			{
				_iconRows[index].ShowSlots(4);
				return;
			}
			int num = Mathf.Clamp(p.BackpackSlots.GetValueOrDefault(), 0, 4);
			_iconRows[index].ShowSlots(5 + num);
			_iconRows[index].SetBackpack(4, (byte)p.BackpackType.Value);
			for (int j = 0; j < num; j++)
			{
				ushort itemId2 = ((p.Pack != null && j < p.Pack.Length) ? ((ushort)p.Pack[j]) : ushort.MaxValue);
				_iconRows[index].Set(5 + j, itemId2);
			}
		}

		private void RefreshBars(int index, RaceParticipant p)
		{
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			bool flag = p.State != "finished" && p.State != "dnf" && p.Health.HasValue;
			_statusBars[index].SetActive(flag);
			_adrenalineBars[index].SetActive(flag && p.ExtraStamina.GetValueOrDefault() > 0.001f);
			if (flag)
			{
				_statusBuffer.Clear();
				for (int i = 0; i < GhostStateTrack.StatusCount; i++)
				{
					_statusBuffer.Add((p.TopStatus.HasValue && p.TopStatus.Value == i) ? Mathf.Clamp01(1f - p.Health.Value) : 0f);
				}
				_statusBars[index].Set(p.Stamina.GetValueOrDefault(), _statusBuffer);
				_adrenalineBars[index].Set(p.ExtraStamina.GetValueOrDefault(), AfflictionPalette.Adrenaline);
			}
		}

		private static int CompareParticipants(RaceParticipant a, RaceParticipant b)
		{
			int num = Weight(a).CompareTo(Weight(b));
			if (num != 0)
			{
				return num;
			}
			if (Weight(a) == 0)
			{
				return (a.Rank ?? int.MaxValue).CompareTo(b.Rank ?? int.MaxValue);
			}
			return b.Progress.CompareTo(a.Progress);
			static int Weight(RaceParticipant p)
			{
				if (!(p.State == "finished"))
				{
					if (!(p.State == "dnf"))
					{
						return 1;
					}
					return 2;
				}
				return 0;
			}
		}

		private static string ShortName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return Loc.T("common.anonymous");
			}
			if (name.Length > 12)
			{
				return name.Substring(0, 11) + "…";
			}
			return name;
		}

		private static string DescribeState(RaceParticipant p)
		{
			return p.State switch
			{
				"finished" => p.TotalMs.HasValue ? FormatTime(p.TotalMs.Value) : Loc.T("state.finished"), 
				"dnf" => Loc.T("state.dnf"), 
				"race_ready" => Loc.T("state.ready"), 
				"loading" => Loc.T("state.loading"), 
				_ => $"{Mathf.RoundToInt(p.Progress * 100f)} %", 
			};
		}

		private static string FormatTime(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			return $"{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}
	}
	public class RankedHelpModal : PeakSidebarModal
	{
		private static readonly string[] CategoryKeys = new string[11]
		{
			"help.cat.overview", "help.cat.dailyCup", "help.cat.ghostDuel", "help.cat.speedrun", "help.cat.liveRace", "help.cat.timing", "help.cat.elo", "help.cat.ghosts", "help.cat.leaderboards", "help.cat.fairness",
			"help.cat.trouble"
		};

		private static RankedHelpModal _instance;

		protected override float WindowWidth => 1420f;

		protected override float WindowHeight => 900f;

		protected override string WindowTitle => Loc.T("help.title");

		protected override string WindowSubtitle => Loc.T("help.subtitle");

		protected override string[] Categories
		{
			get
			{
				string[] array = new string[CategoryKeys.Length];
				for (int i = 0; i < CategoryKeys.Length; i++)
				{
					array[i] = Loc.T(CategoryKeys[i]);
				}
				return array;
			}
		}

		public static bool IsAnyOpen
		{
			get
			{
				if ((Object)(object)_instance != (Object)null)
				{
					return ((MenuWindow)_instance).isOpen;
				}
				return false;
			}
		}

		private void Awake()
		{
			_instance = this;
		}

		public static void OpenWindow(int section = -1)
		{
			_instance?.OpenPanel(section);
		}

		public static void CloseWindow()
		{
			if ((Object)(object)_instance != (Object)null && ((MenuWindow)_instance).isOpen)
			{
				_instance.ClosePanel();
			}
		}

		protected override void BuildContent(int categoryIndex, RectTransform host, float width, float height)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			PeakWindowStyle.CreateScrollingText((Transform)(object)host, "Body", HelpText.Section(categoryIndex), 20f, PeakWindowStyle.TextPrimary, 0f, 0f, width, height, 8f, 10f);
		}
	}
	public class RankedNoticeModal : MonoBehaviour
	{
		private const float Width = 980f;

		private const float Height = 640f;

		private const float TitleBarHeight = 76f;

		private const float TextTop = 36f;

		private const float TextSideMargin = 56f;

		private const float ButtonWidth = 220f;

		private const float ButtonHeight = 54f;

		private const float ButtonBottomMargin = 34f;

		private static RankedNoticeModal _open;

		private GameObject _root;

		public static bool IsOpen => (Object)(object)_open != (Object)null;

		public static void Show(string title, string message)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_open != (Object)null)
				{
					_open.Close();
				}
				RankedNoticeModal rankedNoticeModal = new GameObject("RankedPeak_Notice").AddComponent<RankedNoticeModal>();
				rankedNoticeModal.Build(title, message);
				_open = rankedNoticeModal;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Notice] Hinweisfenster nicht baubar: " + ex.Message);
				RankedLog.Info("[Notice] " + title + ": " + message);
			}
		}

		private void Build(string title, string message)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			Canvas canvas = NativeUiFactory.GetCanvas();
			((Component)this).transform.SetParent(((Component)canvas).transform, false);
			_root = new GameObject("Notice_Root", new Type[1] { typeof(RectTransform) });
			_root.transform.SetParent(((Component)canvas).transform, false);
			RectTransform val = (RectTransform)_root.transform;
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			_root.transform.SetAsLastSibling();
			PeakWindowStyle.CreateBackdrop(_root.transform, "Backdrop");
			PeakWindowStyle.WindowParts windowParts = PeakWindowStyle.CreateWindow(_root.transform, "Notice", 980f, 640f, 76f, title, string.Empty);
			if ((Object)(object)windowParts.Title != (Object)null)
			{
				NativeUiFactory.Place((RectTransform)((TMP_Text)windowParts.Title).transform, 30f, 0f, 920f, 76f);
				((TMP_Text)windowParts.Title).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)windowParts.Title).overflowMode = (TextOverflowModes)1;
			}
			float num = 550f - 34f - 54f;
			TextMeshProUGUI val2 = PeakWindowStyle.CreateScrollingText((Transform)(object)windowParts.Body, "Message", message, 22f, PeakWindowStyle.TextPrimary, 56f, 36f, 868f, num - 36f - 24f);
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)val2).alignment = (TextAlignmentOptions)257;
			}
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)windowParts.Body, "Ok", Loc.T("common.understood"), 380f, num, 220f, 54f).onClick).AddListener(new UnityAction(Close));
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown((KeyCode)13))
			{
				Close();
			}
		}

		private void Close()
		{
			if ((Object)(object)_open == (Object)(object)this)
			{
				_open = null;
			}
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class RankedSettingsModal : PeakSidebarModal
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Func<string> <0>__RaceKeyStatus;

			public static UnityAction <1>__OpenLogFolder;
		}

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

			public static UnityAction <>9__30_0;

			public static Func<int> <>9__35_0;

			public static Action<int> <>9__35_1;

			public static Func<bool> <>9__35_2;

			public static Action<bool> <>9__35_3;

			public static Func<bool> <>9__35_4;

			public static Action<bool> <>9__35_5;

			public static Func<int> <>9__35_6;

			public static Action<int> <>9__35_7;

			public static Func<bool> <>9__36_0;

			public static Action<bool> <>9__36_1;

			public static Func<int> <>9__36_2;

			public static Action<int> <>9__36_3;

			public static Func<bool> <>9__36_4;

			public static Action<bool> <>9__36_5;

			public static Func<bool> <>9__36_6;

			public static Action<bool> <>9__36_7;

			public static Func<int> <>9__37_0;

			public static Action<int> <>9__37_1;

			public static Func<int> <>9__38_0;

			public static Action<int> <>9__38_1;

			public static Func<bool> <>9__38_2;

			public static Action<bool> <>9__38_3;

			public static Func<string> <>9__39_1;

			public static Func<string> <>9__39_2;

			public static Func<string> <>9__39_3;

			public static Func<string> <>9__39_4;

			public static Func<string> <>9__39_5;

			public static Func<string> <>9__39_6;

			public static Func<string> <>9__39_7;

			public static Action<bool> <>9__46_3;

			public static Action<bool> <>9__47_3;

			public static Action<bool> <>9__48_3;

			internal void <BuildTitleBarActions>b__30_0()
			{
				RankedHelpModal.OpenWindow();
			}

			internal int <BuildTimerAndHud>b__35_0()
			{
				return (!Plugin.UseNativeTimer.Value) ? 1 : 0;
			}

			internal void <BuildTimerAndHud>b__35_1(int index)
			{
				Plugin.UseNativeTimer.Value = index == 0;
			}

			internal bool <BuildTimerAndHud>b__35_2()
			{
				return Plugin.ShowRunSummary.Value;
			}

			internal void <BuildTimerAndHud>b__35_3(bool value)
			{
				Plugin.ShowRunSummary.Value = value;
			}

			internal bool <BuildTimerAndHud>b__35_4()
			{
				return Plugin.RaceHudEnabled.Value;
			}

			internal void <BuildTimerAndHud>b__35_5(bool value)
			{
				Plugin.RaceHudEnabled.Value = value;
			}

			internal int <BuildTimerAndHud>b__35_6()
			{
				return Plugin.SummaryMinimized.Value ? 1 : 0;
			}

			internal void <BuildTimerAndHud>b__35_7(int index)
			{
				Plugin.SummaryMinimized.Value = index == 1;
			}

			internal bool <BuildGhost>b__36_0()
			{
				return Plugin.GhostEnabled.Value;
			}

			internal void <BuildGhost>b__36_1(bool value)
			{
				Plugin.GhostEnabled.Value = value;
			}

			internal int <BuildGhost>b__36_2()
			{
				return NearestOpacityStep(Plugin.GhostOpacity.Value);
			}

			internal void <BuildGhost>b__36_3(int index)
			{
				Plugin.GhostOpacity.Value = OpacitySteps[index];
			}

			internal bool <BuildGhost>b__36_4()
			{
				return Plugin.GhostItemsEnabled.Value;
			}

			internal void <BuildGhost>b__36_5(bool value)
			{
				Plugin.GhostItemsEnabled.Value = value;
			}

			internal bool <BuildGhost>b__36_6()
			{
				return Plugin.GhostPanelEnabled.Value;
			}

			internal void <BuildGhost>b__36_7(bool value)
			{
				Plugin.GhostPanelEnabled.Value = value;
			}

			internal int <BuildRunRules>b__37_0()
			{
				return Plugin.ComparisonManual.Value ? 1 : 0;
			}

			internal void <BuildRunRules>b__37_1(int index)
			{
				Plugin.ComparisonManual.Value = index == 1;
			}

			internal int <BuildDiagnostics>b__38_0()
			{
				return (int)Plugin.LogLevel.Value;
			}

			internal void <BuildDiagnostics>b__38_1(int index)
			{
				Plugin.LogLevel.Value = (RankedLogLevel)index;
			}

			internal bool <BuildDiagnostics>b__38_2()
			{
				return Plugin.DebugSpawnLogging.Value;
			}

			internal void <BuildDiagnostics>b__38_3(bool value)
			{
				Plugin.DebugSpawnLogging.Value = value;
			}

			internal string <BuildSystemInfo>b__39_1()
			{
				return Plugin.DisplayVersion;
			}

			internal string <BuildSystemInfo>b__39_2()
			{
				return "https://followme-peak.ddns.net";
			}

			internal string <BuildSystemInfo>b__39_3()
			{
				return MapCatalog.GameVersion;
			}

			internal string <BuildSystemInfo>b__39_4()
			{
				return Loc.T("settings.info.mapSetValue", MapCatalog.SlotCount, MapCatalog.MapSetHash);
			}

			internal string <BuildSystemInfo>b__39_5()
			{
				return SteamIdentity.GetSteamId64() ?? Loc.T("settings.info.steamPending");
			}

			internal string <BuildSystemInfo>b__39_6()
			{
				return RatingService.Instance?.CurrentRating?.FormattedTierName ?? Loc.T("common.unknown");
			}

			internal string <BuildSystemInfo>b__39_7()
			{
				return (RunUploadService.Instance?.PendingCount ?? 0).ToString(CultureInfo.InvariantCulture);
			}

			internal void <CreatePositionRow>b__46_3(bool value)
			{
				NativeTimerPanel.PreviewMode = value;
			}

			internal void <CreateGhostPanelPositionRow>b__47_3(bool value)
			{
				GhostStatusPanel.PreviewMode = value;
			}

			internal void <CreateRaceHudPositionRow>b__48_3(bool value)
			{
				RaceHudOverlay.PreviewMode = value;
			}
		}

		private const float RowHeight = 104f;

		private const float LabelWidth = 560f;

		private static readonly float[] OpacitySteps = new float[3] { 0.35f, 0.6f, 0.85f };

		private const float ControlHeight = 40f;

		private static readonly string[] CategoryKeys = new string[5] { "settings.cat.keys", "settings.cat.timer", "settings.cat.ghost", "settings.cat.run", "settings.cat.diagnostics" };

		private static KeyCode[] _capturableKeys;

		private static RankedSettingsModal _instance;

		private ConfigEntry<KeyCode> _captureEntry;

		private TextMeshProUGUI _captureLabel;

		private bool _positionMode;

		private float _positionBackupX;

		private float _positionBackupY;

		private ConfigEntry<float> _positionTargetX;

		private ConfigEntry<float> _positionTargetY;

		private Action<bool> _positionPreview;

		private RectTransform _positionHint;

		protected override float WindowWidth => 1420f;

		protected override float WindowHeight => 900f;

		protected override string WindowTitle => "PEAK RANKED";

		protected override string WindowSubtitle => Loc.T("settings.subtitle");

		protected override string[] Categories
		{
			get
			{
				string[] array = new string[CategoryKeys.Length];
				for (int i = 0; i < CategoryKeys.Length; i++)
				{
					array[i] = Loc.T(CategoryKeys[i]);
				}
				return array;
			}
		}

		private static int NearestOpacityStep(float value)
		{
			int num = 0;
			for (int i = 1; i < OpacitySteps.Length; i++)
			{
				if (Mathf.Abs(OpacitySteps[i] - value) < Mathf.Abs(OpacitySteps[num] - value))
				{
					num = i;
				}
			}
			return num;
		}

		private void Awake()
		{
			_instance = this;
		}

		public static void OpenWindow()
		{
			_instance?.OpenPanel();
		}

		public static void ToggleWindow()
		{
			_instance?.TogglePanel();
		}

		protected override void BuildTitleBarActions(RectTransform titleBar, float rightEdge)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)titleBar, "BtnHelp", Loc.T("settings.btn.help"), rightEdge - 150f, 20f, 150f, 42f, 19f);
			PeakSidebarModal.TintOnBar(obj);
			ButtonClickedEvent onClick = obj.onClick;
			object obj2 = <>c.<>9__30_0;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					RankedHelpModal.OpenWindow();
				};
				<>c.<>9__30_0 = val;
				obj2 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj2);
		}

		public override void Update()
		{
			if (_positionMode)
			{
				UpdatePositionMode();
			}
			else if (_captureEntry != null)
			{
				UpdateKeyCapture();
			}
			else if (!RankedHelpModal.IsAnyOpen)
			{
				base.Update();
			}
		}

		public override void OnClose()
		{
			base.OnClose();
			CancelKeyCapture();
			RankedHelpModal.CloseWindow();
		}

		protected override void BuildContent(int categoryIndex, RectTransform host, float width, float height)
		{
			switch (categoryIndex)
			{
			case 0:
				BuildKeys(host, width);
				break;
			case 1:
				BuildTimerAndHud(host, width);
				break;
			case 2:
				BuildGhost(host, width);
				break;
			case 3:
				BuildRunRules(host, width);
				break;
			default:
				BuildDiagnostics(host, width);
				break;
			}
		}

		private void BuildKeys(RectTransform host, float width)
		{
			float y = 0f;
			CreateKeyRow(host, ref y, width, Plugin.OverlayToggleKey, "Overlay", Loc.T("settings.key.overlay.title"), Loc.T("settings.key.overlay.desc"));
			CreateKeyRow(host, ref y, width, Plugin.SettingsMenuKey, "Window", Loc.T("settings.key.window.title"), Loc.T("settings.key.window.desc"));
			CreateKeyRow(host, ref y, width, Plugin.RaceMenuKey, "Race", Loc.T("settings.key.race.title"), Loc.T("settings.key.race.desc"), RaceKeyStatus);
			CreateKeyRow(host, ref y, width, Plugin.RunResetKey, "Reset", Loc.T("settings.key.reset.title"), Loc.T("settings.key.reset.desc"));
			CreateHint(host, ref y, width, Loc.T("settings.key.hint"));
		}

		private void BuildTimerAndHud(RectTransform host, float width)
		{
			float y = 0f;
			CreateChoiceRow(host, ref y, width, "Display", Loc.T("settings.display.title"), Loc.T("settings.display.desc"), new string[2]
			{
				Loc.T("settings.display.panel"),
				Loc.T("settings.display.classic")
			}, () => (!Plugin.UseNativeTimer.Value) ? 1 : 0, delegate(int index)
			{
				Plugin.UseNativeTimer.Value = index == 0;
			});
			CreatePositionRow(host, ref y, width);
			CreateToggleRow(host, ref y, width, "Summary", Loc.T("settings.summary.title"), Loc.T("settings.summary.desc"), () => Plugin.ShowRunSummary.Value, delegate(bool value)
			{
				Plugin.ShowRunSummary.Value = value;
			});
			CreateToggleRow(host, ref y, width, "RaceHud", Loc.T("settings.raceHud.title"), Loc.T("settings.raceHud.desc"), () => Plugin.RaceHudEnabled.Value, delegate(bool value)
			{
				Plugin.RaceHudEnabled.Value = value;
			});
			CreateRaceHudPositionRow(host, ref y, width);
			CreateChoiceRow(host, ref y, width, "SummaryState", Loc.T("settings.summaryState.title"), Loc.T("settings.summaryState.desc"), new string[2]
			{
				Loc.T("settings.summaryState.open"),
				Loc.T("settings.summaryState.collapsed")
			}, () => Plugin.SummaryMinimized.Value ? 1 : 0, delegate(int index)
			{
				Plugin.SummaryMinimized.Value = index == 1;
			});
		}

		private void BuildGhost(RectTransform host, float width)
		{
			float y = 0f;
			CreateToggleRow(host, ref y, width, "GhostPb", Loc.T("settings.ghostPb.title"), Loc.T("settings.ghostPb.desc"), () => Plugin.GhostEnabled.Value, delegate(bool value)
			{
				Plugin.GhostEnabled.Value = value;
			});
			CreateChoiceRow(host, ref y, width, "GhostOpacity", Loc.T("settings.ghostOpacity.title"), Loc.T("settings.ghostOpacity.desc"), new string[3]
			{
				Loc.T("settings.ghostOpacity.faint"),
				Loc.T("settings.ghostOpacity.normal"),
				Loc.T("settings.ghostOpacity.solid")
			}, () => NearestOpacityStep(Plugin.GhostOpacity.Value), delegate(int index)
			{
				Plugin.GhostOpacity.Value = OpacitySteps[index];
			}, 120f);
			CreateToggleRow(host, ref y, width, "GhostItems", Loc.T("settings.ghostItems.title"), Loc.T("settings.ghostItems.desc"), () => Plugin.GhostItemsEnabled.Value, delegate(bool value)
			{
				Plugin.GhostItemsEnabled.Value = value;
			});
			CreateToggleRow(host, ref y, width, "GhostPanel", Loc.T("settings.ghostPanel.title"), Loc.T("settings.ghostPanel.desc"), () => Plugin.GhostPanelEnabled.Value, delegate(bool value)
			{
				Plugin.GhostPanelEnabled.Value = value;
			});
			CreateGhostPanelPositionRow(host, ref y, width);
			CreateHint(host, ref y, width, Loc.T("settings.ghost.hint"));
		}

		private void BuildRunRules(RectTransform host, float width)
		{
			float y = 0f;
			CreateChoiceRow(host, ref y, width, "Comparison", Loc.T("settings.comparison.title"), Loc.T("settings.comparison.desc"), new string[2]
			{
				Loc.T("settings.comparison.auto"),
				Loc.T("settings.comparison.manual")
			}, () => Plugin.ComparisonManual.Value ? 1 : 0, delegate(int index)
			{
				Plugin.ComparisonManual.Value = index == 1;
			});
			CreateHint(host, ref y, width, Loc.T("settings.rules.hint"));
		}

		private void BuildDiagnostics(RectTransform host, float width)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			float y = 0f;
			CreateChoiceRow(host, ref y, width, "LogLevel", Loc.T("settings.logLevel.title"), Loc.T("settings.logLevel.desc"), new string[4]
			{
				Loc.T("settings.logLevel.error"),
				Loc.T("settings.logLevel.warning"),
				Loc.T("settings.logLevel.info"),
				Loc.T("settings.logLevel.debug")
			}, () => (int)Plugin.LogLevel.Value, delegate(int index)
			{
				Plugin.LogLevel.Value = (RankedLogLevel)index;
			}, 130f);
			CreateToggleRow(host, ref y, width, "SpawnLog", Loc.T("settings.spawnLog.title"), Loc.T("settings.spawnLog.desc"), () => Plugin.DebugSpawnLogging.Value, delegate(bool value)
			{
				Plugin.DebugSpawnLogging.Value = value;
			});
			TextMeshProUGUI infoLabel = PeakWindowStyle.CreateText((Transform)(object)host, "SystemInfo", string.Empty, 20f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)infoLabel).transform, 0f, y, width, 190f);
			Refreshers.Add(delegate
			{
				((TMP_Text)infoLabel).text = BuildSystemInfo();
			});
			y += 200f;
			ButtonClickedEvent onClick = PeakWindowStyle.CreatePill((Transform)(object)host, "BtnLog", Loc.T("settings.btn.logFolder"), 0f, y, 300f, 40f, 18f).onClick;
			object obj = <>O.<1>__OpenLogFolder;
			if (obj == null)
			{
				UnityAction val = OpenLogFolder;
				<>O.<1>__OpenLogFolder = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnUpload", Loc.T("settings.btn.upload"), 314f, y, 320f, 40f, 18f).onClick).AddListener((UnityAction)delegate
			{
				RunUploadService.Instance?.TriggerImmediateFlush();
				RefreshControls();
			});
		}

		private static string BuildSystemInfo()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			List<string> lines = new List<string>();
			string muted = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted);
			Add(Loc.T("settings.info.modVersion"), () => Plugin.DisplayVersion);
			Add(Loc.T("settings.info.server"), () => "https://followme-peak.ddns.net");
			Add(Loc.T("settings.info.gameVersion"), () => MapCatalog.GameVersion);
			Add(Loc.T("settings.info.mapSet"), () => Loc.T("settings.info.mapSetValue", MapCatalog.SlotCount, MapCatalog.MapSetHash));
			Add(Loc.T("settings.info.steam"), () => SteamIdentity.GetSteamId64() ?? Loc.T("settings.info.steamPending"));
			Add(Loc.T("settings.info.rank"), () => RatingService.Instance?.CurrentRating?.FormattedTierName ?? Loc.T("common.unknown"));
			Add(Loc.T("settings.info.pendingUploads"), () => (RunUploadService.Instance?.PendingCount ?? 0).ToString(CultureInfo.InvariantCulture));
			return string.Join("\n", lines);
			void Add(string caption, Func<string> read)
			{
				string text;
				try
				{
					text = read() ?? "-";
				}
				catch (Exception ex)
				{
					text = Loc.T("common.notAvailable");
					RankedLog.Debug("[Settings] Diagnosewert '" + caption + "' nicht lesbar: " + ex.Message);
				}
				lines.Add("<color=#" + muted + ">" + caption + "</color>   " + text);
			}
		}

		private static void OpenLogFolder()
		{
			try
			{
				Application.OpenURL("file:///" + Paths.BepInExRootPath.Replace('\\', '/'));
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Settings] Log-Ordner liess sich nicht oeffnen: " + ex.Message);
			}
		}

		private void CreateRowLabel(RectTransform host, float y, string id, string title, string description)
		{
			//IL_0013: 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_0047: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)host, "Label_" + id, title, 23f, PeakWindowStyle.Heading, (TextAlignmentOptions)257, display: false, 1f)).transform, 0f, y, 560f, 30f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)host, "Hint_" + id, description, 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)257)).transform, 0f, y + 30f, 560f, 70f);
		}

		private void CreateToggleRow(RectTransform host, ref float y, float width, string id, string title, string description, Func<bool> getter, Action<bool> setter)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			CreateRowLabel(host, y, id, title, description);
			Button onButton = PeakWindowStyle.CreatePill((Transform)(object)host, "On_" + id, Loc.T("settings.toggle.on"), width - 200f, y + 2f, 96f, 40f, 19f);
			Button offButton = PeakWindowStyle.CreatePill((Transform)(object)host, "Off_" + id, Loc.T("settings.toggle.off"), width - 96f, y + 2f, 96f, 40f, 19f);
			((UnityEvent)onButton.onClick).AddListener((UnityAction)delegate
			{
				setter(obj: true);
				RefreshControls();
			});
			((UnityEvent)offButton.onClick).AddListener((UnityAction)delegate
			{
				setter(obj: false);
				RefreshControls();
			});
			Refreshers.Add(delegate
			{
				bool flag = getter();
				PeakWindowStyle.SetPillSelected(onButton, flag);
				PeakWindowStyle.SetPillSelected(offButton, !flag);
			});
			y += 104f;
		}

		private void CreateChoiceRow(RectTransform host, ref float y, float width, string id, string title, string description, string[] options, Func<int> getter, Action<int> setter, float optionWidth = 190f)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			CreateRowLabel(host, y, id, title, description);
			Button[] buttons = (Button[])(object)new Button[options.Length];
			for (int i = 0; i < options.Length; i++)
			{
				int index = i;
				float x = width - (float)(options.Length - i) * (optionWidth + 8f) + 8f;
				Button val = PeakWindowStyle.CreatePill((Transform)(object)host, "Opt_" + id + i, options[i], x, y + 2f, optionWidth, 40f, 18f);
				((UnityEvent)val.onClick).AddListener((UnityAction)delegate
				{
					setter(index);
					RefreshControls();
				});
				buttons[i] = val;
			}
			Refreshers.Add(delegate
			{
				int num = getter();
				for (int j = 0; j < buttons.Length; j++)
				{
					PeakWindowStyle.SetPillSelected(buttons[j], j == num);
				}
			});
			y += 104f;
		}

		private void CreateKeyRow(RectTransform host, ref float y, float width, ConfigEntry<KeyCode> entry, string id, string title, string description, Func<string> status = null)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			CreateRowLabel(host, y, id, title, description);
			Button button = PeakWindowStyle.CreatePill((Transform)(object)host, "Key_" + id, string.Empty, width - 260f, y + 2f, 260f, 40f, 19f);
			TextMeshProUGUI label = ((Component)button).GetComponentInChildren<TextMeshProUGUI>();
			((UnityEvent)button.onClick).AddListener((UnityAction)delegate
			{
				BeginKeyCapture(entry, label);
			});
			if (status != null)
			{
				TextMeshProUGUI statusLabel = PeakWindowStyle.CreateText((Transform)(object)host, "KeyStatus_" + id, string.Empty, 17f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
				NativeUiFactory.Place((RectTransform)((TMP_Text)statusLabel).transform, width - 400f, y + 46f, 400f, 24f);
				Refreshers.Add(delegate
				{
					((TMP_Text)statusLabel).text = status();
				});
			}
			Refreshers.Add(delegate
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Invalid comparison between Unknown and I4
				if (_captureEntry != entry)
				{
					((TMP_Text)label).text = KeyLabel(entry.Value);
					PeakWindowStyle.SetPillSelected(button, (int)entry.Value > 0);
				}
			});
			y += 104f;
		}

		private static string RaceKeyStatus()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (RaceService.Instance?.CurrentRace != null)
			{
				string text = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Positive);
				return "<color=#" + text + ">" + Loc.T("settings.race.active") + "</color>";
			}
			return Loc.T("settings.race.inactive");
		}

		private void CreatePositionRow(RectTransform host, ref float y, float width)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			CreateRowLabel(host, y, "Position", Loc.T("settings.position.title"), Loc.T("settings.position.desc"));
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnMove", Loc.T("settings.position.move"), width - 400f, y + 2f, 240f, 40f, 18f).onClick).AddListener((UnityAction)delegate
			{
				BeginPositionMode(Plugin.OverlayPositionX, Plugin.OverlayPositionY, delegate(bool value)
				{
					NativeTimerPanel.PreviewMode = value;
				});
			});
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnMoveReset", Loc.T("settings.position.reset"), width - 152f, y + 2f, 152f, 40f, 16f).onClick).AddListener((UnityAction)delegate
			{
				Plugin.OverlayPositionX.Value = 10f;
				Plugin.OverlayPositionY.Value = 10f;
				RefreshControls();
			});
			TextMeshProUGUI valueLabel = PeakWindowStyle.CreateText((Transform)(object)host, "PositionValue", string.Empty, 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)valueLabel).transform, width - 400f, y + 46f, 400f, 24f);
			Refreshers.Add(delegate
			{
				((TMP_Text)valueLabel).text = string.Format(CultureInfo.InvariantCulture, "X {0:0}  /  Y {1:0}", Plugin.OverlayPositionX.Value, Plugin.OverlayPositionY.Value);
			});
			y += 104f;
		}

		private void CreateGhostPanelPositionRow(RectTransform host, ref float y, float width)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			CreateRowLabel(host, y, "GhostPanelPosition", Loc.T("settings.ghostPanelPos.title"), Loc.T("settings.ghostPanelPos.desc"));
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnGhostMove", Loc.T("settings.position.move"), width - 400f, y + 2f, 240f, 40f, 18f).onClick).AddListener((UnityAction)delegate
			{
				BeginPositionMode(Plugin.GhostPanelX, Plugin.GhostPanelY, delegate(bool value)
				{
					GhostStatusPanel.PreviewMode = value;
				});
			});
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnGhostMoveReset", Loc.T("settings.position.reset"), width - 152f, y + 2f, 152f, 40f, 16f).onClick).AddListener((UnityAction)delegate
			{
				Plugin.GhostPanelX.Value = 10f;
				Plugin.GhostPanelY.Value = 260f;
				RefreshControls();
			});
			TextMeshProUGUI valueLabel = PeakWindowStyle.CreateText((Transform)(object)host, "GhostPanelPositionValue", string.Empty, 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)valueLabel).transform, width - 400f, y + 46f, 400f, 24f);
			Refreshers.Add(delegate
			{
				((TMP_Text)valueLabel).text = string.Format(CultureInfo.InvariantCulture, "X {0:0}  /  Y {1:0}", Plugin.GhostPanelX.Value, Plugin.GhostPanelY.Value);
			});
			y += 104f;
		}

		private void CreateRaceHudPositionRow(RectTransform host, ref float y, float width)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			CreateRowLabel(host, y, "RaceHudPosition", Loc.T("settings.raceHudPos.title"), Loc.T("settings.raceHudPos.desc"));
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnRaceMove", Loc.T("settings.position.move"), width - 400f, y + 2f, 240f, 40f, 18f).onClick).AddListener((UnityAction)delegate
			{
				BeginPositionMode(Plugin.RaceHudX, Plugin.RaceHudY, delegate(bool value)
				{
					RaceHudOverlay.PreviewMode = value;
				});
			});
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)host, "BtnRaceMoveReset", Loc.T("settings.position.reset"), width - 152f, y + 2f, 152f, 40f, 16f).onClick).AddListener((UnityAction)delegate
			{
				Plugin.RaceHudX.Value = 1510f;
				Plugin.RaceHudY.Value = 20f;
				RefreshControls();
			});
			TextMeshProUGUI valueLabel = PeakWindowStyle.CreateText((Transform)(object)host, "RaceHudPositionValue", string.Empty, 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)valueLabel).transform, width - 400f, y + 46f, 400f, 24f);
			Refreshers.Add(delegate
			{
				((TMP_Text)valueLabel).text = string.Format(CultureInfo.InvariantCulture, "X {0:0}  /  Y {1:0}", Plugin.RaceHudX.Value, Plugin.RaceHudY.Value);
			});
			y += 104f;
		}

		private void CreateHint(RectTransform host, ref float y, float width, string text)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			NativeUiFactory.Place((RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)host, "Note", text, 18f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)257)).transform, 0f, y + 8f, width, 60f);
			y += 68f;
		}

		private void CreateWarningRow(RectTransform host, ref float y, float width, Func<bool> visible, string text)
		{
			//IL_001c: 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_005e: Expected O, but got Unknown
			TextMeshProUGUI label = PeakWindowStyle.CreateText((Transform)(object)host, "Warning", text, 19f, PeakWindowStyle.Danger, (TextAlignmentOptions)257);
			NativeUiFactory.Place((RectTransform)((TMP_Text)label).transform, 0f, y + 8f, width, 60f);
			Refreshers.Add(delegate
			{
				((Component)label).gameObject.SetActive(visible());
			});
			y += 68f;
		}

		private unsafe static string KeyLabel(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				return ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString().ToUpperInvariant();
			}
			return Loc.T("common.notBound");
		}

		private void BeginKeyCapture(ConfigEntry<KeyCode> entry, TextMeshProUGUI label)
		{
			_captureEntry = entry;
			_captureLabel = label;
			ModalGuard.CapturingKey = true;
			if ((Object)(object)label != (Object)null)
			{
				((TMP_Text)label).text = Loc.T("settings.key.capture");
			}
		}

		private void CancelKeyCapture()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (_captureEntry != null)
			{
				if ((Object)(object)_captureLabel != (Object)null)
				{
					((TMP_Text)_captureLabel).text = KeyLabel(_captureEntry.Value);
				}
				_captureEntry = null;
				_captureLabel = null;
				ModalGuard.CapturingKey = false;
				RefreshControls();
			}
		}

		private void UpdateKeyCapture()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (Input.GetKeyDown((KeyCode)27))
			{
				CancelKeyCapture();
				return;
			}
			if (Input.GetKeyDown((KeyCode)127) || Input.GetKeyDown((KeyCode)8))
			{
				_captureEntry.Value = (KeyCode)0;
				CancelKeyCapture();
				return;
			}
			KeyCode[] capturableKeys = GetCapturableKeys();
			foreach (KeyCode val in capturableKeys)
			{
				if (Input.GetKeyDown(val))
				{
					_captureEntry.Value = val;
					CancelKeyCapture();
					break;
				}
			}
		}

		private static KeyCode[] GetCapturableKeys()
		{
			//IL_0030: 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)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (_capturableKeys != null)
			{
				return _capturableKeys;
			}
			List<KeyCode> list = new List<KeyCode>();
			foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
			{
				if ((int)value != 0 && (int)value != 27 && (int)value != 323 && (int)value != 324 && (int)value != 127 && (int)value != 8 && !((object)value/*cast due to .constrained prefix*/).ToString().StartsWith("Joystick", StringComparison.Ordinal))
				{
					list.Add(value);
				}
			}
			_capturableKeys = list.ToArray();
			return _capturableKeys;
		}

		private void BeginPositionMode(ConfigEntry<float> targetX, ConfigEntry<float> targetY, Action<bool> preview)
		{
			_positionTargetX = targetX;
			_positionTargetY = targetY;
			_positionPreview = preview;
			_positionBackupX = targetX.Value;
			_positionBackupY = targetY.Value;
			_positionMode = true;
			preview?.Invoke(obj: true);
			Plugin.ConfigFile.SaveOnConfigSet = false;
			((MenuWindow)this).Hide();
			ShowPositionHint(visible: true);
		}

		private void EndPositionMode(bool restore)
		{
			if (restore)
			{
				_positionTargetX.Value = _positionBackupX;
				_positionTargetY.Value = _positionBackupY;
			}
			_positionMode = false;
			_positionPreview?.Invoke(obj: false);
			_positionPreview = null;
			ShowPositionHint(visible: false);
			Plugin.ConfigFile.SaveOnConfigSet = true;
			Plugin.ConfigFile.Save();
			OpenPanel(1);
		}

		private void UpdatePositionMode()
		{
			//IL_002a: 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)
			Canvas canvas = NativeUiFactory.GetCanvas();
			float num = (((Object)(object)canvas != (Object)null && canvas.scaleFactor > 0f) ? canvas.scaleFactor : 1f);
			float num2 = Input.mousePosition.x / num;
			float num3 = ((float)Screen.height - Input.mousePosition.y) / num;
			_positionTargetX.Value = Mathf.Round(Mathf.Clamp(num2, 0f, 1860f));
			_positionTargetY.Value = Mathf.Round(Mathf.Clamp(num3, 0f, 1040f));
			if (Input.GetKeyDown((KeyCode)27))
			{
				EndPositionMode(restore: true);
			}
			else if (Input.GetMouseButtonDown(0))
			{
				EndPositionMode(restore: false);
			}
		}

		private void ShowPositionHint(bool visible)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_positionHint == (Object)null && visible)
			{
				Image val = PeakWindowStyle.CreateSurface(((Component)NativeUiFactory.GetCanvas()).transform, "RankedPeak_PositionHint", new Color(0.05f, 0.06f, 0.08f, 0.88f), 10);
				_positionHint = (RectTransform)((Component)val).transform;
				_positionHint.anchorMin = new Vector2(0.5f, 0f);
				_positionHint.anchorMax = new Vector2(0.5f, 0f);
				_positionHint.pivot = new Vector2(0.5f, 0f);
				_positionHint.anchoredPosition = new Vector2(0f, 90f);
				_positionHint.sizeDelta = new Vector2(760f, 56f);
				RectTransform val2 = (RectTransform)((TMP_Text)PeakWindowStyle.CreateText((Transform)(object)_positionHint, "Text", Loc.T("settings.position.hint"), 22f, NativeUiFactory.TextPrimary, (TextAlignmentOptions)514)).transform;
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
			}
			if ((Object)(object)_positionHint != (Object)null)
			{
				((Component)_positionHint).gameObject.SetActive(visible);
				if (visible)
				{
					NativeUiFactory.EnsureTopMost();
				}
			}
		}
	}
	public class RunSummaryPanel : MenuWindow
	{
		private readonly struct Verdict
		{
			public readonly string ModeName;

			public readonly string Headline;

			public readonly Color HeadlineColor;

			public Verdict(string modeName, string headline, Color headlineColor)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				ModeName = modeName;
				Headline = headline;
				HeadlineColor = headlineColor;
			}
		}

		private const float WindowWidth = 940f;

		private const float WindowHeight = 660f;

		private const float TitleBarHeight = 72f;

		private const float WindowPadding = 22f;

		private const float BoxPadding = 22f;

		private const float AutoHideSeconds = 90f;

		private const float HeadRowHeight = 200f;

		private const float SplitsBoxY = 216f;

		private const float SplitsBoxHeight = 300f;

		private const float FooterY = 524f;

		private const float MiniWidth = 520f;

		private const float MiniHeight = 58f;

		private const int MaxInfoLines = 6;

		private const int MaxSplitLines = 7;

		private const int MaxStandingLines = 7;

		private const float SplitRowHeight = 30f;

		private const float StandingsSplit = 0.55f;

		private RaceTimer _timer;

		private RunStorageService _storage;

		private RectTransform _root;

		private RectTransform _windowRoot;

		private RectTransform _miniRoot;

		private TextMeshProUGUI _miniLabel;

		private TextMeshProUGUI _modeLabel;

		private TextMeshProUGUI _resultLabel;

		private TextMeshProUGUI _timeLabel;

		private TextMeshProUGUI _deltaLabel;

		private TextMeshProUGUI _statusLabel;

		private TextMeshProUGUI _rankLabel;

		private TextMeshProUGUI _splitHeaderLabel;

		private TextMeshProUGUI _standingsHeaderLabel;

		private readonly List<TextMeshProUGUI> _infoLines = new List<TextMeshProUGUI>();

		private readonly List<TextMeshProUGUI> _splitLines = new List<TextMeshProUGUI>();

		private readonly List<TextMeshProUGUI> _standingLines = new List<TextMeshProUGUI>();

		private bool _built;

		private string _shownRunId;

		private RunRecord _shownRecord;

		private float _hideAtTime;

		private string _uploadStatusText;

		private Color _uploadStatusColor;

		private string _dailyRankText;

		private bool _rankFetched;

		private GameObject _panelPlaceholder;

		private bool _dismissed;

		private bool _reopenLogged;

		private static string SplitColumns => "#<pos=6%>" + Loc.T("summary.col.segment") + "<pos=48%>" + Loc.T("summary.col.total") + "<pos=74%>" + Loc.T("summary.col.time");

		public override bool openOnStart => false;

		public override bool selectOnOpen => false;

		public override bool blocksPlayerInput => false;

		public override bool showCursorWhileOpen => true;

		public override GameObject panel
		{
			get
			{
				if (!((Object)(object)_root != (Object)null))
				{
					return _panelPlaceholder;
				}
				return ((Component)_root).gameObject;
			}
		}

		public void Initialize(RaceTimer timer, RunStorageService storage)
		{
			_timer = timer;
			_storage = storage;
		}

		public override void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_panelPlaceholder = new GameObject("PanelPlaceholder");
			_panelPlaceholder.transform.SetParent(((Component)this).transform, false);
			_panelPlaceholder.SetActive(false);
		}

		private void OnEnable()
		{
			RunUploadService.UploadSettled += OnUploadSettled;
			RaceService.RaceUpdated += OnRaceUpdated;
		}

		private void OnDisable()
		{
			RunUploadService.UploadSettled -= OnUploadSettled;
			RaceService.RaceUpdated -= OnRaceUpdated;
		}

		private void OnRaceUpdated(RaceInfo race)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (_built && (Object)(object)_root != (Object)null && ((Component)_root).gameObject.activeSelf)
			{
				RefreshStandings(ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted));
			}
		}

		public override void Update()
		{
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (_timer == null)
			{
				return;
			}
			if (_built && (Object)(object)_root == (Object)null)
			{
				_built = false;
				_shownRunId = null;
				_infoLines.Clear();
				_splitLines.Clear();
			}
			if (!_built)
			{
				BuildPanel();
			}
			RunRecord lastRunRecord = _timer.LastRunRecord;
			bool flag = Plugin.ShowRunSummary.Value && _timer.State == TimerState.Finished && lastRunRecord != null;
			if (flag && _shownRunId != lastRunRecord.Id.ToString())
			{
				ShowSummary(lastRunRecord);
			}
			else if (flag && !_dismissed && !((MenuWindow)this).isOpen)
			{
				if (!_reopenLogged)
				{
					_reopenLogged = true;
					RankedLog.Info("[Summary] Karte wurde vom Spiel geschlossen (MenuWindow.CloseAllWindows) - wird wieder geoeffnet.");
				}
				_hideAtTime = Time.time + 90f;
				((MenuWindow)this).Open();
				NativeUiFactory.EnsureTopMost();
			}
			if (((MenuWindow)this).isOpen)
			{
				if (!flag || Time.time >= _hideAtTime || Input.GetKeyDown((KeyCode)27) || Input.GetKeyDown(Plugin.OverlayToggleKey.Value))
				{
					Dismiss();
				}
				else
				{
					RefreshDynamicLines();
				}
			}
		}

		private void BuildPanel()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0054: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			_built = true;
			Canvas canvas = NativeUiFactory.GetCanvas();
			GameObject val = new GameObject("RankedPeak_SummaryRoot", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)canvas).transform, false);
			_root = (RectTransform)val.transform;
			_root.anchorMin = Vector2.zero;
			_root.anchorMax = Vector2.one;
			_root.offsetMin = Vector2.zero;
			_root.offsetMax = Vector2.zero;
			GameObject val2 = new GameObject("SummaryWindowHost", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)_root, false);
			_windowRoot = (RectTransform)val2.transform;
			_windowRoot.anchorMin = Vector2.zero;
			_windowRoot.anchorMax = Vector2.one;
			_windowRoot.offsetMin = Vector2.zero;
			_windowRoot.offsetMax = Vector2.zero;
			PeakWindowStyle.WindowParts windowParts = PeakWindowStyle.CreateWindow((Transform)(object)_windowRoot, "SummaryWindow", 940f, 660f, 72f, Loc.T("summary.title"), Loc.T("summary.subtitle"));
			Image component = ((Component)windowParts.Root).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).raycastTarget = false;
			}
			BuildTitleBarActions(windowParts.TitleBar);
			RectTransform body = windowParts.Body;
			float innerWidth = 896f;
			BuildResultBox(body, innerWidth);
			BuildSplitsBox(body, innerWidth);
			BuildFooter(body, innerWidth);
			BuildMiniBar();
			((Component)_root).gameObject.SetActive(false);
		}

		private void BuildTitleBarActions(RectTransform titleBar)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)titleBar, "BtnCollapse", Loc.T("summary.btn.collapse"), 662f, 16f, 190f, 40f, 18f);
			TintOnBar(obj);
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				SetMinimized(minimized: true);
			});
			Button obj2 = PeakWindowStyle.CreatePill((Transform)(object)titleBar, "BtnClose", "X", 864f, 16f, 44f, 40f, 22f);
			TintOnBar(obj2);
			((UnityEvent)obj2.onClick).AddListener(new UnityAction(Dismiss));
		}

		private void Dismiss()
		{
			_dismissed = true;
			((MenuWindow)this).Close();
		}

		private void BuildMiniBar()
		{
			//IL_001f: 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_003d: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Expected O, but got Unknown
			Image val = PeakWindowStyle.CreateSurface((Transform)(object)_root, "SummaryMini", new Color(0.05f, 0.06f, 0.08f, 0.9f), 10);
			_miniRoot = (RectTransform)((Component)val).transform;
			_miniRoot.anchorMin = new Vector2(0.5f, 0f);
			_miniRoot.anchorMax = new Vector2(0.5f, 0f);
			_miniRoot.pivot = new Vector2(0.5f, 0f);
			_miniRoot.anchoredPosition = new Vector2(0f, 26f);
			_miniRoot.sizeDelta = new Vector2(520f, 58f);
			_miniLabel = PeakWindowStyle.CreateText((Transform)(object)_miniRoot, "MiniText", string.Empty, 22f, NativeUiFactory.TextPrimary, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_miniLabel).transform, 18f, 0f, 360f, 58f);
			((UnityEvent)PeakWindowStyle.CreatePill((Transform)(object)_miniRoot, "BtnExpand", Loc.T("summary.btn.expand"), 372f, 10f, 132f, 38f, 17f).onClick).AddListener((UnityAction)delegate
			{
				SetMinimized(minimized: false);
			});
			((Component)_miniRoot).gameObject.SetActive(false);
		}

		private static void TintOnBar(Button button)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)button).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(1f, 1f, 1f, 0.22f);
			}
		}

		private void SetMinimized(bool minimized)
		{
			Plugin.SummaryMinimized.Value = minimized;
			ApplyMinimizedState();
		}

		private void ApplyMinimizedState()
		{
			bool value = Plugin.SummaryMinimized.Value;
			if ((Object)(object)_windowRoot != (Object)null)
			{
				((Component)_windowRoot).gameObject.SetActive(!value);
			}
			if ((Object)(object)_miniRoot != (Object)null)
			{
				((Component)_miniRoot).gameObject.SetActive(value);
			}
		}

		private void BuildResultBox(RectTransform body, float innerWidth)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			float num = innerWidth * 0.58f;
			float num2 = innerWidth - num - 16f;
			float width = num - 44f;
			RectTransform parent = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxResult", Loc.T("summary.box.result"), 22f, 8f, num, 200f);
			_modeLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "Mode", string.Empty, 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513, display: false, 6f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_modeLabel).transform, 22f, 48f, width, 24f);
			_resultLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "Result", string.Empty, 30f, PeakWindowStyle.Positive, (TextAlignmentOptions)513, display: false, 5f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_resultLabel).transform, 22f, 72f, width, 38f);
			_timeLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "Time", "00:00.000", 50f, PeakWindowStyle.Heading, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_timeLabel).transform, 22f, 110f, width, 56f);
			_deltaLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "Delta", string.Empty, 20f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_deltaLabel).transform, 22f, 166f, width, 26f);
			RectTransform parent2 = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxRun", Loc.T("summary.box.run"), 22f + num + 16f, 8f, num2, 200f);
			float num3 = 46f;
			for (int i = 0; i < 6; i++)
			{
				TextMeshProUGUI val = PeakWindowStyle.CreateText((Transform)(object)parent2, $"Info{i}", string.Empty, 19f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val).transform, 22f, num3, num2 - 44f, 24f);
				((TMP_Text)val).textWrappingMode = (TextWrappingModes)0;
				((Component)val).gameObject.SetActive(false);
				_infoLines.Add(val);
				num3 += 21f;
			}
		}

		private void BuildSplitsBox(RectTransform body, float innerWidth)
		{
			//IL_003f: 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_007e: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			RectTransform parent = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxSplits", Loc.T("summary.box.splits"), 22f, 216f, innerWidth, 300f);
			float num = innerWidth - 44f;
			_splitHeaderLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "SplitHeader", SplitColumns, 19f, PeakWindowStyle.Heading, (TextAlignmentOptions)513, display: false, 3f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_splitHeaderLabel).transform, 22f, 50f, num, 26f);
			PeakWindowStyle.CreateSeparator((Transform)(object)parent, "SplitSeparator", 22f, 78f, num);
			for (int i = 0; i < 7; i++)
			{
				TextMeshProUGUI val = PeakWindowStyle.CreateText((Transform)(object)parent, $"Split{i}", string.Empty, 22f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val).transform, 22f, 86f + (float)i * 30f, num, 30f);
				((Component)val).gameObject.SetActive(false);
				_splitLines.Add(val);
			}
			float x = 22f + num * 0.55f + 16f;
			float width = num * 0.45f - 16f;
			_standingsHeaderLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "StandingsHeader", "#<pos=18%>" + Loc.T("summary.col.player") + "<pos=68%>" + Loc.T("summary.col.time"), 19f, PeakWindowStyle.Heading, (TextAlignmentOptions)513, display: false, 3f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_standingsHeaderLabel).transform, x, 50f, width, 26f);
			((Component)_standingsHeaderLabel).gameObject.SetActive(false);
			for (int j = 0; j < 7; j++)
			{
				TextMeshProUGUI val2 = PeakWindowStyle.CreateText((Transform)(object)parent, $"Standing{j}", string.Empty, 21f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val2).transform, x, 86f + (float)j * 30f, width, 30f);
				((Component)val2).gameObject.SetActive(false);
				_standingLines.Add(val2);
			}
		}

		private void BuildFooter(RectTransform body, float innerWidth)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			_statusLabel = PeakWindowStyle.CreateText((Transform)(object)body, "UploadStatus", string.Empty, 21f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_statusLabel).transform, 22f, 524f, innerWidth * 0.6f, 28f);
			_rankLabel = PeakWindowStyle.CreateText((Transform)(object)body, "DailyRank", string.Empty, 21f, PeakWindowStyle.Heading, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_rankLabel).transform, 22f + innerWidth * 0.6f, 524f, innerWidth * 0.4f, 28f);
		}

		private static string ModeName(GameMode mode)
		{
			return mode switch
			{
				GameMode.StaticDaily => Loc.T("mode.staticDaily"), 
				GameMode.RankedDuel => Loc.T("mode.rankedDuel"), 
				GameMode.Speedrun => Loc.T("mode.speedrun"), 
				GameMode.GhostTraining => Loc.T("mode.ghostTraining"), 
				GameMode.LiveRace => Loc.T("mode.liveRace"), 
				_ => mode.ToString().ToUpperInvariant(), 
			};
		}

		private static Verdict BuildVerdict(RunRecord record, RaceInfo race)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			string text = ModeName(record.Mode);
			if (record.Result == RunResult.Died)
			{
				return new Verdict(text, Loc.T("verdict.died"), PeakWindowStyle.Danger);
			}
			if (record.Result != RunResult.Completed)
			{
				return new Verdict(text, Loc.T("verdict.aborted"), PeakWindowStyle.Danger);
			}
			if (race != null)
			{
				return Placement(text, race.Participants.Find((RaceParticipant p) => p.SteamId == SteamIdentity.GetSteamId64())?.Rank);
			}
			if (record.Mode == GameMode.RankedDuel)
			{
				GhostPlaybackService instance = GhostPlaybackService.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.CurrentGhostTotalMs > 0 && record.TotalMs >= instance.CurrentGhostTotalMs)
				{
					return new Verdict(text, Loc.T("verdict.lost"), PeakWindowStyle.Danger);
				}
				return new Verdict(text, Loc.T("verdict.won"), PeakWindowStyle.Gold);
			}
			return new Verdict(text, Loc.T("verdict.finished"), PeakWindowStyle.Positive);
		}

		private static Verdict Placement(string mode, int? rank)
		{
			//IL_007a: 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_004a: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			return rank switch
			{
				1 => new Verdict(mode, Loc.T("verdict.won"), PeakWindowStyle.Gold), 
				2 => new Verdict(mode, Loc.T("verdict.place2"), PeakWindowStyle.Silver), 
				3 => new Verdict(mode, Loc.T("verdict.place3"), PeakWindowStyle.Bronze), 
				null => new Verdict(mode, Loc.T("verdict.finished"), PeakWindowStyle.Positive), 
				_ => new Verdict(mode, Loc.T("verdict.placeN", rank), PeakWindowStyle.Positive), 
			};
		}

		private static Color OnDark(Color color)
		{
			//IL_0000: 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)
			float num = default(float);
			float num2 = default(float);
			float num3 = default(float);
			Color.RGBToHSV(color, ref num, ref num2, ref num3);
			return Color.HSVToRGB(num, Mathf.Min(num2, 0.72f), Mathf.Max(num3, 0.85f));
		}

		private static RaceInfo RaceFor(RunRecord record)
		{
			if (record == null || record.Mode != GameMode.LiveRace)
			{
				return null;
			}
			RaceService instance = RaceService.Instance;
			object obj = instance?.CurrentRace;
			if (obj == null)
			{
				if (instance == null)
				{
					return null;
				}
				obj = instance.LastFinishedRace;
			}
			return (RaceInfo)obj;
		}

		private void ShowSummary(RunRecord record)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			_shownRunId = record.Id.ToString();
			_shownRecord = record;
			_hideAtTime = Time.time + 90f;
			_dismissed = false;
			_reopenLogged = false;
			bool flag = RunUploadService.IsBoardEligible(record.Mode);
			_uploadStatusText = Loc.T((record.Mode == GameMode.Vanilla) ? "summary.upload.vanilla" : (flag ? "summary.upload.sending" : "summary.upload.practice"));
			_uploadStatusColor = PeakWindowStyle.TextMuted;
			((TMP_Text)_timeLabel).text = FormatTime(record.TotalMs);
			SetDelta(string.Empty, PeakWindowStyle.TextMuted);
			RunUploadService.Instance?.TriggerImmediateFlush();
			RaceInfo race = RaceFor(record);
			Verdict verdict = BuildVerdict(record, race);
			((TMP_Text)_modeLabel).text = verdict.ModeName;
			SetResult(verdict.Headline, verdict.HeadlineColor);
			string text = ColorUtility.ToHtmlStringRGB(OnDark(verdict.HeadlineColor));
			((TMP_Text)_miniLabel).text = verdict.ModeName + "   <color=#" + text + ">" + verdict.Headline + "</color>   " + FormatTime(record.TotalMs);
			List<(string, Color)> list = new List<(string, Color)>();
			list.Add((Loc.T("summary.info.map", record.MapName, MapCatalog.ToDisplaySignature(record.BiomeId)), PeakWindowStyle.TextPrimary));
			list.Add((Loc.T("summary.info.ascent", record.AscentLevel, record.GameVersion), PeakWindowStyle.TextPrimary));
			list.Add((Loc.T("summary.info.route", RunConfigService.GetRouteName(record.RouteIndex)) + (string.IsNullOrEmpty(record.RouteBiomeName) ? string.Empty : (" (" + record.RouteBiomeName + ")")), PeakWindowStyle.TextPrimary));
			List<(string, Color)> list2 = list;
			if (record.Seed >= 0)
			{
				list2.Add((Loc.T("summary.info.seed", record.Seed), PeakWindowStyle.TextPrimary));
			}
			AddModeInfo(record, race, list2);
			for (int i = 0; i < _infoLines.Count; i++)
			{
				bool flag2 = i < list2.Count;
				((Component)_infoLines[i]).gameObject.SetActive(flag2);
				if (flag2)
				{
					((TMP_Text)_infoLines[i]).text = list2[i].Item1;
					((Graphic)_infoLines[i]).color = list2[i].Item2;
				}
			}
			int num = Math.Min(record.Splits.Count, 7);
			string text2 = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted);
			for (int j = 0; j < _splitLines.Count; j++)
			{
				bool flag3 = j < num;
				((Component)_splitLines[j]).gameObject.SetActive(flag3);
				if (flag3)
				{
					SplitRecord splitRecord = record.Splits[j];
					long num2 = ((j > 0) ? record.Splits[j - 1].ElapsedMs : 0);
					((TMP_Text)_splitLines[j]).text = $"<color=#{text2}>{j + 1}</color><pos=6%>{splitRecord.SegmentName}" + "<pos=48%>" + FormatTime(splitRecord.ElapsedMs) + "<pos=74%><color=#" + text2 + ">" + FormatTime(splitRecord.ElapsedMs - num2) + "</color>";
				}
			}
			RefreshStandings(text2);
			ApplyMinimizedState();
			((MenuWindow)this).Open();
			NativeUiFactory.EnsureTopMost();
			RefreshDynamicLines();
			RankedLog.Info($"[Summary] Run-Summary angezeigt (Run {_shownRunId}, {record.Result}, {record.TotalMs} ms).");
		}

		private void AddModeInfo(RunRecord record, RaceInfo race, List<(string Text, Color Color)> info)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (race != null)
			{
				info.Add((Loc.T("summary.info.race", race.InviteCode, race.Participants.Count), PeakWindowStyle.TextPrimary));
				SetRaceComparison(record, race);
				return;
			}
			GhostPlaybackService instance = GhostPlaybackService.Instance;
			bool flag = (Object)(object)instance != (Object)null && instance.IsExternalGhostActive && instance.CurrentGhostTotalMs > 0;
			if (record.Mode == GameMode.RankedDuel)
			{
				if (flag)
				{
					info.Add((Loc.T("summary.info.opponent", Truncate(instance.CurrentGhostPlayerName, 14), instance.CurrentGhostElo), PeakWindowStyle.TextPrimary));
					SetComparison(Loc.T("summary.cmp.opponent"), instance.CurrentGhostTotalMs, record.TotalMs);
				}
				DuelService.Instance?.SubmitDuelResult(record, delegate(DuelResultDto result)
				{
					//IL_008d: 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_0092: Unknown result type (might be due to invalid IL or missing references)
					string arg = ((result.Delta >= 0) ? "+" : string.Empty);
					_uploadStatusText = Loc.T("summary.duel.result", Loc.T(result.Won ? "summary.duel.won" : "summary.duel.lost"), result.OldElo, result.NewElo, $"{arg}{result.Delta}");
					_uploadStatusColor = (result.Won ? PeakWindowStyle.Positive : PeakWindowStyle.Danger);
					RefreshDynamicLines();
				});
			}
			else if (record.Mode == GameMode.GhostTraining && flag)
			{
				info.Add((Loc.T("summary.info.ghost", Truncate(instance.CurrentGhostPlayerName, 22)), PeakWindowStyle.TextPrimary));
				SetComparison(Loc.T("summary.cmp.ghost"), instance.CurrentGhostTotalMs, record.TotalMs);
			}
			else
			{
				SetPersonalBestComparison(record);
			}
		}

		private void SetComparison(string opponentLabel, long opponentMs, long ownMs)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			long num = ownMs - opponentMs;
			SetDelta(opponentLabel + " " + FormatTime(opponentMs) + "   " + FormatDelta(num), (num <= 0) ? PeakWindowStyle.Positive : PeakWindowStyle.Danger);
		}

		private void SetRaceComparison(RunRecord record, RaceInfo race)
		{
			RaceParticipant raceParticipant = race.Participants.Find((RaceParticipant p) => p.Rank == 1 && p.TotalMs.HasValue);
			if (raceParticipant == null || raceParticipant.SteamId == SteamIdentity.GetSteamId64())
			{
				SetPersonalBestComparison(record);
				return;
			}
			SetComparison(Loc.T("summary.cmp.winner", Truncate(raceParticipant.PlayerName, 14)), raceParticipant.TotalMs.Value, record.TotalMs);
		}

		private void SetPersonalBestComparison(RunRecord record)
		{
			//IL_000e: 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_006e: 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)
			if (record.Result != RunResult.Completed)
			{
				SetDelta(string.Empty, PeakWindowStyle.TextMuted);
				return;
			}
			if (_timer.LastRunWasPersonalBest)
			{
				SetDelta(Loc.T("summary.newPb"), PeakWindowStyle.Positive);
				return;
			}
			long lastRunDeltaToPbMs = _timer.LastRunDeltaToPbMs;
			SetDelta(Loc.T("summary.cmp.pb", FormatDelta(lastRunDeltaToPbMs)), (lastRunDeltaToPbMs <= 0) ? PeakWindowStyle.Positive : PeakWindowStyle.TextMuted);
		}

		private void RefreshStandings(string mutedHex)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			RaceInfo raceInfo = ShownRace();
			bool flag = raceInfo != null && raceInfo.Participants.Count > 0;
			((Component)_standingsHeaderLabel).gameObject.SetActive(flag);
			float num = 896f - 44f;
			float num2 = (flag ? (num * 0.55f) : num);
			foreach (TextMeshProUGUI splitLine in _splitLines)
			{
				RectTransform val = (RectTransform)((TMP_Text)splitLine).transform;
				val.sizeDelta = new Vector2(num2, val.sizeDelta.y);
			}
			if ((Object)(object)_splitHeaderLabel != (Object)null)
			{
				RectTransform val2 = (RectTransform)((TMP_Text)_splitHeaderLabel).transform;
				val2.sizeDelta = new Vector2(num2, val2.sizeDelta.y);
			}
			if (!flag)
			{
				foreach (TextMeshProUGUI standingLine in _standingLines)
				{
					((Component)standingLine).gameObject.SetActive(false);
				}
				return;
			}
			List<RaceParticipant> list = new List<RaceParticipant>(raceInfo.Participants);
			list.Sort(CompareStandings);
			string steamId = SteamIdentity.GetSteamId64();
			for (int i = 0; i < _standingLines.Count; i++)
			{
				bool flag2 = i < list.Count;
				((Component)_standingLines[i]).gameObject.SetActive(flag2);
				if (flag2)
				{
					RaceParticipant raceParticipant = list[i];
					string text = (raceParticipant.Rank.HasValue ? $"#{raceParticipant.Rank.Value}" : "-");
					string state = raceParticipant.State;
					string text2 = ((state == "finished") ? (raceParticipant.TotalMs.HasValue ? FormatTime(raceParticipant.TotalMs.Value) : Loc.T("state.finished")) : ((!(state == "dnf")) ? $"{Mathf.RoundToInt(raceParticipant.Progress * 100f)} %" : Loc.T("state.dnf")));
					string text3 = text2;
					((TMP_Text)_standingLines[i]).text = "<color=#" + mutedHex + ">" + text + "</color><pos=18%>" + raceParticipant.PlayerName + "<pos=68%>" + text3;
					((Graphic)_standingLines[i]).color = ((raceParticipant.SteamId == steamId) ? PeakWindowStyle.Pill : ((raceParticipant.State == "dnf") ? PeakWindowStyle.TextMuted : PeakWindowStyle.TextPrimary));
				}
			}
		}

		private RaceInfo ShownRace()
		{
			return RaceFor(_shownRecord);
		}

		private static int CompareStandings(RaceParticipant a, RaceParticipant b)
		{
			int num = Weight(a).CompareTo(Weight(b));
			if (num != 0)
			{
				return num;
			}
			if (Weight(a) == 0)
			{
				return (a.Rank ?? int.MaxValue).CompareTo(b.Rank ?? int.MaxValue);
			}
			return b.Progress.CompareTo(a.Progress);
			static int Weight(RaceParticipant p)
			{
				if (!(p.State == "finished"))
				{
					if (!(p.State == "dnf"))
					{
						return 1;
					}
					return 2;
				}
				return 0;
			}
		}

		private void SetResult(string text, Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_resultLabel).text = text;
			((Graphic)_resultLabel).color = color;
		}

		private void SetDelta(string text, Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_deltaLabel).text = text;
			((Graphic)_deltaLabel).color = color;
		}

		private void RefreshDynamicLines()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_statusLabel).text = _uploadStatusText;
			((Graphic)_statusLabel).color = _uploadStatusColor;
			string text = _dailyRankText;
			if (text == null && _timer.LastRunRecord != null && _timer.LastRunRecord.Result == RunResult.Completed && RunUploadService.IsBoardEligible(_timer.LastRunRecord.Mode))
			{
				text = Loc.T("rank.loading");
			}
			((TMP_Text)_rankLabel).text = text ?? string.Empty;
		}

		private void OnUploadSettled(string runId, string status)
		{
			//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)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (!(runId != _shownRunId))
			{
				switch (status)
				{
				case "personal_best":
					_uploadStatusText = Loc.T("summary.upload.pb");
					_uploadStatusColor = PeakWindowStyle.Positive;
					break;
				case "ok":
					_uploadStatusText = Loc.T("summary.upload.ok");
					_uploadStatusColor = PeakWindowStyle.Positive;
					break;
				case "duplicate":
					_uploadStatusText = Loc.T("summary.upload.duplicate");
					_uploadStatusColor = PeakWindowStyle.TextMuted;
					break;
				case "under_review":
					_uploadStatusText = Loc.T("summary.upload.review");
					_uploadStatusColor = PeakWindowStyle.Gold;
					break;
				case "flagged":
					_uploadStatusText = Loc.T("summary.upload.flagged");
					_uploadStatusColor = PeakWindowStyle.Danger;
					break;
				default:
					_uploadStatusText = Loc.T("summary.upload.rejected");
					_uploadStatusColor = PeakWindowStyle.Danger;
					break;
				}
				if (status != "flagged" && status != "under_review" && status != "rejected" && _timer.LastRunRecord != null && _timer.LastRunRecord.Result == RunResult.Completed)
				{
					((MonoBehaviour)this).StartCoroutine(FetchDailyRank(runId));
				}
			}
		}

		private IEnumerator FetchDailyRank(string runId)
		{
			if (_rankFetched)
			{
				yield break;
			}
			_rankFetched = true;
			RunRecord lastRunRecord = _timer.LastRunRecord;
			if (lastRunRecord != null)
			{
				yield return DailyRankService.FetchRankText(lastRunRecord, runId, delegate(string text)
				{
					_dailyRankText = text;
				});
			}
		}

		private static string Truncate(string value, int max)
		{
			if (string.IsNullOrEmpty(value) || value.Length <= max)
			{
				return value ?? string.Empty;
			}
			return value.Substring(0, Math.Max(1, max - 1)) + "…";
		}

		private static string FormatTime(long ms)
		{
			bool num = ms < 0;
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(num ? (-ms) : ms);
			string text = (num ? "-" : string.Empty);
			return $"{text}{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}

		private static string FormatDelta(long deltaMs)
		{
			return ((double)deltaMs / 1000.0).ToString("+0.000' s';-0.000' s'", CultureInfo.InvariantCulture);
		}
	}
	public class TimerOverlay : MonoBehaviour
	{
		private const float BoxWidth = 280f;

		private const float LineHeight = 20f;

		private const float TimeHeight = 30f;

		private const float Padding = 8f;

		private RaceTimer _timer;

		private RunStorageService _storage;

		private const string IslandScenePrefix = "Level_";

		private static bool? _wish;

		private static bool _onMountain;

		private Texture2D _backgroundTexture;

		private GUIStyle _timeStyle;

		private GUIStyle _textStyle;

		private GUIStyle _headerStyle;

		public static bool Visible => _wish ?? _onMountain;

		public static bool HudVisible => _wish ?? true;

		public static void SetVisible(bool visible)
		{
			_wish = visible;
		}

		public void Initialize(RaceTimer timer, RunStorageService storage)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_timer = timer;
			_storage = storage;
			Scene activeScene = SceneManager.GetActiveScene();
			_onMountain = IsIslandScene(((Scene)(ref activeScene)).name);
		}

		private void OnEnable()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDisable()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_onMountain = IsIslandScene(((Scene)(ref scene)).name);
			_wish = null;
		}

		private static bool IsIslandScene(string sceneName)
		{
			if (!string.IsNullOrEmpty(sceneName))
			{
				return sceneName.StartsWith("Level_", StringComparison.Ordinal);
			}
			return false;
		}

		private void Update()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!ModalGuard.CapturingKey)
			{
				KeyCode value = Plugin.SettingsMenuKey.Value;
				if ((int)value != 0 && Input.GetKeyDown(value))
				{
					RankedSettingsModal.ToggleWindow();
				}
				KeyCode value2 = Plugin.OverlayToggleKey.Value;
				if ((int)value2 != 0 && Input.GetKeyDown(value2))
				{
					_wish = !Visible;
				}
				KeyCode value3 = Plugin.RunResetKey.Value;
				if ((int)value3 != 0 && Input.GetKeyDown(value3))
				{
					_timer?.SoftReset();
				}
			}
			if (_timer != null && _timer.State == TimerState.WaitingForInput && !RaceInputLock.IsLocked && !ModalGuard.AnyOpen && ControlInputDetected())
			{
				_timer.BeginRun();
			}
		}

		private bool ControlInputDetected()
		{
			if (Input.GetKeyDown((KeyCode)119) || Input.GetKeyDown((KeyCode)97) || Input.GetKeyDown((KeyCode)115) || Input.GetKeyDown((KeyCode)100) || Input.GetKeyDown((KeyCode)32) || Input.GetKeyDown((KeyCode)304) || Input.GetKeyDown((KeyCode)101) || Input.GetKeyDown((KeyCode)102) || Input.GetMouseButtonDown(0) || Input.GetMouseButtonDown(1))
			{
				return true;
			}
			try
			{
				if (Mathf.Abs(Input.GetAxis("Mouse X")) > 0.01f || Mathf.Abs(Input.GetAxis("Mouse Y")) > 0.01f)
				{
					return true;
				}
			}
			catch (Exception)
			{
			}
			return false;
		}

		private void OnGUI()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.UseNativeTimer.Value || !Visible || _timer == null)
			{
				return;
			}
			EnsureStyles();
			List<(string, bool)> list = BuildLines();
			float num = 46f + (float)list.Count * 20f;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(Plugin.OverlayPositionX.Value, Plugin.OverlayPositionY.Value, 280f, num);
			GUI.DrawTexture(val, (Texture)(object)_backgroundTexture);
			float num2 = ((Rect)(ref val)).y + 8f;
			GUI.Label(new Rect(((Rect)(ref val)).x + 8f, num2, 264f, 30f), FormatTime(_timer.CurrentElapsedMs), _timeStyle);
			num2 += 30f;
			foreach (var item in list)
			{
				GUI.Label(new Rect(((Rect)(ref val)).x + 8f, num2, 264f, 20f), item.Item1, item.Item2 ? _headerStyle : _textStyle);
				num2 += 20f;
			}
		}

		private List<(string Text, bool IsHeader)> BuildLines()
		{
			List<(string, bool)> list = new List<(string, bool)> { ($"PEAK RANKED [{_timer.State}]", true) };
			GameMode gameMode = ((_timer.State == TimerState.Running || _timer.State == TimerState.Finished) ? _timer.CurrentMode : Plugin.SelectedMode.Value);
			list.Add((Loc.T("overlay.mode", gameMode), false));
			if (_timer.State != TimerState.Idle && _timer.State != TimerState.Armed && _timer.CurrentSeed >= 0)
			{
				list.Add((Loc.T("overlay.seed", _timer.CurrentSeed), false));
			}
			if (_timer.State == TimerState.Running || _timer.State == TimerState.Finished || _timer.State == TimerState.WaitingForInput)
			{
				list.Add((Loc.T("overlay.map", _timer.CurrentMapName, _timer.CurrentAscentLevel), false));
			}
			if (_timer.State == TimerState.WaitingForInput)
			{
				list.Add((Loc.T("overlay.waitingInput"), false));
			}
			long? personalBestMs = _storage.GetPersonalBestMs(gameMode);
			list.Add((Loc.T("overlay.pb", personalBestMs.HasValue ? FormatTime(personalBestMs.Value) : "-"), false));
			IReadOnlyList<SplitRecord> splits = _timer.Splits;
			if (splits.Count > 0)
			{
				list.Add((Loc.T("overlay.splits"), true));
				foreach (SplitRecord item in splits)
				{
					list.Add((item.SegmentName + "  " + FormatTime(item.ElapsedMs), false));
				}
			}
			if (_timer.State == TimerState.Finished && _timer.LastRunRecord != null)
			{
				RunRecord lastRunRecord = _timer.LastRunRecord;
				switch (lastRunRecord.Result)
				{
				case RunResult.Completed:
					list.Add((Loc.T("overlay.completed"), true));
					list.Add((_timer.LastRunWasPersonalBest ? Loc.T("overlay.newPb") : Loc.T("overlay.pbDelta", FormatDelta(_timer.LastRunDeltaToPbMs)), false));
					break;
				case RunResult.Died:
					list.Add((Loc.T("overlay.died"), true));
					break;
				case RunResult.Aborted:
					list.Add((Loc.T("overlay.aborted"), true));
					break;
				default:
					list.Add((Loc.T("overlay.result", lastRunRecord.Result), true));
					break;
				}
			}
			return list;
		}

		private void EnsureStyles()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_backgroundTexture == (Object)null)
			{
				_backgroundTexture = new Texture2D(1, 1);
				_backgroundTexture.SetPixel(0, 0, new Color(0f, 0f, 0f, 0.75f));
				_backgroundTexture.Apply();
			}
			if (_timeStyle == null)
			{
				_timeStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 24,
					fontStyle = (FontStyle)1
				};
				_timeStyle.normal.textColor = Color.white;
				_textStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 13
				};
				_textStyle.normal.textColor = Color.white;
				_headerStyle = new GUIStyle(GUI.skin.label)
				{
					fontSize = 13,
					fontStyle = (FontStyle)1
				};
				_headerStyle.normal.textColor = new Color(1f, 0.85f, 0.4f);
			}
		}

		private static string FormatTime(long ms)
		{
			bool num = ms < 0;
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(num ? (-ms) : ms);
			string text = (num ? "-" : string.Empty);
			return $"{text}{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}

		private static string FormatDelta(long deltaMs)
		{
			return ((double)deltaMs / 1000.0).ToString("+0.000' s';-0.000' s'", CultureInfo.InvariantCulture);
		}
	}
}
namespace RankedPeak.Ui.Native
{
	public static class AfflictionPalette
	{
		private static readonly Color Fallback = new Color(0.55f, 0.58f, 0.62f);

		private static Color _stamina = new Color(0.55f, 0.8f, 0.3f);

		private static Color _adrenaline = new Color(0.75f, 0.9f, 0.3f);

		private static readonly Dictionary<STATUSTYPE, Color> Colors = new Dictionary<STATUSTYPE, Color>();

		private static bool _resolved;

		public static Color Stamina
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				EnsureResolved();
				return _stamina;
			}
		}

		public static Color Adrenaline
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				EnsureResolved();
				return _adrenaline;
			}
		}

		public static Color ColorOf(STATUSTYPE type)
		{
			//IL_000a: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			EnsureResolved();
			if (!Colors.TryGetValue(type, out var value))
			{
				return Fallback;
			}
			return value;
		}

		public static void Invalidate()
		{
			_resolved = false;
		}

		private static void EnsureResolved()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			if (_resolved)
			{
				return;
			}
			try
			{
				StaminaBar val = (((Object)(object)GUIManager.instance != (Object)null) ? GUIManager.instance.bar : null);
				if ((Object)(object)val == (Object)null || val.afflictions == null || val.afflictions.Length == 0)
				{
					return;
				}
				BarAffliction[] afflictions = val.afflictions;
				foreach (BarAffliction val2 in afflictions)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						Colors[val2.afflictionType] = ReadColor(val2);
					}
				}
				_stamina = ReadGraphicColor(val.staminaBar, _stamina);
				_adrenaline = ReadGraphicColor(val.extraBarStamina, _adrenaline);
				_resolved = true;
				RankedLog.Debug($"[Palette] {Colors.Count} Statusfarben von der Spiel-Leiste uebernommen " + "(Ausdauer " + ColorUtility.ToHtmlStringRGB(_stamina) + ", Adrenalin " + ColorUtility.ToHtmlStringRGB(_adrenaline) + ").");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Palette] Statusfarben nicht lesbar: " + ex.Message);
				_resolved = true;
			}
		}

		private static Color ReadGraphicColor(RectTransform rect, Color fallback)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null)
			{
				return fallback;
			}
			Image[] componentsInChildren = ((Component)rect).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && ((Graphic)val).color.a > 0.2f)
				{
					Color color = ((Graphic)val).color;
					color.a = 1f;
					return color;
				}
			}
			return fallback;
		}

		private static Color ReadColor(BarAffliction affliction)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0028: 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)
			Image component = ((Component)affliction).GetComponent<Image>();
			if ((Object)(object)component != (Object)null && ((Graphic)component).color.a > 0.05f)
			{
				Color color = ((Graphic)component).color;
				color.a = 1f;
				return color;
			}
			if ((Object)(object)affliction.icon != (Object)null)
			{
				Color color2 = ((Graphic)affliction.icon).color;
				color2.a = 1f;
				return color2;
			}
			return Fallback;
		}
	}
	public class HudBar
	{
		public static readonly Color Track = new Color(1f, 1f, 1f, 0.14f);

		private readonly RectTransform _fill;

		private readonly Image _fillImage;

		public RectTransform Root { get; }

		private HudBar(RectTransform root, RectTransform fill, Image fillImage)
		{
			Root = root;
			_fill = fill;
			_fillImage = fillImage;
		}

		public static HudBar Create(Transform parent, string name, float x, float y, float width, float height)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			RectTransform val = (RectTransform)((Component)PeakWindowStyle.CreateSurface(parent, name, Track, Mathf.RoundToInt(height / 2f))).transform;
			NativeUiFactory.Place(val, x, y, width, height);
			Image val2 = PeakWindowStyle.CreateSurface((Transform)val, name + "_Fill", Color.white, Mathf.RoundToInt(height / 2f));
			RectTransform val3 = (RectTransform)((Component)val2).transform;
			val3.anchorMin = new Vector2(0f, 0f);
			val3.anchorMax = new Vector2(1f, 1f);
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			val3.pivot = new Vector2(0f, 0.5f);
			return new HudBar(val, val3, val2);
		}

		public void Set(float value, Color color)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp01(value);
			bool flag = num > 0.001f;
			if (((Component)_fill).gameObject.activeSelf != flag)
			{
				((Component)_fill).gameObject.SetActive(flag);
			}
			if (flag)
			{
				_fill.anchorMax = new Vector2(num, 1f);
				((Graphic)_fillImage).color = color;
			}
		}

		public void SetActive(bool active)
		{
			if (((Component)Root).gameObject.activeSelf != active)
			{
				((Component)Root).gameObject.SetActive(active);
			}
		}
	}
	public class ItemIconRow
	{
		private static readonly Color SlotEmpty = new Color(1f, 1f, 1f, 0.1f);

		private static readonly Color SlotFilled = new Color(1f, 1f, 1f, 0.16f);

		private static readonly Color SlotHand = new Color(0.45f, 0.72f, 1f, 0.38f);

		private readonly List<Image> _slots = new List<Image>();

		private readonly List<RawImage> _icons = new List<RawImage>();

		public int Count => _slots.Count;

		public static ItemIconRow Create(Transform parent, string name, float x, float y, float size, float gap, int count, int handSlots = 1, int gapBefore = -1)
		{
			//IL_002b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			ItemIconRow itemIconRow = new ItemIconRow();
			for (int i = 0; i < count; i++)
			{
				Image val = PeakWindowStyle.CreateSurface(parent, $"{name}_Slot{i}", (i < handSlots) ? SlotHand : SlotEmpty, 4);
				RectTransform val2 = (RectTransform)((Component)val).transform;
				float num = ((gapBefore >= 0 && i >= gapBefore) ? (size * 0.4f) : 0f);
				NativeUiFactory.Place(val2, x + (float)i * (size + gap) + num, y, size, size);
				GameObject val3 = new GameObject($"{name}_Icon{i}", new Type[2]
				{
					typeof(RectTransform),
					typeof(RawImage)
				});
				RectTransform val4 = (RectTransform)val3.transform;
				((Transform)val4).SetParent((Transform)(object)val2, false);
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = new Vector2(2f, 2f);
				val4.offsetMax = new Vector2(-2f, -2f);
				RawImage component = val3.GetComponent<RawImage>();
				((Graphic)component).raycastTarget = false;
				((Behaviour)component).enabled = false;
				itemIconRow._slots.Add(val);
				itemIconRow._icons.Add(component);
			}
			return itemIconRow;
		}

		public void ShowSlots(int count)
		{
			for (int i = 0; i < _slots.Count; i++)
			{
				bool flag = i < count;
				if (((Component)_slots[i]).gameObject.activeSelf != flag)
				{
					((Component)_slots[i]).gameObject.SetActive(flag);
				}
			}
		}

		public void SetBackpack(int index, byte backpackType)
		{
			if (index >= 0 && index < _slots.Count)
			{
				Apply(index, TextureOf(GhostItemTrack.ResolveBackpackPrefab(backpackType)), isHand: false);
			}
		}

		public void Set(int index, ushort itemId, bool isHand = false)
		{
			if (index >= 0 && index < _slots.Count)
			{
				Apply(index, TextureFor(itemId), isHand);
			}
		}

		private void Apply(int index, Texture texture, bool isHand)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)_icons[index]).enabled = (Object)(object)texture != (Object)null;
			if ((Object)(object)texture != (Object)null)
			{
				_icons[index].texture = texture;
				((Graphic)_icons[index]).color = Color.white;
			}
			((Graphic)_slots[index]).color = (isHand ? SlotHand : (((Object)(object)texture != (Object)null) ? SlotFilled : SlotEmpty));
		}

		public void SetActive(bool active)
		{
			foreach (Image slot in _slots)
			{
				if (((Component)slot).gameObject.activeSelf != active)
				{
					((Component)slot).gameObject.SetActive(active);
				}
			}
		}

		private static Texture TextureFor(ushort itemId)
		{
			return TextureOf(GhostItemTrack.ResolvePrefab(itemId));
		}

		private static Texture TextureOf(Item prefab)
		{
			if ((Object)(object)prefab == (Object)null || prefab.UIData == null)
			{
				return null;
			}
			try
			{
				return (Texture)(object)prefab.UIData.GetIcon();
			}
			catch (Exception)
			{
				return (Texture)(object)prefab.UIData.icon;
			}
		}
	}
	public static class ModalGuard
	{
		private static int _openCount;

		public static bool AnyOpen => _openCount > 0;

		public static bool CapturingKey { get; set; }

		public static void Opened()
		{
			_openCount++;
		}

		public static void Closed()
		{
			if (_openCount > 0)
			{
				_openCount--;
			}
		}
	}
	public static class NativeUiFactory
	{
		public static readonly Color PanelBackground = new Color(0.06f, 0.05f, 0.04f, 0.85f);

		public static readonly Color Accent = new Color(1f, 0.8f, 0.35f);

		public static readonly Color TextPrimary = new Color(0.98f, 0.94f, 0.82f);

		public static readonly Color TextSecondary = new Color(0.92f, 0.84f, 0.68f);

		public static readonly Color Good = new Color(0.6f, 0.95f, 0.5f);

		public static readonly Color Bad = new Color(0.95f, 0.45f, 0.35f);

		private static readonly Color WoodFill = new Color(0.5f, 0.34f, 0.18f, 0.94f);

		private static readonly Color WoodEdge = new Color(0.35f, 0.22f, 0.11f, 0.96f);

		private static Canvas _canvas;

		private static TMP_FontAsset _font;

		private static bool _fontSearched;

		private static TMP_FontAsset _detailFont;

		private static bool _detailFontSearched;

		private static Sprite _roundedPanelSprite;

		private static List<TMP_FontAsset> _fallbackDonors;

		private static readonly HashSet<TMP_FontAsset> _fallbackChecked = new HashSet<TMP_FontAsset>();

		private static readonly char[] ScriptProbes = new char[7] { 'あ', 'ア', 'ｾ', '가', '中', 'А', 'Α' };

		public static Canvas GetCanvas()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas != (Object)null)
			{
				return _canvas;
			}
			GameObject val = new GameObject("RankedPeak_NativeCanvas");
			Object.DontDestroyOnLoad((Object)val);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 100;
			CanvasScaler obj = val.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.screenMatchMode = (ScreenMatchMode)0;
			obj.matchWidthOrHeight = 0.5f;
			val.AddComponent<GraphicRaycaster>();
			return _canvas;
		}

		public static bool EnsureCanvasAlive()
		{
			if ((Object)(object)_canvas == (Object)null)
			{
				RankedLog.Warning("[NativeUI] Overlay-Canvas war zerstoert - wird neu erstellt (Panels bauen sich neu).");
				GetCanvas();
				return false;
			}
			if (!((Component)_canvas).gameObject.activeSelf)
			{
				RankedLog.Warning("[NativeUI] Overlay-Canvas war deaktiviert (Ladescreen?) - reaktiviert.");
				((Component)_canvas).gameObject.SetActive(true);
			}
			if (!((Behaviour)_canvas).enabled)
			{
				((Behaviour)_canvas).enabled = true;
			}
			return true;
		}

		public static void EnsureTopMost()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_canvas == (Object)null)
			{
				return;
			}
			int num = 0;
			Canvas[] array = Object.FindObjectsByType<Canvas>((FindObjectsSortMode)0);
			foreach (Canvas val in array)
			{
				if (!((Object)(object)val == (Object)(object)_canvas) && ((Behaviour)val).isActiveAndEnabled && (int)val.renderMode == 0 && val.sortingOrder > num)
				{
					num = val.sortingOrder;
				}
			}
			int num2 = Math.Max(100, num + 10);
			if (_canvas.sortingOrder != num2)
			{
				_canvas.sortingOrder = num2;
			}
		}

		public static TMP_FontAsset GetFont()
		{
			if ((Object)(object)_font != (Object)null || _fontSearched)
			{
				EnsureWideCharacterSupport(_font);
				return _font;
			}
			try
			{
				TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
				if (array != null && array.Length != 0)
				{
					StringBuilder stringBuilder = new StringBuilder();
					TMP_FontAsset[] array2 = array;
					foreach (TMP_FontAsset val in array2)
					{
						if (stringBuilder.Length > 0)
						{
							stringBuilder.Append(", ");
						}
						stringBuilder.Append(((Object)val).name);
					}
					RankedLog.Debug($"[NativeUI] Font-Kandidaten (Resources): {stringBuilder}");
					array2 = array;
					foreach (TMP_FontAsset val2 in array2)
					{
						if (((Object)val2).name.IndexOf("daruma", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							_font = val2;
							_fontSearched = true;
							RankedLog.Debug("[NativeUI] PEAK-Display-Font gefunden: " + ((Object)_font).name + ".");
							EnsureWideCharacterSupport(_font);
							return _font;
						}
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[NativeUI] Font-Namens-Suche fehlgeschlagen: " + ex.Message);
			}
			try
			{
				TextMeshProUGUI[] array3 = Object.FindObjectsByType<TextMeshProUGUI>((FindObjectsSortMode)0);
				if (array3 != null && array3.Length != 0)
				{
					Dictionary<TMP_FontAsset, float> dictionary = new Dictionary<TMP_FontAsset, float>();
					TextMeshProUGUI[] array4 = array3;
					foreach (TextMeshProUGUI val3 in array4)
					{
						if (!((Object)(object)((TMP_Text)val3).font == (Object)null))
						{
							dictionary.TryGetValue(((TMP_Text)val3).font, out var value);
							dictionary[((TMP_Text)val3).font] = value + 1f + ((TMP_Text)val3).fontSize / 20f;
						}
					}
					TMP_FontAsset val4 = null;
					float num = 0f;
					foreach (KeyValuePair<TMP_FontAsset, float> item in dictionary)
					{
						RankedLog.Debug($"[NativeUI] Font-Kandidat (Szene): {((Object)item.Key).name} (Score {item.Value:F1})");
						if (item.Value > num)
						{
							val4 = item.Key;
							num = item.Value;
						}
					}
					if ((Object)(object)val4 != (Object)null)
					{
						_font = val4;
						RankedLog.Debug("[NativeUI] UI-Font aus Szene uebernommen: " + ((Object)_font).name + ".");
						_fontSearched = true;
						EnsureWideCharacterSupport(_font);
						return _font;
					}
				}
			}
			catch (Exception ex2)
			{
				RankedLog.Warning("[NativeUI] Szenen-Font-Suche fehlgeschlagen: " + ex2.Message);
			}
			try
			{
				TMP_FontAsset[] array5 = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
				if (array5 != null && array5.Length != 0)
				{
					TMP_FontAsset[] array2 = array5;
					foreach (TMP_FontAsset val5 in array2)
					{
						string text = ((Object)val5).name.ToLowerInvariant();
						if (!text.Contains("icon") && !text.Contains("emoji") && !text.Contains("sprite"))
						{
							_font = val5;
							break;
						}
					}
					if ((Object)(object)_font == (Object)null)
					{
						_font = array5[0];
					}
					_fontSearched = true;
					RankedLog.Debug($"[NativeUI] Font aus Resources: {((Object)_font).name} (aus {array5.Length}).");
					EnsureWideCharacterSupport(_font);
				}
			}
			catch (Exception ex3)
			{
				RankedLog.Warning("[NativeUI] Font-Suche fehlgeschlagen: " + ex3.Message);
			}
			return _font;
		}

		public static TMP_FontAsset GetDetailFont()
		{
			if ((Object)(object)_detailFont != (Object)null || _detailFontSearched)
			{
				EnsureWideCharacterSupport(_detailFont);
				if (!((Object)(object)_detailFont != (Object)null))
				{
					return GetFont();
				}
				return _detailFont;
			}
			try
			{
				TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
				if (array != null)
				{
					TMP_FontAsset[] array2 = array;
					foreach (TMP_FontAsset val in array2)
					{
						if (((Object)val).name.IndexOf("pangolin", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							_detailFont = val;
							RankedLog.Debug("[NativeUI] Detail-Font gefunden: " + ((Object)_detailFont).name + ".");
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[NativeUI] Detail-Font-Suche fehlgeschlagen: " + ex.Message);
			}
			_detailFontSearched = true;
			EnsureWideCharacterSupport(_detailFont);
			if (!((Object)(object)_detailFont != (Object)null))
			{
				return GetFont();
			}
			return _detailFont;
		}

		public static void EnsureWideCharacterSupport(TMP_FontAsset font)
		{
			if ((Object)(object)font == (Object)null || _fallbackChecked.Contains(font))
			{
				return;
			}
			try
			{
				List<char> list = new List<char>();
				char[] scriptProbes = ScriptProbes;
				foreach (char c in scriptProbes)
				{
					if (!font.HasCharacter(c, true, false))
					{
						list.Add(c);
					}
				}
				if (list.Count == 0)
				{
					_fallbackChecked.Add(font);
					return;
				}
				if (font.fallbackFontAssetTable == null)
				{
					font.fallbackFontAssetTable = new List<TMP_FontAsset>();
				}
				int num = 0;
				foreach (TMP_FontAsset fallbackDonor in GetFallbackDonors())
				{
					if ((Object)(object)fallbackDonor == (Object)null || (Object)(object)fallbackDonor == (Object)(object)font || font.fallbackFontAssetTable.Contains(fallbackDonor))
					{
						continue;
					}
					bool flag = false;
					foreach (char item in list)
					{
						if (fallbackDonor.HasCharacter(item, false, false))
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						font.fallbackFontAssetTable.Add(fallbackDonor);
						num++;
					}
				}
				if (num == 0)
				{
					RankedLog.Debug($"[NativeUI] '{((Object)font).name}' fehlen {list.Count} Schriftsystem(e), " + "aber keine geladene Font kann sie - spaeter erneut versuchen.");
					return;
				}
				_fallbackChecked.Add(font);
				font.ReadFontAssetDefinition();
				TMPro_EventManager.ON_FONT_PROPERTY_CHANGED(true, (Object)(object)font);
				RankedLog.Info($"[NativeUI] '{((Object)font).name}': {num} Ersatz-Font(s) fuer fremde " + "Schriftzeichen angehaengt (Steam-Namen mit Katakana, Hangul, Kyrillisch).");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[NativeUI] Ersatz-Fonts nicht anhaengbar: " + ex.Message);
			}
		}

		private static List<TMP_FontAsset> GetFallbackDonors()
		{
			if (_fallbackDonors != null)
			{
				return _fallbackDonors;
			}
			List<TMP_FontAsset> list = new List<TMP_FontAsset>();
			try
			{
				TMP_FontAsset[] array = (TMP_FontAsset[])(((object)Resources.FindObjectsOfTypeAll<TMP_FontAsset>()) ?? ((object)new TMP_FontAsset[0]));
				foreach (TMP_FontAsset val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					string text = ((Object)val).name.ToLowerInvariant();
					if (text.Contains("icon") || text.Contains("emoji") || text.Contains("sprite"))
					{
						continue;
					}
					char[] scriptProbes = ScriptProbes;
					foreach (char c in scriptProbes)
					{
						if (val.HasCharacter(c, false, false))
						{
							list.Add(val);
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[NativeUI] Suche nach Ersatz-Fonts fehlgeschlagen: " + ex.Message);
			}
			if (list.Count == 0)
			{
				return list;
			}
			_fallbackDonors = list;
			RankedLog.Debug("[NativeUI] Ersatz-Font-Kandidaten: " + string.Join(", ", list.ConvertAll((TMP_FontAsset f) => ((Object)f).name).ToArray()));
			return _fallbackDonors;
		}

		public static RectTransform CreatePanel(Transform parent, string name, Color color)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			Sprite roundedPanelSprite = GetRoundedPanelSprite();
			if ((Object)(object)roundedPanelSprite != (Object)null)
			{
				component.sprite = roundedPanelSprite;
				component.type = (Type)1;
				((Graphic)component).color = Color.white;
			}
			else
			{
				((Graphic)component).color = color;
			}
			return (RectTransform)val.transform;
		}

		public static Sprite GetRoundedPanelSprite()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_roundedPanelSprite != (Object)null)
			{
				return _roundedPanelSprite;
			}
			Texture2D val = new Texture2D(96, 96, (TextureFormat)4, false);
			for (int i = 0; i < 96; i++)
			{
				for (int j = 0; j < 96; j++)
				{
					int num = Mathf.Clamp(j, 22, 73);
					int num2 = Mathf.Clamp(i, 22, 73);
					int num3 = j - num;
					int num4 = i - num2;
					float num5 = Mathf.Sqrt((float)(num3 * num3 + num4 * num4));
					if (num5 > 22f)
					{
						val.SetPixel(j, i, Color.clear);
					}
					else if (num5 > 16f)
					{
						val.SetPixel(j, i, WoodEdge);
					}
					else
					{
						val.SetPixel(j, i, WoodFill);
					}
				}
			}
			val.Apply();
			_roundedPanelSprite = Sprite.Create(val, new Rect(0f, 0f, 96f, 96f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4(24f, 24f, 24f, 24f));
			return _roundedPanelSprite;
		}

		public static TextMeshProUGUI CreateLabel(Transform parent, string name, string text, float fontSize, Color color, bool bold = false, TextAlignmentOptions alignment = (TextAlignmentOptions)257, bool detail = false)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(parent, false);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = fontSize;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = alignment;
			((TMP_Text)component).fontStyle = (FontStyles)(bold ? 1 : 0);
			TMP_FontAsset val2 = (detail ? GetDetailFont() : GetFont());
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)component).font = val2;
				Material val3 = new Material(((TMP_Asset)val2).material);
				val3.SetFloat("_OutlineWidth", detail ? 0.1f : 0.18f);
				val3.SetColor("_OutlineColor", new Color(0.15f, 0.1f, 0.05f, 0.8f));
				val3.EnableKeyword("OUTLINE_ON");
				((TMP_Text)component).fontSharedMaterial = val3;
			}
			return component;
		}

		public static void Place(RectTransform rect, float x, float y, float width, float height)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0f, 1f);
			rect.anchorMax = new Vector2(0f, 1f);
			rect.pivot = new Vector2(0f, 1f);
			rect.anchoredPosition = new Vector2(x, 0f - y);
			rect.sizeDelta = new Vector2(width, height);
		}

		public static Button CreateButton(Transform parent, string name, string text, float width, float height, float fontSize = 20f)
		{
			//IL_002e: 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_0040: 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_0078: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			Sprite roundedPanelSprite = GetRoundedPanelSprite();
			if ((Object)(object)roundedPanelSprite != (Object)null)
			{
				component.sprite = roundedPanelSprite;
				component.type = (Type)1;
			}
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			((RectTransform)val.transform).sizeDelta = new Vector2(width, height);
			TextMeshProUGUI obj = CreateLabel(val.transform, "Label", text, fontSize, TextPrimary, bold: true, (TextAlignmentOptions)514);
			RectTransform val2 = (RectTransform)((TMP_Text)obj).transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			((Graphic)obj).raycastTarget = false;
			return component2;
		}

		public static void SetButtonSelected(Button button, bool selected)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI componentInChildren = ((Component)button).GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Graphic)componentInChildren).color = (selected ? Accent : TextPrimary);
			}
			Image component = ((Component)button).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = (Color)(selected ? new Color(1.2f, 1.05f, 0.8f) : Color.white);
			}
		}
	}
	public abstract class PeakSidebarModal : MenuWindow
	{
		protected const float TitleBarHeight = 82f;

		protected const float WindowPadding = 26f;

		protected const float BoxPadding = 24f;

		protected const float SidebarWidth = 330f;

		protected const float ColumnGap = 18f;

		private const float CategoryHeight = 46f;

		private const float CategoryGap = 8f;

		private RectTransform _root;

		private PeakWindowStyle.WindowParts _window;

		private RectTransform _contentHost;

		private TextMeshProUGUI _contentHeading;

		private readonly List<Button> _categoryButtons = new List<Button>();

		private int _currentCategory;

		private bool _built;

		private bool _registeredOpen;

		protected readonly List<Action> Refreshers = new List<Action>();

		private GameObject _panelPlaceholder;

		protected abstract float WindowWidth { get; }

		protected abstract float WindowHeight { get; }

		protected abstract string WindowTitle { get; }

		protected abstract string WindowSubtitle { get; }

		protected abstract string[] Categories { get; }

		public override bool openOnStart => false;

		public override bool selectOnOpen => false;

		public override GameObject panel
		{
			get
			{
				if (!((Object)(object)_root != (Object)null))
				{
					return _panelPlaceholder;
				}
				return ((Component)_root).gameObject;
			}
		}

		protected float ContentWidth => WindowWidth - 52f - 330f - 18f;

		protected float ContentInnerWidth => ContentWidth - 48f;

		protected abstract void BuildContent(int categoryIndex, RectTransform host, float width, float height);

		protected void RefreshControls()
		{
			foreach (Action refresher in Refreshers)
			{
				refresher();
			}
		}

		public override void Start()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_panelPlaceholder = new GameObject("PanelPlaceholder");
			_panelPlaceholder.transform.SetParent(((Component)this).transform, false);
			_panelPlaceholder.SetActive(false);
		}

		protected virtual void OnEnable()
		{
			Loc.LanguageChanged += OnLanguageChanged;
		}

		protected virtual void OnDisable()
		{
			Loc.LanguageChanged -= OnLanguageChanged;
		}

		private void OnLanguageChanged()
		{
			if (_built)
			{
				bool isOpen = ((MenuWindow)this).isOpen;
				int currentCategory = _currentCategory;
				if (isOpen)
				{
					((MenuWindow)this).Close();
				}
				if ((Object)(object)_root != (Object)null)
				{
					((Component)_root).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)_root).gameObject);
					_root = null;
				}
				_built = false;
				_categoryButtons.Clear();
				Refreshers.Clear();
				if (isOpen)
				{
					OpenPanel(currentCategory);
				}
			}
		}

		public void OpenPanel(int categoryIndex = -1)
		{
			if (_built && (Object)(object)_root == (Object)null)
			{
				_built = false;
				_categoryButtons.Clear();
			}
			if (!_built)
			{
				BuildWindow();
			}
			if (categoryIndex >= 0 && categoryIndex < Categories.Length)
			{
				_currentCategory = categoryIndex;
			}
			((MenuWindow)this).Open();
		}

		public override void OnOpen()
		{
			if (!_registeredOpen)
			{
				_registeredOpen = true;
				ModalGuard.Opened();
			}
			NativeUiFactory.EnsureCanvasAlive();
			NativeUiFactory.EnsureTopMost();
			SwitchCategory(_currentCategory);
		}

		public override void OnClose()
		{
			if (_registeredOpen)
			{
				_registeredOpen = false;
				ModalGuard.Closed();
			}
		}

		public void ClosePanel()
		{
			((MenuWindow)this).Close();
		}

		public void TogglePanel()
		{
			if (((MenuWindow)this).isOpen)
			{
				((MenuWindow)this).Close();
			}
			else
			{
				OpenPanel();
			}
		}

		public override void Update()
		{
			if (((MenuWindow)this).isOpen && Input.GetKeyDown((KeyCode)27))
			{
				((MenuWindow)this).Close();
			}
		}

		protected virtual void BuildTitleBarActions(RectTransform titleBar, float rightEdge)
		{
		}

		private void BuildWindow()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Expected O, but got Unknown
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			_built = true;
			Canvas canvas = NativeUiFactory.GetCanvas();
			GameObject val = new GameObject(((object)this).GetType().Name + "Root", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)canvas).transform, false);
			_root = (RectTransform)val.transform;
			_root.anchorMin = Vector2.zero;
			_root.anchorMax = Vector2.one;
			_root.offsetMin = Vector2.zero;
			_root.offsetMax = Vector2.zero;
			PeakWindowStyle.CreateBackdrop((Transform)(object)_root, "Backdrop");
			_window = PeakWindowStyle.CreateWindow((Transform)(object)_root, "Window", WindowWidth, WindowHeight, 82f, WindowTitle, WindowSubtitle);
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)_window.TitleBar, "BtnClose", "X", WindowWidth - 14f - 72f, 20f, 48f, 42f, 24f);
			TintOnBar(obj);
			((UnityEvent)obj.onClick).AddListener(new UnityAction(base.Close));
			BuildTitleBarActions(_window.TitleBar, WindowWidth - 14f - 72f - 12f);
			RectTransform body = _window.Body;
			float num = WindowHeight - 82f - 14f - 8f - 18f;
			RectTransform parent = PeakWindowStyle.CreateBox((Transform)(object)body, "Sidebar", Loc.T("common.sections"), 26f, 8f, 330f, num);
			float num2 = 56f;
			for (int i = 0; i < Categories.Length; i++)
			{
				int index = i;
				Button val2 = PeakWindowStyle.CreatePill((Transform)(object)parent, "Category" + i, Categories[i], 24f, num2, 282f, 46f, 19f);
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					SwitchCategory(index);
				});
				_categoryButtons.Add(val2);
				num2 += 54f;
			}
			RectTransform val3 = PeakWindowStyle.CreateBox((Transform)(object)body, "Content", string.Empty, 374f, 8f, ContentWidth, num);
			_contentHeading = PeakWindowStyle.CreateText((Transform)(object)val3, "ContentHeading", string.Empty, 25f, PeakWindowStyle.Heading, (TextAlignmentOptions)513, display: false, 6f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_contentHeading).transform, 24f, 14f, ContentInnerWidth, 32f);
			PeakWindowStyle.CreateSeparator((Transform)(object)val3, "ContentSeparator", 24f, 52f, ContentInnerWidth);
			GameObject val4 = new GameObject("ContentHost", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent((Transform)(object)val3, false);
			_contentHost = (RectTransform)val4.transform;
			NativeUiFactory.Place(_contentHost, 24f, 68f, ContentInnerWidth, num - 68f - 24f);
		}

		protected static void TintOnBar(Button button)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)button).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(1f, 1f, 1f, 0.22f);
			}
		}

		private void SwitchCategory(int index)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 0 && index < Categories.Length)
			{
				_currentCategory = index;
				for (int i = 0; i < _categoryButtons.Count; i++)
				{
					PeakWindowStyle.SetPillSelected(_categoryButtons[i], i == index);
				}
				((TMP_Text)_contentHeading).text = Categories[index];
				Refreshers.Clear();
				for (int num = ((Transform)_contentHost).childCount - 1; num >= 0; num--)
				{
					GameObject gameObject = ((Component)((Transform)_contentHost).GetChild(num)).gameObject;
					gameObject.SetActive(false);
					Object.Destroy((Object)(object)gameObject);
				}
				try
				{
					BuildContent(index, _contentHost, ContentInnerWidth, _contentHost.sizeDelta.y);
				}
				catch (Exception arg)
				{
					RankedLog.Error($"[{((object)this).GetType().Name}] Bereich '{Categories[index]}' konnte nicht gebaut werden: {arg}");
				}
				RefreshControls();
			}
		}
	}
	public static class PeakWindowStyle
	{
		public class WindowParts
		{
			public RectTransform Root;

			public RectTransform Shadow;

			public RectTransform TitleBar;

			public RectTransform Body;

			public TextMeshProUGUI Title;

			public TextMeshProUGUI Subtitle;
		}

		public static readonly Color WindowFill = new Color(0.973f, 0.98f, 0.973f);

		public static readonly Color WindowBorder = new Color(1f, 1f, 1f);

		public static readonly Color WindowShadow = new Color(0.06f, 0.13f, 0.25f, 0.35f);

		public static readonly Color TitleBar = new Color(0.161f, 0.42f, 0.898f);

		public static readonly Color BoxFill = new Color(0.898f, 0.929f, 0.902f);

		public static readonly Color BoxBorder = new Color(1f, 1f, 1f);

		public static readonly Color Heading = new Color(0.102f, 0.2f, 0.522f);

		public static readonly Color TextPrimary = new Color(0.29f, 0.353f, 0.424f);

		public static readonly Color TextMuted = new Color(0.545f, 0.596f, 0.655f);

		public static readonly Color TextOnBar = new Color(1f, 1f, 1f);

		public static readonly Color Pill = new Color(0.161f, 0.42f, 0.898f);

		public static readonly Color PillIdle = new Color(0.612f, 0.667f, 0.722f);

		public static readonly Color PillAccent = new Color(0.545f, 0.247f, 0.902f);

		public static readonly Color Separator = new Color(0.678f, 0.722f, 0.686f);

		public static readonly Color Positive = new Color(0.106f, 0.518f, 0.286f);

		public static readonly Color Danger = new Color(0.729f, 0.196f, 0.176f);

		public static readonly Color Gold = new Color(0.706f, 0.518f, 0.078f);

		public static readonly Color Silver = new Color(0.478f, 0.522f, 0.573f);

		public static readonly Color Bronze = new Color(0.639f, 0.4f, 0.204f);

		private static readonly Dictionary<string, Sprite> SpriteCache = new Dictionary<string, Sprite>();

		private static Sprite _dottedSprite;

		public static void ResizeWindow(WindowParts window, float width, float height, float titleBarHeight)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)window?.Root == (Object)null))
			{
				window.Root.sizeDelta = new Vector2(width, height);
				if ((Object)(object)window.Shadow != (Object)null)
				{
					window.Shadow.sizeDelta = new Vector2(width + 18f, height + 18f);
				}
				if ((Object)(object)window.Body != (Object)null)
				{
					NativeUiFactory.Place(window.Body, 0f, titleBarHeight + 7f, width, height - titleBarHeight - 14f);
				}
			}
		}

		public static WindowParts CreateWindow(Transform parent, string name, float width, float height, float titleBarHeight, string title, string subtitle)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			Image obj = CreateImage(parent, name + "_Shadow", RoundedSprite(28, 0, Color.white, Color.clear, roundTop: true, roundBottom: true));
			((Graphic)obj).color = WindowShadow;
			RectTransform val = (RectTransform)((Component)obj).transform;
			Center(val, width + 18f, height + 18f);
			val.anchoredPosition = new Vector2(0f, -8f);
			((Graphic)obj).raycastTarget = false;
			RectTransform val2 = (RectTransform)((Component)CreateImage(parent, name, RoundedSprite(28, 7, WindowFill, WindowBorder, roundTop: true, roundBottom: true))).transform;
			Center(val2, width, height);
			Image obj2 = CreateImage((Transform)(object)val2, "TitleBar", RoundedSprite(24, 0, TitleBar, Color.clear, roundTop: true, roundBottom: false));
			RectTransform val3 = (RectTransform)((Component)obj2).transform;
			NativeUiFactory.Place(val3, 7f, 7f, width - 14f, titleBarHeight);
			((Graphic)obj2).raycastTarget = false;
			TextMeshProUGUI val4 = CreateText((Transform)(object)val3, "Title", title, 40f, TextOnBar, (TextAlignmentOptions)513, display: true);
			NativeUiFactory.Place((RectTransform)((TMP_Text)val4).transform, 30f, 0f, width * 0.3f, titleBarHeight);
			TextMeshProUGUI val5 = CreateText((Transform)(object)val3, "Subtitle", subtitle, 22f, new Color(1f, 1f, 1f, 0.9f), (TextAlignmentOptions)514);
			NativeUiFactory.Place((RectTransform)((TMP_Text)val5).transform, width * 0.32f, 0f, width * 0.36f, titleBarHeight);
			GameObject val6 = new GameObject("Body", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent((Transform)(object)val2, false);
			RectTransform val7 = (RectTransform)val6.transform;
			NativeUiFactory.Place(val7, 0f, titleBarHeight + 7f, width, height - titleBarHeight - 14f);
			return new WindowParts
			{
				Root = val2,
				Shadow = val,
				TitleBar = val3,
				Body = val7,
				Title = val4,
				Subtitle = val5
			};
		}

		public static RectTransform CreateBox(Transform parent, string name, string heading, float x, float y, float width, float height)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			Image obj = CreateImage(parent, name, RoundedSprite(20, 4, BoxFill, BoxBorder, roundTop: true, roundBottom: true));
			RectTransform val = (RectTransform)((Component)obj).transform;
			NativeUiFactory.Place(val, x, y, width, height);
			((Graphic)obj).raycastTarget = false;
			if (!string.IsNullOrEmpty(heading))
			{
				NativeUiFactory.Place((RectTransform)((TMP_Text)CreateText((Transform)(object)val, "Heading", heading, 25f, Heading, (TextAlignmentOptions)513, display: false, 6f)).transform, 24f, 14f, width - 48f, 32f);
			}
			return val;
		}

		public static void SetBoxHeading(RectTransform box, string heading)
		{
			if (!((Object)(object)box == (Object)null))
			{
				Transform obj = ((Transform)box).Find("Heading");
				TextMeshProUGUI val = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)val).text = heading;
				}
			}
		}

		public static void SetPillText(Button pill, string text)
		{
			if (!((Object)(object)pill == (Object)null))
			{
				TextMeshProUGUI componentInChildren = ((Component)pill).GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = text;
				}
			}
		}

		public static Image CreateSeparator(Transform parent, string name, float x, float y, float width)
		{
			//IL_0014: 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_003e: Expected O, but got Unknown
			Image obj = CreateImage(parent, name, DottedSprite());
			obj.type = (Type)2;
			((Graphic)obj).color = Separator;
			((Graphic)obj).raycastTarget = false;
			NativeUiFactory.Place((RectTransform)((Component)obj).transform, x, y, width, 3f);
			return obj;
		}

		public static Button CreatePill(Transform parent, string name, string text, float x, float y, float width, float height, float fontSize = 20f)
		{
			//IL_002e: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = RoundedSprite(12, 0, Color.white, Color.clear, roundTop: true, roundBottom: true);
			component.type = (Type)1;
			((Graphic)component).color = Pill;
			Button component2 = val.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)component;
			NativeUiFactory.Place((RectTransform)val.transform, x, y, width, height);
			TextMeshProUGUI obj = CreateText(val.transform, "Label", text, fontSize, TextOnBar, (TextAlignmentOptions)514, display: false, 4f);
			RectTransform val2 = (RectTransform)((TMP_Text)obj).transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = new Vector2(6f, 0f);
			val2.offsetMax = new Vector2(-6f, 0f);
			((Graphic)obj).raycastTarget = false;
			return component2;
		}

		public static Image CreateSurface(Transform parent, string name, Color color, int radius = 12)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			Image obj = CreateImage(parent, name, RoundedSprite(radius, 0, Color.white, Color.clear, roundTop: true, roundBottom: true));
			((Graphic)obj).color = color;
			((Graphic)obj).raycastTarget = false;
			return obj;
		}

		public static Image CreateBackdrop(Transform parent, string name)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			Image component = val.GetComponent<Image>();
			((Graphic)component).color = new Color(0.04f, 0.08f, 0.16f, 0.55f);
			return component;
		}

		public static TextMeshProUGUI CreateScrollingText(Transform parent, string name, string text, float fontSize, Color color, float x, float y, float width, float height, float lineSpacing = 0f, float paragraphSpacing = 0f)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			NativeUiFactory.Place(val2, x, y, width, height);
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			GameObject val3 = new GameObject("Viewport", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val3.transform.SetParent((Transform)(object)val2, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.pivot = new Vector2(0f, 1f);
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = new Vector2(-20f, 0f);
			GameObject val5 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent((Transform)(object)val4, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			val6.anchoredPosition = Vector2.zero;
			TextMeshProUGUI obj = CreateText((Transform)(object)val6, "Body", text, fontSize, color, (TextAlignmentOptions)257);
			((TMP_Text)obj).lineSpacing = lineSpacing;
			((TMP_Text)obj).paragraphSpacing = paragraphSpacing;
			RectTransform val7 = (RectTransform)((TMP_Text)obj).transform;
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = Vector2.zero;
			val7.offsetMax = Vector2.zero;
			float num = width - 10f - 10f;
			float y2 = ((TMP_Text)obj).GetPreferredValues(text, num, 0f).y;
			val6.sizeDelta = new Vector2(0f, Mathf.Max(y2, height));
			Scrollbar verticalScrollbar = CreateScrollbar(val2, 10f);
			ScrollRect component = val.GetComponent<ScrollRect>();
			component.viewport = val4;
			component.content = val6;
			component.horizontal = false;
			component.vertical = true;
			component.movementType = (MovementType)2;
			component.scrollSensitivity = 40f;
			component.verticalScrollbar = verticalScrollbar;
			component.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			component.verticalNormalizedPosition = 1f;
			return obj;
		}

		private static Scrollbar CreateScrollbar(RectTransform parent, float barWidth)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = new Vector2(1f, 0f);
			val2.anchorMax = Vector2.one;
			val2.pivot = new Vector2(1f, 1f);
			val2.anchoredPosition = Vector2.zero;
			val2.sizeDelta = new Vector2(barWidth, 0f);
			Image component = val.GetComponent<Image>();
			component.sprite = RoundedSprite((int)(barWidth / 2f), 0, new Color(Separator.r, Separator.g, Separator.b, 0.45f), Color.clear, roundTop: true, roundBottom: true);
			component.type = (Type)1;
			GameObject val3 = new GameObject("SlidingArea", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent((Transform)(object)val2, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			GameObject val5 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val5.transform.SetParent((Transform)(object)val4, false);
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Image component2 = val5.GetComponent<Image>();
			component2.sprite = RoundedSprite((int)(barWidth / 2f), 0, PillIdle, Color.clear, roundTop: true, roundBottom: true);
			component2.type = (Type)1;
			Scrollbar component3 = val.GetComponent<Scrollbar>();
			component3.direction = (Direction)2;
			component3.handleRect = val6;
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			return component3;
		}

		public static TMP_InputField CreateInputField(Transform parent, string name, string value, float x, float y, float width, float height, float fontSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.SetActive(false);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			NativeUiFactory.Place((RectTransform)val.transform, x, y, width, height);
			Image val2 = val.AddComponent<Image>();
			val2.sprite = RoundedSprite(12, 3, Color.white, new Color(0.78f, 0.82f, 0.79f), roundTop: true, roundBottom: true);
			val2.type = (Type)1;
			GameObject val3 = new GameObject("TextArea", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(16f, 6f);
			val4.offsetMax = new Vector2(-16f, -6f);
			TextMeshProUGUI val5 = CreateText((Transform)(object)val4, "Text", value, fontSize, TextPrimary, (TextAlignmentOptions)513);
			((TMP_Text)val5).richText = false;
			((TMP_Text)val5).textWrappingMode = (TextWrappingModes)0;
			RectTransform val6 = (RectTransform)((TMP_Text)val5).transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			TMP_InputField obj = val.AddComponent<TMP_InputField>();
			obj.textViewport = val4;
			obj.textComponent = (TMP_Text)(object)val5;
			((Selectable)obj).targetGraphic = (Graphic)(object)val2;
			obj.fontAsset = ((TMP_Text)val5).font;
			obj.pointSize = fontSize;
			obj.customCaretColor = true;
			obj.caretColor = Pill;
			obj.selectionColor = new Color(Pill.r, Pill.g, Pill.b, 0.3f);
			obj.lineType = (LineType)0;
			obj.contentType = (ContentType)2;
			obj.restoreOriginalTextOnEscape = false;
			val.SetActive(true);
			obj.text = value;
			return obj;
		}

		public static void SetPillSelected(Button button, bool selected, Color? selectedColor = null)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				Image component = ((Component)button).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (Color)((!selected) ? PillIdle : (((??)selectedColor) ?? Pill));
				}
			}
		}

		public static TextMeshProUGUI CreateText(Transform parent, string name, string text, float fontSize, Color color, TextAlignmentOptions alignment = (TextAlignmentOptions)513, bool display = false, float characterSpacing = 0f)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent(parent, false);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			TMP_FontAsset val2 = (display ? NativeUiFactory.GetFont() : NativeUiFactory.GetDetailFont());
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)component).font = val2;
			}
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = fontSize;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = alignment;
			((TMP_Text)component).fontStyle = (FontStyles)0;
			((TMP_Text)component).characterSpacing = characterSpacing;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static Image CreateImage(Transform parent, string name, Sprite sprite)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			component.type = (Type)1;
			return component;
		}

		private static void Center(RectTransform rect, float width, float height)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(0.5f, 0.5f);
			rect.anchorMax = new Vector2(0.5f, 0.5f);
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.anchoredPosition = Vector2.zero;
			rect.sizeDelta = new Vector2(width, height);
		}

		private static Sprite RoundedSprite(int radius, int border, Color fill, Color borderColor, bool roundTop, bool roundBottom)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			string key = $"{radius}_{border}_{fill}_{borderColor}_{roundTop}_{roundBottom}";
			if (SpriteCache.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			int num = radius * 2 + 8;
			Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
			((Texture)val).wrapMode = (TextureWrapMode)1;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					bool num2 = ((i >= num / 2) ? roundTop : roundBottom);
					int num3 = Mathf.Clamp(j, radius, num - 1 - radius);
					int num4 = (num2 ? Mathf.Clamp(i, radius, num - 1 - radius) : i);
					int num5 = j - num3;
					int num6 = i - num4;
					float num7 = Mathf.Sqrt((float)(num5 * num5 + num6 * num6));
					Color val2 = ((num7 > (float)radius) ? Color.clear : ((border <= 0 || !(num7 > (float)(radius - border))) ? fill : borderColor));
					if (radius > 0 && num7 > (float)radius - 1f && num7 <= (float)radius)
					{
						val2.a *= Mathf.Clamp01((float)radius - num7);
					}
					val.SetPixel(j, i, val2);
				}
			}
			val.Apply();
			Sprite val3 = Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, new Vector4((float)(radius + 2), (float)(radius + 2), (float)(radius + 2), (float)(radius + 2)));
			SpriteCache[key] = val3;
			return val3;
		}

		private static Sprite DottedSprite()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0071: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_dottedSprite != (Object)null)
			{
				return _dottedSprite;
			}
			Texture2D val = new Texture2D(10, 3, (TextureFormat)4, false);
			((Texture)val).wrapMode = (TextureWrapMode)0;
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 10; j++)
				{
					val.SetPixel(j, i, (j < 4) ? Color.white : Color.clear);
				}
			}
			val.Apply();
			_dottedSprite = Sprite.Create(val, new Rect(0f, 0f, 10f, 3f), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0);
			return _dottedSprite;
		}
	}
	public class StatusBarStrip
	{
		private static readonly Color Track = new Color(1f, 1f, 1f, 0.14f);

		private readonly RectTransform _track;

		private readonly RectTransform _staminaFill;

		private readonly Image _staminaImage;

		private readonly List<RectTransform> _segments = new List<RectTransform>();

		private readonly List<Image> _segmentImages = new List<Image>();

		private readonly float _width;

		public RectTransform Root => _track;

		private StatusBarStrip(RectTransform track, RectTransform staminaFill, Image staminaImage, float width)
		{
			_track = track;
			_staminaFill = staminaFill;
			_staminaImage = staminaImage;
			_width = width;
		}

		public static StatusBarStrip Create(Transform parent, string name, float x, float y, float width, float height)
		{
			//IL_0016: 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_0037: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			int radius = Mathf.Max(2, Mathf.RoundToInt(height / 2f));
			RectTransform val = (RectTransform)((Component)PeakWindowStyle.CreateSurface(parent, name, Track, radius)).transform;
			NativeUiFactory.Place(val, x, y, width, height);
			Image val2 = PeakWindowStyle.CreateSurface((Transform)val, name + "_Stamina", AfflictionPalette.Stamina, radius);
			RectTransform val3 = (RectTransform)((Component)val2).transform;
			val3.anchorMin = new Vector2(0f, 0f);
			val3.anchorMax = new Vector2(0f, 1f);
			val3.pivot = new Vector2(0f, 0.5f);
			val3.offsetMin = new Vector2(0f, 0f);
			val3.offsetMax = new Vector2(0f, 0f);
			val3.sizeDelta = new Vector2(0f, 0f);
			return new StatusBarStrip(val, val3, val2, width);
		}

		public void Set(float stamina, IList<float> statuses)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp01(stamina) * _width;
			_staminaFill.sizeDelta = new Vector2(num, 0f);
			((Component)_staminaFill).gameObject.SetActive(num > 0.5f);
			((Graphic)_staminaImage).color = AfflictionPalette.Stamina;
			EnsureSegments(statuses?.Count ?? 0);
			float num2 = _width;
			for (int i = 0; i < _segments.Count; i++)
			{
				float num3 = Mathf.Clamp01((statuses != null && i < statuses.Count) ? statuses[i] : 0f) * _width;
				if (num3 < 1f || num2 <= 0f)
				{
					((Component)_segments[i]).gameObject.SetActive(false);
					continue;
				}
				float num4 = Mathf.Max(0f, num2 - num3);
				((Component)_segments[i]).gameObject.SetActive(true);
				_segments[i].anchoredPosition = new Vector2(num4, 0f);
				_segments[i].sizeDelta = new Vector2(num2 - num4, 0f);
				((Graphic)_segmentImages[i]).color = AfflictionPalette.ColorOf((STATUSTYPE)i);
				num2 = num4;
			}
		}

		private void EnsureSegments(int count)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			while (_segments.Count < count)
			{
				int count2 = _segments.Count;
				Image val = PeakWindowStyle.CreateSurface((Transform)(object)_track, $"Status{count2}", Color.white, 0);
				RectTransform val2 = (RectTransform)((Component)val).transform;
				val2.anchorMin = new Vector2(0f, 0f);
				val2.anchorMax = new Vector2(0f, 1f);
				val2.pivot = new Vector2(0f, 0.5f);
				val2.offsetMin = new Vector2(val2.offsetMin.x, 0f);
				val2.offsetMax = new Vector2(val2.offsetMax.x, 0f);
				((Component)val2).gameObject.SetActive(false);
				_segments.Add(val2);
				_segmentImages.Add(val);
			}
		}

		public void SetActive(bool active)
		{
			if (((Component)_track).gameObject.activeSelf != active)
			{
				((Component)_track).gameObject.SetActive(active);
			}
		}
	}
}
namespace RankedPeak.Ui.Menu
{
	public class AiDisclosureBubble : MonoBehaviour
	{
		private const float RotateSeconds = 7f;

		private const float BobAmplitude = 7f;

		private const float BobSpeed = 1.3f;

		private const float BubbleX = 166f;

		private const float BubbleY = 385f;

		private const float FallbackWidth = 300f;

		private const float FallbackHeight = 76f;

		private static readonly Color FallbackFill = new Color(0.98f, 0.86f, 0.42f);

		private static readonly Color FallbackText = new Color(0.27f, 0.19f, 0.06f);

		private RectTransform _root;

		private RectTransform _clone;

		private TextMeshProUGUI[] _labels;

		private int _index;

		private string _shownText;

		private float _nextRotateAt;

		private float _bobSeed;

		private bool _bob;

		private float _diagnoseAt;

		private bool _diagnosed;

		public static void Attach(Transform mainPage)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006b: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)mainPage == (Object)null) && !((Object)(object)mainPage.Find("RankedAiBubble") != (Object)null))
			{
				GameObject val = new GameObject("RankedAiBubble", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(mainPage, false);
				PlaceBehindIntroFade(val.transform, mainPage);
				RectTransform val2 = (RectTransform)val.transform;
				val2.anchorMin = new Vector2(0.5f, 0.5f);
				val2.anchorMax = new Vector2(0.5f, 0.5f);
				val2.pivot = new Vector2(0f, 0.5f);
				val2.anchoredPosition = new Vector2(166f, 385f);
				AiDisclosureBubble aiDisclosureBubble = val.AddComponent<AiDisclosureBubble>();
				aiDisclosureBubble._root = val2;
				RectTransform val3 = TryCloneVanilla(val.transform);
				if ((Object)(object)val3 != (Object)null)
				{
					Rect rect = val3.rect;
					val2.sizeDelta = ((Rect)(ref rect)).size;
					aiDisclosureBubble._clone = val3;
					aiDisclosureBubble._labels = ((Component)val3).GetComponentsInChildren<TextMeshProUGUI>(true);
					aiDisclosureBubble._bob = (Object)(object)((Component)val3).GetComponentInChildren<Animator>(true) == (Object)null && (Object)(object)((Component)val3).GetComponentInChildren<Animation>(true) == (Object)null;
					RankedLog.Info($"[Menu] KI-Sprechblase aus Vanilla geklont: size={val2.sizeDelta} " + $"labels={aiDisclosureBubble._labels.Length} eigenesSchweben={aiDisclosureBubble._bob}");
				}
				else
				{
					val2.sizeDelta = new Vector2(300f, 76f);
					aiDisclosureBubble._labels = (TextMeshProUGUI[])(object)new TextMeshProUGUI[1] { BuildFallback(val.transform) };
					aiDisclosureBubble._bob = true;
					RankedLog.Warning("[Menu] Vanilla-Sprechblase (DevMessageUI) nicht gefunden - eigene Blase gebaut.");
				}
			}
		}

		private static void PlaceBehindIntroFade(Transform container, Transform mainPage)
		{
			Transform val = mainPage.Find("RankedLogo") ?? mainPage.Find("Logo");
			if ((Object)(object)val != (Object)null)
			{
				container.SetSiblingIndex(val.GetSiblingIndex() + 1);
			}
		}

		private static RectTransform TryCloneVanilla(Transform parent)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DevMessageUI[] array = Object.FindObjectsByType<DevMessageUI>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				if (array == null || array.Length == 0)
				{
					return null;
				}
				GameObject parent2 = array[0].parent;
				if ((Object)(object)parent2 == (Object)null)
				{
					return null;
				}
				GameObject val = Object.Instantiate<GameObject>(parent2, parent);
				((Object)val).name = "Bubble";
				val.SetActive(true);
				DevMessageUI[] componentsInChildren = val.GetComponentsInChildren<DevMessageUI>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)componentsInChildren[i]);
				}
				Transform transform = val.transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val2 == (Object)null)
				{
					Object.Destroy((Object)(object)val);
					return null;
				}
				Rect rect = val2.rect;
				Vector2 size = ((Rect)(ref rect)).size;
				val2.anchorMin = new Vector2(0.5f, 0.5f);
				val2.anchorMax = new Vector2(0.5f, 0.5f);
				val2.pivot = new Vector2(0.5f, 0.5f);
				val2.anchoredPosition = Vector2.zero;
				val2.sizeDelta = size;
				((Transform)val2).localScale = Vector3.one;
				return val2;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Menu] Klonen der Vanilla-Sprechblase fehlgeschlagen: " + ex.Message);
				return null;
			}
		}

		private static TextMeshProUGUI BuildFallback(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)PeakWindowStyle.CreateSurface(parent, "Tail", FallbackFill, 2)).transform;
			val.anchorMin = new Vector2(0f, 0.5f);
			val.anchorMax = new Vector2(0f, 0.5f);
			val.pivot = new Vector2(0.5f, 0.5f);
			val.anchoredPosition = new Vector2(-6f, 0f);
			val.sizeDelta = new Vector2(20f, 20f);
			((Transform)val).localEulerAngles = new Vector3(0f, 0f, 45f);
			Image obj = PeakWindowStyle.CreateSurface(parent, "Bubble", FallbackFill, 16);
			RectTransform val2 = (RectTransform)((Component)obj).transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			TextMeshProUGUI obj2 = PeakWindowStyle.CreateText(((Component)obj).transform, "Text", string.Empty, 16f, FallbackText, (TextAlignmentOptions)514);
			((TMP_Text)obj2).textWrappingMode = (TextWrappingModes)1;
			RectTransform val3 = (RectTransform)((TMP_Text)obj2).transform;
			val3.anchorMin = Vector2.zero;
			val3.anchorMax = Vector2.one;
			val3.offsetMin = new Vector2(14f, 8f);
			val3.offsetMax = new Vector2(-14f, -8f);
			return obj2;
		}

		private void SetText(string text)
		{
			if (text == _shownText)
			{
				return;
			}
			_shownText = text;
			TextMeshProUGUI[] labels = _labels;
			foreach (TextMeshProUGUI val in labels)
			{
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)val).text = text;
				}
			}
		}

		private void Awake()
		{
			_bobSeed = Random.Range(0f, 10f);
			_nextRotateAt = Time.time;
			_diagnoseAt = Time.time + 1.5f;
		}

		private void DiagnoseOnce()
		{
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)_clone == (Object)null))
				{
					Vector2 anchoredPosition = _clone.anchoredPosition;
					string text = $"[Menu] KI-Sprechblase nach 1,5 s: klonLokal={anchoredPosition} " + $"containerPos={_root.anchoredPosition} klonSkala={((Transform)_clone).localScale}";
					if (((Vector2)(ref anchoredPosition)).sqrMagnitude > 1f)
					{
						RankedLog.Info(text + " - Animator verschiebt den Klon.");
					}
					else
					{
						RankedLog.Debug(text);
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Debug("[Menu] Diagnose der KI-Sprechblase fehlgeschlagen: " + ex.Message);
			}
		}

		private void Update()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root == (Object)null || _labels == null || _labels.Length == 0)
			{
				return;
			}
			UpdateCheckService instance = UpdateCheckService.Instance;
			string text = (((Object)(object)instance != (Object)null && instance.HasUpdate) ? instance.Message : null);
			if (text != null)
			{
				SetText(text);
				return;
			}
			if (Time.time >= _nextRotateAt)
			{
				SetText(AiDisclosure.Get(_index));
				_index++;
				_nextRotateAt = Time.time + 7f;
			}
			if (_bob)
			{
				float num = Mathf.Sin((Time.time + _bobSeed) * 1.3f) * 7f;
				_root.anchoredPosition = new Vector2(166f, 385f + num);
			}
			if (!_diagnosed && Time.time >= _diagnoseAt)
			{
				_diagnosed = true;
				DiagnoseOnce();
			}
		}
	}
	public static class RankedLogoBanner
	{
		private const string LogoResource = "RankedPeak.Assets.RankedLogo.png";

		private const string ShadowResource = "RankedPeak.Assets.RankedLogo_Blurred.png";

		private const float LogoX = 340f;

		private const float LogoY = 235f;

		private const float LogoWidth = 520f;

		private const float LogoTiltDegrees = 13f;

		private const float ShadowOffsetY = -2.5f;

		private const float ShadowAlpha = 0.333f;

		private static Sprite _logoSprite;

		private static Sprite _shadowSprite;

		private static bool _logoAttempted;

		private static bool _shadowAttempted;

		public static void Attach(Transform mainPage)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mainPage == (Object)null || (Object)(object)mainPage.Find("RankedLogo") != (Object)null)
			{
				return;
			}
			Sprite val = LoadSprite("RankedPeak.Assets.RankedLogo.png", ref _logoSprite, ref _logoAttempted);
			if (!((Object)(object)val == (Object)null))
			{
				GameObject val2 = new GameObject("RankedLogo", new Type[1] { typeof(RectTransform) });
				val2.transform.SetParent(mainPage, false);
				RectTransform val3 = (RectTransform)val2.transform;
				val3.anchorMin = new Vector2(0.5f, 0.5f);
				val3.anchorMax = new Vector2(0.5f, 0.5f);
				val3.pivot = new Vector2(0.5f, 0.5f);
				val3.anchoredPosition = new Vector2(340f, 235f);
				Rect rect = val.rect;
				float num = 520f * ((Rect)(ref rect)).height;
				rect = val.rect;
				val3.sizeDelta = new Vector2(520f, num / ((Rect)(ref rect)).width);
				((Transform)val3).localEulerAngles = new Vector3(0f, 0f, 13f);
				Sprite val4 = LoadSprite("RankedPeak.Assets.RankedLogo_Blurred.png", ref _shadowSprite, ref _shadowAttempted);
				if ((Object)(object)val4 != (Object)null)
				{
					Image obj = CreateLayer(val2.transform, "Shadow", val4);
					((Graphic)obj).color = new Color(0f, 0f, 0f, 0.333f);
					((RectTransform)((Component)obj).transform).anchoredPosition = new Vector2(0f, -2.5f);
				}
				Image val5 = CreateLayer(val2.transform, "Logo", val);
				((Graphic)val5).color = Color.white;
				((Graphic)val5).material = FindVanillaLogoMaterial(mainPage);
				Transform val6 = mainPage.Find("Logo");
				if ((Object)(object)val6 != (Object)null)
				{
					val2.transform.SetSiblingIndex(val6.GetSiblingIndex() + 1);
				}
				RankedLog.Debug($"[Logo] RANKED-Schriftzug platziert: pos={val3.anchoredPosition} " + $"size={val3.sizeDelta} tilt={13f} " + "material='" + (((Object)(object)((Graphic)val5).material != (Object)null) ? ((Object)((Graphic)val5).material).name : "-") + "'");
			}
		}

		private static Image CreateLayer(Transform parent, string name, Sprite sprite)
		{
			//IL_002e: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.sprite = sprite;
			((Graphic)component).raycastTarget = false;
			RectTransform val2 = (RectTransform)val.transform;
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			val2.anchoredPosition = Vector2.zero;
			return component;
		}

		private static Material FindVanillaLogoMaterial(Transform mainPage)
		{
			try
			{
				Transform val = mainPage.Find("Logo/Logo");
				Image val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : null);
				if ((Object)(object)val2 != (Object)null && (Object)(object)((Graphic)val2).material != (Object)null)
				{
					return ((Graphic)val2).material;
				}
				RankedLog.Warning("[Logo] Vanilla-Logo-Material nicht gefunden - RANKED bleibt ohne animierte Schattierung.");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Logo] Materialsuche fehlgeschlagen: " + ex.Message);
			}
			return null;
		}

		private static Sprite LoadSprite(string resourceName, ref Sprite cache, ref bool attempted)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (attempted)
			{
				return cache;
			}
			attempted = true;
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					RankedLog.Warning("[Logo] Ressource '" + resourceName + "' nicht in der DLL gefunden. Vorhanden: " + string.Join(", ", executingAssembly.GetManifestResourceNames()));
					return null;
				}
				byte[] array = new byte[stream.Length];
				int num;
				for (int i = 0; i < array.Length; i += num)
				{
					num = stream.Read(array, i, array.Length - i);
					if (num <= 0)
					{
						break;
					}
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true)
				{
					wrapMode = (TextureWrapMode)1,
					filterMode = (FilterMode)2,
					anisoLevel = 4
				};
				if (!ImageConversion.LoadImage(val, array))
				{
					RankedLog.Warning("[Logo] PNG '" + resourceName + "' konnte nicht dekodiert werden.");
					Object.Destroy((Object)(object)val);
					return null;
				}
				((Object)val).name = resourceName;
				cache = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)cache).name = resourceName;
				RankedLog.Debug($"[Logo] '{resourceName}' geladen: {((Texture)val).width}x{((Texture)val).height} px.");
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[Logo] Laden von '{resourceName}' fehlgeschlagen: {arg}");
				cache = null;
			}
			return cache;
		}
	}
	public static class RankedMenuIcons
	{
		private static readonly Dictionary<string, Sprite> Cache = new Dictionary<string, Sprite>();

		private static readonly Color IconColor = new Color(0.24f, 0.15f, 0.08f, 0.95f);

		private static readonly Color GoldColor = new Color(1f, 0.88f, 0.35f, 1f);

		public static Sprite GetTierIcon(string tier)
		{
			if (string.IsNullOrEmpty(tier))
			{
				return GetCrownIcon();
			}
			string text = tier.Trim().ToLowerInvariant();
			if (text.Contains("scout"))
			{
				return GetScoutIcon();
			}
			if (text.Contains("hiker"))
			{
				return GetHikerIcon();
			}
			if (text.Contains("climber"))
			{
				return GetClimberIcon();
			}
			if (text.Contains("alpinist"))
			{
				return GetAlpinistIcon();
			}
			if (text.Contains("sherpa"))
			{
				return GetSherpaIcon();
			}
			return GetCrownIcon();
		}

		public static Color GetTierColor(string tier)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(tier))
			{
				return new Color(1f, 0.89f, 0.45f, 1f);
			}
			string text = tier.Trim().ToLowerInvariant();
			if (text.Contains("scout"))
			{
				return new Color(0.65f, 0.88f, 0.35f, 1f);
			}
			if (text.Contains("hiker"))
			{
				return new Color(0.88f, 0.58f, 0.3f, 1f);
			}
			if (text.Contains("climber"))
			{
				return new Color(0.85f, 0.88f, 0.92f, 1f);
			}
			if (text.Contains("alpinist"))
			{
				return new Color(1f, 0.85f, 0.2f, 1f);
			}
			if (text.Contains("sherpa"))
			{
				return new Color(0.2f, 0.9f, 1f, 1f);
			}
			return new Color(1f, 0.89f, 0.45f, 1f);
		}

		public static Color GetTierColorOnLight(string tier)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(tier))
			{
				return new Color(0.62f, 0.45f, 0.05f, 1f);
			}
			string text = tier.Trim().ToLowerInvariant();
			if (text.Contains("scout"))
			{
				return new Color(0.33f, 0.53f, 0.12f, 1f);
			}
			if (text.Contains("hiker"))
			{
				return new Color(0.65f, 0.36f, 0.1f, 1f);
			}
			if (text.Contains("climber"))
			{
				return new Color(0.42f, 0.47f, 0.53f, 1f);
			}
			if (text.Contains("alpinist"))
			{
				return new Color(0.72f, 0.52f, 0.02f, 1f);
			}
			if (text.Contains("sherpa"))
			{
				return new Color(0.05f, 0.48f, 0.62f, 1f);
			}
			return new Color(0.62f, 0.31f, 0.06f, 1f);
		}

		public static Sprite GetCrownIcon()
		{
			return GetOrCreate("Crown", 48, delegate(Texture2D tex)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				DrawFilledRect(tex, 10, 8, 28, 6, GoldColor);
				DrawFilledRect(tex, 8, 14, 32, 4, GoldColor);
				DrawFilledTriangle(tex, new Vector2(8f, 18f), new Vector2(14f, 18f), new Vector2(10f, 36f), GoldColor);
				DrawFilledTriangle(tex, new Vector2(20f, 18f), new Vector2(28f, 18f), new Vector2(24f, 42f), GoldColor);
				DrawFilledTriangle(tex, new Vector2(34f, 18f), new Vector2(40f, 18f), new Vector2(38f, 36f), GoldColor);
				DrawFilledCircle(tex, 10f, 37f, 3f, GoldColor);
				DrawFilledCircle(tex, 24f, 43f, 3.5f, GoldColor);
				DrawFilledCircle(tex, 38f, 37f, 3f, GoldColor);
			});
		}

		public static Sprite GetScoutIcon()
		{
			return GetOrCreate("Tier_Scout", 48, delegate(Texture2D tex)
			{
				//IL_0030: 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_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				Color color = default(Color);
				((Color)(ref color))..ctor(0.65f, 0.88f, 0.35f, 1f);
				DrawCircleOutline(tex, 24f, 24f, 18f, 3.5f, color);
				DrawFilledTriangle(tex, new Vector2(20f, 24f), new Vector2(28f, 24f), new Vector2(24f, 40f), color);
				DrawFilledTriangle(tex, new Vector2(20f, 24f), new Vector2(28f, 24f), new Vector2(24f, 8f), color);
				DrawFilledCircle(tex, 24f, 24f, 4f, color);
			});
		}

		public static Sprite GetHikerIcon()
		{
			return GetOrCreate("Tier_Hiker", 48, delegate(Texture2D tex)
			{
				//IL_0026: 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)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				Color color = default(Color);
				((Color)(ref color))..ctor(0.88f, 0.58f, 0.3f, 1f);
				DrawFilledTriangle(tex, new Vector2(6f, 12f), new Vector2(26f, 12f), new Vector2(16f, 36f), color);
				DrawFilledTriangle(tex, new Vector2(18f, 12f), new Vector2(42f, 12f), new Vector2(30f, 42f), color);
				DrawFilledRect(tex, 6, 8, 36, 4, color);
			});
		}

		public static Sprite GetClimberIcon()
		{
			return GetOrCreate("Tier_Climber", 48, delegate(Texture2D tex)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				Color color = default(Color);
				((Color)(ref color))..ctor(0.85f, 0.88f, 0.92f, 1f);
				DrawRoundedRect(tex, 12, 8, 24, 32, 10, color, 4f);
				DrawFilledRect(tex, 30, 18, 5, 12, color);
			});
		}

		public static Sprite GetAlpinistIcon()
		{
			return GetOrCreate("Tier_Alpinist", 48, delegate(Texture2D tex)
			{
				//IL_0026: 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)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				Color color = default(Color);
				((Color)(ref color))..ctor(1f, 0.85f, 0.2f, 1f);
				DrawFilledTriangle(tex, new Vector2(8f, 10f), new Vector2(40f, 10f), new Vector2(24f, 38f), color);
				DrawFilledCircle(tex, 24f, 42f, 4f, color);
			});
		}

		public static Sprite GetSherpaIcon()
		{
			return GetOrCreate("Tier_Sherpa", 48, delegate(Texture2D tex)
			{
				//IL_0026: 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)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				Color color = default(Color);
				((Color)(ref color))..ctor(0.2f, 0.9f, 1f, 1f);
				DrawFilledTriangle(tex, new Vector2(4f, 10f), new Vector2(22f, 10f), new Vector2(13f, 32f), color);
				DrawFilledTriangle(tex, new Vector2(14f, 10f), new Vector2(34f, 10f), new Vector2(24f, 42f), color);
				DrawFilledTriangle(tex, new Vector2(26f, 10f), new Vector2(44f, 10f), new Vector2(35f, 32f), color);
			});
		}

		public static Sprite GetTargetIcon()
		{
			return GetOrCreate("Target", 48, delegate(Texture2D tex)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				DrawCircleOutline(tex, 24f, 24f, 20f, 4f, IconColor);
				DrawCircleOutline(tex, 24f, 24f, 12f, 3f, IconColor);
				DrawFilledCircle(tex, 24f, 24f, 5f, IconColor);
				DrawFilledRect(tex, 22, 2, 4, 8, IconColor);
				DrawFilledRect(tex, 22, 38, 4, 8, IconColor);
				DrawFilledRect(tex, 2, 22, 8, 4, IconColor);
				DrawFilledRect(tex, 38, 22, 8, 4, IconColor);
			});
		}

		public static Sprite GetStopwatchIcon()
		{
			return GetOrCreate("Stopwatch", 48, delegate(Texture2D tex)
			{
				//IL_0015: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				DrawCircleOutline(tex, 24f, 22f, 18f, 4f, IconColor);
				DrawFilledRect(tex, 21, 40, 6, 6, IconColor);
				DrawFilledRect(tex, 18, 44, 12, 3, IconColor);
				DrawFilledCircle(tex, 24f, 22f, 4f, IconColor);
				DrawLine(tex, new Vector2(24f, 22f), new Vector2(24f, 32f), 3f, IconColor);
				DrawLine(tex, new Vector2(24f, 22f), new Vector2(31f, 27f), 3f, IconColor);
			});
		}

		public static Sprite GetDuelSwordsIcon()
		{
			return GetOrCreate("DuelSwords", 48, delegate(Texture2D tex)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: 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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				DrawLine(tex, new Vector2(10f, 10f), new Vector2(38f, 38f), 3.5f, IconColor);
				DrawLine(tex, new Vector2(38f, 10f), new Vector2(10f, 38f), 3.5f, IconColor);
				DrawLine(tex, new Vector2(12f, 22f), new Vector2(22f, 12f), 3f, IconColor);
				DrawLine(tex, new Vector2(26f, 12f), new Vector2(36f, 22f), 3f, IconColor);
				DrawFilledCircle(tex, 10f, 10f, 3f, IconColor);
				DrawFilledCircle(tex, 38f, 10f, 3f, IconColor);
			});
		}

		public static Sprite GetCompassIcon()
		{
			return GetOrCreate("Compass", 48, delegate(Texture2D tex)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: 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_004d: 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_0071: 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_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				DrawCircleOutline(tex, 24f, 24f, 18f, 3.5f, IconColor);
				DrawFilledTriangle(tex, new Vector2(20f, 24f), new Vector2(28f, 24f), new Vector2(24f, 40f), IconColor);
				DrawFilledTriangle(tex, new Vector2(20f, 24f), new Vector2(28f, 24f), new Vector2(24f, 8f), IconColor);
				DrawFilledCircle(tex, 24f, 24f, 4f, IconColor);
			});
		}

		public static Sprite GetGearIcon()
		{
			return GetOrCreate("Gear", 48, delegate(Texture2D tex)
			{
				//IL_002f: 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_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				for (int i = 0; i < 8; i++)
				{
					float num = (float)i * MathF.PI / 4f;
					((Vector2)(ref val))..ctor(Mathf.Cos(num), Mathf.Sin(num));
					DrawLine(tex, new Vector2(24f + val.x * 12f, 24f + val.y * 12f), new Vector2(24f + val.x * 20f, 24f + val.y * 20f), 6f, IconColor);
				}
				DrawCircleOutline(tex, 24f, 24f, 14f, 6f, IconColor);
				DrawFilledCircle(tex, 24f, 24f, 4.5f, IconColor);
			});
		}

		private static Sprite GetOrCreate(string key, int size, Action<Texture2D> drawAction)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (Cache.TryGetValue(key, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					val.SetPixel(j, i, Color.clear);
				}
			}
			try
			{
				drawAction(val);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RankedMenuIcons] Fehler beim Zeichnen von '" + key + "': " + ex.Message);
			}
			val.Apply();
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), 100f);
			Cache[key] = val2;
			return val2;
		}

		private static void DrawFilledCircle(Texture2D tex, float cx, float cy, float radius, Color color)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, (int)(cx - radius - 1f));
			int num2 = Mathf.Min(((Texture)tex).width - 1, (int)(cx + radius + 1f));
			int num3 = Mathf.Max(0, (int)(cy - radius - 1f));
			int num4 = Mathf.Min(((Texture)tex).height - 1, (int)(cy + radius + 1f));
			Color color2 = default(Color);
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					float num5 = Mathf.Sqrt(((float)j - cx) * ((float)j - cx) + ((float)i - cy) * ((float)i - cy));
					if (num5 <= radius)
					{
						tex.SetPixel(j, i, color);
					}
					else if (num5 <= radius + 1f)
					{
						float num6 = (radius + 1f - num5) * color.a;
						((Color)(ref color2))..ctor(color.r, color.g, color.b, num6);
						BlendPixel(tex, j, i, color2);
					}
				}
			}
		}

		private static void DrawCircleOutline(Texture2D tex, float cx, float cy, float radius, float thickness, Color color)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, (int)(cx - radius - thickness));
			int num2 = Mathf.Min(((Texture)tex).width - 1, (int)(cx + radius + thickness));
			int num3 = Mathf.Max(0, (int)(cy - radius - thickness));
			int num4 = Mathf.Min(((Texture)tex).height - 1, (int)(cy + radius + thickness));
			float num5 = radius - thickness / 2f;
			float num6 = radius + thickness / 2f;
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					float num7 = Mathf.Sqrt(((float)j - cx) * ((float)j - cx) + ((float)i - cy) * ((float)i - cy));
					if (num7 >= num5 && num7 <= num6)
					{
						tex.SetPixel(j, i, color);
					}
				}
			}
		}

		private static void DrawFilledRect(Texture2D tex, int x, int y, int width, int height, Color color)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			for (int i = y; i < y + height && i < ((Texture)tex).height; i++)
			{
				for (int j = x; j < x + width && j < ((Texture)tex).width; j++)
				{
					if (j >= 0 && i >= 0)
					{
						tex.SetPixel(j, i, color);
					}
				}
			}
		}

		private static void DrawRoundedRect(Texture2D tex, int x, int y, int width, int height, int r, Color color, float borderThickness)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			for (int i = y; i < y + height && i < ((Texture)tex).height; i++)
			{
				for (int j = x; j < x + width && j < ((Texture)tex).width; j++)
				{
					int num = Mathf.Clamp(j, x + r, x + width - 1 - r);
					int num2 = Mathf.Clamp(i, y + r, y + height - 1 - r);
					float num3 = Mathf.Sqrt((float)((j - num) * (j - num) + (i - num2) * (i - num2)));
					if (num3 <= (float)r && (num3 >= (float)r - borderThickness || (float)j < (float)x + borderThickness || (float)j >= (float)(x + width) - borderThickness || (float)i < (float)y + borderThickness || (float)i >= (float)(y + height) - borderThickness))
					{
						tex.SetPixel(j, i, color);
					}
				}
			}
		}

		private static void DrawFilledTriangle(Texture2D tex, Vector2 p1, Vector2 p2, Vector2 p3, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, (int)Mathf.Min(p1.x, Mathf.Min(p2.x, p3.x)));
			int num2 = Mathf.Min(((Texture)tex).width - 1, (int)Mathf.Max(p1.x, Mathf.Max(p2.x, p3.x)));
			int num3 = Mathf.Max(0, (int)Mathf.Min(p1.y, Mathf.Min(p2.y, p3.y)));
			int num4 = Mathf.Min(((Texture)tex).height - 1, (int)Mathf.Max(p1.y, Mathf.Max(p2.y, p3.y)));
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					if (PointInTriangle(new Vector2((float)j, (float)i), p1, p2, p3))
					{
						tex.SetPixel(j, i, color);
					}
				}
			}
		}

		private static void DrawLine(Texture2D tex, Vector2 p1, Vector2 p2, float thickness, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0025: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			int num = (int)(Vector2.Distance(p1, p2) * 2f) + 1;
			for (int i = 0; i <= num; i++)
			{
				float num2 = (float)i / (float)num;
				Vector2 val = Vector2.Lerp(p1, p2, num2);
				DrawFilledCircle(tex, val.x, val.y, thickness / 2f, color);
			}
		}

		private static bool PointInTriangle(Vector2 pt, Vector2 v1, Vector2 v2, Vector2 v3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			float num = Sign(pt, v1, v2);
			float num2 = Sign(pt, v2, v3);
			float num3 = Sign(pt, v3, v1);
			bool flag = num < 0f || num2 < 0f || num3 < 0f;
			bool flag2 = num > 0f || num2 > 0f || num3 > 0f;
			return !(flag && flag2);
		}

		private static float Sign(Vector2 p1, Vector2 p2, Vector2 p3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
		}

		private static void BlendPixel(Texture2D tex, int x, int y, Color color)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_001a: 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)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			Color pixel = tex.GetPixel(x, y);
			float num = color.a + pixel.a * (1f - color.a);
			if (num > 0.001f)
			{
				float num2 = (color.r * color.a + pixel.r * pixel.a * (1f - color.a)) / num;
				float num3 = (color.g * color.a + pixel.g * pixel.a * (1f - color.a)) / num;
				float num4 = (color.b * color.a + pixel.b * pixel.a * (1f - color.a)) / num;
				tex.SetPixel(x, y, new Color(num2, num3, num4, num));
			}
		}
	}
	public class RankedPeakMenuPage : UIPage, IHaveParentPage, INavigationPage
	{
		public enum TabType
		{
			EloRanking,
			StaticDaily,
			SpeedrunBoard,
			MyRuns
		}

		public enum PeriodFilter
		{
			Daily,
			AllTime
		}

		private struct GhostCandidate
		{
			public string RunId;

			public string PlayerName;

			public long TotalMs;

			public int Seed;

			public int LevelIndex;

			public string MapSetHash;

			public bool Eligible;
		}

		private const float WindowWidth = 1660f;

		private const float WindowHeight = 900f;

		private const float TitleBarHeight = 82f;

		private const float WindowPadding = 26f;

		private const float BoxPadding = 24f;

		private const float RowHeight = 38f;

		private const int RowsPerPage = 10;

		private TabType _currentTab;

		private PeriodFilter _currentPeriod;

		private int _currentPage;

		private int _totalEntries;

		private PeakWindowStyle.WindowParts _window;

		private RectTransform _profileBox;

		private RectTransform _viewBox;

		private RectTransform _tableBox;

		private Button _refreshButton;

		private TextMeshProUGUI _playerCardLabel;

		private TextMeshProUGUI _playerStatsLabel;

		private Button _tabEloButton;

		private Button _tabStaticButton;

		private Button _tabSpeedrunButton;

		private RectTransform _subFilterContainer;

		private Button _periodDailyButton;

		private Button _periodAllTimeButton;

		private Button _versionCurrentButton;

		private Button _versionAllButton;

		private bool _speedrunAllVersions;

		private string _speedrunRouteBiome;

		private readonly List<string> _knownRouteBiomes = new List<string>();

		private Button _routeFilterButton;

		private TextMeshProUGUI _metaInfoLabel;

		private TextMeshProUGUI _tableHeaderLabel;

		private readonly TextMeshProUGUI[] _rowLabels = (TextMeshProUGUI[])(object)new TextMeshProUGUI[10];

		private Button _prevPageButton;

		private Button _nextPageButton;

		private TextMeshProUGUI _pageIndicatorLabel;

		private Button _trainGhostButton;

		private readonly GhostCandidate[] _rowCandidates = new GhostCandidate[10];

		private readonly Button[] _rowButtons = (Button[])(object)new Button[10];

		private readonly RunRecord[] _myRunRows = new RunRecord[10];

		private Button _tabMyRunsButton;

		private readonly Image[] _rowHighlights = (Image[])(object)new Image[10];

		private int _selectedGhostRow = -1;

		private bool _ghostSelectionActive;

		private Coroutine _fetchRoutine;

		private int _blockedGhostCount;

		private static string EloColumns => "<pos=0>#</pos><pos=70>" + Loc.T("menu.col.player") + "</pos><pos=470>" + Loc.T("menu.col.tier") + "</pos><pos=880>ELO</pos><pos=1150>" + Loc.T("menu.col.duels") + "</pos>";

		private static string SpeedrunColumns => "<pos=0>#</pos><pos=70>" + Loc.T("menu.col.player") + "</pos><pos=470>" + Loc.T("menu.col.time") + "</pos><pos=700>" + Loc.T("menu.col.map") + "</pos><pos=950>" + Loc.T("menu.col.seed") + "</pos><pos=1200>" + Loc.T("menu.col.game") + "</pos><pos=1380>" + Loc.T("menu.col.date") + "</pos>";

		private static string MyRunsColumns => "<pos=0>#</pos><pos=70>" + Loc.T("menu.col.time") + "</pos><pos=330>" + Loc.T("menu.col.map") + "</pos><pos=560>" + Loc.T("menu.col.route") + "</pos><pos=780>" + Loc.T("menu.col.mode") + "</pos><pos=1010>" + Loc.T("menu.col.seed") + "</pos><pos=1220>" + Loc.T("menu.col.date") + "</pos>";

		private static string SpeedrunBoardColumns => "<pos=0>#</pos><pos=60>" + Loc.T("menu.col.player") + "</pos><pos=370>" + Loc.T("menu.col.time") + "</pos><pos=550>" + Loc.T("menu.col.map") + "</pos><pos=760>" + Loc.T("menu.col.route") + "</pos><pos=940>" + Loc.T("menu.col.seed") + "</pos><pos=1090>" + Loc.T("menu.col.game") + "</pos><pos=1190>" + Loc.T("menu.col.mode") + "</pos><pos=1420>" + Loc.T("menu.col.date") + "</pos>";

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)((Component)this).transform;
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			BuildUi();
			Loc.LanguageChanged += ApplyLanguage;
		}

		private void OnDestroy()
		{
			Loc.LanguageChanged -= ApplyLanguage;
		}

		private void ApplyLanguage()
		{
			if ((Object)(object)_window?.Subtitle != (Object)null)
			{
				((TMP_Text)_window.Subtitle).text = Loc.T("menu.subtitle");
			}
			PeakWindowStyle.SetBoxHeading(_profileBox, Loc.T("menu.box.profile"));
			PeakWindowStyle.SetBoxHeading(_viewBox, Loc.T("menu.box.view"));
			PeakWindowStyle.SetBoxHeading(_tableBox, Loc.T("menu.box.table"));
			PeakWindowStyle.SetPillText(_refreshButton, Loc.T("menu.btn.refresh"));
			PeakWindowStyle.SetPillText(_tabEloButton, Loc.T("menu.tab.elo"));
			PeakWindowStyle.SetPillText(_tabStaticButton, Loc.T("mode.staticDaily"));
			PeakWindowStyle.SetPillText(_tabSpeedrunButton, Loc.T("mode.speedrun"));
			PeakWindowStyle.SetPillText(_periodDailyButton, Loc.T("menu.period.today"));
			PeakWindowStyle.SetPillText(_periodAllTimeButton, Loc.T("menu.period.allTime"));
			PeakWindowStyle.SetPillText(_versionCurrentButton, Loc.T("menu.version.only", MapCatalog.GameVersion));
			PeakWindowStyle.SetPillText(_versionAllButton, Loc.T("menu.version.all"));
			PeakWindowStyle.SetPillText(_prevPageButton, Loc.T("menu.btn.prev"));
			PeakWindowStyle.SetPillText(_nextPageButton, Loc.T("menu.btn.next"));
			RefreshPlayerCard();
			RefreshTabButtons();
			if (((Behaviour)this).isActiveAndEnabled)
			{
				LoadCurrentTab();
			}
		}

		public override void OnPageEnter()
		{
			((UIPage)this).OnPageEnter();
			RatingService.RatingUpdated += OnRatingUpdated;
			RatingService.Instance?.RefreshRating();
			RefreshPlayerCard();
			RefreshTabButtons();
			LoadCurrentTab();
		}

		public override void OnPageExit()
		{
			((PageBase)this).OnPageExit();
			RatingService.RatingUpdated -= OnRatingUpdated;
			if (_fetchRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_fetchRoutine);
				_fetchRoutine = null;
			}
		}

		private void OnRatingUpdated(PlayerRating rating)
		{
			RefreshPlayerCard();
			if (_currentTab == TabType.EloRanking)
			{
				LoadCurrentTab();
			}
		}

		public (UIPage, PageTransistion) GetParentPage()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			return (base.pageHandler.GetPage<MainMenuMainPage>(), (PageTransistion)new SetActivePageTransistion());
		}

		public GameObject GetFirstSelectedGameObject()
		{
			if (!((Object)(object)_tabEloButton != (Object)null))
			{
				return null;
			}
			return ((Component)_tabEloButton).gameObject;
		}

		private void BuildUi()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			PeakWindowStyle.WindowParts windowParts = (_window = PeakWindowStyle.CreateWindow(((Component)this).transform, "RankedPeakLeaderboardWindow", 1660f, 900f, 82f, "PEAK RANKED", Loc.T("menu.subtitle")));
			BuildTitleBarActions(windowParts);
			RectTransform body = windowParts.Body;
			float num = 1608f;
			float num2 = 8f;
			float num3 = num * 0.55f;
			float num4 = num - num3 - 18f;
			RectTransform parent = (_profileBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxProfile", Loc.T("menu.box.profile"), 26f, num2, num3, 168f));
			_playerCardLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "PlayerCard", Loc.T("menu.card.loading"), 32f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513, display: false, 2f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_playerCardLabel).transform, 24f, 54f, num3 - 48f, 42f);
			_playerStatsLabel = PeakWindowStyle.CreateText((Transform)(object)parent, "PlayerStats", string.Empty, 21f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)513);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_playerStatsLabel).transform, 24f, 100f, num3 - 48f, 56f);
			BuildViewControls(_viewBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxView", Loc.T("menu.box.view"), 26f + num3 + 18f, num2, num4, 168f), num4);
			num2 += 186f;
			float num5 = 804f - num2 - 66f - 18f - 8f;
			BuildTable(_tableBox = PeakWindowStyle.CreateBox((Transform)(object)body, "BoxTable", Loc.T("menu.box.table"), 26f, num2, num, num5), num);
			num2 += num5 + 18f;
			BuildFooter(body, num2, num);
		}

		private void BuildTitleBarActions(PeakWindowStyle.WindowParts window)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			Button val = (_refreshButton = PeakWindowStyle.CreatePill((Transform)(object)window.TitleBar, "BtnRefresh", Loc.T("menu.btn.refresh"), 1354f, 20f, 200f, 42f, 19f));
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				RatingService.Instance?.RefreshRating();
				LoadCurrentTab();
			});
			Image component = ((Component)val).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = new Color(1f, 1f, 1f, 0.22f);
			}
			Button obj = PeakWindowStyle.CreatePill((Transform)(object)window.TitleBar, "BtnClose", "X", 1574f, 20f, 48f, 42f, 24f);
			Image component2 = ((Component)obj).GetComponent<Image>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Graphic)component2).color = new Color(1f, 1f, 1f, 0.22f);
			}
			((UnityEvent)obj.onClick).AddListener(new UnityAction(CloseToMainMenu));
		}

		private void BuildViewControls(RectTransform viewBox, float viewWidth)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Expected O, but got Unknown
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Expected O, but got Unknown
			float num = viewWidth - 48f;
			float num2 = (num - 24f) / 4f;
			_tabEloButton = PeakWindowStyle.CreatePill((Transform)(object)viewBox, "TabElo", Loc.T("menu.tab.elo"), 24f, 52f, num2, 40f, 18f);
			((UnityEvent)_tabEloButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchTab(TabType.EloRanking);
			});
			_tabStaticButton = PeakWindowStyle.CreatePill((Transform)(object)viewBox, "TabStatic", Loc.T("mode.staticDaily"), 24f + num2 + 8f, 52f, num2, 40f, 18f);
			((UnityEvent)_tabStaticButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchTab(TabType.StaticDaily);
			});
			_tabSpeedrunButton = PeakWindowStyle.CreatePill((Transform)(object)viewBox, "TabSpeedrun", Loc.T("mode.speedrun"), 24f + 2f * (num2 + 8f), 52f, num2, 40f, 18f);
			((UnityEvent)_tabSpeedrunButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchTab(TabType.SpeedrunBoard);
			});
			_tabMyRunsButton = PeakWindowStyle.CreatePill((Transform)(object)viewBox, "TabMyRuns", Loc.T("menu.tab.myRuns"), 24f + 3f * (num2 + 8f), 52f, num2, 40f, 18f);
			((UnityEvent)_tabMyRunsButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchTab(TabType.MyRuns);
			});
			PeakWindowStyle.CreateSeparator((Transform)(object)viewBox, "ViewSeparator", 24f, 102f, num);
			GameObject val = new GameObject("SubFilterContainer", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)viewBox, false);
			_subFilterContainer = (RectTransform)val.transform;
			NativeUiFactory.Place(_subFilterContainer, 24f, 114f, num, 40f);
			_periodDailyButton = PeakWindowStyle.CreatePill((Transform)(object)_subFilterContainer, "PeriodDaily", Loc.T("menu.period.today"), 0f, 0f, 150f, 38f, 18f);
			((UnityEvent)_periodDailyButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchPeriod(PeriodFilter.Daily);
			});
			_periodAllTimeButton = PeakWindowStyle.CreatePill((Transform)(object)_subFilterContainer, "PeriodAllTime", Loc.T("menu.period.allTime"), 158f, 0f, 150f, 38f, 18f);
			((UnityEvent)_periodAllTimeButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchPeriod(PeriodFilter.AllTime);
			});
			_versionCurrentButton = PeakWindowStyle.CreatePill((Transform)(object)_subFilterContainer, "VersionCurrent", Loc.T("menu.version.only", MapCatalog.GameVersion), 0f, 0f, 180f, 38f, 17f);
			((UnityEvent)_versionCurrentButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchVersionFilter(allVersions: false);
			});
			_versionAllButton = PeakWindowStyle.CreatePill((Transform)(object)_subFilterContainer, "VersionAll", Loc.T("menu.version.all"), 188f, 0f, 210f, 38f, 17f);
			((UnityEvent)_versionAllButton.onClick).AddListener((UnityAction)delegate
			{
				SwitchVersionFilter(allVersions: true);
			});
			_routeFilterButton = PeakWindowStyle.CreatePill((Transform)(object)_subFilterContainer, "RouteFilter", string.Empty, 406f, 0f, 250f, 38f, 17f);
			((UnityEvent)_routeFilterButton.onClick).AddListener(new UnityAction(CycleRouteFilter));
		}

		private void BuildTable(RectTransform tableBox, float innerWidth)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0069: 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_00a8: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			float num = innerWidth - 48f;
			_metaInfoLabel = PeakWindowStyle.CreateText((Transform)(object)tableBox, "MetaInfo", string.Empty, 19f, PeakWindowStyle.TextMuted, (TextAlignmentOptions)516);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_metaInfoLabel).transform, 24f, 16f, num, 28f);
			_tableHeaderLabel = PeakWindowStyle.CreateText((Transform)(object)tableBox, "TableHeader", string.Empty, 21f, PeakWindowStyle.Heading, (TextAlignmentOptions)513, display: false, 4f);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_tableHeaderLabel).transform, 24f, 54f, num, 30f);
			PeakWindowStyle.CreateSeparator((Transform)(object)tableBox, "TableSeparator", 24f, 88f, num);
			float num2 = 100f;
			for (int i = 0; i < 10; i++)
			{
				GameObject val = new GameObject($"RowButton{i}", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent((Transform)(object)tableBox, false);
				NativeUiFactory.Place((RectTransform)val.transform, 16f, num2, num + 16f, 38f);
				Image component = val.GetComponent<Image>();
				((Graphic)component).color = Color.clear;
				_rowHighlights[i] = component;
				int rowIndex = i;
				Button component2 = val.GetComponent<Button>();
				((Selectable)component2).transition = (Transition)0;
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					SelectGhostRow(rowIndex);
				});
				_rowButtons[i] = component2;
				TextMeshProUGUI val2 = PeakWindowStyle.CreateText((Transform)(object)tableBox, $"Row{i}", string.Empty, 23f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)513);
				NativeUiFactory.Place((RectTransform)((TMP_Text)val2).transform, 24f, num2, num, 38f);
				((Graphic)val2).raycastTarget = false;
				_rowLabels[i] = val2;
				num2 += 38f;
			}
		}

		private void SelectGhostRow(int rowIndex)
		{
			if (rowIndex < 0 || rowIndex >= 10)
			{
				return;
			}
			if (_currentTab == TabType.MyRuns)
			{
				PinComparisonRow(rowIndex);
				return;
			}
			GhostCandidate ghostCandidate = _rowCandidates[rowIndex];
			if (!string.IsNullOrEmpty(ghostCandidate.RunId) && ghostCandidate.Eligible)
			{
				_selectedGhostRow = rowIndex;
				RefreshGhostSelection();
			}
		}

		private void RefreshGhostSelection()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < 10; i++)
			{
				GhostCandidate ghostCandidate = _rowCandidates[i];
				bool flag = !string.IsNullOrEmpty(ghostCandidate.RunId);
				bool flag2 = _ghostSelectionActive && flag && ghostCandidate.Eligible;
				if ((Object)(object)_rowHighlights[i] != (Object)null)
				{
					((Graphic)_rowHighlights[i]).color = (Color)((i == _selectedGhostRow && flag2) ? new Color(0.24f, 0.45f, 0.78f, 0.2f) : (flag2 ? new Color(0.24f, 0.45f, 0.78f, 0.05f) : Color.clear));
				}
				if ((Object)(object)_rowLabels[i] != (Object)null)
				{
					((TMP_Text)_rowLabels[i]).alpha = ((_ghostSelectionActive && flag && !ghostCandidate.Eligible) ? 0.42f : 1f);
				}
				if ((Object)(object)_rowButtons[i] != (Object)null)
				{
					((Selectable)_rowButtons[i]).interactable = flag2;
				}
			}
			bool flag3 = _selectedGhostRow >= 0 && !string.IsNullOrEmpty(_rowCandidates[_selectedGhostRow].RunId);
			if (!((Object)(object)_trainGhostButton == (Object)null))
			{
				((Component)_trainGhostButton).gameObject.SetActive(flag3);
				if (flag3)
				{
					string text = Truncate(_rowCandidates[_selectedGhostRow].PlayerName, 14);
					((TMP_Text)((Component)_trainGhostButton).GetComponentInChildren<TextMeshProUGUI>()).text = Loc.T("menu.btn.trainVs", text.ToUpperInvariant());
				}
			}
		}

		private void BuildFooter(RectTransform body, float y, float innerWidth)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			_prevPageButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnPrev", Loc.T("menu.btn.prev"), 26f, y, 190f, 46f, 19f);
			((UnityEvent)_prevPageButton.onClick).AddListener(new UnityAction(PrevPage));
			_pageIndicatorLabel = PeakWindowStyle.CreateText((Transform)(object)body, "PageIndicator", Loc.T("menu.page", 1, 1), 22f, PeakWindowStyle.TextPrimary, (TextAlignmentOptions)514);
			NativeUiFactory.Place((RectTransform)((TMP_Text)_pageIndicatorLabel).transform, 224f, y, 190f, 46f);
			_nextPageButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnNext", Loc.T("menu.btn.next"), 422f, y, 190f, 46f, 19f);
			((UnityEvent)_nextPageButton.onClick).AddListener(new UnityAction(NextPage));
			_trainGhostButton = PeakWindowStyle.CreatePill((Transform)(object)body, "BtnTrainGhost", Loc.T("menu.btn.trainTop"), 26f + innerWidth - 330f, y, 330f, 46f, 19f);
			((UnityEvent)_trainGhostButton.onClick).AddListener(new UnityAction(TrainAgainstTopGhost));
		}

		private void CloseToMainMenu()
		{
			var (val, val2) = GetParentPage();
			if ((Object)(object)val != (Object)null)
			{
				base.pageHandler.TransistionToPage(val, val2);
			}
		}

		private void TrainAgainstTopGhost()
		{
			if (_selectedGhostRow < 0)
			{
				return;
			}
			GhostCandidate ghostCandidate = _rowCandidates[_selectedGhostRow];
			if (!string.IsNullOrEmpty(ghostCandidate.RunId) && ghostCandidate.Eligible)
			{
				string runId = ghostCandidate.RunId;
				string playerName = ghostCandidate.PlayerName;
				long totalMs = ghostCandidate.TotalMs;
				int seed = ghostCandidate.Seed;
				int levelIndex = ghostCandidate.LevelIndex;
				string mapSetHash = ghostCandidate.MapSetHash;
				RunConfigService.ResetToRankedDefaults();
				RankedLog.Info("[Menu] Starte Ghost-Training vs " + playerName + "...");
				DuelService.Instance?.StartGhostTraining(runId, playerName, totalMs, seed, levelIndex, mapSetHash, delegate
				{
					RankedLog.Info("[Menu] Ghost " + playerName + " geladen -> starte direkt ins Level!");
					RankedGameLauncher.LaunchDirectToIsland();
				}, delegate(string err)
				{
					RankedLog.Warning("[Menu] Ghost-Training Fehler: " + err);
				});
			}
		}

		private void RefreshPlayerCard()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_playerCardLabel == (Object)null))
			{
				PlayerRating playerRating = RatingService.Instance?.CurrentRating;
				RunStorageService storageService = Plugin.StorageService;
				string text = ((storageService != null) ? FormatPb(storageService.GetPersonalBestMs(GameMode.StaticDaily)) : "-");
				string text2 = Hex(PeakWindowStyle.TextMuted);
				if (playerRating != null && playerRating.Ranked && !string.Equals(playerRating.Tier, "UNRANKED", StringComparison.OrdinalIgnoreCase))
				{
					string text3 = Hex(RankedMenuIcons.GetTierColorOnLight(playerRating.Tier));
					int num = playerRating.DuelWins + playerRating.DuelLosses;
					int num2 = ((num > 0) ? (playerRating.DuelWins * 100 / num) : 0);
					string text4 = Hex(PeakWindowStyle.TextPrimary);
					((TMP_Text)_playerCardLabel).text = $"<color=#{text3}>{playerRating.FormattedTierName}</color>   <color=#{Hex(PeakWindowStyle.Heading)}>{playerRating.Elo:N0} ELO</color>";
					((TMP_Text)_playerStatsLabel).text = "<color=#" + text2 + ">" + Loc.T("menu.card.duels", $"<color=#{text4}>{playerRating.DuelWins}W / {playerRating.DuelLosses}L</color>", num2) + "</color>\n<color=#" + text2 + ">" + Loc.T("menu.card.pb", "<color=#" + text4 + ">" + text + "</color>") + "</color>";
				}
				else
				{
					int num3 = playerRating?.PlacementGames ?? 0;
					string text5 = Hex(PeakWindowStyle.TextPrimary);
					((TMP_Text)_playerCardLabel).text = "<color=#" + Hex(PeakWindowStyle.Heading) + ">" + Loc.T("menu.card.placement", num3) + "</color>";
					((TMP_Text)_playerStatsLabel).text = "<color=#" + text2 + ">" + Loc.T("menu.card.placementHint", $"<color=#{text5}>{Math.Max(0, 3 - num3)}</color>") + "</color>\n<color=#" + text2 + ">" + Loc.T("menu.card.pb", "<color=#" + text5 + ">" + text + "</color>") + "</color>";
				}
			}
		}

		private void SwitchTab(TabType tab)
		{
			_currentTab = tab;
			_currentPage = 0;
			RefreshTabButtons();
			LoadCurrentTab();
		}

		private void SwitchPeriod(PeriodFilter period)
		{
			_currentPeriod = period;
			_currentPage = 0;
			RefreshPeriodButtons();
			LoadCurrentTab();
		}

		private void CycleRouteFilter()
		{
			if (_knownRouteBiomes.Count == 0)
			{
				_speedrunRouteBiome = null;
			}
			else if (_speedrunRouteBiome == null)
			{
				_speedrunRouteBiome = _knownRouteBiomes[0];
			}
			else
			{
				int num = _knownRouteBiomes.IndexOf(_speedrunRouteBiome) + 1;
				_speedrunRouteBiome = ((num >= _knownRouteBiomes.Count) ? null : _knownRouteBiomes[num]);
			}
			_currentPage = 0;
			RefreshPeriodButtons();
			LoadCurrentTab();
		}

		private static string FormatRouteFilterLabel(string routeBiome)
		{
			if (!string.IsNullOrEmpty(routeBiome))
			{
				return Loc.T("menu.route.only", routeBiome);
			}
			return Loc.T("menu.route.whole");
		}

		private void SwitchVersionFilter(bool allVersions)
		{
			_speedrunAllVersions = allVersions;
			_currentPage = 0;
			RefreshPeriodButtons();
			LoadCurrentTab();
		}

		private void RefreshTabButtons()
		{
			PeakWindowStyle.SetPillSelected(_tabEloButton, _currentTab == TabType.EloRanking);
			PeakWindowStyle.SetPillSelected(_tabStaticButton, _currentTab == TabType.StaticDaily);
			PeakWindowStyle.SetPillSelected(_tabSpeedrunButton, _currentTab == TabType.SpeedrunBoard);
			PeakWindowStyle.SetPillSelected(_tabMyRunsButton, _currentTab == TabType.MyRuns);
			PeakWindowStyle.SetBoxHeading(_tableBox, Loc.T((_currentTab == TabType.MyRuns) ? "menu.box.myRuns" : "menu.box.table"));
			((Component)_subFilterContainer).gameObject.SetActive(_currentTab != TabType.EloRanking && _currentTab != TabType.MyRuns);
			RefreshPeriodButtons();
		}

		private void RefreshPeriodButtons()
		{
			bool flag = _currentTab == TabType.SpeedrunBoard;
			((Component)_periodDailyButton).gameObject.SetActive(!flag);
			((Component)_periodAllTimeButton).gameObject.SetActive(!flag);
			((Component)_versionCurrentButton).gameObject.SetActive(flag);
			((Component)_versionAllButton).gameObject.SetActive(flag);
			((Component)_routeFilterButton).gameObject.SetActive(flag);
			((TMP_Text)((Component)_routeFilterButton).GetComponentInChildren<TextMeshProUGUI>()).text = FormatRouteFilterLabel(_speedrunRouteBiome);
			PeakWindowStyle.SetPillSelected(_routeFilterButton, _speedrunRouteBiome != null);
			PeakWindowStyle.SetPillSelected(_periodDailyButton, _currentPeriod == PeriodFilter.Daily);
			PeakWindowStyle.SetPillSelected(_periodAllTimeButton, _currentPeriod == PeriodFilter.AllTime);
			PeakWindowStyle.SetPillSelected(_versionCurrentButton, !_speedrunAllVersions);
			PeakWindowStyle.SetPillSelected(_versionAllButton, _speedrunAllVersions);
		}

		private void PrevPage()
		{
			if (_currentPage > 0)
			{
				_currentPage--;
				LoadCurrentTab();
			}
		}

		private void NextPage()
		{
			int num = Math.Max(0, (_totalEntries - 1) / 10);
			if (_currentPage < num)
			{
				_currentPage++;
				LoadCurrentTab();
			}
		}

		private void LoadCurrentTab()
		{
			if (_fetchRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_fetchRoutine);
			}
			SetRowsLoading();
			if (_currentTab == TabType.EloRanking)
			{
				((TMP_Text)_tableHeaderLabel).text = EloColumns;
				_fetchRoutine = ((MonoBehaviour)this).StartCoroutine(FetchEloRatingsRoutine(_currentPage * 10, 10));
			}
			else if (_currentTab == TabType.SpeedrunBoard)
			{
				((TMP_Text)_tableHeaderLabel).text = SpeedrunBoardColumns;
				_fetchRoutine = ((MonoBehaviour)this).StartCoroutine(FetchSpeedrunBoardRoutine(_currentPage * 10, 10));
			}
			else if (_currentTab == TabType.MyRuns)
			{
				((TMP_Text)_tableHeaderLabel).text = MyRunsColumns;
				RenderMyRuns();
			}
			else
			{
				string period = ((_currentPeriod == PeriodFilter.Daily) ? "daily" : "alltime");
				((TMP_Text)_tableHeaderLabel).text = SpeedrunColumns;
				_fetchRoutine = ((MonoBehaviour)this).StartCoroutine(FetchSpeedrunLeaderboardRoutine(GameMode.StaticDaily, period, _currentPage * 10, 10));
			}
		}

		private void RenderMyRuns()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			ClearGhostCandidates();
			Array.Clear(_myRunRows, 0, _myRunRows.Length);
			RunStorageService storageService = Plugin.StorageService;
			List<RunRecord> list = ((storageService != null) ? storageService.GetRecentRuns() : new List<RunRecord>());
			int num = _currentPage * 10;
			for (int i = 0; i < 10; i++)
			{
				int num2 = num + i;
				if (num2 >= list.Count)
				{
					((TMP_Text)_rowLabels[i]).text = string.Empty;
					((Graphic)_rowHighlights[i]).color = Color.clear;
					((Selectable)_rowButtons[i]).interactable = false;
					continue;
				}
				RunRecord runRecord = list[num2];
				_myRunRows[i] = runRecord;
				RunRecord pinnedComparison = storageService.GetPinnedComparison(runRecord.Mode, runRecord.MapName, runRecord.RouteIndex);
				bool flag = pinnedComparison != null && pinnedComparison.Id == runRecord.Id;
				string arg = (flag ? ("  <color=#" + Hex(PeakWindowStyle.Positive) + ">" + Loc.T("menu.myRuns.pinned") + "</color>") : string.Empty);
				((TMP_Text)_rowLabels[i]).text = $"<pos=0>{num2 + 1}</pos>" + "<pos=70>" + FormatTime(runRecord.TotalMs) + "</pos><pos=330>" + runRecord.MapName + "</pos><pos=560>" + RunConfigService.GetRouteName(runRecord.RouteIndex) + "</pos><pos=780>" + ModeShortName(runRecord.Mode, runRecord.RandomSeed) + "</pos><pos=1010>" + ((runRecord.Seed >= 0) ? runRecord.Seed.ToString() : "-") + "</pos>" + $"<pos=1220>{runRecord.StartTimeUtc.ToLocalTime():dd.MM.}</pos>{arg}";
				bool flag2 = runRecord.Result == RunResult.Completed && runRecord.Splits.Count > 0;
				((TMP_Text)_rowLabels[i]).alpha = (flag2 ? 1f : 0.42f);
				((Selectable)_rowButtons[i]).interactable = flag2;
				((Graphic)_rowHighlights[i]).color = (Color)(flag ? new Color(0.24f, 0.45f, 0.78f, 0.2f) : (flag2 ? new Color(0.24f, 0.45f, 0.78f, 0.05f) : Color.clear));
			}
			((TMP_Text)_metaInfoLabel).text = ((list.Count == 0) ? Loc.T("menu.myRuns.empty") : Loc.T("menu.myRuns.hint"));
		}

		private void PinComparisonRow(int rowIndex)
		{
			RunRecord runRecord = _myRunRows[rowIndex];
			RunStorageService storageService = Plugin.StorageService;
			if (runRecord != null && storageService != null)
			{
				RunRecord pinnedComparison = storageService.GetPinnedComparison(runRecord.Mode, runRecord.MapName, runRecord.RouteIndex);
				bool flag = pinnedComparison != null && pinnedComparison.Id == runRecord.Id;
				storageService.SetPinnedComparison(runRecord.Mode, runRecord.MapName, runRecord.RouteIndex, flag ? null : runRecord);
				if (!flag && !Plugin.ComparisonManual.Value)
				{
					Plugin.ComparisonManual.Value = true;
					RankedLog.Info("[Menu] Vergleich auf manuell gestellt - es wurde ein Lauf gewaehlt.");
				}
				RenderMyRuns();
			}
		}

		private static string ModeShortName(GameMode mode, bool randomSeed = false)
		{
			return mode switch
			{
				GameMode.StaticDaily => Loc.T("mode.short.staticDaily"), 
				GameMode.RankedDuel => Loc.T("mode.short.rankedDuel"), 
				GameMode.Speedrun => Loc.T(randomSeed ? "mode.short.speedrunRandom" : "mode.short.speedrunSet"), 
				GameMode.LiveRace => Loc.T("mode.short.liveRace"), 
				GameMode.GhostTraining => Loc.T("mode.ghostTraining"), 
				GameMode.Vanilla => "Vanilla", 
				_ => mode.ToString(), 
			};
		}

		private void SetRowsLoading()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			ClearGhostCandidates();
			((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + Loc.T("menu.loading") + "</color>";
			for (int i = 1; i < 10; i++)
			{
				((TMP_Text)_rowLabels[i]).text = string.Empty;
			}
		}

		private IEnumerator FetchEloRatingsRoutine(int offset, int limit)
		{
			string text = string.Format("{0}/ranked/ratings?limit={1}&offset={2}", "https://followme-peak.ddns.net", limit, offset);
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				_fetchRoutine = null;
				if ((int)request.result != 1)
				{
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.unreachable") + "</color>";
					yield break;
				}
				try
				{
					JObject val = JObject.Parse(request.downloadHandler.text);
					JToken obj = val["entries"];
					JArray val2 = (JArray)(object)((obj is JArray) ? obj : null);
					RankedPeakMenuPage rankedPeakMenuPage = this;
					JToken obj2 = val["total"];
					rankedPeakMenuPage._totalEntries = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 0);
					string steamId = SteamIdentity.GetSteamId64();
					UpdatePaginationDisplay();
					if (val2 == null || ((JContainer)val2).Count == 0)
					{
						((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + Loc.T("menu.empty.elo") + "</color>";
						yield break;
					}
					string text2 = Hex(PeakWindowStyle.TextMuted);
					string text3 = Hex(PeakWindowStyle.Heading);
					for (int i = 0; i < 10; i++)
					{
						if (i < ((JContainer)val2).Count)
						{
							JToken obj3 = val2[i];
							JToken obj4 = obj3[(object)"rank"];
							int rank = ((obj4 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj4) : (offset + i + 1));
							string name = ((object)obj3[(object)"playerName"])?.ToString() ?? Loc.T("common.anonymous");
							string text4 = ((object)obj3[(object)"steamId"])?.ToString();
							JToken obj5 = obj3[(object)"elo"];
							int num = ((obj5 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj5) : 1000);
							string tier = ((object)obj3[(object)"tier"])?.ToString() ?? "UNRANKED";
							JToken obj6 = obj3[(object)"sub"];
							int? sub = ((obj6 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj6) : ((int?)null));
							JToken obj7 = obj3[(object)"duelWins"];
							int num2 = ((obj7 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj7) : 0);
							JToken obj8 = obj3[(object)"duelLosses"];
							int num3 = ((obj8 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj8) : 0);
							bool isMe = !string.IsNullOrEmpty(steamId) && text4 == steamId;
							string text5 = FormatMedal(rank);
							string text6 = Hex(RankedMenuIcons.GetTierColorOnLight(tier));
							string text7 = FormatTierShort(tier, sub);
							string text8 = FormatName(name, isMe);
							((TMP_Text)_rowLabels[i]).text = $"<pos=0>{text5}</pos><pos=70>{text8}</pos><pos=470><color=#{text6}>{text7}</color></pos><pos=880><color=#{text3}>{num:N0}</color></pos><pos=1150><color=#{text2}>{num2}W / {num3}L</color></pos>";
						}
						else
						{
							((TMP_Text)_rowLabels[i]).text = string.Empty;
						}
					}
				}
				catch (Exception ex)
				{
					RankedLog.Error("[Leaderboard] ELO-Parse-Fehler: " + ex.Message);
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.elo") + "</color>";
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private IEnumerator FetchSpeedrunBoardRoutine(int offset, int limit)
		{
			string text = string.Format("{0}/ranked/speedrun?limit={1}&offset={2}", "https://followme-peak.ddns.net", limit, offset);
			if (!_speedrunAllVersions && !string.IsNullOrEmpty(MapCatalog.GameVersion))
			{
				text = text + "&gameVersion=" + UnityWebRequest.EscapeURL(MapCatalog.GameVersion);
			}
			text += (string.IsNullOrEmpty(_speedrunRouteBiome) ? "&route=0" : ("&routeBiome=" + UnityWebRequest.EscapeURL(_speedrunRouteBiome)));
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				_fetchRoutine = null;
				if ((int)request.result != 1)
				{
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.unreachable") + "</color>";
					yield break;
				}
				try
				{
					JObject val = JObject.Parse(request.downloadHandler.text);
					JToken obj = val["entries"];
					JArray val2 = (JArray)(object)((obj is JArray) ? obj : null);
					RankedPeakMenuPage rankedPeakMenuPage = this;
					JToken obj2 = val["total"];
					rankedPeakMenuPage._totalEntries = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 0);
					string steamId = SteamIdentity.GetSteamId64();
					UpdatePaginationDisplay();
					if (val2 == null || ((JContainer)val2).Count == 0)
					{
						string text2 = (_speedrunAllVersions ? Loc.T("menu.empty.speedrun") : Loc.T("menu.empty.speedrunVersion", MapCatalog.GameVersion));
						((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + text2 + "</color>";
						yield break;
					}
					string text3 = Hex(PeakWindowStyle.TextMuted);
					string text4 = Hex(PeakWindowStyle.Positive);
					string text5 = Hex(PeakWindowStyle.Heading);
					for (int i = 0; i < 10; i++)
					{
						if (i >= ((JContainer)val2).Count)
						{
							((TMP_Text)_rowLabels[i]).text = string.Empty;
							continue;
						}
						JToken obj3 = val2[i];
						JToken obj4 = obj3[(object)"rank"];
						int rank = ((obj4 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj4) : (offset + i + 1));
						string name = ((object)obj3[(object)"playerName"])?.ToString() ?? Loc.T("common.anonymous");
						string text6 = ((object)obj3[(object)"steamId"])?.ToString();
						JToken obj5 = obj3[(object)"totalMs"];
						long ms = ((obj5 != null) ? Extensions.Value<long>((IEnumerable<JToken>)obj5) : 0);
						JToken obj6 = obj3[(object)"seed"];
						int valueOrDefault = ((obj6 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj6) : ((int?)null)).GetValueOrDefault();
						string text7 = ((object)obj3[(object)"mapName"])?.ToString() ?? "?";
						string text8 = ((object)obj3[(object)"biomeId"])?.ToString();
						string text9 = ((object)obj3[(object)"gameVersion"])?.ToString();
						string mode = ((object)obj3[(object)"mode"])?.ToString() ?? "?";
						JToken obj7 = obj3[(object)"randomSeed"];
						bool valueOrDefault2 = ((obj7 != null) ? Extensions.Value<bool?>((IEnumerable<JToken>)obj7) : ((bool?)null)) == true;
						string isoDate = ((object)obj3[(object)"createdAt"])?.ToString() ?? string.Empty;
						JToken obj8 = obj3[(object)"route"];
						int valueOrDefault3 = ((obj8 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj8) : ((int?)null)).GetValueOrDefault();
						string biomeName = ((object)obj3[(object)"routeBiomeName"])?.ToString();
						bool isMe = !string.IsNullOrEmpty(steamId) && text6 == steamId;
						string text10 = (string.IsNullOrEmpty(text8) ? text7 : (text7 + " <size=80%>" + MapCatalog.ToDisplaySignature(text8) + "</size>"));
						string text11 = (MapCatalog.HasMountain(text7, text8, text9) ? ("<color=#" + text3 + ">" + text9 + "</color>") : ("<color=#" + Hex(PeakWindowStyle.Danger) + ">" + (string.IsNullOrEmpty(text9) ? "?" : text9) + "</color>"));
						((TMP_Text)_rowLabels[i]).text = "<pos=0>" + FormatMedal(rank) + "</pos><pos=60>" + FormatName(name, isMe) + "</pos><pos=370><color=#" + text4 + ">" + FormatTime(ms) + "</color></pos><pos=550><color=#" + text5 + ">" + text10 + "</color></pos><pos=760><size=85%>" + FormatRoute(valueOrDefault3, biomeName) + "</size></pos>" + $"<pos=940><color=#{text3}><size=85%>{valueOrDefault}</size></color></pos>" + "<pos=1090>" + text11 + "</pos><pos=1190><color=#" + text3 + "><size=85%>" + FormatModeShort(mode, valueOrDefault2) + "</size></color></pos><pos=1420><color=#" + text3 + "><size=85%>" + FormatDateShort(isoDate) + "</size></color></pos>";
					}
					FillGhostCandidates(val2);
					_knownRouteBiomes.Clear();
					JToken obj9 = val["routes"];
					JArray val3 = (JArray)(object)((obj9 is JArray) ? obj9 : null);
					if (val3 != null)
					{
						foreach (JToken item in val3)
						{
							string text12 = ((object)item[(object)"biomeName"])?.ToString();
							if (!string.IsNullOrEmpty(text12) && !_knownRouteBiomes.Contains(text12))
							{
								_knownRouteBiomes.Add(text12);
							}
						}
					}
					UpdatePaginationDisplay();
				}
				catch (Exception ex)
				{
					RankedLog.Error("[Leaderboard] Speedrun-Board-Parse-Fehler: " + ex.Message);
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.speedrunBoard") + "</color>";
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static string FormatRoute(int route, string biomeName)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (route <= 0)
			{
				return "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + Loc.T("menu.cell.wholeMountain") + "</color>";
			}
			if (!string.IsNullOrEmpty(biomeName))
			{
				return $"{biomeName} <color=#{Hex(PeakWindowStyle.TextMuted)}>· {route}</color>";
			}
			return "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + Loc.T("menu.cell.segment", route) + "</color>";
		}

		private static string FormatModeShort(string mode, bool randomSeed)
		{
			return mode switch
			{
				"StaticDaily" => Loc.T("mode.short.staticDaily"), 
				"RankedDuel" => Loc.T("mode.short.rankedDuel"), 
				"Speedrun" => Loc.T(randomSeed ? "mode.short.speedrunRandom" : "mode.short.speedrunSet"), 
				"LiveRace" => Loc.T("mode.short.liveRace"), 
				_ => mode, 
			};
		}

		private IEnumerator FetchSpeedrunLeaderboardRoutine(GameMode mode, string period, int offset, int limit)
		{
			string text = string.Format("{0}/ranked/leaderboards?mode={1}&playerCount=1&period={2}&limit={3}&offset={4}", "https://followme-peak.ddns.net", mode, period, limit, offset);
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				_fetchRoutine = null;
				if ((int)request.result != 1)
				{
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.unreachable") + "</color>";
					yield break;
				}
				try
				{
					JObject val = JObject.Parse(request.downloadHandler.text);
					JToken obj = val["entries"];
					JArray val2 = (JArray)(object)((obj is JArray) ? obj : null);
					RankedPeakMenuPage rankedPeakMenuPage = this;
					JToken obj2 = val["total"];
					rankedPeakMenuPage._totalEntries = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 0);
					string steamId = SteamIdentity.GetSteamId64();
					UpdatePaginationDisplay();
					if (val2 == null || ((JContainer)val2).Count == 0)
					{
						string text2 = Loc.T((period == "daily") ? "menu.empty.dailyToday" : "menu.empty.dailyAllTime");
						((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.TextMuted) + ">" + text2 + "</color>";
						yield break;
					}
					string text3 = Hex(PeakWindowStyle.TextMuted);
					string text4 = Hex(PeakWindowStyle.Positive);
					for (int i = 0; i < 10; i++)
					{
						if (i < ((JContainer)val2).Count)
						{
							JToken obj3 = val2[i];
							JToken obj4 = obj3[(object)"rank"];
							int rank = ((obj4 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj4) : (offset + i + 1));
							string name = ((object)obj3[(object)"playerName"])?.ToString() ?? Loc.T("common.anonymous");
							string text5 = ((object)obj3[(object)"steamId"])?.ToString();
							JToken obj5 = obj3[(object)"totalMs"];
							long ms = ((obj5 != null) ? Extensions.Value<long>((IEnumerable<JToken>)obj5) : 0);
							JToken obj6 = obj3[(object)"seed"];
							int valueOrDefault = ((obj6 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj6) : ((int?)null)).GetValueOrDefault();
							string isoDate = ((object)obj3[(object)"createdAt"])?.ToString() ?? "";
							string text6 = ((object)obj3[(object)"mapName"])?.ToString() ?? "?";
							string text7 = ((object)obj3[(object)"gameVersion"])?.ToString();
							string biomeId = ((object)obj3[(object)"biomeId"])?.ToString();
							bool isMe = !string.IsNullOrEmpty(steamId) && text5 == steamId;
							string text8 = FormatMedal(rank);
							string text9 = FormatTime(ms);
							string text10 = FormatDateShort(isoDate);
							string text11 = FormatName(name, isMe);
							string text12 = (MapCatalog.HasMountain(text6, biomeId, text7) ? ("<color=#" + text3 + ">" + text7 + "</color>") : ("<color=#" + Hex(PeakWindowStyle.Danger) + ">" + (string.IsNullOrEmpty(text7) ? "?" : text7) + "</color>"));
							((TMP_Text)_rowLabels[i]).text = "<pos=0>" + text8 + "</pos><pos=70>" + text11 + "</pos><pos=470><color=#" + text4 + ">" + text9 + "</color></pos><pos=700><color=#" + Hex(PeakWindowStyle.Heading) + ">" + text6 + "</color></pos>" + $"<pos=950><color=#{text3}>{valueOrDefault}</color></pos>" + "<pos=1200>" + text12 + "</pos><pos=1380><color=#" + text3 + ">" + text10 + "</color></pos>";
						}
						else
						{
							((TMP_Text)_rowLabels[i]).text = string.Empty;
						}
					}
					FillGhostCandidates(val2);
					UpdatePaginationDisplay();
				}
				catch (Exception ex)
				{
					RankedLog.Error("[Leaderboard] Speedrun-Parse-Fehler: " + ex.Message);
					((TMP_Text)_rowLabels[0]).text = "<color=#" + Hex(PeakWindowStyle.Danger) + ">" + Loc.T("menu.error.leaderboard") + "</color>";
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private void FillGhostCandidates(JArray entries)
		{
			_selectedGhostRow = -1;
			_ghostSelectionActive = true;
			int num = 0;
			for (int i = 0; i < 10; i++)
			{
				_rowCandidates[i] = default(GhostCandidate);
				if (entries == null || i >= ((JContainer)entries).Count)
				{
					continue;
				}
				JToken val = entries[i];
				string text = ((object)val[(object)"runId"])?.ToString();
				if (!string.IsNullOrEmpty(text))
				{
					string mapSetHash = ((object)val[(object)"mapSetHash"])?.ToString();
					JToken obj = val[(object)"hasGhost"];
					bool flag = (obj == null || Extensions.Value<bool>((IEnumerable<JToken>)obj)) && MapCatalog.HasMountain(((object)val[(object)"mapName"])?.ToString(), ((object)val[(object)"biomeId"])?.ToString(), ((object)val[(object)"gameVersion"])?.ToString());
					GhostCandidate[] rowCandidates = _rowCandidates;
					int num2 = i;
					GhostCandidate ghostCandidate = new GhostCandidate
					{
						RunId = text,
						PlayerName = (((object)val[(object)"playerName"])?.ToString() ?? "Ghost")
					};
					JToken obj2 = val[(object)"totalMs"];
					ghostCandidate.TotalMs = ((obj2 != null) ? Extensions.Value<long>((IEnumerable<JToken>)obj2) : 0);
					JToken obj3 = val[(object)"seed"];
					ghostCandidate.Seed = ((obj3 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj3) : ((int?)null)).GetValueOrDefault();
					JToken obj4 = val[(object)"levelIndex"];
					ghostCandidate.LevelIndex = ((obj4 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj4) : ((int?)null)).GetValueOrDefault();
					ghostCandidate.MapSetHash = mapSetHash;
					ghostCandidate.Eligible = flag;
					rowCandidates[num2] = ghostCandidate;
					if (!flag)
					{
						num++;
					}
					else if (_selectedGhostRow < 0)
					{
						_selectedGhostRow = i;
					}
				}
			}
			RefreshGhostSelection();
			_blockedGhostCount = num;
		}

		private void ClearGhostCandidates()
		{
			for (int i = 0; i < 10; i++)
			{
				_rowCandidates[i] = default(GhostCandidate);
			}
			_selectedGhostRow = -1;
			_blockedGhostCount = 0;
			_ghostSelectionActive = false;
			RefreshGhostSelection();
		}

		private void UpdatePaginationDisplay()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Max(0, (_totalEntries - 1) / 10);
			((TMP_Text)_pageIndicatorLabel).text = Loc.T("menu.page", _currentPage + 1, num + 1);
			SetPillEnabled(_prevPageButton, _currentPage > 0);
			SetPillEnabled(_nextPageButton, _currentPage < num);
			RefreshGhostSelection();
			if ((Object)(object)_metaInfoLabel != (Object)null)
			{
				string text = Hex(PeakWindowStyle.TextPrimary);
				if (_blockedGhostCount > 0)
				{
					((TMP_Text)_metaInfoLabel).text = Loc.T("menu.meta.blocked", $"<color=#{text}>{_totalEntries}</color>", $"<color=#{Hex(PeakWindowStyle.Danger)}>{_blockedGhostCount}</color>");
					return;
				}
				((TMP_Text)_metaInfoLabel).text = ((_currentTab == TabType.SpeedrunBoard) ? Loc.T("menu.meta.speedrun", $"<color=#{text}>{_totalEntries}</color>", "<color=#" + text + ">" + MapCatalog.GameVersion + "</color>", MapCatalog.MapSetHash, MapCatalog.SlotCount) : Loc.T("menu.meta.total", $"<color=#{text}>{_totalEntries}</color>"));
			}
		}

		private static void SetPillEnabled(Button button, bool enabled)
		{
			if (!((Object)(object)button == (Object)null))
			{
				((Selectable)button).interactable = enabled;
				PeakWindowStyle.SetPillSelected(button, enabled);
			}
		}

		private static string FormatName(string name, bool isMe)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!isMe)
			{
				return Truncate(name, 24);
			}
			return "<color=#" + Hex(PeakWindowStyle.Pill) + ">" + Truncate(name, 18) + " " + Loc.T("common.you") + "</color>";
		}

		private static string FormatMedal(int rank)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			return rank switch
			{
				1 => "<color=#" + Hex(PeakWindowStyle.Gold) + ">#1</color>", 
				2 => "<color=#" + Hex(PeakWindowStyle.Silver) + ">#2</color>", 
				3 => "<color=#" + Hex(PeakWindowStyle.Bronze) + ">#3</color>", 
				_ => $"<color=#{Hex(PeakWindowStyle.TextMuted)}>#{rank}</color>", 
			};
		}

		private static string Hex(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ColorUtility.ToHtmlStringRGB(color);
		}

		private static string FormatTierShort(string tier, int? sub)
		{
			if (string.IsNullOrEmpty(tier) || string.Equals(tier, "UNRANKED", StringComparison.OrdinalIgnoreCase))
			{
				return "UNRANKED";
			}
			string text = sub switch
			{
				1 => "I", 
				2 => "II", 
				3 => "III", 
				_ => "", 
			};
			if (!string.IsNullOrEmpty(text))
			{
				return tier.ToUpperInvariant() + " " + text;
			}
			return tier.ToUpperInvariant();
		}

		private static string Truncate(string str, int maxLen)
		{
			if (string.IsNullOrEmpty(str))
			{
				return "-";
			}
			if (str.Length > maxLen)
			{
				return str.Substring(0, maxLen - 1) + "…";
			}
			return str;
		}

		private static string FormatPb(long? ms)
		{
			if (!ms.HasValue)
			{
				return "--:--.---";
			}
			return FormatTime(ms.Value);
		}

		private static string FormatTime(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			return $"{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}

		private static string FormatDateShort(string isoDate)
		{
			if (DateTime.TryParse(isoDate, out var result))
			{
				return result.ToLocalTime().ToString(Loc.DateFormat, CultureInfo.InvariantCulture);
			}
			return string.Empty;
		}
	}
	public class SeasonSign : MonoBehaviour
	{
		private const float GapBelowVanillaSign = 12f;

		private TextMeshProUGUI _titleLabel;

		private TextMeshProUGUI _timerLabel;

		public static void Attach()
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NextLevelUI[] array = Object.FindObjectsByType<NextLevelUI>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				if (array == null || array.Length == 0)
				{
					RankedLog.Warning("[Menu] Rotations-Schild (NextLevelUI) nicht gefunden - kein Saison-Schild.");
					return;
				}
				NextLevelUI val = PickSource(array);
				if ((Object)(object)val == (Object)null)
				{
					RankedLog.Warning("[Menu] Kein brauchbares Rotations-Schild - kein Saison-Schild.");
					return;
				}
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Transform)val2).parent == (Object)null) && !((Object)(object)((Transform)val2).parent.Find("RankedSeasonSign") != (Object)null))
				{
					string timerName = (((Object)(object)val.timer != (Object)null) ? ((Object)((Component)val.timer).gameObject).name : null);
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Transform)val2).parent);
					((Object)val3).name = "RankedSeasonSign";
					val3.SetActive(true);
					NextLevelUI[] componentsInChildren = val3.GetComponentsInChildren<NextLevelUI>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						Object.Destroy((Object)(object)componentsInChildren[i]);
					}
					LocalizedText[] componentsInChildren2 = val3.GetComponentsInChildren<LocalizedText>(true);
					for (int i = 0; i < componentsInChildren2.Length; i++)
					{
						Object.Destroy((Object)(object)componentsInChildren2[i]);
					}
					RectTransform val4 = (RectTransform)val3.transform;
					Vector2 anchoredPosition = val2.anchoredPosition;
					Rect rect = val2.rect;
					val4.anchoredPosition = anchoredPosition - new Vector2(0f, ((Rect)(ref rect)).height + 12f);
					val3.transform.SetSiblingIndex(((Transform)val2).GetSiblingIndex() + 1);
					val3.AddComponent<SeasonSign>().Bind(val3, timerName);
					string text = $"[Menu] Saison-Schild geklont: pos={val4.anchoredPosition} ";
					object arg = val2.anchoredPosition;
					rect = val2.rect;
					RankedLog.Info(text + $"(Vorlage {arg}, Hoehe {((Rect)(ref rect)).height})");
				}
			}
			catch (Exception arg2)
			{
				RankedLog.Error($"[Menu] Saison-Schild fehlgeschlagen: {arg2}");
			}
		}

		private static NextLevelUI PickSource(NextLevelUI[] candidates)
		{
			NextLevelUI result = null;
			int num = int.MinValue;
			foreach (NextLevelUI val in candidates)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Transform transform = ((Component)val).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if (val2 != null && !((Object)(object)((Transform)val2).parent == (Object)null))
				{
					int num2 = 0;
					if (((Component)val).gameObject.activeInHierarchy)
					{
						num2 += 4;
					}
					if ((Object)(object)val.timer != (Object)null)
					{
						num2 += 2;
					}
					num2 = num2 * 1000 - ((Transform)val2).GetSiblingIndex();
					if (num2 > num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		private void Bind(GameObject clone, string timerName)
		{
			TextMeshProUGUI[] componentsInChildren = clone.GetComponentsInChildren<TextMeshProUGUI>(true);
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val in array)
			{
				if (timerName != null && ((Object)((Component)val).gameObject).name == timerName)
				{
					_timerLabel = val;
				}
				else if ((Object)(object)_titleLabel == (Object)null && ((Component)val).gameObject.activeInHierarchy && !string.IsNullOrWhiteSpace(((TMP_Text)val).text))
				{
					_titleLabel = val;
				}
			}
			if ((Object)(object)_titleLabel == (Object)null)
			{
				array = componentsInChildren;
				foreach (TextMeshProUGUI val2 in array)
				{
					if (timerName == null || ((Object)((Component)val2).gameObject).name != timerName)
					{
						_titleLabel = val2;
						break;
					}
				}
			}
			if ((Object)(object)_timerLabel == (Object)null)
			{
				RankedLog.Warning("[Menu] Countdown-Zeile im Saison-Schild nicht erkannt.");
			}
			try
			{
				string[] array2 = new string[componentsInChildren.Length];
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					array2[j] = ((Object)((Component)componentsInChildren[j]).gameObject).name + (((Component)componentsInChildren[j]).gameObject.activeInHierarchy ? "" : " (inaktiv)");
				}
				RankedLog.Info("[Menu] Saison-Schild Beschriftungen: " + string.Join(", ", array2) + " | Countdown='" + timerName + "' | Ueberschrift='" + (((Object)(object)_titleLabel != (Object)null) ? ((Object)((Component)_titleLabel).gameObject).name : "-") + "'");
			}
			catch (Exception ex)
			{
				RankedLog.Debug("[Menu] Saison-Schild Diagnose fehlgeschlagen: " + ex.Message);
			}
		}

		private void Update()
		{
			if ((Object)(object)_titleLabel == (Object)null)
			{
				return;
			}
			DailySeedService instance = DailySeedService.Instance;
			string text = (((Object)(object)instance != (Object)null) ? instance.CurrentSeason : null);
			string text2 = (string.IsNullOrEmpty(text) ? Loc.T("season.sign.unknown") : Loc.T("season.sign.title", text));
			if (!string.Equals(((TMP_Text)_titleLabel).text, text2, StringComparison.Ordinal))
			{
				((TMP_Text)_titleLabel).text = text2;
			}
			if (!((Object)(object)_timerLabel == (Object)null))
			{
				string text3 = FormatRemaining(DailySeedService.GetNextSeasonResetUtc() - DateTime.UtcNow);
				if (!string.Equals(((TMP_Text)_timerLabel).text, text3, StringComparison.Ordinal))
				{
					((TMP_Text)_timerLabel).text = text3;
				}
			}
		}

		private static string FormatRemaining(TimeSpan remaining)
		{
			if (remaining <= TimeSpan.Zero)
			{
				return "-- -- --";
			}
			if (!(remaining.TotalDays >= 1.0))
			{
				return string.Format(CultureInfo.InvariantCulture, "{0}h {1}m {2}s", remaining.Hours, remaining.Minutes, remaining.Seconds);
			}
			return string.Format(CultureInfo.InvariantCulture, "{0}d {1}h", (int)remaining.TotalDays, remaining.Hours);
		}
	}
}
namespace RankedPeak.Tracking
{
	public class ClimbTrackingService : MonoBehaviour
	{
		private const float SamplingIntervalSeconds = 0.5f;

		private RaceTimer _raceTimer;

		private ClimbStorageService _storage;

		private RunUploadService _uploadService;

		private TimerState _lastState;

		private List<Vector3> _points = new List<Vector3>();

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

		private List<ushort> _itemSamples = new List<ushort>();

		private List<byte[]> _barSamples = new List<byte[]>();

		private List<InventorySnapshot> _inventoryEvents = new List<InventorySnapshot>();

		private bool _recording;

		public void Initialize(RaceTimer raceTimer, ClimbStorageService storage, RunUploadService uploadService)
		{
			_raceTimer = raceTimer;
			_storage = storage;
			_uploadService = uploadService;
		}

		private void Update()
		{
			if (_raceTimer == null)
			{
				return;
			}
			TimerState state = _raceTimer.State;
			if (state != _lastState)
			{
				if (state == TimerState.Running && !_recording)
				{
					StartRecording();
				}
				else if (state == TimerState.Finished && _recording)
				{
					FinishRecording(_raceTimer.LastRunRecord);
				}
				else if ((state == TimerState.Armed || state == TimerState.Idle) && _recording)
				{
					RankedLog.Info("[ClimbTracking] Aufzeichnung verworfen (Timer zurueckgesetzt).");
					StopRecording();
				}
				_lastState = state;
			}
		}

		private void StartRecording()
		{
			_points = new List<Vector3>();
			_animSamples = new List<float[]>();
			_itemSamples = new List<ushort>();
			_barSamples = new List<byte[]>();
			_inventoryEvents = new List<InventorySnapshot>();
			_recording = true;
			((MonoBehaviour)this).StartCoroutine(SampleRoutine());
			RankedLog.Info("[ClimbTracking] Aufzeichnung gestartet.");
		}

		private void StopRecording()
		{
			_recording = false;
			_points = new List<Vector3>();
			_animSamples = new List<float[]>();
			_itemSamples = new List<ushort>();
			_barSamples = new List<byte[]>();
			_inventoryEvents = new List<InventorySnapshot>();
		}

		private void FinishRecording(RunRecord run)
		{
			_recording = false;
			List<Vector3> points = _points;
			_points = new List<Vector3>();
			List<float[]> animSamples = _animSamples;
			_animSamples = new List<float[]>();
			List<ushort> itemSamples = _itemSamples;
			_itemSamples = new List<ushort>();
			List<byte[]> barSamples = _barSamples;
			_barSamples = new List<byte[]>();
			List<InventorySnapshot> inventoryEvents = _inventoryEvents;
			_inventoryEvents = new List<InventorySnapshot>();
			if (run == null)
			{
				RankedLog.Info("[ClimbTracking] Verworfen: kein RunRecord.");
				return;
			}
			if (run.Result == RunResult.Aborted)
			{
				_uploadService?.EnqueueRun(run);
				RankedLog.Info("[ClimbTracking] Kein Climb gespeichert (Run abgebrochen) - Run-Upload angestossen.");
				return;
			}
			if (points.Count < 2)
			{
				_uploadService?.EnqueueRun(run);
				RankedLog.Info($"[ClimbTracking] Kein Climb: zu wenig Punkte ({points.Count}) - Run-Upload angestossen.");
				return;
			}
			string pointData;
			try
			{
				using MemoryStream memoryStream = new MemoryStream();
				ClimbDataCrusher.WriteClimbData(memoryStream, points);
				pointData = Convert.ToBase64String(memoryStream.ToArray());
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[ClimbTracking] Kompression fehlgeschlagen: {arg}");
				_uploadService?.EnqueueRun(run);
				return;
			}
			ClimbRecord climbRecord = new ClimbRecord
			{
				Id = Guid.NewGuid(),
				CreationTime = DateTime.Now,
				BiomeName = run.MapName,
				DurationInSeconds = (float)run.TotalMs / 1000f,
				AscentLevel = run.AscentLevel,
				WasDeathClimb = (run.Result == RunResult.Died),
				PointData = pointData,
				AnimData = GhostAnimParams.EncodeSamples(animSamples),
				ItemData = GhostItemTrack.EncodeSamples(itemSamples),
				StateData = GhostStateTrack.EncodeBars(barSamples),
				InventoryData = GhostStateTrack.EncodeInventory(inventoryEvents),
				RunId = run.Id,
				MapName = run.MapName,
				Mode = run.Mode,
				Result = run.Result,
				Seed = run.Seed,
				GameVersion = run.GameVersion,
				MapSetHash = run.MapSetHash,
				RouteIndex = run.RouteIndex
			};
			try
			{
				_storage.AddClimb(climbRecord);
				RankedLog.Info($"[ClimbTracking] Climb gespeichert: {points.Count} Punkte, " + $"{inventoryEvents.Count} Inventar-Aenderungen, {climbRecord.DurationInSeconds:F1}s, " + $"Map: {climbRecord.MapName}, Death-Climb: {climbRecord.WasDeathClimb}");
			}
			catch (Exception arg2)
			{
				RankedLog.Error($"[ClimbTracking] Speichern fehlgeschlagen: {arg2}");
			}
			_uploadService?.EnqueueRun(run, climbRecord.WasDeathClimb ? null : climbRecord);
		}

		private void RecordInventoryIfChanged()
		{
			InventorySnapshot inventorySnapshot = GhostStateTrack.SampleInventory(_raceTimer.CurrentElapsedMs);
			InventorySnapshot inventorySnapshot2 = ((_inventoryEvents.Count > 0) ? _inventoryEvents[_inventoryEvents.Count - 1] : null);
			if (inventorySnapshot2 == null || !inventorySnapshot.SameContentAs(inventorySnapshot2))
			{
				_inventoryEvents.Add(inventorySnapshot);
			}
		}

		private IEnumerator SampleRoutine()
		{
			while (_recording)
			{
				Camera main = Camera.main;
				if ((Object)(object)main != (Object)null)
				{
					_points.Add(((Component)main).transform.position + Vector3.down * 0.8f);
					float[] array = GhostAnimParams.SampleFromLocalCharacter();
					_animSamples.Add(array ?? new float[14]);
					_itemSamples.Add(GhostItemTrack.SampleFromLocalCharacter());
					_barSamples.Add(GhostStateTrack.SampleBars());
					RecordInventoryIfChanged();
					RunSentinel.Instance?.Sample(_raceTimer.CurrentElapsedMs);
				}
				yield return (object)new WaitForSeconds(0.5f);
			}
		}
	}
	public static class GhostAnimParams
	{
		public static readonly string[] FloatNames = new string[6] { "Input X", "Input Y", "Velocity Y", "Velocity Z", "Look X", "Look Y" };

		public static readonly string[] BoolNames = new string[8] { "Is Grounded", "Sprint", "Crouch", "Climb Surface", "Climb Rope", "Hang", "Is Sliding", "InWater" };

		public const int ValueCount = 14;

		private static int[] _floatHashes;

		private static int[] _boolHashes;

		public const int BytesPerSample = 11;

		private static void EnsureHashes()
		{
			if (_floatHashes == null)
			{
				_floatHashes = new int[FloatNames.Length];
				_boolHashes = new int[BoolNames.Length];
				for (int i = 0; i < FloatNames.Length; i++)
				{
					_floatHashes[i] = Animator.StringToHash(FloatNames[i]);
				}
				for (int j = 0; j < BoolNames.Length; j++)
				{
					_boolHashes[j] = Animator.StringToHash(BoolNames[j]);
				}
			}
		}

		public static float[] SampleFromLocalCharacter()
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				Animator val = (((Object)(object)localCharacter != (Object)null && localCharacter.refs != null) ? localCharacter.refs.animator : null);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				EnsureHashes();
				float[] array = new float[14];
				for (int i = 0; i < _floatHashes.Length; i++)
				{
					array[i] = val.GetFloat(_floatHashes[i]);
				}
				for (int j = 0; j < _boolHashes.Length; j++)
				{
					array[_floatHashes.Length + j] = (val.GetBool(_boolHashes[j]) ? 1f : 0f);
				}
				return array;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static void ApplyTo(Animator animator, float[] values)
		{
			if (!((Object)(object)animator == (Object)null) && values != null && values.Length >= 14)
			{
				EnsureHashes();
				for (int i = 0; i < _floatHashes.Length; i++)
				{
					animator.SetFloat(_floatHashes[i], values[i]);
				}
				for (int j = 0; j < _boolHashes.Length; j++)
				{
					animator.SetBool(_boolHashes[j], values[_floatHashes.Length + j] >= 0.5f);
				}
			}
		}

		public static float[] Lerp(float[] a, float[] b, float t)
		{
			if (a == null || b == null || a.Length < 14 || b.Length < 14)
			{
				return a ?? b;
			}
			float[] array = new float[14];
			for (int i = 0; i < 14; i++)
			{
				array[i] = Mathf.Lerp(a[i], b[i], t);
			}
			return array;
		}

		public static float[] DeriveFromMovement(float speed)
		{
			return new float[14]
			{
				0f,
				0f,
				0f,
				speed,
				0f,
				0f,
				1f,
				(speed > 6f) ? 1f : 0f,
				0f,
				0f,
				0f,
				0f,
				0f,
				0f
			};
		}

		public static void EncodeSampleInto(float[] values, byte[] data, int offset)
		{
			data[offset] = (byte)(sbyte)(Mathf.Clamp(values[0], -1f, 1f) * 127f);
			data[offset + 1] = (byte)(sbyte)(Mathf.Clamp(values[1], -1f, 1f) * 127f);
			WriteInt16(data, offset + 2, Mathf.Clamp(values[2] * 256f, -32767f, 32767f));
			WriteInt16(data, offset + 4, Mathf.Clamp(values[3] * 256f, -32767f, 32767f));
			WriteInt16(data, offset + 6, Mathf.Clamp(values[4] * 64f, -32767f, 32767f));
			WriteInt16(data, offset + 8, Mathf.Clamp(values[5] * 64f, -32767f, 32767f));
			byte b = 0;
			for (int i = 0; i < 8; i++)
			{
				if (values[FloatNames.Length + i] >= 0.5f)
				{
					b |= (byte)(1 << i);
				}
			}
			data[offset + 10] = b;
		}

		public static float[] DecodeSample(byte[] data, int offset)
		{
			float[] array = new float[14];
			if (data == null || offset + 11 > data.Length)
			{
				return array;
			}
			array[0] = (float)(sbyte)data[offset] / 127f;
			array[1] = (float)(sbyte)data[offset + 1] / 127f;
			array[2] = (float)ReadInt16(data, offset + 2) / 256f;
			array[3] = (float)ReadInt16(data, offset + 4) / 256f;
			array[4] = (float)ReadInt16(data, offset + 6) / 64f;
			array[5] = (float)ReadInt16(data, offset + 8) / 64f;
			byte b = data[offset + 10];
			for (int i = 0; i < 8; i++)
			{
				array[FloatNames.Length + i] = (((b & (1 << i)) != 0) ? 1f : 0f);
			}
			return array;
		}

		public static string EncodeSamples(List<float[]> samples)
		{
			if (samples == null || samples.Count == 0)
			{
				return null;
			}
			byte[] array = new byte[samples.Count * 11];
			for (int i = 0; i < samples.Count; i++)
			{
				EncodeSampleInto(samples[i] ?? new float[14], array, i * 11);
			}
			return Convert.ToBase64String(array);
		}

		public static List<float[]> DecodeSamples(string animData)
		{
			if (string.IsNullOrEmpty(animData))
			{
				return null;
			}
			try
			{
				if (animData.TrimStart().StartsWith("["))
				{
					return JsonConvert.DeserializeObject<List<float[]>>(animData);
				}
				byte[] array = Convert.FromBase64String(animData);
				int num = array.Length / 11;
				List<float[]> list = new List<float[]>(num);
				for (int i = 0; i < num; i++)
				{
					int num2 = i * 11;
					float[] array2 = new float[14]
					{
						(float)(sbyte)array[num2] / 127f,
						(float)(sbyte)array[num2 + 1] / 127f,
						(float)ReadInt16(array, num2 + 2) / 256f,
						(float)ReadInt16(array, num2 + 4) / 256f,
						(float)ReadInt16(array, num2 + 6) / 64f,
						(float)ReadInt16(array, num2 + 8) / 64f,
						0f,
						0f,
						0f,
						0f,
						0f,
						0f,
						0f,
						0f
					};
					byte b = array[num2 + 10];
					for (int j = 0; j < 8; j++)
					{
						array2[FloatNames.Length + j] = (((b & (1 << j)) != 0) ? 1f : 0f);
					}
					list.Add(array2);
				}
				return list;
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static void WriteInt16(byte[] data, int offset, float value)
		{
			short num = (short)value;
			data[offset] = (byte)(num & 0xFF);
			data[offset + 1] = (byte)((num >> 8) & 0xFF);
		}

		private static int ReadInt16(byte[] data, int offset)
		{
			return (short)(data[offset] | (data[offset + 1] << 8));
		}
	}
	public static class GhostItemTrack
	{
		public const ushort NoItem = ushort.MaxValue;

		public const string HandBoneName = "Hand_R";

		private static readonly Dictionary<byte, Item> BackpackPrefabs = new Dictionary<byte, Item>();

		public static ushort SampleFromLocalCharacter()
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				Item val = (((Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter.data != (Object)null) ? localCharacter.data.currentItem : null);
				return ((Object)(object)val != (Object)null) ? val.itemID : ushort.MaxValue;
			}
			catch (Exception)
			{
				return ushort.MaxValue;
			}
		}

		public static string EncodeSamples(List<ushort> samples)
		{
			if (samples == null || samples.Count == 0)
			{
				return null;
			}
			bool flag = false;
			foreach (ushort sample in samples)
			{
				if (sample != ushort.MaxValue)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return null;
			}
			byte[] array = new byte[samples.Count * 2];
			for (int i = 0; i < samples.Count; i++)
			{
				array[i * 2] = (byte)(samples[i] & 0xFF);
				array[i * 2 + 1] = (byte)((samples[i] >> 8) & 0xFF);
			}
			return Convert.ToBase64String(array);
		}

		public static List<ushort> DecodeSamples(string itemData)
		{
			if (string.IsNullOrEmpty(itemData))
			{
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(itemData);
				int num = array.Length / 2;
				List<ushort> list = new List<ushort>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add((ushort)(array[i * 2] | (array[i * 2 + 1] << 8)));
				}
				return list;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static Item ResolvePrefab(ushort itemId)
		{
			if (itemId == ushort.MaxValue)
			{
				return null;
			}
			try
			{
				ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
				if ((Object)(object)instance == (Object)null || instance.itemLookup == null)
				{
					return null;
				}
				Item value;
				return instance.itemLookup.TryGetValue(itemId, out value) ? value : null;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static Item ResolveBackpackPrefab(byte backpackType)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (backpackType == 0)
			{
				return null;
			}
			if (BackpackPrefabs.TryGetValue(backpackType, out var value))
			{
				return value;
			}
			Item val = null;
			try
			{
				string b = ((object)(BackpackType)backpackType/*cast due to .constrained prefix*/).ToString();
				ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
				if (instance?.itemLookup != null)
				{
					foreach (KeyValuePair<ushort, Item> item in instance.itemLookup)
					{
						if ((Object)(object)item.Value != (Object)null && string.Equals(((Object)item.Value).name, b, StringComparison.OrdinalIgnoreCase))
						{
							val = item.Value;
							break;
						}
					}
				}
			}
			catch (Exception)
			{
			}
			BackpackPrefabs[backpackType] = val;
			return val;
		}

		public static GameObject CreateVisual(Item prefab, Material ghostMaterial)
		{
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			GameObject val = null;
			try
			{
				val = Object.Instantiate<GameObject>(((Component)prefab).gameObject);
				((Object)val).name = "RankedPeak_GhostItem";
				val.SetActive(true);
				MonoBehaviour[] componentsInChildren = val.GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour val2 in componentsInChildren)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						Object.Destroy((Object)(object)val2);
					}
				}
				Joint[] componentsInChildren2 = val.GetComponentsInChildren<Joint>(true);
				foreach (Joint val3 in componentsInChildren2)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						Object.Destroy((Object)(object)val3);
					}
				}
				Component[] componentsInChildren3 = val.GetComponentsInChildren<Component>(true);
				foreach (Component val4 in componentsInChildren3)
				{
					if (!((Object)(object)val4 == (Object)null) && !(val4 is Transform) && !(val4 is Renderer) && !(val4 is MeshFilter) && !(val4 is Animator))
					{
						Object.Destroy((Object)(object)val4);
					}
				}
				SetLayerRecursively(val, 0);
				Renderer[] componentsInChildren4 = val.GetComponentsInChildren<Renderer>(true);
				PrepareRenderers(componentsInChildren4, ghostMaterial);
				if (!AnyVisible(componentsInChildren4))
				{
					Renderer[] array = componentsInChildren4;
					for (int i = 0; i < array.Length; i++)
					{
						((Component)array[i]).gameObject.SetActive(true);
					}
					RankedLog.Debug($"[Ghost] Item {((Object)prefab).name}: kein Renderer war aktiv, alle {componentsInChildren4.Length} " + "einzeln eingeschaltet.");
				}
				RankedLog.Debug($"[Ghost] Item {((Object)prefab).name} (ID {prefab.itemID}): {componentsInChildren4.Length} Renderer, " + $"davon sichtbar {CountVisible(componentsInChildren4)}.");
				return val;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Ghost] Item-Klon fehlgeschlagen (" + ((Object)prefab).name + "): " + ex.Message);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				return null;
			}
		}

		private static void PrepareRenderers(Renderer[] renderers, Material ghostMaterial)
		{
			foreach (Renderer val in renderers)
			{
				val.enabled = true;
				val.forceRenderingOff = false;
				val.SetPropertyBlock((MaterialPropertyBlock)null);
				SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((val is SkinnedMeshRenderer) ? val : null);
				if (val2 != null)
				{
					val2.updateWhenOffscreen = true;
				}
				Material[] array = (Material[])(object)new Material[val.sharedMaterials.Length];
				for (int j = 0; j < array.Length; j++)
				{
					array[j] = ghostMaterial;
				}
				val.sharedMaterials = array;
				val.shadowCastingMode = (ShadowCastingMode)0;
				val.receiveShadows = false;
			}
		}

		private static bool AnyVisible(Renderer[] renderers)
		{
			for (int i = 0; i < renderers.Length; i++)
			{
				if (((Component)renderers[i]).gameObject.activeInHierarchy)
				{
					return true;
				}
			}
			return false;
		}

		private static int CountVisible(Renderer[] renderers)
		{
			int num = 0;
			for (int i = 0; i < renderers.Length; i++)
			{
				if (((Component)renderers[i]).gameObject.activeInHierarchy)
				{
					num++;
				}
			}
			return num;
		}

		private static void SetLayerRecursively(GameObject root, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			root.layer = layer;
			foreach (Transform item in root.transform)
			{
				SetLayerRecursively(((Component)item).gameObject, layer);
			}
		}
	}
	public class GhostModel
	{
		public GameObject Root;

		public Animator Animator;

		public Transform HandBone;

		public Material Material;

		public Vector3 ModelOffset;

		public bool IsValid => (Object)(object)Root != (Object)null;
	}
	public static class GhostModelFactory
	{
		private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");

		public static GhostModel Create(string name, Color color)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Character localCharacter = Character.localCharacter;
				Animator val = (((Object)(object)localCharacter != (Object)null && localCharacter.refs != null) ? localCharacter.refs.animator : null);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				Material val2 = CreateMaterial(color);
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject);
				((Object)val3).name = name;
				val3.transform.localScale = ((Component)val).transform.lossyScale;
				Camera[] componentsInChildren = val3.GetComponentsInChildren<Camera>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)((Component)componentsInChildren[i]).gameObject);
				}
				Light[] componentsInChildren2 = val3.GetComponentsInChildren<Light>(true);
				for (int i = 0; i < componentsInChildren2.Length; i++)
				{
					Object.Destroy((Object)(object)((Component)componentsInChildren2[i]).gameObject);
				}
				AudioSource[] componentsInChildren3 = val3.GetComponentsInChildren<AudioSource>(true);
				for (int i = 0; i < componentsInChildren3.Length; i++)
				{
					Object.Destroy((Object)(object)((Component)componentsInChildren3[i]).gameObject);
				}
				SetLayerRecursively(val3, 0);
				MonoBehaviour[] componentsInChildren4 = val3.GetComponentsInChildren<MonoBehaviour>(true);
				foreach (MonoBehaviour val4 in componentsInChildren4)
				{
					if ((Object)(object)val4 != (Object)null)
					{
						Object.Destroy((Object)(object)val4);
					}
				}
				Joint[] componentsInChildren5 = val3.GetComponentsInChildren<Joint>(true);
				foreach (Joint val5 in componentsInChildren5)
				{
					if ((Object)(object)val5 != (Object)null)
					{
						Object.Destroy((Object)(object)val5);
					}
				}
				Component[] componentsInChildren6 = val3.GetComponentsInChildren<Component>(true);
				foreach (Component val6 in componentsInChildren6)
				{
					if (!((Object)(object)val6 == (Object)null) && !(val6 is Transform) && !(val6 is Animator) && !(val6 is Renderer) && !(val6 is MeshFilter))
					{
						Object.Destroy((Object)(object)val6);
					}
				}
				int num = 0;
				Renderer[] componentsInChildren7 = val3.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val7 in componentsInChildren7)
				{
					val7.enabled = true;
					val7.SetPropertyBlock((MaterialPropertyBlock)null);
					num++;
					SkinnedMeshRenderer val8 = (SkinnedMeshRenderer)(object)((val7 is SkinnedMeshRenderer) ? val7 : null);
					if (val8 != null)
					{
						((Renderer)val8).forceRenderingOff = false;
						val8.updateWhenOffscreen = true;
					}
					Material[] array = (Material[])(object)new Material[val7.sharedMaterials.Length];
					for (int j = 0; j < array.Length; j++)
					{
						array[j] = val2;
					}
					val7.sharedMaterials = array;
					val7.shadowCastingMode = (ShadowCastingMode)0;
					val7.receiveShadows = false;
				}
				Animator componentInChildren = val3.GetComponentInChildren<Animator>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.applyRootMotion = false;
					componentInChildren.cullingMode = (AnimatorCullingMode)0;
				}
				Camera main = Camera.main;
				Vector3 modelOffset = (((Object)(object)main != (Object)null) ? (((Component)val).transform.position - (((Component)main).transform.position + Vector3.down * 0.8f)) : (Vector3.down * 0.8f));
				RankedLog.Debug($"[Ghost] '{name}': {num} Renderer, " + "Animator: " + (((Object)(object)componentInChildren != (Object)null) ? "ja" : "nein") + ".");
				return new GhostModel
				{
					Root = val3,
					Animator = componentInChildren,
					HandBone = FindHandBone(val3.transform, componentInChildren),
					Material = val2,
					ModelOffset = modelOffset
				};
			}
			catch (Exception ex)
			{
				RankedLog.Error("[Ghost] Modell-Klon '" + name + "' fehlgeschlagen: " + ex.Message);
				return null;
			}
		}

		public static Material CreateMaterial(Color color)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//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_0020: 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_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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			Shader val = Shader.Find("Universal Render Pipeline/Unlit");
			if ((Object)(object)val != (Object)null)
			{
				Material val2 = new Material(val);
				val2.SetColor(BaseColorId, color);
				val2.SetFloat("_Surface", 1f);
				val2.SetFloat("_Blend", 0f);
				val2.SetOverrideTag("RenderType", "Transparent");
				val2.SetInt("_SrcBlend", 5);
				val2.SetInt("_DstBlend", 10);
				val2.SetInt("_ZWrite", 0);
				val2.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
				val2.renderQueue = 3000;
				return val2;
			}
			return new Material(Shader.Find("Legacy Shaders/Transparent/Diffuse"))
			{
				color = color
			};
		}

		public static void ApplyColor(Material material, Color color)
		{
			//IL_0025: 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)
			if (!((Object)(object)material == (Object)null))
			{
				if (material.HasProperty(BaseColorId))
				{
					material.SetColor(BaseColorId, color);
				}
				else
				{
					material.color = color;
				}
			}
		}

		private static Transform FindHandBone(Transform cloneRoot, Animator animator)
		{
			Transform[] componentsInChildren = ((Component)cloneRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (((Object)val).name == "Hand_R")
				{
					return val;
				}
			}
			Transform val2 = (((Object)(object)animator != (Object)null && animator.isHuman) ? animator.GetBoneTransform((HumanBodyBones)18) : null);
			if ((Object)(object)val2 != (Object)null)
			{
				RankedLog.Debug("[Ghost] Handknochen ueber den Avatar gefunden: " + ((Object)val2).name + ".");
				return val2;
			}
			try
			{
				List<string> list = new List<string>();
				componentsInChildren = ((Component)cloneRoot).GetComponentsInChildren<Transform>(true);
				foreach (Transform val3 in componentsInChildren)
				{
					if (list.Count < 12 && ((Object)val3).name.IndexOf("hand", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						list.Add(((Object)val3).name);
					}
				}
				RankedLog.Warning("[Ghost] Handknochen 'Hand_R' nicht gefunden - Ghost bleibt ohne Item. Kandidaten mit 'hand' im Namen: " + ((list.Count > 0) ? string.Join(", ", list) : "keine") + ".");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Ghost] Handknochen nicht gefunden, Namensauszug fehlgeschlagen: " + ex.Message);
			}
			return null;
		}

		public static void SetLayerRecursively(GameObject root, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			root.layer = layer;
			foreach (Transform item in root.transform)
			{
				SetLayerRecursively(((Component)item).gameObject, layer);
			}
		}
	}
	public class GhostPlaybackService : MonoBehaviour
	{
		private const float SamplingIntervalSeconds = 0.5f;

		private static readonly int BaseColorId = Shader.PropertyToID("_BaseColor");

		private static readonly Color GhostTint = new Color(0.2f, 0.9f, 1f);

		private string _externalPointDataBase64;

		private string _externalAnimData;

		private string _externalItemData;

		private string _externalStateData;

		private string _externalInventoryData;

		private RaceTimer _raceTimer;

		private ClimbStorageService _storage;

		private TimerState _lastState;

		private List<Vector3> _ghostPoints;

		private List<float[]> _animSamples;

		private List<ushort> _itemSamples;

		private List<byte[]> _barSamples;

		private List<InventorySnapshot> _inventoryEvents;

		private GameObject _ghostObject;

		private Animator _ghostAnimator;

		private Material _ghostMaterial;

		private float _appliedOpacity = -1f;

		private Transform _ghostHandBone;

		private GameObject _ghostItemObject;

		private ushort _shownItemId = ushort.MaxValue;

		private Vector3 _modelOffset;

		private bool _ghostFinishedLogged;

		public static GhostPlaybackService Instance { get; private set; }

		public string CurrentGhostPlayerName { get; private set; }

		public string CurrentGhostTier { get; private set; }

		public int CurrentGhostElo { get; private set; }

		public long CurrentGhostTotalMs { get; private set; }

		public bool IsExternalGhostActive { get; private set; }

		public bool IsDuelActive { get; private set; }

		public bool IsGhostRunning
		{
			get
			{
				if ((Object)(object)_ghostObject != (Object)null && _ghostObject.activeSelf)
				{
					return _ghostPoints != null;
				}
				return false;
			}
		}

		public byte[] CurrentBars { get; private set; }

		public InventorySnapshot CurrentInventory { get; private set; }

		public long GhostElapsedMs { get; private set; }

		public bool GhostFinished { get; private set; }

		public long OwnElapsedMs
		{
			get
			{
				if (_raceTimer == null)
				{
					return 0L;
				}
				return _raceTimer.CurrentElapsedMs;
			}
		}

		private static Color CurrentGhostColor()
		{
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			Color ghostTint = GhostTint;
			ghostTint.a = Mathf.Clamp(Plugin.GhostOpacity.Value, 0.05f, 1f);
			return ghostTint;
		}

		public void Initialize(RaceTimer raceTimer, ClimbStorageService storage)
		{
			_raceTimer = raceTimer;
			_storage = storage;
			Instance = this;
		}

		public void SetExternalGhost(string playerName, string tier, int elo, long targetTotalMs, string pointDataBase64, string animData, string itemData, string stateData, string inventoryData, bool isDuel)
		{
			CurrentGhostPlayerName = playerName;
			CurrentGhostTier = tier;
			CurrentGhostElo = elo;
			CurrentGhostTotalMs = targetTotalMs;
			_externalPointDataBase64 = pointDataBase64;
			_externalAnimData = animData;
			_externalItemData = itemData;
			_externalStateData = stateData;
			_externalInventoryData = inventoryData;
			IsExternalGhostActive = true;
			IsDuelActive = isDuel;
			RankedLog.Info($"[Ghost] Externer Ghost gesetzt: {playerName} ({elo} ELO, {targetTotalMs}ms, Duell: {isDuel})");
		}

		public void ClearExternalGhost()
		{
			IsExternalGhostActive = false;
			IsDuelActive = false;
			CurrentGhostPlayerName = null;
			CurrentGhostTier = null;
			CurrentGhostElo = 0;
			CurrentGhostTotalMs = 0L;
			_externalPointDataBase64 = null;
			_externalAnimData = null;
			_externalItemData = null;
			_externalStateData = null;
			_externalInventoryData = null;
		}

		private void Update()
		{
			if (_raceTimer == null)
			{
				return;
			}
			TimerState state = _raceTimer.State;
			if (state != _lastState)
			{
				if (state == TimerState.Running)
				{
					TrySpawnGhost();
				}
				else if ((Object)(object)_ghostObject != (Object)null)
				{
					DespawnGhost();
				}
				_lastState = state;
			}
			if (state == TimerState.Running && (Object)(object)_ghostObject != (Object)null && _ghostPoints != null)
			{
				UpdateGhostPosition();
				ApplyGhostOpacity();
			}
		}

		private void ApplyGhostOpacity()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_ghostMaterial == (Object)null)
			{
				return;
			}
			Color val = CurrentGhostColor();
			if (!Mathf.Approximately(_appliedOpacity, val.a))
			{
				_appliedOpacity = val.a;
				if (_ghostMaterial.HasProperty(BaseColorId))
				{
					_ghostMaterial.SetColor(BaseColorId, val);
				}
				else
				{
					_ghostMaterial.color = val;
				}
			}
		}

		private void TrySpawnGhost()
		{
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			DespawnGhost();
			_ghostPoints = null;
			_animSamples = null;
			_itemSamples = null;
			_barSamples = null;
			_inventoryEvents = null;
			_ghostFinishedLogged = false;
			if (!Plugin.GhostEnabled.Value)
			{
				return;
			}
			if (IsExternalGhostActive && !string.IsNullOrEmpty(_externalPointDataBase64))
			{
				try
				{
					_ghostPoints = ClimbDataCrusher.ReadClimbData(Convert.FromBase64String(_externalPointDataBase64));
				}
				catch (Exception ex)
				{
					RankedLog.Error("[Ghost] Externes PointData nicht lesbar: " + ex.Message);
					return;
				}
				if (_ghostPoints == null || _ghostPoints.Count < 2)
				{
					RankedLog.Info("[Ghost] Externer Ghost hat zu wenig Punkte.");
					_ghostPoints = null;
					return;
				}
				_animSamples = GhostAnimParams.DecodeSamples(_externalAnimData);
				_itemSamples = GhostItemTrack.DecodeSamples(_externalItemData);
				_barSamples = GhostStateTrack.DecodeBars(_externalStateData);
				_inventoryEvents = GhostStateTrack.DecodeInventory(_externalInventoryData);
				_ghostMaterial = CreateGhostMaterial();
				_ghostObject = CreatePlayerModelGhost();
				if ((Object)(object)_ghostObject == (Object)null)
				{
					_ghostObject = CreateMarkerGhost();
				}
				_ghostObject.transform.position = _ghostPoints[0] + _modelOffset;
				RankedLog.Info($"[Ghost] Externer Ghost gestartet ({CurrentGhostPlayerName}, {CurrentGhostTotalMs}ms, {_ghostPoints.Count} Punkte, Duell: {IsDuelActive}).");
				LogPlacement();
				LogItemTrack();
				return;
			}
			GameMode currentMode = _raceTimer.CurrentMode;
			if (!AllowsPersonalBestGhost(currentMode))
			{
				RankedLog.Info($"[Ghost] Modus {currentMode} zeigt keinen eigenen PB-Ghost.");
				return;
			}
			ClimbRecord climbRecord = FindPersonalBestClimb();
			if (climbRecord == null)
			{
				RankedLog.Info("[Ghost] Kein eigener Completed-Climb fuer " + _raceTimer.CurrentMapName + " " + $"(Seed {_raceTimer.CurrentSeed}, Ascent {_raceTimer.CurrentAscentLevel}, " + $"Strecke {_raceTimer.CurrentRouteIndex}, Satz {MapCatalog.MapSetHash}) - kein Ghost.");
				return;
			}
			try
			{
				_ghostPoints = ClimbDataCrusher.ReadClimbData(Convert.FromBase64String(climbRecord.PointData));
			}
			catch (Exception ex2)
			{
				RankedLog.Error($"[Ghost] PointData nicht lesbar (Climb {climbRecord.Id}): {ex2.Message}");
				return;
			}
			if (_ghostPoints == null || _ghostPoints.Count < 2)
			{
				RankedLog.Info($"[Ghost] Climb {climbRecord.Id} hat zu wenig Punkte - kein Ghost.");
				_ghostPoints = null;
				return;
			}
			_animSamples = GhostAnimParams.DecodeSamples(climbRecord.AnimData);
			_itemSamples = GhostItemTrack.DecodeSamples(climbRecord.ItemData);
			_barSamples = GhostStateTrack.DecodeBars(climbRecord.StateData);
			_inventoryEvents = GhostStateTrack.DecodeInventory(climbRecord.InventoryData);
			_ghostMaterial = CreateGhostMaterial();
			_ghostObject = CreatePlayerModelGhost();
			if ((Object)(object)_ghostObject == (Object)null)
			{
				RankedLog.Warning("[Ghost] Charaktermodell nicht klonbar - Fallback auf Marker.");
				_ghostObject = CreateMarkerGhost();
			}
			_ghostObject.transform.position = _ghostPoints[0] + _modelOffset;
			RankedLog.Info(string.Format("[Ghost] PB-Ghost gestartet (Climb {0}, {1:F1}s, {2} Punkte, AnimData: {3}).", climbRecord.Id, climbRecord.DurationInSeconds, _ghostPoints.Count, (_animSamples != null) ? "ja" : "nein"));
			RankedLog.Info(string.Format("[Ghost] Start-Position: {0}, Spieler: {1}", _ghostObject.transform.position, ((Object)(object)Character.localCharacter != (Object)null) ? ((object)Character.localCharacter.Center/*cast due to .constrained prefix*/).ToString() : "?"));
			LogItemTrack();
		}

		private static bool AllowsPersonalBestGhost(GameMode mode)
		{
			if (mode != GameMode.StaticDaily)
			{
				return mode == GameMode.Speedrun;
			}
			return true;
		}

		private ClimbRecord FindPersonalBestClimb()
		{
			string currentMapName = _raceTimer.CurrentMapName;
			GameMode currentMode = _raceTimer.CurrentMode;
			int currentSeed = _raceTimer.CurrentSeed;
			int currentAscentLevel = _raceTimer.CurrentAscentLevel;
			int currentRouteIndex = _raceTimer.CurrentRouteIndex;
			string gameVersion = MapCatalog.GameVersion;
			ClimbRecord climbRecord = null;
			foreach (ClimbRecord climb in _storage.GetClimbs())
			{
				if (climb.Result == RunResult.Completed && !climb.WasDeathClimb && !(climb.MapName != currentMapName) && climb.Mode == currentMode && (string.IsNullOrEmpty(climb.GameVersion) || string.IsNullOrEmpty(gameVersion) || !(climb.GameVersion != gameVersion)) && climb.Seed == currentSeed && climb.AscentLevel == currentAscentLevel && climb.RouteIndex == currentRouteIndex && !string.IsNullOrEmpty(climb.PointData) && (climbRecord == null || climb.DurationInSeconds < climbRecord.DurationInSeconds))
				{
					climbRecord = climb;
				}
			}
			return climbRecord;
		}

		private void UpdateGhostPosition()
		{
			//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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)_raceTimer.CurrentElapsedMs / 1000f / 0.5f;
			int num2 = (int)num;
			if (num2 >= _ghostPoints.Count - 1)
			{
				if (!_ghostFinishedLogged)
				{
					_ghostFinishedLogged = true;
					RankedLog.Info("[Ghost] PB-Ghost hat sein Ziel erreicht.");
				}
				_ghostObject.SetActive(false);
				return;
			}
			if (!_ghostObject.activeSelf)
			{
				_ghostObject.SetActive(true);
			}
			float num3 = num - (float)num2;
			Vector3 val = _ghostPoints[num2];
			Vector3 val2 = _ghostPoints[num2 + 1];
			_ghostObject.transform.position = Vector3.Lerp(val, val2, num3) + _modelOffset;
			Vector3 val3 = val2 - val;
			val3.y = 0f;
			if (((Vector3)(ref val3)).sqrMagnitude > 0.001f)
			{
				_ghostObject.transform.rotation = Quaternion.LookRotation(val3);
			}
			if ((Object)(object)_ghostAnimator != (Object)null)
			{
				Vector3 val4 = val2 - val;
				float speed = ((Vector3)(ref val4)).magnitude / 0.5f;
				float[] array = null;
				if (_animSamples != null && num2 + 1 < _animSamples.Count)
				{
					array = GhostAnimParams.Lerp(_animSamples[num2], _animSamples[num2 + 1], num3);
				}
				if (array == null)
				{
					array = GhostAnimParams.DeriveFromMovement(speed);
				}
				GhostAnimParams.ApplyTo(_ghostAnimator, array);
			}
			UpdateGhostItem(num2);
			UpdateGhostState(num2);
		}

		private void UpdateGhostState(int sampleIndex)
		{
			long currentElapsedMs = _raceTimer.CurrentElapsedMs;
			if (_barSamples != null && sampleIndex < _barSamples.Count)
			{
				float fraction = (float)currentElapsedMs / 1000f / 0.5f - (float)sampleIndex;
				CurrentBars = ((sampleIndex + 1 < _barSamples.Count) ? LerpBars(_barSamples[sampleIndex], _barSamples[sampleIndex + 1], fraction) : _barSamples[sampleIndex]);
			}
			CurrentInventory = GhostStateTrack.InventoryAt(_inventoryEvents, currentElapsedMs);
			long num = ((CurrentGhostTotalMs > 0) ? CurrentGhostTotalMs : long.MaxValue);
			GhostFinished = currentElapsedMs >= num;
			GhostElapsedMs = (GhostFinished ? num : currentElapsedMs);
		}

		private static byte[] LerpBars(byte[] a, byte[] b, float fraction)
		{
			if (a == null || b == null)
			{
				return a ?? b;
			}
			float num = Mathf.Clamp01(fraction);
			byte[] array = new byte[a.Length];
			for (int i = 0; i < a.Length && i < b.Length; i++)
			{
				array[i] = (byte)Mathf.RoundToInt(Mathf.Lerp((float)(int)a[i], (float)(int)b[i], num));
			}
			return array;
		}

		private void LogPlacement()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Camera main = Camera.main;
				Character localCharacter = Character.localCharacter;
				Vector3 val = (((Object)(object)localCharacter != (Object)null && localCharacter.refs != null && (Object)(object)localCharacter.refs.animator != (Object)null) ? ((Component)localCharacter.refs.animator).transform.position : Vector3.zero);
				RankedLog.Debug($"[Ghost] Lage: Punkt[0]={_ghostPoints[0]}, Versatz={_modelOffset}, " + $"Ghost={_ghostObject.transform.position}, " + $"Spieler-Modellwurzel={val}, " + "Kamera=" + (((Object)(object)main != (Object)null) ? ((object)((Component)main).transform.position/*cast due to .constrained prefix*/).ToString() : "?") + ", " + $"Skalierung={_ghostObject.transform.localScale}.");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Ghost] Lage nicht auswertbar: " + ex.Message);
			}
		}

		private void LogItemTrack()
		{
			try
			{
				if (_itemSamples == null)
				{
					RankedLog.Info("[Ghost] Kein Item-Mitschnitt zu diesem Lauf.");
					return;
				}
				List<ushort> list = new List<ushort>();
				foreach (ushort itemSample in _itemSamples)
				{
					if (itemSample != ushort.MaxValue && !list.Contains(itemSample))
					{
						list.Add(itemSample);
					}
				}
				List<string> list2 = new List<string>();
				foreach (ushort item in list)
				{
					Item val = GhostItemTrack.ResolvePrefab(item);
					list2.Add(((Object)(object)val != (Object)null) ? $"{item}={((Object)val).name}" : $"{item}=unbekannt");
				}
				RankedLog.Info($"[Ghost] Item-Mitschnitt: {_itemSamples.Count} Samples, " + string.Format("{0} verschiedene Items ({1}).", list.Count, string.Join(", ", list2)));
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Ghost] Item-Mitschnitt nicht auswertbar: " + ex.Message);
			}
		}

		private void UpdateGhostItem(int sampleIndex)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (_itemSamples == null || (Object)(object)_ghostHandBone == (Object)null)
			{
				return;
			}
			ushort num = ((Plugin.GhostItemsEnabled.Value && sampleIndex < _itemSamples.Count) ? _itemSamples[sampleIndex] : ushort.MaxValue);
			if (num == _shownItemId)
			{
				return;
			}
			_shownItemId = num;
			if ((Object)(object)_ghostItemObject != (Object)null)
			{
				Object.Destroy((Object)(object)_ghostItemObject);
				_ghostItemObject = null;
			}
			Item val = GhostItemTrack.ResolvePrefab(num);
			if (!((Object)(object)val == (Object)null))
			{
				_ghostItemObject = GhostItemTrack.CreateVisual(val, _ghostMaterial);
				if (!((Object)(object)_ghostItemObject == (Object)null))
				{
					_ghostItemObject.transform.SetParent(_ghostHandBone, false);
					_ghostItemObject.transform.localPosition = Vector3.zero;
					_ghostItemObject.transform.localRotation = Quaternion.identity;
				}
			}
		}

		private void DespawnGhost()
		{
			if ((Object)(object)_ghostObject != (Object)null)
			{
				Object.Destroy((Object)(object)_ghostObject);
				_ghostObject = null;
				_ghostAnimator = null;
			}
			_ghostPoints = null;
			_animSamples = null;
			_itemSamples = null;
			_barSamples = null;
			_inventoryEvents = null;
			CurrentBars = null;
			CurrentInventory = null;
			GhostElapsedMs = 0L;
			GhostFinished = false;
			_ghostHandBone = null;
			_ghostItemObject = null;
			_shownItemId = ushort.MaxValue;
		}

		private GameObject CreatePlayerModelGhost()
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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)
			Color val = CurrentGhostColor();
			GhostModel ghostModel = GhostModelFactory.Create("RankedPeak_Ghost", val);
			if (ghostModel == null || !ghostModel.IsValid)
			{
				return null;
			}
			_ghostMaterial = ghostModel.Material;
			_appliedOpacity = val.a;
			_ghostAnimator = ghostModel.Animator;
			_ghostHandBone = ghostModel.HandBone;
			_modelOffset = ghostModel.ModelOffset;
			return ghostModel.Root;
		}

		private GameObject CreateMarkerGhost()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			_modelOffset = Vector3.zero;
			GameObject val = new GameObject("RankedPeak_Ghost");
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)1);
			((Object)obj).name = "Body";
			Object.Destroy((Object)(object)obj.GetComponent<Collider>());
			obj.GetComponent<Renderer>().sharedMaterial = _ghostMaterial;
			obj.transform.SetParent(val.transform, false);
			obj.transform.localScale = new Vector3(0.6f, 0.75f, 0.6f);
			GameObject obj2 = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)obj2).name = "Head";
			Object.Destroy((Object)(object)obj2.GetComponent<Collider>());
			obj2.GetComponent<Renderer>().sharedMaterial = _ghostMaterial;
			obj2.transform.SetParent(val.transform, false);
			obj2.transform.localPosition = new Vector3(0f, 1.05f, 0f);
			obj2.transform.localScale = new Vector3(0.45f, 0.45f, 0.45f);
			return val;
		}

		private Material CreateGhostMaterial()
		{
			//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_0007: 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)
			Color val = CurrentGhostColor();
			_appliedOpacity = val.a;
			return GhostModelFactory.CreateMaterial(val);
		}

		private void OnDestroy()
		{
			DespawnGhost();
		}
	}
	public class InventorySnapshot
	{
		public uint ElapsedMs;

		public ushort Hand = ushort.MaxValue;

		public ushort[] Belt = new ushort[3] { 65535, 65535, 65535 };

		public ushort Backpack = ushort.MaxValue;

		public byte BackpackType;

		public byte BackpackSlots;

		public ushort[] BackpackItems = new ushort[4] { 65535, 65535, 65535, 65535 };

		public bool SameContentAs(InventorySnapshot other)
		{
			if (other == null || Hand != other.Hand || Backpack != other.Backpack || BackpackType != other.BackpackType || BackpackSlots != other.BackpackSlots)
			{
				return false;
			}
			for (int i = 0; i < Belt.Length; i++)
			{
				if (Belt[i] != other.Belt[i])
				{
					return false;
				}
			}
			for (int j = 0; j < BackpackItems.Length; j++)
			{
				if (BackpackItems[j] != other.BackpackItems[j])
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class GhostStateTrack
	{
		public const int ExpectedStatusCount = 15;

		public const int BarsPerSample = 17;

		private const int InventoryEventBytes = 24;

		private const int LegacyInventoryEventBytes = 23;

		private static int _statusCount = -1;

		public static int StatusCount
		{
			get
			{
				if (_statusCount >= 0)
				{
					return _statusCount;
				}
				try
				{
					int length = Enum.GetValues(typeof(STATUSTYPE)).Length;
					if (length != 15)
					{
						RankedLog.Warning($"[GhostState] Das Spiel kennt {length} Statuswerte, der Mitschnitt " + $"ist auf {15} ausgelegt - es werden die ersten " + $"{Math.Min(length, 15)} aufgezeichnet.");
					}
					_statusCount = Math.Min(length, 15);
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[GhostState] Statuswerte nicht zaehlbar: " + ex.Message);
					_statusCount = 15;
				}
				return _statusCount;
			}
		}

		public static byte[] SampleBars()
		{
			byte[] array = new byte[17];
			try
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					return array;
				}
				if ((Object)(object)localCharacter.data != (Object)null)
				{
					array[0] = ToByte(localCharacter.data.currentStamina);
					array[1] = ToByte(localCharacter.data.extraStamina);
				}
				CharacterAfflictions val = ((localCharacter.refs != null) ? localCharacter.refs.afflictions : null);
				if ((Object)(object)val != (Object)null)
				{
					int statusCount = StatusCount;
					for (int i = 0; i < statusCount; i++)
					{
						array[2 + i] = ToByte(val.GetCurrentStatus((STATUSTYPE)i));
					}
				}
			}
			catch (Exception)
			{
			}
			return array;
		}

		public static string EncodeBars(List<byte[]> samples)
		{
			if (samples == null || samples.Count == 0)
			{
				return null;
			}
			byte[] array = new byte[samples.Count * 17];
			for (int i = 0; i < samples.Count; i++)
			{
				byte[] array2 = samples[i];
				for (int j = 0; j < 17; j++)
				{
					array[i * 17 + j] = (byte)((array2 != null && j < array2.Length) ? array2[j] : 0);
				}
			}
			return Convert.ToBase64String(array);
		}

		public static List<byte[]> DecodeBars(string stateData)
		{
			if (string.IsNullOrEmpty(stateData))
			{
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(stateData);
				int num = array.Length / 17;
				List<byte[]> list = new List<byte[]>(num);
				for (int i = 0; i < num; i++)
				{
					byte[] array2 = new byte[17];
					Array.Copy(array, i * 17, array2, 0, 17);
					list.Add(array2);
				}
				return list;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static float HealthFrom(byte[] sample)
		{
			return Mathf.Clamp01(1f - StatusSumFrom(sample));
		}

		public static float StatusSumFrom(byte[] sample)
		{
			if (sample == null)
			{
				return 0f;
			}
			float num = 0f;
			for (int i = 2; i < sample.Length; i++)
			{
				num += (float)(int)sample[i] / 255f;
			}
			return num;
		}

		public static float StaminaFrom(byte[] sample)
		{
			if (sample == null || sample.Length == 0)
			{
				return 0f;
			}
			return (float)(int)sample[0] / 255f;
		}

		public static float ExtraStaminaFrom(byte[] sample)
		{
			if (sample == null || sample.Length <= 1)
			{
				return 0f;
			}
			return (float)(int)sample[1] / 255f;
		}

		public static float StatusFrom(byte[] sample, STATUSTYPE type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Expected I4, but got Unknown
			int num = 2 + type;
			if (sample == null || num >= sample.Length)
			{
				return 0f;
			}
			return (float)(int)sample[num] / 255f;
		}

		public static InventorySnapshot SampleInventory(long elapsedMs)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			InventorySnapshot inventorySnapshot = new InventorySnapshot
			{
				ElapsedMs = (uint)Math.Max(0L, elapsedMs)
			};
			try
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					return inventorySnapshot;
				}
				inventorySnapshot.Hand = GhostItemTrack.SampleFromLocalCharacter();
				Player player = localCharacter.player;
				if ((Object)(object)player == (Object)null)
				{
					return inventorySnapshot;
				}
				if (player.itemSlots != null)
				{
					for (int i = 0; i < inventorySnapshot.Belt.Length && i < player.itemSlots.Length; i++)
					{
						inventorySnapshot.Belt[i] = IdOf(player.itemSlots[i]);
					}
				}
				BackpackSlot backpackSlot = player.backpackSlot;
				if (backpackSlot != null && (int)backpackSlot.backpackType != 0)
				{
					inventorySnapshot.BackpackType = (byte)backpackSlot.backpackType;
					inventorySnapshot.Backpack = IdOf((ItemSlot)(object)backpackSlot);
					inventorySnapshot.BackpackSlots = ReadSlotCount(localCharacter, backpackSlot.backpackType);
					ReadBackpackContents(backpackSlot, inventorySnapshot);
				}
			}
			catch (Exception)
			{
			}
			return inventorySnapshot;
		}

		private static void ReadBackpackContents(BackpackSlot slot, InventorySnapshot snapshot)
		{
			try
			{
				BackpackData val = default(BackpackData);
				if (((ItemSlot)slot).data != null && ((ItemSlot)slot).data.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref val) && val?.itemSlots != null)
				{
					for (int i = 0; i < snapshot.BackpackItems.Length && i < val.itemSlots.Length; i++)
					{
						snapshot.BackpackItems[i] = IdOf(val.itemSlots[i]);
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static byte ReadSlotCount(Character character, BackpackType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)type == 4)
			{
				return 0;
			}
			try
			{
				BackpackOnBackVisuals val = ((character.refs != null && (Object)(object)character.refs.backpackHandler != (Object)null) ? character.refs.backpackHandler.activeBackpackVisuals : null);
				if ((Object)(object)val != (Object)null && val.slotCount > 0)
				{
					return (byte)Mathf.Min(val.slotCount, 4);
				}
			}
			catch (Exception)
			{
			}
			return 4;
		}

		private static ushort IdOf(ItemSlot slot)
		{
			Item val = ((slot != null) ? slot.prefab : null);
			if (!((Object)(object)val != (Object)null))
			{
				return ushort.MaxValue;
			}
			return val.itemID;
		}

		public static string EncodeInventory(List<InventorySnapshot> events)
		{
			if (events == null || events.Count == 0)
			{
				return null;
			}
			byte[] array = new byte[events.Count * 24];
			for (int i = 0; i < events.Count; i++)
			{
				int num = i * 24;
				InventorySnapshot inventorySnapshot = events[i];
				WriteUInt(array, num, inventorySnapshot.ElapsedMs);
				WriteUShort(array, num + 4, inventorySnapshot.Hand);
				for (int j = 0; j < 3; j++)
				{
					WriteUShort(array, num + 6 + j * 2, inventorySnapshot.Belt[j]);
				}
				WriteUShort(array, num + 12, inventorySnapshot.Backpack);
				array[num + 14] = inventorySnapshot.BackpackType;
				for (int k = 0; k < 4; k++)
				{
					WriteUShort(array, num + 15 + k * 2, inventorySnapshot.BackpackItems[k]);
				}
				array[num + 23] = inventorySnapshot.BackpackSlots;
			}
			return Convert.ToBase64String(array);
		}

		public static List<InventorySnapshot> DecodeInventory(string inventoryData)
		{
			if (string.IsNullOrEmpty(inventoryData))
			{
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(inventoryData);
				int num = ((array.Length % 24 == 0) ? 24 : ((array.Length % 23 == 0) ? 23 : 24));
				int num2 = array.Length / num;
				List<InventorySnapshot> list = new List<InventorySnapshot>(num2);
				for (int i = 0; i < num2; i++)
				{
					int num3 = i * num;
					InventorySnapshot inventorySnapshot = new InventorySnapshot
					{
						ElapsedMs = ReadUInt(array, num3),
						Hand = ReadUShort(array, num3 + 4),
						Backpack = ReadUShort(array, num3 + 12),
						BackpackType = array[num3 + 14]
					};
					for (int j = 0; j < 3; j++)
					{
						inventorySnapshot.Belt[j] = ReadUShort(array, num3 + 6 + j * 2);
					}
					for (int k = 0; k < 4; k++)
					{
						inventorySnapshot.BackpackItems[k] = ReadUShort(array, num3 + 15 + k * 2);
					}
					inventorySnapshot.BackpackSlots = ((num == 24) ? array[num3 + 23] : ((byte)((inventorySnapshot.BackpackType != 0 && inventorySnapshot.BackpackType != 4) ? 4u : 0u)));
					list.Add(inventorySnapshot);
				}
				return list;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static InventorySnapshot InventoryAt(List<InventorySnapshot> events, long elapsedMs)
		{
			if (events == null || events.Count == 0)
			{
				return null;
			}
			InventorySnapshot result = null;
			foreach (InventorySnapshot @event in events)
			{
				if (@event.ElapsedMs > elapsedMs)
				{
					break;
				}
				result = @event;
			}
			return result;
		}

		private static byte ToByte(float value)
		{
			return (byte)Mathf.Clamp(Mathf.RoundToInt(value * 255f), 0, 255);
		}

		private static void WriteUShort(byte[] data, int offset, ushort value)
		{
			data[offset] = (byte)(value & 0xFF);
			data[offset + 1] = (byte)((value >> 8) & 0xFF);
		}

		private static ushort ReadUShort(byte[] data, int offset)
		{
			return (ushort)(data[offset] | (data[offset + 1] << 8));
		}

		private static void WriteUInt(byte[] data, int offset, uint value)
		{
			data[offset] = (byte)(value & 0xFF);
			data[offset + 1] = (byte)((value >> 8) & 0xFF);
			data[offset + 2] = (byte)((value >> 16) & 0xFF);
			data[offset + 3] = (byte)((value >> 24) & 0xFF);
		}

		private static uint ReadUInt(byte[] data, int offset)
		{
			return (uint)(data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24));
		}
	}
	[Flags]
	public enum IntegrityFlags : ushort
	{
		None = 0,
		StaminaFlagNoCause = 1,
		StaminaNoDrain = 2,
		StaminaOverMax = 4,
		StatusLocked = 8,
		StatusFrozen = 0x10,
		SpeedModNoCause = 0x20,
		SpeedImpossible = 0x40,
		Teleport = 0x80,
		Flight = 0x100,
		KinematicNoCause = 0x200,
		TimeScale = 0x400,
		ClockMismatch = 0x800,
		NoObservation = 0x1000,
		GroundedNoGround = 0x2000
	}
	public class IntegrityEvent
	{
		public long ms;

		public string type;

		public string detail;

		public int actor = -1;
	}
	public class IntegrityPatch
	{
		public string target;

		public string owner;

		public string kind;

		public bool self;
	}
	public class AscentSnapshot
	{
		public int level = -99;

		public bool customRun;

		public float climbStamina = 1f;

		public float hungerRate = 1f;

		public float fallDamage = 1f;

		public bool grappleMode;

		public float timeScale = 1f;
	}
	public class MotionStats
	{
		public float maxStepHorizontal;

		public float maxStepUp;

		public float maxStepDown;

		public float maxFreeRise;

		public int climbTicks;

		public int groundedTicks;

		public int airborneTicks;
	}
	public class IntegrityReport
	{
		public int v = 1;

		public string sentinelVersion = "1.0";

		public int sampleCount;

		public string ticks;

		public string afflictions;

		public long gameElapsedMs;

		public long realElapsedMs;

		public long unscaledElapsedMs;

		public double clockRatio = 1.0;

		public float minTimeScale = 1f;

		public float maxTimeScale = 1f;

		public int timeScaleFrames;

		public int pausedFrames;

		public AscentSnapshot ascent = new AscentSnapshot();

		public MotionStats motion = new MotionStats();

		public List<IntegrityEvent> events = new List<IntegrityEvent>();

		public List<IntegrityPatch> census = new List<IntegrityPatch>();

		public string censusHash = string.Empty;

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

		public int guardedCommands;

		public static string EncodeAfflictions(List<uint> masks)
		{
			if (masks == null || masks.Count == 0)
			{
				return null;
			}
			bool flag = false;
			foreach (uint mask in masks)
			{
				if (mask != 0)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				return null;
			}
			byte[] array = new byte[masks.Count * 4];
			for (int i = 0; i < masks.Count; i++)
			{
				uint num = masks[i];
				array[i * 4] = (byte)(num & 0xFF);
				array[i * 4 + 1] = (byte)((num >> 8) & 0xFF);
				array[i * 4 + 2] = (byte)((num >> 16) & 0xFF);
				array[i * 4 + 3] = (byte)((num >> 24) & 0xFF);
			}
			return Convert.ToBase64String(array);
		}

		public static string EncodeTicks(List<ushort> ticks)
		{
			if (ticks == null || ticks.Count == 0)
			{
				return null;
			}
			byte[] array = new byte[ticks.Count * 2];
			for (int i = 0; i < ticks.Count; i++)
			{
				array[i * 2] = (byte)(ticks[i] & 0xFF);
				array[i * 2 + 1] = (byte)((ticks[i] >> 8) & 0xFF);
			}
			return Convert.ToBase64String(array);
		}

		public static List<ushort> DecodeTicks(string ticks)
		{
			if (string.IsNullOrEmpty(ticks))
			{
				return null;
			}
			try
			{
				byte[] array = Convert.FromBase64String(ticks);
				List<ushort> list = new List<ushort>(array.Length / 2);
				for (int i = 0; i + 1 < array.Length; i += 2)
				{
					list.Add((ushort)(array[i] | (array[i + 1] << 8)));
				}
				return list;
			}
			catch (Exception)
			{
				return null;
			}
		}

		public static string HashCensus(List<IntegrityPatch> census)
		{
			if (census == null || census.Count == 0)
			{
				return string.Empty;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				foreach (IntegrityPatch censu in census)
				{
					stringBuilder.Append(censu.target).Append('|').Append(censu.owner)
						.Append('|')
						.Append(censu.kind)
						.Append(';');
				}
				using SHA256 sHA = SHA256.Create();
				byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(stringBuilder.ToString()));
				StringBuilder stringBuilder2 = new StringBuilder(16);
				for (int i = 0; i < 8; i++)
				{
					stringBuilder2.Append(array[i].ToString("x2", CultureInfo.InvariantCulture));
				}
				return stringBuilder2.ToString();
			}
			catch (Exception)
			{
				return string.Empty;
			}
		}
	}
	public class RunSentinel : MonoBehaviour
	{
		public const string SentinelVersion = "1.0";

		private const float TeleportHorizontalMeters = 40f;

		private const float TeleportUpMeters = 30f;

		private const float TeleportDownMeters = 80f;

		private const float GroundedSpeedMeters = 12f;

		private const float GroundedRiseMeters = 4f;

		private const float GroundedContactMeters = 6f;

		private const int FlightStreakTicks = 8;

		private const float FlightRisePerTick = 0.5f;

		private const float HoverBandMeters = 0.15f;

		private const long InfiniteStamGraceMs = 4000L;

		private const int StaminaWindowTicks = 20;

		private const float StaminaWindowRiseMeters = 1f;

		private const float StaminaDrainEpsilon = 0.002f;

		private const int HungerWindowTicks = 240;

		private const float HungerExpectedShare = 0.3f;

		private const float WarpCauseMs = 2500f;

		private const float ImpulseCauseMs = 6000f;

		private const float ImpulseMagnitude = 60f;

		private const int MaxEvents = 400;

		private const int MaxCensusEntries = 200;

		private bool _watching;

		private DateTime _startUtc;

		private readonly List<ushort> _ticks = new List<ushort>();

		private readonly List<uint> _afflictionMasks = new List<uint>();

		private readonly List<IntegrityEvent> _events = new List<IntegrityEvent>();

		private readonly List<IntegrityPatch> _census = new List<IntegrityPatch>();

		private readonly List<string> _missingAnchors = new List<string>();

		private IntegrityReport _report = new IntegrityReport();

		private readonly MotionStats _motion = new MotionStats();

		private ushort _pendingFlags;

		private float _minTimeScale = 1f;

		private float _maxTimeScale = 1f;

		private int _timeScaleFrames;

		private int _pausedFrames;

		private float _startRealtime;

		private int _sampleIndex;

		private Vector3 _lastCenter;

		private bool _hasLastCenter;

		private bool _groundedIsFake;

		private float _lastWarpMs = float.NegativeInfinity;

		private float _lastImpulseMs = float.NegativeInfinity;

		private float _lastFuel = -1f;

		private float _lastFuelDrainMs = float.NegativeInfinity;

		private ushort _lastHandItem = ushort.MaxValue;

		private float _lastHandChangeMs = float.NegativeInfinity;

		private uint _lastAdvantageMask;

		private int _riseStreak;

		private float _riseStreakStartY;

		private long _riseStreakStartMs;

		private int _hoverStreak;

		private long _hoverStreakStartMs;

		private int _climbStreak;

		private float _climbStreakStartStamina;

		private float _climbStreakStartY;

		private long _climbStreakStartMs;

		private int _hungerTicks;

		private long _lastInfiniteStamMs = -4611686018427387904L;

		private float _hungerStart;

		private float _hungerPrevious;

		private long _hungerStartMs;

		private bool _hungerWindowValid;

		private const float FuelCauseMs = 3000f;

		private const float HandCauseMs = 8000f;

		private static readonly uint AdvantageAfflictionMask = 65209606u;

		public static RunSentinel Instance { get; private set; }

		public static bool Watching
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					return Instance._watching;
				}
				return false;
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void BeginRun(DateTime startUtc, int ascentLevel)
		{
			Reset();
			if (!RankedRunGate.IsRankedRun)
			{
				RankedLog.Debug("[Sentinel] Vanilla-Lauf - keine Beobachtung.");
				return;
			}
			_startUtc = startUtc;
			_startRealtime = ReadRealtime();
			_watching = true;
			CaptureAscent(ascentLevel);
			CaptureCensus();
			CollectMissingAnchors();
			RankedLog.Info("[Sentinel] Beobachtung gestartet (v1.0, " + $"{SentinelPatches.GuardedCommandCount} Konsolenbefehle bewacht, " + $"{_census.Count} fremde Patches auf der Schutzoberflaeche).");
		}

		public void AbortRun()
		{
			if (_watching)
			{
				RankedLog.Debug("[Sentinel] Beobachtung verworfen.");
			}
			Reset();
		}

		private void Reset()
		{
			_watching = false;
			_ticks.Clear();
			_afflictionMasks.Clear();
			_events.Clear();
			_census.Clear();
			_missingAnchors.Clear();
			_report = new IntegrityReport();
			_pendingFlags = 0;
			_minTimeScale = 1f;
			_maxTimeScale = 1f;
			_timeScaleFrames = 0;
			_pausedFrames = 0;
			_startRealtime = 0f;
			_sampleIndex = 0;
			_hasLastCenter = false;
			_groundedIsFake = false;
			_lastWarpMs = float.NegativeInfinity;
			_lastImpulseMs = float.NegativeInfinity;
			_lastFuel = -1f;
			_lastFuelDrainMs = float.NegativeInfinity;
			_lastHandItem = ushort.MaxValue;
			_lastHandChangeMs = float.NegativeInfinity;
			_lastAdvantageMask = 0u;
			_riseStreak = 0;
			_hoverStreak = 0;
			_climbStreak = 0;
			_hungerTicks = 0;
			_hungerPrevious = 0f;
			_lastInfiniteStamMs = -4611686018427387904L;
			_hungerWindowValid = false;
			_motion.maxStepHorizontal = 0f;
			_motion.maxStepUp = 0f;
			_motion.maxStepDown = 0f;
			_motion.maxFreeRise = 0f;
			_motion.climbTicks = 0;
			_motion.groundedTicks = 0;
			_motion.airborneTicks = 0;
		}

		public IntegrityReport SealRun(long gameElapsedMs, long realElapsedMs)
		{
			if (!_watching)
			{
				return null;
			}
			_watching = false;
			try
			{
				IntegrityReport report = _report;
				report.sampleCount = _ticks.Count;
				report.gameElapsedMs = gameElapsedMs;
				report.realElapsedMs = realElapsedMs;
				long num = (report.unscaledElapsedMs = (long)Math.Max(0f, (ReadRealtime() - _startRealtime) * 1000f));
				report.clockRatio = ((realElapsedMs > 0) ? ((double)num / (double)realElapsedMs) : 1.0);
				report.minTimeScale = _minTimeScale;
				report.maxTimeScale = _maxTimeScale;
				report.timeScaleFrames = _timeScaleFrames;
				report.pausedFrames = _pausedFrames;
				report.motion = CopyOf(_motion);
				report.events = new List<IntegrityEvent>(_events);
				report.census = new List<IntegrityPatch>(_census);
				report.censusHash = IntegrityReport.HashCensus(_census);
				report.missingAnchors = new List<string>(_missingAnchors);
				report.guardedCommands = SentinelPatches.GuardedCommandCount;
				if (_ticks.Count > 0 && realElapsedMs > 2000 && Math.Abs(report.clockRatio - 1.0) > 0.02)
				{
					_ticks[_ticks.Count - 1] |= 2048;
					AddEvent(gameElapsedMs, "window", $"CLOCK_MISMATCH unscaled={report.unscaledElapsedMs}ms real={realElapsedMs}ms " + "ratio=" + report.clockRatio.ToString("F4", CultureInfo.InvariantCulture));
				}
				report.ticks = IntegrityReport.EncodeTicks(_ticks);
				report.afflictions = IntegrityReport.EncodeAfflictions(_afflictionMasks);
				RankedLog.Info($"[Sentinel] Strom abgeschlossen: {report.sampleCount} Ticks, " + string.Format("{0} Ereignisse, Uhr {1}, ", report.events.Count, report.clockRatio.ToString("F3", CultureInfo.InvariantCulture)) + $"auffaellige Ticks: {CountFlaggedTicks()}.");
				return report;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[Sentinel] Abschluss fehlgeschlagen: {arg}");
				return null;
			}
		}

		private int CountFlaggedTicks()
		{
			int num = 0;
			foreach (ushort tick in _ticks)
			{
				if ((tick & -4097) != 0)
				{
					num++;
				}
			}
			return num;
		}

		private void Update()
		{
			if (!_watching)
			{
				return;
			}
			try
			{
				float timeScale = Time.timeScale;
				if (timeScale < _minTimeScale)
				{
					_minTimeScale = timeScale;
				}
				if (timeScale > _maxTimeScale)
				{
					_maxTimeScale = timeScale;
				}
				if (timeScale <= 0.001f)
				{
					_pausedFrames++;
				}
				else if (Mathf.Abs(timeScale - ReadExpectedTimeScale()) > 0.01f)
				{
					_timeScaleFrames++;
					_pendingFlags |= 1024;
				}
			}
			catch (Exception)
			{
			}
		}

		public void Sample(long elapsedMs)
		{
			if (!_watching)
			{
				return;
			}
			ushort num = _pendingFlags;
			_pendingFlags = 0;
			try
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null || (Object)(object)localCharacter.data == (Object)null || localCharacter.refs == null)
				{
					num |= 0x1000;
					ResetWindows();
				}
				else
				{
					num |= CheckStamina(localCharacter, elapsedMs);
					num |= CheckStatuses(localCharacter, elapsedMs);
					num |= CheckMovement(localCharacter);
					num |= CheckPosition(localCharacter, elapsedMs);
				}
			}
			catch (Exception ex)
			{
				num |= 0x1000;
				RankedLog.Debug($"[Sentinel] Sample {_sampleIndex} nicht auswertbar: {ex.Message}");
			}
			_ticks.Add(num);
			uint num2 = SampleAfflictions();
			_afflictionMasks.Add(num2);
			TrackCauses(num2, elapsedMs);
			_sampleIndex++;
		}

		private void ResetWindows()
		{
			_riseStreak = 0;
			_hoverStreak = 0;
			_climbStreak = 0;
			_hungerWindowValid = false;
			_hasLastCenter = false;
		}

		private ushort CheckStamina(Character character, long elapsedMs)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			ushort num = 0;
			CharacterData data = character.data;
			CharacterAfflictions afflictions = character.refs.afflictions;
			if (character.infiniteStam && !HasAffliction(afflictions, (AfflictionType)1) && !HasAffliction(afflictions, (AfflictionType)24))
			{
				num |= 1;
			}
			if (data.extraStamina > 1.001f)
			{
				num |= 4;
			}
			if (character.infiniteStam)
			{
				_lastInfiniteStamMs = elapsedMs;
			}
			bool flag = elapsedMs - _lastInfiniteStamMs > 4000;
			if (!character.infiniteStam && flag && data.currentStamina > 1.001f)
			{
				num |= 4;
			}
			int num2;
			if (!data.isClimbing && !data.isRopeClimbing)
			{
				num2 = (data.isVineClimbing ? 1 : 0);
				if (num2 == 0)
				{
					goto IL_00b5;
				}
			}
			else
			{
				num2 = 1;
			}
			_motion.climbTicks++;
			goto IL_00b5;
			IL_00b5:
			float totalStamina = data.TotalStamina;
			float y = SafeCenter(character).y;
			bool flag2 = ReadClimbStaminaMultiplier() <= 0.001f;
			bool flag3 = character.infiniteStam || HasAffliction(afflictions, (AfflictionType)10) || HasAffliction(afflictions, (AfflictionType)1) || HasAffliction(afflictions, (AfflictionType)24);
			if (num2 == 0 || flag2 || flag3)
			{
				_climbStreak = 0;
				return num;
			}
			if (_climbStreak == 0)
			{
				_climbStreakStartStamina = totalStamina;
				_climbStreakStartY = y;
				_climbStreakStartMs = elapsedMs;
			}
			_climbStreak++;
			if (_climbStreak >= 20)
			{
				float num3 = _climbStreakStartStamina - totalStamina;
				float num4 = y - _climbStreakStartY;
				if (num4 >= 1f && Mathf.Abs(num3) <= 0.002f)
				{
					num |= 2;
					AddEvent(elapsedMs, "window", "STAMINA_NO_DRAIN " + FormatRange(_climbStreakStartMs, elapsedMs) + " rise=" + num4.ToString("F1", CultureInfo.InvariantCulture) + "m drain=" + num3.ToString("F4", CultureInfo.InvariantCulture));
				}
				_climbStreak = 0;
			}
			return num;
		}

		private ushort CheckStatuses(Character character, long elapsedMs)
		{
			ushort num = 0;
			CharacterAfflictions afflictions = character.refs.afflictions;
			if (character.statusesLocked)
			{
				num |= 8;
			}
			if (!HungerCanRise(character))
			{
				_hungerWindowValid = false;
				return num;
			}
			float currentStatus = afflictions.GetCurrentStatus((STATUSTYPE)1);
			if (!_hungerWindowValid)
			{
				_hungerWindowValid = true;
				_hungerStart = currentStatus;
				_hungerPrevious = currentStatus;
				_hungerStartMs = elapsedMs;
				_hungerTicks = 0;
				return num;
			}
			if (currentStatus < _hungerPrevious - 0.0001f)
			{
				_hungerStart = currentStatus;
				_hungerPrevious = currentStatus;
				_hungerStartMs = elapsedMs;
				_hungerTicks = 0;
				return num;
			}
			_hungerPrevious = currentStatus;
			_hungerTicks++;
			if (_hungerTicks >= 240)
			{
				float num2 = (float)(elapsedMs - _hungerStartMs) / 1000f;
				float num3 = 0.0005f * ReadHungerRateMultiplier() * num2;
				float num4 = currentStatus - _hungerStart;
				if (num3 > 0.0001f && num4 < num3 * 0.3f)
				{
					num |= 0x10;
					AddEvent(elapsedMs, "window", "STATUS_FROZEN " + FormatRange(_hungerStartMs, elapsedMs) + " hunger+" + num4.ToString("F4", CultureInfo.InvariantCulture) + " expected+" + num3.ToString("F4", CultureInfo.InvariantCulture));
				}
				_hungerStart = currentStatus;
				_hungerPrevious = currentStatus;
				_hungerStartMs = elapsedMs;
				_hungerTicks = 0;
			}
			return num;
		}

		private static bool HungerCanRise(Character character)
		{
			try
			{
				CharacterData data = character.data;
				CharacterAfflictions afflictions = character.refs.afflictions;
				if ((Object)(object)data == (Object)null || (Object)(object)afflictions == (Object)null)
				{
					return false;
				}
				if (!data.fullyConscious || data.dead)
				{
					return false;
				}
				if (data.isInvincible || data.isSkeleton)
				{
					return false;
				}
				if (character.isZombie || character.isScoutmaster)
				{
					return false;
				}
				if (afflictions.m_inAirport)
				{
					return false;
				}
				if (!afflictions.canGetHungry)
				{
					return false;
				}
				if (afflictions.statusSum > 0.95f)
				{
					return false;
				}
				return ReadHungerRateMultiplier() > 0.001f;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private ushort CheckMovement(Character character)
		{
			ushort num = 0;
			CharacterMovement movement = character.refs.movement;
			if ((Object)(object)movement == (Object)null)
			{
				return num;
			}
			float num2 = 1f + SumFasterBoi(character.refs.afflictions);
			if (movement.movementModifier > num2 + 0.05f)
			{
				num |= 0x20;
			}
			return num;
		}

		private ushort CheckPosition(Character character, long elapsedMs)
		{
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			ushort num = 0;
			CharacterData data = character.data;
			Vector3 val = SafeCenter(character);
			if (data.isGrounded)
			{
				_motion.groundedTicks++;
			}
			else
			{
				_motion.airborneTicks++;
			}
			_groundedIsFake = data.isGrounded && val.y - data.groundPos.y > 6f;
			if (_groundedIsFake)
			{
				num |= 0x2000;
			}
			if (data.isKinecmatic && !character.warping && !data.isCarried && !RecentlyWarped(elapsedMs) && !data.dead)
			{
				num |= 0x200;
			}
			if (!_hasLastCenter)
			{
				_lastCenter = val;
				_hasLastCenter = true;
				return num;
			}
			Vector3 val2 = val - _lastCenter;
			_lastCenter = val;
			Vector2 val3 = new Vector2(val2.x, val2.z);
			float magnitude = ((Vector2)(ref val3)).magnitude;
			if (magnitude > _motion.maxStepHorizontal)
			{
				_motion.maxStepHorizontal = magnitude;
			}
			if (val2.y > _motion.maxStepUp)
			{
				_motion.maxStepUp = val2.y;
			}
			if (0f - val2.y > _motion.maxStepDown)
			{
				_motion.maxStepDown = 0f - val2.y;
			}
			bool flag = character.warping || RecentlyWarped(elapsedMs) || RecentlyImpulsed(elapsedMs) || data.isCarried;
			if (!flag && (magnitude > 40f || val2.y > 30f || 0f - val2.y > 80f))
			{
				num |= 0x80;
				AddEvent(elapsedMs, "window", "TELEPORT dx=" + magnitude.ToString("F1", CultureInfo.InvariantCulture) + "m dy=" + val2.y.ToString("F1", CultureInfo.InvariantCulture) + "m");
			}
			if (data.isGrounded && !flag && magnitude > 12f)
			{
				num |= 0x40;
			}
			return (ushort)(num | CheckFlight(character, val2.y, elapsedMs));
		}

		private ushort CheckFlight(Character character, float deltaY, long elapsedMs)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			ushort num = 0;
			if (LiftCause(character, elapsedMs, deltaY) != null)
			{
				_riseStreak = 0;
				_hoverStreak = 0;
				return num;
			}
			if (deltaY >= 0.5f)
			{
				if (_riseStreak == 0)
				{
					_riseStreakStartY = SafeCenter(character).y - deltaY;
					_riseStreakStartMs = elapsedMs;
				}
				_riseStreak++;
				if (_riseStreak >= 8)
				{
					float num2 = SafeCenter(character).y - _riseStreakStartY;
					if (num2 > _motion.maxFreeRise)
					{
						_motion.maxFreeRise = num2;
					}
					num |= 0x100;
					AddEvent(elapsedMs, "window", "FLIGHT rise " + FormatRange(_riseStreakStartMs, elapsedMs) + " +" + num2.ToString("F1", CultureInfo.InvariantCulture) + "m, no lift cause");
					_riseStreak = 0;
				}
			}
			else
			{
				_riseStreak = 0;
			}
			if (Mathf.Abs(deltaY) <= 0.15f && !character.data.isGrounded)
			{
				if (_hoverStreak == 0)
				{
					_hoverStreakStartMs = elapsedMs;
				}
				_hoverStreak++;
				if (_hoverStreak >= 8)
				{
					num |= 0x100;
					AddEvent(elapsedMs, "window", "FLIGHT hover " + FormatRange(_hoverStreakStartMs, elapsedMs));
					_hoverStreak = 0;
				}
			}
			else
			{
				_hoverStreak = 0;
			}
			return num;
		}

		internal string LiftCause(Character character, long elapsedMs, float deltaY)
		{
			try
			{
				CharacterData data = character.data;
				CharacterRefs refs = character.refs;
				if (data.isGrounded && !_groundedIsFake && Mathf.Abs(deltaY) <= 4f)
				{
					return "grounded";
				}
				if (data.isClimbing)
				{
					return "climbing";
				}
				if (data.isRopeClimbing)
				{
					return "rope";
				}
				if (data.isVineClimbing)
				{
					return "vine";
				}
				if (data.sinceGrounded < 0.75f)
				{
					return "just left ground";
				}
				if (data.sinceClimb < 2f || data.sinceClimbJump < 2f)
				{
					return "just climbed";
				}
				if (data.sinceJump < 1.5f && data.sinceGrounded < 3f)
				{
					return "jump";
				}
				if ((Object)(object)data.heldRope != (Object)null)
				{
					return "holding rope";
				}
				if ((Object)(object)data.heldVine != (Object)null)
				{
					return "holding vine";
				}
				if ((Object)(object)data.currentStickyItem != (Object)null)
				{
					return "sticky item";
				}
				if (data.sinceStandOnPlayer < 1.5f)
				{
					return "standing on player";
				}
				if (character.warping)
				{
					return "warping";
				}
				if (data.isCarried)
				{
					return "carried";
				}
				if (data.passedOut || data.fullyPassedOut)
				{
					return "passed out";
				}
				if (data.dead)
				{
					return "dead";
				}
				if ((Object)(object)data.grabbedPlayer != (Object)null || (Object)(object)data.grabbingPlayer != (Object)null)
				{
					return "grabbing";
				}
				if (data.inWater > 0f)
				{
					return "water";
				}
				if (data.timeInAntigrav > 0f)
				{
					return "antigrav sphere";
				}
				if ((Object)(object)refs.afflictions != (Object)null && refs.afflictions.isStruggling)
				{
					return "struggling";
				}
				CharacterMovement movement = refs.movement;
				if ((Object)(object)movement != (Object)null)
				{
					if (movement.hasJetpack && (float)elapsedMs - _lastFuelDrainMs < 3000f)
					{
						return "jetpack (fuel draining)";
					}
					if (movement.rocketActive || movement.rocketLit)
					{
						return "rocket";
					}
					if (Mathf.Abs(movement.balloonFloatMultiplier) > 0.001f)
					{
						return "balloon lift";
					}
				}
				CharacterBalloons balloons = refs.balloons;
				if ((Object)(object)balloons != (Object)null)
				{
					if (balloons._isParachuteOpen)
					{
						return "parachute";
					}
					if (balloons.heldBalloonCount > 0)
					{
						return "balloon in hand";
					}
					if (balloons.tiedBalloons != null && balloons.tiedBalloons.Count > 0)
					{
						return "balloon tied";
					}
				}
				CharacterAfflictions afflictions = refs.afflictions;
				if (HasAffliction(afflictions, (AfflictionType)17))
				{
					return "low gravity";
				}
				if (HasAffliction(afflictions, (AfflictionType)25))
				{
					return "super jump";
				}
				if (HasAffliction(afflictions, (AfflictionType)23))
				{
					return "double jump";
				}
				if (RecentlyImpulsed(elapsedMs))
				{
					return "impulse";
				}
				if (RecentlyWarped(elapsedMs))
				{
					return "recent warp";
				}
				return null;
			}
			catch (Exception)
			{
				return "unreadable";
			}
		}

		public void OnConsoleCommand(string domain, string command)
		{
			AddEvent(NowMs(), "console", domain + "." + command);
		}

		public void OnWarp(Vector3 target, bool remote)
		{
			long num = NowMs();
			_lastWarpMs = num;
			AddEvent(num, remote ? "warpRpc" : "warp", "(" + target.x.ToString("F1", CultureInfo.InvariantCulture) + ", " + target.y.ToString("F1", CultureInfo.InvariantCulture) + ", " + target.z.ToString("F1", CultureInfo.InvariantCulture) + ")");
		}

		public void OnItemSpawn(string itemName, bool viaRpc)
		{
			AddEvent(NowMs(), "itemSpawn", itemName + (viaRpc ? " (rpc)" : string.Empty));
		}

		public void OnForceWin()
		{
			AddEvent(NowMs(), "forceWin", "RPCEndGame_ForceWin");
		}

		public void OnImpulse(float magnitude)
		{
			if (!(magnitude < 60f))
			{
				_lastImpulseMs = NowMs();
			}
		}

		private void CaptureCensus()
		{
			try
			{
				foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
				{
					if (_census.Count >= 200)
					{
						break;
					}
					Type type = allPatchedMethod?.DeclaringType;
					if (type == null)
					{
						continue;
					}
					bool flag = IsOwnCode(type);
					if (!flag && !IsProtectedSurface(type))
					{
						continue;
					}
					Patches patchInfo;
					try
					{
						patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
					}
					catch (Exception)
					{
						continue;
					}
					if (patchInfo == null)
					{
						continue;
					}
					foreach (string owner in patchInfo.Owners)
					{
						if (!(owner == "com.rankedpeak.mod"))
						{
							_census.Add(new IntegrityPatch
							{
								target = type.Name + "." + allPatchedMethod.Name,
								owner = owner,
								kind = DescribeKinds(patchInfo, owner),
								self = flag
							});
						}
					}
				}
				_census.Sort((IntegrityPatch a, IntegrityPatch b) => string.CompareOrdinal(a.target + a.owner, b.target + b.owner));
			}
			catch (Exception ex2)
			{
				RankedLog.Warning("[Sentinel] Patch-Zensus fehlgeschlagen: " + ex2.Message);
				_missingAnchors.Add("Harmony.GetAllPatchedMethods");
			}
		}

		private static string DescribeKinds(Patches info, string owner)
		{
			List<string> list = new List<string>(4);
			if (Owns(info.Prefixes, owner))
			{
				list.Add("pre");
			}
			if (Owns(info.Postfixes, owner))
			{
				list.Add("post");
			}
			if (Owns(info.Transpilers, owner))
			{
				list.Add("trans");
			}
			if (Owns(info.Finalizers, owner))
			{
				list.Add("fin");
			}
			return string.Join("+", list.ToArray());
		}

		private static bool Owns(IReadOnlyCollection<Patch> patches, string owner)
		{
			if (patches == null)
			{
				return false;
			}
			foreach (Patch patch in patches)
			{
				if (patch.owner == owner)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsOwnCode(Type type)
		{
			string text = type.Namespace;
			if (text != null)
			{
				if (!(text == "RankedPeak"))
				{
					return text.StartsWith("RankedPeak.", StringComparison.Ordinal);
				}
				return true;
			}
			return false;
		}

		private static bool IsProtectedSurface(Type type)
		{
			string text = type.Namespace;
			if (text != null && text.StartsWith("Peak.Afflictions", StringComparison.Ordinal))
			{
				return true;
			}
			switch (type.Name)
			{
			case "CharacterData":
			case "PhotonNetwork":
			case "CharacterClimbing":
			case "CharacterMovement":
			case "CharacterRopeHandling":
			case "CharacterVineClimbing":
			case "CharacterStats":
			case "CharacterItems":
			case "CharacterInput":
			case "Item":
			case "Time":
			case "Ascents":
			case "Physics":
			case "MapHandler":
			case "RunManager":
			case "Campfire":
			case "MapBaker":
			case "Character":
			case "CharacterAfflictions":
			case "CharacterRagdoll":
			case "ItemDatabase":
			case "RunSettings":
			case "MountainProgressHandler":
				return true;
			default:
				return false;
			}
		}

		private void CaptureAscent(int ascentLevel)
		{
			try
			{
				_report.ascent = new AscentSnapshot
				{
					level = ascentLevel,
					customRun = ReadIsCustomRun(),
					climbStamina = ReadClimbStaminaMultiplier(),
					hungerRate = ReadHungerRateMultiplier(),
					fallDamage = ReadFallDamageMultiplier(),
					timeScale = ReadExpectedTimeScale(),
					grappleMode = ReadGrappleMode()
				};
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Sentinel] Aufstiegs-Multiplikatoren nicht lesbar: " + ex.Message);
				_missingAnchors.Add("Ascents.multipliers");
			}
		}

		private void CollectMissingAnchors()
		{
			foreach (string missingAnchor in SentinelPatches.MissingAnchors)
			{
				if (!_missingAnchors.Contains(missingAnchor))
				{
					_missingAnchors.Add(missingAnchor);
				}
			}
		}

		private void AddEvent(long ms, string type, string detail, int actor = -1)
		{
			if (_events.Count < 400)
			{
				_events.Add(new IntegrityEvent
				{
					ms = ms,
					type = type,
					detail = ((detail != null && detail.Length > 120) ? detail.Substring(0, 120) : detail),
					actor = actor
				});
			}
		}

		private long NowMs()
		{
			try
			{
				return (long)(DateTime.UtcNow - _startUtc).TotalMilliseconds;
			}
			catch (Exception)
			{
				return 0L;
			}
		}

		private bool RecentlyWarped(long elapsedMs)
		{
			return (float)elapsedMs - _lastWarpMs < 2500f;
		}

		private bool RecentlyImpulsed(long elapsedMs)
		{
			return (float)elapsedMs - _lastImpulseMs < 6000f;
		}

		private static string FormatRange(long fromMs, long toMs)
		{
			return "@" + FormatMs(fromMs) + "-" + FormatMs(toMs);
		}

		private static string FormatMs(long ms)
		{
			long num = Math.Max(0L, ms) / 1000;
			return $"{num / 60:00}:{num % 60:00}";
		}

		private void TrackCauses(uint afflictionMask, long elapsedMs)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float num = ReadJetpackFuel();
				if (num >= 0f)
				{
					if (_lastFuel >= 0f && num < _lastFuel - 0.01f)
					{
						_lastFuelDrainMs = elapsedMs;
					}
					_lastFuel = num;
				}
				else
				{
					_lastFuel = -1f;
				}
				ushort num2 = GhostItemTrack.SampleFromLocalCharacter();
				if (num2 != _lastHandItem)
				{
					_lastHandItem = num2;
					_lastHandChangeMs = elapsedMs;
				}
				uint num3 = afflictionMask & ~_lastAdvantageMask & AdvantageAfflictionMask;
				_lastAdvantageMask = afflictionMask & AdvantageAfflictionMask;
				if (num3 == 0 || !((float)elapsedMs - _lastHandChangeMs > 8000f))
				{
					return;
				}
				for (int i = 0; i < 32; i++)
				{
					if ((num3 & (uint)(1 << i)) != 0)
					{
						AddEvent(elapsedMs, "afflictionNoItem", ((object)(AfflictionType)i/*cast due to .constrained prefix*/).ToString());
					}
				}
			}
			catch (Exception)
			{
			}
		}

		private static float ReadJetpackFuel()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			try
			{
				Character localCharacter = Character.localCharacter;
				BackpackSlot val = ((localCharacter == null) ? null : localCharacter.player?.backpackSlot);
				if (val == null || (int)val.backpackType != 3 || ((ItemSlot)val).data == null)
				{
					return -1f;
				}
				FloatItemData val2 = default(FloatItemData);
				return (((ItemSlot)val).data.TryGetDataEntry<FloatItemData>((DataEntryKey)10, ref val2) && val2 != null) ? val2.Value : (-1f);
			}
			catch (Exception)
			{
				return -1f;
			}
		}

		private static uint SampleAfflictions()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			uint num = 0u;
			try
			{
				List<Affliction> list = Character.localCharacter?.refs?.afflictions?.afflictionList;
				if (list == null)
				{
					return 0u;
				}
				foreach (Affliction item in list)
				{
					if (item != null)
					{
						int num2 = (int)item.GetAfflictionType();
						if (num2 >= 0 && num2 < 32)
						{
							num |= (uint)(1 << num2);
						}
					}
				}
				return num;
			}
			catch (Exception)
			{
				return 0u;
			}
		}

		private static MotionStats CopyOf(MotionStats source)
		{
			return new MotionStats
			{
				maxStepHorizontal = source.maxStepHorizontal,
				maxStepUp = source.maxStepUp,
				maxStepDown = source.maxStepDown,
				maxFreeRise = source.maxFreeRise,
				climbTicks = source.climbTicks,
				groundedTicks = source.groundedTicks,
				airborneTicks = source.airborneTicks
			};
		}

		private static Vector3 SafeCenter(Character character)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return character.Center;
			}
			catch (Exception)
			{
				return ((Object)(object)((Component)character).transform != (Object)null) ? ((Component)character).transform.position : Vector3.zero;
			}
		}

		private static bool HasAffliction(CharacterAfflictions afflictions, AfflictionType type)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Affliction val = default(Affliction);
				return (Object)(object)afflictions != (Object)null && afflictions.HasAfflictionType(type, ref val);
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static float SumFasterBoi(CharacterAfflictions afflictions)
		{
			float num = 0f;
			try
			{
				if (afflictions?.afflictionList == null)
				{
					return 0f;
				}
				foreach (Affliction affliction in afflictions.afflictionList)
				{
					Affliction_FasterBoi val = (Affliction_FasterBoi)(object)((affliction is Affliction_FasterBoi) ? affliction : null);
					if (val != null)
					{
						num += val.moveSpeedMod;
					}
				}
				return num;
			}
			catch (Exception)
			{
				return float.MaxValue;
			}
		}

		private static float ReadClimbStaminaMultiplier()
		{
			try
			{
				return Ascents.climbStaminaMultiplier;
			}
			catch (Exception)
			{
				return 1f;
			}
		}

		private static float ReadHungerRateMultiplier()
		{
			try
			{
				return Ascents.hungerRateMultiplier;
			}
			catch (Exception)
			{
				return 1f;
			}
		}

		private static float ReadFallDamageMultiplier()
		{
			try
			{
				return Ascents.fallDamageMultiplier;
			}
			catch (Exception)
			{
				return 1f;
			}
		}

		private static float ReadRealtime()
		{
			try
			{
				return Time.realtimeSinceStartup;
			}
			catch (Exception)
			{
				return 0f;
			}
		}

		private static float ReadExpectedTimeScale()
		{
			try
			{
				return GameUtils.GetTimeScale();
			}
			catch (Exception)
			{
				return 1f;
			}
		}

		private static bool ReadIsCustomRun()
		{
			try
			{
				return RunSettings.IsCustomRun;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static bool ReadGrappleMode()
		{
			try
			{
				return RunSettings.GetValue((SETTINGTYPE)20000, false) == 1;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
}
namespace RankedPeak.Timer
{
	public enum TimerState
	{
		Idle,
		Armed,
		WaitingForInput,
		Running,
		Finished
	}
	public class RaceTimer
	{
		private readonly RunStorageService _storage;

		private TimerState _state;

		private float _startTimeSeconds;

		private long _finalMs;

		private readonly List<SplitRecord> _splits = new List<SplitRecord>();

		private DateTime _startTimeUtc;

		private GameMode _mode;

		private int _ascentLevel;

		private int _playerCount = 1;

		private string _mapName = string.Empty;

		private int _seed = -1;

		private bool _randomSeed;

		private string _gameVersion = string.Empty;

		private int _levelIndex = -1;

		private string _biomeId = string.Empty;

		private string _mapSetHash = string.Empty;

		private int _routeIndex;

		public static RaceTimer Instance { get; private set; }

		public TimerState State => _state;

		public IReadOnlyList<SplitRecord> Splits => _splits;

		public GameMode CurrentMode => _mode;

		public int CurrentAscentLevel => _ascentLevel;

		public string CurrentMapName => _mapName;

		public int CurrentSeed => _seed;

		public bool CurrentSeedWasRandom => _randomSeed;

		public string CurrentGameVersion => _gameVersion;

		public int CurrentLevelIndex => _levelIndex;

		public string CurrentBiomeId => _biomeId;

		public int CurrentRouteIndex => _routeIndex;

		public RunRecord LastRunRecord { get; private set; }

		public bool LastRunWasPersonalBest { get; private set; }

		public long LastRunDeltaToPbMs { get; private set; }

		public long CurrentElapsedMs => _state switch
		{
			TimerState.Running => (long)((Time.time - _startTimeSeconds) * 1000f), 
			TimerState.Finished => _finalMs, 
			_ => 0L, 
		};

		public RaceTimer(RunStorageService storage)
		{
			_storage = storage;
			Instance = this;
		}

		public void Arm()
		{
			_splits.Clear();
			_finalMs = 0L;
			_state = TimerState.Armed;
			RunSentinel.Instance?.AbortRun();
		}

		public void OnRunStarted()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (_state == TimerState.Running)
			{
				RankedLog.Warning("[RaceTimer] StartRun waehrend laufendem Run - Timer wird neu gestartet, bisherige Aufzeichnung verworfen.");
			}
			_splits.Clear();
			_finalMs = 0L;
			_startTimeUtc = DateTime.UtcNow;
			_mode = RankedRunGate.CurrentMode();
			_ascentLevel = ReadAscentLevel();
			_playerCount = ReadPlayerCount();
			Scene activeScene = SceneManager.GetActiveScene();
			_mapName = ((Scene)(ref activeScene)).name;
			_seed = ((RankedRunGate.MayInterfere && SeedService.Instance != null) ? SeedService.Instance.EnsureSeed() : (-1));
			_randomSeed = _seed >= 0 && RankedRunGate.RandomSeed;
			CaptureMapIdentity();
			_routeIndex = RunConfigService.GetCurrentRouteIndex();
			_state = TimerState.WaitingForInput;
			RankedLog.Info($"[RaceTimer] Run erkannt (Map: {_mapName} #{_levelIndex} {_biomeId}, Strecke: {RunConfigService.GetRouteName(_routeIndex)}, Spiel: {_gameVersion}, Set: {_mapSetHash}, Modus: {_mode}, Ascent: {_ascentLevel}, Spieler: {_playerCount}) - wartet auf erste Eingabe.");
		}

		private void CaptureMapIdentity()
		{
			_gameVersion = MapCatalog.GameVersion;
			_mapSetHash = MapCatalog.MapSetHash;
			_levelIndex = MapCatalog.CurrentLevelIndex;
			string sceneName = MapCatalog.GetSceneName(_levelIndex);
			if (!string.IsNullOrEmpty(sceneName) && !string.IsNullOrEmpty(_mapName) && sceneName != _mapName)
			{
				int num = FindSlotForScene(_mapName);
				RankedLog.Warning($"[RaceTimer] Level-Index {_levelIndex} zeigt auf '{sceneName}', geladen ist " + $"aber '{_mapName}'. Index wird auf Slot {num} korrigiert.");
				_levelIndex = num;
			}
			_biomeId = MapCatalog.GetBiomeId(_levelIndex);
		}

		private static int FindSlotForScene(string sceneName)
		{
			for (int i = 0; i < MapCatalog.SlotCount; i++)
			{
				if (MapCatalog.GetSceneName(i) == sceneName)
				{
					return i;
				}
			}
			return -1;
		}

		public void BeginRun()
		{
			if (_state == TimerState.WaitingForInput || _state == TimerState.Armed)
			{
				_startTimeSeconds = Time.time;
				_startTimeUtc = DateTime.UtcNow;
				_state = TimerState.Running;
				RunSentinel.Instance?.BeginRun(_startTimeUtc, _ascentLevel);
				RankedLog.Info($"[RaceTimer] Zeitmessung gestartet (Map: {_mapName} #{_levelIndex} {_biomeId}, Spiel: {_gameVersion}, Modus: {_mode}, Ascent: {_ascentLevel}, Spieler: {_playerCount})");
			}
		}

		public void AddSplit(string segmentName)
		{
			if (_state == TimerState.Running)
			{
				if (string.IsNullOrEmpty(segmentName))
				{
					segmentName = "Unknown";
				}
				long currentElapsedMs = CurrentElapsedMs;
				SplitRecord splitRecord = ((_splits.Count > 0) ? _splits[_splits.Count - 1] : null);
				if (splitRecord != null && splitRecord.SegmentName == segmentName)
				{
					splitRecord.ElapsedMs = currentElapsedMs;
					RankedLog.Info($"[RaceTimer] Split aktualisiert: {segmentName} @ {currentElapsedMs} ms");
					return;
				}
				_splits.Add(new SplitRecord
				{
					SegmentName = segmentName,
					ElapsedMs = currentElapsedMs
				});
				RankedLog.Info($"[RaceTimer] Split: {segmentName} @ {currentElapsedMs} ms");
			}
		}

		public void FinishRun(string finalSegmentName = null)
		{
			if (_state == TimerState.Running)
			{
				if (!string.IsNullOrEmpty(finalSegmentName))
				{
					AddSplit(finalSegmentName);
				}
				EndRun(RunResult.Completed);
			}
		}

		public void OnPlayerDied()
		{
			if (_state == TimerState.Running)
			{
				EndRun(RunResult.Died);
			}
		}

		public void AbortRun()
		{
			if (_state == TimerState.WaitingForInput)
			{
				RankedLog.Info("[RaceTimer] Run vor erster Eingabe verlassen - verworfen (kein Record).");
				Arm();
			}
			else if (_state == TimerState.Running)
			{
				EndRun(RunResult.Aborted);
			}
		}

		public void SoftReset()
		{
			if (_state == TimerState.Running || _state == TimerState.WaitingForInput)
			{
				RankedLog.Info("[RaceTimer] Laufender Run per Hotkey verworfen (Soft-Reset, kein RunRecord gespeichert).");
			}
			Arm();
			RankedLog.Info("[RaceTimer] Timer zurueck auf Armed.");
		}

		private void EndRun(RunResult result)
		{
			_finalMs = (long)((Time.time - _startTimeSeconds) * 1000f);
			long realElapsedMs = (long)Math.Max(0.0, (DateTime.UtcNow - _startTimeUtc).TotalMilliseconds);
			_state = TimerState.Finished;
			RunRecord runRecord = new RunRecord
			{
				Id = Guid.NewGuid(),
				Mode = _mode,
				StartTimeUtc = _startTimeUtc,
				MapName = _mapName,
				Splits = new List<SplitRecord>(_splits),
				TotalMs = _finalMs,
				RealElapsedMs = realElapsedMs,
				Result = result,
				AscentLevel = _ascentLevel,
				PlayerCount = _playerCount,
				Seed = _seed,
				RandomSeed = _randomSeed,
				GameVersion = _gameVersion,
				LevelIndex = _levelIndex,
				BiomeId = _biomeId,
				MapSetHash = _mapSetHash,
				RouteIndex = _routeIndex,
				RouteBiomeName = ((_routeIndex > 0 && _splits.Count > 0) ? _splits[0].SegmentName : string.Empty)
			};
			try
			{
				runRecord.Integrity = RunSentinel.Instance?.SealRun(_finalMs, realElapsedMs);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RaceTimer] Sentinel-Strom nicht abschliessbar: " + ex.Message);
			}
			LastRunRecord = runRecord;
			LastRunWasPersonalBest = false;
			LastRunDeltaToPbMs = 0L;
			try
			{
				LastRunWasPersonalBest = _storage.AddRun(runRecord, out var deltaToPreviousPbMs);
				LastRunDeltaToPbMs = deltaToPreviousPbMs;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RaceTimer] Run konnte nicht gespeichert werden: {arg}");
			}
			RankedLog.Info($"[RaceTimer] Run beendet: {result} nach {_finalMs} ms (Map: {_mapName}), Splits: {runRecord.Splits.Count}, Neuer PB: {LastRunWasPersonalBest}");
			try
			{
				RaceService.Instance?.ReportFinish(runRecord);
			}
			catch (Exception ex2)
			{
				RankedLog.Warning("[RaceTimer] Race-Ergebnis konnte nicht gemeldet werden: " + ex2.Message);
			}
		}

		private static int ReadAscentLevel()
		{
			try
			{
				return Ascents.currentAscent;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RaceTimer] Ascents.currentAscent nicht lesbar: " + ex.Message);
				return 0;
			}
		}

		private static int ReadPlayerCount()
		{
			try
			{
				if (PhotonNetwork.InRoom && PhotonNetwork.CurrentRoom != null)
				{
					return Math.Max(1, PhotonNetwork.CurrentRoom.PlayerCount);
				}
				if (PhotonNetwork.InRoom)
				{
					return Math.Max(1, PhotonNetwork.PlayerList.Length);
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RaceTimer] Spielerzahl nicht ermittelbar: " + ex.Message);
			}
			return 1;
		}
	}
	public class SplitComparison
	{
		private readonly List<SplitRecord> _reference = new List<SplitRecord>();

		private readonly Dictionary<int, long> _bestSegments;

		public bool IsPinned { get; }

		public DateTime ReferenceStartedUtc { get; }

		public long ReferenceTotalMs { get; }

		public bool HasReference => _reference.Count > 0;

		public SplitComparison(RunStorageService storage, GameMode mode, string mapName, int routeIndex = 0)
		{
			RunRecord runRecord = ((!Plugin.ComparisonManual.Value) ? null : storage?.GetPinnedComparison(mode, mapName, routeIndex));
			RunRecord runRecord2 = runRecord ?? storage?.GetBestRunForRoute(mode, mapName, routeIndex);
			IsPinned = runRecord != null;
			if (runRecord2 != null)
			{
				_reference.AddRange(runRecord2.Splits);
				ReferenceTotalMs = runRecord2.TotalMs;
				ReferenceStartedUtc = runRecord2.StartTimeUtc;
			}
			_bestSegments = storage?.GetBestSegmentTimes(mode, mapName, routeIndex) ?? new Dictionary<int, long>();
		}

		public long? GetReferenceElapsedMs(int index)
		{
			if (index < 0 || index >= _reference.Count)
			{
				return null;
			}
			return _reference[index].ElapsedMs;
		}

		public long? GetBestSegmentMs(int index)
		{
			if (!_bestSegments.TryGetValue(index, out var value))
			{
				return null;
			}
			return value;
		}

		public long? GetSumOfBest()
		{
			if (_reference.Count == 0)
			{
				return null;
			}
			long num = 0L;
			for (int i = 0; i < _reference.Count; i++)
			{
				if (!_bestSegments.TryGetValue(i, out var value))
				{
					return null;
				}
				num += value;
			}
			return num;
		}
	}
}
namespace RankedPeak.Services
{
	public class ClimbStorageService
	{
		private class ClimbStorageData
		{
			public List<ClimbRecord> Climbs { get; set; } = new List<ClimbRecord>();
		}

		private const int MaxClimbEntries = 100;

		private readonly string _filePath;

		private readonly object _fileLock = new object();

		private ClimbStorageData _data = new ClimbStorageData();

		public ClimbStorageService()
		{
			string path = Path.Combine(Paths.PluginPath, "RankedPeak_Data");
			_filePath = Path.Combine(path, "climbs.json");
			Load();
		}

		public void AddClimb(ClimbRecord record)
		{
			lock (_fileLock)
			{
				_data.Climbs.Add(record);
				if (_data.Climbs.Count > 100)
				{
					_data.Climbs.RemoveRange(0, _data.Climbs.Count - 100);
				}
				Save();
			}
		}

		public List<ClimbRecord> GetClimbs()
		{
			lock (_fileLock)
			{
				return new List<ClimbRecord>(_data.Climbs);
			}
		}

		private void Load()
		{
			try
			{
				if (File.Exists(_filePath))
				{
					string text = File.ReadAllText(_filePath);
					_data = JsonConvert.DeserializeObject<ClimbStorageData>(text) ?? new ClimbStorageData();
					RankedLog.Info($"[ClimbStorage] {_data.Climbs.Count} Climbs aus {_filePath} geladen.");
				}
			}
			catch (Exception ex)
			{
				RankedLog.Error("[ClimbStorage] Laden fehlgeschlagen, starte leer: " + ex.Message);
				_data = new ClimbStorageData();
			}
		}

		private void Save()
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(_filePath));
				File.WriteAllText(_filePath, JsonConvert.SerializeObject((object)_data, (Formatting)1));
			}
			catch (Exception ex)
			{
				RankedLog.Error("[ClimbStorage] Speichern fehlgeschlagen: " + ex.Message);
			}
		}
	}
	public static class DailyRankService
	{
		public static IEnumerator FetchRankText(RunRecord record, string runId, Action<string> onResult)
		{
			if (record == null || onResult == null)
			{
				yield break;
			}
			string text = "https://followme-peak.ddns.net/ranked/leaderboards" + $"?mode={record.Mode}&playerCount={record.PlayerCount}&period=daily&limit=200";
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					RankedLog.Warning("[DailyRank] Leaderboard-Abruf fehlgeschlagen: " + request.error);
					onResult(Loc.T("rank.unreachable"));
					yield break;
				}
				string obj5;
				try
				{
					JObject obj = JObject.Parse(request.downloadHandler.text);
					JToken obj2 = obj["entries"];
					JArray val = (JArray)(object)((obj2 is JArray) ? obj2 : null);
					JToken obj3 = obj["total"];
					int num = ((obj3 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj3) : 0);
					string steamId = SteamIdentity.GetSteamId64();
					int? num2 = null;
					if (val != null)
					{
						foreach (JToken item in val)
						{
							string text2 = ((object)item[(object)"runId"])?.ToString();
							string text3 = ((object)item[(object)"steamId"])?.ToString();
							if (text2 == runId || (!string.IsNullOrEmpty(steamId) && text3 == steamId))
							{
								JToken obj4 = item[(object)"rank"];
								num2 = ((obj4 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj4)) : ((int?)null));
								break;
							}
						}
					}
					obj5 = (num2.HasValue ? Loc.T("rank.position", num2.Value, num) : Loc.T("rank.none"));
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[DailyRank] Leaderboard-Parse fehlgeschlagen: " + ex.Message);
					obj5 = Loc.T("rank.none");
				}
				onResult(obj5);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	public class DuelMatchInfo
	{
		public string DuelId { get; set; }

		public string GhostRunId { get; set; }

		public string GhostPlayerName { get; set; }

		public int GhostElo { get; set; }

		public string GhostTier { get; set; }

		public long GhostTotalMs { get; set; }

		public string MapName { get; set; }

		public int Seed { get; set; }

		public int LevelIndex { get; set; }

		public string MapSetHash { get; set; }

		public string Fallback { get; set; }
	}
	public class DuelResultDto
	{
		public int OldElo { get; set; }

		public int NewElo { get; set; }

		public int Delta { get; set; }

		public bool Won { get; set; }

		public int PlacementGames { get; set; }

		public int PlacementRemaining { get; set; }

		public string Tier { get; set; }

		public int? Sub { get; set; }

		public bool Ranked { get; set; }
	}
	public class DuelService : MonoBehaviour
	{
		public static DuelService Instance { get; private set; }

		public DuelMatchInfo ActiveDuelMatch { get; private set; }

		public DuelResultDto LastDuelResult { get; private set; }

		public static event Action<DuelResultDto> DuelResultSettled;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		public void StartDuelMatchmaking(Action<DuelMatchInfo> onSuccess, Action<string> onError)
		{
			((MonoBehaviour)this).StartCoroutine(DuelMatchmakingRoutine(onSuccess, onError));
		}

		public void StartGhostTraining(string ghostRunId, string playerName, long totalMs, int seed, int levelIndex, string mapSetHash, Action onSuccess, Action<string> onError)
		{
			((MonoBehaviour)this).StartCoroutine(GhostTrainingRoutine(ghostRunId, playerName, totalMs, seed, levelIndex, mapSetHash, onSuccess, onError));
		}

		private IEnumerator DuelMatchmakingRoutine(Action<DuelMatchInfo> onSuccess, Action<string> onError)
		{
			string steamId = SteamIdentity.GetSteamId64();
			if (string.IsNullOrEmpty(steamId))
			{
				onError?.Invoke(Loc.T("duel.err.noSteam"));
				yield break;
			}
			string mapSetHash = MapCatalog.MapSetHash;
			string text = "https://followme-peak.ddns.net/ranked/duel/match?steamId=" + steamId;
			if (!string.IsNullOrEmpty(mapSetHash))
			{
				text = text + "&mapSetHash=" + UnityWebRequest.EscapeURL(mapSetHash);
			}
			RankedLog.Debug("[Duel] Suche 1v1 Gegner: GET " + text + "...");
			UnityWebRequest matchRequest = UnityWebRequest.Get(text);
			try
			{
				matchRequest.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				matchRequest.timeout = 10;
				yield return matchRequest.SendWebRequest();
				if ((int)matchRequest.result != 1)
				{
					RankedLog.Warning("[Duel] Matchmaking fehlgeschlagen: " + matchRequest.error);
					onError?.Invoke(Loc.T("duel.err.noOpponent", matchRequest.error));
					yield break;
				}
				DuelMatchInfo matchInfo;
				try
				{
					JObject val = JObject.Parse(matchRequest.downloadHandler.text);
					DuelMatchInfo obj = new DuelMatchInfo
					{
						GhostRunId = ((object)val["ghostRunId"])?.ToString(),
						GhostPlayerName = (((object)val["ghostPlayerName"])?.ToString() ?? Loc.T("common.opponent"))
					};
					JToken obj2 = val["ghostElo"];
					obj.GhostElo = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 1000);
					JToken obj3 = val["ghostTotalMs"];
					obj.GhostTotalMs = ((obj3 != null) ? Extensions.Value<long>((IEnumerable<JToken>)obj3) : 0);
					obj.MapName = ((object)val["mapName"])?.ToString() ?? "Level_7";
					JToken obj4 = val["seed"];
					obj.Seed = ((obj4 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj4) : 0);
					JToken obj5 = val["levelIndex"];
					obj.LevelIndex = ((obj5 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj5) : ((int?)null)).GetValueOrDefault();
					obj.MapSetHash = ((object)val["mapSetHash"])?.ToString();
					obj.Fallback = ((object)val["fallback"])?.ToString() ?? "none";
					matchInfo = obj;
				}
				catch (Exception ex)
				{
					RankedLog.Error("[Duel] Match-Parse Fehler: " + ex.Message);
					onError?.Invoke(Loc.T("duel.err.matchmaking"));
					yield break;
				}
				RankedLog.Info($"[Duel] Match gefunden: vs. {matchInfo.GhostPlayerName} ({matchInfo.GhostElo} ELO, {matchInfo.GhostTotalMs} ms, Seed: {matchInfo.Seed})");
				bool ghostLoaded = false;
				yield return DownloadAndSetGhost(matchInfo.GhostRunId, matchInfo.GhostPlayerName, matchInfo.GhostElo, matchInfo.GhostTotalMs, isDuel: true, delegate(bool ok)
				{
					ghostLoaded = ok;
				});
				if (!ghostLoaded)
				{
					onError?.Invoke(Loc.T("duel.err.noGhostData", matchInfo.GhostPlayerName));
					yield break;
				}
				ActiveDuelMatch = matchInfo;
				LastDuelResult = null;
				ApplyGhostRun(matchInfo.Seed, matchInfo.LevelIndex, matchInfo.MapSetHash, matchInfo.GhostPlayerName);
				if (!RankedRunGate.Select(GameMode.RankedDuel, matchInfo.LevelIndex))
				{
					ActiveDuelMatch = null;
					onError?.Invoke(RankedRunGate.LastRefusal);
				}
				else
				{
					onSuccess?.Invoke(matchInfo);
				}
			}
			finally
			{
				((IDisposable)matchRequest)?.Dispose();
			}
		}

		private IEnumerator GhostTrainingRoutine(string ghostRunId, string playerName, long totalMs, int seed, int levelIndex, string mapSetHash, Action onSuccess, Action<string> onError)
		{
			RankedLog.Info("[Duel] Starte Ghost-Training vs. " + playerName + " (Run: " + ghostRunId + ")...");
			bool ghostLoaded = false;
			yield return DownloadAndSetGhost(ghostRunId, playerName, 1000, totalMs, isDuel: false, delegate(bool ok)
			{
				ghostLoaded = ok;
			});
			if (!ghostLoaded)
			{
				onError?.Invoke(Loc.T("duel.err.noGhostData", playerName));
				yield break;
			}
			ActiveDuelMatch = null;
			LastDuelResult = null;
			ApplyGhostRun(seed, levelIndex, mapSetHash, playerName);
			if (!RankedRunGate.Select(GameMode.GhostTraining, levelIndex))
			{
				onError?.Invoke(RankedRunGate.LastRefusal);
			}
			else
			{
				onSuccess?.Invoke();
			}
		}

		private static void ApplyGhostRun(int seed, int levelIndex, string mapSetHash, string playerName)
		{
			if (seed == 0)
			{
				RankedLog.Warning("[Duel] Ghost-Run von " + playerName + " hat keinen Seed - der Berg wird neu gewuerfelt, die Item-Funde weichen ab.");
				SeedService.Instance?.ClearOverrideSeed();
			}
			else
			{
				SeedService.Instance?.SetOverrideSeed(seed);
				RankedLog.Info($"[Duel] Seed des Ghost-Runs uebernommen: {seed} (vs. {playerName}).");
			}
			string mapSetHash2 = MapCatalog.MapSetHash;
			bool flag = !string.IsNullOrEmpty(mapSetHash) && !string.IsNullOrEmpty(mapSetHash2) && string.Equals(mapSetHash, mapSetHash2, StringComparison.OrdinalIgnoreCase);
			if (levelIndex > 0 && flag)
			{
				string arg = RankedGameLauncher.ForceLevelIndex(levelIndex);
				RankedLog.Info($"[Duel] Karte des Ghost-Runs erzwungen: Index {levelIndex} => '{arg}'.");
				return;
			}
			RankedGameLauncher.ClearForcedLevel();
			if (levelIndex <= 0)
			{
				RankedLog.Warning("[Duel] Ghost-Run von " + playerName + " hat keinen Level-Index - es bleibt bei der Tageskarte.");
				return;
			}
			RankedLog.Warning("[Duel] Karten-Satz des Ghosts weicht ab (Ghost '" + mapSetHash + "', eigener '" + mapSetHash2 + "') - Karte wird nicht erzwungen, nur die Zeit ist vergleichbar.");
		}

		private IEnumerator DownloadAndSetGhost(string runId, string playerName, int elo, long totalMs, bool isDuel, Action<bool> onDone)
		{
			bool loaded = false;
			string text = "https://followme-peak.ddns.net/ranked/ghosts/" + runId;
			UnityWebRequest ghostRequest = UnityWebRequest.Get(text);
			try
			{
				ghostRequest.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				ghostRequest.timeout = 10;
				yield return ghostRequest.SendWebRequest();
				if ((int)ghostRequest.result == 1)
				{
					try
					{
						JObject obj = JObject.Parse(ghostRequest.downloadHandler.text);
						string text2 = ((object)obj["pointData"])?.ToString();
						string animData = ((object)obj["animData"])?.ToString();
						string itemData = ((object)obj["itemData"])?.ToString();
						string stateData = ((object)obj["stateData"])?.ToString();
						string inventoryData = ((object)obj["inventoryData"])?.ToString();
						if (!string.IsNullOrEmpty(text2))
						{
							GhostPlaybackService.Instance?.SetExternalGhost(playerName, "Hiker", elo, totalMs, text2, animData, itemData, stateData, inventoryData, isDuel);
							RankedLog.Info($"[Duel] Ghost {playerName} ({text2.Length} Chars) erfolgreich geladen.");
							loaded = true;
						}
						else
						{
							RankedLog.Warning("[Duel] Ghost-Daten fuer Run " + runId + " haben keine Trajektorie.");
						}
					}
					catch (Exception ex)
					{
						RankedLog.Error("[Duel] Fehler beim Parsen des Ghosts: " + ex.Message);
					}
				}
				else
				{
					RankedLog.Warning("[Duel] Ghost-Download fehlgeschlagen: " + ghostRequest.error);
				}
				onDone?.Invoke(loaded);
			}
			finally
			{
				((IDisposable)ghostRequest)?.Dispose();
			}
		}

		public void SubmitDuelResult(RunRecord run, Action<DuelResultDto> onComplete = null)
		{
			if (ActiveDuelMatch != null && run != null && run.Mode == GameMode.RankedDuel)
			{
				bool won = run.Result == RunResult.Completed && (ActiveDuelMatch.GhostTotalMs <= 0 || run.TotalMs < ActiveDuelMatch.GhostTotalMs);
				((MonoBehaviour)this).StartCoroutine(SubmitDuelResultRoutine(run, won, onComplete));
			}
		}

		private IEnumerator SubmitDuelResultRoutine(RunRecord run, bool won, Action<DuelResultDto> onComplete)
		{
			string steamId = SteamIdentity.GetSteamId64();
			DuelMatchInfo activeDuelMatch = ActiveDuelMatch;
			var anon = new
			{
				steamId = steamId,
				playerName = (PhotonNetwork.NickName ?? "Local"),
				ghostRunId = activeDuelMatch.GhostRunId,
				won = won,
				runId = run.Id.ToString()
			};
			string text = "https://followme-peak.ddns.net/ranked/duel/result";
			string s = JsonConvert.SerializeObject((object)anon);
			RankedLog.Debug($"[Duel] POST {text} (Won: {won}, vs: {activeDuelMatch.GhostPlayerName})...");
			UnityWebRequest request = new UnityWebRequest(text, "POST");
			try
			{
				request.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(s));
				request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				request.SetRequestHeader("Content-Type", "application/json");
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result == 1)
				{
					try
					{
						JObject val = JObject.Parse(request.downloadHandler.text);
						DuelResultDto duelResultDto = new DuelResultDto();
						JToken obj = val["oldElo"];
						duelResultDto.OldElo = ((obj != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj) : 1000);
						JToken obj2 = val["newElo"];
						duelResultDto.NewElo = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 1000);
						JToken obj3 = val["delta"];
						duelResultDto.Delta = ((obj3 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj3) : 0);
						JToken obj4 = val["won"];
						duelResultDto.Won = ((obj4 != null) ? Extensions.Value<bool>((IEnumerable<JToken>)obj4) : won);
						JToken obj5 = val["placementGames"];
						duelResultDto.PlacementGames = ((obj5 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj5) : 3);
						JToken obj6 = val["placementRemaining"];
						duelResultDto.PlacementRemaining = ((obj6 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj6) : 0);
						duelResultDto.Tier = ((object)val["tier"])?.ToString() ?? "Hiker";
						JToken obj7 = val["sub"];
						duelResultDto.Sub = ((obj7 != null) ? Extensions.Value<int?>((IEnumerable<JToken>)obj7) : ((int?)null));
						JToken obj8 = val["ranked"];
						duelResultDto.Ranked = obj8 == null || Extensions.Value<bool>((IEnumerable<JToken>)obj8);
						DuelResultDto duelResultDto2 = (LastDuelResult = duelResultDto);
						RankedLog.Info(string.Format("[Duel] Ergebnis gewertet: {0} ({1} -> {2} ELO, Delta: {3}{4})", duelResultDto2.Won ? "SIEG" : "NIEDERLAGE", duelResultDto2.OldElo, duelResultDto2.NewElo, (duelResultDto2.Delta >= 0) ? "+" : "", duelResultDto2.Delta));
						RatingService.Instance?.RefreshRating();
						DuelService.DuelResultSettled?.Invoke(duelResultDto2);
						onComplete?.Invoke(duelResultDto2);
					}
					catch (Exception ex)
					{
						RankedLog.Error("[Duel] Parse-Fehler beim Duell-Ergebnis: " + ex.Message);
					}
				}
				else
				{
					RankedLog.Warning("[Duel] Duell-Ergebnis konnte nicht gesendet werden: " + request.error);
				}
				ActiveDuelMatch = null;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	public static class MapCatalog
	{
		private static string[] _sceneNames;

		private static string[] _biomeIds;

		private static string _mapSetHash;

		private static bool _fullDiagnosticsLogged;

		public static string GameVersion
		{
			get
			{
				try
				{
					return Application.version ?? string.Empty;
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[MapCatalog] Application.version nicht lesbar: " + ex.Message);
					return string.Empty;
				}
			}
		}

		public static int SlotCount
		{
			get
			{
				EnsureCatalog();
				string[] sceneNames = _sceneNames;
				if (sceneNames == null)
				{
					return 0;
				}
				return sceneNames.Length;
			}
		}

		public static int CurrentLevelIndex
		{
			get
			{
				try
				{
					NextLevelService service = GameHandler.GetService<NextLevelService>();
					return ((service != null) ? service.NextLevelIndexOrFallback : 0) + NextLevelService.debugLevelIndexOffset;
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[MapCatalog] Level-Index nicht lesbar: " + ex.Message);
					return 0;
				}
			}
		}

		public static bool HasServerLevelIndex
		{
			get
			{
				try
				{
					NextLevelService service = GameHandler.GetService<NextLevelService>();
					return service != null && service.HasReceivedLevelIndex;
				}
				catch
				{
					return false;
				}
			}
		}

		public static string MapSetHash
		{
			get
			{
				EnsureCatalog();
				return _mapSetHash ?? string.Empty;
			}
		}

		public static string GetSceneName(int levelIndex)
		{
			EnsureCatalog();
			return Pick(_sceneNames, levelIndex) ?? string.Empty;
		}

		public static string GetBiomeId(int levelIndex)
		{
			EnsureCatalog();
			return Pick(_biomeIds, levelIndex) ?? string.Empty;
		}

		public static string GetBiomeLabel(int levelIndex)
		{
			return ToDisplaySignature(GetBiomeId(levelIndex));
		}

		public static string ToDisplaySignature(string rawBiomeId)
		{
			if (string.IsNullOrEmpty(rawBiomeId))
			{
				return string.Empty;
			}
			char[] array = rawBiomeId.ToCharArray();
			for (int i = 1; i < array.Length; i++)
			{
				if (array[i] == 'S')
				{
					array[i] = 'G';
				}
			}
			return new string(array);
		}

		public static string ExpectedSceneName(int slot)
		{
			return "Level_" + slot.ToString(CultureInfo.InvariantCulture);
		}

		public static bool IsSlotAuthentic(int levelIndex)
		{
			string sceneName = GetSceneName(levelIndex);
			if (string.IsNullOrEmpty(sceneName))
			{
				return true;
			}
			return sceneName == ExpectedSceneName(SlotOf(levelIndex));
		}

		public static string DescribeCatalogDeviations()
		{
			EnsureCatalog();
			if (_sceneNames == null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < _sceneNames.Length; i++)
			{
				string text = ExpectedSceneName(i);
				if (!(_sceneNames[i] == text))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append($"Slot {i}: {_sceneNames[i]} (erwartet {text})");
				}
			}
			return stringBuilder.ToString();
		}

		public static bool HasMountain(string sceneName, string biomeId, string gameVersion)
		{
			if (!string.IsNullOrEmpty(gameVersion) && !string.IsNullOrEmpty(GameVersion) && gameVersion != GameVersion)
			{
				return false;
			}
			if (string.IsNullOrEmpty(sceneName))
			{
				return true;
			}
			EnsureCatalog();
			if (_sceneNames == null)
			{
				return true;
			}
			for (int i = 0; i < _sceneNames.Length; i++)
			{
				if (!(_sceneNames[i] != sceneName) && (string.IsNullOrEmpty(biomeId) || _biomeIds[i] == biomeId))
				{
					return true;
				}
			}
			return false;
		}

		public static int SlotOf(int levelIndex)
		{
			int slotCount = SlotCount;
			if (slotCount <= 0)
			{
				return 0;
			}
			int num = levelIndex % slotCount;
			if (num >= 0)
			{
				return num;
			}
			return num + slotCount;
		}

		private static string Pick(string[] source, int levelIndex)
		{
			if (source == null || source.Length == 0)
			{
				return null;
			}
			int num = levelIndex % source.Length;
			if (num < 0)
			{
				num += source.Length;
			}
			return source[num];
		}

		private static void EnsureCatalog()
		{
			if (_sceneNames != null)
			{
				return;
			}
			try
			{
				MapBaker instance = SingletonAsset<MapBaker>.Instance;
				if (instance?.ScenePaths != null && instance.ScenePaths.Length != 0)
				{
					int num = instance.ScenePaths.Length;
					string[] array = new string[num];
					string[] array2 = new string[num];
					for (int i = 0; i < num; i++)
					{
						array[i] = instance.GetLevel(i);
						array2[i] = instance.GetBiomeID(i);
					}
					_sceneNames = array;
					_biomeIds = array2;
					_mapSetHash = ComputeMapSetHash(array, array2);
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[MapCatalog] MapBaker nicht lesbar: " + ex.Message);
			}
		}

		private static string ComputeMapSetHash(string[] scenes, string[] biomes)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < scenes.Length; i++)
			{
				stringBuilder.Append(scenes[i]).Append(':').Append(biomes[i])
					.Append('|');
			}
			uint num = 2166136261u;
			string text = stringBuilder.ToString();
			foreach (char c in text)
			{
				num = (num ^ c) * 16777619;
			}
			return num.ToString("x8", CultureInfo.InvariantCulture);
		}

		public static string Describe(int levelIndex)
		{
			return string.Format(CultureInfo.InvariantCulture, "{0} | {1} (#{2}, Slot {3}, {4}) | Set {5}", GameVersion, GetSceneName(levelIndex), levelIndex, SlotOf(levelIndex), GetBiomeLabel(levelIndex), MapSetHash);
		}

		public static void LogDiagnostics(string context)
		{
			try
			{
				int currentLevelIndex = CurrentLevelIndex;
				if (_fullDiagnosticsLogged)
				{
					RankedLog.Info("[MapCatalog] " + context + ": " + Describe(currentLevelIndex));
					return;
				}
				EnsureCatalog();
				if (_sceneNames == null)
				{
					RankedLog.Warning("[MapCatalog] " + context + ": Katalog noch nicht lesbar " + $"(Spielversion {GameVersion}, Index {currentLevelIndex}).");
					return;
				}
				_fullDiagnosticsLogged = true;
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("[MapCatalog] " + context + " - Karten-Katalog dieser Spielversion:");
				stringBuilder.AppendLine("  Spielversion (Application.version): " + GameVersion);
				stringBuilder.AppendLine("  Unity: " + Application.unityVersion);
				stringBuilder.AppendLine($"  Slots (MapBaker.ScenePaths): {_sceneNames.Length}");
				stringBuilder.AppendLine("  MapSetHash: " + MapSetHash);
				string text = DescribeCatalogDeviations();
				stringBuilder.AppendLine("  Katalog: " + (string.IsNullOrEmpty(text) ? "unveraendert" : text));
				stringBuilder.AppendLine($"  Server-Index empfangen: {HasServerLevelIndex}");
				stringBuilder.AppendLine($"  LevelIndex (inkl. Debug-Offset {NextLevelService.debugLevelIndexOffset}): {currentLevelIndex}");
				stringBuilder.AppendLine($"  => heutige Karte: {GetSceneName(currentLevelIndex)} (Slot {SlotOf(currentLevelIndex)}, Biome {GetBiomeLabel(currentLevelIndex)})");
				for (int i = 0; i < _sceneNames.Length; i++)
				{
					stringBuilder.AppendLine($"    [{i,2}] {_sceneNames[i],-10} {ToDisplaySignature(_biomeIds[i])} (roh {_biomeIds[i]})");
				}
				RankedLog.Info(stringBuilder.ToString().TrimEnd());
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[MapCatalog] Diagnose fehlgeschlagen: " + ex.Message);
			}
		}
	}
	public class ModAllowlistService : MonoBehaviour
	{
		[Serializable]
		private class AllowlistEntry
		{
			public string guid;
		}

		[Serializable]
		private class AllowlistResponse
		{
			public List<AllowlistEntry> mods;
		}

		private const float RequestTimeoutSeconds = 10f;

		private static readonly TimeSpan RefreshInterval = TimeSpan.FromMinutes(30.0);

		private static readonly HashSet<string> Allowed = new HashSet<string>(StringComparer.Ordinal);

		private bool _fetchInProgress;

		private DateTime _lastSuccessUtc = DateTime.MinValue;

		public static ModAllowlistService Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		public static bool IsAllowed(string id)
		{
			if (!string.IsNullOrEmpty(id))
			{
				return Allowed.Contains(id);
			}
			return false;
		}

		public void RefreshIfStale()
		{
			if (!_fetchInProgress && !(DateTime.UtcNow - _lastSuccessUtc < RefreshInterval))
			{
				((MonoBehaviour)this).StartCoroutine(FetchAllowlist());
			}
		}

		private IEnumerator FetchAllowlist()
		{
			_fetchInProgress = true;
			string text = "https://followme-peak.ddns.net/ranked/mods/allowlist";
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result == 1)
				{
					try
					{
						AllowlistResponse allowlistResponse = JsonConvert.DeserializeObject<AllowlistResponse>(request.downloadHandler.text);
						if (allowlistResponse?.mods != null)
						{
							Allowed.Clear();
							int num = 0;
							foreach (AllowlistEntry mod in allowlistResponse.mods)
							{
								if (!string.IsNullOrEmpty(mod?.guid) && Allowed.Add(mod.guid))
								{
									num++;
								}
							}
							_lastSuccessUtc = DateTime.UtcNow;
							RankedLog.Info($"[ModAllowlist] Whitelist geladen: {num} Eintrag(e).");
						}
					}
					catch (Exception ex)
					{
						RankedLog.Warning("[ModAllowlist] Antwort nicht parsebar: " + ex.Message);
					}
				}
				else
				{
					RankedLog.Warning($"[ModAllowlist] Server nicht erreichbar ({request.responseCode} {request.error}) - " + ((Allowed.Count > 0) ? "die bisherige Liste bleibt aktiv." : "Whitelist leer, die Quarantaene laesst nichts durch."));
				}
				_fetchInProgress = false;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	public class ModEntry
	{
		public string guid;

		public string name;

		public string version;
	}
	public static class ModInventory
	{
		private static List<ModEntry> _mods;

		private static string _hash;

		public static List<ModEntry> GetMods()
		{
			EnsureCollected();
			return _mods;
		}

		public static string GetModSetHash()
		{
			EnsureCollected();
			return _hash;
		}

		private static void EnsureCollected()
		{
			if (_mods != null)
			{
				return;
			}
			List<ModEntry> list = new List<ModEntry>();
			try
			{
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					PluginInfo value = pluginInfo.Value;
					BepInPlugin val = ((value != null) ? value.Metadata : null);
					if (val != null)
					{
						list.Add(new ModEntry
						{
							guid = val.GUID,
							name = Shorten(val.Name, 60),
							version = ((val.Version != null) ? val.Version.ToString(3) : string.Empty)
						});
					}
				}
				list.Sort((ModEntry a, ModEntry b) => string.CompareOrdinal(a.guid, b.guid));
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[ModInventory] Plugin-Liste nicht lesbar: " + ex.Message);
			}
			_mods = list;
			_hash = ComputeHash(list);
			RankedLog.Info(string.Format("[ModInventory] {0} Plugin(s) geladen (Satz {1}): ", list.Count, (_hash.Length > 0) ? _hash : "unbekannt") + string.Join(", ", list.ConvertAll((ModEntry m) => m.guid + "@" + m.version).ToArray()));
		}

		private static string ComputeHash(List<ModEntry> mods)
		{
			if (mods.Count == 0)
			{
				return string.Empty;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				foreach (ModEntry mod in mods)
				{
					stringBuilder.Append(mod.guid).Append('@').Append(mod.version)
						.Append(';');
				}
				using SHA256 sHA = SHA256.Create();
				byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(stringBuilder.ToString()));
				StringBuilder stringBuilder2 = new StringBuilder(16);
				for (int i = 0; i < 8; i++)
				{
					stringBuilder2.Append(array[i].ToString("x2", CultureInfo.InvariantCulture));
				}
				return stringBuilder2.ToString();
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[ModInventory] Fingerabdruck fehlgeschlagen: " + ex.Message);
				return string.Empty;
			}
		}

		private static string Shorten(string value, int max)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			if (value.Length > max)
			{
				return value.Substring(0, max);
			}
			return value;
		}
	}
	public static class ModQuarantine
	{
		private class CapturedPatch
		{
			public MethodBase Method;

			public HarmonyPatchType Kind;

			public MethodInfo PatchMethod;

			public int Priority;

			public string[] Before;

			public string[] After;

			public bool Debug;
		}

		private static readonly string QuarantineId = "com.rankedpeak.mod.quarantine";

		private static readonly Harmony _harmony = new Harmony(QuarantineId);

		private static readonly List<CapturedPatch> _captured = new List<CapturedPatch>();

		private static readonly List<BaseUnityPlugin> _disabledPlugins = new List<BaseUnityPlugin>();

		private static readonly Dictionary<MethodInfo, string> _foreignOwners = new Dictionary<MethodInfo, string>();

		public static bool IsEngaged { get; private set; }

		public static void Engage()
		{
			if (IsEngaged)
			{
				return;
			}
			IsEngaged = true;
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			try
			{
				foreach (MethodBase item in Harmony.GetAllPatchedMethods().ToList())
				{
					Patches patchInfo;
					try
					{
						patchInfo = Harmony.GetPatchInfo(item);
					}
					catch (Exception ex)
					{
						RankedLog.Warning("[ModQuarantine] Patch-Info fuer '" + item.Name + "' nicht lesbar: " + ex.Message);
						continue;
					}
					if (patchInfo != null)
					{
						num += CaptureAndRemove(item, patchInfo.Prefixes, (HarmonyPatchType)1);
						num += CaptureAndRemove(item, patchInfo.Postfixes, (HarmonyPatchType)2);
						num += CaptureAndRemove(item, patchInfo.Transpilers, (HarmonyPatchType)3);
						num += CaptureAndRemove(item, patchInfo.Finalizers, (HarmonyPatchType)4);
					}
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[ModQuarantine] Patch-Erfassung fehlgeschlagen: {arg}");
			}
			try
			{
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					PluginInfo value = pluginInfo.Value;
					BepInPlugin val = ((value != null) ? value.Metadata : null);
					if (val == null || val.GUID == "com.rankedpeak.mod")
					{
						continue;
					}
					if (ModAllowlistService.IsAllowed(val.GUID))
					{
						num3++;
						continue;
					}
					BaseUnityPlugin instance = pluginInfo.Value.Instance;
					if (!((Object)(object)instance == (Object)null) && ((Behaviour)instance).enabled)
					{
						try
						{
							((MonoBehaviour)instance).StopAllCoroutines();
							((Behaviour)instance).enabled = false;
							_disabledPlugins.Add(instance);
							num2++;
						}
						catch (Exception ex2)
						{
							RankedLog.Warning("[ModQuarantine] Plugin '" + val.GUID + "' nicht deaktivierbar: " + ex2.Message);
						}
					}
				}
			}
			catch (Exception arg2)
			{
				RankedLog.Error($"[ModQuarantine] Plugin-Stilllegung fehlgeschlagen: {arg2}");
			}
			RankedLog.Info($"[ModQuarantine] Scharf: {num} fremde(r) Harmony-Patch(es) geloest, " + $"{num2} Plugin(s) deaktiviert, {num3} per Whitelist erlaubt.");
		}

		public static void Release()
		{
			//IL_002e: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected I4, but got Unknown
			if (!IsEngaged)
			{
				return;
			}
			IsEngaged = false;
			int num = 0;
			foreach (CapturedPatch item in _captured)
			{
				try
				{
					HarmonyMethod val = new HarmonyMethod(item.PatchMethod)
					{
						priority = item.Priority,
						before = item.Before,
						after = item.After,
						debug = item.Debug
					};
					HarmonyPatchType kind = item.Kind;
					switch (kind - 1)
					{
					case 0:
						_harmony.Patch(item.Method, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						break;
					case 1:
						_harmony.Patch(item.Method, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						break;
					case 2:
						_harmony.Patch(item.Method, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
						break;
					case 3:
						_harmony.Patch(item.Method, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null);
						break;
					}
					num++;
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[ModQuarantine] Patch " + Describe(item.PatchMethod) + " nicht wieder anwendbar: " + ex.Message);
				}
			}
			_captured.Clear();
			int num2 = 0;
			foreach (BaseUnityPlugin disabledPlugin in _disabledPlugins)
			{
				try
				{
					if ((Object)(object)disabledPlugin != (Object)null)
					{
						((Behaviour)disabledPlugin).enabled = true;
						num2++;
					}
				}
				catch (Exception ex2)
				{
					RankedLog.Warning("[ModQuarantine] Plugin nicht reaktivierbar: " + ex2.Message);
				}
			}
			_disabledPlugins.Clear();
			RankedLog.Info($"[ModQuarantine] Gelockert: {num} Patch(es) wieder angewendet, {num2} Plugin(s) wieder aktiv.");
		}

		private static int CaptureAndRemove(MethodBase method, IEnumerable<Patch> patches, HarmonyPatchType kind)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (Patch patch in patches)
			{
				if (patch.PatchMethod == null)
				{
					continue;
				}
				string text = patch.owner;
				if (text == "com.rankedpeak.mod" || text == QuarantineId)
				{
					if (!_foreignOwners.TryGetValue(patch.PatchMethod, out var value))
					{
						continue;
					}
					text = value;
				}
				if (!ModAllowlistService.IsAllowed(text))
				{
					_captured.Add(new CapturedPatch
					{
						Method = method,
						Kind = kind,
						PatchMethod = patch.PatchMethod,
						Priority = patch.priority,
						Before = patch.before,
						After = patch.after,
						Debug = patch.debug
					});
					_foreignOwners[patch.PatchMethod] = text;
					try
					{
						_harmony.Unpatch(method, patch.PatchMethod);
						num++;
					}
					catch (Exception ex)
					{
						RankedLog.Warning("[ModQuarantine] Patch " + Describe(patch.PatchMethod) + " auf '" + method.Name + "' nicht loesbar: " + ex.Message);
					}
				}
			}
			return num;
		}

		private static string Describe(MethodInfo method)
		{
			return method.DeclaringType?.FullName + "." + method.Name;
		}
	}
	public static class RaceInputLock
	{
		public static bool IsLocked { get; private set; }

		public static void Lock()
		{
			if (!IsLocked)
			{
				IsLocked = true;
				RankedLog.Info("[RaceInputLock] Steuerung und Kamera gesperrt (Menü bleibt frei).");
			}
		}

		public static void Unlock()
		{
			if (IsLocked)
			{
				IsLocked = false;
				RankedLog.Info("[RaceInputLock] Steuerung freigegeben - die Zeit läuft.");
			}
		}

		public static void ForceUnlock(string reason)
		{
			if (IsLocked)
			{
				RankedLog.Warning("[RaceInputLock] Zwangsfreigabe: " + reason);
				Unlock();
			}
		}
	}
	public static class RaceProgress
	{
		private static float _baseline;

		private static bool _hasBaseline;

		private static float _maxProgress;

		private static bool _singleSegment;

		public static void SetRoute(int routeIndex)
		{
			_singleSegment = routeIndex > 0;
			RankedLog.Info("[RaceProgress] Bezugsgroesse: " + (_singleSegment ? "einzelner Abschnitt" : "ganzer Berg") + ".");
		}

		public static void Reset()
		{
			_baseline = 0f;
			_hasBaseline = false;
			_maxProgress = 0f;
		}

		public static float Current()
		{
			float num = RawProgress();
			if (num < 0f)
			{
				return -1f;
			}
			if (!_hasBaseline)
			{
				_baseline = num;
				_hasBaseline = true;
				RankedLog.Info($"[RaceProgress] Nullpunkt gesetzt (roh {num:0.000}).");
			}
			float num2 = 1f - _baseline;
			float num3 = ((num2 > 0.001f) ? ((num - _baseline) / num2) : num);
			_maxProgress = Mathf.Max(_maxProgress, Mathf.Clamp01(num3));
			return _maxProgress;
		}

		private static float RawProgress()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Character localCharacter = Character.localCharacter;
				if ((Object)(object)localCharacter == (Object)null)
				{
					return -1f;
				}
				MountainProgressHandler instance = Singleton<MountainProgressHandler>.Instance;
				ProgressPoint[] array = (((Object)(object)instance != (Object)null) ? instance.progressPoints : null);
				if (array == null || array.Length < 2)
				{
					return -1f;
				}
				float y = localCharacter.Center.y;
				int num = Mathf.Clamp(instance.maxProgressPointReached, 0, array.Length - 1);
				int num2 = array.Length - 1;
				if (num >= num2)
				{
					return 1f;
				}
				ProgressPoint val = array[num];
				ProgressPoint val2 = array[num + 1];
				float num3 = (((Object)(object)val?.transform != (Object)null) ? val.transform.position.y : float.NaN);
				float num4 = (((Object)(object)val2?.transform != (Object)null) ? val2.transform.position.y : float.NaN);
				if (float.IsNaN(num3) || float.IsNaN(num4) || Mathf.Approximately(num4, num3))
				{
					return Mathf.Clamp01((float)num / (float)num2);
				}
				float num5 = Mathf.Clamp01((y - num3) / (num4 - num3));
				return _singleSegment ? num5 : Mathf.Clamp01(((float)num + num5) / (float)num2);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RaceProgress] Nicht ermittelbar: " + ex.Message);
				return -1f;
			}
		}
	}
	public class RaceParticipant
	{
		public string SteamId { get; set; } = string.Empty;

		public string PlayerName { get; set; } = string.Empty;

		public string State { get; set; } = "joined";

		public int? Rank { get; set; }

		public long? TotalMs { get; set; }

		public float Progress { get; set; }

		public float? Health { get; set; }

		public float? Stamina { get; set; }

		public float? ExtraStamina { get; set; }

		public int? HandItem { get; set; }

		public int? TopStatus { get; set; }

		public int[] Belt { get; set; }

		public int? BackpackType { get; set; }

		public int? BackpackSlots { get; set; }

		public int[] Pack { get; set; }
	}
	public class RaceInfo
	{
		public string InviteCode { get; set; } = string.Empty;

		public string HostSteamId { get; set; } = string.Empty;

		public string Mode { get; set; } = "CustomRace";

		public int Seed { get; set; }

		public int LevelIndex { get; set; }

		public int Ascent { get; set; }

		public int Route { get; set; }

		public int MaxPlayers { get; set; }

		public bool AutoStart { get; set; }

		public bool GhostsVisible { get; set; }

		public bool SecretSeed { get; set; }

		public string Status { get; set; } = "lobby";

		public long? StartAt { get; set; }

		public List<RaceParticipant> Participants { get; } = new List<RaceParticipant>();
	}
	public class RaceService : MonoBehaviour
	{
		private const float LobbyPollSeconds = 1.5f;

		private const float CountdownPollSeconds = 0.35f;

		private const float ProgressReportSeconds = 1f;

		private const float SocketWatchdogSeconds = 20f;

		private readonly Dictionary<byte, uint> _mergedTime = new Dictionary<byte, uint>();

		private long _serverClockOffsetMs;

		private bool _hasClockOffset;

		private Coroutine _pollRoutine;

		private bool _raceReadySent;

		private bool _startApplied;

		private float _nextProgressReport;

		private DateTime _raceLoadUtc;

		public static RaceService Instance { get; private set; }

		public RaceInfo CurrentRace { get; private set; }

		public RaceInfo LastFinishedRace { get; private set; }

		public bool InRace => CurrentRace != null;

		public bool IsHost
		{
			get
			{
				if (CurrentRace != null)
				{
					return CurrentRace.HostSteamId == SteamIdentity.GetSteamId64();
				}
				return false;
			}
		}

		public long? MsUntilStart
		{
			get
			{
				RaceInfo currentRace = CurrentRace;
				if (currentRace != null && currentRace.StartAt.HasValue)
				{
					return CurrentRace.StartAt.Value - ServerNowMs();
				}
				return null;
			}
		}

		public static event Action<RaceInfo> RaceUpdated;

		private void Awake()
		{
			Instance = this;
			RaceLiveConnection.ServerState += OnServerState;
		}

		private void OnDestroy()
		{
			RaceLiveConnection.ServerState -= OnServerState;
		}

		private void OnServerState(JObject json)
		{
			if (CurrentRace != null && json != null)
			{
				ApplyState(((JToken)json).ToString((Formatting)0, Array.Empty<JsonConverter>()));
			}
		}

		private long ServerNowMs()
		{
			return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + _serverClockOffsetMs;
		}

		public void CreateRace(int seed, int levelIndex, int ascent, int route, int maxPlayers, bool autoStart, bool ghostsVisible, bool secretSeed, Action<RaceInfo> onSuccess, Action<string> onError)
		{
			//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_001a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: 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)
			//IL_00fc: Expected O, but got Unknown
			JObject payload = new JObject
			{
				["hostSteamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()),
				["playerName"] = JToken.op_Implicit(ReadPlayerName()),
				["mode"] = JToken.op_Implicit("CustomRace"),
				["seed"] = JToken.op_Implicit(seed),
				["levelIndex"] = JToken.op_Implicit(levelIndex),
				["ascent"] = JToken.op_Implicit(ascent),
				["route"] = JToken.op_Implicit(route),
				["maxPlayers"] = JToken.op_Implicit(maxPlayers),
				["autoStart"] = JToken.op_Implicit(autoStart),
				["ghostsVisible"] = JToken.op_Implicit(ghostsVisible),
				["secretSeed"] = JToken.op_Implicit(secretSeed),
				["gameVersion"] = JToken.op_Implicit(MapCatalog.GameVersion),
				["mapSetHash"] = JToken.op_Implicit(MapCatalog.MapSetHash)
			};
			((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races", payload, onSuccess, onError));
		}

		public void UpdateRaceConfig(int seed, int levelIndex, int ascent, int route, int maxPlayers, bool autoStart, bool ghostsVisible, bool secretSeed, Action<string> onError)
		{
			//IL_0028: 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_0042: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			if (CurrentRace != null && IsHost && !(CurrentRace.Status != "lobby"))
			{
				JObject payload = new JObject
				{
					["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()),
					["seed"] = JToken.op_Implicit(seed),
					["levelIndex"] = JToken.op_Implicit(levelIndex),
					["ascent"] = JToken.op_Implicit(ascent),
					["route"] = JToken.op_Implicit(route),
					["maxPlayers"] = JToken.op_Implicit(maxPlayers),
					["autoStart"] = JToken.op_Implicit(autoStart),
					["ghostsVisible"] = JToken.op_Implicit(ghostsVisible),
					["secretSeed"] = JToken.op_Implicit(secretSeed)
				};
				((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + CurrentRace.InviteCode + "/config", payload, null, onError));
			}
		}

		public void JoinRace(string inviteCode, Action<RaceInfo> onSuccess, Action<string> onError)
		{
			//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_001a: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			JObject payload = new JObject
			{
				["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()),
				["playerName"] = JToken.op_Implicit(ReadPlayerName()),
				["gameVersion"] = JToken.op_Implicit(MapCatalog.GameVersion),
				["mapSetHash"] = JToken.op_Implicit(MapCatalog.MapSetHash)
			};
			((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + inviteCode.ToUpperInvariant() + "/join", payload, onSuccess, onError));
		}

		public void LeaveRace()
		{
			//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_0030: Expected O, but got Unknown
			if (CurrentRace != null)
			{
				string inviteCode = CurrentRace.InviteCode;
				JObject payload = new JObject { ["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()) };
				((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + inviteCode + "/leave", payload, null, null, applyResponse: false));
				StopRace("selbst verlassen");
			}
		}

		public void StartRace(Action<string> onError)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (CurrentRace != null && IsHost)
			{
				JObject payload = new JObject { ["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()) };
				((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + CurrentRace.InviteCode + "/start", payload, null, onError));
			}
		}

		private void BeginPolling()
		{
			if (_pollRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_pollRoutine);
			}
			_pollRoutine = ((MonoBehaviour)this).StartCoroutine(PollRoutine());
		}

		private IEnumerator PollRoutine()
		{
			while (CurrentRace != null)
			{
				RaceLiveConnection instance = RaceLiveConnection.Instance;
				bool onSocket = (Object)(object)instance != (Object)null && instance.IsConnected;
				if (!onSocket)
				{
					yield return FetchRoutine();
				}
				float num = (onSocket ? 20f : ((!(CurrentRace?.StartAt.HasValue ?? false) || !(MsUntilStart > 0)) ? 1.5f : 0.35f));
				yield return (object)new WaitForSecondsRealtime(num);
			}
			_pollRoutine = null;
		}

		private IEnumerator FetchRoutine()
		{
			if (CurrentRace == null)
			{
				yield break;
			}
			string text = "https://followme-peak.ddns.net/ranked/races/" + CurrentRace.InviteCode;
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					RankedLog.Warning("[Race] Zustand nicht abrufbar: " + request.error);
				}
				else
				{
					ApplyState(request.downloadHandler.text);
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private void ApplyState(string json)
		{
			RaceInfo raceInfo;
			try
			{
				raceInfo = ParseState(json);
			}
			catch (Exception ex)
			{
				RankedLog.Error("[Race] Zustand nicht lesbar: " + ex.Message);
				return;
			}
			string text = CurrentRace?.Status;
			CurrentRace = raceInfo;
			if (!string.IsNullOrEmpty(raceInfo.InviteCode))
			{
				RaceLiveConnection.Instance?.Connect(raceInfo.InviteCode);
			}
			if (text != raceInfo.Status)
			{
				RankedLog.Info("[Race " + raceInfo.InviteCode + "] Status: " + (text ?? "-") + " -> " + raceInfo.Status);
				OnStatusChanged(raceInfo);
			}
			RaceService.RaceUpdated?.Invoke(raceInfo);
		}

		private void OnStatusChanged(RaceInfo race)
		{
			switch (race.Status)
			{
			case "loading":
				LoadRaceLevel(race);
				break;
			case "countdown":
				RankedLog.Info($"[Race] Countdown laeuft - Start in {MsUntilStart} ms.");
				break;
			case "finished":
				RaceInputLock.ForceUnlock("Race beendet");
				LastFinishedRace = race;
				StopRace("Rennen beendet");
				break;
			}
		}

		private void LoadRaceLevel(RaceInfo race)
		{
			_raceReadySent = false;
			_startApplied = false;
			_raceLoadUtc = DateTime.UtcNow;
			SeedService.Instance?.SetOverrideSeed(race.Seed);
			if (!RankedRunGate.Select(GameMode.LiveRace, race.LevelIndex))
			{
				SeedService.Instance?.ClearOverrideSeed();
				RankedNoticeModal.Show(Loc.T("gate.mapAltered.title"), RankedRunGate.LastRefusal);
				return;
			}
			RunConfigService.ApplyCustomRun(race.Ascent, race.Route);
			GhostPlaybackService.Instance?.ClearExternalGhost();
			RankedGameLauncher.ForceLevelIndex(race.LevelIndex);
			RaceProgress.SetRoute(race.Route);
			if (!TryStartFromAirport(race))
			{
				RankedGameLauncher.LaunchDirectToIsland();
			}
			((MonoBehaviour)this).StartCoroutine(ReportRaceReadyWhenLoaded());
		}

		private bool TryStartFromAirport(RaceInfo race)
		{
			try
			{
				AirportCheckInKiosk val = Object.FindAnyObjectByType<AirportCheckInKiosk>();
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				RankedLog.Info($"[Race] Start aus dem Flughafen ueber den Check-in-Kiosk (Ascent {race.Ascent}).");
				val.StartGame(race.Ascent);
				return true;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Race] Kiosk-Start fehlgeschlagen (" + ex.Message + ") - nutze den Menue-Weg.");
				return false;
			}
		}

		public void EnterWaitingArea()
		{
			if (CurrentRace != null)
			{
				RankedLog.Info("[Race] Wechsle in den Flughafen (Wartebereich).");
				RankedGameLauncher.LaunchToAirport();
			}
		}

		private IEnumerator ReportRaceReadyWhenLoaded()
		{
			float timeout = Time.realtimeSinceStartup + 180f;
			string lastReason = string.Empty;
			bool ready = false;
			while (Time.realtimeSinceStartup < timeout)
			{
				if (CurrentRace == null)
				{
					yield break;
				}
				string text = NotReadyReason();
				if (text == null)
				{
					ready = true;
					break;
				}
				if (text != lastReason)
				{
					lastReason = text;
					RankedLog.Info("[Race] Noch nicht bereit: " + text);
				}
				yield return (object)new WaitForSecondsRealtime(0.25f);
			}
			if (_raceReadySent || CurrentRace == null)
			{
				yield break;
			}
			if (!ready)
			{
				RankedLog.Warning("[Race] Nach 180 s nicht spielbereit (zuletzt: " + lastReason + ") - verlasse das Rennen.");
				RankedNoticeModal.Show(Loc.T("race.loadFailed.title"), Loc.T("race.loadFailed"));
				LeaveRace();
				yield break;
			}
			RaceInputLock.Lock();
			_raceReadySent = true;
			JObject payload = new JObject { ["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()) };
			yield return PostRoutine("/ranked/races/" + CurrentRace.InviteCode + "/race-ready", payload, null, delegate(string err)
			{
				RankedLog.Warning("[Race] race-ready fehlgeschlagen: " + err);
			});
			RankedLog.Info("[Race] Spielbereit, race-ready gemeldet - warte auf die anderen.");
		}

		private string NotReadyReason()
		{
			RaceTimer instance = RaceTimer.Instance;
			if (instance == null || instance.State != TimerState.WaitingForInput)
			{
				return "Level laedt noch";
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter == (Object)null)
			{
				return "Figur noch nicht gespawnt";
			}
			try
			{
				CharacterData data = localCharacter.data;
				if ((Object)(object)data == (Object)null)
				{
					return "Figurdaten fehlen";
				}
				if (data.dead)
				{
					return "Figur ist tot";
				}
				if (data.passedOutOnTheBeach > 0f)
				{
					return $"Aufwach-Animation laeuft ({data.passedOutOnTheBeach:0.0} s)";
				}
				if (data.passedOut || data.fullyPassedOut)
				{
					return "Figur ist bewusstlos";
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Race] Bereitschaft nicht pruefbar (" + ex.Message + ") - gilt als bereit.");
				return null;
			}
			return null;
		}

		private void Update()
		{
			if (CurrentRace == null)
			{
				return;
			}
			ReleaseWhenStartReached();
			MergeLiveStates();
			if (IsRunningNow())
			{
				RaceLiveConnection instance = RaceLiveConnection.Instance;
				if ((Object)(object)instance != (Object)null && instance.IsConnected)
				{
					ReportProgress();
				}
				else if (Time.realtimeSinceStartup >= _nextProgressReport)
				{
					_nextProgressReport = Time.realtimeSinceStartup + 1f;
					ReportProgress();
				}
			}
		}

		private void ReleaseWhenStartReached()
		{
			if (!_startApplied && CurrentRace.StartAt.HasValue && !(MsUntilStart > 0))
			{
				_startApplied = true;
				RaceProgress.Reset();
				RaceInputLock.Unlock();
				RaceTimer.Instance?.BeginRun();
				_nextProgressReport = Time.realtimeSinceStartup + 1f;
				RankedLog.Info("[Race] Start!");
			}
		}

		private void ReportProgress()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			float num = RaceProgress.Current();
			if (num < 0f)
			{
				return;
			}
			RaceLiveConnection instance = RaceLiveConnection.Instance;
			if ((Object)(object)instance != (Object)null && instance.IsConnected)
			{
				if (instance.SampleDue())
				{
					RaceParticipant raceParticipant = FindSelf();
					LiveState state = LiveFrame.SampleLocal((uint)Mathf.Max(0f, (float)((RaceTimer.Instance != null) ? RaceTimer.Instance.CurrentElapsedMs : 0)), num, instance.GhostsVisible, raceParticipant?.State ?? "running", (raceParticipant?.Rank).GetValueOrDefault());
					instance.SendState(state);
					ApplyToSelf(state);
				}
			}
			else
			{
				JObject payload = new JObject
				{
					["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()),
					["progress"] = JToken.op_Implicit(num)
				};
				AddTelemetry(payload);
				((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + CurrentRace.InviteCode + "/progress", payload, null, null));
			}
		}

		private bool IsRunningNow()
		{
			if (CurrentRace == null)
			{
				return false;
			}
			if (CurrentRace.Status == "running")
			{
				return true;
			}
			if (CurrentRace.Status == "countdown" && CurrentRace.StartAt.HasValue)
			{
				return MsUntilStart <= 0;
			}
			return false;
		}

		private void MergeLiveStates()
		{
			RaceLiveConnection instance = RaceLiveConnection.Instance;
			if ((Object)(object)instance == (Object)null || !instance.IsConnected || CurrentRace == null)
			{
				return;
			}
			bool flag = false;
			foreach (KeyValuePair<byte, LiveState> peer in instance.Peers)
			{
				if (!instance.PeerSteamIds.TryGetValue(peer.Key, out var value) || string.IsNullOrEmpty(value) || (_mergedTime.TryGetValue(peer.Key, out var value2) && value2 == peer.Value.TimeMs))
				{
					continue;
				}
				_mergedTime[peer.Key] = peer.Value.TimeMs;
				flag = true;
				foreach (RaceParticipant participant in CurrentRace.Participants)
				{
					if (!(participant.SteamId != value))
					{
						LiveState value3 = peer.Value;
						byte[] array = value3.ToBars();
						participant.Progress = value3.ProgressFraction;
						participant.Stamina = (float)(int)value3.Stamina / 255f;
						participant.ExtraStamina = (float)(int)value3.ExtraStamina / 255f;
						participant.Health = GhostStateTrack.HealthFrom(array);
						participant.HandItem = value3.Item;
						participant.TopStatus = TopStatusOf(array);
						participant.Belt = ToIntArray(value3.Belt);
						participant.BackpackType = value3.BackpackType;
						participant.BackpackSlots = value3.BackpackSlots;
						participant.Pack = ToIntArray(value3.Pack);
						string text = LiveFrame.StateName(value3.State);
						if (participant.State != "finished" && participant.State != "dnf" && (text == "running" || text == "race_ready"))
						{
							participant.State = text;
						}
						if (value3.Rank > 0)
						{
							participant.Rank = value3.Rank;
						}
						break;
					}
				}
			}
			if (flag)
			{
				RaceService.RaceUpdated?.Invoke(CurrentRace);
			}
		}

		private void ApplyToSelf(LiveState state)
		{
			RaceParticipant raceParticipant = FindSelf();
			if (raceParticipant != null)
			{
				byte[] array = state.ToBars();
				raceParticipant.Progress = state.ProgressFraction;
				raceParticipant.Stamina = (float)(int)state.Stamina / 255f;
				raceParticipant.ExtraStamina = (float)(int)state.ExtraStamina / 255f;
				raceParticipant.Health = GhostStateTrack.HealthFrom(array);
				raceParticipant.HandItem = state.Item;
				raceParticipant.TopStatus = TopStatusOf(array);
				raceParticipant.Belt = ToIntArray(state.Belt);
				raceParticipant.BackpackType = state.BackpackType;
				raceParticipant.BackpackSlots = state.BackpackSlots;
				raceParticipant.Pack = ToIntArray(state.Pack);
				if (raceParticipant.State == "race_ready")
				{
					raceParticipant.State = "running";
				}
			}
		}

		private static int[] ToIntArray(ushort[] values)
		{
			int[] array = new int[values.Length];
			for (int i = 0; i < values.Length; i++)
			{
				array[i] = values[i];
			}
			return array;
		}

		private static int TopStatusOf(byte[] bars)
		{
			int result = -1;
			float num = 0.05f;
			for (int i = 0; i < GhostStateTrack.StatusCount; i++)
			{
				float num2 = GhostStateTrack.StatusFrom(bars, (STATUSTYPE)i);
				if (num2 > num)
				{
					num = num2;
					result = i;
				}
			}
			return result;
		}

		private RaceParticipant FindSelf()
		{
			if (CurrentRace == null)
			{
				return null;
			}
			string steamId = SteamIdentity.GetSteamId64();
			foreach (RaceParticipant participant in CurrentRace.Participants)
			{
				if (participant.SteamId == steamId)
				{
					return participant;
				}
			}
			return null;
		}

		private static void AddTelemetry(JObject payload)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00e1: 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)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			try
			{
				byte[] sample = GhostStateTrack.SampleBars();
				payload["health"] = JToken.op_Implicit(GhostStateTrack.HealthFrom(sample));
				payload["stamina"] = JToken.op_Implicit(GhostStateTrack.StaminaFrom(sample));
				payload["extraStamina"] = JToken.op_Implicit(GhostStateTrack.ExtraStaminaFrom(sample));
				InventorySnapshot inventorySnapshot = GhostStateTrack.SampleInventory(0L);
				payload["handItem"] = JToken.op_Implicit(inventorySnapshot.Hand);
				JArray val = new JArray();
				val.Add(JToken.op_Implicit(inventorySnapshot.Belt[0]));
				val.Add(JToken.op_Implicit(inventorySnapshot.Belt[1]));
				val.Add(JToken.op_Implicit(inventorySnapshot.Belt[2]));
				payload["belt"] = (JToken)val;
				payload["backpackType"] = JToken.op_Implicit(inventorySnapshot.BackpackType);
				payload["backpackSlots"] = JToken.op_Implicit(inventorySnapshot.BackpackSlots);
				JArray val2 = new JArray();
				val2.Add(JToken.op_Implicit(inventorySnapshot.BackpackItems[0]));
				val2.Add(JToken.op_Implicit(inventorySnapshot.BackpackItems[1]));
				val2.Add(JToken.op_Implicit(inventorySnapshot.BackpackItems[2]));
				val2.Add(JToken.op_Implicit(inventorySnapshot.BackpackItems[3]));
				payload["pack"] = (JToken)val2;
				int num = -1;
				float num2 = 0.05f;
				for (int i = 0; i < GhostStateTrack.StatusCount; i++)
				{
					float num3 = GhostStateTrack.StatusFrom(sample, (STATUSTYPE)i);
					if (num3 > num2)
					{
						num2 = num3;
						num = i;
					}
				}
				payload["topStatus"] = JToken.op_Implicit(num);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Race] Telemetrie nicht lesbar: " + ex.Message);
			}
		}

		private static float? OptionalFloat(JToken token)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (token != null && (int)token.Type != 10)
			{
				return Extensions.Value<float>((IEnumerable<JToken>)token);
			}
			return null;
		}

		private static int? OptionalInt(JToken token)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (token != null && (int)token.Type != 10)
			{
				return Extensions.Value<int>((IEnumerable<JToken>)token);
			}
			return null;
		}

		private static int[] OptionalIntArray(JToken token)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (token == null || (int)token.Type != 2)
			{
				return null;
			}
			List<int> list = new List<int>();
			foreach (JToken item in (IEnumerable<JToken>)token)
			{
				list.Add(((int)item.Type == 10) ? 65535 : Extensions.Value<int>((IEnumerable<JToken>)item));
			}
			return list.ToArray();
		}

		public void ReportFinish(RunRecord record)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			if (CurrentRace == null || record == null)
			{
				return;
			}
			if (_raceLoadUtc != default(DateTime) && record.StartTimeUtc != default(DateTime) && record.StartTimeUtc < _raceLoadUtc)
			{
				RankedLog.Warning($"[Race] Ergebnis verworfen: Run begann um {record.StartTimeUtc:HH:mm:ss} UTC, " + $"vor dem Laden dieses Races ({_raceLoadUtc:HH:mm:ss} UTC) - stammt aus einem frueheren Kontext.");
				return;
			}
			JArray val = new JArray();
			foreach (SplitRecord split in record.Splits)
			{
				val.Add((JToken)new JObject
				{
					["SegmentName"] = JToken.op_Implicit(split.SegmentName),
					["ElapsedMs"] = JToken.op_Implicit(split.ElapsedMs)
				});
			}
			JObject val2 = new JObject
			{
				["steamId"] = JToken.op_Implicit(SteamIdentity.GetSteamId64()),
				["result"] = JToken.op_Implicit(record.Result.ToString()),
				["totalMs"] = JToken.op_Implicit(record.TotalMs),
				["splits"] = (JToken)(object)val,
				["modVersion"] = JToken.op_Implicit("0.10.3"),
				["startTimeUtc"] = JToken.op_Implicit((record.StartTimeUtc == default(DateTime)) ? null : record.StartTimeUtc.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture))
			};
			try
			{
				if (record.Integrity != null)
				{
					val2["integrityData"] = (JToken)(object)JObject.FromObject((object)record.Integrity);
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Race] Sentinel-Strom nicht anhaengbar: " + ex.Message);
			}
			((MonoBehaviour)this).StartCoroutine(PostRoutine("/ranked/races/" + CurrentRace.InviteCode + "/finish", val2, null, delegate(string err)
			{
				RankedLog.Warning("[Race] Ergebnis-Meldung fehlgeschlagen: " + err);
			}));
		}

		public void StopRace(string reason)
		{
			if (CurrentRace != null)
			{
				RankedLog.Info("[Race] Freigegeben (" + reason + ").");
				RaceLiveConnection.Instance?.Disconnect(reason);
				CurrentRace = null;
				_raceReadySent = false;
				_startApplied = false;
				if (RaceTimer.Instance != null && RaceTimer.Instance.State == TimerState.WaitingForInput)
				{
					RaceTimer.Instance.AbortRun();
				}
				RaceInputLock.ForceUnlock(reason);
				RaceService.RaceUpdated?.Invoke(null);
			}
		}

		public static void ResetGameSettings()
		{
			RankedGameLauncher.ClearForcedLevel();
			RunConfigService.ResetToRankedDefaults();
			SeedService.Instance?.ClearOverrideSeed();
		}

		private static string ExtractErrorMessage(string body)
		{
			if (string.IsNullOrEmpty(body))
			{
				return null;
			}
			try
			{
				JObject val = JObject.Parse(body);
				string text = ((object)val["message"])?.ToString();
				return (!string.IsNullOrEmpty(text)) ? text : ((object)val["error"])?.ToString();
			}
			catch
			{
				return body;
			}
		}

		private IEnumerator PostRoutine(string path, JObject payload, Action<RaceInfo> onSuccess, Action<string> onError, bool applyResponse = true)
		{
			string text = "https://followme-peak.ddns.net" + path;
			UnityWebRequest request = new UnityWebRequest(text, "POST");
			try
			{
				byte[] bytes = Encoding.UTF8.GetBytes(((JToken)payload).ToString((Formatting)0, Array.Empty<JsonConverter>()));
				request.uploadHandler = (UploadHandler)new UploadHandlerRaw(bytes);
				request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				request.SetRequestHeader("Content-Type", "application/json");
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					string text2 = ((request.downloadHandler != null) ? request.downloadHandler.text : null);
					string obj = ExtractErrorMessage(text2) ?? request.error;
					RankedLog.Warning("[Race] POST " + path + " fehlgeschlagen: " + (text2 ?? request.error));
					onError?.Invoke(obj);
				}
				else if (applyResponse)
				{
					ApplyState(request.downloadHandler.text);
					if (CurrentRace != null && _pollRoutine == null)
					{
						BeginPolling();
					}
					onSuccess?.Invoke(CurrentRace);
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private RaceInfo ParseState(string json)
		{
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Invalid comparison between Unknown and I4
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Invalid comparison between Unknown and I4
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Invalid comparison between Unknown and I4
			JObject obj = JObject.Parse(json);
			JToken obj2 = obj["serverNow"];
			long? num = ((obj2 != null) ? new long?(Extensions.Value<long>((IEnumerable<JToken>)obj2)) : ((long?)null));
			if (num.HasValue && !_hasClockOffset)
			{
				_serverClockOffsetMs = num.Value - DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
				_hasClockOffset = true;
				RankedLog.Info($"[Race] Uhrenversatz zum Server: {_serverClockOffsetMs} ms.");
			}
			JToken val = obj["race"];
			RaceInfo obj3 = new RaceInfo
			{
				InviteCode = (((val == null) ? null : ((object)val[(object)"inviteCode"])?.ToString()) ?? string.Empty),
				HostSteamId = (((val == null) ? null : ((object)val[(object)"hostSteamId"])?.ToString()) ?? string.Empty),
				Mode = (((val == null) ? null : ((object)val[(object)"mode"])?.ToString()) ?? "CustomRace")
			};
			int? obj4;
			if (val == null)
			{
				obj4 = null;
			}
			else
			{
				JToken obj5 = val[(object)"seed"];
				obj4 = ((obj5 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj5)) : ((int?)null));
			}
			int? num2 = obj4;
			obj3.Seed = num2.GetValueOrDefault();
			int? obj6;
			if (val == null)
			{
				obj6 = null;
			}
			else
			{
				JToken obj7 = val[(object)"levelIndex"];
				obj6 = ((obj7 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj7)) : ((int?)null));
			}
			num2 = obj6;
			obj3.LevelIndex = num2.GetValueOrDefault();
			int? obj8;
			if (val == null)
			{
				obj8 = null;
			}
			else
			{
				JToken obj9 = val[(object)"ascent"];
				obj8 = ((obj9 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj9)) : ((int?)null));
			}
			num2 = obj8;
			obj3.Ascent = num2.GetValueOrDefault();
			int? obj10;
			if (val == null)
			{
				obj10 = null;
			}
			else
			{
				JToken obj11 = val[(object)"route"];
				obj10 = ((obj11 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj11)) : ((int?)null));
			}
			num2 = obj10;
			obj3.Route = num2.GetValueOrDefault();
			int? obj12;
			if (val == null)
			{
				obj12 = null;
			}
			else
			{
				JToken obj13 = val[(object)"maxPlayers"];
				obj12 = ((obj13 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj13)) : ((int?)null));
			}
			obj3.MaxPlayers = obj12 ?? 8;
			bool? obj14;
			if (val == null)
			{
				obj14 = null;
			}
			else
			{
				JToken obj15 = val[(object)"autoStart"];
				obj14 = ((obj15 != null) ? new bool?(Extensions.Value<bool>((IEnumerable<JToken>)obj15)) : ((bool?)null));
			}
			obj3.AutoStart = obj14 ?? true;
			bool? obj16;
			if (val == null)
			{
				obj16 = null;
			}
			else
			{
				JToken obj17 = val[(object)"ghostsVisible"];
				obj16 = ((obj17 != null) ? new bool?(Extensions.Value<bool>((IEnumerable<JToken>)obj17)) : ((bool?)null));
			}
			bool? flag = obj16;
			obj3.GhostsVisible = flag == true;
			bool? obj18;
			if (val == null)
			{
				obj18 = null;
			}
			else
			{
				JToken obj19 = val[(object)"secretSeed"];
				obj18 = ((obj19 != null) ? new bool?(Extensions.Value<bool>((IEnumerable<JToken>)obj19)) : ((bool?)null));
			}
			flag = obj18;
			obj3.SecretSeed = flag == true;
			obj3.Status = ((val == null) ? null : ((object)val[(object)"status"])?.ToString()) ?? "lobby";
			long? startAt;
			if (val != null)
			{
				JToken obj20 = val[(object)"startAt"];
				if ((int)((obj20 != null) ? new JTokenType?(obj20.Type) : ((JTokenType?)null)).GetValueOrDefault() == 10)
				{
					startAt = null;
					goto IL_03cb;
				}
			}
			if (val == null)
			{
				startAt = null;
			}
			else
			{
				JToken obj21 = val[(object)"startAt"];
				startAt = ((obj21 != null) ? new long?(Extensions.Value<long>((IEnumerable<JToken>)obj21)) : ((long?)null));
			}
			goto IL_03cb;
			IL_03cb:
			obj3.StartAt = startAt;
			RaceInfo raceInfo = obj3;
			JToken obj22 = obj["participants"];
			JArray val2 = (JArray)(object)((obj22 is JArray) ? obj22 : null);
			if (val2 != null)
			{
				foreach (JToken item in val2)
				{
					List<RaceParticipant> participants = raceInfo.Participants;
					RaceParticipant obj23 = new RaceParticipant
					{
						SteamId = (((object)item[(object)"steamId"])?.ToString() ?? string.Empty),
						PlayerName = (((object)item[(object)"playerName"])?.ToString() ?? Loc.T("common.anonymous")),
						State = (((object)item[(object)"state"])?.ToString() ?? "joined")
					};
					JToken obj24 = item[(object)"rank"];
					int? rank;
					if (obj24 == null || (int)obj24.Type != 10)
					{
						JToken obj25 = item[(object)"rank"];
						rank = ((obj25 != null) ? new int?(Extensions.Value<int>((IEnumerable<JToken>)obj25)) : ((int?)null));
					}
					else
					{
						rank = null;
					}
					obj23.Rank = rank;
					JToken obj26 = item[(object)"totalMs"];
					long? totalMs;
					if (obj26 == null || (int)obj26.Type != 10)
					{
						JToken obj27 = item[(object)"totalMs"];
						totalMs = ((obj27 != null) ? new long?(Extensions.Value<long>((IEnumerable<JToken>)obj27)) : ((long?)null));
					}
					else
					{
						totalMs = null;
					}
					obj23.TotalMs = totalMs;
					JToken obj28 = item[(object)"progress"];
					obj23.Progress = ((obj28 != null) ? Extensions.Value<float>((IEnumerable<JToken>)obj28) : 0f);
					obj23.Health = OptionalFloat(item[(object)"health"]);
					obj23.Stamina = OptionalFloat(item[(object)"stamina"]);
					obj23.ExtraStamina = OptionalFloat(item[(object)"extraStamina"]);
					obj23.HandItem = OptionalInt(item[(object)"handItem"]);
					obj23.TopStatus = OptionalInt(item[(object)"topStatus"]);
					obj23.Belt = OptionalIntArray(item[(object)"belt"]);
					obj23.BackpackType = OptionalInt(item[(object)"backpackType"]);
					obj23.BackpackSlots = OptionalInt(item[(object)"backpackSlots"]);
					obj23.Pack = OptionalIntArray(item[(object)"pack"]);
					participants.Add(obj23);
				}
			}
			return raceInfo;
		}

		private static string ReadPlayerName()
		{
			try
			{
				if (!string.IsNullOrEmpty(PhotonNetwork.NickName))
				{
					return PhotonNetwork.NickName;
				}
			}
			catch (Exception)
			{
			}
			return null;
		}
	}
	public static class RankedGameLauncher
	{
		private static int? _forcedLevelIndex;

		public static bool SkipAirport { get; set; }

		public static int RunAscent { get; set; }

		public static void LaunchDirectToIsland()
		{
			SkipAirport = true;
			Ascents.currentAscent = RunAscent;
			RankedLog.Info($"[RankedGameLauncher] Starte direkten Run (Ascent {RunAscent}, ueberspringe Flughafen)...");
			MainMenuMainPage.StartMultiplayerLobby();
		}

		public static void LaunchToAirport()
		{
			SkipAirport = false;
			RankedLog.Info("[RankedGameLauncher] Starte in den Flughafen (Race-Wartebereich)...");
			MainMenuMainPage.StartMultiplayerLobby();
		}

		public static string ForceLevelIndex(int levelIndex)
		{
			try
			{
				_forcedLevelIndex = levelIndex;
				int num = CurrentLevelIndex();
				int debugLevelIndexOffset = NextLevelService.debugLevelIndexOffset;
				NextLevelService.debugLevelIndexOffset = levelIndex - num;
				string activeIslandSceneName = GetActiveIslandSceneName();
				RankedLog.Info($"[RankedGameLauncher] Karte erzwungen: Ziel-Index {levelIndex} " + $"(Basis {num}, Offset {debugLevelIndexOffset} -> {NextLevelService.debugLevelIndexOffset}) " + "=> Szene '" + activeIslandSceneName + "'");
				return activeIslandSceneName;
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RankedGameLauncher] Karte konnte nicht erzwungen werden: " + ex.Message);
				return null;
			}
		}

		public static void ReapplyForcedLevel()
		{
			if (!_forcedLevelIndex.HasValue)
			{
				return;
			}
			try
			{
				int num = CurrentLevelIndex();
				int num2 = _forcedLevelIndex.Value - num;
				if (num2 != NextLevelService.debugLevelIndexOffset)
				{
					RankedLog.Info($"[RankedGameLauncher] Basis-Index hat sich verschoben (jetzt {num}) - " + $"Offset fuer Ziel {_forcedLevelIndex.Value} nachgezogen " + $"({NextLevelService.debugLevelIndexOffset} -> {num2}).");
					NextLevelService.debugLevelIndexOffset = num2;
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RankedGameLauncher] Offset nicht nachziehbar: " + ex.Message);
			}
		}

		public static int CurrentLevelIndex()
		{
			try
			{
				NextLevelService service = GameHandler.GetService<NextLevelService>();
				return (service != null) ? service.NextLevelIndexOrFallback : 0;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RankedGameLauncher] Level-Index nicht lesbar: " + ex.Message);
				return 0;
			}
		}

		public static void ClearForcedLevel()
		{
			_forcedLevelIndex = null;
			if (NextLevelService.debugLevelIndexOffset != 0)
			{
				RankedLog.Info("[RankedGameLauncher] Karten-Offset zurueckgesetzt " + $"({NextLevelService.debugLevelIndexOffset} -> 0).");
				NextLevelService.debugLevelIndexOffset = 0;
			}
		}

		public static string GetActiveIslandSceneName()
		{
			try
			{
				NextLevelService service = GameHandler.GetService<NextLevelService>();
				int num = ((service != null) ? service.NextLevelIndexOrFallback : 0);
				Type type = Type.GetType("MapBaker, Assembly-CSharp");
				if (type != null)
				{
					object obj = typeof(SingletonAsset<>).MakeGenericType(type).GetProperty("Instance", BindingFlags.Static | BindingFlags.Public)?.GetValue(null);
					if (obj != null)
					{
						string text = type.GetMethod("GetLevel", new Type[1] { typeof(int) })?.Invoke(obj, new object[1] { num + NextLevelService.debugLevelIndexOffset }) as string;
						if (!string.IsNullOrEmpty(text))
						{
							return text;
						}
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RankedGameLauncher] Konnte Insel-Name nicht ermitteln (" + ex.Message + "), Fallback auf WilIsland.");
			}
			return "WilIsland";
		}
	}
	[HarmonyPatch(typeof(SteamLobbyHandler), "OnLobbyCreated")]
	public static class SteamLobbyCreatedPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(SteamLobbyHandler __instance, LobbyCreated_t param)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_0070: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0069: Expected O, but got Unknown
			if (!RankedGameLauncher.SkipAirport)
			{
				return true;
			}
			RankedGameLauncher.SkipAirport = false;
			__instance.m_isHosting = true;
			if ((int)param.m_eResult != 1)
			{
				Modal.OpenModal((HeaderModalOption)new DefaultHeaderModalOption(LocalizedText.GetText("MODAL_CANTCREATELOBBY_TITLE", true), $"{param.m_eResult}"), (ModalContentOption)new ModalButtonsOption((Option[])(object)new Option[1]
				{
					new Option(LocalizedText.GetText("OK", true), (Action)null)
				}), (Action)null);
				return false;
			}
			RankedLog.Info($"[RankedGameLauncher] Lobby {param.m_ulSteamIDLobby} erstellt. Ueberspringe Flughafen...");
			__instance.LobbySteamId = new CSteamID(param.m_ulSteamIDLobby);
			CSteamID lobbySteamId = __instance.LobbySteamId;
			BuildVersion val = new BuildVersion(Application.version, "???");
			if (!SteamMatchmaking.SetLobbyData(lobbySteamId, "PeakVersion", ((BuildVersion)(ref val)).ToMatchmaking()))
			{
				RankedLog.Error("Failed to assign game version to lobby");
			}
			((StateMachine<ConnectionState>)(object)GameHandler.GetService<ConnectionService>().StateMachine).SwitchState<HostState>(false).RoomName = __instance.GenerateRoomName();
			Ascents.currentAscent = RankedGameLauncher.RunAscent;
			RankedGameLauncher.ReapplyForcedLevel();
			string activeIslandSceneName = RankedGameLauncher.GetActiveIslandSceneName();
			RankedLog.Info($"[RankedGameLauncher] Lade Insel-Level '{activeIslandSceneName}' direkt (Ascent: {Ascents.currentAscent})...");
			RetrievableResourceSingleton<LoadingScreenHandler>.Instance.Load((LoadingScreenType)1, (Action)null, new IEnumerator[1] { RetrievableResourceSingleton<LoadingScreenHandler>.Instance.LoadSceneProcess(activeIslandSceneName, true, true, 0f) });
			return false;
		}
	}
	public static class RankedRunGate
	{
		public static bool IsRankedRun { get; private set; }

		public static bool RandomSeed { get; private set; }

		public static string LastRefusal { get; private set; } = string.Empty;

		public static bool MayInterfere => IsRankedRun;

		public static bool Select(GameMode mode, int levelIndex, bool randomSeed = false)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!MapCatalog.IsSlotAuthentic(levelIndex))
			{
				string text = MapCatalog.DescribeCatalogDeviations();
				LastRefusal = Loc.T("gate.mapAltered", "<color=#" + ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Danger) + ">" + MapCatalog.GetSceneName(levelIndex) + "</color>", "<color=#" + ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Heading) + ">" + MapCatalog.ExpectedSceneName(MapCatalog.SlotOf(levelIndex)) + "</color>");
				RankedLog.Warning($"[RunGate] Abgelehnt: Slot {MapCatalog.SlotOf(levelIndex)} (Index {levelIndex}) " + "traegt '" + MapCatalog.GetSceneName(levelIndex) + "' statt '" + MapCatalog.ExpectedSceneName(MapCatalog.SlotOf(levelIndex)) + "'. Katalog-Abweichungen: " + (string.IsNullOrEmpty(text) ? "keine" : text));
				return false;
			}
			LastRefusal = string.Empty;
			Plugin.SelectedMode.Value = mode;
			IsRankedRun = true;
			RandomSeed = randomSeed;
			ModQuarantine.Engage();
			RankedLog.Info($"[RunGate] Gewerteter Lauf vorgemerkt: {mode}" + (randomSeed ? " (gewuerfelter Seed)" : string.Empty) + ".");
			return true;
		}

		public static void Disarm()
		{
			if (IsRankedRun)
			{
				IsRankedRun = false;
				RandomSeed = false;
				ModQuarantine.Release();
				RankedLog.Info("[RunGate] Hauptmenue - Vormerkung aufgehoben, naechster Start waere Vanilla.");
			}
		}

		public static GameMode CurrentMode()
		{
			if (!IsRankedRun)
			{
				return GameMode.Vanilla;
			}
			return Plugin.SelectedMode.Value;
		}
	}
	public class RatingService : MonoBehaviour
	{
		private const float RequestTimeoutSeconds = 10f;

		public static RatingService Instance { get; private set; }

		public PlayerRating CurrentRating { get; private set; }

		public bool IsLoaded { get; private set; }

		public bool IsLoading { get; private set; }

		public static event Action<PlayerRating> RatingUpdated;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void OnEnable()
		{
			RunUploadService.UploadSettled += OnUploadSettled;
		}

		private void OnDisable()
		{
			RunUploadService.UploadSettled -= OnUploadSettled;
		}

		private void Start()
		{
			RefreshRating();
		}

		private void OnUploadSettled(string runId, string status)
		{
			RankedLog.Info("[RatingService] Run-Upload abgeschlossen (" + status + ") -> hole frisches Rating vom Server...");
			((MonoBehaviour)this).StartCoroutine(DelayedRefreshRoutine(0.5f));
		}

		private IEnumerator DelayedRefreshRoutine(float delaySeconds)
		{
			yield return (object)new WaitForSeconds(delaySeconds);
			RefreshRating();
		}

		public void RefreshRating(Action<PlayerRating> onComplete = null)
		{
			if (!IsLoading)
			{
				((MonoBehaviour)this).StartCoroutine(FetchRatingRoutine(onComplete));
			}
		}

		private IEnumerator FetchRatingRoutine(Action<PlayerRating> onComplete)
		{
			IsLoading = true;
			string steamId = SteamIdentity.GetSteamId64();
			if (string.IsNullOrEmpty(steamId) || steamId == "0")
			{
				RankedLog.Info("[RatingService] SteamID noch nicht bereit (Steam initialisiert spaeter) - warte auf Menue-Laden.");
				IsLoading = false;
				yield break;
			}
			string text = "https://followme-peak.ddns.net/ranked/rating/mine?steamId=" + steamId;
			RankedLog.Debug("[RatingService] GET " + text + "...");
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result == 1)
				{
					try
					{
						PlayerRating playerRating = (CurrentRating = JsonConvert.DeserializeObject<PlayerRating>(request.downloadHandler.text));
						IsLoaded = true;
						RankedLog.Info($"[RatingService] Rating geladen: {playerRating?.FormattedHeaderSignText} (Placements: {playerRating?.PlacementGames}/3, ELO: {playerRating?.Elo})");
					}
					catch (Exception ex)
					{
						RankedLog.Error("[RatingService] Fehler beim Parsen des Ratings: " + ex.Message);
						if (CurrentRating == null)
						{
							CurrentRating = new PlayerRating
							{
								PlacementGames = 0,
								Ranked = false,
								Tier = "UNRANKED"
							};
						}
					}
				}
				else if (request.responseCode == 404)
				{
					RankedLog.Info("[RatingService] Spieler hat noch kein Rating (Unranked 0/3).");
					CurrentRating = new PlayerRating
					{
						PlacementGames = 0,
						Ranked = false,
						Tier = "UNRANKED"
					};
					IsLoaded = true;
				}
				else
				{
					RankedLog.Warning($"[RatingService] Rating-Abruf fehlgeschlagen ({request.responseCode} {request.error}).");
					if (CurrentRating == null)
					{
						CurrentRating = new PlayerRating
						{
							PlacementGames = 0,
							Ranked = false,
							Tier = "UNRANKED"
						};
					}
				}
				IsLoading = false;
				RatingService.RatingUpdated?.Invoke(CurrentRating);
				onComplete?.Invoke(CurrentRating);
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
	public static class RunConfigService
	{
		public const int TenderfootAscent = -1;

		private const int FallbackMaxAscent = 7;

		public const int FallbackMiniRunBiomeCount = 4;

		private static int? _miniRunBiomeCount;

		public const bool EnableExperimentalKilnRoute = false;

		private static int? _pendingAscent;

		private static int _pendingRoute;

		public static int MiniRunBiomeCount
		{
			get
			{
				if (_miniRunBiomeCount.HasValue)
				{
					return _miniRunBiomeCount.Value;
				}
				int num = ReadMiniRunBiomeCount();
				if (num <= 0)
				{
					return 4;
				}
				_miniRunBiomeCount = num;
				if (num != 4)
				{
					RankedLog.Warning($"[RunConfig] Das Spiel meldet {num} Mini-Run-Abschnitte statt der " + $"erwarteten {4} - die Streckenwahl passt sich an. " + "Biom-Namen und Leaderboard-Kategorien pruefen.");
				}
				return num;
			}
		}

		private static int ExperimentalRouteIndex => MiniRunBiomeCount + 1;

		public static int RouteCount => 1 + MiniRunBiomeCount;

		public static int MaxAscent
		{
			get
			{
				try
				{
					int num = 9;
					return (num > 0) ? num : 7;
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[RunConfig] MAX_ASCENT nicht lesbar: " + ex.Message);
					return 7;
				}
			}
		}

		private static int ReadMiniRunBiomeCount()
		{
			try
			{
				if (RunSettings.defaultRunSettings != null && RunSettings.defaultRunSettings.TryGetValue("MiniRunBiome", out var value) && value != null && value.maxValue > 0)
				{
					return value.maxValue + 1;
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunConfig] Standard-Streckenwerte nicht lesbar: " + ex.Message);
			}
			try
			{
				int maxValue = RunSettings.GetMaxValue("MiniRunBiome");
				if (maxValue > 0)
				{
					return maxValue + 1;
				}
			}
			catch (Exception ex2)
			{
				RankedLog.Warning("[RunConfig] Streckenanzahl nicht lesbar: " + ex2.Message);
			}
			return 0;
		}

		public static bool IsExperimentalRoute(int routeIndex)
		{
			return false;
		}

		public static string GetAscentName(int ascent)
		{
			if (ascent <= -1)
			{
				return Loc.T("config.ascent.tenderfoot");
			}
			if (ascent != 0)
			{
				return Loc.T("config.ascent.numbered", ascent);
			}
			return Loc.T("config.ascent.peak");
		}

		public static string GetAscentShortName(int ascent)
		{
			if (ascent <= -1)
			{
				return Loc.T("config.ascent.tenderfoot");
			}
			if (ascent != 0)
			{
				return ascent.ToString();
			}
			return Loc.T("config.ascent.peak");
		}

		public static string GetAscentDescription(int ascent)
		{
			if (ascent > -1)
			{
				return ascent switch
				{
					0 => Loc.T("config.ascent.desc.0"), 
					1 => Loc.T("config.ascent.desc.1"), 
					2 => Loc.T("config.ascent.desc.2"), 
					3 => Loc.T("config.ascent.desc.3"), 
					4 => Loc.T("config.ascent.desc.4"), 
					5 => Loc.T("config.ascent.desc.5"), 
					6 => Loc.T("config.ascent.desc.6"), 
					_ => Loc.T("config.ascent.desc.more"), 
				};
			}
			return Loc.T("config.ascent.desc.tenderfoot");
		}

		public static string GetRouteName(int routeIndex)
		{
			if (routeIndex <= 0)
			{
				return Loc.T("config.route.whole");
			}
			if (!IsExperimentalRoute(routeIndex))
			{
				return Loc.T("config.route.biome", routeIndex);
			}
			return Loc.T("config.route.biomeTest", routeIndex);
		}

		public static string GetRouteDescription(int routeIndex)
		{
			if (routeIndex <= 0)
			{
				return Loc.T("config.route.desc.whole");
			}
			if (IsExperimentalRoute(routeIndex))
			{
				return Loc.T("config.route.desc.experimental");
			}
			return Loc.T("config.route.desc.mini", routeIndex);
		}

		public static void ApplyCustomRun(int ascent, int routeIndex)
		{
			int num = Mathf.Clamp(ascent, -1, MaxAscent);
			bool flag = routeIndex > 0;
			_pendingAscent = num;
			_pendingRoute = routeIndex;
			try
			{
				Ascents.currentAscent = num;
				RankedGameLauncher.RunAscent = num;
				ResetAllRunSettingsToDefaults();
				RunSettings.IsCustomRun = true;
				int num2 = (flag ? (routeIndex - 1) : 0);
				RunSettings.SetValue((SETTINGTYPE)10000, flag ? 1 : 0);
				bool flag2 = RunSettings.SetValue((SETTINGTYPE)10050, num2);
				RankedLog.Info($"[RunConfig] Custom Run: Ascent={num}, Strecke={GetRouteName(routeIndex)} " + $"(MiniRun={flag}, Biom-Index={num2}, SetValue={flag2})");
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunConfig] Custom-Run-Einstellungen fehlgeschlagen: {arg}");
			}
			LogSettingsReadback();
		}

		private static void LogSettingsReadback()
		{
			try
			{
				if (!RunSettings.initialized)
				{
					RankedLog.Info("[RunConfig] Readback übersprungen - RunSettings ist im Menü noch nicht initialisiert.");
					return;
				}
				int value = RunSettings.GetValue((SETTINGTYPE)10050, false);
				int maxValue = RunSettings.GetMaxValue((SETTINGTYPE)10050);
				RankedLog.Info($"[RunConfig] Readback: Biom-Index={value}, MaxValue laut Spiel={maxValue}");
			}
			catch (Exception ex)
			{
				RankedLog.Info("[RunConfig] Readback nicht möglich: " + ex.Message);
			}
		}

		public static int GetCurrentRouteIndex()
		{
			try
			{
				if (RunSettings.GetValue((SETTINGTYPE)10000, false) <= 0)
				{
					return 0;
				}
				int value = RunSettings.GetValue((SETTINGTYPE)10050, false);
				return (value >= 0) ? (value + 1) : 0;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunConfig] Strecke nicht lesbar: " + ex.Message);
				return 0;
			}
		}

		public static void ResetToRankedDefaults()
		{
			RankedGameLauncher.RunAscent = 0;
			_pendingAscent = null;
			try
			{
				RunSettings.SetValue((SETTINGTYPE)10000, 0);
				RunSettings.SetValue((SETTINGTYPE)10050, 0);
				RunSettings.IsCustomRun = false;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunConfig] Zuruecksetzen der Runeinstellungen fehlgeschlagen: " + ex.Message);
			}
		}

		private static void ResetAllRunSettingsToDefaults()
		{
			try
			{
				if (RunSettings.defaultRunSettings == null || RunSettings.defaultRunSettings.Count == 0)
				{
					RankedLog.Info("[RunConfig] Standardwerte noch nicht aufgebaut - Reset laeuft ueber den LoadFromDisk-Patch nach.");
					return;
				}
				RunSettings.SetValuesToDefault();
				RankedLog.Info("[RunConfig] Alle Runeinstellungen auf Vanilla-Standard gesetzt.");
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunConfig] Runeinstellungen nicht auf Standard setzbar: " + ex.Message);
			}
		}

		public static void ReapplyPendingCustomRun()
		{
			if (_pendingAscent.HasValue)
			{
				RankedLog.Info("[RunConfig] Gespeicherte Terminal-Werte nachgeladen - Race-Konfiguration wird erneut angewendet.");
				ApplyCustomRun(_pendingAscent.Value, _pendingRoute);
			}
		}
	}
	public class RunStorageService
	{
		private class RunStorageData
		{
			public List<RunRecord> Runs { get; set; } = new List<RunRecord>();

			public Dictionary<string, long> PersonalBests { get; set; } = new Dictionary<string, long>();

			public Dictionary<string, string> PinnedComparisons { get; set; } = new Dictionary<string, string>();
		}

		private const int MaxHistoryEntries = 100;

		private readonly string _filePath;

		private readonly object _fileLock = new object();

		private RunStorageData _data = new RunStorageData();

		public static string ComparisonKey(GameMode mode, string mapName, int routeIndex)
		{
			return $"{mode}|{mapName}|{routeIndex}";
		}

		public RunStorageService()
		{
			string path = Path.Combine(Paths.PluginPath, "RankedPeak_Data");
			_filePath = Path.Combine(path, "runs.json");
			Load();
		}

		private static string PersonalBestKey(GameMode mode, int routeIndex)
		{
			if (routeIndex <= 0)
			{
				return mode.ToString();
			}
			return $"{mode}|Route{routeIndex}";
		}

		public long? GetPersonalBestMs(GameMode mode, int routeIndex = 0)
		{
			lock (_fileLock)
			{
				long value;
				return _data.PersonalBests.TryGetValue(PersonalBestKey(mode, routeIndex), out value) ? new long?(value) : ((long?)null);
			}
		}

		public List<RunRecord> GetRecentRuns()
		{
			lock (_fileLock)
			{
				List<RunRecord> list = new List<RunRecord>(_data.Runs);
				list.Sort((RunRecord a, RunRecord b) => b.StartTimeUtc.CompareTo(a.StartTimeUtc));
				return list;
			}
		}

		public RunRecord GetPinnedComparison(GameMode mode, string mapName, int routeIndex = 0)
		{
			lock (_fileLock)
			{
				if (!_data.PinnedComparisons.TryGetValue(ComparisonKey(mode, mapName, routeIndex), out var value) || string.IsNullOrEmpty(value))
				{
					return null;
				}
				foreach (RunRecord run in _data.Runs)
				{
					if (run.Id.ToString() == value)
					{
						return run;
					}
				}
				return null;
			}
		}

		public void SetPinnedComparison(GameMode mode, string mapName, int routeIndex, RunRecord run)
		{
			lock (_fileLock)
			{
				string key = ComparisonKey(mode, mapName, routeIndex);
				if (run == null)
				{
					_data.PinnedComparisons.Remove(key);
				}
				else
				{
					_data.PinnedComparisons[key] = run.Id.ToString();
				}
				Save();
			}
		}

		public List<RunRecord> GetRunsForComparison(GameMode mode, string mapName, int routeIndex = 0)
		{
			lock (_fileLock)
			{
				List<RunRecord> list = new List<RunRecord>();
				foreach (RunRecord run in _data.Runs)
				{
					if (run.Result == RunResult.Completed && run.Mode == mode && run.MapName == mapName && run.RouteIndex == routeIndex && run.Splits.Count > 0)
					{
						list.Add(run);
					}
				}
				list.Sort((RunRecord a, RunRecord b) => a.TotalMs.CompareTo(b.TotalMs));
				return list;
			}
		}

		public RunRecord GetBestRunForRoute(GameMode mode, string mapName, int routeIndex = 0)
		{
			lock (_fileLock)
			{
				RunRecord runRecord = null;
				foreach (RunRecord run in _data.Runs)
				{
					if (run.Result == RunResult.Completed && run.Mode == mode && !(run.MapName != mapName) && run.RouteIndex == routeIndex && run.Splits.Count != 0 && (runRecord == null || run.TotalMs < runRecord.TotalMs))
					{
						runRecord = run;
					}
				}
				return runRecord;
			}
		}

		public Dictionary<int, long> GetBestSegmentTimes(GameMode mode, string mapName, int routeIndex = 0)
		{
			Dictionary<int, long> dictionary = new Dictionary<int, long>();
			lock (_fileLock)
			{
				foreach (RunRecord run in _data.Runs)
				{
					if (run.Result != RunResult.Completed || run.Mode != mode || run.MapName != mapName || run.RouteIndex != routeIndex)
					{
						continue;
					}
					for (int i = 0; i < run.Splits.Count; i++)
					{
						long num = ((i > 0) ? run.Splits[i - 1].ElapsedMs : 0);
						long num2 = run.Splits[i].ElapsedMs - num;
						if (num2 > 0 && (!dictionary.TryGetValue(i, out var value) || num2 < value))
						{
							dictionary[i] = num2;
						}
					}
				}
				return dictionary;
			}
		}

		public bool AddRun(RunRecord record, out long deltaToPreviousPbMs)
		{
			lock (_fileLock)
			{
				deltaToPreviousPbMs = 0L;
				bool flag = false;
				if (record.Result == RunResult.Completed)
				{
					string key = PersonalBestKey(record.Mode, record.RouteIndex);
					long value;
					bool num = _data.PersonalBests.TryGetValue(key, out value);
					flag = !num || record.TotalMs < value;
					if (flag)
					{
						_data.PersonalBests[key] = record.TotalMs;
					}
					if (num)
					{
						deltaToPreviousPbMs = record.TotalMs - value;
					}
				}
				_data.Runs.Add(record);
				if (_data.Runs.Count > 100)
				{
					_data.Runs.RemoveRange(0, _data.Runs.Count - 100);
				}
				Save();
				return flag;
			}
		}

		private void Load()
		{
			try
			{
				if (File.Exists(_filePath))
				{
					string text = File.ReadAllText(_filePath);
					_data = JsonConvert.DeserializeObject<RunStorageData>(text) ?? new RunStorageData();
					MigrateLegacyModeKeys();
					RankedLog.Info($"[RunStorage] {_data.Runs.Count} Runs aus {_filePath} geladen.");
				}
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RunStorage] Laden fehlgeschlagen, starte mit leerer History: " + ex.Message);
				_data = new RunStorageData();
			}
		}

		private void MigrateLegacyModeKeys()
		{
			string text = GameMode.Speedrun.ToString();
			bool flag = false;
			string[] array = new string[2] { "CustomPractice", "RandomDaily" };
			foreach (string text2 in array)
			{
				if (_data.PersonalBests.TryGetValue(text2, out var value))
				{
					long value2;
					long num = (_data.PersonalBests.TryGetValue(text, out value2) ? Math.Min(value2, value) : value);
					_data.PersonalBests[text] = num;
					_data.PersonalBests.Remove(text2);
					flag = true;
					RankedLog.Info($"[RunStorage] Bestzeit aus '{text2}' nach '{text}' uebernommen ({num} ms).");
				}
			}
			if (flag)
			{
				Save();
			}
		}

		private void Save()
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(_filePath));
				File.WriteAllText(_filePath, JsonConvert.SerializeObject((object)_data, (Formatting)1));
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RunStorage] Speichern fehlgeschlagen: " + ex.Message);
			}
		}
	}
	public class RunUploadService : MonoBehaviour
	{
		public class RunUploadDto
		{
			public string id;

			public string playerName;

			public string mode;

			public string mapName;

			public int seed;

			public bool randomSeed;

			public List<SplitDto> splits;

			public long totalMs;

			public string startTimeUtc;

			public long realElapsedMs;

			public string result;

			public int ascentLevel;

			public int playerCount;

			public string modVersion;

			public string climbId;

			public string steamId;

			public string gameVersion;

			public int levelIndex;

			public string biomeId;

			public string mapSetHash;

			public int route;

			public string routeBiomeName;

			public List<ModEntry> mods;

			public string modSetHash;

			public IntegrityReport integrityData;

			public ClimbUploadDto climbPayload;

			public static RunUploadDto FromRun(RunRecord run, ClimbRecord climb, string playerName, string steamId)
			{
				RunUploadDto runUploadDto = new RunUploadDto
				{
					id = run.Id.ToString(),
					playerName = playerName,
					steamId = steamId,
					mode = run.Mode.ToString(),
					mapName = run.MapName,
					seed = run.Seed,
					randomSeed = run.RandomSeed,
					splits = run.Splits.ConvertAll((SplitRecord s) => new SplitDto
					{
						SegmentName = s.SegmentName,
						ElapsedMs = s.ElapsedMs
					}),
					totalMs = run.TotalMs,
					startTimeUtc = ((run.StartTimeUtc == default(DateTime)) ? null : run.StartTimeUtc.ToUniversalTime().ToString("o", CultureInfo.InvariantCulture)),
					realElapsedMs = run.RealElapsedMs,
					integrityData = run.Integrity,
					result = run.Result.ToString(),
					ascentLevel = run.AscentLevel,
					playerCount = run.PlayerCount,
					modVersion = "0.10.3",
					climbId = null,
					gameVersion = run.GameVersion,
					levelIndex = run.LevelIndex,
					biomeId = run.BiomeId,
					mapSetHash = run.MapSetHash,
					route = run.RouteIndex,
					routeBiomeName = run.RouteBiomeName,
					mods = ModInventory.GetMods(),
					modSetHash = ModInventory.GetModSetHash()
				};
				if (climb != null && !climb.WasDeathClimb && run.Result == RunResult.Completed)
				{
					runUploadDto.climbPayload = new ClimbUploadDto
					{
						id = climb.Id.ToString(),
						levelId = climb.MapName,
						playerName = playerName,
						biomeName = climb.BiomeName,
						duration = climb.DurationInSeconds,
						pointData = climb.PointData,
						animData = climb.AnimData,
						itemData = climb.ItemData,
						stateData = climb.StateData,
						inventoryData = climb.InventoryData,
						compressionVersion = 1,
						isSuccessful = true,
						ascentLevel = climb.AscentLevel,
						modVersion = "0.10.3"
					};
					runUploadDto.climbId = runUploadDto.climbPayload.id;
				}
				return runUploadDto;
			}
		}

		public class ClimbUploadDto
		{
			public string id;

			public string levelId;

			public string playerName;

			public string biomeName;

			public float duration;

			public string pointData;

			public string animData;

			public string itemData;

			public string stateData;

			public string inventoryData;

			public int compressionVersion;

			public bool isSuccessful;

			public int ascentLevel;

			public string modVersion;
		}

		public class SplitDto
		{
			public string SegmentName;

			public long ElapsedMs;
		}

		internal const string ApiKey = "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E";

		private const float RetryIntervalSeconds = 30f;

		private const float RequestTimeoutSeconds = 15f;

		private readonly string _queueFilePath;

		private readonly object _queueLock = new object();

		private List<RunUploadDto> _pending = new List<RunUploadDto>();

		private bool _uploadInProgress;

		public static RunUploadService Instance { get; private set; }

		public int PendingCount
		{
			get
			{
				lock (_queueLock)
				{
					return _pending.Count;
				}
			}
		}

		public static event Action<string, string> UploadSettled;

		public RunUploadService()
		{
			_queueFilePath = Path.Combine(Paths.PluginPath, "RankedPeak_Data", "pending_uploads.json");
		}

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}

		private void Start()
		{
			LoadQueue();
			TriggerImmediateFlush();
			((MonoBehaviour)this).StartCoroutine(FlushLoop());
		}

		public static bool IsBoardEligible(GameMode mode)
		{
			if (mode != GameMode.GhostTraining)
			{
				return mode != GameMode.Vanilla;
			}
			return false;
		}

		public void EnqueueRun(RunRecord run, ClimbRecord climb = null)
		{
			if (run == null)
			{
				return;
			}
			if (!IsBoardEligible(run.Mode))
			{
				RankedLog.Info($"[RunUpload] Run {run.Id} ({run.Mode}) ist ein Übungslauf - bleibt lokal, kein Upload.");
				return;
			}
			RunUploadDto item = RunUploadDto.FromRun(run, climb, ReadPlayerName(), SteamIdentity.GetSteamId64());
			lock (_queueLock)
			{
				_pending.Add(item);
				SaveQueue();
			}
			RankedLog.Info($"[RunUpload] Run {run.Id} (mit Climb: {climb != null}) eingereiht -> starte Sofort-Upload ({_pending.Count} offen).");
			TriggerImmediateFlush();
		}

		public void TriggerImmediateFlush()
		{
			if (!_uploadInProgress && _pending.Count > 0)
			{
				((MonoBehaviour)this).StartCoroutine(FlushRoutine());
			}
		}

		private IEnumerator FlushLoop()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(30f);
				TriggerImmediateFlush();
			}
		}

		private IEnumerator FlushRoutine()
		{
			if (_uploadInProgress)
			{
				yield break;
			}
			while (true)
			{
				RunUploadDto runUploadDto = null;
				lock (_queueLock)
				{
					if (_pending.Count <= 0)
					{
						_uploadInProgress = false;
						break;
					}
					runUploadDto = _pending[0];
					_uploadInProgress = true;
				}
				if (runUploadDto != null)
				{
					yield return UploadOnce(runUploadDto);
					_uploadInProgress = false;
					continue;
				}
				break;
			}
		}

		private IEnumerator UploadOnce(RunUploadDto dto)
		{
			if (dto.climbPayload != null)
			{
				string text = "https://followme-peak.ddns.net/api/climbs";
				string s = JsonConvert.SerializeObject((object)dto.climbPayload);
				RankedLog.Debug("[RunUpload] Sende Climb " + dto.climbPayload.id + " an " + text + "...");
				UnityWebRequest climbRequest = new UnityWebRequest(text, "POST");
				try
				{
					climbRequest.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(s));
					climbRequest.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					climbRequest.SetRequestHeader("Content-Type", "application/json");
					climbRequest.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
					climbRequest.timeout = 15;
					yield return climbRequest.SendWebRequest();
					if ((int)climbRequest.result == 1 || climbRequest.responseCode == 201)
					{
						RankedLog.Info("[RunUpload] Climb " + dto.climbPayload.id + " erfolgreich hochgeladen.");
						dto.climbPayload = null;
						SaveQueue();
					}
					else
					{
						if (climbRequest.responseCode != 400 && climbRequest.responseCode != 413)
						{
							RankedLog.Warning($"[RunUpload] Climb-Upload fehlgeschlagen ({climbRequest.responseCode} {climbRequest.error}) - Retry folgt.");
							yield break;
						}
						RankedLog.Warning($"[RunUpload] Climb vom Server abgelehnt ({climbRequest.responseCode}): {climbRequest.downloadHandler.text}");
						dto.climbPayload = null;
						dto.climbId = null;
						SaveQueue();
					}
				}
				finally
				{
					((IDisposable)climbRequest)?.Dispose();
				}
			}
			string text2 = "https://followme-peak.ddns.net/ranked/runs";
			string s2 = JsonConvert.SerializeObject((object)dto);
			RankedLog.Debug($"[RunUpload] POST {text2} (Run {dto.id}, {dto.mode}, {dto.totalMs} ms, {dto.result})");
			UnityWebRequest request = new UnityWebRequest(text2, "POST");
			try
			{
				request.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(s2));
				request.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				request.SetRequestHeader("Content-Type", "application/json");
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 15;
				yield return request.SendWebRequest();
				if ((int)request.result == 1)
				{
					lock (_queueLock)
					{
						_pending.Remove(dto);
						SaveQueue();
					}
					RankedLog.Info($"[RunUpload] Run {dto.id} erfolgreich hochgeladen ({_pending.Count} offen).");
					NotifySettled(dto.id, ParseStatus(request.downloadHandler.text) ?? "ok");
				}
				else if (request.responseCode == 400)
				{
					lock (_queueLock)
					{
						_pending.Remove(dto);
						SaveQueue();
					}
					RankedLog.Warning("[RunUpload] Run " + dto.id + " vom Server abgelehnt (400): " + request.downloadHandler.text + " - verworfen.");
					NotifySettled(dto.id, "rejected");
				}
				else
				{
					RankedLog.Warning($"[RunUpload] Upload fehlgeschlagen ({request.responseCode} {request.error}) - Retry in {30f}s.");
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		private static string ReadPlayerName()
		{
			try
			{
				if (!string.IsNullOrEmpty(PhotonNetwork.NickName))
				{
					return PhotonNetwork.NickName;
				}
			}
			catch (Exception)
			{
			}
			return "Local";
		}

		private static string ParseStatus(string responseText)
		{
			try
			{
				return ((object)JObject.Parse(responseText)["status"])?.ToString();
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static void NotifySettled(string runId, string status)
		{
			try
			{
				RunUploadService.UploadSettled?.Invoke(runId, status);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunUpload] UploadSettled-Listener fehlgeschlagen: " + ex.Message);
			}
		}

		private void LoadQueue()
		{
			try
			{
				if (File.Exists(_queueFilePath))
				{
					string text = File.ReadAllText(_queueFilePath);
					_pending = JsonConvert.DeserializeObject<List<RunUploadDto>>(text) ?? new List<RunUploadDto>();
					if (_pending.Count > 0)
					{
						RankedLog.Info($"[RunUpload] {_pending.Count} ausstehende Uploads geladen.");
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RunUpload] Queue-Laden fehlgeschlagen, starte leer: " + ex.Message);
				_pending = new List<RunUploadDto>();
			}
		}

		private void SaveQueue()
		{
			try
			{
				Directory.CreateDirectory(Path.GetDirectoryName(_queueFilePath));
				File.WriteAllText(_queueFilePath, JsonConvert.SerializeObject((object)_pending, (Formatting)1));
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RunUpload] Queue-Speichern fehlgeschlagen: " + ex.Message);
			}
		}
	}
	public static class SteamIdentity
	{
		private static string _cachedSteamId64;

		public static string GetSteamId64()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(_cachedSteamId64))
			{
				return _cachedSteamId64;
			}
			try
			{
				CSteamID steamID = SteamUser.GetSteamID();
				if (steamID != CSteamID.Nil && ((CSteamID)(ref steamID)).IsValid() && steamID.m_SteamID != 0L)
				{
					_cachedSteamId64 = steamID.m_SteamID.ToString();
					RankedLog.Info("[SteamIdentity] SteamID64 erfolgreich ermittelt: " + _cachedSteamId64);
					return _cachedSteamId64;
				}
			}
			catch (Exception ex)
			{
				RankedLog.Debug("[SteamIdentity] SteamID noch nicht bereit (" + ex.Message + ").");
			}
			return null;
		}
	}
	public class UpdateCheckService : MonoBehaviour
	{
		[Serializable]
		private class UpdateResponse
		{
			public bool hasUpdate;

			public string message;

			public string type;
		}

		private const float RequestTimeoutSeconds = 10f;

		public static UpdateCheckService Instance { get; private set; }

		public bool HasUpdate { get; private set; }

		public string Message { get; private set; }

		public string Type { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(Check());
		}

		private IEnumerator Check()
		{
			string text = "https://followme-peak.ddns.net/ranked/updates/check/" + UnityWebRequest.EscapeURL("0.10.3");
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result != 1)
				{
					RankedLog.Info($"[Update] Kein Hinweis abrufbar ({request.responseCode} {request.error}) - ohne Folgen.");
					yield break;
				}
				try
				{
					UpdateResponse updateResponse = JsonConvert.DeserializeObject<UpdateResponse>(request.downloadHandler.text);
					if (updateResponse != null && updateResponse.hasUpdate && !string.IsNullOrEmpty(updateResponse.message))
					{
						HasUpdate = true;
						Message = updateResponse.message;
						Type = (string.IsNullOrEmpty(updateResponse.type) ? "info" : updateResponse.type);
						RankedLog.Info("[Update] Hinweis fuer 0.10.3 (" + Type + "): " + Message);
					}
					else
					{
						RankedLog.Debug("[Update] Kein Hinweis fuer 0.10.3.");
					}
				}
				catch (Exception ex)
				{
					RankedLog.Warning("[Update] Antwort nicht parsebar: " + ex.Message);
				}
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}
	}
}
namespace RankedPeak.Seeds
{
	public class DailySeedService : MonoBehaviour
	{
		[Serializable]
		private class DailyResponse
		{
			public string date;

			public int seed;

			public int secondsUntilRotation;

			public string season;

			public int secondsUntilSeasonReset;
		}

		private const float RequestTimeoutSeconds = 10f;

		private bool _fetchInProgress;

		private static readonly DateTime FirstSeasonStart = new DateTime(2026, 8, 1, 0, 0, 0, DateTimeKind.Utc);

		public static DailySeedService Instance { get; private set; }

		public string ServerSeedDate { get; private set; }

		public int ServerSeed { get; private set; } = -1;

		public int SecondsUntilRotation { get; private set; } = -1;

		public bool HasValidServerSeed
		{
			get
			{
				if (ServerSeed >= 0)
				{
					return ServerSeedDate == GetCurrentRotationDate();
				}
				return false;
			}
		}

		public string ServerSeason { get; private set; }

		public string CurrentSeason
		{
			get
			{
				if (!string.IsNullOrEmpty(ServerSeason))
				{
					return ServerSeason;
				}
				return ComputeSeasonId(DateTime.UtcNow);
			}
		}

		private void Awake()
		{
			Instance = this;
		}

		public void RefreshIfStale()
		{
			if (!_fetchInProgress && !HasValidServerSeed)
			{
				((MonoBehaviour)this).StartCoroutine(FetchDaily());
			}
		}

		private IEnumerator FetchDaily()
		{
			_fetchInProgress = true;
			string text = "https://followme-peak.ddns.net/ranked/daily";
			UnityWebRequest request = UnityWebRequest.Get(text);
			try
			{
				request.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
				request.timeout = 10;
				yield return request.SendWebRequest();
				if ((int)request.result == 1)
				{
					try
					{
						DailyResponse dailyResponse = JsonConvert.DeserializeObject<DailyResponse>(request.downloadHandler.text);
						if (dailyResponse != null && dailyResponse.seed > 0)
						{
							ServerSeed = dailyResponse.seed;
							ServerSeedDate = dailyResponse.date;
							SecondsUntilRotation = dailyResponse.secondsUntilRotation;
							ServerSeason = dailyResponse.season;
							RankedLog.Info($"[DailySeed] Server-Seed fuer {dailyResponse.date}: {dailyResponse.seed} " + string.Format("(Rotation in {0}s, Saison {1})", dailyResponse.secondsUntilRotation, dailyResponse.season ?? "-"));
						}
					}
					catch (Exception ex)
					{
						RankedLog.Warning("[DailySeed] Antwort nicht parsebar: " + ex.Message);
					}
				}
				else
				{
					RankedLog.Warning($"[DailySeed] Server nicht erreichbar ({request.responseCode} {request.error}) - lokaler Fallback-Seed bleibt aktiv.");
				}
				_fetchInProgress = false;
			}
			finally
			{
				((IDisposable)request)?.Dispose();
			}
		}

		public static string GetCurrentRotationDate()
		{
			return DateTime.UtcNow.AddHours(-17.0).ToString("yyyy-MM-dd");
		}

		public static DateTime GetNextSeasonResetUtc()
		{
			DateTime utcNow = DateTime.UtcNow;
			DateTime dateTime = new DateTime(utcNow.Year, utcNow.Month, 1, 17, 0, 0, DateTimeKind.Utc);
			if (!(dateTime <= utcNow))
			{
				return dateTime;
			}
			return dateTime.AddMonths(1);
		}

		public static string ComputeSeasonId(DateTime utc)
		{
			int val = (utc.Year - FirstSeasonStart.Year) * 12 + (utc.Month - FirstSeasonStart.Month);
			return $"S{Math.Max(0, val) + 1}";
		}
	}
	internal static class RunUploadApiKey
	{
		public const string Value = "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E";
	}
	public struct SeedScopeState
	{
		public bool Active;

		public State SavedUnityState;

		public Random SavedUtilRandom;
	}
	public static class SeedScope
	{
		public static SeedScopeState Enter(Vector3 spawnerPosition)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			SeedScopeState result = default(SeedScopeState);
			if (!RankedRunGate.MayInterfere || !PhotonNetwork.IsMasterClient || SeedService.Instance == null)
			{
				return result;
			}
			try
			{
				result.SavedUnityState = Random.state;
				result.SavedUtilRandom = Util.r;
				int subSeed = SeedService.Instance.GetSubSeed(spawnerPosition);
				Random.InitState(subSeed);
				Util.r = new Random(subSeed);
				result.Active = true;
				return result;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[SeedScope] Enter fehlgeschlagen: {arg}");
				return default(SeedScopeState);
			}
		}

		public static void Exit(SeedScopeState state)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!state.Active)
			{
				return;
			}
			try
			{
				Random.state = state.SavedUnityState;
				Util.r = state.SavedUtilRandom;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[SeedScope] Exit fehlgeschlagen: {arg}");
			}
		}
	}
	public class SeedService
	{
		public const string SeedRoomPropertyKey = "RankedPeak_Seed";

		public static SeedService Instance { get; private set; }

		public int? CurrentSeed { get; private set; }

		public int? OverrideSeed { get; set; }

		public void SetOverrideSeed(int seed)
		{
			OverrideSeed = seed;
			CurrentSeed = seed;
			RankedLog.Info($"[Seed] Override-Seed gesetzt: {seed}");
		}

		public void ClearOverrideSeed()
		{
			OverrideSeed = null;
			CurrentSeed = null;
			RankedLog.Info("[Seed] Override-Seed geloescht.");
		}

		public bool TryGetSeed(out int seed)
		{
			if (OverrideSeed.HasValue)
			{
				seed = OverrideSeed.Value;
				CurrentSeed = seed;
				return true;
			}
			if (CurrentSeed.HasValue)
			{
				seed = CurrentSeed.Value;
				return true;
			}
			if (TryReadRoomSeed(out seed))
			{
				CurrentSeed = seed;
				RankedLog.Info($"[Seed] Seed aus Room-Property uebernommen: {seed}");
				return true;
			}
			return false;
		}

		public SeedService()
		{
			Instance = this;
		}

		public void ResetForNewScene()
		{
			if (!OverrideSeed.HasValue)
			{
				CurrentSeed = null;
			}
			else
			{
				CurrentSeed = OverrideSeed.Value;
			}
		}

		public int EnsureSeed()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if (OverrideSeed.HasValue)
			{
				CurrentSeed = OverrideSeed.Value;
				return OverrideSeed.Value;
			}
			if (CurrentSeed.HasValue)
			{
				return CurrentSeed.Value;
			}
			if (TryReadRoomSeed(out var seed))
			{
				CurrentSeed = seed;
				RankedLog.Info($"[Seed] Seed aus Room-Property uebernommen: {seed}");
				return seed;
			}
			if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
			{
				RankedLog.Warning("[Seed] Room-Property noch nicht da - Client wartet auf Master-Seed.");
				return -1;
			}
			GameMode value = Plugin.SelectedMode.Value;
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			int num = ((value == GameMode.StaticDaily) ? ComputeStaticDailySeed(name) : GenerateRandomSeed());
			CurrentSeed = num;
			if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
			{
				TryWriteRoomSeed(num);
			}
			RankedLog.Info($"[Seed] Neuer Seed erzeugt: {num} (Modus: {value}, Map: {name})");
			return num;
		}

		public int GetSubSeed(Vector3 spawnerPosition)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return (((EnsureSeed() * 31 + Mathf.RoundToInt(spawnerPosition.x)) * 31 + Mathf.RoundToInt(spawnerPosition.y)) * 31 + Mathf.RoundToInt(spawnerPosition.z)) & 0x7FFFFFFF;
		}

		public int GetTempleSeed()
		{
			return (EnsureSeed() * 31 + HashString("temple")) & 0x7FFFFFFF;
		}

		private static int ComputeStaticDailySeed(string mapName)
		{
			if ((Object)(object)DailySeedService.Instance != (Object)null && DailySeedService.Instance.HasValidServerSeed)
			{
				return DailySeedService.Instance.ServerSeed;
			}
			return HashString(DateTime.UtcNow.AddHours(-17.0).ToString("yyyy-MM-dd", CultureInfo.InvariantCulture) + "|" + mapName) & 0x7FFFFFFF;
		}

		private static int GenerateRandomSeed()
		{
			return new Random().Next(1, int.MaxValue);
		}

		private static int HashString(string value)
		{
			int num = -2128831035;
			foreach (char c in value)
			{
				num = (num ^ c) * 16777619;
			}
			return num;
		}

		private static bool TryReadRoomSeed(out int seed)
		{
			seed = 0;
			try
			{
				if (!PhotonNetwork.InRoom)
				{
					return false;
				}
				Room currentRoom = PhotonNetwork.CurrentRoom;
				Hashtable val = ((currentRoom != null) ? ((RoomInfo)currentRoom).CustomProperties : null);
				if (val != null && ((Dictionary<object, object>)(object)val).TryGetValue((object)"RankedPeak_Seed", out object value) && value is int num)
				{
					seed = num;
					return true;
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Seed] Room-Property nicht lesbar: " + ex.Message);
			}
			return false;
		}

		private static void TryWriteRoomSeed(int seed)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			try
			{
				Hashtable val = new Hashtable { [(object)"RankedPeak_Seed"] = seed };
				PhotonNetwork.CurrentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Seed] Room-Property nicht schreibbar: " + ex.Message);
			}
		}
	}
}
namespace RankedPeak.Patches
{
	public static class BoardingPassPatch
	{
		private static readonly List<GameObject> HiddenControls = new List<GameObject>();

		private static RaceInfo ActiveLobbyRace()
		{
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			if (raceInfo == null || !(raceInfo.Status == "lobby"))
			{
				return null;
			}
			return raceInfo;
		}

		[HarmonyPatch(typeof(BoardingPass), "StartGame")]
		[HarmonyPrefix]
		public static bool StartGamePrefix()
		{
			try
			{
				RaceInfo raceInfo = ActiveLobbyRace();
				if (raceInfo == null)
				{
					return true;
				}
				RaceService instance = RaceService.Instance;
				if (!instance.IsHost)
				{
					RankedLog.Info("[Race] Nur der Host startet das Rennen.");
					return false;
				}
				RankedLog.Info("[Race] Host startet das Rennen an der Bordkarte " + $"({raceInfo.Participants.Count}/{raceInfo.MaxPlayers} Teilnehmer).");
				instance.StartRace(delegate(string err)
				{
					RankedLog.Warning("[Race] Start fehlgeschlagen: " + err);
				});
				return false;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[Race] Bordkarten-Patch fehlgeschlagen: {arg}");
				return true;
			}
		}

		[HarmonyPatch(typeof(BoardingPass), "IncrementAscent")]
		[HarmonyPrefix]
		public static bool IncrementAscentPrefix()
		{
			return ActiveLobbyRace() == null;
		}

		[HarmonyPatch(typeof(BoardingPass), "DecrementAscent")]
		[HarmonyPrefix]
		public static bool DecrementAscentPrefix()
		{
			return ActiveLobbyRace() == null;
		}

		[HarmonyPatch(typeof(BoardingPass), "ToggleCustom")]
		[HarmonyPrefix]
		public static bool ToggleCustomPrefix()
		{
			return ActiveLobbyRace() == null;
		}

		[HarmonyPatch(typeof(BoardingPass), "OpenCustom")]
		[HarmonyPrefix]
		public static bool OpenCustomPrefix()
		{
			return ActiveLobbyRace() == null;
		}

		[HarmonyPatch(typeof(BoardingPass), "OnOpen")]
		[HarmonyPostfix]
		public static void OnOpenPostfix(BoardingPass __instance)
		{
			ShowRaceInfo(__instance);
		}

		[HarmonyPatch(typeof(BoardingPass), "UpdateAscent")]
		[HarmonyPostfix]
		public static void UpdateAscentPostfix(BoardingPass __instance)
		{
			ShowRaceInfo(__instance);
		}

		private static void ShowRaceInfo(BoardingPass boardingPass)
		{
			try
			{
				if ((Object)(object)boardingPass == (Object)null)
				{
					return;
				}
				RaceInfo raceInfo = ActiveLobbyRace();
				if (raceInfo == null)
				{
					RestoreHiddenControls();
					return;
				}
				HideDuringRace(boardingPass.incrementAscentButton);
				HideDuringRace(boardingPass.decrementAscentButton);
				HideDuringRace(boardingPass.customRunButton);
				HideDuringRace(boardingPass.customOptionsButton);
				RaceService instance = RaceService.Instance;
				if ((Object)(object)boardingPass.ascentTitle != (Object)null)
				{
					boardingPass.ascentTitle.text = "RACE " + raceInfo.InviteCode;
				}
				if (!((Object)(object)boardingPass.ascentDesc != (Object)null))
				{
					return;
				}
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(Loc.T("race.pass.participants", raceInfo.Participants.Count, raceInfo.MaxPlayers));
				stringBuilder.Append("   ·   " + RunConfigService.GetAscentName(raceInfo.Ascent));
				stringBuilder.Append("   ·   " + RunConfigService.GetRouteName(raceInfo.Route));
				stringBuilder.AppendLine();
				foreach (RaceParticipant participant in raceInfo.Participants)
				{
					bool flag = participant.SteamId == raceInfo.HostSteamId;
					stringBuilder.Append(participant.PlayerName + (flag ? (" (" + Loc.T("common.host") + ")") : string.Empty) + "   ");
				}
				stringBuilder.AppendLine();
				stringBuilder.Append(Loc.T(((Object)(object)instance != (Object)null && instance.IsHost) ? "race.pass.hostHint" : "race.pass.guestHint"));
				boardingPass.ascentDesc.text = stringBuilder.ToString();
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Race] Bordkarte konnte nicht beschriftet werden: " + ex.Message);
			}
		}

		private static void HideDuringRace(Button button)
		{
			if (!((Object)(object)button == (Object)null) && ((Component)button).gameObject.activeSelf)
			{
				((Component)button).gameObject.SetActive(false);
				HiddenControls.Add(((Component)button).gameObject);
			}
		}

		private static void RestoreHiddenControls()
		{
			if (HiddenControls.Count == 0)
			{
				return;
			}
			foreach (GameObject hiddenControl in HiddenControls)
			{
				if ((Object)(object)hiddenControl != (Object)null)
				{
					hiddenControl.SetActive(true);
				}
			}
			RankedLog.Info($"[Race] {HiddenControls.Count} Bordkarten-Bedienelemente wieder freigegeben.");
			HiddenControls.Clear();
		}
	}
	[HarmonyPatch(typeof(EndScreen), "Initialize")]
	public static class EndScreenTakeoverPatch
	{
		private const string ContentName = "RankedPeak_Content";

		private const float PaperWidth = 780f;

		private const float PaperHeight = 580f;

		private const float SplitsBoxHeight = 175f;

		private const float StandingsBoxHeight = 215f;

		private const int MaxStandingRows = 8;

		private static bool _structureLogged;

		public static bool Active { get; private set; }

		[HarmonyPostfix]
		public static void InitializePostfix(EndScreen __instance)
		{
			try
			{
				LogStructureOnce(__instance);
				Active = BuildTakeover(__instance);
			}
			catch (Exception arg)
			{
				Active = false;
				RankedLog.Error($"[EndScreen] Uebernahme fehlgeschlagen: {arg}");
			}
		}

		private static bool BuildTakeover(EndScreen endScreen)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (((Object)(object)endScreen != (Object)null) ? endScreen.timelinePanel : null);
			if ((Object)(object)val == (Object)null)
			{
				RankedLog.Warning("[EndScreen] timelinePanel fehlt - Bericht bleibt Vanilla.");
				return false;
			}
			RaceTimer instance = RaceTimer.Instance;
			RunRecord runRecord = instance?.LastRunRecord;
			if (runRecord == null || instance.State != TimerState.Finished)
			{
				RankedLog.Info("[EndScreen] Kein abgeschlossener Run - Bericht bleibt Vanilla.");
				return false;
			}
			Transform parent = ((Transform)val).parent;
			Transform val2 = (((Object)(object)parent != (Object)null) ? parent.parent : null);
			Transform val3 = (((Object)(object)val2 != (Object)null) ? val2.parent : null);
			Transform val4 = (((Object)(object)val3 != (Object)null) ? val3.parent : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val4 == (Object)null)
			{
				RankedLog.Warning("[EndScreen] Berichtsaufbau unerwartet - Bericht bleibt Vanilla.");
				return false;
			}
			((RectTransform)val4).sizeDelta = new Vector2(780f, 580f);
			TMP_Text endTime = endScreen.endTime;
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace ?? RaceService.Instance?.LastFinishedRace;
			EndScreenTakeover endScreenTakeover = ((Component)endScreen).gameObject.GetComponent<EndScreenTakeover>() ?? ((Component)endScreen).gameObject.AddComponent<EndScreenTakeover>();
			endScreenTakeover.Initialize(endTime, FormatTime(runRecord.TotalMs), CollectBannerLabels(endScreen), BannerText(runRecord, raceInfo));
			HideScoutWindows(endScreen);
			WidenTimeBox(endScreen);
			Rect rect = ((RectTransform)val2).rect;
			float height = ((Rect)(ref rect)).height;
			List<Transform> list = CollectBoxes(val2);
			RankedLog.Debug($"[EndScreen] Blatt {780f}x{580f}, Spaltenhoehe {height:0.#}, " + $"{list.Count} Sektionen.");
			Transform val5 = ((list.Count > 1) ? list[1] : null);
			Transform val6 = ((list.Count > 2) ? list[2] : null);
			if ((Object)(object)val5 != (Object)null)
			{
				FillSplits(PrepareBox(val5, Loc.T("summary.box.splits"), endTime, 175f), runRecord, endTime);
			}
			if ((Object)(object)val6 != (Object)null)
			{
				string title = Loc.T((raceInfo != null) ? "summary.box.race" : "summary.box.run");
				RectTransform content = PrepareBox(val6, title, endTime, 215f);
				if (raceInfo != null)
				{
					List<TextMeshProUGUI> rows = CreateStandingRows(content, endTime);
					endScreenTakeover.TrackStandings(content, endTime, rows);
				}
				else
				{
					FillRunInfo(content, runRecord, endTime);
				}
			}
			RankedLog.Info("[EndScreen] Bericht uebernommen (" + ((raceInfo != null) ? "Race" : "Solo") + ", " + $"{runRecord.Splits.Count} Splits).");
			return true;
		}

		private static TMP_Text[] CollectBannerLabels(EndScreen endScreen)
		{
			GameObject[] obj = new GameObject[5] { endScreen.peakBanner, endScreen.peakNadirBanner, endScreen.deadBanner, endScreen.yourFriendsWonBanner, endScreen.miniWinBanner };
			List<TMP_Text> list = new List<TMP_Text>();
			GameObject[] array = (GameObject[])(object)obj;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				TMP_Text[] componentsInChildren = val.GetComponentsInChildren<TMP_Text>(true);
				foreach (TMP_Text val2 in componentsInChildren)
				{
					LocalizedText component = ((Component)val2).GetComponent<LocalizedText>();
					if ((Object)(object)component != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)component);
					}
					list.Add(val2);
				}
			}
			return list.ToArray();
		}

		private static string BannerText(RunRecord record, RaceInfo race)
		{
			if (record.Result == RunResult.Died)
			{
				return Loc.T("verdict.died");
			}
			if (record.Result == RunResult.Aborted)
			{
				return Loc.T("verdict.aborted");
			}
			if (race != null)
			{
				RaceParticipant raceParticipant = race.Participants.Find((RaceParticipant p) => p.SteamId == SteamIdentity.GetSteamId64());
				if (raceParticipant != null && raceParticipant.Rank == 1)
				{
					return Loc.T("verdict.raceWon");
				}
				if (raceParticipant != null && raceParticipant.Rank.HasValue)
				{
					return Loc.T("verdict.placeN", raceParticipant.Rank);
				}
				return Loc.T("verdict.finished");
			}
			return Loc.T("verdict.done");
		}

		private static void HideScoutWindows(EndScreen endScreen)
		{
			if (endScreen.scoutWindows == null)
			{
				return;
			}
			EndScreenScoutWindow[] scoutWindows = endScreen.scoutWindows;
			foreach (EndScreenScoutWindow val in scoutWindows)
			{
				if (!((Object)(object)val == (Object)null))
				{
					(((Component)val).GetComponent<LayoutElement>() ?? ((Component)val).gameObject.AddComponent<LayoutElement>()).ignoreLayout = true;
					(((Component)val).GetComponent<CanvasGroup>() ?? ((Component)val).gameObject.AddComponent<CanvasGroup>()).alpha = 0f;
				}
			}
		}

		private static void WidenTimeBox(EndScreen endScreen)
		{
			TMP_Text endTime = endScreen.endTime;
			if (!((Object)(object)endTime == (Object)null))
			{
				Transform parent = endTime.transform.parent;
				if (!((Object)(object)parent == (Object)null))
				{
					LayoutElement obj = ((Component)parent).GetComponent<LayoutElement>() ?? ((Component)parent).gameObject.AddComponent<LayoutElement>();
					obj.preferredWidth = 340f;
					obj.flexibleWidth = 0f;
					endTime.textWrappingMode = (TextWrappingModes)0;
					endTime.overflowMode = (TextOverflowModes)0;
				}
			}
		}

		private static List<Transform> CollectBoxes(Transform column)
		{
			List<Transform> list = new List<Transform>();
			for (int i = 0; i < column.childCount; i++)
			{
				list.Add(column.GetChild(i));
			}
			return list;
		}

		private static RectTransform PrepareBox(Transform box, string title, TMP_Text template, float height)
		{
			//IL_0001: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			RectTransform val = (RectTransform)box;
			LayoutElement obj = ((Component)box).GetComponent<LayoutElement>() ?? ((Component)box).gameObject.AddComponent<LayoutElement>();
			obj.preferredHeight = height;
			obj.flexibleHeight = 0f;
			val.sizeDelta = new Vector2(val.sizeDelta.x, height);
			Transform val2 = box.Find("RankedPeak_Content");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)((Component)val2).gameObject);
			}
			for (int i = 0; i < box.childCount; i++)
			{
				Transform child = box.GetChild(i);
				if (((Object)child).name == "Title")
				{
					LocalizedText component = ((Component)child).GetComponent<LocalizedText>();
					if ((Object)(object)component != (Object)null)
					{
						Object.DestroyImmediate((Object)(object)component);
					}
					TMP_Text component2 = ((Component)child).GetComponent<TMP_Text>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.text = title;
					}
				}
				else if (!(((Object)child).name == "Border"))
				{
					((Component)child).gameObject.SetActive(false);
				}
			}
			GameObject val3 = new GameObject("RankedPeak_Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(box, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(12f, 8f);
			val4.offsetMax = new Vector2(-12f, -34f);
			return val4;
		}

		private static void FillSplits(RectTransform content, RunRecord record, TMP_Text template)
		{
			Place(CreateLabel(content, "Header", "#<pos=12%>" + Loc.T("summary.col.segment") + "<pos=55%>" + Loc.T("summary.col.total") + "<pos=80%>" + Loc.T("summary.col.time"), template, 11f, 0.55f), 0f, 16f);
			int num = Math.Min(record.Splits.Count, 6);
			for (int i = 0; i < num; i++)
			{
				SplitRecord splitRecord = record.Splits[i];
				long num2 = ((i > 0) ? record.Splits[i - 1].ElapsedMs : 0);
				Place(CreateLabel(content, $"Split{i}", $"{i + 1}<pos=12%>{splitRecord.SegmentName}<pos=55%>{FormatTime(splitRecord.ElapsedMs)}" + "<pos=80%>" + FormatTime(splitRecord.ElapsedMs - num2), template, 13f, 0.95f), 20f + (float)i * 18f, 18f);
			}
		}

		private static List<TextMeshProUGUI> CreateStandingRows(RectTransform content, TMP_Text template)
		{
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace ?? RaceService.Instance?.LastFinishedRace;
			string text = ((raceInfo != null) ? raceInfo.InviteCode : string.Empty);
			Place(CreateLabel(content, "Header", "RACE " + text + "<pos=45%>" + Loc.T("summary.col.player") + "<pos=80%>" + Loc.T("summary.col.time"), template, 11f, 0.55f), 0f, 16f);
			List<TextMeshProUGUI> list = new List<TextMeshProUGUI>();
			for (int i = 0; i < 8; i++)
			{
				TextMeshProUGUI val = CreateLabel(content, $"Standing{i}", string.Empty, template, 13f, 0.85f);
				Place(val, 20f + (float)i * 18f, 18f);
				((Component)val).gameObject.SetActive(false);
				list.Add(val);
			}
			return list;
		}

		private static void FillRunInfo(RectTransform content, RunRecord record, TMP_Text template)
		{
			RaceTimer instance = RaceTimer.Instance;
			List<string> list = new List<string>();
			list.Add(Loc.T("summary.info.mode", record.Mode) + "      " + Loc.T("summary.info.map", record.MapName, MapCatalog.ToDisplaySignature(record.BiomeId)) + "      " + Loc.T("summary.info.ascent", record.AscentLevel, record.GameVersion));
			list.Add(Loc.T("summary.info.seed", record.Seed));
			list.Add(Loc.T("summary.info.route", RunConfigService.GetRouteName(record.RouteIndex)) + (string.IsNullOrEmpty(record.RouteBiomeName) ? string.Empty : (" (" + record.RouteBiomeName + ")")));
			List<string> list2 = list;
			if (record.Result == RunResult.Completed && instance != null)
			{
				list2.Add(instance.LastRunWasPersonalBest ? Loc.T("summary.newPb") : Loc.T("summary.pbDelta", FormatDelta(instance.LastRunDeltaToPbMs)));
			}
			else if (record.Result != RunResult.Completed)
			{
				list2.Add(Loc.T((record.Result == RunResult.Died) ? "hud.died" : "hud.aborted"));
			}
			for (int i = 0; i < list2.Count; i++)
			{
				Place(CreateLabel(content, $"Info{i}", list2[i], template, 13f, 0.9f), 4f + (float)i * 20f, 20f);
			}
		}

		private static int CompareStandings(RaceParticipant a, RaceParticipant b)
		{
			int num = Weight(a).CompareTo(Weight(b));
			if (num != 0)
			{
				return num;
			}
			if (Weight(a) == 0)
			{
				return (a.Rank ?? int.MaxValue).CompareTo(b.Rank ?? int.MaxValue);
			}
			return b.Progress.CompareTo(a.Progress);
			static int Weight(RaceParticipant p)
			{
				if (!(p.State == "finished"))
				{
					if (!(p.State == "dnf"))
					{
						return 1;
					}
					return 2;
				}
				return 0;
			}
		}

		private static TextMeshProUGUI CreateLabel(RectTransform parent, string name, string text, TMP_Text template, float fontSize, float alpha)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val.transform.SetParent((Transform)(object)parent, false);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			if ((Object)(object)template != (Object)null && (Object)(object)template.font != (Object)null)
			{
				((TMP_Text)component).font = template.font;
				((TMP_Text)component).fontSharedMaterial = template.fontSharedMaterial;
			}
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = fontSize;
			Color color = (Color)(((Object)(object)template != (Object)null) ? ((Graphic)template).color : new Color(0.25f, 0.22f, 0.19f));
			color.a = alpha;
			((Graphic)component).color = color;
			((TMP_Text)component).alignment = (TextAlignmentOptions)513;
			((TMP_Text)component).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)component).overflowMode = (TextOverflowModes)0;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		private static void Place(TextMeshProUGUI label, float y, float height)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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)
			RectTransform val = (RectTransform)((TMP_Text)label).transform;
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = new Vector2(0f, 0f - y);
			val.sizeDelta = new Vector2(0f, height);
		}

		private static void LogStructureOnce(EndScreen endScreen)
		{
			if (_structureLogged || (Object)(object)endScreen == (Object)null || (Object)(object)endScreen.timelinePanel == (Object)null)
			{
				return;
			}
			_structureLogged = true;
			Transform parent = ((Transform)endScreen.timelinePanel).parent;
			object obj;
			if (parent == null)
			{
				obj = null;
			}
			else
			{
				Transform parent2 = parent.parent;
				if (parent2 == null)
				{
					obj = null;
				}
				else
				{
					Transform parent3 = parent2.parent;
					obj = ((parent3 != null) ? parent3.parent : null);
				}
			}
			Transform val = (Transform)obj;
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("[EndScreenDump] Blatt '" + ((Object)val).name + "' " + Describe(val));
			for (int i = 0; i < val.childCount; i++)
			{
				Transform child = val.GetChild(i);
				stringBuilder.AppendLine($"  [{i}] {Describe(child)}");
			}
			Transform parent4 = val.parent;
			if ((Object)(object)parent4 != (Object)null)
			{
				stringBuilder.AppendLine("[EndScreenDump] Canvas '" + ((Object)parent4).name + "' Kinder:");
				for (int j = 0; j < parent4.childCount; j++)
				{
					stringBuilder.AppendLine($"  [{j}] {Describe(parent4.GetChild(j))}");
				}
			}
			RankedLog.Debug(stringBuilder.ToString());
		}

		private static string Describe(Transform t)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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)
			RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
			if (val != null)
			{
				return $"'{((Object)t).name}' pos={val.anchoredPosition} size={val.sizeDelta} " + $"anchorMin={val.anchorMin} anchorMax={val.anchorMax} active={((Component)t).gameObject.activeSelf}";
			}
			return $"'{((Object)t).name}' active={((Component)t).gameObject.activeSelf}";
		}

		private static string FormatTime(long ms)
		{
			TimeSpan timeSpan = TimeSpan.FromMilliseconds(ms);
			return $"{(int)timeSpan.TotalMinutes:00}:{timeSpan.Seconds:00}.{timeSpan.Milliseconds:000}";
		}

		private static string FormatDelta(long deltaMs)
		{
			return ((double)deltaMs / 1000.0).ToString("+0.000' s';-0.000' s'", CultureInfo.InvariantCulture);
		}
	}
	public static class MainMenuPatches
	{
		[HarmonyPatch(typeof(MainMenuPageHandler), "Start")]
		public static class PageInjectionPatch
		{
			public static void Prefix(MainMenuPageHandler __instance)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if (!((Object)(object)((Component)__instance).GetComponentInChildren<RankedPeakMenuPage>(true) != (Object)null))
					{
						MainMenuMainPage componentInChildren = ((Component)__instance).GetComponentInChildren<MainMenuMainPage>(true);
						Transform val = (((Object)(object)componentInChildren != (Object)null) ? ((Component)componentInChildren).transform.parent : ((Component)__instance).transform);
						new GameObject("RankedPeakMenuPage", new Type[2]
						{
							typeof(RectTransform),
							typeof(RankedPeakMenuPage)
						}).transform.SetParent(val, false);
						RankedLog.Info("[Menu] RankedPeak-Page ins Hauptmenue injiziert.");
					}
				}
				catch (Exception arg)
				{
					RankedLog.Error($"[Menu] Page-Injektion fehlgeschlagen: {arg}");
				}
			}
		}

		[HarmonyPatch(typeof(MainMenuMainPage), "Start")]
		public static class SignpostPatch
		{
			internal readonly struct SignEntry
			{
				public readonly Button Button;

				public readonly float HeadPadding;

				public readonly float TailOffset;

				public readonly string LocKey;

				public readonly bool EloMark;

				public SignEntry(Button button, float headPadding, string locKey, bool eloMark = false, float tailOffset = 0f)
				{
					Button = button;
					HeadPadding = headPadding;
					LocKey = locKey;
					EloMark = eloMark;
					TailOffset = tailOffset;
				}

				public string BuildText()
				{
					if (!EloMark)
					{
						return Loc.T(LocKey);
					}
					return WithEloMark(Loc.T(LocKey));
				}
			}

			public class SignLanguageRefresher : MonoBehaviour
			{
				private readonly List<SignEntry> _signs = new List<SignEntry>();

				internal void Track(List<SignEntry> signs)
				{
					_signs.Clear();
					_signs.AddRange(signs);
				}

				private void OnEnable()
				{
					Loc.LanguageChanged += Apply;
				}

				private void OnDisable()
				{
					Loc.LanguageChanged -= Apply;
				}

				private void Apply()
				{
					foreach (SignEntry sign in _signs)
					{
						if (!((Object)(object)sign.Button == (Object)null) && !string.IsNullOrEmpty(sign.LocKey))
						{
							TextMeshProUGUI componentInChildren = ((Component)sign.Button).GetComponentInChildren<TextMeshProUGUI>(true);
							if ((Object)(object)componentInChildren != (Object)null)
							{
								((TMP_Text)componentInChildren).text = sign.BuildText();
							}
						}
					}
					LayoutSignLabels(_signs);
					RankedLog.Info("[Menu] Schildermast in neuer Sprache beschriftet.");
				}
			}

			private const float SignEdgeX = -110f;

			private const float MinSignWidth = 190f;

			private const float SpeedrunTailOffset = 50f;

			private const float LiveRaceTailOffset = 75f;

			private const float SettingsTailOffset = 100f;

			private const float MaxSignWidth = 440f;

			private const float SignHeight = 52f;

			private const float SignGapY = 10f;

			private const float GroupGapY = 18f;

			private const int RankedSignCount = 2;

			private const float UtilityGapY = 16f;

			private const int PlaySignCount = 4;

			private const float HeaderY = 190f;

			private const float HeaderHeight = 66f;

			private const float IconInset = 40f;

			private const float IconSize = 26f;

			private const float IconPitch = 18f;

			private const float HeaderIconSize = 32f;

			private const float TextHeadPadding = 70f;

			private const float TextIconGap = 17f;

			private const float TextTailPadding = 22f;

			private const float SignFontSize = 24f;

			internal const float HeaderFontSize = 28f;

			private static readonly Color EloMarkColor = new Color(0.647f, 0.31f, 0.063f);

			private static float MaxTextWidthFor(float headPadding)
			{
				return 440f - headPadding - 22f;
			}

			private static float IconColumnStart(float iconSize)
			{
				return 40f - iconSize / 2f;
			}

			private static float IconBlockWidth(int count, float iconSize)
			{
				return iconSize + (float)Mathf.Max(0, count - 1) * 18f;
			}

			private static float HeadPaddingFor(int iconCount, float iconSize)
			{
				return IconColumnStart(iconSize) + IconBlockWidth(iconCount, iconSize) + 17f;
			}

			public static void Postfix(MainMenuMainPage __instance)
			{
				try
				{
					RaceService.ResetGameSettings();
					RankedRunGate.Disarm();
					BuildRightSignpost(__instance);
				}
				catch (Exception arg)
				{
					RankedLog.Error($"[Menu] Erstellung des rechten Schildermastes fehlgeschlagen: {arg}");
				}
				try
				{
					RankedLogoBanner.Attach(((Component)__instance).transform);
				}
				catch (Exception arg2)
				{
					RankedLog.Error($"[Menu] RANKED-Schriftzug fehlgeschlagen: {arg2}");
				}
				try
				{
					AiDisclosureBubble.Attach(((Component)__instance).transform);
				}
				catch (Exception arg3)
				{
					RankedLog.Error($"[Menu] KI-Sprechblase fehlgeschlagen: {arg3}");
				}
				SeasonSign.Attach();
				MenuHierarchyDump.Dump(__instance);
			}

			private static void BuildRightSignpost(MainMenuMainPage page)
			{
				//IL_030a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0314: Unknown result type (might be due to invalid IL or missing references)
				//IL_0331: Unknown result type (might be due to invalid IL or missing references)
				//IL_033b: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0261: Unknown result type (might be due to invalid IL or missing references)
				//IL_0270: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Unknown result type (might be due to invalid IL or missing references)
				//IL_028d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0592: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a28: Unknown result type (might be due to invalid IL or missing references)
				//IL_0619: Unknown result type (might be due to invalid IL or missing references)
				Button playButton = page.m_playButton;
				Button settingsButton = page.m_settingsButton;
				if ((Object)(object)playButton == (Object)null && (Object)(object)settingsButton == (Object)null)
				{
					RankedLog.Warning("[Menu] Keine Vanilla-Buttons auf MainPage gefunden.");
					return;
				}
				Transform val = (((Object)(object)playButton != (Object)null) ? ((Component)playButton).transform.parent : ((Component)settingsButton).transform.parent);
				if ((Object)(object)val == (Object)null)
				{
					RankedLog.Warning("[Menu] Button-Container nicht gefunden.");
					return;
				}
				Transform val2 = (((Object)(object)val.parent != (Object)null && (Object)(object)val.parent != (Object)(object)((Component)page).transform) ? val.parent : val);
				Transform val3 = (((Object)(object)val2.parent != (Object)null) ? val2.parent : ((Component)page).transform);
				if ((Object)(object)val3.Find("RankedSignpostContainer") != (Object)null)
				{
					RankedLog.Info("[Menu] Rechter Ranked-Schildermast existiert bereits.");
					return;
				}
				RankedLog.Info("[Menu] Klone gesamten Schildermast: '" + ((Object)val2).name + "'...");
				GameObject val4 = Object.Instantiate<GameObject>(((Component)val2).gameObject, val3);
				((Object)val4).name = "RankedSignpostContainer";
				val4.transform.SetSiblingIndex(val2.GetSiblingIndex() + 1);
				MainMenuMainPage component = val4.GetComponent<MainMenuMainPage>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				RectTransform val5 = (RectTransform)(object)((val2 is RectTransform) ? val2 : null);
				if (val5 != null)
				{
					Transform transform = val4.transform;
					RectTransform val6 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					if (val6 != null)
					{
						val6.anchorMin = val5.anchorMin;
						val6.anchorMax = val5.anchorMax;
						val6.pivot = val5.pivot;
						val6.sizeDelta = new Vector2(val5.sizeDelta.x, 700f);
						float num = -84f;
						val6.anchoredPosition = new Vector2(340f, val5.anchoredPosition.y + num);
						((Transform)val6).localScale = new Vector3(-1.35f, 1.35f, ((Transform)val5).localScale.z);
						string[] array = new string[2] { "Panel (3)", "Panel (2)" };
						foreach (string text in array)
						{
							Transform obj = val4.transform.Find(text);
							RectTransform val7 = (RectTransform)(object)((obj is RectTransform) ? obj : null);
							if (val7 == null)
							{
								RankedLog.Warning("[Menu] Pfosten-Panel '" + text + "' nicht gefunden - der rechte Mast bleibt in Vanilla-Laenge.");
								continue;
							}
							val7.sizeDelta = new Vector2(val7.sizeDelta.x, 810f);
							val7.anchoredPosition = new Vector2(val7.anchoredPosition.x, -90f);
						}
						SignpostAnimationFollower signpostAnimationFollower = val4.AddComponent<SignpostAnimationFollower>();
						signpostAnimationFollower.TargetLeftMast = val5;
						signpostAnimationFollower.RightMast = val6;
						signpostAnimationFollower.TargetX = 340f;
						signpostAnimationFollower.YOffset = num;
						RankedLog.Debug($"[Menu] Rechter Mast positioniert & Animations-Follower aktiv: pos={val6.anchoredPosition}, scale={((Transform)val6).localScale}");
						goto IL_0345;
					}
				}
				val4.transform.localPosition = new Vector3(340f, 210f, val2.localPosition.z);
				val4.transform.localScale = new Vector3(-1.35f, 1.35f, val2.localScale.z);
				goto IL_0345;
				IL_0345:
				LocalizedText[] componentsInChildren = val4.GetComponentsInChildren<LocalizedText>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Object.Destroy((Object)(object)componentsInChildren[i]);
				}
				Transform val8 = val4.transform.Find("Buttons") ?? val4.transform;
				Transform obj2 = val8.Find("Button_PlayWithFriends");
				object obj3 = ((obj2 != null) ? ((Component)obj2).GetComponent<Button>() : null);
				if (obj3 == null)
				{
					Transform obj4 = val8.Find("Button_Host");
					obj3 = ((obj4 != null) ? ((Component)obj4).GetComponent<Button>() : null);
				}
				Button val9 = (Button)obj3;
				Transform obj5 = val8.Find("Button_PlaySolo");
				object obj6 = ((obj5 != null) ? ((Component)obj5).GetComponent<Button>() : null);
				if (obj6 == null)
				{
					Transform obj7 = val8.Find("Button_Offline");
					obj6 = ((obj7 != null) ? ((Component)obj7).GetComponent<Button>() : null);
				}
				Transform obj8 = val8.Find("Button_Settings");
				Button val10 = ((obj8 != null) ? ((Component)obj8).GetComponent<Button>() : null);
				Transform obj9 = val8.Find("Button_Credits");
				Button val11 = ((obj9 != null) ? ((Component)obj9).GetComponent<Button>() : null);
				Transform obj10 = val8.Find("Button_Discord");
				Button val12 = ((obj10 != null) ? ((Component)obj10).GetComponent<Button>() : null);
				Transform obj11 = val8.Find("Button_Quit");
				Button val13 = ((obj11 != null) ? ((Component)obj11).GetComponent<Button>() : null);
				Transform obj12 = val8.Find("Button_Continue");
				Button val14 = ((obj12 != null) ? ((Component)obj12).GetComponent<Button>() : null);
				if ((Object)(object)val12 != (Object)null)
				{
					((Component)val12).gameObject.SetActive(false);
				}
				Button val15 = null;
				if ((Object)(object)val14 != (Object)null)
				{
					val15 = val14;
					((Component)val15).gameObject.SetActive(true);
				}
				else if ((Object)(object)val9 != (Object)null)
				{
					GameObject obj13 = Object.Instantiate<GameObject>(((Component)val9).gameObject, val8);
					obj13.transform.SetAsFirstSibling();
					val15 = obj13.GetComponent<Button>();
				}
				if ((Object)(object)val15 != (Object)null)
				{
					PlaceSign(val15, 190f, 66f);
				}
				Transform val16 = val.Find("Button_PlaySolo") ?? val.Find("Button_Offline") ?? val.Find("Button_PlayWithFriends");
				Transform val17 = val.Find("Button_Settings") ?? val.Find("Button_Credits");
				if ((Object)(object)val16 == (Object)null || (Object)(object)val17 == (Object)null)
				{
					RankedLog.Warning("[Menu] Vanilla-Brettformen nicht vollstaendig gefunden - die Schilder behalten die Form ihres geklonten Buttons.");
				}
				Image val18 = FindPersonIcon(val);
				Sprite val19 = (((Object)(object)val18 != (Object)null) ? val18.sprite : null);
				Color? iconTint = (((Object)(object)val18 != (Object)null) ? new Color?(((Graphic)val18).color) : ((Color?)null));
				if ((Object)(object)val19 == (Object)null)
				{
					RankedLog.Warning("[Menu] Vanilla-Maennchen-Sprite nicht gefunden - benutze prozedurale Symbole.");
				}
				List<Button> list = new List<Button>();
				List<SignEntry> list2 = new List<SignEntry>();
				if ((Object)(object)val15 != (Object)null)
				{
					PlayerRating playerRating = RatingService.Instance?.CurrentRating;
					ConfigureSign(text: BuildHeaderSignText(playerRating), iconSprite: (playerRating != null) ? RankedMenuIcons.GetTierIcon(playerRating.Tier) : RankedMenuIcons.GetCrownIcon(), iconTint: (playerRating != null) ? new Color?(RankedMenuIcons.GetTierColorOnLight(playerRating.Tier)) : ((Color?)null), button: val15, name: "Header", iconCount: 1, headPadding: 70f, onClick: delegate
					{
						//IL_0016: Unknown result type (might be due to invalid IL or missing references)
						//IL_0020: Expected O, but got Unknown
						MainMenuPageHandler componentInParent = ((Component)page).GetComponentInParent<MainMenuPageHandler>();
						if ((Object)(object)componentInParent != (Object)null)
						{
							((UIPageHandler)componentInParent).TransistionToPage<RankedPeakMenuPage>((PageTransistion)new SetActivePageTransistion());
						}
					}, isHeader: true);
					CopyBoardShape(val17, ((Component)val15).transform);
					FitSignToLabel(val15, 28f);
					(((Component)val15).gameObject.GetComponent<HeaderRatingSignUpdater>() ?? ((Component)val15).gameObject.AddComponent<HeaderRatingSignUpdater>()).Button = val15;
					list.Add(val15);
				}
				Button val20 = (Button)obj6;
				if ((Object)(object)val20 != (Object)null)
				{
					PlaceSign(val20, SignY(0), 52f);
					float headPadding = HeadPaddingFor(1, 26f);
					ConfigureSign(val20, "DailyCup", WithEloMark(Loc.T("mode.staticDaily")), val19 ?? RankedMenuIcons.GetTargetIcon(), 1, headPadding, delegate
					{
						GhostPlaybackService.Instance?.ClearExternalGhost();
						SeedService.Instance?.ClearOverrideSeed();
						RunConfigService.ResetToRankedDefaults();
						if (!RankedRunGate.Select(GameMode.StaticDaily, MapCatalog.CurrentLevelIndex))
						{
							RankedNoticeModal.Show(Loc.T("gate.mapAltered.title"), RankedRunGate.LastRefusal);
						}
						else
						{
							RankedLog.Info("[Menu] DAILY CUP gewaehlt -> starte direkt ins Level...");
							RankedGameLauncher.LaunchDirectToIsland();
						}
					}, isHeader: false, iconTint);
					CopyBoardShape(val16, ((Component)val20).transform);
					list.Add(val20);
					list2.Add(new SignEntry(val20, headPadding, "mode.staticDaily", eloMark: true));
				}
				Button val21 = val9;
				if ((Object)(object)val21 != (Object)null)
				{
					PlaceSign(val21, SignY(1), 52f);
					float headPadding2 = HeadPaddingFor(1, 26f);
					ConfigureSign(val21, "GhostDuell", WithEloMark(Loc.T("mode.rankedDuel")), val19 ?? RankedMenuIcons.GetDuelSwordsIcon(), 1, headPadding2, delegate
					{
						RunConfigService.ResetToRankedDefaults();
						if (!MapCatalog.IsSlotAuthentic(MapCatalog.CurrentLevelIndex))
						{
							RankedRunGate.Select(GameMode.RankedDuel, MapCatalog.CurrentLevelIndex);
							RankedNoticeModal.Show(Loc.T("gate.mapAltered.title"), RankedRunGate.LastRefusal);
						}
						else
						{
							RankedLog.Info("[Menu] GHOST DUELL gewaehlt -> starte Matchmaking...");
							DuelService.Instance?.StartDuelMatchmaking(delegate(DuelMatchInfo match)
							{
								RankedLog.Info($"[Menu] Gegner gefunden: {match.GhostPlayerName} ({match.GhostElo} ELO) -> Starte direkt ins Level!");
								RankedGameLauncher.LaunchDirectToIsland();
							}, delegate(string err)
							{
								RankedLog.Warning("[Menu] Duell-Fehler: " + err);
								if (!RankedRunGate.Select(GameMode.RankedDuel, MapCatalog.CurrentLevelIndex))
								{
									RankedNoticeModal.Show(Loc.T("gate.mapAltered.title"), RankedRunGate.LastRefusal);
								}
								else
								{
									RankedGameLauncher.LaunchDirectToIsland();
								}
							});
						}
					}, isHeader: false, iconTint);
					CopyBoardShape(val16, ((Component)val21).transform);
					list.Add(val21);
					list2.Add(new SignEntry(val21, headPadding2, "mode.rankedDuel", eloMark: true));
				}
				Button val22 = val10;
				if ((Object)(object)val22 != (Object)null)
				{
					PlaceSign(val22, SignY(2), 52f, 50f);
					float headPadding3 = HeadPaddingFor(1, 26f);
					ConfigureSign(val22, "Speedrun", Loc.T("mode.speedrun"), val19 ?? RankedMenuIcons.GetStopwatchIcon(), 1, headPadding3, delegate
					{
						RankedLog.Info("[Menu] SPEEDRUN gewaehlt -> oeffne Setup-Dialog...");
						CustomRunModal.OpenSpeedrun();
					}, isHeader: false, iconTint);
					CopyBoardShape(val16, ((Component)val22).transform);
					list.Add(val22);
					list2.Add(new SignEntry(val22, headPadding3, "mode.speedrun", eloMark: false, 50f));
				}
				Button val23 = val11;
				if ((Object)(object)val23 != (Object)null)
				{
					PlaceSign(val23, SignY(3), 52f, 75f);
					int iconCount = ((!((Object)(object)val19 != (Object)null)) ? 1 : 2);
					float headPadding4 = HeadPaddingFor(iconCount, 26f);
					ConfigureSign(val23, "LiveRace", Loc.T("mode.liveRace"), val19 ?? RankedMenuIcons.GetCompassIcon(), iconCount, headPadding4, delegate
					{
						RankedLog.Info("[Menu] LIVE RACE gewaehlt -> oeffne Setup-Dialog...");
						CustomRunModal.OpenRace();
					}, isHeader: false, iconTint);
					CopyBoardShape(val16, ((Component)val23).transform);
					list.Add(val23);
					list2.Add(new SignEntry(val23, headPadding4, "mode.liveRace", eloMark: false, 75f));
				}
				Button val24 = val13;
				if ((Object)(object)val24 != (Object)null)
				{
					PlaceSign(val24, SignY(4), 52f, 100f);
					float headPadding5 = HeadPaddingFor(1, 26f);
					ConfigureSign(val24, "Settings", Loc.T("sign.settings"), RankedMenuIcons.GetGearIcon(), 1, headPadding5, delegate
					{
						RankedLog.Info("[Menu] EINSTELLUNGEN gewaehlt -> oeffne Fenster...");
						RankedSettingsModal.OpenWindow();
					});
					CopyBoardShape(val17, ((Component)val24).transform);
					list.Add(val24);
					list2.Add(new SignEntry(val24, headPadding5, "sign.settings", eloMark: false, 100f));
				}
				else
				{
					RankedLog.Warning("[Menu] Kein geklonter Button fuer das Schild EINSTELLUNGEN - " + $"das Fenster bleibt ueber {Plugin.SettingsMenuKey.Value} erreichbar.");
				}
				LayoutSignLabels(list2);
				(val4.GetComponent<SignLanguageRefresher>() ?? val4.AddComponent<SignLanguageRefresher>()).Track(list2);
				SetupNavigation(page, list);
				RankedLog.Info("[Menu] Rechter gespiegelter Ranked-Schildermast erfolgreich erstellt.");
			}

			private static float SignY(int index)
			{
				float num = 121f - (float)index * 62f;
				if (index >= 2)
				{
					num -= 18f;
				}
				if (index >= 4)
				{
					num -= 16f;
				}
				return num;
			}

			private static string WithEloMark(string label)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				string text = ColorUtility.ToHtmlStringRGB(EloMarkColor);
				return "<color=#" + text + "><cspace=0.12em>ELO</cspace></color>  " + label;
			}

			private static void CopyBoardShape(Transform source, Transform target)
			{
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)source == (Object)null || (Object)(object)target == (Object)null)
				{
					return;
				}
				Transform val = source.Find("Hinge") ?? source;
				Transform val2 = target.Find("Hinge") ?? target;
				string[] array = new string[3] { "Shadow", "PanelDrop", "Panel" };
				foreach (string text in array)
				{
					Transform obj = val.Find(text);
					Image val3 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
					Transform obj2 = val2.Find(text);
					Image val4 = ((obj2 != null) ? ((Component)obj2).GetComponent<Image>() : null);
					if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null) && !((Object)(object)val3.sprite == (Object)null))
					{
						val4.sprite = val3.sprite;
						val4.type = val3.type;
						val4.fillCenter = val3.fillCenter;
						val4.pixelsPerUnitMultiplier = val3.pixelsPerUnitMultiplier;
					}
				}
			}

			private static Image FindPersonIcon(Transform leftButtonContainer)
			{
				Transform val = leftButtonContainer.Find("Button_PlayWithFriends/Hinge/Icons") ?? leftButtonContainer.Find("Button_PlaySolo/Hinge/Icons");
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				Image[] componentsInChildren = ((Component)val).GetComponentsInChildren<Image>(true);
				foreach (Image val2 in componentsInChildren)
				{
					if ((Object)(object)val2.sprite != (Object)null)
					{
						return val2;
					}
				}
				return null;
			}

			private static void PlaceSign(Button button, float y, float height, float tailOffset = 0f)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				RectTransform val = (RectTransform)((Component)button).transform;
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.pivot = new Vector2(0.5f, 0.5f);
				((Transform)val).localScale = Vector3.one;
				val.sizeDelta = new Vector2(440f, height);
				val.anchoredPosition = new Vector2(-110f + tailOffset + 220f, y);
			}

			internal static void FitSignToLabel(Button button, float fontSize, float headPadding = 70f, float tailOffset = 0f)
			{
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)button == (Object)null)
				{
					return;
				}
				TextMeshProUGUI componentInChildren = ((Component)button).GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren == (Object)null)
				{
					return;
				}
				((TMP_Text)componentInChildren).fontSize = fontSize;
				((TMP_Text)componentInChildren).ForceMeshUpdate(false, false);
				float preferredWidth = ((TMP_Text)componentInChildren).preferredWidth;
				if (preferredWidth <= 0f)
				{
					RankedLog.Warning("[Menu] Schildbreite fuer '" + ((Object)((Component)button).gameObject).name + "' nicht messbar - Standardbreite bleibt.");
					return;
				}
				float num = MaxTextWidthFor(headPadding);
				if (preferredWidth > num)
				{
					((TMP_Text)componentInChildren).fontSize = fontSize * num / preferredWidth;
					((TMP_Text)componentInChildren).ForceMeshUpdate(false, false);
					preferredWidth = ((TMP_Text)componentInChildren).preferredWidth;
				}
				float num2 = Mathf.Clamp(headPadding + preferredWidth + 22f, 190f, 440f);
				RectTransform val = (RectTransform)((Component)button).transform;
				val.sizeDelta = new Vector2(num2, val.sizeDelta.y);
				val.anchoredPosition = new Vector2(-110f + tailOffset + num2 / 2f, val.anchoredPosition.y);
			}

			internal static string BuildHeaderSignText(PlayerRating rating)
			{
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				if (rating == null)
				{
					return Loc.T("sign.ranked");
				}
				int num;
				string text;
				if (rating.Ranked)
				{
					num = ((!string.Equals(rating.Tier, "UNRANKED", StringComparison.OrdinalIgnoreCase)) ? 1 : 0);
					if (num != 0)
					{
						text = rating.FormattedTierName;
						goto IL_0042;
					}
				}
				else
				{
					num = 0;
				}
				text = Loc.T("sign.ranked");
				goto IL_0042;
				IL_0042:
				string text2 = text;
				string text3 = ((num != 0) ? $"{rating.Elo:N0} ELO" : Loc.T("sign.placement", rating.PlacementGames));
				string text4 = ColorUtility.ToHtmlStringRGB(RankedMenuIcons.GetTierColorOnLight(rating.Tier));
				return "<color=#" + text4 + "><cspace=0.05em>" + text2 + "</cspace></color>  <size=80%>• " + text3 + "</size>";
			}

			private static void ConfigureSign(Button button, string name, string text, Sprite iconSprite, int iconCount, float headPadding, Action onClick, bool isHeader = false, Color? iconTint = null)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0391: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03db: Unknown result type (might be due to invalid IL or missing references)
				//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0406: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				//IL_0419: Unknown result type (might be due to invalid IL or missing references)
				//IL_0432: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_0294: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ce: 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_02e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0311: Unknown result type (might be due to invalid IL or missing references)
				//IL_031b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_0339: Unknown result type (might be due to invalid IL or missing references)
				((Object)((Component)button).gameObject).name = "RankedSign_" + name;
				((Component)button).gameObject.SetActive(true);
				((UnityEventBase)button.onClick).RemoveAllListeners();
				((UnityEvent)button.onClick).AddListener(new UnityAction(onClick.Invoke));
				Transform val = ((Component)button).transform.Find("Hinge") ?? ((Component)button).transform;
				if ((Object)(object)val != (Object)(object)((Component)button).transform)
				{
					RectTransform val2 = (RectTransform)(object)((val is RectTransform) ? val : null);
					if (val2 != null)
					{
						val2.anchorMin = Vector2.zero;
						val2.anchorMax = Vector2.one;
						val2.offsetMin = Vector2.zero;
						val2.offsetMax = Vector2.zero;
					}
				}
				Transform val3 = val.Find("Shadow");
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val3).gameObject.SetActive(true);
				}
				Transform val4 = val.Find("PanelDrop");
				if ((Object)(object)val4 != (Object)null)
				{
					((Component)val4).gameObject.SetActive(true);
				}
				Transform val5 = val.Find("Panel");
				if ((Object)(object)val5 != (Object)null)
				{
					((Component)val5).gameObject.SetActive(true);
				}
				float num = (isHeader ? 32f : 26f);
				TextMeshProUGUI componentInChildren = ((Component)button).GetComponentInChildren<TextMeshProUGUI>(true);
				Color val6 = (((Object)(object)componentInChildren != (Object)null) ? ((Graphic)componentInChildren).color : Color.white);
				Transform val7 = val.Find("Icons");
				if ((Object)(object)val7 != (Object)null)
				{
					HorizontalLayoutGroup component = ((Component)val7).GetComponent<HorizontalLayoutGroup>();
					if ((Object)(object)component != (Object)null)
					{
						((Behaviour)component).enabled = false;
					}
					int num2 = (((Object)(object)iconSprite != (Object)null) ? Mathf.Max(1, iconCount) : 0);
					RectTransform val8 = (RectTransform)val7;
					val8.anchorMin = new Vector2(1f, 0.5f);
					val8.anchorMax = new Vector2(1f, 0.5f);
					val8.pivot = new Vector2(1f, 0.5f);
					val8.anchoredPosition = new Vector2(0f - IconColumnStart(num), 0f);
					val8.sizeDelta = new Vector2(IconBlockWidth(num2, num), num);
					((Transform)val8).localScale = Vector3.one;
					for (int num3 = val7.childCount - 1; num3 >= 0; num3--)
					{
						Object.Destroy((Object)(object)((Component)val7.GetChild(num3)).gameObject);
					}
					if (num2 > 0)
					{
						((Component)val7).gameObject.SetActive(true);
						for (int i = 0; i < num2; i++)
						{
							GameObject val9 = new GameObject($"RankedIcon{i}", new Type[2]
							{
								typeof(RectTransform),
								typeof(Image)
							});
							val9.transform.SetParent(val7, false);
							Image component2 = val9.GetComponent<Image>();
							component2.sprite = iconSprite;
							((Graphic)component2).color = iconTint ?? val6;
							RectTransform val10 = (RectTransform)val9.transform;
							val10.anchorMin = new Vector2(1f, 0.5f);
							val10.anchorMax = new Vector2(1f, 0.5f);
							val10.pivot = new Vector2(0.5f, 0.5f);
							val10.anchoredPosition = new Vector2(0f - (num / 2f + (float)i * 18f), 0f);
							val10.sizeDelta = new Vector2(num, num);
							((Transform)val10).localScale = new Vector3(-1f, 1f, 1f);
						}
					}
					else
					{
						((Component)val7).gameObject.SetActive(false);
					}
				}
				TextMeshProUGUI[] componentsInChildren = ((Component)button).GetComponentsInChildren<TextMeshProUGUI>(true);
				foreach (TextMeshProUGUI obj in componentsInChildren)
				{
					((TMP_Text)obj).text = text;
					((TMP_Text)obj).alignment = (TextAlignmentOptions)513;
					((TMP_Text)obj).fontStyle = (FontStyles)0;
					((TMP_Text)obj).margin = Vector4.zero;
					((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
					((TMP_Text)obj).textWrappingMode = (TextWrappingModes)0;
					((TMP_Text)obj).enableAutoSizing = false;
					((TMP_Text)obj).fontSize = (isHeader ? 28f : 24f);
					RectTransform val11 = (RectTransform)((TMP_Text)obj).transform;
					val11.anchorMin = Vector2.zero;
					val11.anchorMax = Vector2.one;
					val11.pivot = new Vector2(0.5f, 0.5f);
					val11.offsetMin = new Vector2(22f, 0f);
					val11.offsetMax = new Vector2(0f - headPadding, 0f);
					((Transform)val11).localScale = new Vector3(-1f, 1f, 1f);
				}
			}

			private static void LayoutSignLabels(List<SignEntry> signs)
			{
				float num = 24f;
				foreach (SignEntry sign in signs)
				{
					TextMeshProUGUI componentInChildren = ((Component)sign.Button).GetComponentInChildren<TextMeshProUGUI>(true);
					if (!((Object)(object)componentInChildren == (Object)null))
					{
						((TMP_Text)componentInChildren).fontSize = 24f;
						((TMP_Text)componentInChildren).ForceMeshUpdate(false, false);
						float preferredWidth = ((TMP_Text)componentInChildren).preferredWidth;
						float num2 = MaxTextWidthFor(sign.HeadPadding);
						if (preferredWidth > num2)
						{
							num = Mathf.Min(num, 24f * num2 / preferredWidth);
						}
					}
				}
				foreach (SignEntry sign2 in signs)
				{
					FitSignToLabel(sign2.Button, num, sign2.HeadPadding, sign2.TailOffset);
				}
				RankedLog.Debug($"[Menu] Einheitliche Schild-Schriftgroesse: {num:0.#}");
			}

			private static void SetupNavigation(MainMenuMainPage page, List<Button> rightButtons)
			{
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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)
				//IL_012e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				List<Button> list = new List<Button>();
				if ((Object)(object)page.m_playButton != (Object)null)
				{
					list.Add(page.m_playButton);
				}
				if ((Object)(object)page.m_continueButton != (Object)null && ((Component)page.m_continueButton).gameObject.activeSelf)
				{
					list.Add(page.m_continueButton);
				}
				if ((Object)(object)page.m_settingsButton != (Object)null)
				{
					list.Add(page.m_settingsButton);
				}
				if ((Object)(object)page.m_quitButton != (Object)null)
				{
					list.Add(page.m_quitButton);
				}
				if (list.Count != 0 && rightButtons.Count != 0)
				{
					for (int i = 0; i < rightButtons.Count; i++)
					{
						Navigation navigation = ((Selectable)rightButtons[i]).navigation;
						((Navigation)(ref navigation)).mode = (Mode)4;
						((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)rightButtons[(i - 1 + rightButtons.Count) % rightButtons.Count];
						((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)rightButtons[(i + 1) % rightButtons.Count];
						((Selectable)rightButtons[i]).navigation = navigation;
					}
					for (int j = 0; j < list.Count; j++)
					{
						Button obj = list[j];
						int index = Mathf.Clamp(j * rightButtons.Count / list.Count, 0, rightButtons.Count - 1);
						Button selectOnRight = rightButtons[index];
						Navigation navigation2 = ((Selectable)obj).navigation;
						((Navigation)(ref navigation2)).mode = (Mode)4;
						((Navigation)(ref navigation2)).selectOnRight = (Selectable)(object)selectOnRight;
						((Selectable)obj).navigation = navigation2;
					}
					for (int k = 0; k < rightButtons.Count; k++)
					{
						Button obj2 = rightButtons[k];
						int index2 = Mathf.Clamp(k * list.Count / rightButtons.Count, 0, list.Count - 1);
						Button selectOnLeft = list[index2];
						Navigation navigation3 = ((Selectable)obj2).navigation;
						((Navigation)(ref navigation3)).selectOnLeft = (Selectable)(object)selectOnLeft;
						((Selectable)rightButtons[k]).navigation = navigation3;
					}
				}
			}
		}

		public class SignpostAnimationFollower : MonoBehaviour
		{
			public RectTransform TargetLeftMast;

			public RectTransform RightMast;

			public float TargetX = 340f;

			public float YOffset = -84f;

			private void LateUpdate()
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)TargetLeftMast == (Object)null) && !((Object)(object)RightMast == (Object)null))
				{
					float num = TargetLeftMast.anchoredPosition.y + YOffset;
					Vector2 anchoredPosition = RightMast.anchoredPosition;
					if (Mathf.Abs(anchoredPosition.y - num) > 0.01f || Mathf.Abs(anchoredPosition.x - TargetX) > 0.01f)
					{
						RightMast.anchoredPosition = new Vector2(TargetX, num);
					}
				}
			}
		}

		public class HeaderRatingSignUpdater : MonoBehaviour
		{
			public Button Button;

			private void OnEnable()
			{
				RatingService.RatingUpdated += OnRatingUpdated;
				if ((Object)(object)RatingService.Instance != (Object)null && RatingService.Instance.CurrentRating != null)
				{
					OnRatingUpdated(RatingService.Instance.CurrentRating);
				}
				RatingService.Instance?.RefreshRating();
			}

			private void OnDisable()
			{
				RatingService.RatingUpdated -= OnRatingUpdated;
			}

			private void OnRatingUpdated(PlayerRating rating)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)Button == (Object)null) && rating != null)
				{
					Color tierColorOnLight = RankedMenuIcons.GetTierColorOnLight(rating.Tier);
					Transform obj = (((Component)Button).transform.Find("Hinge") ?? ((Component)Button).transform).Find("Icons/RankedIcon0");
					Image val = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
					if ((Object)(object)val != (Object)null)
					{
						val.sprite = RankedMenuIcons.GetTierIcon(rating.Tier);
						((Graphic)val).color = tierColorOnLight;
					}
					string text = SignpostPatch.BuildHeaderSignText(rating);
					TextMeshProUGUI[] componentsInChildren = ((Component)Button).GetComponentsInChildren<TextMeshProUGUI>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						((TMP_Text)componentsInChildren[i]).text = text;
					}
					SignpostPatch.FitSignToLabel(Button, 28f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterInput), "Sample")]
	public static class RaceInputLockPatch
	{
		[HarmonyPostfix]
		public static void SamplePostfix(CharacterInput __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!RaceInputLock.IsLocked || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				__instance.movementInput = Vector2.zero;
				__instance.lookInput = Vector2.zero;
				__instance.scrollInput = 0f;
				__instance.jumpWasPressed = false;
				__instance.jumpIsPressed = false;
				__instance.sprintIsPressed = false;
				__instance.sprintWasPressed = false;
				__instance.sprintToggleIsPressed = false;
				__instance.sprintToggleWasPressed = false;
				__instance.crouchIsPressed = false;
				__instance.crouchWasPressed = false;
				__instance.crouchToggleWasPressed = false;
				__instance.interactWasPressed = false;
				__instance.interactIsPressed = false;
				__instance.interactWasReleased = false;
				__instance.dropWasPressed = false;
				__instance.dropIsPressed = false;
				__instance.dropWasReleased = false;
				__instance.usePrimaryWasPressed = false;
				__instance.usePrimaryIsPressed = false;
				__instance.usePrimaryWasReleased = false;
				__instance.useSecondaryWasPressed = false;
				__instance.useSecondaryIsPressed = false;
				__instance.useSecondaryWasReleased = false;
				__instance.selectSlotForwardWasPressed = false;
				__instance.selectSlotBackwardWasPressed = false;
				__instance.unselectSlotWasPressed = false;
				__instance.selectBackpackWasPressed = false;
				__instance.scrollForwardWasPressed = false;
				__instance.scrollBackwardWasPressed = false;
			}
			catch (Exception ex)
			{
				RankedLog.Error("[RaceInputLock] Sperre fehlgeschlagen: " + ex.Message);
				RaceInputLock.ForceUnlock("Sperre nicht anwendbar");
			}
		}
	}
	public static class RunLifecyclePatches
	{
		private static string _campfireCompletedSegmentName;

		private static bool _gameEndingDetected;

		private static bool _localPlayerDiedThisRun;

		[HarmonyPatch(typeof(RunManager), "StartRun")]
		[HarmonyPostfix]
		public static void StartRunPostfix()
		{
			try
			{
				_gameEndingDetected = false;
				_localPlayerDiedThisRun = false;
				RankedLog.Info("[RunLifecycle] RunManager.StartRun - Run gestartet.");
				RaceTimer.Instance?.OnRunStarted();
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] Fehler in StartRunPostfix: {arg}");
			}
		}

		[HarmonyPatch(typeof(Campfire), "Light_Rpc")]
		[HarmonyPrefix]
		public static void CampfireLightPrefix()
		{
			try
			{
				_campfireCompletedSegmentName = null;
				MapHandler instance = Singleton<MapHandler>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					_campfireCompletedSegmentName = GetSegmentDisplayName(instance, instance.currentSegment);
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] Fehler in CampfireLightPrefix: {arg}");
			}
		}

		[HarmonyPatch(typeof(Campfire), "Light_Rpc")]
		[HarmonyPostfix]
		public static void CampfireLightPostfix(Campfire __instance)
		{
			try
			{
				if (_campfireCompletedSegmentName != null)
				{
					string campfireCompletedSegmentName = _campfireCompletedSegmentName;
					_campfireCompletedSegmentName = null;
					if (IsMiniRunEndingCampfire(__instance))
					{
						OnRunCompleted("Campfire.Light_Rpc (Mini-Run-Ziel)", campfireCompletedSegmentName);
					}
					else
					{
						RaceTimer.Instance?.AddSplit(campfireCompletedSegmentName);
					}
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] Fehler in CampfireLightPostfix: {arg}");
			}
		}

		private static bool IsMiniRunEndingCampfire(Campfire campfire)
		{
			try
			{
				return (Object)(object)campfire != (Object)null && campfire.IsMiniRunEndingCampfire();
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunLifecycle] IsMiniRunEndingCampfire nicht lesbar: " + ex.Message);
				return false;
			}
		}

		private static bool IsMiniRunActive()
		{
			bool result = false;
			try
			{
				result = RunSettings.GetValue((SETTINGTYPE)10000, false) == 1 || RunSettings.GetValue((SETTINGTYPE)10000, true) == 1;
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunLifecycle] MiniRun-Einstellung nicht lesbar: " + ex.Message);
			}
			return result;
		}

		private static string GetSegmentDisplayName(MapHandler mapHandler, int segmentIndex)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MountainProgressHandler instance = Singleton<MountainProgressHandler>.Instance;
				ProgressPoint[] array = (((Object)(object)instance != (Object)null) ? instance.progressPoints : null);
				if (array != null && segmentIndex >= 0 && segmentIndex < array.Length)
				{
					string title = array[segmentIndex].title;
					if (!string.IsNullOrEmpty(title))
					{
						return title;
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning($"[RunLifecycle] Progress-Point-Titel nicht lesbar (Segment {segmentIndex}): {ex.Message}");
			}
			try
			{
				return GetBiomeDisplayName(mapHandler.GetCurrentBiome());
			}
			catch (Exception)
			{
				return (segmentIndex >= 0 && segmentIndex <= 6) ? ((object)(Segment)(byte)segmentIndex/*cast due to .constrained prefix*/).ToString() : "Unknown";
			}
		}

		private unsafe static string GetBiomeDisplayName(BiomeType biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected I4, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			switch ((int)biome)
			{
			default:
				if ((int)biome != 17)
				{
					break;
				}
				return "Void";
			case 0:
				return "Shore";
			case 1:
				return "Tropics";
			case 7:
				return "Roots";
			case 2:
				return "Alpine";
			case 6:
				return "Mesa";
			case 3:
				return "Caldera";
			case 8:
				return "Gloom";
			case 5:
				return "Peak";
			case 4:
				break;
			}
			return ((object)(*(BiomeType*)(&biome))/*cast due to .constrained prefix*/).ToString();
		}

		[HarmonyPatch(typeof(Character), "RPCA_Die")]
		[HarmonyPostfix]
		[HarmonyPriority(600)]
		public static void RpcaDiePostfix(Character __instance)
		{
			OnCharacterDied(__instance, "RPCA_Die");
		}

		[HarmonyPatch(typeof(Character), "Die")]
		[HarmonyPostfix]
		[HarmonyPriority(600)]
		public static void DiePostfix(Character __instance)
		{
			OnCharacterDied(__instance, "Die");
		}

		private static void OnCharacterDied(Character character, string source)
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				if (!((Object)(object)localCharacter != (Object)null) || localCharacter == character)
				{
					RankedLog.Info("[RunLifecycle] Lokaler Spieler gestorben (" + source + ").");
					_localPlayerDiedThisRun = true;
					RaceTimer.Instance?.OnPlayerDied();
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] Fehler in OnCharacterDied ({source}): {arg}");
			}
		}

		public static void ApplyEndGamePatches(Harmony harmony)
		{
			try
			{
				if (TryPatchCharacterEndGame(harmony))
				{
					RankedLog.Info("[RunLifecycle] Character.EndGame gepatcht.");
				}
				else if (TryPatchRunManagerEndGame(harmony))
				{
					RankedLog.Info("[RunLifecycle] RunManager.EndGame gepatcht (Fallback).");
				}
				else if (TryPatchPeakSequence(harmony))
				{
					RankedLog.Info("[RunLifecycle] PeakSequence.CheckGameComplete gepatcht (Fallback).");
				}
				else
				{
					RankedLog.Error("[RunLifecycle] Kein EndGame-Patch moeglich - Run-Ende wird nicht erkannt.");
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] EndGame-Patches fehlgeschlagen: {arg}");
			}
		}

		private static bool TryPatchCharacterEndGame(Harmony harmony)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Character), "EndGame", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					RankedLog.Warning("[RunLifecycle] Character.EndGame nicht gefunden.");
					return false;
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(RunLifecyclePatches), "CharacterEndGamePrefix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
				{
					priority = 200
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] TryPatchCharacterEndGame fehlgeschlagen: {arg}");
				return false;
			}
		}

		private static bool TryPatchRunManagerEndGame(Harmony harmony)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(RunManager), "EndGame", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					RankedLog.Warning("[RunLifecycle] RunManager.EndGame nicht gefunden.");
					return false;
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(RunLifecyclePatches), "RunManagerEndGamePrefix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
				{
					priority = 200
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] TryPatchRunManagerEndGame fehlgeschlagen: {arg}");
				return false;
			}
		}

		private static bool TryPatchPeakSequence(Harmony harmony)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(PeakSequence), "CheckGameComplete", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					RankedLog.Warning("[RunLifecycle] PeakSequence.CheckGameComplete nicht gefunden.");
					return false;
				}
				MethodInfo methodInfo2 = AccessTools.Method(typeof(RunLifecyclePatches), "PeakSequenceCheckGameCompletePostfix", (Type[])null, (Type[])null);
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2)
				{
					priority = 200
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] TryPatchPeakSequence fehlgeschlagen: {arg}");
				return false;
			}
		}

		public static void CharacterEndGamePrefix()
		{
			TryDetectRunEnd("Character.EndGame");
		}

		public static void RunManagerEndGamePrefix()
		{
			TryDetectRunEnd("RunManager.EndGame");
		}

		public static void PeakSequenceCheckGameCompletePostfix(ref bool ___endingGame)
		{
			if (___endingGame && !_gameEndingDetected)
			{
				TryDetectRunEnd("PeakSequence.CheckGameComplete");
			}
		}

		private static void TryDetectRunEnd(string source)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected I4, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MapHandler instance = Singleton<MapHandler>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					RankedLog.Warning("[RunLifecycle] " + source + ": MapHandler nicht verfuegbar, Segment nicht pruefbar.");
					return;
				}
				Segment currentSegment = instance.GetCurrentSegment();
				if ((int)currentSegment != 4 && !IsMiniRunActive())
				{
					RankedLog.Info($"[RunLifecycle] {source} in Segment {currentSegment} - nicht am Peak, kein Run-Ende.");
				}
				else
				{
					OnRunCompleted(source, GetSegmentDisplayName(instance, (int)currentSegment));
				}
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[RunLifecycle] Fehler bei Run-Ende-Erkennung ({source}): {arg}");
			}
		}

		private static void OnRunCompleted(string source, string finalSegmentName)
		{
			if (!_gameEndingDetected)
			{
				_gameEndingDetected = true;
				if (_localPlayerDiedThisRun || IsLocalPlayerDead())
				{
					RankedLog.Info("[RunLifecycle] " + source + ": Spieler ist tot - Run gilt als Died, nicht Completed (Bug B1).");
					RaceTimer.Instance?.OnPlayerDied();
					return;
				}
				RankedLog.Info("[RunLifecycle] Run-Ende erkannt via " + source + " (Zielsegment: " + finalSegmentName + ").");
				RaceTimer.Instance?.FinishRun(finalSegmentName);
			}
		}

		private static bool IsLocalPlayerDead()
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				return (Object)(object)localCharacter != (Object)null && (Object)(object)localCharacter.data != (Object)null && localCharacter.data.dead;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(RunSettings), "LoadFromDisk")]
	public static class RunSettingsPatch
	{
		[HarmonyPostfix]
		public static void LoadFromDiskPostfix()
		{
			try
			{
				RunConfigService.ReapplyPendingCustomRun();
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[RunSettingsPatch] Nachziehen der Race-Konfiguration fehlgeschlagen: " + ex.Message);
			}
		}
	}
	public static class SeedScopePatches
	{
		[HarmonyPatch(typeof(Spawner), "TrySpawnItems")]
		public static class TrySpawnItemsPatch
		{
			public static void Prefix(Spawner __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(Spawner __instance, SeedScopeState __state, List<PhotonView> __result)
			{
				SeedScope.Exit(__state);
				LogSpawnResult((MonoBehaviour)(object)__instance, "TrySpawnItems", __result);
			}
		}

		[HarmonyPatch(typeof(Spawner), "SpawnItems")]
		public static class SpawnItemsPatch
		{
			public static void Prefix(Spawner __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(Spawner __instance, SeedScopeState __state, List<PhotonView> __result)
			{
				SeedScope.Exit(__state);
				LogSpawnResult((MonoBehaviour)(object)__instance, "SpawnItems", __result);
			}
		}

		[HarmonyPatch(typeof(Spawner), "GetSpawnSpots")]
		public static class GetSpawnSpotsPatch
		{
			public static void Prefix(Spawner __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(SeedScopeState __state)
			{
				SeedScope.Exit(__state);
			}
		}

		[HarmonyPatch(typeof(GroundPlaceSpawner), "SpawnItems")]
		public static class GroundPlaceSpawnerPatch
		{
			public static void Prefix(GroundPlaceSpawner __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(GroundPlaceSpawner __instance, SeedScopeState __state, List<PhotonView> __result)
			{
				SeedScope.Exit(__state);
				LogSpawnResult((MonoBehaviour)(object)__instance, "GroundPlaceSpawner.SpawnItems", __result);
			}
		}

		[HarmonyPatch(typeof(BerryBush), "SpawnItems")]
		public static class BerryBushPatch
		{
			public static void Prefix(BerryBush __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(BerryBush __instance, SeedScopeState __state, List<PhotonView> __result)
			{
				SeedScope.Exit(__state);
				LogSpawnResult((MonoBehaviour)(object)__instance, "BerryBush.SpawnItems", __result);
			}
		}

		[HarmonyPatch(typeof(BerryVine), "SpawnItems")]
		public static class BerryVinePatch
		{
			public static void Prefix(BerryVine __instance, out SeedScopeState __state)
			{
				EnterScope((MonoBehaviour)(object)__instance, out __state);
			}

			public static void Postfix(BerryVine __instance, SeedScopeState __state, List<PhotonView> __result)
			{
				SeedScope.Exit(__state);
				LogSpawnResult((MonoBehaviour)(object)__instance, "BerryVine.SpawnItems", __result);
			}
		}

		[HarmonyPatch(typeof(TempleConfig), "CreateTemple_RPC")]
		public static class TempleSeedPatch
		{
			public static void Prefix(ref int seed)
			{
				if (!RankedRunGate.MayInterfere || SeedService.Instance == null)
				{
					return;
				}
				try
				{
					seed = SeedService.Instance.GetTempleSeed();
				}
				catch (Exception arg)
				{
					RankedLog.Error($"[Seed] Temple-Seed-Patch fehlgeschlagen: {arg}");
				}
			}
		}

		private static void EnterScope(MonoBehaviour spawner, out SeedScopeState state)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			state = (((Object)(object)spawner != (Object)null) ? SeedScope.Enter(((Component)spawner).transform.position) : default(SeedScopeState));
		}

		private static void LogSpawnResult(MonoBehaviour spawner, string method, List<PhotonView> result)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.DebugSpawnLogging.Value || !PhotonNetwork.IsMasterClient || SeedService.Instance == null || !SeedService.Instance.CurrentSeed.HasValue)
			{
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				if (result != null)
				{
					foreach (PhotonView item in result)
					{
						if ((Object)(object)item != (Object)null)
						{
							if (stringBuilder.Length > 0)
							{
								stringBuilder.Append(", ");
							}
							stringBuilder.Append(((Object)item).name);
						}
					}
				}
				Vector3 position = ((Component)spawner).transform.position;
				Plugin.Log.LogInfo((object)($"[SpawnLog] seed={SeedService.Instance.CurrentSeed.Value} {method} " + $"spawner={((Object)spawner).name} pos=({position.x:F1},{position.y:F1},{position.z:F1}) items=[{stringBuilder}]"));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[SpawnLog] Logging fehlgeschlagen: " + ex.Message));
			}
		}
	}
	public static class SentinelPatches
	{
		public static readonly List<string> MissingAnchors = new List<string>();

		private static bool _consoleGuardApplied;

		public static int GuardedCommandCount { get; private set; }

		public static void Apply(Harmony harmony)
		{
			MissingAnchors.Clear();
			GuardedCommandCount = 0;
			_consoleGuardApplied = false;
			GuardWarp(harmony);
			GuardItemSpawn(harmony);
			GuardForceWin(harmony);
			GuardImpulses(harmony);
			RankedLog.Info("[Sentinel] Methoden-Wachen gesetzt" + ((MissingAnchors.Count > 0) ? (", fehlende Anker: " + string.Join(", ", MissingAnchors.ToArray())) : ", alle Anker gefunden") + ".");
		}

		public static void ApplyConsoleGuards(Harmony harmony)
		{
			if (!_consoleGuardApplied)
			{
				_consoleGuardApplied = true;
				GuardConsoleCommands(harmony);
				RankedLog.Info($"[Sentinel] {GuardedCommandCount} Spiel-Konsolenbefehle bewacht.");
			}
		}

		private static void GuardConsoleCommands(Harmony harmony)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			try
			{
				List<ConsoleCommand> consoleCommandMethods = ConsoleCommands.ConsoleCommandMethods;
				if (consoleCommandMethods == null || consoleCommandMethods.Count == 0)
				{
					MissingAnchors.Add("ConsoleCommands.ConsoleCommandMethods");
					return;
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(SentinelPatches), "ConsoleCommandPrefix", (Type[])null, (Type[])null);
				int num = 0;
				foreach (ConsoleCommand item in consoleCommandMethods)
				{
					MethodInfo methodInfo2 = item.MethodInfo;
					if (!(methodInfo2 == null) && !methodInfo2.IsAbstract && !methodInfo2.ContainsGenericParameters)
					{
						try
						{
							harmony.Patch((MethodBase)methodInfo2, new HarmonyMethod(methodInfo)
							{
								priority = 800
							}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							GuardedCommandCount++;
						}
						catch (Exception ex)
						{
							num++;
							RankedLog.Warning("[Sentinel] Konsolenbefehl " + methodInfo2.DeclaringType?.Name + "." + methodInfo2.Name + " nicht bewachbar: " + ex.Message);
						}
					}
				}
				if (num > 0)
				{
					RankedLog.Warning($"[Sentinel] {num} Konsolenbefehl(e) liessen sich nicht bewachen " + "(Namen siehe die Zeilen darueber).");
				}
			}
			catch (Exception ex2)
			{
				RankedLog.Warning("[Sentinel] Konsolen-Wache fehlgeschlagen: " + ex2.Message);
				MissingAnchors.Add("ConsoleCommands.ConsoleCommandMethods");
			}
		}

		public static void ConsoleCommandPrefix(MethodBase __originalMethod)
		{
			try
			{
				if (RunSentinel.Watching)
				{
					RunSentinel.Instance?.OnConsoleCommand(__originalMethod?.DeclaringType?.Name ?? "?", __originalMethod?.Name ?? "?");
				}
			}
			catch (Exception)
			{
			}
		}

		private static void GuardWarp(Harmony harmony)
		{
			TryPatch(harmony, typeof(Character), "WarpPlayer", "WarpPlayerPrefix", new Type[2]
			{
				typeof(Vector3),
				typeof(bool)
			});
			TryPatch(harmony, typeof(Character), "WarpPlayerRPC", "WarpPlayerRpcPrefix", new Type[2]
			{
				typeof(Vector3),
				typeof(bool)
			});
		}

		public static void WarpPlayerPrefix(Character __instance, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ReportWarp(__instance, position, remote: false);
		}

		public static void WarpPlayerRpcPrefix(Character __instance, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ReportWarp(__instance, position, remote: true);
		}

		private static void ReportWarp(Character character, Vector3 position, bool remote)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (RunSentinel.Watching && IsLocal(character))
				{
					RunSentinel.Instance?.OnWarp(position, remote);
				}
			}
			catch (Exception)
			{
			}
		}

		private static void GuardItemSpawn(Harmony harmony)
		{
			TryPatch(harmony, typeof(CharacterItems), "SpawnItemInHand", "SpawnItemInHandPrefix", new Type[1] { typeof(string) });
			TryPatch(harmony, typeof(CharacterItems), "RPC_SpawnItemInHandMaster", "SpawnItemInHandMasterPrefix", new Type[1] { typeof(string) });
		}

		public static void SpawnItemInHandPrefix(string objName)
		{
			ReportSpawn(objName, viaRpc: false);
		}

		public static void SpawnItemInHandMasterPrefix(string objName)
		{
			ReportSpawn(objName, viaRpc: true);
		}

		private static void ReportSpawn(string objName, bool viaRpc)
		{
			try
			{
				if (RunSentinel.Watching)
				{
					RunSentinel.Instance?.OnItemSpawn(objName ?? "?", viaRpc);
				}
			}
			catch (Exception)
			{
			}
		}

		private static void GuardForceWin(Harmony harmony)
		{
			TryPatch(harmony, typeof(Character), "RPCEndGame_ForceWin", "ForceWinPrefix", Type.EmptyTypes);
		}

		public static void ForceWinPrefix()
		{
			try
			{
				if (RunSentinel.Watching)
				{
					RunSentinel.Instance?.OnForceWin();
				}
			}
			catch (Exception)
			{
			}
		}

		private static void GuardImpulses(Harmony harmony)
		{
			TryPatch(harmony, typeof(Character), "AddForce", "AddForcePrefix", new Type[3]
			{
				typeof(Vector3),
				typeof(float),
				typeof(float)
			});
			TryPatch(harmony, typeof(Character), "RPCA_AddForceAtPosition", "AddForceAtPositionPrefix", new Type[3]
			{
				typeof(Vector3),
				typeof(Vector3),
				typeof(float)
			});
		}

		public static void AddForcePrefix(Character __instance, Vector3 move)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ReportImpulse(__instance, move);
		}

		public static void AddForceAtPositionPrefix(Character __instance, Vector3 force)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			ReportImpulse(__instance, force);
		}

		private static void ReportImpulse(Character character, Vector3 force)
		{
			try
			{
				if (RunSentinel.Watching && IsLocal(character))
				{
					RunSentinel.Instance?.OnImpulse(((Vector3)(ref force)).magnitude);
				}
			}
			catch (Exception)
			{
			}
		}

		private static bool IsLocal(Character character)
		{
			try
			{
				Character localCharacter = Character.localCharacter;
				return (Object)(object)localCharacter != (Object)null && (Object)(object)character != (Object)null && localCharacter == character;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static void TryPatch(Harmony harmony, Type type, string methodName, string prefixName, Type[] parameters)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			string text = type.Name + "." + methodName;
			try
			{
				MethodInfo methodInfo = AccessTools.Method(type, methodName, parameters, (Type[])null);
				if (methodInfo == null)
				{
					RankedLog.Warning("[Sentinel] Anker fehlt: " + text);
					MissingAnchors.Add(text);
				}
				else
				{
					MethodInfo methodInfo2 = AccessTools.Method(typeof(SentinelPatches), prefixName, (Type[])null, (Type[])null);
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2)
					{
						priority = 800
					}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Sentinel] Wache " + text + " fehlgeschlagen: " + ex.Message);
				MissingAnchors.Add(text);
			}
		}
	}
}
namespace RankedPeak.Models
{
	public class ClimbRecord
	{
		public Guid Id { get; set; } = Guid.NewGuid();

		public DateTime CreationTime { get; set; }

		public string BiomeName { get; set; } = string.Empty;

		public float DurationInSeconds { get; set; }

		public int AscentLevel { get; set; }

		public bool WasDeathClimb { get; set; }

		public string PlayerName { get; set; } = "Local";

		public string PointData { get; set; } = string.Empty;

		public Guid RunId { get; set; }

		public string MapName { get; set; } = string.Empty;

		[JsonConverter(typeof(StringEnumConverter))]
		public GameMode Mode { get; set; }

		[JsonConverter(typeof(StringEnumConverter))]
		public RunResult Result { get; set; }

		public int Seed { get; set; } = -1;

		public string GameVersion { get; set; } = string.Empty;

		public string MapSetHash { get; set; } = string.Empty;

		public int RouteIndex { get; set; }

		[JsonIgnore]
		public List<Vector3> Points { get; set; } = new List<Vector3>();

		public string AnimData { get; set; }

		public string ItemData { get; set; }

		public string StateData { get; set; }

		public string InventoryData { get; set; }
	}
	public class GameModeConverter : StringEnumConverter
	{
		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
		{
			//IL_0049: Expected O, but got Unknown
			string text = reader.Value as string;
			switch (text)
			{
			case "CustomPractice":
				return GameMode.Speedrun;
			case "RandomDaily":
				return GameMode.Speedrun;
			default:
				try
				{
					return ((StringEnumConverter)this).ReadJson(reader, objectType, existingValue, serializer);
				}
				catch (JsonSerializationException ex)
				{
					JsonSerializationException ex2 = ex;
					RankedLog.Warning("[RunStorage] Unbekannter Modus '" + text + "' - als Speedrun gewertet (" + ((Exception)(object)ex2).Message + ").");
					return GameMode.Speedrun;
				}
			}
		}
	}
	public class PlayerRating
	{
		[JsonProperty("steamId")]
		public string SteamId { get; set; } = "";

		[JsonProperty("playerName")]
		public string PlayerName { get; set; } = "";

		[JsonProperty("elo")]
		public int Elo { get; set; } = 1000;

		[JsonProperty("tier")]
		public string Tier { get; set; } = "UNRANKED";

		[JsonProperty("sub")]
		public int? Sub { get; set; }

		[JsonProperty("placementGames")]
		public int PlacementGames { get; set; }

		[JsonProperty("placementRemaining")]
		public int PlacementRemaining { get; set; } = 3;

		[JsonProperty("ranked")]
		public bool Ranked { get; set; }

		[JsonProperty("duelWins")]
		public int DuelWins { get; set; }

		[JsonProperty("duelLosses")]
		public int DuelLosses { get; set; }

		public string FormattedTierName
		{
			get
			{
				if (!Ranked || string.Equals(Tier, "UNRANKED", StringComparison.OrdinalIgnoreCase))
				{
					return $"PLATZIERUNG ({PlacementGames}/3)";
				}
				string text = Sub switch
				{
					1 => "I", 
					2 => "II", 
					3 => "III", 
					_ => "", 
				};
				if (!string.IsNullOrEmpty(text))
				{
					return Tier.ToUpperInvariant() + " " + text;
				}
				return Tier.ToUpperInvariant();
			}
		}

		public string FormattedHeaderSignText
		{
			get
			{
				if (!Ranked || string.Equals(Tier, "UNRANKED", StringComparison.OrdinalIgnoreCase))
				{
					if (PlacementGames <= 0)
					{
						return "RANKED • UNRANKED (0/3)";
					}
					return $"RANKED • PLATZIERUNG ({PlacementGames}/3)";
				}
				return $"{FormattedTierName} • {Elo:N0} ELO";
			}
		}
	}
	[JsonConverter(typeof(GameModeConverter))]
	public enum GameMode
	{
		StaticDaily,
		RankedDuel,
		Speedrun,
		GhostTraining,
		LiveRace,
		Vanilla
	}
	public enum RunResult
	{
		Completed,
		Died,
		Aborted
	}
	public class SplitRecord
	{
		public string SegmentName { get; set; } = string.Empty;

		public long ElapsedMs { get; set; }
	}
	public class RunRecord
	{
		public Guid Id { get; set; } = Guid.NewGuid();

		[JsonConverter(typeof(GameModeConverter))]
		public GameMode Mode { get; set; }

		public DateTime StartTimeUtc { get; set; }

		public string MapName { get; set; } = string.Empty;

		public List<SplitRecord> Splits { get; set; } = new List<SplitRecord>();

		public long TotalMs { get; set; }

		public long RealElapsedMs { get; set; }

		[JsonConverter(typeof(StringEnumConverter))]
		public RunResult Result { get; set; }

		public int AscentLevel { get; set; }

		public int PlayerCount { get; set; } = 1;

		public int Seed { get; set; } = -1;

		public bool RandomSeed { get; set; }

		public string GameVersion { get; set; } = string.Empty;

		public int LevelIndex { get; set; } = -1;

		public string BiomeId { get; set; } = string.Empty;

		public int RouteIndex { get; set; }

		public string RouteBiomeName { get; set; } = string.Empty;

		public string MapSetHash { get; set; } = string.Empty;

		[JsonIgnore]
		public IntegrityReport Integrity { get; set; }
	}
	public static class ServerConfig
	{
		public const string ApiBaseUrl = "https://followme-peak.ddns.net";
	}
}
namespace RankedPeak.Localization
{
	internal static class HelpText
	{
		internal static string Section(int index)
		{
			if (Loc.Current != ModLanguage.German)
			{
				return HelpTextEn.Section(index);
			}
			return HelpTextDe.Section(index);
		}

		internal static string Head(string text)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text2 = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Heading);
			return "<color=#" + text2 + ">" + text + "</color>";
		}

		internal static string Muted(string text)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text2 = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.TextMuted);
			return "<color=#" + text2 + ">" + text + "</color>";
		}

		internal unsafe static string Key(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string text = ColorUtility.ToHtmlStringRGB(PeakWindowStyle.Heading);
			if ((int)key != 0)
			{
				return "<color=#" + text + ">" + ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString().ToUpperInvariant() + "</color>";
			}
			return Muted(Loc.T("common.notBoundLower"));
		}
	}
	internal static class HelpTextDe
	{
		internal static string Section(int index)
		{
			return index switch
			{
				0 => Overview(), 
				1 => DailyCup(), 
				2 => GhostDuel(), 
				3 => Speedrun(), 
				4 => LiveRace(), 
				5 => Timing(), 
				6 => Elo(), 
				7 => Ghosts(), 
				8 => Leaderboards(), 
				9 => Fairness(), 
				_ => Troubleshooting(), 
			};
		}

		private static string Overview()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			return "PEAK RANKED macht aus dem Berg eine Rennstrecke. Der Mod misst deine Zeit nach Speedrun-Regeln, sorgt dafuer, dass alle auf demselben Berg mit denselben Gegenstaenden laufen, und traegt das Ergebnis in weltweite Ranglisten ein.\n\n" + HelpText.Head("Die vier Modi am rechten Schildermast") + "\n•  " + HelpText.Head("DAILY CUP") + " - der Hauptmodus. Ein Berg pro Tag, fuer alle gleich. Zaehlt fuer den Rang.\n•  " + HelpText.Head("1V1 GHOST DUELL") + " - direktes Duell gegen den aufgezeichneten Lauf eines anderen. Zaehlt fuer den Rang.\n•  " + HelpText.Head("SPEEDRUN") + " - freie Uebung: Seed, Karte und Strecke waehlst du selbst. Ohne Rangwertung.\n•  " + HelpText.Head("LIVE RACE") + " - mehrere Leute laufen gleichzeitig dieselbe Strecke. Ohne Rangwertung.\n\nDas oberste Schild zeigt deinen Rang und oeffnet die Ranglisten. Das unterste oeffnet dieses Fenster.\n\n" + HelpText.Head("Deine Tasten gerade jetzt") + "\n" + HelpText.Muted("Timer-Anzeige") + "   " + HelpText.Key(Plugin.OverlayToggleKey.Value) + "\n" + HelpText.Muted("Einstellungen") + "   " + HelpText.Key(Plugin.SettingsMenuKey.Value) + "\n" + HelpText.Muted("Renn-Fenster") + "   " + HelpText.Key(Plugin.RaceMenuKey.Value) + HelpText.Muted("  (nur waehrend eines Rennens)") + "\n" + HelpText.Muted("Lauf verwerfen") + "   " + HelpText.Key(Plugin.RunResetKey.Value);
		}

		private static string DailyCup()
		{
			return "Ein Berg pro Tag - dieselbe Karte, derselbe Seed, dieselben Gegenstaende fuer alle auf der Welt. Genau das macht die Tagesrangliste vergleichbar.\n\n" + HelpText.Head("So laeuft es") + "\nSchild DAILY CUP anklicken. Der Mod holt den Tages-Seed vom Server und startet direkt ins Level - den Flughafen ueberspringst du.\n\n" + HelpText.Head("Was zaehlt") + "\n•  Gewertet wird die Zeit bis zum Gipfel.\n•  Der Lauf zaehlt fuer deinen ELO-Rang.\n•  Ein Tag laeuft bis 17:00 UTC, dann wechselt die Insel. Der Wechsel-Countdown steht oben rechts im Hauptmenue.\n•  Deine Platzierung siehst du nach dem Lauf in der Zusammenfassung und jederzeit unter DAILY CUP in den Ranglisten.\n\n" + HelpText.Muted("Stirbst du oder verlaesst du das Level vorzeitig, wird der Versuch als abgebrochen gewertet - eine Zeit gibt es dafuer nicht.");
		}

		private static string GhostDuel()
		{
			return "Ein Rennen gegen einen echten Gegner, der nicht online sein muss: du laeufst gegen seinen aufgezeichneten Lauf.\n\n" + HelpText.Head("So laeuft es") + "\nSchild 1V1 GHOST DUELL anklicken. Der Mod sucht einen Gegner mit aehnlichem ELO, laedt dessen Aufzeichnung und startet euch beide auf demselben Seed. Waehrend des Laufs siehst du ihn als durchsichtige Figur neben dir.\n\n" + HelpText.Head("Was zaehlt") + "\n•  Wer frueher oben ist, gewinnt.\n•  ELO wird sofort nach dem Lauf verrechnet.\n•  Findet die Suche keinen passenden Gegner, startet der Lauf trotzdem - dann eben ohne Ghost.\n\n" + HelpText.Muted("Der Ghost kann dich nicht beruehren und nichts aufheben. Er ist eine Anzeige, kein Mitspieler.");
		}

		private static string Speedrun()
		{
			return "Der Uebungsmodus - und zugleich der Modus fuer alles, was du bei speedrun.com einreichen willst.\n\n" + HelpText.Head("So laeuft es") + "\nSchild SPEEDRUN anklicken. Es oeffnet sich ein Fenster, in dem du festlegst:\n•  " + HelpText.Head("STATIC oder RANDOM") + " - Seed und Karte selbst waehlen, oder erst beim Start wuerfeln lassen.\n•  " + HelpText.Head("Seed") + " - dieselbe Zahl ergibt denselben Berg mit denselben Gegenstaenden.\n•  " + HelpText.Head("Karte") + " - eine der Inseln aus der Rotation.\n•  " + HelpText.Head("Aufstiegsstufe") + " - der Schwierigkeitsgrad des Spiels.\n•  " + HelpText.Head("Strecke") + " - der ganze Berg oder ein einzelner Abschnitt zum Ueben.\n\n" + HelpText.Head("Was zaehlt") + "\n•  Kein ELO - dieser Modus veraendert deinen Rang nicht.\n•  Die Zeit landet trotzdem in der Speedrun-Rangliste, getrennt nach Karte, Strecke und Spielversion.\n\n" + HelpText.Muted("Ein einzelner Abschnitt ist eine eigene Kategorie und wird nie mit kompletten Besteigungen in eine Liste geworfen.");
		}

		private static string LiveRace()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			return "Mehrere Leute, dieselbe Strecke, gleichzeitig gestartet.\n\n" + HelpText.Head("So laeuft es") + "\n•  Schild LIVE RACE anklicken, Strecke einstellen und " + HelpText.Head("ERSTELLEN") + " druecken.\n•  Du bekommst einen Code. Wer mitlaufen will, gibt ihn im selben Fenster ein.\n•  Sind alle da, startet der Countdown - entweder automatisch oder auf dein Kommando als Ersteller.\n\n" + HelpText.Head("Fairer Start") + "\nBis zum Ende des Countdowns ist die Steuerung fuer alle gesperrt. Ohne diese Sperre entschiede die Ladezeit das Rennen: wer frueher fertig geladen hat, brachte sich schon in Position.\n\n" + HelpText.Head("Waehrend des Rennens") + "\nOben rechts steht der Zwischenstand aller Teilnehmer. Mit " + HelpText.Key(Plugin.RaceMenuKey.Value) + " holst du das Renn-Fenster zurueck - Code, Teilnehmerliste und der Weg hinaus.\n" + HelpText.Muted("Die Taste wirkt nur, solange ein Rennen laeuft. In einem Daily Cup oder Speedrun gaebe es in diesem Fenster nichts zu tun.") + "\n\n" + HelpText.Muted("Kein ELO - Live Races sind zum Spass und zum Ueben da.");
		}

		private static string Timing()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			return HelpText.Head("Wann die Uhr startet") + "\nBei deiner ersten Eingabe - also sobald du die Figur wirklich steuern kannst. Das ist die Regel, nach der auch speedrun.com misst. Der spielinterne Start liegt rund vier Sekunden frueher, mitten in der Einflug-Sequenz; wuerde man dort messen, waeren alle Zeiten geschenkt zu lang.\n" + HelpText.Muted("Keine Einstellung - die Regel gilt fuer alle gleich, weil eine Rangliste nur vergleichen kann, was gleich gemessen wurde.") + "\n\n" + HelpText.Head("Wann sie stoppt") + "\nAm Gipfel. Stirbst du, endet der Lauf als Tod; verlaesst du das Level, gilt er als abgebrochen. In beiden Faellen gibt es keine gewertete Zeit.\n\n" + HelpText.Head("Wo sie steht") + "\nDie Anzeige erscheint mit dem Lauf und verschwindet mit ihm - im Hauptmenue und im Flughafen zeigte sie nur den Stand des letzten Versuchs. Mit " + HelpText.Key(Plugin.OverlayToggleKey.Value) + " laesst sie sich jederzeit vorab hervorholen oder waehrend des Laufs ausblenden.\n\n" + HelpText.Head("Splits") + "\nJedes erreichte Lagerfeuer setzt eine Zwischenzeit. Das Timer-Panel zeigt sie im Vergleich zum Vergleichslauf - <color=#1B8449>gruen</color> heisst schneller, <color=#BA322D>rot</color> heisst langsamer.\n\n" + HelpText.Head("Was der Vergleich ist") + "\nVerglichen wird immer mit einem eigenen Lauf auf " + HelpText.Head("derselben Karte und derselben Strecke") + ". Eine Zeit von einem anderen Berg taugt nicht als Ziel: PEAK setzt jeden Berg aus anderen Biomen zusammen.\nGibt es dort noch keinen abgeschlossenen Lauf, steht statt einer Zeit ein Strich - lieber nichts als eine Zahl, die nichts bedeutet.\n\nVorgabe ist deine Bestzeit dieser Kategorie. Du kannst stattdessen einen bestimmten Lauf festnageln: in den Ranglisten unter " + HelpText.Head("MEINE LAEUFE") + " eine Zeile anklicken. Das Timer-Panel schreibt dann " + HelpText.Head("Vergleich (gewaehlt)") + " statt " + HelpText.Head("Vergleich (PB)") + ", damit die Zeile nicht mit deiner Bestzeit zu verwechseln ist.\n" + HelpText.Muted("Umschalten unter Einstellungen - RUN & WERTUNG, Zeile Vergleichslauf.") + "\n\n" + HelpText.Head("Lauf verwerfen") + "\nDie Taste " + HelpText.Key(Plugin.RunResetKey.Value) + " stellt die Uhr auf 0 und wartet auf einen neuen Startversuch. Sie laedt die Karte " + HelpText.Head("nicht") + " neu - der Berg bleibt genau so, wie du ihn hinterlassen hast.";
		}

		private static string Elo()
		{
			return "ELO ist eine einzige Zahl fuer deine Staerke. Sie steigt, wenn du dich gegen starke Gegner durchsetzt, und faellt, wenn du gegen schwaechere verlierst.\n\n" + HelpText.Head("Die sechs Bergsteiger-Raenge") + "\n•  SCOUT   " + HelpText.Muted("bis 799") + "\n•  HIKER   " + HelpText.Muted("800 - 1.199") + "\n•  CLIMBER   " + HelpText.Muted("1.200 - 1.599") + "\n•  ALPINIST   " + HelpText.Muted("1.600 - 1.999") + "\n•  SHERPA   " + HelpText.Muted("2.000 - 2.399") + "\n•  PEAK LEGEND   " + HelpText.Muted("ab 2.400") + "\nJeder Rang hat drei Unterstufen (I, II, III).\n\n" + HelpText.Head("Einstufung") + "\nDie ersten drei gewerteten Laeufe sind Platzierungsspiele. Bis sie durch sind, steht auf dem Rang-Schild PLATZIERUNG statt eines Rangs.\n\n" + HelpText.Head("Was den Rang bewegt") + "\n•  " + HelpText.Head("Daily Cup") + " - viel ELO, einmal pro Tag.\n•  " + HelpText.Head("Ghost Duell") + " - wenig ELO pro Duell, dafuer jederzeit.\n•  " + HelpText.Head("Speedrun und Live Race") + " - gar keins.";
		}

		private static string Ghosts()
		{
			return "Ein Ghost ist die Aufzeichnung eines gelaufenen Wegs: dieselbe Strecke, dieselbe Route, synchron zu deiner Zeit abgespielt.\n\n" + HelpText.Head("Dein eigener Bestzeit-Ghost") + "\nLaeuft automatisch mit, sobald du dieselbe Karte im selben Modus noch einmal spielst. Er kommt aus deinen lokalen Aufzeichnungen, nicht vom Server.\n\n" + HelpText.Head("Gegen einen fremden Ghost trainieren") + "\nIn den Ranglisten eine Zeile anklicken und " + HelpText.Head("GEGEN DIESEN GHOST TRAINIEREN") + " druecken. Der Mod uebernimmt Seed und Karte des Laufs und startet dich dagegen.\n" + HelpText.Muted("Blasse Zeilen lassen sich nicht anklicken: der Lauf stammt aus einem anderen Kartensatz, sein Weg fuehrte in dieser Spielversion durch Fels.") + "\n\n" + HelpText.Head("Was der Ghost mit sich traegt") + "\nHatte er in dem Moment ein Item in der Hand, haelt es sein Ghost auch - so siehst du, womit er die Stelle geloest hat.\n\n" + HelpText.Muted("Sichtbarkeit und Deckkraft stellst du unter Einstellungen - GHOST & REPLAY ein.");
		}

		private static string Leaderboards()
		{
			return "Die Ranglisten oeffnest du ueber das oberste Schild am rechten Mast. Drei Ansichten stehen dort zur Wahl.\n\n•  " + HelpText.Head("ELO-RANGLISTE") + " - wer ist der staerkste Bergsteiger.\n•  " + HelpText.Head("DAILY CUP") + " - die Zeiten des heutigen Bergs, wahlweise auch aller Zeiten.\n•  " + HelpText.Head("SPEEDRUN") + " - alle schnellen Laeufe, die speedrun.com-Sicht.\n\n" + HelpText.Head("Warum getrennte Kategorien") + "\nEine Zeit sagt nur etwas aus, wenn die Strecke dieselbe war. Deshalb trennt die Speedrun-Ansicht nach:\n•  " + HelpText.Head("Karte") + " - jede Insel ist ein anderer Berg.\n•  " + HelpText.Head("Strecke") + " - ganzer Berg oder einzelner Abschnitt. Ein Abschnitt dauert einen Bruchteil davon; gemischt waere die Liste keine Rangfolge mehr.\n•  " + HelpText.Head("Spielversion") + " - ein Update kann den Berg veraendern. Ab Werk siehst du nur deine eigene Version; auf Wunsch alle gemischt.\n\n" + HelpText.Muted("Bei den Abschnitten wird nach dem Namen des Bioms gefiltert, nicht nach seiner Nummer: Abschnitt 2 ist auf der einen Insel TROPICS und auf der naechsten ROOTS.");
		}

		private static string Fairness()
		{
			return "Eine Rangliste ist genau so viel wert wie das Vertrauen, das ihr entgegengebracht wird. Deshalb hier in klaren Worten, was der Mod waehrend eines gewerteten Laufs tut - und was ausdruecklich nicht.\n\n" + HelpText.Head("Was aufgezeichnet wird") + "\nWaehrend eines gewerteten Laufs zeichnet der Mod zweimal pro Sekunde deinen Weg den Berg hinauf auf, dazu was du getragen hast und wie sich Ausdauer und Statuswerte entwickelt haben. Das ist dieselbe Aufzeichnung, aus der auch dein Ghost besteht. Daneben haelt er Signale aus dem Spielzustand fest: ob sich Werte so veraendert haben, wie das Spiel selbst es gar nicht kann.\n\n" + HelpText.Head("Was nicht") + "\n•  Nichts ausserhalb des Spielprozesses. Keine Dateien, keine Bildschirmfotos, keine Liste deiner Programme, keine Tastendruecke.\n•  Nichts in einem Vanilla-Lauf. Wer ueber den linken Mast startet, wird nur gestoppt.\n\n" + HelpText.Head("Welche Mods laufen duerfen") + "\nIn einem gewerteten Lauf - alles, was ueber die Schilder " + HelpText.Head("rechts") + " startet - bleiben nur Mods von der Freigabeliste aktiv. Jeder andere Mod wird fuer die Dauer des Laufs abgeschaltet und kommt zurueck, sobald du wieder im Hauptmenue bist. So ist jeder Eintrag einer Rangliste unter denselben Bedingungen entstanden, und niemand muss hinterher beweisen, dass seine Mods harmlos waren.\n\nAusserhalb gewerteter Laeufe wird nichts angefasst: wer ueber den linken Mast startet, spielt genau mit dem, was er installiert hat.\n\n" + HelpText.Head("Dein Mod fehlt auf der Liste?") + " Sag Bescheid - die Liste wird von Hand gepflegt, und Kosmetik- und Komfort-Mods gehoeren darauf.\n" + HelpText.Muted("1. Discord beitreten:  discord.gg/nKUHvzdmVp") + "\n" + HelpText.Muted("2. Im PEAK-RANKED-Thread schreiben (er oeffnet erst, wenn du auf dem Server bist):") + "\n" + HelpText.Muted("   discord.com/channels/1363179626435707082/1539751504746127451") + "\n\n" + HelpText.Head("Was mit einem auffaelligen Lauf passiert") + "\nEr wird nie abgelehnt - er wird zurueckgestellt und von einem Menschen angesehen. Ein faelschlich abgelehnter ehrlicher Lauf ist schlimmer als ein Cheater, der ein Review spaeter auffliegt. Wo eine Schwelle gerechnet und nicht absolut ist, steht auf der Ergebniskarte " + HelpText.Muted("in Pruefung") + " - damit du weisst, dass dein Lauf geprueft und nicht verloren ist.";
		}

		private static string Troubleshooting()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			return HelpText.Head("Meine Zeit steht nicht in der Rangliste") + "\nLaeufe werden zwischengespeichert und spaeter nachgereicht, wenn der Server gerade nicht erreichbar ist. Unter Einstellungen - DIAGNOSE steht, wie viele noch offen sind; dort laesst sich das Senden auch anstossen.\n\n" + HelpText.Head("Der Ghost fehlt") + "\nEr braucht einen abgeschlossenen eigenen Lauf auf derselben Karte im selben Modus. Nach einem Tod oder Abbruch gibt es nichts aufzuzeichnen.\n\n" + HelpText.Head("Ein Mitspieler findet andere Gegenstaende") + "\nDann spielt ihr verschiedene Spielversionen, oder einer von euch ist ueber den linken Mast gestartet - dort greift der Mod nicht in die Item-Verteilung ein.\n\n" + HelpText.Head("Die Anzeige ist weg") + "\nIm Hauptmenue und im Flughafen ist der Timer aus - er erscheint mit dem Lauf. Sonst schaltest du ihn mit " + HelpText.Key(Plugin.OverlayToggleKey.Value) + " wieder ein. Ist er aus dem Bild gerutscht, hilft Einstellungen - TIMER & HUD, ECKE LINKS OBEN.\n\n" + HelpText.Head("Etwas ist wirklich kaputt") + "\nUnter Einstellungen - DIAGNOSE stehen Version, Server und Kartensatz beisammen, und der Knopf daneben oeffnet den Ordner mit dem Log.";
		}
	}
	internal static class HelpTextEn
	{
		internal static string Section(int index)
		{
			return index switch
			{
				0 => Overview(), 
				1 => DailyCup(), 
				2 => GhostDuel(), 
				3 => Speedrun(), 
				4 => LiveRace(), 
				5 => Timing(), 
				6 => Elo(), 
				7 => Ghosts(), 
				8 => Leaderboards(), 
				9 => Fairness(), 
				_ => Troubleshooting(), 
			};
		}

		private static string Overview()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			return "PEAK RANKED turns the mountain into a race track. The mod times your run by speedrun rules, makes sure everyone climbs the same mountain with the same items, and puts the result on worldwide leaderboards.\n\n" + HelpText.Head("The four modes on the right signpost") + "\n•  " + HelpText.Head("DAILY CUP") + " - the main mode. One mountain a day, the same for everyone. Counts towards your rank.\n•  " + HelpText.Head("1V1 GHOST DUEL") + " - a head-to-head against someone else's recorded run. Counts towards your rank.\n•  " + HelpText.Head("SPEEDRUN") + " - free practice: you pick seed, map and route yourself. Unranked.\n•  " + HelpText.Head("LIVE RACE") + " - several people run the same route at the same time. Unranked.\n\nThe topmost sign shows your rank and opens the leaderboards. The bottom one opens this window.\n\n" + HelpText.Head("Your keys right now") + "\n" + HelpText.Muted("Timer display") + "   " + HelpText.Key(Plugin.OverlayToggleKey.Value) + "\n" + HelpText.Muted("Settings") + "   " + HelpText.Key(Plugin.SettingsMenuKey.Value) + "\n" + HelpText.Muted("Race window") + "   " + HelpText.Key(Plugin.RaceMenuKey.Value) + HelpText.Muted("  (only during a race)") + "\n" + HelpText.Muted("Discard run") + "   " + HelpText.Key(Plugin.RunResetKey.Value);
		}

		private static string DailyCup()
		{
			return "One mountain a day - the same map, the same seed, the same items for everyone in the world. That is exactly what makes the daily leaderboard comparable.\n\n" + HelpText.Head("How it goes") + "\nClick the DAILY CUP sign. The mod fetches the daily seed from the server and drops you straight into the level - you skip the airport.\n\n" + HelpText.Head("What counts") + "\n•  Your time to the summit is what gets scored.\n•  The run counts towards your ELO rank.\n•  A day runs until 17:00 UTC, then the island changes. The countdown to the change is in the top right of the main menu.\n•  You see your placing after the run in the summary, and any time under DAILY CUP in the leaderboards.\n\n" + HelpText.Muted("If you die or leave the level early, the attempt counts as aborted - there is no time for that.");
		}

		private static string GhostDuel()
		{
			return "A race against a real opponent who does not have to be online: you run against their recorded attempt.\n\n" + HelpText.Head("How it goes") + "\nClick the 1V1 GHOST DUEL sign. The mod looks for an opponent with similar ELO, loads their recording and starts you both on the same seed. During the run you see them as a transparent figure beside you.\n\n" + HelpText.Head("What counts") + "\n•  Whoever is up first wins.\n•  ELO is settled immediately after the run.\n•  If the search finds no suitable opponent, the run starts anyway - just without a ghost.\n\n" + HelpText.Muted("The ghost cannot touch you and cannot pick anything up. It is a display, not a player.");
		}

		private static string Speedrun()
		{
			return "The practice mode - and at the same time the mode for anything you want to submit to speedrun.com.\n\n" + HelpText.Head("How it goes") + "\nClick the SPEEDRUN sign. A window opens in which you set:\n•  " + HelpText.Head("STATIC or RANDOM") + " - pick seed and map yourself, or have them rolled at the start.\n•  " + HelpText.Head("Seed") + " - the same number gives the same mountain with the same items.\n•  " + HelpText.Head("Map") + " - one of the islands from the rotation.\n•  " + HelpText.Head("Ascent level") + " - the game's difficulty.\n•  " + HelpText.Head("Route") + " - the whole mountain or a single segment to practise.\n\n" + HelpText.Head("What counts") + "\n•  No ELO - this mode does not change your rank.\n•  The time still goes onto the speedrun leaderboard, split by map, route and game version.\n\n" + HelpText.Muted("A single segment is a category of its own and is never thrown into one list with complete ascents.");
		}

		private static string LiveRace()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			return "Several people, the same route, started at the same time.\n\n" + HelpText.Head("How it goes") + "\n•  Click the LIVE RACE sign, set up the route and press " + HelpText.Head("CREATE") + ".\n•  You get a code. Anyone who wants to join enters it in the same window.\n•  Once everyone is there the countdown starts - either automatically or on your command as the creator.\n\n" + HelpText.Head("A fair start") + "\nUntil the countdown ends the controls are locked for everyone. Without that lock, loading time would decide the race: whoever finished loading earlier would already be getting into position.\n\n" + HelpText.Head("During the race") + "\nThe standings of all participants are in the top right. With " + HelpText.Key(Plugin.RaceMenuKey.Value) + " you bring the race window back - code, participant list and the way out.\n" + HelpText.Muted("The key only works while a race is running. In a Daily Cup or a Speedrun there would be nothing to do in that window.") + "\n\n" + HelpText.Muted("No ELO - live races are there for fun and for practice.");
		}

		private static string Timing()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			return HelpText.Head("When the clock starts") + "\nOn your first input - that is, as soon as you can really control the character. That is the rule speedrun.com times by as well. The game's own start is about four seconds earlier, in the middle of the fly-in sequence; measured from there, every time would be needlessly long.\n" + HelpText.Muted("Not a setting - the same rule applies to everyone, because a leaderboard can only compare runs measured the same way.") + "\n\n" + HelpText.Head("When it stops") + "\nAt the summit. If you die, the run ends as a death; if you leave the level, it counts as aborted. In both cases there is no scored time.\n\n" + HelpText.Head("Where it sits") + "\nThe display appears with the run and goes away with it - in the main menu and at the airport it would only show the state of your last attempt. With " + HelpText.Key(Plugin.OverlayToggleKey.Value) + " you can bring it up early at any time, or hide it during a run.\n\n" + HelpText.Head("Splits") + "\nEvery campfire you reach sets a split. The timer panel shows them against the comparison run - <color=#1B8449>green</color> means faster, <color=#BA322D>red</color> means slower.\n\n" + HelpText.Head("What the comparison is") + "\nThe comparison is always one of your own runs on " + HelpText.Head("the same map and the same route") + ". A time from a different mountain is no target: PEAK builds every mountain from a different set of biomes.\nWith no finished run there yet, a dash appears instead of a time - better nothing than a number that means nothing.\n\nThe default is your best time in that category. You can pin a specific run instead: open the leaderboards, go to " + HelpText.Head("MY RUNS") + " and click a row. The timer panel then reads " + HelpText.Head("Compare (chosen)") + " instead of " + HelpText.Head("Compare (PB)") + ", so it cannot be mistaken for your best time.\n" + HelpText.Muted("Switch it under Settings - RUN & SCORING, row Comparison run.") + "\n\n" + HelpText.Head("Discarding a run") + "\nThe " + HelpText.Key(Plugin.RunResetKey.Value) + " key sets the clock back to 0 and waits for a new attempt. It does " + HelpText.Head("not") + " reload the map - the mountain stays exactly as you left it.";
		}

		private static string Elo()
		{
			return "ELO is a single number for how strong you are. It rises when you beat strong opponents and falls when you lose to weaker ones.\n\n" + HelpText.Head("The six climber ranks") + "\n•  SCOUT   " + HelpText.Muted("up to 799") + "\n•  HIKER   " + HelpText.Muted("800 - 1,199") + "\n•  CLIMBER   " + HelpText.Muted("1,200 - 1,599") + "\n•  ALPINIST   " + HelpText.Muted("1,600 - 1,999") + "\n•  SHERPA   " + HelpText.Muted("2,000 - 2,399") + "\n•  PEAK LEGEND   " + HelpText.Muted("from 2,400") + "\nEvery rank has three sub-levels (I, II, III).\n\n" + HelpText.Head("Placement") + "\nThe first three scored runs are placement runs. Until they are done, the rank sign reads PLACEMENT instead of a rank.\n\n" + HelpText.Head("What moves your rank") + "\n•  " + HelpText.Head("Daily Cup") + " - a lot of ELO, once a day.\n•  " + HelpText.Head("Ghost Duel") + " - little ELO per duel, but available any time.\n•  " + HelpText.Head("Speedrun and Live Race") + " - none at all.";
		}

		private static string Ghosts()
		{
			return "A ghost is the recording of a climb: the same route, the same line, played back in sync with your own time.\n\n" + HelpText.Head("Your own best-time ghost") + "\nRuns along automatically as soon as you play the same map in the same mode again. It comes from your local recordings, not from the server.\n\n" + HelpText.Head("Training against someone else's ghost") + "\nClick a row in the leaderboards and press " + HelpText.Head("TRAIN AGAINST THIS GHOST") + ". The mod takes over the seed and map of that run and starts you against it.\n" + HelpText.Muted("Faded rows cannot be clicked: the run comes from a different map set, its line would lead through rock in this game version.") + "\n\n" + HelpText.Head("What the ghost carries") + "\nIf they held an item at that moment, their ghost holds it too - so you see what they solved the spot with.\n\n" + HelpText.Muted("Visibility and opacity live under Settings - GHOST & REPLAY.");
		}

		private static string Leaderboards()
		{
			return "You open the leaderboards from the topmost sign on the right post. Three views are available there.\n\n•  " + HelpText.Head("ELO RANKING") + " - who is the strongest climber.\n•  " + HelpText.Head("DAILY CUP") + " - the times on today's mountain, optionally all-time as well.\n•  " + HelpText.Head("SPEEDRUN") + " - every fast run, the speedrun.com view.\n\n" + HelpText.Head("Why separate categories") + "\nA time only means something if the route was the same. That is why the speedrun view separates by:\n•  " + HelpText.Head("Map") + " - every island is a different mountain.\n•  " + HelpText.Head("Route") + " - whole mountain or single segment. A segment takes a fraction of the time; mixed together the list would no longer be a ranking.\n•  " + HelpText.Head("Game version") + " - an update can change the mountain. By default you only see your own version; all of them mixed on request.\n\n" + HelpText.Muted("Segments are filtered by the name of the biome, not by its number: segment 2 is TROPICS on one island and ROOTS on the next.");
		}

		private static string Fairness()
		{
			return "A leaderboard is worth exactly as much as the trust people put in it. So here is, in plain words, what the mod does during a ranked run - and what it does not.\n\n" + HelpText.Head("What is recorded") + "\nDuring a ranked run the mod records your path up the mountain twice a second, what you carried, and how your stamina and status bars developed. That is the same recording your ghost is made of. Alongside it, it notes game state signals for the fairness check: whether values changed in ways the game itself cannot produce.\n\n" + HelpText.Head("What is not") + "\n•  Nothing outside the game process. No files, no screenshots, no list of your programs, no keystrokes.\n•  Nothing in a vanilla run. Start over the left signpost and the mod only times you.\n\n" + HelpText.Head("Which mods may run") + "\nIn a scored run - anything started from the signs on the " + HelpText.Head("right") + " - only mods on the allowlist stay active. Every other mod is switched off for the duration of the run and comes back the moment you return to the main menu. That way everyone on a leaderboard climbed under the same conditions, and nobody has to prove afterwards that their mods were harmless.\n\nOutside scored runs nothing is touched: start over the left signpost and your setup runs exactly as you installed it.\n\n" + HelpText.Head("Your mod is missing from the list?") + " Say so - the list is curated by hand and cosmetic and quality-of-life mods belong on it.\n" + HelpText.Muted("1. Join the Discord:  discord.gg/nKUHvzdmVp") + "\n" + HelpText.Muted("2. Post in the PEAK RANKED thread (it only opens once you are on the server):") + "\n" + HelpText.Muted("   discord.com/channels/1363179626435707082/1539751504746127451") + "\n\n" + HelpText.Head("What happens to a conspicuous run") + "\nIt is never rejected - it is set aside and looked at by a human. A wrongly rejected honest run is worse than a cheater who is caught one review later. Where a threshold is calibrated rather than absolute, the result card says " + HelpText.Muted("under review") + " so you know your run is being checked, not lost.";
		}

		private static string Troubleshooting()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			return HelpText.Head("My time is not on the leaderboard") + "\nRuns are buffered and handed in later when the server is unreachable. Under Settings - DIAGNOSTICS you can see how many are still pending; you can also trigger the sending from there.\n\n" + HelpText.Head("The ghost is missing") + "\nIt needs a finished run of your own on the same map in the same mode. After a death or an abort there is nothing to record.\n\n" + HelpText.Head("A fellow player finds different items") + "\nThen you are on different game versions, or one of you started over the left signpost - there the mod does not touch how items are spread.\n\n" + HelpText.Head("The display is gone") + "\nIn the main menu and at the airport the timer is off - it appears with the run. Otherwise press " + HelpText.Key(Plugin.OverlayToggleKey.Value) + " to switch it back on. If it has slipped off screen, Settings - TIMER & HUD, TOP LEFT CORNER helps.\n\n" + HelpText.Head("Something is really broken") + "\nUnder Settings - DIAGNOSTICS you find version, server and map set together, and the button next to it opens the folder with the log.";
		}
	}
	public enum ModLanguage
	{
		English,
		German
	}
	public static class Loc
	{
		private static readonly Dictionary<string, string> English = StringsEn.Build();

		private static readonly Dictionary<string, string> German = StringsDe.Build();

		private static ModLanguage _current = ModLanguage.English;

		private static bool _hooked;

		public static ModLanguage Current
		{
			get
			{
				EnsureHooked();
				return _current;
			}
		}

		public static string DateFormat => T("common.date.format");

		public static event Action LanguageChanged;

		private static void EnsureHooked()
		{
			if (_hooked)
			{
				return;
			}
			_hooked = true;
			ReadGameLanguage();
			try
			{
				LocalizedText.OnLangugageChanged = (Action)Delegate.Combine(LocalizedText.OnLangugageChanged, new Action(OnGameLanguageChanged));
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Loc] Sprachwechsel-Ereignis nicht erreichbar: " + ex.Message);
			}
		}

		internal static void Initialize()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			EnsureHooked();
			RankedLog.Info($"[Loc] Sprache: {_current} (Spiel: {SafeGameLanguage()})");
		}

		internal static void Refresh()
		{
			OnGameLanguageChanged();
		}

		private static void OnGameLanguageChanged()
		{
			EnsureHooked();
			ModLanguage current = _current;
			ReadGameLanguage();
			if (current == _current)
			{
				return;
			}
			RankedLog.Info($"[Loc] Sprache gewechselt: {current} -> {_current}");
			try
			{
				Loc.LanguageChanged?.Invoke();
			}
			catch (Exception arg)
			{
				RankedLog.Error($"[Loc] Fehler beim Sprachwechsel: {arg}");
			}
		}

		private static void ReadGameLanguage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			_current = (((int)SafeGameLanguage() == 3) ? ModLanguage.German : ModLanguage.English);
		}

		private static Language SafeGameLanguage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return LocalizedText.CURRENT_LANGUAGE;
			}
			catch
			{
				return (Language)0;
			}
		}

		public static string T(string key)
		{
			if (key == null)
			{
				return string.Empty;
			}
			if (((Current == ModLanguage.German) ? German : English).TryGetValue(key, out var value))
			{
				return value;
			}
			if (English.TryGetValue(key, out var value2))
			{
				return value2;
			}
			RankedLog.Warning("[Loc] Unbekannter Schluessel '" + key + "'");
			return key;
		}

		public static string T(string key, params object[] args)
		{
			string text = T(key);
			try
			{
				return string.Format(CultureInfo.InvariantCulture, text, args);
			}
			catch (FormatException)
			{
				RankedLog.Warning("[Loc] Platzhalter passen nicht zu '" + key + "': " + text);
				return text;
			}
		}

		public static string Pick(string english, string german)
		{
			if (Current != ModLanguage.German)
			{
				return english;
			}
			return german;
		}
	}
	internal static class StringsDe
	{
		internal static Dictionary<string, string> Build()
		{
			return new Dictionary<string, string>
			{
				["common.sections"] = "BEREICHE",
				["common.you"] = "(Du)",
				["common.anonymous"] = "Anonym",
				["common.opponent"] = "Gegner",
				["common.host"] = "Host",
				["common.notAvailable"] = "nicht verfuegbar",
				["common.unknown"] = "unbekannt",
				["common.notBound"] = "NICHT BELEGT",
				["common.notBoundLower"] = "nicht belegt",
				["common.understood"] = "VERSTANDEN",
				["common.date.format"] = "dd.MM. HH:mm",
				["gate.mapAltered.title"] = "KARTE NICHT BESTAETIGT",
				["gate.mapAltered"] = "Ein anderer Mod hat diese Karte ausgetauscht, bevor PEAK RANKED sie sehen konnte: an der Stelle des heutigen Tages steht {0}, das Spiel backt dort aber {1}.\n\nEine gewertete Zeit bedeutet nur etwas, wenn alle denselben Berg geklettert sind - dieser Lauf kann deshalb nicht als gewerteter Lauf starten.\n\nStarte PEAK ohne den Mod, der den Kartenpool veraendert - meist ist das MorePeak; er ersetzt einen einzelnen Platz durch eine zufaellig gezogene Karte, weshalb die meisten Tage unberuehrt bleiben und dieser nicht. Oder nimm den linken Schildermast fuer einen normalen, ungewerteten Lauf.",
				["mode.staticDaily"] = "DAILY CUP",
				["mode.rankedDuel"] = "1V1 GHOST DUELL",
				["mode.speedrun"] = "SPEEDRUN",
				["mode.ghostTraining"] = "GHOST-TRAINING",
				["mode.liveRace"] = "LIVE RACE",
				["mode.custom"] = "CUSTOM RUN",
				["mode.vanilla"] = "VANILLA – NICHT GEWERTET",
				["mode.short.staticDaily"] = "Daily Cup",
				["mode.short.rankedDuel"] = "Ghost-Duell",
				["mode.short.speedrunSet"] = "Speedrun Set Seed",
				["mode.short.speedrunRandom"] = "Speedrun Random",
				["mode.short.liveRace"] = "Live Race",
				["sign.ranked"] = "RANKED",
				["sign.placement"] = "PLATZIERUNG ({0}/3)",
				["sign.settings"] = "EINSTELLUNGEN",
				["menu.subtitle"] = "Globale Ranglisten, Bestzeiten und dein Karriere-Profil",
				["menu.box.profile"] = "DEIN KARRIERE-PROFIL",
				["menu.box.view"] = "ANSICHT",
				["menu.box.table"] = "RANGLISTE",
				["menu.box.myRuns"] = "MEINE LAEUFE",
				["menu.btn.refresh"] = "AKTUALISIEREN",
				["menu.tab.elo"] = "ELO-RANGLISTE",
				["menu.tab.myRuns"] = "MEINE LAEUFE",
				["menu.myRuns.hint"] = "Zeile anklicken, um sie als Vergleich festzunageln - noch einmal klicken loest die Wahl.",
				["menu.myRuns.empty"] = "Noch keine eigenen Laeufe aufgezeichnet.",
				["menu.myRuns.pinned"] = "VERGLEICH",
				["menu.period.today"] = "HEUTE",
				["menu.period.allTime"] = "ALL-TIME",
				["menu.version.only"] = "NUR {0}",
				["menu.version.all"] = "ALLE VERSIONEN",
				["menu.route.whole"] = "GANZER BERG",
				["menu.route.only"] = "NUR {0}",
				["menu.col.player"] = "SPIELER",
				["menu.col.tier"] = "BERGSTEIGER-RANG",
				["menu.col.duels"] = "DUELLE (W/L)",
				["menu.col.time"] = "ZEIT",
				["menu.col.map"] = "KARTE",
				["menu.col.seed"] = "SEED",
				["menu.col.game"] = "SPIEL",
				["menu.col.date"] = "DATUM",
				["menu.col.route"] = "STRECKE",
				["menu.col.mode"] = "MODUS",
				["menu.card.loading"] = "Lade Karriere-Profil ...",
				["menu.card.duels"] = "Duelle: {0} ({1}% Siege)",
				["menu.card.pb"] = "Daily Cup (Bestzeit): {0}",
				["menu.card.placement"] = "PLATZIERUNG ({0}/3 SPIELE)",
				["menu.card.placementHint"] = "Noch {0} Spiel(e) bis zum ersten Bergsteiger-Rang",
				["menu.page"] = "Seite {0} / {1}",
				["menu.btn.prev"] = "< VORHERIGE",
				["menu.btn.next"] = "NÄCHSTE >",
				["menu.btn.trainTop"] = "VS. TOP-GHOST TRAINIEREN",
				["menu.btn.trainVs"] = "VS. {0} TRAINIEREN",
				["menu.loading"] = "Lade Daten vom Server ...",
				["menu.error.unreachable"] = "Server nicht erreichbar.",
				["menu.error.elo"] = "Fehler beim Lesen der Rangliste.",
				["menu.error.speedrunBoard"] = "Fehler beim Lesen des Speedrun-Boards.",
				["menu.error.leaderboard"] = "Fehler beim Lesen der Bestenliste.",
				["menu.empty.elo"] = "Noch keine platzierten Spieler vorhanden. Schließe 3 Runs ab!",
				["menu.empty.speedrun"] = "Noch keine Runs verzeichnet.",
				["menu.empty.speedrunVersion"] = "Noch keine Runs auf Spielversion {0} - über ALLE VERSIONEN sind ältere zu sehen.",
				["menu.empty.dailyToday"] = "Noch keine Runs heute eingetragen - sei der Erste!",
				["menu.empty.dailyAllTime"] = "Noch keine All-Time Runs verzeichnet.",
				["menu.cell.wholeMountain"] = "Ganzer Berg",
				["menu.cell.segment"] = "Abschnitt {0}",
				["menu.meta.blocked"] = "{0} Einträge   ·   {1} davon blass: anderer Karten-Satz oder keine Aufzeichnung, als Ghost nicht spielbar",
				["menu.meta.speedrun"] = "Einträge: {0}   ·   Dein Spiel: {1} (Satz {2}, {3} Karten)",
				["menu.meta.total"] = "Einträge gesamt: {0}",
				["settings.subtitle"] = "Einstellungen - alle Aenderungen wirken sofort",
				["settings.cat.keys"] = "TASTEN",
				["settings.cat.timer"] = "TIMER & HUD",
				["settings.cat.ghost"] = "GHOST & REPLAY",
				["settings.cat.run"] = "RUN & WERTUNG",
				["settings.cat.diagnostics"] = "DIAGNOSE",
				["settings.btn.help"] = "HILFE",
				["settings.toggle.on"] = "AN",
				["settings.toggle.off"] = "AUS",
				["settings.key.overlay.title"] = "Timer-Anzeige",
				["settings.key.overlay.desc"] = "Blendet Timer-Panel und Renn-Anzeige ein und aus. Ausserhalb eines Laufs bleibt der Timer verborgen - diese Taste holt ihn vorab hervor. Der Timer laeuft in beiden Faellen weiter.",
				["settings.key.window.title"] = "Dieses Fenster",
				["settings.key.window.desc"] = "Oeffnet die Einstellungen - im Menue wie auf dem Berg.",
				["settings.key.race.title"] = "Renn-Fenster",
				["settings.key.race.desc"] = "Code, Teilnehmer und Verlassen eines laufenden Rennens. Angelegt wird eines am Schild LIVE RACE.",
				["settings.key.reset.title"] = "Lauf verwerfen",
				["settings.key.reset.desc"] = "Verwirft den laufenden Versuch und stellt die Uhr auf 0. Kein Neustart der Karte - das Level bleibt, wie es ist. Ab Werk nicht belegt.",
				["settings.key.hint"] = "Waehrend der Abfrage bricht ESC ab, ENTF loescht die Belegung.",
				["settings.key.capture"] = "TASTE DRUECKEN ...",
				["settings.race.active"] = "Ein Rennen laeuft - die Taste oeffnet das Fenster.",
				["settings.race.inactive"] = "Nur waehrend eines Rennens - gerade laeuft keins.",
				["settings.display.title"] = "Darstellung",
				["settings.display.desc"] = "Das native Panel gehoert zum Spiel-Bild und skaliert mit. Die klassische Anzeige ist die Rueckfallebene, falls das Panel Aerger macht.",
				["settings.display.panel"] = "PANEL",
				["settings.display.classic"] = "KLASSISCH",
				["settings.position.title"] = "Position der Anzeige",
				["settings.position.desc"] = "Das Timer-Panel haengt sich an die Maus, ein Linksklick setzt es ab.",
				["settings.position.move"] = "VERSCHIEBEN",
				["settings.position.reset"] = "ECKE LINKS OBEN",
				["settings.position.hint"] = "Linksklick setzt die Anzeige ab   -   ESC bricht ab",
				["settings.summary.title"] = "Ergebnis nach dem Lauf",
				["settings.summary.desc"] = "Legt Ergebnis, Splits, Vergleich, Upload-Status und Tagesplatz ueber den Pfadfinderbericht des Spiels. Der Bericht selbst bleibt unveraendert.",
				["settings.raceHud.title"] = "Renn-Anzeige",
				["settings.raceHud.desc"] = "Zwischenstand waehrend eines Rennens: Platz, Fortschritt, Leisten und Items je Teilnehmer.",
				["settings.raceHudPos.title"] = "Lage der Renn-Anzeige",
				["settings.raceHudPos.desc"] = "Anzeige an die Maus haengen und mit einem Klick absetzen. Gezeigt wird sie dabei mit acht Teilnehmern.",
				["settings.summaryState.title"] = "Ergebnis erscheint",
				["settings.summaryState.desc"] = "Zugeklappt ist es eine schmale Leiste am unteren Bildrand und gibt den Bericht frei. Der Knopf in der Titelleiste des Fensters setzt diesen Wert ebenfalls.",
				["settings.summaryState.open"] = "OFFEN",
				["settings.summaryState.collapsed"] = "ZUGEKLAPPT",
				["settings.ghostPb.title"] = "Bestzeit-Ghost",
				["settings.ghostPb.desc"] = "Laesst den eigenen schnellsten Lauf derselben Karte im selben Modus mitlaufen - durchsichtig und ohne Kollision.",
				["settings.comparison.title"] = "Vergleichslauf",
				["settings.comparison.desc"] = "Automatisch = deine Bestzeit auf dieser Karte und Strecke. Gewaehlt = der Lauf, den du unter MEINE LAEUFE festgenagelt hast.",
				["settings.comparison.auto"] = "AUTOMATISCH",
				["settings.comparison.manual"] = "GEWAEHLT",
				["settings.ghostOpacity.title"] = "Deckkraft des Ghosts",
				["settings.ghostOpacity.desc"] = "Wie deutlich die durchsichtige Figur zu sehen ist. Wirkt sofort, auch mitten im Lauf.",
				["settings.ghostOpacity.faint"] = "DEZENT",
				["settings.ghostOpacity.normal"] = "NORMAL",
				["settings.ghostOpacity.solid"] = "DEUTLICH",
				["settings.ghostItems.title"] = "Item in der Hand des Ghosts",
				["settings.ghostItems.desc"] = "Zeigt am Ghost-Modell, was der Laeufer an dieser Stelle in der Hand hielt.",
				["settings.ghostPanel.title"] = "Panel des Gegners",
				["settings.ghostPanel.desc"] = "Kleines Feld mit Uhr, Ausdauer, Statuswerten und Inventar des Ghosts.",
				["settings.ghostPanelPos.title"] = "Lage des Gegner-Panels",
				["settings.ghostPanelPos.desc"] = "Panel an die Maus haengen und mit einem Klick absetzen.",
				["settings.ghost.hint"] = "Einen fremden Ghost holst du dir in der Rangliste: Zeile anklicken, dann GEGEN DIESEN GHOST TRAINIEREN.",
				["settings.rules.hint"] = "Die Uhr laeuft immer bei der ersten Eingabe an, und die Items werden immer aus dem Seed des Laufs gewuerfelt. Beides ist keine Einstellung: eine Rangliste kann nur vergleichen, was unter denselben Regeln entstanden ist.",
				["settings.logLevel.title"] = "Log-Umfang",
				["settings.logLevel.desc"] = "Wie viel der Mod ins BepInEx-Log schreibt. Fehler und Warnungen bleiben immer sichtbar; Ausfuehrlich hilft beim Melden eines Problems, kostet aber etwas Leistung.",
				["settings.logLevel.error"] = "FEHLER",
				["settings.logLevel.warning"] = "WARNUNG",
				["settings.logLevel.info"] = "NORMAL",
				["settings.logLevel.debug"] = "AUSFUEHRLICH",
				["settings.spawnLog.title"] = "Spawn-Protokoll",
				["settings.spawnLog.desc"] = "Schreibt jeden Spawn-Vorgang ins BepInEx-Log. Zum Nachweis, dass zwei Laeufe mit gleichem Seed dieselben Gegenstaende bekommen. Kostet Leistung.",
				["settings.btn.logFolder"] = "LOG-ORDNER OEFFNEN",
				["settings.btn.upload"] = "UPLOADS JETZT SENDEN",
				["settings.info.modVersion"] = "Mod-Version",
				["settings.info.server"] = "Server",
				["settings.info.gameVersion"] = "Spielversion",
				["settings.info.mapSet"] = "Karten-Satz",
				["settings.info.mapSetValue"] = "{0} Karten, Kennung {1}",
				["settings.info.steam"] = "Steam-Konto",
				["settings.info.steamPending"] = "noch nicht bereit",
				["settings.info.rank"] = "Rang",
				["settings.info.pendingUploads"] = "Offene Uploads",
				["help.title"] = "HILFE",
				["help.subtitle"] = "Wie PEAK RANKED funktioniert und was die Modi unterscheidet",
				["help.cat.overview"] = "UEBERBLICK",
				["help.cat.dailyCup"] = "DAILY CUP",
				["help.cat.ghostDuel"] = "1V1 GHOST DUELL",
				["help.cat.speedrun"] = "SPEEDRUN",
				["help.cat.liveRace"] = "LIVE RACE",
				["help.cat.timing"] = "ZEITMESSUNG",
				["help.cat.elo"] = "ELO & RAENGE",
				["help.cat.ghosts"] = "GHOSTS & TRAINING",
				["help.cat.leaderboards"] = "RANGLISTEN",
				["help.cat.fairness"] = "FAIRES SPIEL",
				["help.cat.trouble"] = "WENN ETWAS HAKT",
				["run.speedrun.subtitle"] = "Allein gegen die Uhr",
				["run.race.subtitle"] = "Gegen andere auf derselben Strecke",
				["run.mode.static"] = "STATIC",
				["run.mode.random"] = "RANDOM",
				["run.mode.hint"] = "STATIC: Seed und Karte selbst wählen.   RANDOM: beides bleibt bis zum Start geheim.",
				["run.box.mountain"] = "SEED & KARTE",
				["run.box.random"] = "ZUFALLSBERG",
				["run.box.ascent"] = "AUFSTIEGSSTUFE",
				["run.box.route"] = "STRECKE",
				["run.box.race"] = "RENNEN",
				["run.btn.daily"] = "DAILY",
				["run.btn.copySeed"] = "KOPIEREN",
				["run.btn.today"] = "HEUTE",
				["run.seed.hint"] = "Gleicher Seed = gleicher Berg. Strg+V fügt einen kopierten Seed ein.",
				["run.random.hint.race"] = "Seed und Karte werden erst beim Anlegen des Rennens gewürfelt - auch der Host weiß vorher nicht, welcher Berg kommt.",
				["run.random.hint.solo"] = "Seed und Karte werden erst beim Start gewürfelt - du siehst den Berg zum ersten Mal, wenn du davor stehst.",
				["run.route.limitHint"] = "PEAK bietet nur die ersten {0} Abschnitte als Mini-Run an.",
				["run.btn.autoStart"] = "AUTO-START",
				["run.btn.rivals"] = "MITSTREITER ZEIGEN",
				["run.hint.rivalsOn"] = "Mitstreiter erscheinen in deinem Berg, waehrend sie klettern.",
				["run.hint.rivalsOff"] = "Nur der Zwischenstand wird geteilt - niemand ist in deinem Berg zu sehen.",
				["run.btn.join"] = "BEITRETEN",
				["run.btn.create"] = "RENNEN ERSTELLEN",
				["run.btn.copyCode"] = "CODE KOPIEREN",
				["run.btn.airport"] = "IN DEN FLUGHAFEN",
				["run.btn.startRace"] = "RENNEN STARTEN",
				["run.btn.leave"] = "VERLASSEN",
				["run.btn.cancel"] = "ABBRECHEN",
				["run.btn.start"] = "RUN STARTEN",
				["run.players"] = "{0} Spieler",
				["run.msg.noDailySeed"] = "Kein Daily-Seed vom Server verfügbar.",
				["run.msg.seedCopied"] = "Seed {0} kopiert.",
				["run.msg.creating"] = "Rennen wird angelegt ...",
				["run.msg.created"] = "Code {0} - teilen, dann in den Flughafen.",
				["run.msg.createFailed"] = "Anlegen fehlgeschlagen: {0}",
				["run.msg.codeTooShort"] = "Bitte den sechsstelligen Code eingeben.",
				["run.msg.joining"] = "Trete {0} bei ...",
				["run.msg.joined"] = "Beigetreten ({0}/{1}) - ab in den Flughafen.",
				["run.msg.joinFailed"] = "Beitritt fehlgeschlagen: {0}",
				["run.msg.startFailed"] = "Start fehlgeschlagen: {0}",
				["run.msg.left"] = "Race verlassen.",
				["run.msg.codeCopied"] = "Code {0} kopiert.",
				["run.btn.back"] = "ZURÜCK",
				["run.msg.configFailed"] = "Renn-Einstellungen konnten nicht übernommen werden: {0}",
				["race.role.box"] = "HOST ODER BEITRETEN?",
				["race.role.host"] = "RENNEN HOSTEN",
				["race.role.join"] = "RENNEN BEITRETEN",
				["race.role.hint"] = "Der Host legt Seed, Karte, Stufe und Strecke fest und bekommt einen Code. Alle anderen brauchen nur diesen Code - die Einstellungen kommen mit.",
				["race.join.hint"] = "Code vom Host eingeben - die Renneinstellungen siehst du nach dem Beitritt.",
				["run.level.slot"] = "Slot {0}",
				["run.level.noCatalog"] = "Karten-Katalog noch nicht gelesen.",
				["run.level.map"] = "Karte {0}/{1}",
				["run.level.biomes"] = "Biome {0}",
				["run.level.version"] = "Spielversion {0} (Satz {1})",
				["run.level.today"] = "heutige Tageskarte",
				["run.level.swapped"] = "von einem Mod ausgetauscht (waere {0}) - nicht wertbar",
				["run.summary.seed"] = "Seed",
				["config.ascent.tenderfoot"] = "NEULING",
				["config.ascent.peak"] = "PEAK",
				["config.ascent.numbered"] = "AUFSTIEG {0}",
				["config.ascent.desc.tenderfoot"] = "Klettern verbraucht weniger Ausdauer. Hunger nimmt langsamer zu. Keine Zeitbegrenzung.",
				["config.ascent.desc.0"] = "Die Standard-Schwierigkeit auf der Insel.",
				["config.ascent.desc.1"] = "Mehr Fallschaden.",
				["config.ascent.desc.2"] = "Hunger nimmt schneller zu.",
				["config.ascent.desc.3"] = "Gegenstände sind schwerer.",
				["config.ascent.desc.4"] = "Es gibt keine Leuchtfackeln auf dem PEAK.",
				["config.ascent.desc.5"] = "Die Nacht ist kalt.",
				["config.ascent.desc.6"] = "Klettern verbraucht mehr Ausdauer.",
				["config.ascent.desc.more"] = "Von Anfang an verflucht. Fluch steigt mit jeder Wiederbelebung.",
				["config.route.whole"] = "GANZER BERG",
				["config.route.biome"] = "BIOM {0}",
				["config.route.biomeTest"] = "BIOM {0} (TEST)",
				["config.route.desc.whole"] = "Vom Strand bis zum PEAK - die komplette Strecke.",
				["config.route.desc.experimental"] = "Experimentell: PEAK bietet den 5. Abschnitt (THE CITADEL) nicht als Mini-Run an. Ausgang offen - das Log zeigt nach dem Start, ob der Wert übernommen wurde.",
				["config.route.desc.mini"] = "Mini-Run: nur der {0}. Abschnitt des Bergs. Welches Biom dort liegt, entscheidet der Seed.",
				["summary.title"] = "ERGEBNIS",
				["summary.subtitle"] = "Zuklappen gibt den Pfadfinderbericht frei",
				["summary.btn.collapse"] = "ZUKLAPPEN",
				["summary.btn.expand"] = "AUFKLAPPEN",
				["summary.box.result"] = "ERGEBNIS",
				["summary.box.run"] = "LAUF",
				["summary.box.splits"] = "SPLITS",
				["summary.box.race"] = "RENNEN",
				["summary.col.segment"] = "ABSCHNITT",
				["summary.col.total"] = "GESAMT",
				["summary.col.time"] = "ZEIT",
				["summary.col.player"] = "SPIELER",
				["summary.info.map"] = "Karte: {0} {1}",
				["summary.info.ascent"] = "Aufstieg: {0}   Spiel: {1}",
				["summary.info.route"] = "Strecke: {0}",
				["summary.info.seed"] = "Seed: {0}",
				["summary.info.mode"] = "Modus: {0}",
				["summary.info.race"] = "Rennen: {0}   ({1} Teilnehmer)",
				["summary.info.opponent"] = "Gegner: {0} ({1} ELO)",
				["summary.info.ghost"] = "Ghost: {0}",
				["summary.cmp.opponent"] = "Gegner",
				["summary.cmp.ghost"] = "Ghost",
				["summary.cmp.winner"] = "Sieger {0}",
				["summary.cmp.pb"] = "Bestzeit {0}",
				["summary.newPb"] = "NEUE BESTZEIT",
				["summary.pbDelta"] = "PB Delta: {0}",
				["summary.duel.won"] = "gewonnen",
				["summary.duel.lost"] = "verloren",
				["summary.duel.result"] = "Duell {0}: {1} -> {2} ELO ({3})",
				["summary.upload.sending"] = "Upload: wird gesendet ...",
				["summary.upload.practice"] = "Übungslauf - kein Eintrag ins Leaderboard",
				["summary.upload.vanilla"] = "Vanilla-Lauf - ausserhalb der Wertung",
				["summary.upload.pb"] = "Upload: OK (Personal Best!)",
				["summary.upload.ok"] = "Upload: OK",
				["summary.upload.duplicate"] = "Upload: OK (bereits bekannt)",
				["summary.upload.review"] = "Upload: in Prüfung - zählt, sobald sie durch ist",
				["summary.upload.flagged"] = "Upload: geflaggt (Anti-Cheat) - nicht im Board",
				["summary.upload.rejected"] = "Upload: vom Server abgelehnt",
				["verdict.died"] = "GESTORBEN",
				["verdict.aborted"] = "ABGEBROCHEN",
				["verdict.won"] = "GEWONNEN",
				["verdict.lost"] = "VERLOREN",
				["verdict.finished"] = "IM ZIEL",
				["verdict.place2"] = "PLATZ 2",
				["verdict.place3"] = "PLATZ 3",
				["verdict.placeN"] = "PLATZ {0}",
				["verdict.raceWon"] = "RENNEN GEWONNEN",
				["verdict.done"] = "GESCHAFFT",
				["rank.loading"] = "Daily-Board: wird geladen ...",
				["rank.unreachable"] = "Daily-Board: nicht erreichbar",
				["rank.position"] = "Daily-Board: #{0} von {1}",
				["rank.none"] = "Daily-Board: -",
				["state.finished"] = "im Ziel",
				["state.dnf"] = "DNF",
				["state.ready"] = "bereit",
				["state.loading"] = "lädt ...",
				["hud.compare"] = "Vergleich (PB)",
				["hud.compare.pinned"] = "Vergleich (gewaehlt)",
				["hud.sob"] = "Beste mögliche Zeit",
				["hud.ready"] = "Bereit - erste Eingabe startet die Zeit",
				["hud.preview.segment"] = "Abschnitt {0}",
				["hud.ghost"] = "Ghost",
				["hud.vs"] = "VS.",
				["hud.finish"] = "Ziel  {0}",
				["hud.newPb"] = "NEUE BESTZEIT",
				["hud.died"] = "TOT - RUN UNGÜLTIG",
				["hud.aborted"] = "RUN ABGEBROCHEN",
				["hud.meta.seed"] = "Seed {0}",
				["hud.meta.ascent"] = "Aufstieg {0}",
				["hud.vanilla.note"] = "Nur Zeitmessung – kein Seed, kein Ghost, kein Eintrag",
				["overlay.mode"] = "Modus: {0}",
				["overlay.seed"] = "Seed: {0}",
				["overlay.map"] = "Karte: {0}  Aufstieg: {1}",
				["overlay.waitingInput"] = "Warte auf erste Eingabe ...",
				["overlay.pb"] = "PB: {0}",
				["overlay.splits"] = "--- Splits ---",
				["overlay.completed"] = "RUN ABGESCHLOSSEN",
				["overlay.newPb"] = "NEUE BESTZEIT!",
				["overlay.pbDelta"] = "PB Delta: {0}",
				["overlay.died"] = "TOT - RUN UNGÜLTIG",
				["overlay.aborted"] = "RUN ABGEBROCHEN",
				["overlay.result"] = "ERGEBNIS: {0}",
				["race.hud.aboutToStart"] = "GLEICH GEHT ES LOS",
				["race.hud.waiting"] = "WARTE AUF MITSPIELER",
				["race.hud.go"] = "LOS!",
				["race.hud.finished"] = "RENNEN BEENDET",
				["race.hud.previewName"] = "Teilnehmer",
				["race.hud.hintHost"] = "Bordkarte am Kiosk → START   ·   {0} = Menü",
				["race.hud.hintGuest"] = "Warte auf den Host   ·   {0} = Menü",
				["race.countdown.caption"] = "RENNEN STARTET IN",
				["race.countdown.go"] = "LOS!",
				["race.pass.participants"] = "{0}/{1} Teilnehmer",
				["race.pass.hostHint"] = "START beginnt das Rennen für alle.",
				["race.pass.guestHint"] = "Warte auf den Host.",
				["race.loadFailed.title"] = "RENNEN VERLASSEN",
				["race.loadFailed"] = "Die Welt des Rennens konnte nicht rechtzeitig geladen werden. Du wurdest aus dem Rennen genommen, damit die anderen starten können.",
				["duel.err.noSteam"] = "SteamID nicht verfuegbar. Bitte Steam starten.",
				["duel.err.noOpponent"] = "Kein Duell-Gegner gefunden ({0}).",
				["duel.err.matchmaking"] = "Fehler beim Verarbeiten des Matchmakings.",
				["duel.err.noGhostData"] = "Der Ghost von {0} hat keine Aufzeichnung. Bitte einen anderen Gegner waehlen.",
				["ghostPanel.title"] = "GEGNER",
				["ghostPanel.nameSuffix"] = "{0} (GHOST)",
				["ghostPanel.remaining"] = "noch {0}",
				["status.injury"] = "Verletzt",
				["status.hunger"] = "Hunger",
				["status.cold"] = "Kalt",
				["status.poison"] = "Gift",
				["status.crab"] = "Krabbe",
				["status.curse"] = "Fluch",
				["status.drowsy"] = "Muede",
				["status.weight"] = "Last",
				["status.hot"] = "Hitze",
				["status.thorns"] = "Dornen",
				["status.spores"] = "Sporen",
				["status.web"] = "Netz",
				["status.arrow"] = "Pfeil",
				["status.petrify"] = "Versteinert",
				["status.flytrap"] = "Falle",
				["season.sign.title"] = "SAISON {0} ENDET",
				["season.sign.unknown"] = "SAISON",
				["aiDisclosure.label"] = "MIT KI GEBAUT",
				["aiDisclosure.1"] = "Mit KI-Hilfe gebaut. Manche haben das persönlich genommen.",
				["aiDisclosure.2"] = "6 Monate hat es niemand gebaut. Also haben eine KI und ich es getan.",
				["aiDisclosure.3"] = "Enthält Code, den eine KI geschrieben hat. Und sehr viel Kaffee.",
				["aiDisclosure.4"] = "Ein Mensch hat gebaut, eine KI geholfen. Keinem ist es peinlich.",
				["aiDisclosure.5"] = "Angeblich ist das kein echtes Programmieren. Läuft trotzdem.",
				["aiDisclosure.6"] = "Kein Team, kein Budget, ein KI-Co-Pilot. Trotzdem fertig geworden.",
				["aiDisclosure.7"] = "Falls dich das stört: Niemand hat dich gezwungen, den Mod zu installieren."
			};
		}
	}
	internal static class StringsEn
	{
		internal static Dictionary<string, string> Build()
		{
			return new Dictionary<string, string>
			{
				["common.sections"] = "SECTIONS",
				["common.you"] = "(You)",
				["common.anonymous"] = "Anonymous",
				["common.opponent"] = "Opponent",
				["common.host"] = "Host",
				["common.notAvailable"] = "not available",
				["common.unknown"] = "unknown",
				["common.notBound"] = "NOT BOUND",
				["common.notBoundLower"] = "not bound",
				["common.understood"] = "GOT IT",
				["common.date.format"] = "MM/dd HH:mm",
				["gate.mapAltered.title"] = "MAP NOT VERIFIED",
				["gate.mapAltered"] = "Another mod has replaced this map before PEAK RANKED could see it: the slot for today holds {0}, but the game bakes {1} there.\n\nA ranked time only means something if everyone climbed the same mountain, so this run cannot be started as a ranked run.\n\nRestart PEAK without the mod that changes the map pool - MorePeak is the usual one; it swaps a single slot for a randomly chosen level, which is why most days are unaffected and this one is not. Or use the left signpost for a normal, unranked run.",
				["mode.staticDaily"] = "DAILY CUP",
				["mode.rankedDuel"] = "1V1 GHOST DUEL",
				["mode.speedrun"] = "SPEEDRUN",
				["mode.ghostTraining"] = "GHOST TRAINING",
				["mode.liveRace"] = "LIVE RACE",
				["mode.custom"] = "CUSTOM RUN",
				["mode.vanilla"] = "VANILLA – NOT RANKED",
				["mode.short.staticDaily"] = "Daily Cup",
				["mode.short.rankedDuel"] = "Ghost Duel",
				["mode.short.speedrunSet"] = "Speedrun Set Seed",
				["mode.short.speedrunRandom"] = "Speedrun Random",
				["mode.short.liveRace"] = "Live Race",
				["sign.ranked"] = "RANKED",
				["sign.placement"] = "PLACEMENT ({0}/3)",
				["sign.settings"] = "SETTINGS",
				["menu.subtitle"] = "Global leaderboards, best times and your career profile",
				["menu.box.profile"] = "YOUR CAREER PROFILE",
				["menu.box.view"] = "VIEW",
				["menu.box.table"] = "LEADERBOARD",
				["menu.box.myRuns"] = "MY RUNS",
				["menu.btn.refresh"] = "REFRESH",
				["menu.tab.elo"] = "ELO RANKING",
				["menu.tab.myRuns"] = "MY RUNS",
				["menu.myRuns.hint"] = "Click a row to pin it as your comparison - click again to release it.",
				["menu.myRuns.empty"] = "No runs recorded yet.",
				["menu.myRuns.pinned"] = "COMPARISON",
				["menu.period.today"] = "TODAY",
				["menu.period.allTime"] = "ALL-TIME",
				["menu.version.only"] = "{0} ONLY",
				["menu.version.all"] = "ALL VERSIONS",
				["menu.route.whole"] = "WHOLE MOUNTAIN",
				["menu.route.only"] = "{0} ONLY",
				["menu.col.player"] = "PLAYER",
				["menu.col.tier"] = "CLIMBER RANK",
				["menu.col.duels"] = "DUELS (W/L)",
				["menu.col.time"] = "TIME",
				["menu.col.map"] = "MAP",
				["menu.col.seed"] = "SEED",
				["menu.col.game"] = "GAME",
				["menu.col.date"] = "DATE",
				["menu.col.route"] = "ROUTE",
				["menu.col.mode"] = "MODE",
				["menu.card.loading"] = "Loading career profile ...",
				["menu.card.duels"] = "Duels: {0} ({1}% wins)",
				["menu.card.pb"] = "Daily Cup (best time): {0}",
				["menu.card.placement"] = "PLACEMENT ({0}/3 RUNS)",
				["menu.card.placementHint"] = "{0} more run(s) until your first climber rank",
				["menu.page"] = "Page {0} / {1}",
				["menu.btn.prev"] = "< PREVIOUS",
				["menu.btn.next"] = "NEXT >",
				["menu.btn.trainTop"] = "TRAIN VS. TOP GHOST",
				["menu.btn.trainVs"] = "TRAIN VS. {0}",
				["menu.loading"] = "Loading data from the server ...",
				["menu.error.unreachable"] = "Server unreachable.",
				["menu.error.elo"] = "Could not read the ranking.",
				["menu.error.speedrunBoard"] = "Could not read the speedrun board.",
				["menu.error.leaderboard"] = "Could not read the leaderboard.",
				["menu.empty.elo"] = "No ranked players yet. Finish 3 runs!",
				["menu.empty.speedrun"] = "No runs recorded yet.",
				["menu.empty.speedrunVersion"] = "No runs on game version {0} - ALL VERSIONS shows the older ones.",
				["menu.empty.dailyToday"] = "No runs today yet - be the first!",
				["menu.empty.dailyAllTime"] = "No all-time runs recorded yet.",
				["menu.cell.wholeMountain"] = "Whole mountain",
				["menu.cell.segment"] = "Segment {0}",
				["menu.meta.blocked"] = "{0} entries   ·   {1} of them faded: different map set or no recording, not playable as a ghost",
				["menu.meta.speedrun"] = "Entries: {0}   ·   Your game: {1} (set {2}, {3} maps)",
				["menu.meta.total"] = "Entries total: {0}",
				["settings.subtitle"] = "Settings - every change takes effect immediately",
				["settings.cat.keys"] = "KEYS",
				["settings.cat.timer"] = "TIMER & HUD",
				["settings.cat.ghost"] = "GHOST & REPLAY",
				["settings.cat.run"] = "RUN & SCORING",
				["settings.cat.diagnostics"] = "DIAGNOSTICS",
				["settings.btn.help"] = "HELP",
				["settings.toggle.on"] = "ON",
				["settings.toggle.off"] = "OFF",
				["settings.key.overlay.title"] = "Timer display",
				["settings.key.overlay.desc"] = "Shows and hides the timer panel and the race display. Outside a run the timer stays hidden - this key brings it up early. The clock keeps running either way.",
				["settings.key.window.title"] = "This window",
				["settings.key.window.desc"] = "Opens the settings - in the menu as well as on the mountain.",
				["settings.key.race.title"] = "Race window",
				["settings.key.race.desc"] = "Code, participants and the way out of a running race. You create one at the LIVE RACE sign.",
				["settings.key.reset.title"] = "Discard run",
				["settings.key.reset.desc"] = "Discards the current attempt and sets the clock to 0. No map reload - the level stays as it is. Unbound by default.",
				["settings.key.hint"] = "While a key is being read, ESC cancels and DEL clears the binding.",
				["settings.key.capture"] = "PRESS A KEY ...",
				["settings.race.active"] = "A race is running - the key opens the window.",
				["settings.race.inactive"] = "Only during a race - none is running right now.",
				["settings.display.title"] = "Presentation",
				["settings.display.desc"] = "The native panel belongs to the game picture and scales with it. The classic display is the fallback in case the panel causes trouble.",
				["settings.display.panel"] = "PANEL",
				["settings.display.classic"] = "CLASSIC",
				["settings.position.title"] = "Display position",
				["settings.position.desc"] = "The timer panel hangs on the mouse, a left click drops it.",
				["settings.position.move"] = "MOVE",
				["settings.position.reset"] = "TOP LEFT CORNER",
				["settings.position.hint"] = "Left click drops the display   -   ESC cancels",
				["settings.summary.title"] = "Result after the run",
				["settings.summary.desc"] = "Puts result, splits, comparison, upload status and daily placing over the game's scout report. The report itself stays untouched.",
				["settings.raceHud.title"] = "Race display",
				["settings.raceHud.desc"] = "Standings during a race: place, progress, bars and items per participant.",
				["settings.raceHudPos.title"] = "Race display position",
				["settings.raceHudPos.desc"] = "Attach the display to the mouse and drop it with a click. It is shown with eight participants.",
				["settings.summaryState.title"] = "Result appears",
				["settings.summaryState.desc"] = "Collapsed it is a narrow bar at the bottom edge and frees the report. The button in the window's title bar sets this value as well.",
				["settings.summaryState.open"] = "OPEN",
				["settings.summaryState.collapsed"] = "COLLAPSED",
				["settings.ghostPb.title"] = "Best-time ghost",
				["settings.ghostPb.desc"] = "Runs your own fastest attempt on the same map in the same mode alongside you - transparent and without collision.",
				["settings.comparison.title"] = "Comparison run",
				["settings.comparison.desc"] = "Automatic = your best time on this map and route. Chosen = the run you pinned under MY RUNS.",
				["settings.comparison.auto"] = "AUTOMATIC",
				["settings.comparison.manual"] = "CHOSEN",
				["settings.ghostOpacity.title"] = "Ghost opacity",
				["settings.ghostOpacity.desc"] = "How clearly the transparent figure shows up. Takes effect at once, even mid-run.",
				["settings.ghostOpacity.faint"] = "FAINT",
				["settings.ghostOpacity.normal"] = "NORMAL",
				["settings.ghostOpacity.solid"] = "SOLID",
				["settings.ghostItems.title"] = "Item in the ghost's hand",
				["settings.ghostItems.desc"] = "Shows on the ghost model what the runner was holding at that point.",
				["settings.ghostPanel.title"] = "Opponent panel",
				["settings.ghostPanel.desc"] = "Small box with the ghost's clock, stamina, status values and inventory.",
				["settings.ghostPanelPos.title"] = "Opponent panel position",
				["settings.ghostPanelPos.desc"] = "Attach the panel to the mouse and drop it with a click.",
				["settings.ghost.hint"] = "You pick up someone else's ghost in the leaderboard: click a row, then TRAIN AGAINST THIS GHOST.",
				["settings.rules.hint"] = "The clock always starts on your first input, and the items are always rolled from the seed of the run. Neither is a setting: a leaderboard can only compare runs made under the same rules.",
				["settings.logLevel.title"] = "Log verbosity",
				["settings.logLevel.desc"] = "How much the mod writes to the BepInEx log. Errors and warnings always show; Verbose helps when reporting a problem, at some cost to performance.",
				["settings.logLevel.error"] = "ERRORS",
				["settings.logLevel.warning"] = "WARNINGS",
				["settings.logLevel.info"] = "NORMAL",
				["settings.logLevel.debug"] = "VERBOSE",
				["settings.spawnLog.title"] = "Spawn log",
				["settings.spawnLog.desc"] = "Writes every spawn to the BepInEx log. To prove that two runs with the same seed get the same items. Costs performance.",
				["settings.btn.logFolder"] = "OPEN LOG FOLDER",
				["settings.btn.upload"] = "SEND UPLOADS NOW",
				["settings.info.modVersion"] = "Mod version",
				["settings.info.server"] = "Server",
				["settings.info.gameVersion"] = "Game version",
				["settings.info.mapSet"] = "Map set",
				["settings.info.mapSetValue"] = "{0} maps, id {1}",
				["settings.info.steam"] = "Steam account",
				["settings.info.steamPending"] = "not ready yet",
				["settings.info.rank"] = "Rank",
				["settings.info.pendingUploads"] = "Pending uploads",
				["help.title"] = "HELP",
				["help.subtitle"] = "How PEAK RANKED works and what sets the modes apart",
				["help.cat.overview"] = "OVERVIEW",
				["help.cat.dailyCup"] = "DAILY CUP",
				["help.cat.ghostDuel"] = "1V1 GHOST DUEL",
				["help.cat.speedrun"] = "SPEEDRUN",
				["help.cat.liveRace"] = "LIVE RACE",
				["help.cat.timing"] = "TIMING",
				["help.cat.elo"] = "ELO & RANKS",
				["help.cat.ghosts"] = "GHOSTS & TRAINING",
				["help.cat.leaderboards"] = "LEADERBOARDS",
				["help.cat.fairness"] = "FAIR PLAY",
				["help.cat.trouble"] = "WHEN SOMETHING STICKS",
				["run.speedrun.subtitle"] = "Alone against the clock",
				["run.race.subtitle"] = "Against others on the same route",
				["run.mode.static"] = "STATIC",
				["run.mode.random"] = "RANDOM",
				["run.mode.hint"] = "STATIC: pick seed and map yourself.   RANDOM: both stay secret until the start.",
				["run.box.mountain"] = "SEED & MAP",
				["run.box.random"] = "RANDOM MOUNTAIN",
				["run.box.ascent"] = "ASCENT LEVEL",
				["run.box.route"] = "ROUTE",
				["run.box.race"] = "RACE",
				["run.btn.daily"] = "DAILY",
				["run.btn.copySeed"] = "COPY",
				["run.btn.today"] = "TODAY",
				["run.seed.hint"] = "Same seed = same mountain. Ctrl+V pastes a copied seed.",
				["run.random.hint.race"] = "Seed and map are rolled only when the race is created - not even the host knows beforehand which mountain comes up.",
				["run.random.hint.solo"] = "Seed and map are rolled only at the start - you see the mountain for the first time when you stand in front of it.",
				["run.route.limitHint"] = "PEAK only offers the first {0} segments as a mini run.",
				["run.btn.autoStart"] = "AUTO-START",
				["run.btn.rivals"] = "SHOW RIVALS",
				["run.hint.rivalsOn"] = "Rivals appear in your mountain as they climb.",
				["run.hint.rivalsOff"] = "Only the standings are shared - no rivals in your mountain.",
				["run.btn.join"] = "JOIN",
				["run.btn.create"] = "CREATE RACE",
				["run.btn.copyCode"] = "COPY CODE",
				["run.btn.airport"] = "TO THE AIRPORT",
				["run.btn.startRace"] = "START RACE",
				["run.btn.leave"] = "LEAVE",
				["run.btn.cancel"] = "CANCEL",
				["run.btn.start"] = "START RUN",
				["run.players"] = "{0} players",
				["run.msg.noDailySeed"] = "No daily seed available from the server.",
				["run.msg.seedCopied"] = "Seed {0} copied.",
				["run.msg.creating"] = "Creating race ...",
				["run.msg.created"] = "Code {0} - share it, then head to the airport.",
				["run.msg.createFailed"] = "Creating failed: {0}",
				["run.msg.codeTooShort"] = "Please enter the six-character code.",
				["run.msg.joining"] = "Joining {0} ...",
				["run.msg.joined"] = "Joined ({0}/{1}) - off to the airport.",
				["run.msg.joinFailed"] = "Joining failed: {0}",
				["run.msg.startFailed"] = "Start failed: {0}",
				["run.msg.left"] = "Race left.",
				["run.msg.codeCopied"] = "Code {0} copied.",
				["run.btn.back"] = "BACK",
				["run.msg.configFailed"] = "Could not update the race: {0}",
				["race.role.box"] = "HOST OR JOIN?",
				["race.role.host"] = "HOST A RACE",
				["race.role.join"] = "JOIN A RACE",
				["race.role.hint"] = "The host picks seed, map, ascent and route and gets a code. Everyone else only needs that code - the settings come with it.",
				["race.join.hint"] = "Enter the host's code - the race settings appear once you are in.",
				["run.level.slot"] = "Slot {0}",
				["run.level.noCatalog"] = "Map catalogue not read yet.",
				["run.level.map"] = "Map {0}/{1}",
				["run.level.biomes"] = "Biomes {0}",
				["run.level.version"] = "Game version {0} (set {1})",
				["run.level.today"] = "today's map",
				["run.level.swapped"] = "swapped by a mod (should be {0}) - not rankable",
				["run.summary.seed"] = "Seed",
				["config.ascent.tenderfoot"] = "TENDERFOOT",
				["config.ascent.peak"] = "PEAK",
				["config.ascent.numbered"] = "ASCENT {0}",
				["config.ascent.desc.tenderfoot"] = "Climbing costs less stamina. Hunger builds up more slowly. No time limit.",
				["config.ascent.desc.0"] = "The standard difficulty on the island.",
				["config.ascent.desc.1"] = "More fall damage.",
				["config.ascent.desc.2"] = "Hunger builds up faster.",
				["config.ascent.desc.3"] = "Items are heavier.",
				["config.ascent.desc.4"] = "There are no flares on the PEAK.",
				["config.ascent.desc.5"] = "The night is cold.",
				["config.ascent.desc.6"] = "Climbing costs more stamina.",
				["config.ascent.desc.more"] = "Cursed from the start. The curse grows with every revive.",
				["config.route.whole"] = "WHOLE MOUNTAIN",
				["config.route.biome"] = "BIOME {0}",
				["config.route.biomeTest"] = "BIOME {0} (TEST)",
				["config.route.desc.whole"] = "From the shore to the PEAK - the complete route.",
				["config.route.desc.experimental"] = "Experimental: PEAK does not offer the 5th segment (THE CITADEL) as a mini run. Outcome open - the log shows after the start whether the value was accepted.",
				["config.route.desc.mini"] = "Mini run: only segment {0} of the mountain. Which biome lies there is decided by the seed.",
				["summary.title"] = "RESULT",
				["summary.subtitle"] = "Collapsing frees the scout report",
				["summary.btn.collapse"] = "COLLAPSE",
				["summary.btn.expand"] = "EXPAND",
				["summary.box.result"] = "RESULT",
				["summary.box.run"] = "RUN",
				["summary.box.splits"] = "SPLITS",
				["summary.box.race"] = "RACE",
				["summary.col.segment"] = "SEGMENT",
				["summary.col.total"] = "TOTAL",
				["summary.col.time"] = "TIME",
				["summary.col.player"] = "PLAYER",
				["summary.info.map"] = "Map: {0} {1}",
				["summary.info.ascent"] = "Ascent: {0}   Game: {1}",
				["summary.info.route"] = "Route: {0}",
				["summary.info.seed"] = "Seed: {0}",
				["summary.info.mode"] = "Mode: {0}",
				["summary.info.race"] = "Race: {0}   ({1} participants)",
				["summary.info.opponent"] = "Opponent: {0} ({1} ELO)",
				["summary.info.ghost"] = "Ghost: {0}",
				["summary.cmp.opponent"] = "Opponent",
				["summary.cmp.ghost"] = "Ghost",
				["summary.cmp.winner"] = "Winner {0}",
				["summary.cmp.pb"] = "Best time {0}",
				["summary.newPb"] = "NEW BEST TIME",
				["summary.pbDelta"] = "PB delta: {0}",
				["summary.duel.won"] = "won",
				["summary.duel.lost"] = "lost",
				["summary.duel.result"] = "Duel {0}: {1} -> {2} ELO ({3})",
				["summary.upload.sending"] = "Upload: sending ...",
				["summary.upload.practice"] = "Practice run - no leaderboard entry",
				["summary.upload.vanilla"] = "Vanilla run - outside the ranking",
				["summary.upload.pb"] = "Upload: OK (personal best!)",
				["summary.upload.ok"] = "Upload: OK",
				["summary.upload.duplicate"] = "Upload: OK (already known)",
				["summary.upload.review"] = "Upload: under review - counts once it is checked",
				["summary.upload.flagged"] = "Upload: flagged (anti-cheat) - not on the board",
				["summary.upload.rejected"] = "Upload: rejected by the server",
				["verdict.died"] = "DIED",
				["verdict.aborted"] = "ABORTED",
				["verdict.won"] = "WON",
				["verdict.lost"] = "LOST",
				["verdict.finished"] = "FINISHED",
				["verdict.place2"] = "2ND PLACE",
				["verdict.place3"] = "3RD PLACE",
				["verdict.placeN"] = "PLACE {0}",
				["verdict.raceWon"] = "RACE WON",
				["verdict.done"] = "MADE IT",
				["rank.loading"] = "Daily board: loading ...",
				["rank.unreachable"] = "Daily board: unreachable",
				["rank.position"] = "Daily board: #{0} of {1}",
				["rank.none"] = "Daily board: -",
				["state.finished"] = "finished",
				["state.dnf"] = "DNF",
				["state.ready"] = "ready",
				["state.loading"] = "loading ...",
				["hud.compare"] = "Compare (PB)",
				["hud.compare.pinned"] = "Compare (chosen)",
				["hud.sob"] = "Best possible time",
				["hud.ready"] = "Ready - first input starts the clock",
				["hud.preview.segment"] = "Segment {0}",
				["hud.ghost"] = "Ghost",
				["hud.vs"] = "VS.",
				["hud.finish"] = "Finish  {0}",
				["hud.newPb"] = "NEW BEST TIME",
				["hud.died"] = "DEAD - RUN INVALID",
				["hud.aborted"] = "RUN ABORTED",
				["hud.meta.seed"] = "Seed {0}",
				["hud.meta.ascent"] = "Ascent {0}",
				["hud.vanilla.note"] = "Timing only – no seed, no ghost, no submission",
				["overlay.mode"] = "Mode: {0}",
				["overlay.seed"] = "Seed: {0}",
				["overlay.map"] = "Map: {0}  Ascent: {1}",
				["overlay.waitingInput"] = "Waiting for first input ...",
				["overlay.pb"] = "PB: {0}",
				["overlay.splits"] = "--- Splits ---",
				["overlay.completed"] = "RUN COMPLETED",
				["overlay.newPb"] = "NEW PERSONAL BEST!",
				["overlay.pbDelta"] = "PB delta: {0}",
				["overlay.died"] = "DIED - RUN INVALID",
				["overlay.aborted"] = "RUN ABORTED",
				["overlay.result"] = "RESULT: {0}",
				["race.hud.aboutToStart"] = "ABOUT TO START",
				["race.hud.waiting"] = "WAITING FOR PLAYERS",
				["race.hud.go"] = "GO!",
				["race.hud.finished"] = "RACE FINISHED",
				["race.hud.previewName"] = "Racer",
				["race.hud.hintHost"] = "Boarding pass at the kiosk → START   ·   {0} = menu",
				["race.hud.hintGuest"] = "Waiting for the host   ·   {0} = menu",
				["race.countdown.caption"] = "RACE STARTS IN",
				["race.countdown.go"] = "GO!",
				["race.pass.participants"] = "{0}/{1} participants",
				["race.pass.hostHint"] = "START begins the race for everyone.",
				["race.pass.guestHint"] = "Waiting for the host.",
				["race.loadFailed.title"] = "RACE LEFT",
				["race.loadFailed"] = "The race world could not be loaded in time. You were removed from the race so the others can start.",
				["duel.err.noSteam"] = "Steam ID not available. Please start Steam.",
				["duel.err.noOpponent"] = "No duel opponent found ({0}).",
				["duel.err.matchmaking"] = "Error while processing matchmaking.",
				["duel.err.noGhostData"] = "The ghost of {0} has no replay data. Please try another opponent.",
				["ghostPanel.title"] = "OPPONENT",
				["ghostPanel.nameSuffix"] = "{0} (GHOST)",
				["ghostPanel.remaining"] = "{0} left",
				["status.injury"] = "Injured",
				["status.hunger"] = "Hunger",
				["status.cold"] = "Cold",
				["status.poison"] = "Poison",
				["status.crab"] = "Crab",
				["status.curse"] = "Curse",
				["status.drowsy"] = "Drowsy",
				["status.weight"] = "Weight",
				["status.hot"] = "Heat",
				["status.thorns"] = "Thorns",
				["status.spores"] = "Spores",
				["status.web"] = "Web",
				["status.arrow"] = "Arrow",
				["status.petrify"] = "Petrified",
				["status.flytrap"] = "Flytrap",
				["season.sign.title"] = "SEASON {0} ENDS",
				["season.sign.unknown"] = "SEASON",
				["aiDisclosure.label"] = "BUILT WITH AI",
				["aiDisclosure.1"] = "Built with AI help. Some people took that personally.",
				["aiDisclosure.2"] = "Nobody built this for 6 months. So an AI and I did.",
				["aiDisclosure.3"] = "Contains code written by an AI. And a lot of coffee.",
				["aiDisclosure.4"] = "A human built it, an AI helped. Neither is sorry.",
				["aiDisclosure.5"] = "Apparently this isn't real coding. It still runs.",
				["aiDisclosure.6"] = "No team, no budget, one AI co-pilot. Shipped anyway.",
				["aiDisclosure.7"] = "If this bothers you: nobody made you install the mod."
			};
		}
	}
}
namespace RankedPeak.Live
{
	public class LiveState
	{
		public uint TimeMs;

		public ushort Progress;

		public Vector3 Position;

		public byte[] Anim = new byte[11];

		public byte Stamina;

		public byte ExtraStamina;

		public byte[] Status = new byte[15];

		public ushort Item = ushort.MaxValue;

		public ushort[] Belt = new ushort[3] { 65535, 65535, 65535 };

		public byte BackpackType;

		public byte BackpackSlots;

		public ushort[] Pack = new ushort[4] { 65535, 65535, 65535, 65535 };

		public byte State;

		public byte Rank;

		public float ReceivedAt;

		public float ProgressFraction => (float)(int)Progress / 65535f;

		public LiveState Copy()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return new LiveState
			{
				TimeMs = TimeMs,
				Progress = Progress,
				Position = Position,
				Anim = (byte[])Anim.Clone(),
				Stamina = Stamina,
				ExtraStamina = ExtraStamina,
				Status = (byte[])Status.Clone(),
				Item = Item,
				Belt = (ushort[])Belt.Clone(),
				BackpackType = BackpackType,
				BackpackSlots = BackpackSlots,
				Pack = (ushort[])Pack.Clone(),
				State = State,
				Rank = Rank,
				ReceivedAt = ReceivedAt
			};
		}

		public byte[] ToBars()
		{
			byte[] array = new byte[17]
			{
				Stamina, ExtraStamina, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0, 0, 0, 0, 0, 0
			};
			for (int i = 0; i < Status.Length && 2 + i < array.Length; i++)
			{
				array[2 + i] = Status[i];
			}
			return array;
		}

		public InventorySnapshot ToInventory()
		{
			return new InventorySnapshot
			{
				ElapsedMs = TimeMs,
				Hand = Item,
				Belt = (ushort[])Belt.Clone(),
				BackpackType = BackpackType,
				BackpackSlots = BackpackSlots,
				BackpackItems = (ushort[])Pack.Clone()
			};
		}
	}
	public static class LiveFrame
	{
		public const byte MsgSample = 1;

		public const byte MsgBundle = 2;

		private const int FieldTime = 0;

		private const int FieldProgress = 1;

		private const int FieldPosition = 2;

		private const int FieldAnim = 3;

		private const int FieldVitals = 4;

		private const int FieldStatus = 5;

		private const int FieldItem = 6;

		private const int FieldBelt = 7;

		private const int FieldPack = 8;

		private const int FieldState = 9;

		private const int FieldRank = 10;

		private const int FieldCount = 11;

		private static readonly int[] FieldBytes = new int[11]
		{
			4, 2, 12, 11, 2, 15, 2, 6, 10, 1,
			1
		};

		public const int FullBytes = 68;

		public static readonly string[] StateCodes = new string[7] { "joined", "loading", "race_ready", "running", "finished", "dnf", "disconnected" };

		public static byte StateCode(string state)
		{
			for (byte b = 0; b < StateCodes.Length; b++)
			{
				if (StateCodes[b] == state)
				{
					return b;
				}
			}
			return 0;
		}

		public static string StateName(byte code)
		{
			if (code >= StateCodes.Length)
			{
				return "joined";
			}
			return StateCodes[code];
		}

		public static int DiffMask(LiveState previous, LiveState next)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (previous == null)
			{
				return 2047;
			}
			int num = 0;
			if (previous.TimeMs != next.TimeMs)
			{
				num |= 1;
			}
			if (previous.Progress != next.Progress)
			{
				num |= 2;
			}
			if (previous.Position != next.Position)
			{
				num |= 4;
			}
			if (!Same(previous.Anim, next.Anim))
			{
				num |= 8;
			}
			if (previous.Stamina != next.Stamina || previous.ExtraStamina != next.ExtraStamina)
			{
				num |= 0x10;
			}
			if (!Same(previous.Status, next.Status))
			{
				num |= 0x20;
			}
			if (previous.Item != next.Item)
			{
				num |= 0x40;
			}
			if (!Same(previous.Belt, next.Belt))
			{
				num |= 0x80;
			}
			if (previous.BackpackType != next.BackpackType || previous.BackpackSlots != next.BackpackSlots || !Same(previous.Pack, next.Pack))
			{
				num |= 0x100;
			}
			if (previous.State != next.State)
			{
				num |= 0x200;
			}
			if (previous.Rank != next.Rank)
			{
				num |= 0x400;
			}
			return num;
		}

		public static int MaskedBytes(int mask)
		{
			int num = 2;
			for (int i = 0; i < 11; i++)
			{
				if ((mask & (1 << i)) != 0)
				{
					num += FieldBytes[i];
				}
			}
			return num;
		}

		public static int Write(byte[] target, int offset, int mask, LiveState state)
		{
			WriteUInt16(target, ref offset, (ushort)mask);
			if ((mask & 1) != 0)
			{
				WriteUInt32(target, ref offset, state.TimeMs);
			}
			if ((mask & 2) != 0)
			{
				WriteUInt16(target, ref offset, state.Progress);
			}
			if ((mask & 4) != 0)
			{
				WriteFloat(target, ref offset, state.Position.x);
				WriteFloat(target, ref offset, state.Position.y);
				WriteFloat(target, ref offset, state.Position.z);
			}
			if ((mask & 8) != 0)
			{
				for (int i = 0; i < 11; i++)
				{
					target[offset++] = state.Anim[i];
				}
			}
			if ((mask & 0x10) != 0)
			{
				target[offset++] = state.Stamina;
				target[offset++] = state.ExtraStamina;
			}
			if ((mask & 0x20) != 0)
			{
				for (int j = 0; j < 15; j++)
				{
					target[offset++] = state.Status[j];
				}
			}
			if ((mask & 0x40) != 0)
			{
				WriteUInt16(target, ref offset, state.Item);
			}
			if ((mask & 0x80) != 0)
			{
				for (int k = 0; k < 3; k++)
				{
					WriteUInt16(target, ref offset, state.Belt[k]);
				}
			}
			if ((mask & 0x100) != 0)
			{
				target[offset++] = state.BackpackType;
				target[offset++] = state.BackpackSlots;
				for (int l = 0; l < 4; l++)
				{
					WriteUInt16(target, ref offset, state.Pack[l]);
				}
			}
			if ((mask & 0x200) != 0)
			{
				target[offset++] = state.State;
			}
			if ((mask & 0x400) != 0)
			{
				target[offset++] = state.Rank;
			}
			return offset;
		}

		public static int Read(byte[] source, int offset, LiveState state)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if (offset + 2 > source.Length)
			{
				throw new FormatException("Frame endet vor der Maske");
			}
			ushort num = ReadUInt16(source, ref offset);
			if (offset + (MaskedBytes(num) - 2) > source.Length)
			{
				throw new FormatException($"Frame zu kurz fuer Maske 0x{num:x}");
			}
			if ((num & 1) != 0)
			{
				state.TimeMs = ReadUInt32(source, ref offset);
			}
			if ((num & 2) != 0)
			{
				state.Progress = ReadUInt16(source, ref offset);
			}
			if ((num & 4) != 0)
			{
				state.Position = new Vector3(ReadFloat(source, ref offset), ReadFloat(source, ref offset), ReadFloat(source, ref offset));
			}
			if ((num & 8) != 0)
			{
				for (int i = 0; i < 11; i++)
				{
					state.Anim[i] = source[offset++];
				}
			}
			if ((num & 0x10) != 0)
			{
				state.Stamina = source[offset++];
				state.ExtraStamina = source[offset++];
			}
			if ((num & 0x20) != 0)
			{
				for (int j = 0; j < 15; j++)
				{
					state.Status[j] = source[offset++];
				}
			}
			if ((num & 0x40) != 0)
			{
				state.Item = ReadUInt16(source, ref offset);
			}
			if ((num & 0x80) != 0)
			{
				for (int k = 0; k < 3; k++)
				{
					state.Belt[k] = ReadUInt16(source, ref offset);
				}
			}
			if ((num & 0x100) != 0)
			{
				state.BackpackType = source[offset++];
				state.BackpackSlots = source[offset++];
				for (int l = 0; l < 4; l++)
				{
					state.Pack[l] = ReadUInt16(source, ref offset);
				}
			}
			if ((num & 0x200) != 0)
			{
				state.State = source[offset++];
			}
			if ((num & 0x400) != 0)
			{
				state.Rank = source[offset++];
			}
			return offset;
		}

		public static LiveState SampleLocal(uint elapsedMs, float progress, bool withGhostFields, string participantState, int rank)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			LiveState liveState = new LiveState
			{
				TimeMs = elapsedMs,
				Progress = (ushort)Mathf.Clamp(Mathf.RoundToInt(progress * 65535f), 0, 65535),
				State = StateCode(participantState),
				Rank = (byte)Mathf.Clamp(rank, 0, 255)
			};
			try
			{
				byte[] array = GhostStateTrack.SampleBars();
				if (array != null)
				{
					liveState.Stamina = (byte)((array.Length != 0) ? array[0] : 0);
					liveState.ExtraStamina = (byte)((array.Length > 1) ? array[1] : 0);
					for (int i = 0; i < 15 && 2 + i < array.Length; i++)
					{
						liveState.Status[i] = array[2 + i];
					}
				}
				InventorySnapshot inventorySnapshot = GhostStateTrack.SampleInventory(elapsedMs);
				if (inventorySnapshot != null)
				{
					liveState.Item = inventorySnapshot.Hand;
					liveState.Belt = (ushort[])inventorySnapshot.Belt.Clone();
					liveState.BackpackType = inventorySnapshot.BackpackType;
					liveState.BackpackSlots = inventorySnapshot.BackpackSlots;
					liveState.Pack = (ushort[])inventorySnapshot.BackpackItems.Clone();
				}
				if (withGhostFields)
				{
					Camera main = Camera.main;
					if ((Object)(object)main != (Object)null)
					{
						liveState.Position = ((Component)main).transform.position + Vector3.down * 0.8f;
					}
					float[] array2 = GhostAnimParams.SampleFromLocalCharacter();
					if (array2 != null && array2.Length >= 14)
					{
						GhostAnimParams.EncodeSampleInto(array2, liveState.Anim, 0);
					}
				}
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Live] Eigener Zustand nur teilweise lesbar: " + ex.Message);
			}
			return liveState;
		}

		public static float[] ToAnimValues(LiveState state)
		{
			return GhostAnimParams.DecodeSample(state.Anim, 0);
		}

		private static bool Same(byte[] a, byte[] b)
		{
			if (a.Length != b.Length)
			{
				return false;
			}
			for (int i = 0; i < a.Length; i++)
			{
				if (a[i] != b[i])
				{
					return false;
				}
			}
			return true;
		}

		private static bool Same(ushort[] a, ushort[] b)
		{
			if (a.Length != b.Length)
			{
				return false;
			}
			for (int i = 0; i < a.Length; i++)
			{
				if (a[i] != b[i])
				{
					return false;
				}
			}
			return true;
		}

		private static void WriteUInt32(byte[] target, ref int offset, uint value)
		{
			target[offset++] = (byte)(value & 0xFF);
			target[offset++] = (byte)((value >> 8) & 0xFF);
			target[offset++] = (byte)((value >> 16) & 0xFF);
			target[offset++] = (byte)((value >> 24) & 0xFF);
		}

		private static void WriteUInt16(byte[] target, ref int offset, ushort value)
		{
			target[offset++] = (byte)(value & 0xFF);
			target[offset++] = (byte)((value >> 8) & 0xFF);
		}

		private static void WriteFloat(byte[] target, ref int offset, float value)
		{
			byte[] bytes = BitConverter.GetBytes(value);
			if (!BitConverter.IsLittleEndian)
			{
				Array.Reverse(bytes);
			}
			Buffer.BlockCopy(bytes, 0, target, offset, 4);
			offset += 4;
		}

		private static uint ReadUInt32(byte[] source, ref int offset)
		{
			int result = source[offset] | (source[offset + 1] << 8) | (source[offset + 2] << 16) | (source[offset + 3] << 24);
			offset += 4;
			return (uint)result;
		}

		private static ushort ReadUInt16(byte[] source, ref int offset)
		{
			ushort result = (ushort)(source[offset] | (source[offset + 1] << 8));
			offset += 2;
			return result;
		}

		private static float ReadFloat(byte[] source, ref int offset)
		{
			float result;
			if (BitConverter.IsLittleEndian)
			{
				result = BitConverter.ToSingle(source, offset);
			}
			else
			{
				byte[] array = new byte[4];
				Buffer.BlockCopy(source, offset, array, 0, 4);
				Array.Reverse(array);
				result = BitConverter.ToSingle(array, 0);
			}
			offset += 4;
			return result;
		}
	}
	public class LiveGhostManager : MonoBehaviour
	{
		private class Ghost
		{
			public GhostModel Model;

			public string Name;

			public readonly List<(float At, Vector3 Position, float[] Anim)> Track = new List<(float, Vector3, float[])>();

			public uint LastTimeMs = uint.MaxValue;

			public float LastSeen;
		}

		private const float BufferSeconds = 0.4f;

		private const int MaxVisible = 4;

		private const float MaxDistance = 220f;

		private static readonly Color[] SlotColors = (Color[])(object)new Color[8]
		{
			new Color(1f, 0.45f, 0.25f),
			new Color(0.55f, 1f, 0.45f),
			new Color(1f, 0.85f, 0.3f),
			new Color(0.85f, 0.5f, 1f),
			new Color(1f, 0.55f, 0.75f),
			new Color(0.45f, 0.75f, 1f),
			new Color(0.95f, 0.95f, 0.95f),
			new Color(0.7f, 0.6f, 0.45f)
		};

		private readonly Dictionary<byte, Ghost> _ghosts = new Dictionary<byte, Ghost>();

		public static LiveGhostManager Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Update()
		{
			RaceLiveConnection instance = RaceLiveConnection.Instance;
			RaceInfo raceInfo = RaceService.Instance?.CurrentRace;
			if (!((Object)(object)instance != (Object)null) || !instance.IsConnected || !instance.GhostsVisible || raceInfo == null || (!(raceInfo.Status == "running") && !(raceInfo.Status == "countdown")) || !((Object)(object)Character.localCharacter != (Object)null))
			{
				if (_ghosts.Count > 0)
				{
					Clear("kein laufendes Rennen mit Mitstreitern");
				}
			}
			else
			{
				Collect(instance);
				Render();
			}
		}

		private void OnDestroy()
		{
			Clear("Beenden");
		}

		private void Collect(RaceLiveConnection connection)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			foreach (KeyValuePair<byte, LiveState> peer in connection.Peers)
			{
				byte key = peer.Key;
				LiveState value = peer.Value;
				if (!_ghosts.TryGetValue(key, out var value2))
				{
					value2 = new Ghost
					{
						Name = (connection.PeerNames.TryGetValue(key, out var value3) ? value3 : Loc.T("common.anonymous"))
					};
					_ghosts[key] = value2;
				}
				if (value.TimeMs != value2.LastTimeMs)
				{
					value2.LastTimeMs = value.TimeMs;
					value2.LastSeen = realtimeSinceStartup;
					value2.Track.Add((realtimeSinceStartup, value.Position, LiveFrame.ToAnimValues(value)));
					while (value2.Track.Count > 2 && realtimeSinceStartup - value2.Track[1].At > 0.8f)
					{
						value2.Track.RemoveAt(0);
					}
				}
			}
			List<byte> list = new List<byte>();
			foreach (KeyValuePair<byte, Ghost> ghost in _ghosts)
			{
				if (!connection.Peers.ContainsKey(ghost.Key) || realtimeSinceStartup - ghost.Value.LastSeen > 5f)
				{
					list.Add(ghost.Key);
				}
			}
			foreach (byte item in list)
			{
				Destroy(_ghosts[item]);
				_ghosts.Remove(item);
			}
		}

		private void Render()
		{
			//IL_0017: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: 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_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			Vector3 val = (((Object)(object)localCharacter != (Object)null) ? localCharacter.Center : Vector3.zero);
			float renderAt = Time.realtimeSinceStartup - 0.4f;
			List<KeyValuePair<byte, float>> list = new List<KeyValuePair<byte, float>>();
			foreach (KeyValuePair<byte, Ghost> ghost2 in _ghosts)
			{
				float[] anim;
				Vector3 val2 = Sample(ghost2.Value, renderAt, out anim);
				list.Add(new KeyValuePair<byte, float>(ghost2.Key, Vector3.Distance(val, val2)));
			}
			list.Sort((KeyValuePair<byte, float> a, KeyValuePair<byte, float> b) => a.Value.CompareTo(b.Value));
			for (int num = 0; num < list.Count; num++)
			{
				byte key = list[num].Key;
				Ghost ghost = _ghosts[key];
				if (num >= 4 || !(list[num].Value <= 220f) || ghost.Track.Count < 2)
				{
					if (ghost.Model != null && (Object)(object)ghost.Model.Root != (Object)null)
					{
						ghost.Model.Root.SetActive(false);
					}
					continue;
				}
				if (ghost.Model == null)
				{
					ghost.Model = GhostModelFactory.Create($"RankedPeak_LiveGhost_{key}", ColorFor(key));
					if (ghost.Model == null)
					{
						continue;
					}
					RankedLog.Info($"[LiveGhost] {ghost.Name} erscheint (Slot {key}).");
				}
				GameObject root = ghost.Model.Root;
				if ((Object)(object)root == (Object)null)
				{
					ghost.Model = null;
					continue;
				}
				if (!root.activeSelf)
				{
					root.SetActive(true);
				}
				float[] anim2;
				Vector3 val3 = Sample(ghost, renderAt, out anim2);
				root.transform.position = val3 + ghost.Model.ModelOffset;
				Vector3 val4 = Heading(ghost, renderAt);
				if (((Vector3)(ref val4)).sqrMagnitude > 0.001f)
				{
					root.transform.rotation = Quaternion.LookRotation(val4);
				}
				if ((Object)(object)ghost.Model.Animator != (Object)null && anim2 != null)
				{
					GhostAnimParams.ApplyTo(ghost.Model.Animator, anim2);
				}
				float num2 = Mathf.Clamp01(1f - list[num].Value / 220f);
				Color color = ColorFor(key);
				color.a = Mathf.Clamp(Plugin.GhostOpacity.Value, 0.05f, 1f) * Mathf.Lerp(0.35f, 1f, num2);
				GhostModelFactory.ApplyColor(ghost.Model.Material, color);
			}
		}

		private static Vector3 Sample(Ghost ghost, float renderAt, out float[] anim)
		{
			//IL_0010: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			anim = null;
			if (ghost.Track.Count == 0)
			{
				return Vector3.zero;
			}
			if (ghost.Track.Count == 1 || renderAt >= ghost.Track[ghost.Track.Count - 1].At)
			{
				(float, Vector3, float[]) tuple = ghost.Track[ghost.Track.Count - 1];
				anim = tuple.Item3;
				return tuple.Item2;
			}
			for (int i = 0; i < ghost.Track.Count - 1; i++)
			{
				(float, Vector3, float[]) tuple2 = ghost.Track[i];
				(float, Vector3, float[]) tuple3 = ghost.Track[i + 1];
				if (!(renderAt < tuple2.Item1) && !(renderAt > tuple3.Item1))
				{
					float num = tuple3.Item1 - tuple2.Item1;
					float num2 = ((num > 0.0001f) ? ((renderAt - tuple2.Item1) / num) : 0f);
					anim = GhostAnimParams.Lerp(tuple2.Item3, tuple3.Item3, num2);
					return Vector3.Lerp(tuple2.Item2, tuple3.Item2, num2);
				}
			}
			(float, Vector3, float[]) tuple4 = ghost.Track[0];
			anim = tuple4.Item3;
			return tuple4.Item2;
		}

		private static Vector3 Heading(Ghost ghost, float renderAt)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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)
			if (ghost.Track.Count < 2)
			{
				return Vector3.zero;
			}
			(float, Vector3, float[]) tuple = ghost.Track[ghost.Track.Count - 2];
			Vector3 result = ghost.Track[ghost.Track.Count - 1].Position - tuple.Item2;
			result.y = 0f;
			return result;
		}

		private static Color ColorFor(byte slot)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			return SlotColors[slot % SlotColors.Length];
		}

		private void Clear(string reason)
		{
			if (_ghosts.Count > 0)
			{
				RankedLog.Info($"[LiveGhost] {_ghosts.Count} Figur(en) abgeraeumt ({reason}).");
			}
			foreach (Ghost value in _ghosts.Values)
			{
				Destroy(value);
			}
			_ghosts.Clear();
		}

		private static void Destroy(Ghost ghost)
		{
			if (ghost?.Model != null)
			{
				if ((Object)(object)ghost.Model.Root != (Object)null)
				{
					Object.Destroy((Object)(object)ghost.Model.Root);
				}
				if ((Object)(object)ghost.Model.Material != (Object)null)
				{
					Object.Destroy((Object)(object)ghost.Model.Material);
				}
				ghost.Model = null;
			}
		}
	}
	public class RaceLiveConnection : MonoBehaviour
	{
		private struct Incoming
		{
			public string Text;

			public byte[] Binary;

			public long AtMs;
		}

		private const float SendHz = 4f;

		private const float PingSeconds = 5f;

		private static readonly float[] BackoffSeconds = new float[5] { 1f, 2f, 4f, 8f, 15f };

		private readonly Dictionary<byte, LiveState> _peers = new Dictionary<byte, LiveState>();

		private readonly Dictionary<byte, string> _peerNames = new Dictionary<byte, string>();

		private readonly Dictionary<byte, string> _peerSteamIds = new Dictionary<byte, string>();

		private readonly ConcurrentQueue<Incoming> _incoming = new ConcurrentQueue<Incoming>();

		private readonly SemaphoreSlim _sendLock = new SemaphoreSlim(1, 1);

		private ClientWebSocket _socket;

		private CancellationTokenSource _cancel;

		private string _wantedCode;

		private bool _helloSeen;

		private bool _connecting;

		private int _attempt;

		private float _retryAt;

		private float _nextSend;

		private float _nextPing;

		private LiveState _lastSent;

		private byte[] _sendBuffer = new byte[69];

		public static RaceLiveConnection Instance { get; private set; }

		public bool IsConnected
		{
			get
			{
				if (_socket != null && _socket.State == WebSocketState.Open)
				{
					return _helloSeen;
				}
				return false;
			}
		}

		public bool IsActive => _wantedCode != null;

		public bool GhostsVisible { get; private set; }

		public int MySlot { get; private set; } = -1;

		public IReadOnlyDictionary<byte, LiveState> Peers => _peers;

		public IReadOnlyDictionary<byte, string> PeerNames => _peerNames;

		public IReadOnlyDictionary<byte, string> PeerSteamIds => _peerSteamIds;

		public long LastRttMs { get; private set; } = -1L;

		public static event Action<JObject> ServerState;

		private void Awake()
		{
			Instance = this;
		}

		public void Connect(string inviteCode)
		{
			if (!string.IsNullOrEmpty(inviteCode))
			{
				string text = inviteCode.ToUpperInvariant();
				if (!(_wantedCode == text))
				{
					Disconnect("Wechsel des Races");
					_wantedCode = text;
					_attempt = 0;
					_retryAt = 0f;
					RankedLog.Info("[Live] Verbinde mit Race " + text + ".");
				}
			}
		}

		public void Disconnect(string reason)
		{
			if (_wantedCode != null || _socket != null)
			{
				if (_wantedCode != null)
				{
					RankedLog.Info("[Live] Verbindung beendet (" + reason + ").");
				}
				_wantedCode = null;
				CloseSocket();
				_peers.Clear();
				_peerNames.Clear();
				_peerSteamIds.Clear();
				MySlot = -1;
				GhostsVisible = false;
			}
		}

		public void SendState(LiveState state)
		{
			if (!IsConnected)
			{
				return;
			}
			int num = LiveFrame.DiffMask(_lastSent, state);
			if (num != 0)
			{
				int num2 = 1 + LiveFrame.MaskedBytes(num);
				if (_sendBuffer.Length < num2)
				{
					_sendBuffer = new byte[num2];
				}
				_sendBuffer[0] = 1;
				LiveFrame.Write(_sendBuffer, 1, num, state);
				byte[] array = new byte[num2];
				Buffer.BlockCopy(_sendBuffer, 0, array, 0, num2);
				SendBinary(array);
				_lastSent = state.Copy();
			}
		}

		public bool SampleDue()
		{
			if (Time.realtimeSinceStartup < _nextSend)
			{
				return false;
			}
			_nextSend = Time.realtimeSinceStartup + 0.25f;
			return true;
		}

		private void Update()
		{
			DrainIncoming();
			if (_wantedCode != null)
			{
				if (_socket == null && !_connecting && Time.realtimeSinceStartup >= _retryAt)
				{
					BeginConnect();
				}
				if (IsConnected && Time.realtimeSinceStartup >= _nextPing)
				{
					_nextPing = Time.realtimeSinceStartup + 5f;
					SendText($"{{\"t\":\"ping\",\"c\":{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}}}");
				}
			}
		}

		private void OnDestroy()
		{
			Disconnect("Beenden");
		}

		private void BeginConnect()
		{
			string text = "https://followme-peak.ddns.net";
			string text2 = (text.StartsWith("https://", StringComparison.OrdinalIgnoreCase) ? ("wss://" + text.Substring("https://".Length)) : ("ws://" + text.Substring("http://".Length)));
			string steamId = SteamIdentity.GetSteamId64();
			string text3 = ReadPlayerName();
			string text4 = text2 + "/ranked/races/" + _wantedCode + "/live?steamId=" + steamId;
			if (!string.IsNullOrEmpty(text3))
			{
				text4 = text4 + "&name=" + Uri.EscapeDataString(text3);
			}
			_connecting = true;
			_helloSeen = false;
			_lastSent = null;
			_peers.Clear();
			ClientWebSocket clientWebSocket = new ClientWebSocket();
			try
			{
				clientWebSocket.Options.SetRequestHeader("X-API-Key", "FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
			}
			catch (Exception)
			{
				text4 = text4 + "&key=" + Uri.EscapeDataString("FMP_2024_PEAK_CLIMB_AUTH_v1_7B8C9D2E");
			}
			_socket = clientWebSocket;
			_cancel = new CancellationTokenSource();
			RunReceiveLoop(text4, clientWebSocket, _cancel.Token);
		}

		private async void RunReceiveLoop(string url, ClientWebSocket socket, CancellationToken token)
		{
			byte[] buffer = new byte[8192];
			try
			{
				await socket.ConnectAsync(new Uri(url), token);
				Enqueue(new Incoming
				{
					Text = "{\"t\":\"__open\"}"
				});
				while (socket.State == WebSocketState.Open && !token.IsCancellationRequested)
				{
					List<byte[]> chunks = new List<byte[]>();
					int total = 0;
					WebSocketReceiveResult webSocketReceiveResult;
					do
					{
						webSocketReceiveResult = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), token);
						if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
						{
							break;
						}
						byte[] array = new byte[webSocketReceiveResult.Count];
						Buffer.BlockCopy(buffer, 0, array, 0, webSocketReceiveResult.Count);
						chunks.Add(array);
						total += webSocketReceiveResult.Count;
					}
					while (!webSocketReceiveResult.EndOfMessage);
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
					{
						break;
					}
					byte[] array2 = new byte[total];
					int num = 0;
					foreach (byte[] item in chunks)
					{
						Buffer.BlockCopy(item, 0, array2, num, item.Length);
						num += item.Length;
					}
					if (webSocketReceiveResult.MessageType == WebSocketMessageType.Binary)
					{
						Enqueue(new Incoming
						{
							Binary = array2
						});
					}
					else
					{
						Enqueue(new Incoming
						{
							Text = Encoding.UTF8.GetString(array2)
						});
					}
				}
				Enqueue(new Incoming
				{
					Text = "{\"t\":\"__closed\"}"
				});
			}
			catch (OperationCanceledException)
			{
			}
			catch (Exception ex2)
			{
				Enqueue(new Incoming
				{
					Text = "{\"t\":\"__error\",\"m\":\"" + ex2.Message.Replace("\"", "'") + "\"}"
				});
			}
		}

		private void Enqueue(Incoming incoming)
		{
			incoming.AtMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
			_incoming.Enqueue(incoming);
		}

		private void CloseSocket()
		{
			ClientWebSocket socket = _socket;
			CancellationTokenSource cancel = _cancel;
			_socket = null;
			_cancel = null;
			_connecting = false;
			_helloSeen = false;
			if (socket == null)
			{
				return;
			}
			Task.Run(async delegate
			{
				try
				{
					if (socket.State == WebSocketState.Open)
					{
						await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "bye", CancellationToken.None);
					}
				}
				catch (Exception)
				{
				}
				finally
				{
					cancel?.Cancel();
					socket.Dispose();
					cancel?.Dispose();
				}
			});
		}

		private void ScheduleRetry(string reason)
		{
			CloseSocket();
			if (_wantedCode != null)
			{
				float num = BackoffSeconds[Mathf.Min(_attempt, BackoffSeconds.Length - 1)];
				_attempt++;
				_retryAt = Time.realtimeSinceStartup + num;
				RankedLog.Warning($"[Live] Verbindung weg ({reason}) - neuer Versuch in {num:0.#} s. " + "Bis dahin laeuft das Rennen ueber HTTP weiter.");
			}
		}

		private void DrainIncoming()
		{
			Incoming result;
			while (_incoming.TryDequeue(out result))
			{
				if (result.Binary != null)
				{
					ApplyBundle(result.Binary);
				}
				else
				{
					ApplyText(result.Text, result.AtMs);
				}
			}
		}

		private void ApplyBundle(byte[] frame)
		{
			if (frame.Length < 2 || frame[0] != 2)
			{
				return;
			}
			byte b = frame[1];
			int num = 2;
			for (int i = 0; i < b; i++)
			{
				if (num >= frame.Length)
				{
					RankedLog.Warning("[Live] Bundle endet vor dem angekuendigten Eintrag.");
					break;
				}
				byte key = frame[num++];
				if (!_peers.TryGetValue(key, out var value))
				{
					value = new LiveState();
					_peers[key] = value;
				}
				try
				{
					num = LiveFrame.Read(frame, num, value);
				}
				catch (FormatException ex)
				{
					RankedLog.Warning("[Live] Bundle verworfen: " + ex.Message);
					break;
				}
				value.ReceivedAt = Time.realtimeSinceStartup;
			}
		}

		private void ApplyText(string text, long arrivedAtMs)
		{
			if (text.Contains("\"__open\""))
			{
				_connecting = false;
				_attempt = 0;
				_nextPing = Time.realtimeSinceStartup + 5f;
				return;
			}
			if (text.Contains("\"__closed\""))
			{
				ScheduleRetry("Gegenstelle hat geschlossen");
				return;
			}
			if (text.Contains("\"__error\""))
			{
				ScheduleRetry(text);
				return;
			}
			JObject val;
			try
			{
				val = JObject.Parse(text);
			}
			catch (Exception ex)
			{
				RankedLog.Warning("[Live] Nachricht nicht lesbar: " + ex.Message);
				return;
			}
			switch (((object)val["t"])?.ToString())
			{
			case "hello":
			{
				_helloSeen = true;
				JToken obj3 = val["slot"];
				MySlot = ((obj3 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj3) : (-1));
				JToken obj4 = val["ghostsVisible"];
				GhostsVisible = obj4 != null && Extensions.Value<bool>((IEnumerable<JToken>)obj4);
				JToken obj5 = val["slots"];
				ReadSlots((JArray)(object)((obj5 is JArray) ? obj5 : null));
				RankedLog.Info($"[Live] Verbunden mit {_wantedCode}: Slot {MySlot}, " + "Ghosts " + (GhostsVisible ? "an" : "aus") + ", " + $"{_peerNames.Count} Mitspieler.");
				RaceLiveConnection.ServerState?.Invoke(val);
				break;
			}
			case "state":
			{
				JToken obj6 = val["race"];
				bool? obj7;
				if (obj6 == null)
				{
					obj7 = null;
				}
				else
				{
					JToken obj8 = obj6[(object)"ghostsVisible"];
					obj7 = ((obj8 != null) ? new bool?(Extensions.Value<bool>((IEnumerable<JToken>)obj8)) : ((bool?)null));
				}
				GhostsVisible = obj7 ?? GhostsVisible;
				RaceLiveConnection.ServerState?.Invoke(val);
				break;
			}
			case "joined":
			{
				JToken obj2 = val["slots"];
				ReadSlots((JArray)(object)((obj2 is JArray) ? obj2 : null));
				break;
			}
			case "gone":
			{
				JToken obj9 = val["slot"];
				int num2 = ((obj9 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj9) : (-1));
				if (num2 >= 0)
				{
					_peers.Remove((byte)num2);
				}
				JToken obj10 = val["slots"];
				ReadSlots((JArray)(object)((obj10 is JArray) ? obj10 : null));
				RankedLog.Info(string.Format("[Live] Mitspieler {0} ist weg (Slot {1}).", val["id"], num2));
				break;
			}
			case "pong":
			{
				JToken obj = val["c"];
				long num = ((obj != null) ? Extensions.Value<long>((IEnumerable<JToken>)obj) : 0);
				LastRttMs = arrivedAtMs - num;
				break;
			}
			}
		}

		private void ReadSlots(JArray slots)
		{
			if (slots == null)
			{
				return;
			}
			_peerNames.Clear();
			_peerSteamIds.Clear();
			foreach (JToken slot in slots)
			{
				JToken obj = slot[(object)"slot"];
				int num = ((obj != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj) : (-1));
				if (num >= 0)
				{
					_peerNames[(byte)num] = ((object)slot[(object)"name"])?.ToString() ?? Loc.T("common.anonymous");
					_peerSteamIds[(byte)num] = ((object)slot[(object)"steamId"])?.ToString() ?? string.Empty;
				}
			}
		}

		private async void SendBinary(byte[] payload)
		{
			ClientWebSocket socket = _socket;
			if (socket == null || socket.State != WebSocketState.Open)
			{
				return;
			}
			await _sendLock.WaitAsync();
			try
			{
				await socket.SendAsync(new ArraySegment<byte>(payload), WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None);
			}
			catch (Exception)
			{
			}
			finally
			{
				_sendLock.Release();
			}
		}

		private async void SendText(string text)
		{
			ClientWebSocket socket = _socket;
			if (socket == null || socket.State != WebSocketState.Open)
			{
				return;
			}
			byte[] bytes = Encoding.UTF8.GetBytes(text);
			await _sendLock.WaitAsync();
			try
			{
				await socket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, endOfMessage: true, CancellationToken.None);
			}
			catch (Exception)
			{
			}
			finally
			{
				_sendLock.Release();
			}
		}

		private static string ReadPlayerName()
		{
			try
			{
				if (!string.IsNullOrEmpty(PhotonNetwork.NickName))
				{
					return PhotonNetwork.NickName;
				}
			}
			catch (Exception)
			{
			}
			return null;
		}
	}
}