using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Aube;
using Aube.Relays;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GarfieldKartAPMod.Helpers;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("GarfieldKartAPMod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+42c06cc2c333864bc50015f2409bd233ae3f6b48")]
[assembly: AssemblyProduct("GarfieldKartAPMod")]
[assembly: AssemblyTitle("GarfieldKartAPMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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 GarfieldKartAPMod
{
	public static class ApJsonSaveFile
	{
		private class SlotSaveData
		{
			public HashSet<string> RaceVictories = new HashSet<string>();

			public HashSet<int> CupVictories = new HashSet<int>();

			public HashSet<string> TimeTrialVictories = new HashSet<string>();

			public List<SavedActiveFiller> ActiveFiller = new List<SavedActiveFiller>();

			public List<long> CompletedFiller = new List<long>();
		}

		public class SavedActiveFiller
		{
			public long Id;

			public int RemainingRaces;

			public float TrapSecondsActive;
		}

		private static SlotSaveData cached;

		private static string cachedKey;

		public static void RecordRaceVictory(string track)
		{
			SlotSaveData slotSaveData = Load();
			if (slotSaveData != null && slotSaveData.RaceVictories.Add(track))
			{
				Save(slotSaveData);
			}
		}

		public static void RecordCupVictory(int cupId)
		{
			SlotSaveData slotSaveData = Load();
			if (slotSaveData != null && slotSaveData.CupVictories.Add(cupId))
			{
				Save(slotSaveData);
			}
		}

		public static void RecordTimeTrialVictory(string track)
		{
			SlotSaveData slotSaveData = Load();
			if (slotSaveData != null && slotSaveData.TimeTrialVictories.Add(track))
			{
				Save(slotSaveData);
			}
		}

		public static int GetRaceVictoryCount()
		{
			return Load()?.RaceVictories.Count ?? 0;
		}

		public static int GetCupVictoryCount()
		{
			return Load()?.CupVictories.Count ?? 0;
		}

		public static int GetTimeTrialVictoryCount()
		{
			return Load()?.TimeTrialVictories.Count ?? 0;
		}

		public static List<SavedActiveFiller> GetActiveFillerState()
		{
			return Load()?.ActiveFiller ?? new List<SavedActiveFiller>();
		}

		public static List<long> GetCompletedFillerState()
		{
			return Load()?.CompletedFiller ?? new List<long>();
		}

		public static void SaveFillerState(List<SavedActiveFiller> active, List<long> completed)
		{
			SlotSaveData slotSaveData = Load();
			if (slotSaveData != null)
			{
				slotSaveData.ActiveFiller = active;
				slotSaveData.CompletedFiller = completed;
				Save(slotSaveData);
			}
		}

		private static SlotSaveData Load()
		{
			string fileKey = GetFileKey();
			if (fileKey == null)
			{
				return null;
			}
			if (cached != null && cachedKey == fileKey)
			{
				return cached;
			}
			SlotSaveData slotSaveData = new SlotSaveData();
			string path = GetPath(fileKey);
			try
			{
				if (File.Exists(path))
				{
					slotSaveData = JsonConvert.DeserializeObject<SlotSaveData>(File.ReadAllText(path)) ?? new SlotSaveData();
				}
			}
			catch (Exception ex)
			{
				Log.Error("Failed to read save file " + path + ": " + ex.Message);
			}
			MergeLegacyTimeTrialFile(slotSaveData);
			cached = slotSaveData;
			cachedKey = fileKey;
			return slotSaveData;
		}

		private static void Save(SlotSaveData data)
		{
			string fileKey = GetFileKey();
			if (fileKey == null)
			{
				return;
			}
			string path = GetPath(fileKey);
			try
			{
				File.WriteAllText(path, JsonConvert.SerializeObject((object)data, (Formatting)1));
			}
			catch (Exception ex)
			{
				Log.Error("Failed to write save file " + path + ": " + ex.Message);
			}
		}

		private static void MergeLegacyTimeTrialFile(SlotSaveData data)
		{
			string seed = GetSeed();
			if (seed == null)
			{
				return;
			}
			string path = Application.persistentDataPath + "/" + seed + "_timetrials.txt";
			try
			{
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text))
					{
						data.TimeTrialVictories.Add(text.Trim());
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error("Failed to merge legacy time trial file: " + ex.Message);
			}
		}

		private static string GetSeed()
		{
			ArchipelagoSession obj = GarfieldKartAPMod.APClient?.GetSession();
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				IRoomStateHelper roomState = obj.RoomState;
				obj2 = ((roomState != null) ? roomState.Seed : null);
			}
			string text = (string)obj2;
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return null;
		}

		private static string GetFileKey()
		{
			string seed = GetSeed();
			string text = GarfieldKartAPMod.APClient?.SlotName;
			if (seed == null || string.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			return seed + "_" + SanitizeForFileName(text);
		}

		private static string GetPath(string fileKey)
		{
			return Application.persistentDataPath + "/" + fileKey + ".json";
		}

		private static string SanitizeForFileName(string name)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				name = name.Replace(oldChar, '_');
			}
			return name;
		}
	}
	public class ArchipelagoClient
	{
		private ArchipelagoSession session;

		private readonly Queue<string> pendingNotifications = new Queue<string>();

		public bool IsConnected
		{
			get
			{
				ArchipelagoSession obj = session;
				if (obj == null)
				{
					return false;
				}
				return obj.Socket.Connected;
			}
		}

		public string SlotName { get; private set; }

		public event Action OnConnected;

		public event Action<string> OnConnectionFailed;

		public event Action OnDisconnected;

		public void Connect(string hostname, int port, string slotName, string password = "")
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Expected O, but got Unknown
			try
			{
				Log.Message($"Attempting to connect to {hostname}:{port} as {slotName}");
				session = ArchipelagoSessionFactory.CreateSession(hostname, port);
				session.Socket.ErrorReceived += new ErrorReceivedHandler(OnError);
				session.Socket.SocketClosed += new SocketClosedHandler(OnSocketClosed);
				LoginResult val = session.TryConnectAndLogin("Garfield Kart - Furious Racing", slotName, (ItemsHandlingFlags)7, new Version(0, 6, 6), (string[])null, (string)null, string.IsNullOrEmpty(password) ? null : password, true);
				if (val.Successful)
				{
					LoginSuccessful val2 = (LoginSuccessful)val;
					SlotName = slotName;
					GarfieldKartAPMod.sessionSlotData = val2.SlotData;
					Log.Message($"Connected successfully! Slot: {val2.Slot}");
					foreach (KeyValuePair<string, object> slotDatum in val2.SlotData)
					{
						Log.Message($"Slot Data: {slotDatum.Key} = {slotDatum.Value}");
					}
					session.MessageLog.OnMessageReceived += new MessageReceivedHandler(OnMessageReceived);
					DeathLinkManager.OnSessionConnected(session);
					ArchipelagoItemTracker.LoadFromServer();
					this.OnConnected?.Invoke();
					ArchipelagoItemTracker.LogAllReceivedItems();
					ArchipelagoItemTracker.LogAllCheckedLocations();
				}
				else
				{
					LoginFailure val3 = (LoginFailure)val;
					string text = string.Join(", ", val3.Errors);
					Log.Error("Connection failed: " + text);
					this.OnConnectionFailed?.Invoke(text);
					session = null;
				}
			}
			catch (Exception ex)
			{
				Log.Error($"Connection exception: {ex}");
				this.OnConnectionFailed?.Invoke(ex.Message);
				session = null;
			}
		}

		public ArchipelagoSession GetSession()
		{
			return session;
		}

		public void Disconnect()
		{
			if (session != null)
			{
				session.Socket.DisconnectAsync();
				session = null;
				DeathLinkManager.OnDisconnected();
				Log.Message("Disconnected from Archipelago");
			}
		}

		private void OnMessageReceived(LogMessage message)
		{
			ConfigEntry<bool> showOnlyRelevantNotifications = GarfieldKartAPMod.showOnlyRelevantNotifications;
			if (showOnlyRelevantNotifications != null && showOnlyRelevantNotifications.Value)
			{
				ItemSendLogMessage val = (ItemSendLogMessage)(object)((message is ItemSendLogMessage) ? message : null);
				if (val == null || (!val.IsSenderTheActivePlayer && !val.IsReceiverTheActivePlayer))
				{
					return;
				}
			}
			pendingNotifications.Enqueue(FormatLogMessage(message));
		}

		private string FormatLogMessage(LogMessage message)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			MessagePart[] parts = message.Parts;
			foreach (MessagePart val in parts)
			{
				string colorHex = GetColorHex(val.Color);
				if (colorHex != null)
				{
					stringBuilder.Append("<color=#" + colorHex + ">" + val.Text + "</color>");
				}
				else
				{
					stringBuilder.Append(val.Text);
				}
			}
			return stringBuilder.ToString();
		}

		private string GetColorHex(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_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)
			//IL_0026: 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_0039: 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_004c: 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_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_0072: 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_0085: 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_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_00ab: 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_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)
			if (color == Color.Black)
			{
				return "000000";
			}
			if (color == Color.Red)
			{
				return "EE0000";
			}
			if (color == Color.Green)
			{
				return "00FF7F";
			}
			if (color == Color.Yellow)
			{
				return "FAFAD2";
			}
			if (color == Color.Blue)
			{
				return "6495ED";
			}
			if (color == Color.Magenta)
			{
				return "EE00EE";
			}
			if (color == Color.Cyan)
			{
				return "00EEEE";
			}
			if (color == Color.White)
			{
				return "FFFFFF";
			}
			if (color == Color.Plum)
			{
				return "DDA0DD";
			}
			if (color == Color.SlateBlue)
			{
				return "6A5ACD";
			}
			if (color == Color.Salmon)
			{
				return "FA8072";
			}
			return null;
		}

		private void OnError(Exception ex, string message)
		{
			Log.Error("Socket error: " + message + " - " + ex.Message);
		}

		private void OnSocketClosed(string reason)
		{
			Log.Warning("Socket closed: " + reason);
			session = null;
			DeathLinkManager.OnDisconnected();
			this.OnDisconnected?.Invoke();
		}

		public void SendLocation(long locationId)
		{
			if (IsConnected)
			{
				ArchipelagoItemTracker.AddCheckedLocation(locationId);
				session.Locations.CompleteLocationChecks(new long[1] { locationId });
				Log.Message($"Sent location check: {locationId}");
			}
		}

		public string GetSlotDataValue(string key)
		{
			if (session == null || GarfieldKartAPMod.sessionSlotData == null)
			{
				return null;
			}
			if (GarfieldKartAPMod.sessionSlotData.TryGetValue("options", out var value))
			{
				Dictionary<string, object> dictionary2;
				if (!(value is Dictionary<string, object> dictionary))
				{
					JObject val = (JObject)((value is JObject) ? value : null);
					dictionary2 = ((val == null) ? null : ((JToken)val).ToObject<Dictionary<string, object>>());
				}
				else
				{
					dictionary2 = dictionary;
				}
				Dictionary<string, object> dictionary3 = dictionary2;
				if (dictionary3 != null && dictionary3.TryGetValue(key, out var value2))
				{
					return value2.ToString();
				}
			}
			if (GarfieldKartAPMod.sessionSlotData.TryGetValue(key, out var value3))
			{
				return value3.ToString();
			}
			throw new SlotDataException("Invalid option requested from apworld: " + key + ". Did you generate on the wrong version?");
		}

		public string GetSeed()
		{
			ArchipelagoSession obj = session;
			if (obj == null)
			{
				return null;
			}
			IRoomStateHelper roomState = obj.RoomState;
			if (roomState == null)
			{
				return null;
			}
			return roomState.Seed;
		}

		public void QueueNotification(string message)
		{
			pendingNotifications.Enqueue(message);
		}

		public bool HasPendingNotifications()
		{
			return pendingNotifications.Count > 0;
		}

		public string DequeuePendingNotification()
		{
			return pendingNotifications.Dequeue();
		}
	}
	public static class ArchipelagoConstants
	{
		public const long LOC_CATZ_IN_THE_HOOD_VICTORY = 1L;

		public const long LOC_CRAZY_DUNES_VICTORY = 2L;

		public const long LOC_PALEROCK_LAKE_VICTORY = 3L;

		public const long LOC_CITY_SLICKER_VICTORY = 4L;

		public const long LOC_COUNTRY_BUMPKIN_VICTORY = 5L;

		public const long LOC_SPOOKY_MANOR_VICTORY = 6L;

		public const long LOC_MALLY_MARKET_VICTORY = 7L;

		public const long LOC_VALLEY_OF_THE_KINGS_VICTORY = 8L;

		public const long LOC_MISTY_FOR_ME_VICTORY = 9L;

		public const long LOC_SNEAK_A_PEAK_VICTORY = 10L;

		public const long LOC_BLAZING_OASIS_VICTORY = 11L;

		public const long LOC_PASTACOSI_FACTORY_VICTORY = 12L;

		public const long LOC_MYSTERIOUS_TEMPLE_VICTORY = 13L;

		public const long LOC_PROHIBITED_SITE_VICTORY = 14L;

		public const long LOC_CASKOU_PARK_VICTORY = 15L;

		public const long LOC_LOOPY_LAGOON_VICTORY = 16L;

		public const long LOC_CATZ_IN_THE_HOOD_TIME_TRIAL_BRONZE = 21L;

		public const long LOC_CRAZY_DUNES_TIME_TRIAL_BRONZE = 22L;

		public const long LOC_PALEROCK_LAKE_TIME_TRIAL_BRONZE = 23L;

		public const long LOC_CITY_SLICKER_TIME_TRIAL_BRONZE = 24L;

		public const long LOC_COUNTRY_BUMPKIN_TIME_TRIAL_BRONZE = 25L;

		public const long LOC_SPOOKY_MANOR_TIME_TRIAL_BRONZE = 26L;

		public const long LOC_MALLY_MARKET_TIME_TRIAL_BRONZE = 27L;

		public const long LOC_VALLEY_OF_THE_KINGS_TIME_TRIAL_BRONZE = 28L;

		public const long LOC_MISTY_FOR_ME_TIME_TRIAL_BRONZE = 29L;

		public const long LOC_SNEAK_A_PEAK_TIME_TRIAL_BRONZE = 30L;

		public const long LOC_BLAZING_OASIS_TIME_TRIAL_BRONZE = 31L;

		public const long LOC_PASTACOSI_FACTORY_TIME_TRIAL_BRONZE = 32L;

		public const long LOC_MYSTERIOUS_TEMPLE_TIME_TRIAL_BRONZE = 33L;

		public const long LOC_PROHIBITED_SITE_TIME_TRIAL_BRONZE = 34L;

		public const long LOC_CASKOU_PARK_TIME_TRIAL_BRONZE = 35L;

		public const long LOC_LOOPY_LAGOON_TIME_TRIAL_BRONZE = 36L;

		public const long LOC_CATZ_IN_THE_HOOD_TIME_TRIAL_SILVER = 41L;

		public const long LOC_CRAZY_DUNES_TIME_TRIAL_SILVER = 42L;

		public const long LOC_PALEROCK_LAKE_TIME_TRIAL_SILVER = 43L;

		public const long LOC_CITY_SLICKER_TIME_TRIAL_SILVER = 44L;

		public const long LOC_COUNTRY_BUMPKIN_TIME_TRIAL_SILVER = 45L;

		public const long LOC_SPOOKY_MANOR_TIME_TRIAL_SILVER = 46L;

		public const long LOC_MALLY_MARKET_TIME_TRIAL_SILVER = 47L;

		public const long LOC_VALLEY_OF_THE_KINGS_TIME_TRIAL_SILVER = 48L;

		public const long LOC_MISTY_FOR_ME_TIME_TRIAL_SILVER = 49L;

		public const long LOC_SNEAK_A_PEAK_TIME_TRIAL_SILVER = 50L;

		public const long LOC_BLAZING_OASIS_TIME_TRIAL_SILVER = 51L;

		public const long LOC_PASTACOSI_FACTORY_TIME_TRIAL_SILVER = 52L;

		public const long LOC_MYSTERIOUS_TEMPLE_TIME_TRIAL_SILVER = 53L;

		public const long LOC_PROHIBITED_SITE_TIME_TRIAL_SILVER = 54L;

		public const long LOC_CASKOU_PARK_TIME_TRIAL_SILVER = 55L;

		public const long LOC_LOOPY_LAGOON_TIME_TRIAL_SILVER = 56L;

		public const long LOC_CATZ_IN_THE_HOOD_TIME_TRIAL_GOLD = 61L;

		public const long LOC_CRAZY_DUNES_TIME_TRIAL_GOLD = 62L;

		public const long LOC_PALEROCK_LAKE_TIME_TRIAL_GOLD = 63L;

		public const long LOC_CITY_SLICKER_TIME_TRIAL_GOLD = 64L;

		public const long LOC_COUNTRY_BUMPKIN_TIME_TRIAL_GOLD = 65L;

		public const long LOC_SPOOKY_MANOR_TIME_TRIAL_GOLD = 66L;

		public const long LOC_MALLY_MARKET_TIME_TRIAL_GOLD = 67L;

		public const long LOC_VALLEY_OF_THE_KINGS_TIME_TRIAL_GOLD = 68L;

		public const long LOC_MISTY_FOR_ME_TIME_TRIAL_GOLD = 69L;

		public const long LOC_SNEAK_A_PEAK_TIME_TRIAL_GOLD = 70L;

		public const long LOC_BLAZING_OASIS_TIME_TRIAL_GOLD = 71L;

		public const long LOC_PASTACOSI_FACTORY_TIME_TRIAL_GOLD = 72L;

		public const long LOC_MYSTERIOUS_TEMPLE_TIME_TRIAL_GOLD = 73L;

		public const long LOC_PROHIBITED_SITE_TIME_TRIAL_GOLD = 74L;

		public const long LOC_CASKOU_PARK_TIME_TRIAL_GOLD = 75L;

		public const long LOC_LOOPY_LAGOON_TIME_TRIAL_GOLD = 76L;

		public const long LOC_CATZ_IN_THE_HOOD_TIME_TRIAL_PLATINUM = 81L;

		public const long LOC_CRAZY_DUNES_TIME_TRIAL_PLATINUM = 82L;

		public const long LOC_PALEROCK_LAKE_TIME_TRIAL_PLATINUM = 83L;

		public const long LOC_CITY_SLICKER_TIME_TRIAL_PLATINUM = 84L;

		public const long LOC_COUNTRY_BUMPKIN_TIME_TRIAL_PLATINUM = 85L;

		public const long LOC_SPOOKY_MANOR_TIME_TRIAL_PLATINUM = 86L;

		public const long LOC_MALLY_MARKET_TIME_TRIAL_PLATINUM = 87L;

		public const long LOC_VALLEY_OF_THE_KINGS_TIME_TRIAL_PLATINUM = 88L;

		public const long LOC_MISTY_FOR_ME_TIME_TRIAL_PLATINUM = 89L;

		public const long LOC_SNEAK_A_PEAK_TIME_TRIAL_PLATINUM = 90L;

		public const long LOC_BLAZING_OASIS_TIME_TRIAL_PLATINUM = 91L;

		public const long LOC_PASTACOSI_FACTORY_TIME_TRIAL_PLATINUM = 92L;

		public const long LOC_MYSTERIOUS_TEMPLE_TIME_TRIAL_PLATINUM = 93L;

		public const long LOC_PROHIBITED_SITE_TIME_TRIAL_PLATINUM = 94L;

		public const long LOC_CASKOU_PARK_TIME_TRIAL_PLATINUM = 95L;

		public const long LOC_LOOPY_LAGOON_TIME_TRIAL_PLATINUM = 96L;

		public const long LOC_TIME_TRIAL_MEDAL_GAP = 20L;

		public const long LOC_LASAGNA_CUP_VICTORY = 101L;

		public const long LOC_PIZZA_CUP_VICTORY = 102L;

		public const long LOC_BURGER_CUP_VICTORY = 103L;

		public const long LOC_ICE_CREAM_CUP_VICTORY = 104L;

		public const long LOC_RACE_VICTORY_CC_BASE = 700L;

		public const long LOC_RACE_VICTORY_CC_GAP = 20L;

		public const long LOC_CUP_VICTORY_CC_BASE = 760L;

		public const long LOC_CUP_VICTORY_CC_GAP = 10L;

		public const long LOC_CATZ_IN_THE_HOOD_PUZZLE_PIECE_1 = 201L;

		public const long LOC_CATZ_IN_THE_HOOD_PUZZLE_PIECE_2 = 202L;

		public const long LOC_CATZ_IN_THE_HOOD_PUZZLE_PIECE_3 = 203L;

		public const long LOC_CRAZY_DUNES_PUZZLE_PIECE_1 = 204L;

		public const long LOC_CRAZY_DUNES_PUZZLE_PIECE_2 = 205L;

		public const long LOC_CRAZY_DUNES_PUZZLE_PIECE_3 = 206L;

		public const long LOC_PALEROCK_LAKE_PUZZLE_PIECE_1 = 207L;

		public const long LOC_PALEROCK_LAKE_PUZZLE_PIECE_2 = 208L;

		public const long LOC_PALEROCK_LAKE_PUZZLE_PIECE_3 = 209L;

		public const long LOC_CITY_SLICKER_PUZZLE_PIECE_1 = 210L;

		public const long LOC_CITY_SLICKER_PUZZLE_PIECE_2 = 211L;

		public const long LOC_CITY_SLICKER_PUZZLE_PIECE_3 = 212L;

		public const long LOC_COUNTRY_BUMPKIN_PUZZLE_PIECE_1 = 213L;

		public const long LOC_COUNTRY_BUMPKIN_PUZZLE_PIECE_2 = 214L;

		public const long LOC_COUNTRY_BUMPKIN_PUZZLE_PIECE_3 = 215L;

		public const long LOC_SPOOKY_MANOR_PUZZLE_PIECE_1 = 216L;

		public const long LOC_SPOOKY_MANOR_PUZZLE_PIECE_2 = 217L;

		public const long LOC_SPOOKY_MANOR_PUZZLE_PIECE_3 = 218L;

		public const long LOC_MALLY_MARKET_PUZZLE_PIECE_1 = 219L;

		public const long LOC_MALLY_MARKET_PUZZLE_PIECE_2 = 220L;

		public const long LOC_MALLY_MARKET_PUZZLE_PIECE_3 = 221L;

		public const long LOC_VALLEY_OF_THE_KINGS_PUZZLE_PIECE_1 = 222L;

		public const long LOC_VALLEY_OF_THE_KINGS_PUZZLE_PIECE_2 = 223L;

		public const long LOC_VALLEY_OF_THE_KINGS_PUZZLE_PIECE_3 = 224L;

		public const long LOC_MISTY_FOR_ME_PUZZLE_PIECE_1 = 225L;

		public const long LOC_MISTY_FOR_ME_PUZZLE_PIECE_2 = 226L;

		public const long LOC_MISTY_FOR_ME_PUZZLE_PIECE_3 = 227L;

		public const long LOC_SNEAK_A_PEAK_PUZZLE_PIECE_1 = 228L;

		public const long LOC_SNEAK_A_PEAK_PUZZLE_PIECE_2 = 229L;

		public const long LOC_SNEAK_A_PEAK_PUZZLE_PIECE_3 = 230L;

		public const long LOC_BLAZING_OASIS_PUZZLE_PIECE_1 = 231L;

		public const long LOC_BLAZING_OASIS_PUZZLE_PIECE_2 = 232L;

		public const long LOC_BLAZING_OASIS_PUZZLE_PIECE_3 = 233L;

		public const long LOC_PASTACOSI_FACTORY_PUZZLE_PIECE_1 = 234L;

		public const long LOC_PASTACOSI_FACTORY_PUZZLE_PIECE_2 = 235L;

		public const long LOC_PASTACOSI_FACTORY_PUZZLE_PIECE_3 = 236L;

		public const long LOC_MYSTERIOUS_TEMPLE_PUZZLE_PIECE_1 = 237L;

		public const long LOC_MYSTERIOUS_TEMPLE_PUZZLE_PIECE_2 = 238L;

		public const long LOC_MYSTERIOUS_TEMPLE_PUZZLE_PIECE_3 = 239L;

		public const long LOC_PROHIBITED_SITE_PUZZLE_PIECE_1 = 240L;

		public const long LOC_PROHIBITED_SITE_PUZZLE_PIECE_2 = 241L;

		public const long LOC_PROHIBITED_SITE_PUZZLE_PIECE_3 = 242L;

		public const long LOC_CASKOU_PARK_PUZZLE_PIECE_1 = 243L;

		public const long LOC_CASKOU_PARK_PUZZLE_PIECE_2 = 244L;

		public const long LOC_CASKOU_PARK_PUZZLE_PIECE_3 = 245L;

		public const long LOC_LOOPY_LAGOON_PUZZLE_PIECE_1 = 246L;

		public const long LOC_LOOPY_LAGOON_PUZZLE_PIECE_2 = 247L;

		public const long LOC_LOOPY_LAGOON_PUZZLE_PIECE_3 = 248L;

		public const long LOC_CATZ_IN_THE_HOOD_LAP_SANITY = 500L;

		public const long LOC_CRAZY_DUNES_LAP_SANITY = 510L;

		public const long LOC_PALEROCK_LAKE_LAP_SANITY = 520L;

		public const long LOC_CITY_SLICKER_LAP_SANITY = 530L;

		public const long LOC_COUNTRY_BUMPKIN_LAP_SANITY = 540L;

		public const long LOC_SPOOKY_MANOR_LAP_SANITY = 550L;

		public const long LOC_MALLY_MARKET_LAP_SANITY = 560L;

		public const long LOC_VALLEY_OF_THE_KINGS_LAP_SANITY = 570L;

		public const long LOC_MISTY_FOR_ME_LAP_SANITY = 580L;

		public const long LOC_SNEAK_A_PEAK_LAP_SANITY = 590L;

		public const long LOC_BLAZING_OASIS_LAP_SANITY = 600L;

		public const long LOC_PASTACOSI_FACTORY_LAP_SANITY = 610L;

		public const long LOC_MYSTERIOUS_TEMPLE_LAP_SANITY = 620L;

		public const long LOC_PROHIBITED_SITE_LAP_SANITY = 630L;

		public const long LOC_CASKOU_PARK_LAP_SANITY = 640L;

		public const long LOC_LOOPY_LAGOON_LAP_SANITY = 650L;

		public const long LOC_LASAGNA_CUP_UNLOCK_SPOILER_1 = 301L;

		public const long LOC_PIZZA_CUP_UNLOCK_SPOILER_1 = 302L;

		public const long LOC_BURGER_CUP_UNLOCK_SPOILER_1 = 303L;

		public const long LOC_ICE_CREAM_CUP_UNLOCK_SPOILER_1 = 304L;

		public const long LOC_LASAGNA_CUP_UNLOCK_SPOILER_2 = 311L;

		public const long LOC_PIZZA_CUP_UNLOCK_SPOILER_2 = 312L;

		public const long LOC_BURGER_CUP_UNLOCK_SPOILER_2 = 313L;

		public const long LOC_ICE_CREAM_CUP_UNLOCK_SPOILER_2 = 314L;

		public const long LOC_CATZ_IN_THE_HOOD_HAT_UNLOCK = 401L;

		public const long LOC_CRAZY_DUNES_HAT_UNLOCK = 402L;

		public const long LOC_PALEROCK_LAKE_HAT_UNLOCK = 403L;

		public const long LOC_CITY_SLICKER_HAT_UNLOCK = 404L;

		public const long LOC_COUNTRY_BUMPKIN_HAT_UNLOCK = 405L;

		public const long LOC_SPOOKY_MANOR_HAT_UNLOCK = 406L;

		public const long LOC_MALLY_MARKET_HAT_UNLOCK = 407L;

		public const long LOC_VALLEY_OF_THE_KINGS_HAT_UNLOCK = 408L;

		public const long LOC_MISTY_FOR_ME_HAT_UNLOCK = 409L;

		public const long LOC_SNEAK_A_PEAK_HAT_UNLOCK = 410L;

		public const long LOC_BLAZING_OASIS_HAT_UNLOCK = 411L;

		public const long LOC_PASTACOSI_FACTORY_HAT_UNLOCK = 412L;

		public const long LOC_MYSTERIOUS_TEMPLE_HAT_UNLOCK = 413L;

		public const long LOC_PROHIBITED_SITE_HAT_UNLOCK = 414L;

		public const long LOC_CASKOU_PARK_HAT_UNLOCK = 415L;

		public const long LOC_LOOPY_LAGOON_HAT_UNLOCK = 416L;

		public const long LOC_WIN_RACE_AS_GARFIELD = 1001L;

		public const long LOC_WIN_RACE_AS_JON = 1002L;

		public const long LOC_WIN_RACE_AS_LIZ = 1003L;

		public const long LOC_WIN_RACE_AS_ODIE = 1004L;

		public const long LOC_WIN_RACE_AS_ARLENE = 1005L;

		public const long LOC_WIN_RACE_AS_NERMAL = 1006L;

		public const long LOC_WIN_RACE_AS_SQUEAK = 1007L;

		public const long LOC_WIN_RACE_AS_HARRY = 1008L;

		public const long LOC_WIN_RACE_WITH_FORMULA_ZZZZ = 1051L;

		public const long LOC_WIN_RACE_WITH_ABSTRACT_KART = 1052L;

		public const long LOC_WIN_RACE_WITH_MEDI_KART = 1053L;

		public const long LOC_WIN_RACE_WITH_WOOF_MOBILE = 1054L;

		public const long LOC_WIN_RACE_WITH_KISSY_KART = 1055L;

		public const long LOC_WIN_RACE_WITH_CUTIE_PIE_CAT = 1056L;

		public const long LOC_WIN_RACE_WITH_RAT_RACER = 1057L;

		public const long LOC_WIN_RACE_WITH_MUCK_MADNESS = 1058L;

		public const long LOC_FIND_ITEM_PIE = 1101L;

		public const long LOC_FIND_ITEM_HOMING_PIE = 1102L;

		public const long LOC_FIND_ITEM_DIAMOND = 1103L;

		public const long LOC_FIND_ITEM_MAGIC_WAND = 1104L;

		public const long LOC_FIND_ITEM_PERFUME = 1105L;

		public const long LOC_FIND_ITEM_LASAGNA = 1106L;

		public const long LOC_FIND_ITEM_UFO = 1107L;

		public const long LOC_FIND_ITEM_PILLOW = 1108L;

		public const long LOC_FIND_ITEM_SPRING = 1109L;

		public const long ITEM_PUZZLE_PIECE = 49L;

		public const long ITEM_PROGRESSIVE_COURSE_UNLOCK = 100L;

		public const long ITEM_COURSE_UNLOCK_CATZ_IN_THE_HOOD = 101L;

		public const long ITEM_COURSE_UNLOCK_CRAZY_DUNES = 102L;

		public const long ITEM_COURSE_UNLOCK_PALEROCK_LAKE = 103L;

		public const long ITEM_COURSE_UNLOCK_CITY_SLICKER = 104L;

		public const long ITEM_COURSE_UNLOCK_COUNTRY_BUMPKIN = 105L;

		public const long ITEM_COURSE_UNLOCK_SPOOKY_MANOR = 106L;

		public const long ITEM_COURSE_UNLOCK_MALLY_MARKET = 107L;

		public const long ITEM_COURSE_UNLOCK_VALLEY_OF_THE_KINGS = 108L;

		public const long ITEM_COURSE_UNLOCK_MISTY_FOR_ME = 109L;

		public const long ITEM_COURSE_UNLOCK_SNEAK_A_PEAK = 110L;

		public const long ITEM_COURSE_UNLOCK_BLAZING_OASIS = 111L;

		public const long ITEM_COURSE_UNLOCK_PASTACOSI_FACTORY = 112L;

		public const long ITEM_COURSE_UNLOCK_MYSTERIOUS_TEMPLE = 113L;

		public const long ITEM_COURSE_UNLOCK_PROHIBITED_SITE = 114L;

		public const long ITEM_COURSE_UNLOCK_CASKOU_PARK = 115L;

		public const long ITEM_COURSE_UNLOCK_LOOPY_LAGOON = 116L;

		public const long ITEM_PROGRESSIVE_CUP_UNLOCK = 200L;

		public const long ITEM_CUP_UNLOCK_LASAGNA = 201L;

		public const long ITEM_CUP_UNLOCK_PIZZA = 202L;

		public const long ITEM_CUP_UNLOCK_BURGER = 203L;

		public const long ITEM_CUP_UNLOCK_ICE_CREAM = 204L;

		public const long ITEM_CHARACTER_GARFIELD = 301L;

		public const long ITEM_CHARACTER_JON = 302L;

		public const long ITEM_CHARACTER_LIZ = 303L;

		public const long ITEM_CHARACTER_ODIE = 304L;

		public const long ITEM_CHARACTER_ARLENE = 305L;

		public const long ITEM_CHARACTER_NERMAL = 306L;

		public const long ITEM_CHARACTER_SQUEAK = 307L;

		public const long ITEM_CHARACTER_HARRY = 308L;

		public const long ITEM_KART_FORMULA_ZZZZ = 351L;

		public const long ITEM_KART_ABSTRACT_KART = 352L;

		public const long ITEM_KART_MEDI_KART = 353L;

		public const long ITEM_KART_WOOF_MOBILE = 354L;

		public const long ITEM_KART_KISSY_KART = 355L;

		public const long ITEM_KART_CUTIE_PIE_CAT = 356L;

		public const long ITEM_KART_RAT_RACER = 357L;

		public const long ITEM_KART_MUCK_MADNESS = 358L;

		public const long ITEM_UNLOCK_BEDDY_BYE_CAP = 421L;

		public const long ITEM_UNLOCK_WHIZZY_WIZARD = 422L;

		public const long ITEM_UNLOCK_TIC_TOQUE = 423L;

		public const long ITEM_UNLOCK_ELASTO_HAT = 424L;

		public const long ITEM_UNLOCK_CHEFS_SPECIAL = 425L;

		public const long ITEM_UNLOCK_CUTIE_PIE_CROWN = 426L;

		public const long ITEM_UNLOCK_VIKING_HELMET = 427L;

		public const long ITEM_UNLOCK_STINK_O_RAMA = 428L;

		public const long ITEM_UNLOCK_SPACE_BUBBLE = 429L;

		public const long ITEM_UNLOCK_PIZZAIOLO_HAT = 430L;

		public const long ITEM_UNLOCK_BUNNY_BAND = 431L;

		public const long ITEM_UNLOCK_JOE_MONTAGNA = 432L;

		public const long ITEM_UNLOCK_ARISTO_CATIC_BICORN = 433L;

		public const long ITEM_UNLOCK_TOUTANKHAMEOW = 434L;

		public const long ITEM_UNLOCK_APPRENTICE_SORCERER = 435L;

		public const long ITEM_UNLOCK_MULE_HEAD = 436L;

		public const long ITEM_UNLOCK_BOMBASTIC_SPOILER = 521L;

		public const long ITEM_UNLOCK_WHACKY_SPOILER = 522L;

		public const long ITEM_UNLOCK_SUPERFIT_SPOILER = 523L;

		public const long ITEM_UNLOCK_CYCLOBONE_SPOILER = 524L;

		public const long ITEM_UNLOCK_FOXY_SPOILER = 525L;

		public const long ITEM_UNLOCK_SHIMMERING_SPOILER = 526L;

		public const long ITEM_UNLOCK_HOLEY_MOLEY_SPOILER = 527L;

		public const long ITEM_UNLOCK_STAINED_SPOILER = 528L;

		public const long ITEM_PIE = 901L;

		public const long ITEM_HOMING_PIE = 902L;

		public const long ITEM_DIAMOND = 903L;

		public const long ITEM_MAGIC_WAND = 904L;

		public const long ITEM_PERFUME = 905L;

		public const long ITEM_LASAGNA = 906L;

		public const long ITEM_UFO = 907L;

		public const long ITEM_PILLOW = 908L;

		public const long ITEM_SPRING = 909L;

		public const long ITEM_RANDOM_ITEM_BOX_FILLER = 1000L;

		public const long ITEM_START_BOOST_HELPER_FILLER = 1001L;

		public const long ITEM_STRONGER_ITEM_BOXES_FILLER = 1002L;

		public const long ITEM_QUOTE_FILLER = 1003L;

		public const long ITEM_MIRROR_TRAP = 1500L;

		public const long ITEM_SLEEP_TRAP = 1501L;

		public const long ITEM_GRAYSCALE_TRAP = 1502L;

		public const long ITEM_BROKEN_DRIFT_TRAP = 1503L;

		public const long ITEM_BOUNCE_TRAP = 1504L;

		public const long GOAL_GRAND_PRIX = 0L;

		public const long GOAL_RACES = 1L;

		public const long GOAL_TIME_TRIALS = 2L;

		public const long GOAL_PUZZLE_PIECE = 3L;

		public const long OPTION_RANDOMIZE_RACES_CUPS = 0L;

		public const long OPTION_RANDOMIZE_RACES_RACES = 1L;

		public const long OPTION_RANDOMIZE_RACES_BOTH = 2L;

		public const long OPTION_TRAP_HANDLING_TIME = 0L;

		public const long OPTION_TRAP_HANDLING_RACE = 1L;

		public const long OPTION_TRAP_HANDLING_WIN = 2L;

		public const float TRAP_DISABLE_SECONDS = 60f;

		public static readonly string[] GARFIELD_QUOTES = new string[42]
		{
			"Love me, feed me, never leave me.", "I am hungry. Therefore I am.", "Oh no! I overslept! I’m late! For my nap.", "Eat every meal as though it were your last.", "The most active thing about me is my imagination.", "A little ego goes nowhere.", "I’ll rise, but I won’t shine.", "Once again I’m saved by the miracle of… lasagna!", "So much time, and so little... I need to do.", "I just need a little quality time with man's real best friend, television.",
			"Sure, Jon. I'll eat all your lasagna for you.", "I'll purr like a Ferrari. Make that a Jaguar.", "A smart cat knows just how far to go without crossing over the line", "Big fat hairy deal.", "I hate Mondays.", "We're bachelors, baby.", "Feed me.", "Eat your heart out.", "I'm not overweight. I'm undertall.", "I'm not known for my compassion.",
			"I love lasagna.", "Diet is 'die' but with a t.", "Christmas: It's not the giving. It's not the getting. It's the loving.", "It's not that I dislike you, I just don't like you near me.", "Show me a good mouser and I'll show you a cat with bad breath.", "Momma? Umm... I don't know, Penelope...", "Be still my beating heart.", "When I want in, I want in now!", "I hate birthdays.", "Love me, feed me, never leave me.",
			"Good morning? GOOD MORNING?! Jon, it's Monday! Monday is the armpit of the week! It's like a black hole in the calendar that just sucks all the joy out of your entire being!", "I know where you live!", "Hello, little hot dogs... wow...", "Whup! Um... did you hear something?", "Would you pass the ketchup?", "This game is K-rated. No adults unless accompanied by a kid.", "Hey, what do you know? I guess every cloud DOES have a silver lining.", "Hey Heathcliff, eat your heart out!", "The Real World! That's the change I need!", "You folks have this confused. I'M real, and YOU'RE animated.",
			"SEE YOU IN THE FUNNY PAPERS, ODIE!", "Hi, there. I'm Garfield. I'm a cat, and this is my cartoonist, Jon."
		};

		public static string GetSceneNameFromTrackId(TrackId trackId)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected I4, but got Unknown
			return (int)trackId switch
			{
				4 => "E2C1", 
				12 => "E4C1", 
				8 => "E3C1", 
				0 => "E1C1", 
				9 => "E3C2", 
				5 => "E2C2", 
				1 => "E1C2", 
				13 => "E4C2", 
				2 => "E1C3", 
				10 => "E3C3", 
				14 => "E4C3", 
				6 => "E2C3", 
				15 => "E4C4", 
				3 => "E1C4", 
				7 => "E2C4", 
				11 => "E3C4", 
				_ => null, 
			};
		}

		public static long GetRaceVictoryLoc(string startScene)
		{
			return startScene switch
			{
				"E2C1" => 1L, 
				"E4C1" => 2L, 
				"E3C1" => 3L, 
				"E1C1" => 4L, 
				"E3C2" => 5L, 
				"E2C2" => 6L, 
				"E1C2" => 7L, 
				"E4C2" => 8L, 
				"E1C3" => 9L, 
				"E3C3" => 10L, 
				"E4C3" => 11L, 
				"E2C3" => 12L, 
				"E4C4" => 13L, 
				"E1C4" => 14L, 
				"E2C4" => 15L, 
				"E3C4" => 16L, 
				_ => -1L, 
			};
		}

		public static List<long> GetRaceVictoryCCLocs(string startScene, Difficulty difficulty)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between I4 and Unknown
			List<long> list = new List<long>();
			long raceVictoryLoc = GetRaceVictoryLoc(startScene);
			if (raceVictoryLoc == -1)
			{
				return list;
			}
			for (int i = 0; i <= (int)difficulty; i++)
			{
				list.Add(700 + (long)i * 20L + raceVictoryLoc);
			}
			return list;
		}

		public static long GetCupVictoryLoc(int cupId)
		{
			if (cupId < 0 || cupId > 3)
			{
				return -1L;
			}
			return 101L + (long)cupId;
		}

		public static List<long> GetCupVictoryCCLocs(int cupId, Difficulty difficulty)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between I4 and Unknown
			List<long> list = new List<long>();
			if (cupId < 0 || cupId > 3)
			{
				return list;
			}
			for (int i = 0; i <= (int)difficulty; i++)
			{
				list.Add(760 + (long)i * 10L + (cupId + 1));
			}
			return list;
		}

		public static long GetPuzzlePieceLoc(string startScene, int puzzleIndex)
		{
			return startScene switch
			{
				"E2C1" => 201L + (long)puzzleIndex, 
				"E4C1" => 204L + (long)puzzleIndex, 
				"E3C1" => 207L + (long)puzzleIndex, 
				"E1C1" => 210L + (long)puzzleIndex, 
				"E3C2" => 213L + (long)puzzleIndex, 
				"E2C2" => 216L + (long)puzzleIndex, 
				"E1C2" => 219L + (long)puzzleIndex, 
				"E4C2" => 222L + (long)puzzleIndex, 
				"E1C3" => 225L + (long)puzzleIndex, 
				"E3C3" => 228L + (long)puzzleIndex, 
				"E4C3" => 231L + (long)puzzleIndex, 
				"E2C3" => 234L + (long)puzzleIndex, 
				"E4C4" => 237L + (long)puzzleIndex, 
				"E1C4" => 240L + (long)puzzleIndex, 
				"E2C4" => 243L + (long)puzzleIndex, 
				"E3C4" => 246L + (long)puzzleIndex, 
				_ => -1L, 
			};
		}

		public static long GetLapSanityLoc(string startScene, int lapIndex)
		{
			long num = startScene switch
			{
				"E2C1" => 500L, 
				"E4C1" => 510L, 
				"E3C1" => 520L, 
				"E1C1" => 530L, 
				"E3C2" => 540L, 
				"E2C2" => 550L, 
				"E1C2" => 560L, 
				"E4C2" => 570L, 
				"E1C3" => 580L, 
				"E3C3" => 590L, 
				"E4C3" => 600L, 
				"E2C3" => 610L, 
				"E4C4" => 620L, 
				"E1C4" => 630L, 
				"E2C4" => 640L, 
				"E3C4" => 650L, 
				_ => -1L, 
			};
			if (num == -1)
			{
				return -1L;
			}
			return num + lapIndex;
		}

		public static long GetTimeTrialLoc(string startScene, E_TimeTrialMedal medal)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			int num = (int)medal;
			if (num < 1 || num > 4)
			{
				return -1L;
			}
			long raceVictoryLoc = GetRaceVictoryLoc(startScene);
			if (raceVictoryLoc == -1)
			{
				return -1L;
			}
			return 20L * (long)num + raceVictoryLoc;
		}

		public static List<long> GetTimeTrialLocs(string startScene, E_TimeTrialMedal medal)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between I4 and Unknown
			List<long> list = new List<long>();
			for (int i = 1; i <= (int)medal; i++)
			{
				long timeTrialLoc = GetTimeTrialLoc(startScene, (E_TimeTrialMedal)i);
				if (timeTrialLoc != -1)
				{
					list.Add(timeTrialLoc);
				}
			}
			return list;
		}

		public static long GetHatLoc(string startScene)
		{
			long raceVictoryLoc = GetRaceVictoryLoc(startScene);
			if (raceVictoryLoc == -1)
			{
				return -1L;
			}
			return 400 + raceVictoryLoc;
		}

		public static long GetHatItemId(string hat)
		{
			switch (hat)
			{
			case "EgyptPriestHatN":
			case "EgyptPriestHatR":
			case "EgyptPriestHatU":
				return 423L;
			case "SleepingHatN":
			case "SleepingHatR":
			case "SleepingHatU":
				return 421L;
			case "PharaonHatN":
			case "PharaonHatR":
			case "PharaonHatU":
				return 434L;
			case "BeautyHatN":
			case "BeautyHatR":
			case "BeautyHatU":
				return 433L;
			case "PiratHatN":
			case "PiratHatR":
			case "PiratHatU":
				return 428L;
			case "FootballHelmetN":
			case "FootballHelmetR":
			case "FootballHelmetU":
				return 432L;
			case "ChickenHatN":
			case "ChickenHatR":
			case "ChickenHatU":
				return 424L;
			case "SpaceHelmetN":
			case "SpaceHelmetR":
			case "SpaceHelmetU":
				return 429L;
			case "CrownHatN":
			case "CrownHatR":
			case "CrownHatU":
				return 426L;
			case "PizzaioloHatN":
			case "PizzaioloHatR":
			case "PizzaioloHatU":
				return 430L;
			case "VikingHelmetN":
			case "VikingHelmetR":
			case "VikingHelmetU":
				return 427L;
			case "MagicHatN":
			case "MagicHatR":
			case "MagicHatU":
				return 422L;
			case "WizardHatN":
			case "WizardHatR":
			case "WizardHatU":
				return 435L;
			case "DunkeyHatN":
			case "DunkeyHatR":
			case "DunkeyHatU":
				return 436L;
			case "PastryHatN":
			case "PastryHatR":
			case "PastryHatU":
				return 425L;
			case "RabbitHatN":
			case "RabbitHatR":
			case "RabbitHatU":
				return 431L;
			default:
				return -1L;
			}
		}

		public static List<long> GetSpoilerLocs(int cupId)
		{
			List<long> list = new List<long>();
			if (cupId < 0 || cupId > 3)
			{
				return list;
			}
			list.Add(301L + (long)cupId);
			list.Add(311L + (long)cupId);
			return list;
		}

		public static long GetSpoilerItemId(string custom)
		{
			switch (custom)
			{
			case "KGC_ManiabilityN":
			case "KGC_ManiabilityR":
			case "KGC_ManiabilityU":
				return 521L;
			case "KJC_SpeedN":
			case "KJC_SpeedR":
			case "KJC_SpeedU":
				return 522L;
			case "KLC_AccelerationN":
			case "KLC_AccelerationR":
			case "KLC_AccelerationU":
				return 523L;
			case "KOC_AccelerationN":
			case "KOC_AccelerationR":
			case "KOC_AccelerationU":
				return 524L;
			case "KAC_AccelerationN":
			case "KAC_AccelerationR":
			case "KAC_AccelerationU":
				return 525L;
			case "KNC_AccelerationN":
			case "KNC_AccelerationR":
			case "KNC_AccelerationU":
				return 526L;
			case "KSC_ManiabilityN":
			case "KSC_ManiabilityR":
			case "KSC_ManiabilityU":
				return 527L;
			case "KHC_SpeedN":
			case "KHC_SpeedR":
			case "KHC_SpeedU":
				return 528L;
			default:
				return -1L;
			}
		}
	}
	public class ArchipelagoItemTracker
	{
		private static readonly ConcurrentDictionary<long, int> receivedItems = new ConcurrentDictionary<long, int>();

		private static readonly ConcurrentDictionary<long, byte> checkedLocations = new ConcurrentDictionary<long, byte>();

		private static int liveItemCursor;

		public static void Initialize()
		{
			Log.Message("Initializing Archipelago Item Tracker");
		}

		public static void AddReceivedItem(long itemId)
		{
			receivedItems.AddOrUpdate(itemId, 1, (long _, int existing) => existing + 1);
			ArchipelagoFillerManager.TryReceiveFiller(itemId);
		}

		public static void ProcessLiveReceivedItems()
		{
			ArchipelagoClient aPClient = GarfieldKartAPMod.APClient;
			object obj;
			if (aPClient == null)
			{
				obj = null;
			}
			else
			{
				ArchipelagoSession session = aPClient.GetSession();
				if (session == null)
				{
					obj = null;
				}
				else
				{
					IReceivedItemsHelper items = session.Items;
					obj = ((items != null) ? items.AllItemsReceived : null);
				}
			}
			ReadOnlyCollection<ItemInfo> readOnlyCollection = (ReadOnlyCollection<ItemInfo>)obj;
			if (readOnlyCollection != null)
			{
				while (liveItemCursor < readOnlyCollection.Count)
				{
					long itemId = readOnlyCollection[liveItemCursor].ItemId;
					AddReceivedItem(itemId);
					ArchipelagoTrapEffects.OnMidRaceReceive(itemId);
					liveItemCursor++;
				}
			}
		}

		public static bool HasItem(long itemId)
		{
			return receivedItems.ContainsKey(itemId);
		}

		public static int AmountOfItem(long itemId)
		{
			return receivedItems.GetValueOrDefault(itemId, 0);
		}

		public static void AddCheckedLocation(long locationId)
		{
			checkedLocations.TryAdd(locationId, 0);
		}

		public static bool HasLocation(long locationId)
		{
			return checkedLocations.ContainsKey(locationId);
		}

		public static int GetCheckedLocationCount()
		{
			return checkedLocations.Count;
		}

		public static void Clear()
		{
			receivedItems.Clear();
			checkedLocations.Clear();
			Log.Message("[AP] Cleared all received items and checked locations");
		}

		public static void LoadFromServer()
		{
			try
			{
				ArchipelagoSession session = GarfieldKartAPMod.APClient.GetSession();
				if (session == null)
				{
					return;
				}
				Clear();
				List<ItemInfo> list = session.Items.AllItemsReceived?.ToList();
				if (list != null)
				{
					Log.Message($"[AP] Loading {list.Count} items from server");
					foreach (ItemInfo item in list)
					{
						Log.Message($"[AP] Item: {item.ItemName} (ID: {item.ItemId})");
						receivedItems.AddOrUpdate(item.ItemId, 1, (long _, int existing) => existing + 1);
					}
					ArchipelagoFillerManager.LoadFillerFromReceivedItems(list);
				}
				IReceivedItemsHelper items = session.Items;
				liveItemCursor = ((items != null) ? items.Index : liveItemCursor);
				List<long> list2 = session.Locations.AllLocationsChecked?.ToList();
				if (list2 == null)
				{
					return;
				}
				Log.Message($"[AP] Loading {list2.Count} checked locations from server");
				foreach (long item2 in list2)
				{
					Log.Message($"[AP] Location checked: {item2}");
					checkedLocations.TryAdd(item2, 0);
				}
			}
			catch (Exception arg)
			{
				Log.Error($"[AP] LoadFromServer exception: {arg}");
			}
		}

		public static void ResyncFromServer()
		{
			Log.Message("[AP] Resyncing Archipelago state from server");
			LoadFromServer();
		}

		public static List<long> GetAvailableCups()
		{
			List<long> list = new List<long>();
			for (int i = 0; i < 4; i++)
			{
				if (CanAccessCup(i))
				{
					list.Add(i);
				}
			}
			return list;
		}

		public static bool HasRace(int raceId)
		{
			int cupId = raceId / 4;
			bool flag = ArchipelagoHelper.IsRacesRandomized();
			bool flag2 = ArchipelagoHelper.IsCupsRandomized();
			if (!flag && !flag2)
			{
				return true;
			}
			if (flag2 && !flag)
			{
				return HasCup(cupId);
			}
			return HasItem(101L + (long)raceId);
		}

		public static bool HasCup(int cupId)
		{
			bool flag = ArchipelagoHelper.IsCupsRandomized();
			if (ArchipelagoHelper.IsRacesRandomized() && !flag)
			{
				return HasAllRacesInCup(cupId);
			}
			if (flag)
			{
				if (ArchipelagoHelper.IsProgressiveCupsEnabled())
				{
					return AmountOfItem(200L) >= cupId;
				}
				return HasItem(201L + (long)cupId);
			}
			return true;
		}

		public static bool CanAccessCup(int cupId)
		{
			if (!HasCup(cupId))
			{
				return false;
			}
			return HasAllRacesInCup(cupId);
		}

		public static bool HasRaceInCup(int cupId)
		{
			int num = cupId * 4;
			for (int i = 0; i < 4; i++)
			{
				if (HasRace(num + i))
				{
					return true;
				}
			}
			return false;
		}

		public static bool HasAllRacesInCup(int cupId)
		{
			int num = cupId * 4;
			for (int i = 0; i < 4; i++)
			{
				if (!HasRace(num + i))
				{
					return false;
				}
			}
			return true;
		}

		public static int GetPuzzlePieceCount(string startScene)
		{
			long puzzlePieceLoc = ArchipelagoConstants.GetPuzzlePieceLoc(startScene, 0);
			if (puzzlePieceLoc == -1)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < 3; i++)
			{
				if (HasLocation(puzzlePieceLoc + i))
				{
					num++;
				}
			}
			return num;
		}

		public static int GetOverallPuzzlePieceCount()
		{
			return AmountOfItem(49L);
		}

		public static bool HasBonusAvailable(BonusCategory bonus)
		{
			//IL_0009: 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_0035: Expected I4, but got Unknown
			if (!ArchipelagoHelper.IsItemRandomizerEnabled())
			{
				return true;
			}
			return (bonus - 1) switch
			{
				0 => HasItem(901L), 
				1 => HasItem(902L), 
				3 => HasItem(906L), 
				2 => HasItem(909L), 
				4 => HasItem(903L), 
				5 => HasItem(907L), 
				6 => HasItem(908L), 
				7 => HasItem(905L), 
				8 => HasItem(904L), 
				_ => true, 
			};
		}

		public static void LogAllReceivedItems()
		{
			int num = receivedItems.Sum((KeyValuePair<long, int> kv) => kv.Value);
			Log.Message($"[AP Debug] === All Received Items ({num} total entries) ===");
			foreach (KeyValuePair<long, int> item in receivedItems.OrderBy((KeyValuePair<long, int> kv) => kv.Key))
			{
				Log.Message($"[AP Debug] Item ID: {item.Key} Count: {item.Value}");
			}
		}

		public static void LogAllCheckedLocations()
		{
			Log.Message($"[AP Debug] === All Checked Locations ({checkedLocations.Count} total) ===");
			foreach (long item in checkedLocations.Keys.OrderBy((long x) => x))
			{
				Log.Message($"[AP Debug] Location ID: {item}");
			}
		}
	}
	public class ConnectionUI : MonoBehaviour
	{
		private bool showUI = true;

		private bool m_paused;

		private string hostname = "archipelago.gg";

		private string slotName = "";

		private string port = "38281";

		private string password = "";

		private string statusMessage = "";

		private Rect windowRect = new Rect((float)(Screen.width / 2 - 300), (float)(Screen.height / 2 - 250), 800f, 700f);

		private ArchipelagoClient apClient;

		private bool originalCursorVisible;

		private CursorLockMode originalLockMode;

		private bool NeedsConnection => !(apClient?.IsConnected ?? false);

		public void Initialize(ArchipelagoClient client)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			apClient = client;
			apClient.OnConnected += delegate
			{
				statusMessage = "Connected successfully!";
			};
			apClient.OnConnectionFailed += delegate(string error)
			{
				statusMessage = "Failed: " + error;
			};
			apClient.OnDisconnected += delegate
			{
				statusMessage = "Disconnected";
			};
			apClient.OnConnected += delegate
			{
				FileWriter fileWriter = Object.FindObjectOfType<FileWriter>();
				if (!((Object)(object)fileWriter == (Object)null))
				{
					int.TryParse(port, out var result);
					fileWriter.WriteLastConnection(hostname, result, slotName, password);
				}
			};
			(string, string, string, string) tuple = FileWriter.ReadLastConnection();
			if (!string.IsNullOrEmpty(tuple.Item1))
			{
				(hostname, _, _, _) = tuple;
			}
			if (!string.IsNullOrEmpty(tuple.Item2))
			{
				port = tuple.Item2;
			}
			if (!string.IsNullOrEmpty(tuple.Item3))
			{
				slotName = tuple.Item3;
			}
			if (!string.IsNullOrEmpty(tuple.Item4))
			{
				password = tuple.Item4;
			}
			originalCursorVisible = Cursor.visible;
			originalLockMode = Cursor.lockState;
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
		}

		public void ToggleUI()
		{
			//IL_0046: 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)
			showUI = !showUI;
			if (showUI)
			{
				originalCursorVisible = Cursor.visible;
				originalLockMode = Cursor.lockState;
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			else
			{
				Cursor.visible = originalCursorVisible;
				Cursor.lockState = originalLockMode;
			}
		}

		public void ForceShow()
		{
			Time.timeScale = 0f;
			m_paused = true;
			showUI = true;
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
		}

		private void Update()
		{
			bool needsConnection = NeedsConnection;
			if (needsConnection && !m_paused)
			{
				Time.timeScale = 0f;
				m_paused = true;
				showUI = true;
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			else if (!needsConnection && m_paused)
			{
				Time.timeScale = 1f;
				m_paused = false;
			}
			if (!needsConnection && Input.GetKeyDown((KeyCode)282))
			{
				ToggleUI();
			}
		}

		private void OnGUI()
		{
			//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_0065: 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: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (showUI || NeedsConnection)
			{
				GUI.skin.label.fontSize = 24;
				GUI.skin.button.fontSize = 24;
				GUI.skin.textField.fontSize = 24;
				Color backgroundColor = GUI.backgroundColor;
				GUI.backgroundColor = new Color(1f, 0.5f, 0f);
				windowRect = GUI.Window(0, windowRect, new WindowFunction(DrawWindow), "Archipelago Connection");
				GUI.backgroundColor = backgroundColor;
			}
		}

		private void DrawWindow(int windowID)
		{
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Press F1 to show this menu while connected ingame.", Array.Empty<GUILayoutOption>());
			GUILayout.Space(15f);
			GUILayout.Label("Hostname:", Array.Empty<GUILayoutOption>());
			hostname = GUILayout.TextField(hostname, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Port:", Array.Empty<GUILayoutOption>());
			port = GUILayout.TextField(port, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Slot Name:", Array.Empty<GUILayoutOption>());
			slotName = GUILayout.TextField(slotName, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Password (optional):", Array.Empty<GUILayoutOption>());
			password = GUILayout.PasswordField(password, '*', (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(15f);
			ArchipelagoClient archipelagoClient = apClient;
			if (archipelagoClient != null && archipelagoClient.IsConnected)
			{
				if (GUILayout.Button("Disconnect", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) }))
				{
					apClient.Disconnect();
				}
			}
			else if (GUILayout.Button("Connect", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) }))
			{
				int result;
				if (string.IsNullOrEmpty(slotName))
				{
					statusMessage = "Please enter a slot name!";
				}
				else if (int.TryParse(port, out result))
				{
					statusMessage = "Connecting...";
					apClient?.Connect(hostname, result, slotName, password);
				}
				else
				{
					statusMessage = "Invalid port number!";
				}
			}
			GUILayout.Space(15f);
			if (!string.IsNullOrEmpty(statusMessage))
			{
				GUILayout.Label("Status: " + statusMessage, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndVertical();
			GUI.DragWindow();
		}
	}
	public class FileWriter : MonoBehaviour
	{
		private const string LastConnectionFileName = "last_connection.txt";

		public void WriteLastConnection(string host, int port, string slotName, string password)
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				List<string> contents = new List<string>
				{
					host ?? "",
					port.ToString(),
					slotName ?? "",
					password ?? ""
				};
				File.WriteAllLines(path, contents);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to write last connection info: " + ex.Message));
			}
		}

		public static (string host, string port, string slotName, string password) ReadLastConnection()
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				if (!File.Exists(path))
				{
					return (host: null, port: null, slotName: null, password: null);
				}
				string[] array = File.ReadAllLines(path);
				string item = ((array.Length != 0) ? array[0] : null);
				string item2 = ((array.Length > 1) ? array[1] : null);
				string item3 = ((array.Length > 2) ? array[2] : null);
				string item4 = ((array.Length > 3) ? array[3] : null);
				return (host: item, port: item2, slotName: item3, password: item4);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to read last connection info: " + ex.Message));
				return (host: null, port: null, slotName: null, password: null);
			}
		}
	}
	public enum ItemManiaMode
	{
		UseYaml,
		On,
		Off
	}
	public enum DeathLinkMode
	{
		UseYaml,
		On,
		Off
	}
	[BepInPlugin("Jeffdev.GarfieldKartAPMod", "GarfieldKartAPMod", "1.0.2")]
	public class GarfieldKartAPMod : BaseUnityPlugin
	{
		private const string PluginGuid = "Jeffdev.GarfieldKartAPMod";

		private const string PluginAuthor = "Jeffdev";

		private const string PluginName = "GarfieldKartAPMod";

		private const string PluginVersion = "1.0.2";

		public static ConfigEntry<int> notificationTime;

		public static ConfigEntry<int> lapCountOverride;

		public static ConfigEntry<bool> showNotifications;

		public static ConfigEntry<bool> showOnlyRelevantNotifications;

		public static ConfigEntry<bool> disableStatRandomization;

		public static ConfigEntry<int> lapSanityPlacementRequirement;

		public static ConfigEntry<bool> strictCpuItems;

		public static ConfigEntry<ItemManiaMode> itemManiaMode;

		public static ConfigEntry<DeathLinkMode> deathLink;

		private Harmony harmony;

		public static Dictionary<string, object> sessionSlotData;

		private static GameObject uiObject;

		private static bool uiCreated;

		private static NotificationDisplay notificationDisplay;

		private FileWriter fileWriter;

		public static ArchipelagoClient APClient { get; private set; }

		public void Awake()
		{
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			notificationTime = ((BaseUnityPlugin)this).Config.Bind<int>("Archipelago", "Server Message On-Screen Time", 3, "How long to show archipelago server messages and checks on the screen, in seconds.");
			lapCountOverride = ((BaseUnityPlugin)this).Config.Bind<int>("Archipelago", "Lap Count Override", 0, "Override the lap count for races. Set to 0 to use the lap count from Archipelago slot data.");
			showNotifications = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Show Log Messages", true, "Show Archipelago server log messages at the top of the screen.");
			showOnlyRelevantNotifications = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Show Only Relevant Messages", true, "Only show log messages relevant to you (items you send or receive, your hints). Other message types still appear.");
			disableStatRandomization = ((BaseUnityPlugin)this).Config.Bind<bool>("Archipelago", "Disable Stat Randomization", false, "Disable kart and character stat randomization, even if the Archipelago slot has it enabled.");
			lapSanityPlacementRequirement = ((BaseUnityPlugin)this).Config.Bind<int>("Archipelago", "Lap Sanity Placement Requirement", 1, new ConfigDescription("The placement you must be in (or better) when completing a lap for it to count as a lap sanity check. 1 = 1st place only, 8 = any placement.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()));
			strictCpuItems = ((BaseUnityPlugin)this).Config.Bind<bool>("Archipelago", "Strict CPU Items", false, "CPU racers can only use items you have received from Archipelago, instead of being able to use any item.");
			itemManiaMode = ((BaseUnityPlugin)this).Config.Bind<ItemManiaMode>("Archipelago", "Item Mania", ItemManiaMode.UseYaml, "Control Item Mania (CPUs hold 3 items and fire them rapidly). UseYaml follows the Archipelago slot setting; On/Off force it regardless of the yaml.");
			deathLink = ((BaseUnityPlugin)this).Config.Bind<DeathLinkMode>("Archipelago", "Death Link", DeathLinkMode.UseYaml, "Control DeathLink (falling off the track sends a death to other DeathLink players, and their deaths force your kart to respawn). UseYaml follows the Archipelago slot setting; On/Off force it regardless of the yaml.");
			deathLink.SettingChanged += delegate
			{
				DeathLinkManager.ApplyConfig();
			};
			InitializeLogging();
			InitializeAssemblyResolution();
			InitializeComponents();
			ApplyPatches();
			Log.Info("GarfieldKartAPMod loaded successfully!");
		}

		private void InitializeLogging()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
		}

		private void InitializeAssemblyResolution()
		{
			ForceLoadNewtonsoftJson();
			AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
			CheckSystemNumericsAvailability();
		}

		private void ForceLoadNewtonsoftJson()
		{
			try
			{
				Type typeFromHandle = typeof(JsonConvert);
				Log.Message($"Loaded Newtonsoft.Json version: {typeFromHandle.Assembly.GetName().Version}");
			}
			catch (Exception ex)
			{
				Log.Error("Failed to preload Newtonsoft.Json: " + ex.Message);
			}
		}

		private void CheckSystemNumericsAvailability()
		{
			try
			{
				Type type = Type.GetType("System.Numerics.BigInteger, System.Numerics");
				((BaseUnityPlugin)this).Logger.LogInfo((object)$"BigInteger available: {type != null}");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("BigInteger check failed: " + ex.Message));
			}
		}

		private void InitializeComponents()
		{
			UITextureSwapper.Initialize();
			fileWriter = ((Component)this).gameObject.AddComponent<FileWriter>();
			APClient = new ArchipelagoClient();
			APClient.OnConnected += OnArchipelagoConnected;
			APClient.OnDisconnected += OnArchipelagoDisconnected;
			CreateUI();
		}

		private void ApplyPatches()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			harmony = new Harmony("Jeffdev.GarfieldKartAPMod");
			harmony.PatchAll(Assembly.GetExecutingAssembly());
		}

		public void Update()
		{
			DeathLinkManager.ProcessPendingDeath();
			TickActiveTrapTimers();
			if (ArchipelagoHelper.IsConnectedAndEnabled)
			{
				ArchipelagoItemTracker.ProcessLiveReceivedItems();
				ArchipelagoFillerEffects.Update();
				ArchipelagoTrapEffects.Update();
			}
			if (APClient != null && APClient.HasPendingNotifications())
			{
				string message = APClient.DequeuePendingNotification();
				if (showNotifications.Value)
				{
					notificationDisplay.ShowNotification(message);
				}
			}
		}

		private static void TickActiveTrapTimers()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			GameManager instance = Singleton<GameManager>.Instance;
			GameMode obj = ((instance != null) ? instance.GameMode : null);
			InGameGameMode val = (InGameGameMode)(object)((obj is InGameGameMode) ? obj : null);
			if (val == null || !val.HasRaceStarted || (int)Singleton<GameConfigurator>.Instance.GameModeType == 4)
			{
				return;
			}
			foreach (Driver value in ((GameMode)val).Drivers.Values)
			{
				if (value.IsHuman && value.IsLocal)
				{
					if (!((Object)(object)value.Kart == (Object)null) && !((RcVehicle)value.Kart).IsRaceEnded())
					{
						ArchipelagoFillerManager.TickTrapTimers(Time.deltaTime);
					}
					break;
				}
			}
		}

		private void OnArchipelagoConnected()
		{
			Log.Message("Connected to Archipelago - loading items");
			uiObject.GetComponent<ConnectionUI>().ToggleUI();
		}

		private void OnArchipelagoDisconnected()
		{
			Log.Message("Disconnected from Archipelago");
			uiObject.GetComponent<ConnectionUI>().ForceShow();
		}

		private Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
		{
			if (new AssemblyName(args.Name).Name != "Newtonsoft.Json")
			{
				return null;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (!(assembly.GetName().Name != "Newtonsoft.Json"))
				{
					Log.Message($"Resolved Newtonsoft.Json to version {assembly.GetName().Version}");
					return assembly;
				}
			}
			return null;
		}

		public static void CreateUI()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (!uiCreated)
			{
				Log.Message("Creating Archipelago UI...");
				uiObject = new GameObject("ArchipelagoUI");
				Object.DontDestroyOnLoad((Object)(object)uiObject);
				uiObject.AddComponent<ConnectionUI>().Initialize(APClient);
				notificationDisplay = uiObject.AddComponent<NotificationDisplay>();
				notificationDisplay.Initialize();
				uiCreated = true;
			}
		}

		public void OnDestroy()
		{
			APClient?.Disconnect();
			if ((Object)(object)uiObject != (Object)null)
			{
				Object.Destroy((Object)(object)uiObject);
			}
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
	public static class DeathLinkManager
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static DeathLinkReceivedHandler <0>__OnDeathLinkReceived;
		}

		private static DeathLinkService service;

		private static volatile bool deathPending;

		private static string pendingSource;

		private static string pendingCause;

		private static float suppressSendUntil;

		public static void OnSessionConnected(ArchipelagoSession session)
		{
			//IL_0020: 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: Expected O, but got Unknown
			service = DeathLinkProvider.CreateDeathLinkService(session);
			DeathLinkService obj = service;
			object obj2 = <>O.<0>__OnDeathLinkReceived;
			if (obj2 == null)
			{
				DeathLinkReceivedHandler val = OnDeathLinkReceived;
				<>O.<0>__OnDeathLinkReceived = val;
				obj2 = (object)val;
			}
			obj.OnDeathLinkReceived += (DeathLinkReceivedHandler)obj2;
			ApplyConfig();
		}

		public static void OnDisconnected()
		{
			service = null;
			deathPending = false;
		}

		public static void ApplyConfig()
		{
			if (service != null)
			{
				if (ArchipelagoHelper.IsDeathLinkEnabled())
				{
					service.EnableDeathLink();
					Log.Message("DeathLink enabled");
				}
				else
				{
					service.DisableDeathLink();
					Log.Message("DeathLink disabled");
				}
			}
		}

		private static void OnDeathLinkReceived(DeathLink deathLink)
		{
			pendingSource = deathLink.Source;
			pendingCause = deathLink.Cause;
			deathPending = true;
		}

		public static void ProcessPendingDeath()
		{
			if (!deathPending)
			{
				return;
			}
			if (!ArchipelagoHelper.IsDeathLinkEnabled())
			{
				deathPending = false;
				return;
			}
			Kart val = FindLocalPlayerKart();
			if ((Object)(object)val == (Object)null)
			{
				deathPending = false;
				Log.Message("DeathLink from " + pendingSource + " ignored (not in a race)");
			}
			else if (!ArchipelagoHelper.IsBeingAbductedByUfo(val))
			{
				deathPending = false;
				string text = (string.IsNullOrEmpty(pendingCause) ? ("DeathLink from " + pendingSource) : pendingCause);
				Log.Message("DeathLink received: " + text);
				GarfieldKartAPMod.APClient?.QueueNotification("DeathLink: " + text);
				suppressSendUntil = Time.realtimeSinceStartup + 3f;
				((RcVehicle)val).ForceRespawn();
			}
		}

		public static void OnLocalPlayerFell()
		{
			if (!(Time.realtimeSinceStartup < suppressSendUntil))
			{
				SendDeath(SlotName() + " fell off the track");
			}
		}

		public static void SendDebugDeath()
		{
			SendDeath(SlotName() + " pressed the death button");
		}

		public static void SimulateReceivedDeath()
		{
			pendingSource = "Debug";
			pendingCause = "Simulated DeathLink";
			deathPending = true;
		}

		private static void SendDeath(string cause)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (service == null || !ArchipelagoHelper.IsDeathLinkEnabled())
			{
				return;
			}
			try
			{
				service.SendDeathLink(new DeathLink(SlotName(), cause));
				Log.Message("Sent DeathLink: " + cause);
			}
			catch (Exception ex)
			{
				Log.Error("Failed to send DeathLink: " + ex.Message);
			}
		}

		private static string SlotName()
		{
			return GarfieldKartAPMod.APClient?.SlotName ?? "Player";
		}

		private static Kart FindLocalPlayerKart()
		{
			Driver[] array = Object.FindObjectsOfType<Driver>();
			foreach (Driver val in array)
			{
				if (val.IsHuman && val.IsLocal && (Object)(object)val.Kart != (Object)null)
				{
					return val.Kart;
				}
			}
			return null;
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public class NotificationDisplay : MonoBehaviour
	{
		private static readonly Vector2 ReferenceResolution = new Vector2(1920f, 1080f);

		private TextMeshProUGUI notificationText;

		private TextMeshProUGUI shadowText;

		private readonly Queue<string> notificationQueue = new Queue<string>();

		private bool isDisplaying;

		public void Initialize()
		{
			//IL_002f: 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_0055: Expected O, but got Unknown
			//IL_0084: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			Canvas obj = ((Component)this).gameObject.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 1000;
			CanvasScaler obj2 = ((Component)this).gameObject.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = ReferenceResolution;
			obj2.screenMatchMode = (ScreenMatchMode)0;
			obj2.matchWidthOrHeight = 1f;
			GameObject val = new GameObject("NotificationShadow");
			val.transform.SetParent(((Component)this).transform);
			shadowText = val.AddComponent<TextMeshProUGUI>();
			ConfigureText(shadowText);
			((Graphic)shadowText).color = Color.black;
			((Component)shadowText).GetComponent<RectTransform>().anchoredPosition = new Vector2(2f, -22f);
			GameObject val2 = new GameObject("NotificationText");
			val2.transform.SetParent(((Component)this).transform);
			notificationText = val2.AddComponent<TextMeshProUGUI>();
			ConfigureText(notificationText);
			((Graphic)notificationText).color = Color.white;
			((TMP_Text)notificationText).text = "";
			((TMP_Text)shadowText).text = "";
		}

		private void ConfigureText(TextMeshProUGUI text)
		{
			//IL_003c: 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_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_008f: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)text).fontSize = 24f;
			((TMP_Text)text).alignment = (TextAlignmentOptions)258;
			((TMP_Text)text).autoSizeTextContainer = true;
			((TMP_Text)text).enableWordWrapping = true;
			((TMP_Text)text).richText = true;
			RectTransform component = ((Component)text).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -20f);
			component.sizeDelta = new Vector2(-40f, 100f);
		}

		public void ShowNotification(string message)
		{
			if (!message.Contains("Now that you are connected") && !message.Contains("Warning: your client does not"))
			{
				notificationQueue.Enqueue(message);
				if (!isDisplaying)
				{
					((MonoBehaviour)this).StartCoroutine(DisplayNextNotification());
				}
			}
		}

		private IEnumerator DisplayNextNotification()
		{
			isDisplaying = true;
			while (notificationQueue.Count > 0)
			{
				string text = notificationQueue.Dequeue();
				((TMP_Text)notificationText).text = text;
				((TMP_Text)shadowText).text = StripColorTags(text);
				yield return (object)new WaitForSeconds((float)GarfieldKartAPMod.notificationTime.Value);
			}
			((TMP_Text)notificationText).text = "";
			((TMP_Text)shadowText).text = "";
			isDisplaying = false;
		}

		private string StripColorTags(string input)
		{
			if (string.IsNullOrEmpty(input))
			{
				return input;
			}
			string text = input;
			while (text.Contains("<color="))
			{
				int num = text.IndexOf("<color=");
				int num2 = text.IndexOf(">", num);
				if (num2 == -1)
				{
					break;
				}
				text = text.Remove(num, num2 - num + 1);
			}
			return text.Replace("</color>", "");
		}
	}
	[Serializable]
	public class SlotDataException : ApplicationException
	{
		public SlotDataException()
		{
		}

		public SlotDataException(string message)
			: base(message)
		{
		}

		public SlotDataException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public static class UITextureSwapper
	{
		public static string spriteFolder = "Resources/Sprites";

		private static Sprite baseArchipelagoSprite;

		public static Sprite puzzlePieceFilledSprite;

		public static Sprite puzzlePieceEmptySprite;

		public static Sprite mainMenuLogoSprite;

		public static Sprite galleryIconSprite;

		private static bool initialized;

		private static bool hasSwappedThisMenu;

		private const float GalleryIconScale = 0.7f;

		private static readonly Vector2 GalleryIconNudge = new Vector2(10f, 0f);

		public static void Initialize()
		{
			if (!initialized)
			{
				Log.Message("Initializing UI texture swapper...");
				if (TryLoadSprite("garfkart_ap_puzzle_filled.png", out baseArchipelagoSprite) && TryLoadSprite("garfkart_ap_puzzle_filled.png", out puzzlePieceFilledSprite) && TryLoadSprite("garfkart_ap_puzzle_empty.png", out puzzlePieceEmptySprite) && TryLoadSprite("logo_garfAP_complete.png", out mainMenuLogoSprite) && TryLoadSprite("garfkart_ap_icon.png", out galleryIconSprite))
				{
					initialized = true;
				}
			}
		}

		private static bool TryLoadSprite(string path, out Sprite targetSprite)
		{
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_012c: 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)
			_ = typeof(UITextureSwapper).Namespace;
			targetSprite = null;
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
				string text = null;
				string[] array = manifestResourceNames;
				foreach (string text2 in array)
				{
					if (!(text2 != path) || text2.EndsWith("." + path))
					{
						if (text != null)
						{
							throw new ApplicationException("Duplicate resource name found, unable to load the correct texture: " + text2);
						}
						text = text2;
					}
				}
				if (text == null)
				{
					Log.Warning("Couldn't find " + path + " in embedded resources, loading default sprite instead.");
					targetSprite = CreateDefaultSprite();
					return false;
				}
				Log.Message("Loading embedded resource: " + text);
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream == null)
				{
					Log.Error("Failed to load " + path + " for unknown reasons :)");
					targetSprite = CreateDefaultSprite();
					return false;
				}
				byte[] array2 = new byte[stream.Length];
				stream.Read(array2, 0, (int)stream.Length);
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, array2);
				val.Apply();
				targetSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				Log.Message($"Successfully loaded {path} ({((Texture)val).width}x{((Texture)val).height})");
				return true;
			}
			catch (Exception ex)
			{
				Log.Error("Failed to load " + path + ": " + ex.Message + "\n" + ex.StackTrace);
				targetSprite = CreateDefaultSprite();
				return false;
			}
		}

		private static Sprite CreateDefaultSprite()
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//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_005b: 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)
			Texture2D val = new Texture2D(64, 64);
			Color[] array = (Color[])(object)new Color[4096];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = Color.red;
			}
			val.SetPixels(array);
			val.Apply();
			Log.Message("Created default red placeholder sprite");
			return Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
		}

		public static void ResetSwapFlag()
		{
			hasSwappedThisMenu = false;
		}

		public static void SwapMainMenuLogo(GameObject root)
		{
			if ((Object)(object)mainMenuLogoSprite == (Object)null)
			{
				Log.Error("Cannot swap - main menu logo sprite not loaded");
				return;
			}
			try
			{
				int num = 0;
				bool flag = false;
				Image[] componentsInChildren = root.GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if ((Object)(object)val.sprite == (Object)null)
					{
						continue;
					}
					if ((Object)(object)val.sprite == (Object)(object)mainMenuLogoSprite)
					{
						flag = true;
						continue;
					}
					string text = ((Object)val.sprite).name.ToLower();
					string text2 = ((Object)((Component)val).gameObject).name.ToLower();
					if (text.Contains("titlelogo") || text2.Contains("titlelogo"))
					{
						val.sprite = mainMenuLogoSprite;
						val.preserveAspect = true;
						num++;
						Log.Message("Swapped main menu logo on: " + ((Object)((Component)val).gameObject).name);
					}
				}
				if (num == 0 && !flag)
				{
					Log.Warning("No main menu logo image found to swap");
				}
			}
			catch (Exception ex)
			{
				Log.Error("Failed to swap main menu logo: " + ex.Message);
			}
		}

		public static void SwapGalleryButtonIcon(GameObject galleryButton)
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)galleryButton == (Object)null)
			{
				return;
			}
			if ((Object)(object)galleryIconSprite == (Object)null)
			{
				Log.Error("Cannot swap - AP gallery icon sprite not loaded");
				return;
			}
			try
			{
				Button component = galleryButton.GetComponent<Button>();
				Graphic val = (((Object)(object)component != (Object)null) ? ((Selectable)component).targetGraphic : null);
				int num = 0;
				Image[] componentsInChildren = galleryButton.GetComponentsInChildren<Image>(true);
				foreach (Image val2 in componentsInChildren)
				{
					if (!((Object)(object)val2 == (Object)(object)val) && !((Object)(object)val2.sprite == (Object)(object)galleryIconSprite))
					{
						string text = ((Object)((Component)val2).gameObject).name.ToLower();
						string text2 = (((Object)(object)val2.sprite != (Object)null) ? ((Object)val2.sprite).name.ToLower() : "");
						Log.Message("Gallery button image: " + ((Object)((Component)val2).gameObject).name + " (sprite: " + text2 + ")");
						if (text.Contains("icn") || text.Contains("icon") || text2.Contains("icn") || text2.Contains("icon"))
						{
							val2.sprite = galleryIconSprite;
							val2.preserveAspect = true;
							((Transform)((Graphic)val2).rectTransform).localScale = Vector3.one * 0.7f;
							RectTransform rectTransform = ((Graphic)val2).rectTransform;
							rectTransform.anchoredPosition += GalleryIconNudge;
							num++;
						}
					}
				}
				if (num == 0)
				{
					Log.Warning("No icon image found on the Gallery button to swap");
				}
			}
			catch (Exception ex)
			{
				Log.Error("Failed to swap gallery button icon: " + ex.Message);
			}
		}

		public static void SwapPuzzlePieceIcons(GameObject menu)
		{
			if (hasSwappedThisMenu)
			{
				Log.Error("Cannot swap - already swapped this menu");
				return;
			}
			if ((Object)(object)baseArchipelagoSprite == (Object)null)
			{
				Log.Error("Cannot swap - Archipelago sprite not loaded");
				return;
			}
			try
			{
				int num = 0;
				Image[] componentsInChildren = menu.GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if (!((Object)(object)val.sprite == (Object)null))
					{
						string text = ((Object)val.sprite).name.ToLower();
						string text2 = ((Object)((Component)val).gameObject).name.ToLower();
						if (text.Contains("icnpuzzle") || text2.Contains("icnpuzzle") || text.Contains("icnpuzzlefull") || text2.Contains("icnpuzzlefull"))
						{
							val.sprite = baseArchipelagoSprite;
							num++;
							Log.Message("Swapped UI.Image on: " + ((Object)((Component)val).gameObject).name);
						}
					}
				}
				Log.Message($"Swapped {num} puzzle piece icons");
				hasSwappedThisMenu = true;
			}
			catch (Exception ex)
			{
				Log.Error("Failed to swap puzzle icons: " + ex.Message);
			}
		}
	}
}
namespace GarfieldKartAPMod.Helpers
{
	internal static class ApGalleryMenu
	{
		private class Entry
		{
			public Sprite Icon;

			public bool Received;
		}

		private class Section
		{
			public string Header;

			public List<Entry> Entries;
		}

		private const string RootName = "APGalleryRoot";

		private const int Columns = 8;

		private const float TileSize = 116f;

		private const float TileSpacing = 10f;

		private static readonly Color ReceivedTint = Color.white;

		private static readonly Color MissingTint = new Color(0.14f, 0.14f, 0.17f, 0.9f);

		private static readonly Color IconlessTint = new Color(1f, 1f, 1f, 0.4f);

		private static readonly Color HeaderShadowColor = new Color(0.42f, 0.16f, 0.02f, 1f);

		private static readonly Vector2 HeaderShadowOffset = new Vector2(2f, -2f);

		private const float HeaderFontSize = 32f;

		private const float HeaderHeight = 24f;

		private static readonly (BonusCategory Bonus, int IconIndex)[] BonusIcons = new(BonusCategory, int)[9]
		{
			((BonusCategory)1, 4),
			((BonusCategory)2, 6),
			((BonusCategory)5, 9),
			((BonusCategory)9, 7),
			((BonusCategory)8, 1),
			((BonusCategory)4, 0),
			((BonusCategory)6, 11),
			((BonusCategory)7, 10),
			((BonusCategory)3, 2)
		};

		private const float TopMargin = 240f;

		private const float BottomMargin = 70f;

		public static void Refresh(MenuHDGallery menu, TextMeshProUGUI titleLabel, Canvas listCanvas, GameObject submitButton, InfoBox infoBox)
		{
			if ((Object)(object)menu == (Object)null)
			{
				return;
			}
			bool isConnectedAndEnabled = ArchipelagoHelper.IsConnectedAndEnabled;
			if ((Object)(object)listCanvas != (Object)null)
			{
				((Component)listCanvas).gameObject.SetActive(!isConnectedAndEnabled);
			}
			if ((Object)(object)submitButton != (Object)null)
			{
				submitButton.SetActive(!isConnectedAndEnabled);
			}
			if (isConnectedAndEnabled && infoBox != null)
			{
				infoBox.SetText("");
			}
			GalleryArtwork[] componentsInChildren = ((Component)menu).GetComponentsInChildren<GalleryArtwork>(true);
			foreach (GalleryArtwork val in componentsInChildren)
			{
				if ((Object)(object)val.Button != (Object)null)
				{
					((Selectable)val.Button).interactable = !isConnectedAndEnabled;
				}
			}
			Transform val2 = ((Component)menu).transform.Find("APGalleryRoot");
			if ((Object)(object)val2 != (Object)null)
			{
				((Object)val2).name = "APGalleryRoot_old";
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
			if (isConnectedAndEnabled)
			{
				if ((Object)(object)titleLabel != (Object)null)
				{
					((TMP_Text)titleLabel).text = "Archipelago Items";
				}
				BuildPanel(menu, titleLabel);
			}
		}

		private static void BuildPanel(MenuHDGallery menu, TextMeshProUGUI fontSource)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0042: 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_006c: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("APGalleryRoot", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(((Component)menu).transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -240f);
			component.sizeDelta = new Vector2(1008f, 0f);
			VerticalLayoutGroup obj = val.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			val.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			List<Section> list = BuildSections();
			if (list.Count == 0)
			{
				CreateHeader(val.transform, fontSource, "Nothing is randomized in this seed.");
				return;
			}
			foreach (Section item in list)
			{
				CreateHeader(val.transform, fontSource, item.Header);
				if (item.Entries.Count > 0)
				{
					CreateGrid(val.transform, item.Entries);
				}
			}
			ShrinkToFit(menu, component);
		}

		private static void ShrinkToFit(MenuHDGallery menu, RectTransform rootRect)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = ((Component)menu).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val != null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(rootRect);
				Rect rect = val.rect;
				float num = ((Rect)(ref rect)).height - 240f - 70f;
				float preferredHeight = LayoutUtility.GetPreferredHeight(rootRect);
				if (!(preferredHeight <= 0f) && !(num <= 0f) && !(preferredHeight <= num))
				{
					float num2 = num / preferredHeight;
					((Transform)rootRect).localScale = Vector3.one * num2;
					Log.Message($"[Gallery] Panel needs {preferredHeight:F0} of {num:F0} available, scaled to {num2:F2}");
				}
			}
		}

		private static List<Section> BuildSections()
		{
			List<Section> list = new List<Section>();
			list.Add(BuildGoalSection());
			if (ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				list.Add(BuildPuzzleSection());
			}
			if (ArchipelagoHelper.IsCharRandomizerEnabled())
			{
				list.Add(Grid("RACERS", BuildDriverEntries(character: true)));
			}
			if (ArchipelagoHelper.IsKartRandomizerEnabled())
			{
				list.Add(Grid("KARTS", BuildDriverEntries(character: false)));
			}
			if (ArchipelagoHelper.IsHatRandomizerEnabled())
			{
				list.Add(Grid("HATS", BuildHatEntries()));
			}
			if (ArchipelagoHelper.IsSpoilerRandomizerEnabled())
			{
				list.Add(Grid("SPOILERS", BuildSpoilerEntries()));
			}
			if (ArchipelagoHelper.IsItemRandomizerEnabled())
			{
				list.Add(Grid("ITEMS", BuildBonusEntries()));
			}
			return list;
		}

		private static Section Grid(string title, List<Entry> entries)
		{
			int num = entries.Count((Entry entry) => entry.Received);
			return new Section
			{
				Header = $"{title}   {num}/{entries.Count}",
				Entries = entries
			};
		}

		private static Section BuildGoalSection()
		{
			string text = "GOAL: ";
			long goalId = ArchipelagoGoalManager.GetGoalId();
			if ((ulong)goalId <= 3uL)
			{
				switch (goalId)
				{
				case 0L:
					text += "GET FIRST IN ALL CUPS ON GRAND PRIX";
					break;
				case 1L:
					text += "GET FIRST IN ALL RACES";
					break;
				case 2L:
					text += "DEFEAT ALL TIME TRIALS";
					break;
				case 3L:
					text += "GET THE REQUIRED PUZZLE PIECES BELOW, THEN WIN A RACE";
					break;
				}
			}
			return new Section
			{
				Header = text,
				Entries = new List<Entry>()
			};
		}

		private static Section BuildPuzzleSection()
		{
			int overallPuzzlePieceCount = ArchipelagoItemTracker.GetOverallPuzzlePieceCount();
			string header;
			try
			{
				header = ((ArchipelagoGoalManager.GetGoalId() != 3) ? $"PUZZLE PIECES   {overallPuzzlePieceCount}/{ArchipelagoHelper.GetPuzzlePieceCount()}" : $"PUZZLE PIECES   {overallPuzzlePieceCount}/{ArchipelagoHelper.GetRequiredPuzzlePieceCount()}");
			}
			catch (SlotDataException)
			{
				header = $"PUZZLE PIECES   {overallPuzzlePieceCount}";
			}
			return new Section
			{
				Header = header,
				Entries = new List<Entry>()
			};
		}

		private static List<Entry> BuildDriverEntries(bool character)
		{
			long num = (character ? 301 : 351);
			List<Entry> list = new List<Entry>();
			for (int i = 0; i < 8; i++)
			{
				list.Add(new Entry
				{
					Icon = (character ? ((EnumArray<ECharacter, Sprite>)(object)UISprites.CharactersFaces)[i] : ((EnumArray<ECharacter, Sprite>)(object)UISprites.KartIcons)[i]),
					Received = ArchipelagoItemTracker.HasItem(num + i)
				});
			}
			return list;
		}

		private static List<Entry> BuildHatEntries()
		{
			return BuildCosmeticEntries(PlayerGameEntities.HatList?.Cast<IconCarac>(), ArchipelagoConstants.GetHatItemId, UISprites.HatIcons);
		}

		private static List<Entry> BuildSpoilerEntries()
		{
			return BuildCosmeticEntries(PlayerGameEntities.KartCustomList?.Cast<IconCarac>(), ArchipelagoConstants.GetSpoilerItemId, UISprites.KartCustomIcons);
		}

		private static List<Entry> BuildCosmeticEntries(IEnumerable<IconCarac> all, Func<string, long> toItemId, Dictionary<string, Sprite> icons)
		{
			List<Entry> list = new List<Entry>();
			if (all == null)
			{
				return list;
			}
			HashSet<long> hashSet = new HashSet<long>();
			foreach (IconCarac item in all)
			{
				long num = toItemId(((Object)item).name);
				if (num != -1 && hashSet.Add(num))
				{
					icons.TryGetValue(((Object)item).name, out var value);
					list.Add(new Entry
					{
						Icon = value,
						Received = ArchipelagoItemTracker.HasItem(num)
					});
				}
			}
			return list;
		}

		private static List<Entry> BuildBonusEntries()
		{
			return BonusIcons.Select(((BonusCategory Bonus, int IconIndex) bonus) => new Entry
			{
				Icon = ((EnumArray<BONUS_TYPE, Sprite>)(object)UISprites.TutoBonusIcons)[bonus.IconIndex],
				Received = ArchipelagoItemTracker.HasBonusAvailable(bonus.Bonus)
			}).ToList();
		}

		private static void CreateHeader(Transform parent, TextMeshProUGUI fontSource, string text)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0089: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("APGalleryHeader", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			LayoutElement obj = val.AddComponent<LayoutElement>();
			obj.minHeight = 24f;
			obj.preferredHeight = 24f;
			TextMeshProUGUI obj2 = CreateHeaderLabel(val.transform, fontSource, text, "APGalleryHeaderShadow");
			TextMeshProUGUI component = Object.Instantiate<GameObject>(((Component)obj2).gameObject, val.transform).GetComponent<TextMeshProUGUI>();
			((Object)((Component)component).gameObject).name = "APGalleryHeaderLabel";
			((TMP_Text)component).transform.SetAsLastSibling();
			((Graphic)obj2).color = HeaderShadowColor;
			((TMP_Text)obj2).rectTransform.offsetMin = HeaderShadowOffset;
			((TMP_Text)obj2).rectTransform.offsetMax = HeaderShadowOffset;
		}

		private static TextMeshProUGUI CreateHeaderLabel(Transform parent, TextMeshProUGUI fontSource, string text, string name)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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)
			GameObject val;
			if ((Object)(object)fontSource != (Object)null)
			{
				val = Object.Instantiate<GameObject>(((Component)fontSource).gameObject, parent);
				foreach (Transform item in val.transform)
				{
					Object.Destroy((Object)(object)((Component)item).gameObject);
				}
				Component[] components = val.GetComponents<Component>();
				foreach (Component val2 in components)
				{
					if (!(val2 is RectTransform) && !(val2 is CanvasRenderer) && !(val2 is TextMeshProUGUI))
					{
						Object.Destroy((Object)(object)val2);
					}
				}
			}
			else
			{
				val = new GameObject(name, new Type[2]
				{
					typeof(RectTransform),
					typeof(TextMeshProUGUI)
				});
				val.transform.SetParent(parent, false);
			}
			((Object)val).name = name;
			val.SetActive(true);
			TextMeshProUGUI component = val.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).alignment = (TextAlignmentOptions)513;
			((TMP_Text)component).enableAutoSizing = false;
			((TMP_Text)component).fontSize = 32f;
			((TMP_Text)component).enableWordWrapping = false;
			((TMP_Text)component).overflowMode = (TextOverflowModes)0;
			((Graphic)component).raycastTarget = false;
			((TMP_Text)component).margin = Vector4.zero;
			RectTransform rectTransform = ((TMP_Text)component).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((Transform)rectTransform).localScale = Vector3.one;
			return component;
		}

		private static void CreateGrid(Transform parent, List<Entry> entries)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_003c: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("APGalleryGrid", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			GridLayoutGroup obj = val.AddComponent<GridLayoutGroup>();
			obj.cellSize = new Vector2(116f, 116f);
			obj.spacing = new Vector2(10f, 10f);
			obj.constraint = (Constraint)1;
			obj.constraintCount = 8;
			((LayoutGroup)obj).childAlignment = (TextAnchor)0;
			foreach (Entry entry in entries)
			{
				GameObject val2 = new GameObject("APGalleryTile", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val2.transform.SetParent(val.transform, false);
				Image component = val2.GetComponent<Image>();
				component.sprite = entry.Icon;
				component.preserveAspect = true;
				((Graphic)component).raycastTarget = false;
				((Graphic)component).color = (((Object)(object)entry.Icon == (Object)null && entry.Received) ? IconlessTint : (entry.Received ? ReceivedTint : MissingTint));
			}
		}
	}
	internal static class ArchipelagoFillerEffects
	{
		private static readonly Dictionary<BonusCategory, string> BonusDisplayNames = new Dictionary<BonusCategory, string>
		{
			{
				(BonusCategory)1,
				"Pie"
			},
			{
				(BonusCategory)2,
				"Homing Pie"
			},
			{
				(BonusCategory)3,
				"Spring"
			},
			{
				(BonusCategory)4,
				"Lasagna"
			},
			{
				(BonusCategory)5,
				"Diamond"
			},
			{
				(BonusCategory)6,
				"UFO"
			},
			{
				(BonusCategory)7,
				"Pillow"
			},
			{
				(BonusCategory)8,
				"Perfume"
			},
			{
				(BonusCategory)9,
				"Magic Wand"
			}
		};

		public static void Update()
		{
			if (ArchipelagoFillerManager.IsFillerArmed(1000L) && !ArchipelagoHelper.IsTimeTrial() && ArchipelagoHelper.IsRacing())
			{
				Kart localHumanKart = ArchipelagoHelper.GetLocalHumanKart();
				TryGrantRandomItemBox((localHumanKart != null) ? localHumanKart.GetBonusMgr() : null);
			}
		}

		public static void TryApplyStartBoost(Kart kart)
		{
			if (ArchipelagoFillerManager.TryConsumeInstant(1001L))
			{
				kart.BoostStartType = (BoostType)2;
				GarfieldKartAPMod.APClient?.QueueNotification("Start Boost Helper used: perfect start boost!");
				Log.Message("[Filler] Start Boost Helper consumed: guaranteed super start boost");
			}
		}

		public static void TryShowGarfieldQuote()
		{
			if (ArchipelagoFillerManager.IsFillerActive(1003L))
			{
				ArchipelagoPopupManager.ShowRandomGarfieldQuote();
				Log.Message("[Filler] Inspirational Garfield Quote shown");
			}
		}

		private static void TryGrantRandomItemBox(KartBonusMgr bonusMgr)
		{
			//IL_008f: 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_0096: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)bonusMgr == (Object)null) && bonusMgr.CanGetItem() && ArchipelagoFillerManager.IsFillerArmed(1000L))
			{
				List<BonusCategory> list = BonusDisplayNames.Keys.Where(ArchipelagoItemTracker.HasBonusAvailable).ToList();
				if (Singleton<BonusMgr>.Instance != null && Singleton<BonusMgr>.Instance.IsUfoInUse)
				{
					list.Remove((BonusCategory)6);
				}
				if (list.Count != 0 && ArchipelagoFillerManager.TryConsumeInstant(1000L))
				{
					BonusCategory val = list[Random.Range(0, list.Count)];
					bonusMgr.SetItem(val, 1, -1, true);
					GarfieldKartAPMod.APClient?.QueueNotification("Random Item Box opened: " + BonusDisplayNames[val] + "!");
					Log.Message($"[Filler] Random Item Box granted {val}");
				}
			}
		}
	}
	internal static class ArchipelagoFillerManager
	{
		public enum FillerKind
		{
			Instant,
			Duration
		}

		public class FillerItem
		{
			public long Id;

			public string Name;

			public string Description;

			public FillerKind Kind;

			public bool RaceStartOnly;
		}

		private class TrapItem : FillerItem
		{
		}

		public class ActiveFillerItem
		{
			public FillerItem Item;

			public int RemainingRaces;

			public float TrapSecondsActive;
		}

		public static readonly List<FillerItem> FillerItems = new List<FillerItem>(8)
		{
			new FillerItem
			{
				Id = 1000L,
				Name = "Random Item Box",
				Description = "Grant a random item box upon receiving.",
				Kind = FillerKind.Instant
			},
			new FillerItem
			{
				Id = 1001L,
				Name = "Start Boost Helper",
				Description = "Gives the player a guaranteed good starting boost.",
				Kind = FillerKind.Instant,
				RaceStartOnly = true
			},
			new FillerItem
			{
				Id = 1003L,
				Name = "Inspirational Garfield Quote",
				Description = "Gives the player an inspirational garfield quote at the end of the race.",
				Kind = FillerKind.Duration
			},
			new TrapItem
			{
				Id = 1500L,
				Name = "Mirror Trap",
				Description = "Mirrors the player's controls.",
				Kind = FillerKind.Duration
			},
			new TrapItem
			{
				Id = 1501L,
				Name = "Sleep Trap",
				Description = "Puts the player to sleep.",
				Kind = FillerKind.Instant
			},
			new TrapItem
			{
				Id = 1502L,
				Name = "Grayscale Trap",
				Description = "Turns the screen into grayscale.",
				Kind = FillerKind.Duration
			},
			new TrapItem
			{
				Id = 1503L,
				Name = "Broken Drift Trap",
				Description = "Weakens drift, making you unable to get the best drift.",
				Kind = FillerKind.Duration
			},
			new TrapItem
			{
				Id = 1504L,
				Name = "Bounce Trap",
				Description = "Makes the player have a spring bounce occur.",
				Kind = FillerKind.Instant
			}
		};

		private static readonly Dictionary<long, int> pendingInstant = new Dictionary<long, int>();

		private static readonly Dictionary<long, int> queuedDuration = new Dictionary<long, int>();

		private static readonly List<ActiveFillerItem> activeDuration = new List<ActiveFillerItem>();

		private static readonly HashSet<long> armedInstant = new HashSet<long>();

		private static readonly List<long> usedFiller = new List<long>();

		public static FillerItem GetFillerById(long id)
		{
			return FillerItems.FirstOrDefault((FillerItem item) => item.Id == id);
		}

		public static void TryReceiveFiller(long itemId)
		{
			FillerItem fillerById = GetFillerById(itemId);
			if (fillerById == null)
			{
				return;
			}
			if (fillerById.Kind == FillerKind.Instant)
			{
				Increment(pendingInstant, fillerById.Id);
				if (!fillerById.RaceStartOnly && ArchipelagoHelper.IsRacing())
				{
					armedInstant.Add(fillerById.Id);
				}
				Log.Message($"[Filler] Received {fillerById.Name} ({PendingCount(fillerById.Id)} pending)");
			}
			else if (ArchipelagoHelper.IsRacing() && !IsFillerHeld(fillerById.Id))
			{
				Activate(fillerById);
				SaveFiller();
			}
			else
			{
				Increment(queuedDuration, fillerById.Id);
				Log.Message($"[Filler] Queued {fillerById.Name} ({queuedDuration[fillerById.Id]} in queue)");
			}
		}

		public static void OnRaceStart()
		{
			armedInstant.Clear();
			foreach (KeyValuePair<long, int> item in pendingInstant.Where((KeyValuePair<long, int> entry) => entry.Value > 0))
			{
				armedInstant.Add(item.Key);
			}
			if (ArchipelagoHelper.GetTrapHandling() != 0L)
			{
				foreach (ActiveFillerItem item2 in activeDuration.Where((ActiveFillerItem active) => active.Item is TrapItem))
				{
					item2.TrapSecondsActive = 0f;
					GarfieldKartAPMod.APClient.QueueNotification(item2.Item.Name + " Activated!");
				}
			}
			foreach (long item3 in (from entry in queuedDuration
				where entry.Value > 0
				select entry.Key).ToList())
			{
				FillerItem fillerById = GetFillerById(item3);
				if (fillerById != null && !IsFillerHeld(item3))
				{
					queuedDuration[item3]--;
					Activate(fillerById);
				}
			}
			Log.Message($"[Filler] Race started: {armedInstant.Count} armed, {activeDuration.Count} active");
			SaveFiller();
		}

		public static void OnRaceEnd(bool wonRace)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			armedInstant.Clear();
			long trapHandling = ArchipelagoHelper.GetTrapHandling();
			for (int num = activeDuration.Count - 1; num >= 0; num--)
			{
				ActiveFillerItem activeFillerItem = activeDuration[num];
				if (!(activeFillerItem.Item is TrapItem))
				{
					activeFillerItem.RemainingRaces--;
					if (activeFillerItem.RemainingRaces <= 0)
					{
						Discharge(num);
					}
				}
				else if (trapHandling != 0L && (trapHandling != 2 || wonRace))
				{
					Discharge(num);
				}
			}
			SaveFiller();
		}

		public static void TickTrapTimers(float deltaSeconds)
		{
			bool flag = false;
			long trapHandling = ArchipelagoHelper.GetTrapHandling();
			for (int num = activeDuration.Count - 1; num >= 0; num--)
			{
				ActiveFillerItem activeFillerItem = activeDuration[num];
				if (activeFillerItem.Item is TrapItem && !HasRunItsTime(activeFillerItem))
				{
					activeFillerItem.TrapSecondsActive += deltaSeconds;
					if (HasRunItsTime(activeFillerItem))
					{
						flag = true;
						if (trapHandling == 0L)
						{
							Discharge(num);
						}
						else
						{
							GarfieldKartAPMod.APClient.QueueNotification(activeFillerItem.Item.Name + " Wore Off!");
							Log.Message("[Filler] " + activeFillerItem.Item.Name + " wore off, still owed a race");
						}
					}
				}
			}
			if (flag)
			{
				SaveFiller();
			}
		}

		public static bool IsFillerActive(long fillerId)
		{
			return activeDuration.Any((ActiveFillerItem active) => active.Item.Id == fillerId && !HasRunItsTime(active));
		}

		private static bool IsFillerHeld(long fillerId)
		{
			return activeDuration.Any((ActiveFillerItem active) => active.Item.Id == fillerId);
		}

		private static bool HasRunItsTime(ActiveFillerItem active)
		{
			if (active.Item is TrapItem)
			{
				return active.TrapSecondsActive >= 60f;
			}
			return false;
		}

		public static bool IsFillerArmed(long fillerId)
		{
			return armedInstant.Contains(fillerId);
		}

		public static bool TryConsumeInstant(long fillerId)
		{
			if (!armedInstant.Remove(fillerId))
			{
				return false;
			}
			Decrement(pendingInstant, fillerId);
			usedFiller.Add(fillerId);
			Log.Message($"[Filler] Used {GetFillerById(fillerId)?.Name} ({PendingCount(fillerId)} still pending)");
			SaveFiller();
			return true;
		}

		private static void Activate(FillerItem filler)
		{
			activeDuration.Add(new ActiveFillerItem
			{
				Item = filler,
				RemainingRaces = 1
			});
			if (filler.Id != 1003)
			{
				GarfieldKartAPMod.APClient.QueueNotification(filler.Name + " Activated!");
			}
			Log.Message("[Filler] Activated " + filler.Name);
		}

		private static void Discharge(int index)
		{
			ActiveFillerItem activeFillerItem = activeDuration[index];
			activeDuration.RemoveAt(index);
			usedFiller.Add(activeFillerItem.Item.Id);
			Log.Message("[Filler] Expired " + activeFillerItem.Item.Name);
			GarfieldKartAPMod.APClient.QueueNotification(activeFillerItem.Item.Name + " Expired!");
		}

		public static void LoadFillerFromReceivedItems(List<ItemInfo> itemList)
		{
			pendingInstant.Clear();
			queuedDuration.Clear();
			activeDuration.Clear();
			armedInstant.Clear();
			usedFiller.Clear();
			Dictionary<long, int> dictionary = new Dictionary<long, int>();
			foreach (ItemInfo item in itemList.Where((ItemInfo item) => GetFillerById(item.ItemId) != null))
			{
				Increment(dictionary, item.ItemId);
			}
			foreach (long item2 in ApJsonSaveFile.GetCompletedFillerState())
			{
				if (GetFillerById(item2) != null)
				{
					Decrement(dictionary, item2);
					usedFiller.Add(item2);
				}
			}
			foreach (ApJsonSaveFile.SavedActiveFiller item3 in ApJsonSaveFile.GetActiveFillerState())
			{
				FillerItem fillerById = GetFillerById(item3.Id);
				if (fillerById != null && fillerById.Kind == FillerKind.Duration)
				{
					Decrement(dictionary, item3.Id);
					activeDuration.Add(new ActiveFillerItem
					{
						Item = fillerById,
						RemainingRaces = item3.RemainingRaces,
						TrapSecondsActive = item3.TrapSecondsActive
					});
				}
			}
			foreach (KeyValuePair<long, int> item4 in dictionary.Where((KeyValuePair<long, int> entry) => entry.Value > 0))
			{
				((GetFillerById(item4.Key).Kind == FillerKind.Instant) ? pendingInstant : queuedDuration)[item4.Key] = item4.Value;
			}
			Log.Message($"[Filler] Rebuilt from {itemList.Count} server items: {activeDuration.Count} active, " + $"{pendingInstant.Values.Sum()} pending, {queuedDuration.Values.Sum()} queued, " + $"{usedFiller.Count} used");
			SaveFiller();
		}

		public static void SaveFiller()
		{
			ApJsonSaveFile.SaveFillerState(activeDuration.Select((ActiveFillerItem item) => new ApJsonSaveFile.SavedActiveFiller
			{
				Id = item.Item.Id,
				RemainingRaces = item.RemainingRaces,
				TrapSecondsActive = item.TrapSecondsActive
			}).ToList(), usedFiller.ToList());
		}

		private static int PendingCount(long id)
		{
			if (!pendingInstant.TryGetValue(id, out var value))
			{
				return 0;
			}
			return value;
		}

		private static void Increment(Dictionary<long, int> counts, long id)
		{
			counts.TryGetValue(id, out var value);
			counts[id] = value + 1;
		}

		private static void Decrement(Dictionary<long, int> counts, long id)
		{
			if (counts.TryGetValue(id, out var value) && value > 0)
			{
				counts[id] = value - 1;
			}
		}
	}
	public static class ArchipelagoGoalManager
	{
		public static long GetGoalId()
		{
			long.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("goal"), out var result);
			return result;
		}

		public static void CheckAndCompleteGoal()
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			long goalId = GetGoalId();
			if ((ulong)goalId <= 3uL)
			{
				switch (goalId)
				{
				case 0L:
					CheckGrandPrixGoal();
					return;
				case 3L:
					CheckPuzzlePieceGoal();
					return;
				case 1L:
					CheckRacesGoal();
					return;
				case 2L:
					CheckTimeTrialsGoal();
					return;
				}
			}
			Log.Debug($"Unknown goal ID: {goalId}");
		}

		private static void CheckGrandPrixGoal()
		{
			if (ApJsonSaveFile.GetCupVictoryCount() == 4)
			{
				CompleteGoal();
			}
		}

		private static void CheckPuzzlePieceGoal()
		{
			long num = ArchipelagoHelper.GetRequiredPuzzlePieceCount();
			if (ArchipelagoItemTracker.GetOverallPuzzlePieceCount() >= num)
			{
				CompleteGoal();
			}
		}

		private static void CheckRacesGoal()
		{
			if (ApJsonSaveFile.GetRaceVictoryCount() == 16)
			{
				CompleteGoal();
			}
		}

		private static void CheckTimeTrialsGoal()
		{
			if (ApJsonSaveFile.GetTimeTrialVictoryCount() == 16)
			{
				CompleteGoal();
			}
		}

		private static void CompleteGoal()
		{
			GarfieldKartAPMod.APClient.GetSession().SetGoalAchieved();
		}
	}
	public static class ArchipelagoHelper
	{
		public static bool IsConnectedAndEnabled => GarfieldKartAPMod.APClient?.IsConnected ?? false;

		private static bool IsTrue(string str)
		{
			switch (str)
			{
			case "true":
			case "1":
			case "True":
				return true;
			default:
				return false;
			}
		}

		public static Kart GetLocalHumanKart()
		{
			GameManager instance = Singleton<GameManager>.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				GameMode gameMode = instance.GameMode;
				obj = ((gameMode != null) ? gameMode.Drivers : null);
			}
			if (obj == null)
			{
				return null;
			}
			foreach (Driver value in instance.GameMode.Drivers.Values)
			{
				if (value.IsHuman && value.IsLocal)
				{
					return value.Kart;
				}
			}
			return null;
		}

		public static bool IsRacing()
		{
			Kart localHumanKart = GetLocalHumanKart();
			if ((Object)(object)localHumanKart == (Object)null || ((RcVehicle)localHumanKart).IsRaceEnded())
			{
				return false;
			}
			GameManager instance = Singleton<GameManager>.Instance;
			GameMode obj = ((instance != null) ? instance.GameMode : null);
			InGameGameMode val = (InGameGameMode)(object)((obj is InGameGameMode) ? obj : null);
			if (val != null)
			{
				return val.HasRaceStarted;
			}
			return false;
		}

		public static bool IsTimeTrial()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			return (int)Singleton<GameConfigurator>.Instance.GameModeType == 4;
		}

		public static bool IsBeingAbductedByUfo(Kart kart)
		{
			object obj;
			if (kart == null)
			{
				obj = null;
			}
			else
			{
				KartBonusMgr bonusMgr = kart.GetBonusMgr();
				if (bonusMgr == null)
				{
					obj = null;
				}
				else
				{
					BonusEffectMgr bonusEffectMgr = bonusMgr.GetBonusEffectMgr();
					obj = ((bonusEffectMgr != null) ? bonusEffectMgr.GetBonusEffect((EBonusEffect)6) : null);
				}
			}
			BonusEffect val = (BonusEffect)obj;
			if ((Object)(object)val != (Object)null)
			{
				return val.Activated;
			}
			return false;
		}

		public static bool IsPuzzleRandomizationEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_puzzle_pieces"));
		}

		public static bool IsProgressiveCupsEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("progressive_cups"));
		}

		public static bool IsCharRandomizerEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_characters"));
		}

		public static bool IsKartRandomizerEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_karts"));
		}

		public static bool IsHatRandomizerEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_hats"));
		}

		public static bool IsSpoilerRandomizerEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_spoilers"));
		}

		public static bool IsItemRandomizerEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_items"));
		}

		public static bool IsRacesRandomized()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_races"), out var result);
			if ((long)result != 1)
			{
				return (long)result == 2;
			}
			return true;
		}

		public static bool IsCupsRandomized()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_races"), out var result);
			if (result != 0L)
			{
				return (long)result == 2;
			}
			return true;
		}

		public static bool IsRacesAndCupsRandomized()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("randomize_races"), out var result);
			return (long)result == 2;
		}

		public static bool IsSpringsOnly()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("springs_only"));
		}

		public static bool IsCPUItemsDisabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("disable_cpu_items"));
		}

		public static bool IsItemManiaEnabled()
		{
			return GarfieldKartAPMod.itemManiaMode.Value switch
			{
				ItemManiaMode.On => true, 
				ItemManiaMode.Off => false, 
				_ => IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("item_mania")), 
			};
		}

		public static bool IsDeathLinkEnabled()
		{
			return GarfieldKartAPMod.deathLink.Value switch
			{
				DeathLinkMode.On => true, 
				DeathLinkMode.Off => false, 
				_ => IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("death_link")), 
			};
		}

		public static long GetTrapHandling()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("trap_handling"), out var result);
			return result;
		}

		public static int GetTimeTrialRandomization()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("time_trial_randomization"), out var result);
			return result;
		}

		public static int GetTimeTrialGoalGrade()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("time_trial_goal_grade"), out var result);
			return result;
		}

		public static bool MeetsTimeTrialGoalGrade(E_TimeTrialMedal medal)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			return (int)medal >= GetTimeTrialGoalGrade() + 1;
		}

		public static E_TimeTrialMedal GetHighestRequiredMedal()
		{
			int num = GetTimeTrialRandomization();
			if (ArchipelagoGoalManager.GetGoalId() == 2)
			{
				int num2 = GetTimeTrialGoalGrade() + 1;
				if (num2 > num)
				{
					num = num2;
				}
			}
			if (num > 4)
			{
				num = 4;
			}
			return (E_TimeTrialMedal)num;
		}

		public static int GetTimeForMedal(string trackName, E_TimeTrialMedal medal)
		{
			//IL_0027: 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_003f: Expected I4, but got Unknown
			TimeTrialConfig timeToBeatFromTrack = TimeTrialConfigsContainer.GetTimeToBeatFromTrack(trackName);
			if ((Object)(object)timeToBeatFromTrack == (Object)null)
			{
				Log.Warning("[TimeTrial] No times to beat for level '" + trackName + "'");
				return 0;
			}
			return (medal - 1) switch
			{
				0 => timeToBeatFromTrack.Bronze, 
				1 => timeToBeatFromTrack.Silver, 
				2 => timeToBeatFromTrack.Gold, 
				3 => timeToBeatFromTrack.Platinium, 
				_ => 0, 
			};
		}

		public static E_TimeTrialMedal GetMedalForRaceTime(int raceTimeMs)
		{
			//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_0048: 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_00c8: 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)
			TimeTrialConfig timeToBeatFromTrack = TimeTrialConfigsContainer.GetTimeToBeatFromTrack(LoadingManager.LevelToLoad);
			if ((Object)(object)timeToBeatFromTrack == (Object)null)
			{
				Log.Warning("[TimeTrial] No times to beat for level '" + LoadingManager.LevelToLoad + "'");
				return (E_TimeTrialMedal)0;
			}
			E_TimeTrialMedal val = (E_TimeTrialMedal)0;
			if (raceTimeMs < timeToBeatFromTrack.Platinium)
			{
				val = (E_TimeTrialMedal)4;
			}
			else if (raceTimeMs <= timeToBeatFromTrack.Gold)
			{
				val = (E_TimeTrialMedal)3;
			}
			else if (raceTimeMs <= timeToBeatFromTrack.Silver)
			{
				val = (E_TimeTrialMedal)2;
			}
			else if (raceTimeMs <= timeToBeatFromTrack.Bronze)
			{
				val = (E_TimeTrialMedal)1;
			}
			Log.Message($"[TimeTrial] Ran {raceTimeMs}ms on {LoadingManager.LevelToLoad} " + $"(bronze {timeToBeatFromTrack.Bronze}, silver {timeToBeatFromTrack.Silver}, gold {timeToBeatFromTrack.Gold}, " + $"platinum {timeToBeatFromTrack.Platinium}) -> {val}");
			return val;
		}

		public static int GetCCRequirement()
		{
			int.TryParse(GarfieldKartAPMod.APClient.GetSlotDataValue("cc_requirement"), out var result);
			return result;
		}

		public static bool MeetsCCRequirement(Difficulty difficulty)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			return difficulty + 1 >= GetCCRequirement();
		}

		public static int GetPuzzlePieceCount()
		{
			string slotDataValue = GarfieldKartAPMod.APClient.GetSlotDataValue("puzzle_piece_count");
			if (int.TryParse(slotDataValue, out var result))
			{
				return result;
			}
			throw new SlotDataException("Invalid puzzle piece goal value passed from slot data: " + slotDataValue);
		}

		public static int GetRequiredPuzzlePieceCount()
		{
			string slotDataValue = GarfieldKartAPMod.APClient.GetSlotDataValue("puzzle_piece_required");
			if (!int.TryParse(slotDataValue, out var result))
			{
				throw new SlotDataException("Invalid puzzle piece required value passed from slot data: " + slotDataValue);
			}
			return (int)Math.Ceiling((double)(GetPuzzlePieceCount() * result) / 100.0);
		}

		public static bool IsLapSanityEnabled()
		{
			return IsTrue(GarfieldKartAPMod.APClient.GetSlotDataValue("lap_sanity"));
		}

		internal static int GetLapCount()
		{
			if (GarfieldKartAPMod.lapCountOverride.Value > 0)
			{
				return GarfieldKartAPMod.lapCountOverride.Value;
			}
			string slotDataValue = GarfieldKartAPMod.APClient.GetSlotDataValue("lap_count");
			if (slotDataValue == null)
			{
				return 3;
			}
			if (int.TryParse(slotDataValue, out var result))
			{
				return result;
			}
			throw new SlotDataException("Invalid lap count value passed from slot data: " + slotDataValue);
		}
	}
	internal static class ArchipelagoPopupManager
	{
		public static void ShowInfo(string message)
		{
			Show(message, (POPUP_TYPE)2);
		}

		public static void ShowWarning(string message)
		{
			Show(message, (POPUP_TYPE)3);
		}

		public static void ShowError(string message)
		{
			Show(message, (POPUP_TYPE)4);
		}

		public static void ShowRandomGarfieldQuote()
		{
			string[] gARFIELD_QUOTES = ArchipelagoConstants.GARFIELD_QUOTES;
			string text = gARFIELD_QUOTES[Random.Range(0, gARFIELD_QUOTES.Length)];
			ShowInfo("Garfield has an inspirational quote to help you!\n\n\"" + text + "\"");
		}

		private static void Show(string message, POPUP_TYPE type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PopupManager.OpenPopup(message, type, (POPUP_PRIORITY)0, (Relay)null, (Action<CLOSE_REASON>)null, 0f, (string)null);
		}
	}
	public static class ArchipelagoRaceVictory
	{
		public static void SendChecks(string track, int rank)
		{
			//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_001d: 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_0038: 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_004d: 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_00c0: 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)
			if (!ArchipelagoHelper.IsConnectedAndEnabled || string.IsNullOrEmpty(track))
			{
				return;
			}
			Difficulty difficulty = Singleton<GameConfigurator>.Instance.Difficulty;
			SendFinalLapCheck(track, rank, difficulty);
			if (rank != 0)
			{
				return;
			}
			PlayerConfig playerConfig = Singleton<GameConfigurator>.Instance.GetPlayerConfig(0);
			ECharacter character = playerConfig.Character;
			ECharacter kart = playerConfig.Kart;
			long goalId = ArchipelagoGoalManager.GetGoalId();
			if ((goalId == 0L || goalId == 1) && !ArchipelagoHelper.MeetsCCRequirement(difficulty))
			{
				Log.Message("Skipping race victory location send due to CC requirement");
			}
			else
			{
				GarfieldKartAPMod.APClient.SendLocation(ArchipelagoConstants.GetRaceVictoryLoc(track));
				ApJsonSaveFile.RecordRaceVictory(track);
			}
			foreach (long raceVictoryCCLoc in ArchipelagoConstants.GetRaceVictoryCCLocs(track, difficulty))
			{
				GarfieldKartAPMod.APClient.SendLocation(raceVictoryCCLoc);
			}
			GarfieldKartAPMod.APClient.SendLocation((long)character + 1001);
			GarfieldKartAPMod.APClient.SendLocation((long)kart + 1051);
			ArchipelagoGoalManager.CheckAndCompleteGoal();
			long hatLoc = ArchipelagoConstants.GetHatLoc(track);
			if (hatLoc != -1)
			{
				GarfieldKartAPMod.APClient.SendLocation(hatLoc);
			}
		}

		private static void SendFinalLapCheck(string track, int rank, Difficulty difficulty)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!ArchipelagoHelper.IsLapSanityEnabled())
			{
				return;
			}
			if (!ArchipelagoHelper.MeetsCCRequirement(difficulty))
			{
				Log.Message("Skipping lap sanity check due to CC requirement");
			}
			else if (rank < GarfieldKartAPMod.lapSanityPlacementRequirement.Value)
			{
				int num = ArchipelagoHelper.GetLapCount() - 1;
				long lapSanityLoc = ArchipelagoConstants.GetLapSanityLoc(track, num);
				if (lapSanityLoc != -1)
				{
					GarfieldKartAPMod.APClient.SendLocation(lapSanityLoc);
					Log.Message($"Sent final lap sanity check for {track}, lap {num + 1}");
				}
			}
		}
	}
	internal static class ArchipelagoTrapEffects
	{
		private static PostProcessVolume grayscaleVolume;

		private static bool grayscaleActive;

		private static bool mirrorAppliedByUs;

		public static void Update()
		{
			bool racing = ArchipelagoHelper.IsRacing();
			SyncMirror(ArchipelagoHelper.GetLocalHumanKart(), racing);
			SyncGrayscale(racing);
		}

		public static void OnRaceStart(Kart kart)
		{
			if (!((Object)(object)kart == (Object)null))
			{
				TryFireInstantTrap(kart, 1501L);
				TryFireInstantTrap(kart, 1504L);
			}
		}

		public static void OnMidRaceReceive(long itemId)
		{
			if ((itemId == 1501 || itemId == 1504) && ArchipelagoHelper.IsRacing())
			{
				TryFireInstantTrap(ArchipelagoHelper.GetLocalHumanKart(), itemId);
			}
		}

		public static void ClearAll()
		{
			SyncMirror(ArchipelagoHelper.GetLocalHumanKart(), racing: false);
			SyncGrayscale(racing: false);
		}

		private static void TryFireInstantTrap(Kart kart, long itemId)
		{
			if (!ArchipelagoFillerManager.IsFillerArmed(itemId))
			{
				return;
			}
			object obj;
			if (kart == null)
			{
				obj = null;
			}
			else
			{
				KartBonusMgr bonusMgr = kart.GetBonusMgr();
				obj = ((bonusMgr != null) ? bonusMgr.GetBonusEffectMgr() : null);
			}
			BonusEffectMgr val = (BonusEffectMgr)obj;
			if (val == null || !val.AreEffectsLoaded)
			{
				return;
			}
			if (itemId == 1501)
			{
				BonusEffect bonusEffect = val.GetBonusEffect((EBonusEffect)3);
				NapBonusEffect val2 = (NapBonusEffect)(object)((bonusEffect is NapBonusEffect) ? bonusEffect : null);
				if (val2 != null)
				{
					val2.Launcher = kart;
				}
				val.ActivateBonusEffect((EBonusEffect)3);
				Log.Message("[Trap] Sleep Trap put the player to sleep");
			}
			else
			{
				val.ActivateBonusEffect((EBonusEffect)7);
				Log.Message("[Trap] Bounce Trap sprung the player into the air");
			}
			ArchipelagoFillerManager.TryConsumeInstant(itemId);
		}

		private static void SyncMirror(Kart kart, bool racing)
		{
			bool flag = racing && ArchipelagoFillerManager.IsFillerActive(1500L);
			if (!flag && !mirrorAppliedByUs)
			{
				return;
			}
			object obj;
			if (kart == null)
			{
				obj = null;
			}
			else
			{
				Driver driver = kart.Driver;
				obj = ((driver != null) ? ((Component)driver).GetComponentInChildren<RcHumanController>() : null);
			}
			RcHumanController val = (RcHumanController)obj;
			if (flag)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.SetMirrorMode(true);
					mirrorAppliedByUs = true;
				}
			}
			else
			{
				if (val != null)
				{
					val.SetMirrorMode(false);
				}
				mirrorAppliedByUs = false;
			}
		}

		private static void SyncGrayscale(bool racing)
		{
			bool flag = racing && ArchipelagoFillerManager.IsFillerActive(1502L);
			if (flag != grayscaleActive)
			{
				if (flag)
				{
					EnableGrayscale();
				}
				else
				{
					DisableGrayscale();
				}
			}
		}

		private static void EnableGrayscale()
		{
			if ((Object)(object)grayscaleVolume == (Object)null)
			{
				ColorGrading val = ScriptableObject.CreateInstance<ColorGrading>();
				((ParameterOverride<bool>)(object)((PostProcessEffectSettings)val).enabled).Override(true);
				((ParameterOverride<GradingMode>)(object)val.gradingMode).Override((GradingMode)0);
				((ParameterOverride<float>)(object)val.saturation).Override(-100f);
				grayscaleVolume = PostProcessManager.instance.QuickVolume(GetPostProcessLayer(), 1000f, (PostProcessEffectSettings[])(object)new PostProcessEffectSettings[1] { (PostProcessEffectSettings)val });
				Log.Message("[Trap] Grayscale Trap enabled");
			}
			grayscaleActive = true;
		}

		private static void DisableGrayscale()
		{
			if ((Object)(object)grayscaleVolume != (Object)null)
			{
				RuntimeUtilities.DestroyVolume(grayscaleVolume, true, true);
				grayscaleVolume = null;
				Log.Message("[Trap] Grayscale Trap disabled");
			}
			grayscaleActive = false;
		}

		private static int GetPostProcessLayer()
		{
			PostProcessLayer val = Object.FindObjectOfType<PostProcessLayer>();
			if ((Object)(object)val != (Object)null)
			{
				int value = ((LayerMask)(ref val.volumeLayer)).value;
				for (int i = 0; i < 32; i++)
				{
					if ((value & (1 << i)) != 0)
					{
						return i;
					}
				}
			}
			return 0;
		}
	}
	internal static class KartSelectionWinDisplay
	{
		private const string ObjectName = "APWinMarker";

		private const string WonMark = "<color=#6BE36B>WON</color>";

		private const string NotWonMark = "<color=#8A8A8A>NOT WON</color>";

		public static void AttachOrUpdate(KartSelectionItem item)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			long winLocation = GetWinLocation(item);
			bool flag = ArchipelagoHelper.IsConnectedAndEnabled && winLocation != -1;
			TextMeshProUGUI orCreateText = GetOrCreateText(item);
			if (!((Object)(object)orCreateText == (Object)null))
			{
				((Component)orCreateText).gameObject.SetActive(flag);
				if (!flag)
				{
					Log.Message($"[WinMarker] {((Object)item).name}: hidden (type {item.Type}, location {winLocation})");
					return;
				}
				bool flag2 = ArchipelagoItemTracker.HasLocation(winLocation);
				((TMP_Text)orCreateText).text = (flag2 ? "<color=#6BE36B>WON</color>" : "<color=#8A8A8A>NOT WON</color>");
				Log.Message($"[WinMarker] {((Object)item).name}: location {winLocation}, won={flag2}");
			}
		}

		private static long GetWinLocation(KartSelectionItem item)
		{
			//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_0007: 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_000c: Invalid comparison between Unknown and I4
			//IL_0033: 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)
			KARTSELECT_TYPE type = item.Type;
			if ((int)type != 0)
			{
				if ((int)type == 1)
				{
					IconCarac iconCarac = item.IconCarac;
					KartCarac val = (KartCarac)(object)((iconCarac is KartCarac) ? iconCarac : null);
					if (val == null)
					{
						return -1L;
					}
					if (!ArchipelagoHelper.IsKartRandomizerEnabled())
					{
						return -1L;
					}
					return 1051 + (long)((DrivingCarac)val).Owner;
				}
				return -1L;
			}
			IconCarac iconCarac2 = item.IconCarac;
			CharacterCarac val2 = (CharacterCarac)(object)((iconCarac2 is CharacterCarac) ? iconCarac2 : null);
			if (val2 == null)
			{
				return -1L;
			}
			if (!ArchipelagoHelper.IsCharRandomizerEnabled())
			{
				return -1L;
			}
			return 1001 + (long)((DrivingCarac)val2).Owner;
		}

		private static TextMeshProUGUI GetOrCreateText(KartSelectionItem item)
		{
			//IL_008d: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_018d: 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_01ac: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)item).transform.Find("APWinMarker");
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).GetComponent<TextMeshProUGUI>();
			}
			TextMeshProUGUI componentInChildren = ((Component)((Component)item).transform.root).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Log.Warning("[WinMarker] No TMP label found to clone in the kart selection menu");
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, ((Component)item).transform);
			((Object)val2).name = "APWinMarker";
			val2.SetActive(true);
			val2.transform.SetAsLastSibling();
			foreach (Transform item2 in val2.transform)
			{
				Object.Destroy((Object)(object)((Component)item2).gameObject);
			}
			Component[] components = val2.GetComponents<Component>();
			foreach (Component val3 in components)
			{
				if (!(val3 is RectTransform) && !(val3 is CanvasRenderer) && !(val3 is TextMeshProUGUI))
				{
					Object.Destroy((Object)(object)val3);
				}
			}
			TextMeshProUGUI component = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).alignment = (TextAlignmentOptions)514;
			((TMP_Text)component).fontSize = 12f;
			((TMP_Text)component).enableWordWrapping = false;
			((TMP_Text)component).overflowMode = (TextOverflowModes)0;
			((Graphic)component).raycastTarget = false;
			((Graphic)component).color = Color.white;
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 0f);
			component2.pivot = new Vector2(0.5f, 0f);
			component2.anchoredPosition = new Vector2(0f, 4f);
			component2.sizeDelta = new Vector2(0f, 16f);
			((Transform)component2).localScale = Vector3.one;
			return component;
		}
	}
	public static class TrackChecksDisplay
	{
		private const string ObjectName = "APTrackChecksText";

		private const string LapsanityObjectName = "APLapsanityText";

		private const string TimeTrialObjectName = "APTimeTrialText";

		private const string FoundColor = "#6BE36B";

		private const string MissingColor = "#999999";

		private const string FoundMark = "<color=#6BE36B>Y</color>";

		private const string MissingMark = "<color=#999999>N</color>";

		private static readonly string[] MedalLabels = new string[4] { "Bronze", "Silver", "Gold", "Plat" };

		public static void AttachOrUpdate(HD_TrackSelection_Item item, string trackScene)
		{
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			bool flag = ArchipelagoHelper.IsConnectedAndEnabled && !string.IsNullOrEmpty(trackScene);
			bool flag2 = ArchipelagoHelper.IsTimeTrial();
			bool flag3 = flag && !flag2;
			TextMeshProUGUI orCreateText = GetOrCreateText(item, "APTrackChecksText", isTop: false);
			if ((Object)(object)orCreateText != (Object)null)
			{
				((Component)orCreateText).gameObject.SetActive(flag3);
				if (flag3)
				{
					((TMP_Text)orCreateText).text = BuildChecksText(trackScene);
				}
			}
			TextMeshProUGUI orCreateText2 = GetOrCreateText(item, "APLapsanityText", isTop: true);
			if ((Object)(object)orCreateText2 != (Object)null)
			{
				bool flag4 = flag3 && ArchipelagoHelper.IsLapSanityEnabled() && ArchipelagoHelper.GetLapCount() > 1;
				((Component)orCreateText2).gameObject.SetActive(flag4);
				if (flag4)
				{
					((TMP_Text)orCreateText2).text = BuildLapsanityText(trackScene);
				}
			}
			TextMeshProUGUI orCreateText3 = GetOrCreateText(item, "APTimeTrialText", isTop: true);
			if ((Object)(object)orCreateText3 != (Object)null)
			{
				bool flag5 = flag && flag2 && ArchipelagoHelper.GetTimeTrialRandomization() > 0;
				((Component)orCreateText3).gameObject.SetActive(flag5);
				if (flag5)
				{
					((TMP_Text)orCreateText3).text = BuildTimeTrialText(trackScene);
				}
			}
		}

		private static TextMeshProUGUI GetOrCreateText(HD_TrackSelection_Item item, string name, bool isTop)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: 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_01ec: 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_0166: 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_0192: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)item).transform.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).GetComponent<TextMeshProUGUI>();
			}
			TextMeshProUGUI componentInChildren = ((Component)item).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Log.Warning("No TMP text found on " + ((Object)item).name + " to clone for the checks display");
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, ((Component)item).transform);
			((Object)val2).name = name;
			val2.SetActive(true);
			foreach (Transform item2 in val2.transform)
			{
				Object.Destroy((Object)(object)((Component)item2).gameObject);
			}
			Component[] components = val2.GetComponents<Component>();
			foreach (Component val3 in components)
			{
				if (!(val3 is RectTransform) && !(val3 is CanvasRenderer) && !(val3 is TextMeshProUGUI))
				{
					Object.Destroy((Object)(object)val3);
				}
			}
			TextMeshProUGUI component = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).alignment = (TextAlignmentOptions)(isTop ? 514 : 1026);
			((TMP_Text)component).fontSize = (isTop ? 14f : 20f);
			((TMP_Text)component).enableWordWrapping = false;
			((TMP_Text)component).overflowMode = (TextOverflowModes)0;
			((Graphic)component).raycastTarget = false;
			RectTransform component2 = val2.GetComponent<RectTransform>();
			if (isTop)
			{
				component2.anchorMin = new Vector2(0f, 1f);
				component2.anchorMax = new Vector2(1f, 1f);
				component2.pivot = new Vector2(0.5f, 1f);
				component2.anchoredPosition = new Vector2(20f, -25f);
			}
			else
			{
				component2.anchorMin = new Vector2(0f, 0f);
				component2.anchorMax = new Vector2(1f, 0f);
				component2.pivot = new Vector2(0.5f, 0f);
				component2.anchoredPosition = new Vector2(30f, 20f);
			}
			component2.sizeDelta = new Vector2(0f, 24f);
			((Transform)component2).localScale = Vector3.one;
			return component;
		}

		private static string BuildChecksText(string trackScene)
		{
			long raceVictoryLoc = ArchipelagoConstants.GetRaceVictoryLoc(trackScene);
			if (raceVictoryLoc == -1)
			{
				return "";
			}
			List<string> list = new List<string> { "Win: " + Mark(raceVictoryLoc) };
			int cCRequirement = ArchipelagoHelper.GetCCRequirement();
			string[] array = new string[3] { "50cc", "100cc", "150cc" };
			for (int i = 0; i < cCRequirement && i < array.Length; i++)
			{
				long locationId = 700 + (long)i * 20L + raceVictoryLoc;
				list.Add(array[i] + ": " + Mark(locationId));
			}
			if (ArchipelagoHelper.IsHatRandomizerEnabled())
			{
				list.Add("Hat: " + Mark(ArchipelagoConstants.GetHatLoc(trackScene)));
			}
			return string.Join("\n", list);
		}

		private static string BuildLapsanityText(string trackScene)
		{
			if (!ArchipelagoHelper.IsLapSanityEnabled())
			{
				return "";
			}
			int lapCount = ArchipelagoHelper.GetLapCount();
			if (lapCount <= 1)
			{
				return "";
			}
			List<string> list = new List<string>();
			for (int i = 0; i < lapCount; i++)
			{
				long lapSanityLoc = ArchipelagoConstants.GetLapSanityLoc(trackScene, i);
				list.Add(Mark(lapSanityLoc));
			}
			return "Lapsanity\n" + string.Join("/", list);
		}

		private static string BuildTimeTrialText(string trackScene)
		{
			int timeTrialRandomization = ArchipelagoHelper.GetTimeTrialRandomization();
			List<string> list = new List<string>();
			for (int i = 1; i <= timeTrialRandomization && i <= MedalLabels.Length; i++)
			{
				long timeTrialLoc = ArchipelagoConstants.GetTimeTrialLoc(trackScene, (E_TimeTrialMedal)i);
				if (timeTrialLoc != -1)
				{
					string text = (ArchipelagoItemTracker.HasLocation(timeTrialLoc) ? "#6BE36B" : "#999999");
					list.Add("<color=" + text + ">" + MedalLabels[i - 1] + "</color>");
				}
			}
			if (list.Count == 0)
			{
				return "";
			}
			return "Time Trials\n" + string.Join("/", list);
		}

		private static string Mark(long locationId)
		{
			if (!ArchipelagoItemTracker.HasLocation(locationId))
			{
				return "<color=#999999>N</color>";
			}
			return "<color=#6BE36B>Y</color>";
		}
	}
	internal class Utils
	{
		private static readonly Random rng = new Random();

		public static void Shuffle<T>(List<T> list)
		{
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int num2 = rng.Next(num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
		}
	}
}
namespace GarfieldKartAPMod.Patches
{
	public static class ButtonHelper
	{
		public static void DisableButtonsByIndices(object buttonsArray, params int[] indices)
		{
			try
			{
				Type type = buttonsArray.GetType();
				PropertyInfo property = type.GetProperty("Length");
				PropertyInfo property2 = type.GetProperty("Item", new Type[1] { typeof(int) });
				if (property == null)
				{
					return;
				}
				int num = (int)property.GetValue(buttonsArray);
				foreach (int num2 in indices)
				{
					if (num2 < num && !(property2 == null))
					{
						object? value = property2.GetValue(buttonsArray, new object[1] { num2 });
						BetterButton val = (BetterButton)((value is BetterButton) ? value : null);
						if (!((Object)(object)val == (Object)null))
						{
							((Selectable)val).interactable = false;
							Log.Info($"Disabled button at index {num2}");
						}
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to disable buttons: {arg}");
			}
		}

		public static void DisableLockedRaceButtons(object instance, object m_buttons, int currentCupId)
		{
			try
			{
				Type type = m_buttons.GetType();
				PropertyInfo property = type.GetProperty("Length");
				if (property == null)
				{
					return;
				}
				int num = (int)property.GetValue(m_buttons);
				PropertyInfo property2 = type.GetProperty("Item", new Type[1] { typeof(int) });
				for (int i = 0; i < num; i++)
				{
					if (property2 != null)
					{
						object? value = property2.GetValue(m_buttons, new object[1] { i });
						BetterButton val = (BetterButton)((value is BetterButton) ? value : null);
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						if (i == 4)
						{
							((Component)val).gameObject.SetActive(false);
							continue;
						}
						if (!ArchipelagoItemTracker.HasRace(4 * currentCupId + i))
						{
							((Selectable)val).interactable = false;
							continue;
						}
						((Selectable)val).interactable = true;
						GkEventSystem.Current.SelectButton((Selectable)(object)val, 0);
					}
					MenuHDTrackSelection val2 = (MenuHDTrackSelection)((instance is MenuHDTrackSelection) ? instance : null);
					if (val2 != null)
					{
						val2.UpdateRacesButtons(currentCupId);
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Failed to disable race buttons: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(MenuHDMain), "Enter")]
	public class MenuHDMain_Enter_Patch
	{
		private const int GalleryButtonIndex = 3;

		private static void Postfix(MenuHDMain __instance, object ___m_buttons)
		{
			UITextureSwapper.SwapMainMenuLogo(((Component)((Component)__instance).transform.root).gameObject);
			if (ArchipelagoHelper.IsConnectedAndEnabled)
			{
				Button button = GetButton(___m_buttons, 3);
				if ((Object)(object)button != (Object)null)
				{
					UITextureSwapper.SwapGalleryButtonIcon(((Component)button).gameObject);
				}
			}
		}

		private static Button GetButton(object buttons, int index)
		{
			object? obj = (buttons?.GetType().GetMethod("get_Item", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null))?.Invoke(buttons, new object[1] { index });
			return (Button)((obj is Button) ? obj : null);
		}
	}
	[HarmonyPatch(typeof(MenuHDEngagementScreen), "Enter")]
	public class MenuHDEngagementScreen_Enter_Patch
	{
		private static void Postfix(MenuHDEngagementScreen __instance)
		{
			UITextureSwapper.SwapMainMenuLogo(((Component)((Component)__instance).transform.root).gameObject);
		}
	}
	[HarmonyPatch(typeof(MenuHDGameMode), "Enter")]
	public class MenuHDGameMode_Enter_Patch
	{
		private static void Postfix(MenuHDGameMode __instance, object ___m_buttons)
		{
			if (ArchipelagoHelper.IsConnectedAndEnabled && ArchipelagoItemTracker.GetAvailableCups().Count == 0)
			{
				ButtonHelper.DisableButtonsByIndices(___m_buttons, 1);
			}
		}
	}
	[HarmonyPatch(typeof(MenuHDGameMode), "OnSubmitChampionShip")]
	public class MenuHDModeSelect_OnSubmitChampionShip_Patch
	{
		private static bool Prefix(MenuHDGameMode __instance)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			if (ArchipelagoItemTracker.GetAvailableCups().Count != 0)
			{
				return true;
			}
			ArchipelagoPopupManager.ShowWarning("You haven't unlocked any cups!");
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuHDGameType), "Enter")]
	public class MenuHDGameType_Enter_Patch
	{
		private static void Prefix()
		{
			ArchipelagoItemTracker.ResyncFromServer();
		}

		private static void Postfix(MenuHDGameType __instance, object ___m_buttons)
		{
			if (ArchipelagoHelper.IsConnectedAndEnabled)
			{
				ButtonHelper.DisableButtonsByIndices(___m_buttons, 1, 2);
			}
		}
	}
	[HarmonyPatch(typeof(MenuHDTrackSelection), "Enter")]
	public class MenuHDTrackSelection_Enter_Patch
	{
		private static void Postfix(MenuHDTrackSelection __instance, EnumArray<TAB, BetterToggle> ___m_tabs, object ___m_buttons, ref int ___m_currentChampionshipIndex)
		{
			Log.Message("Track Selection Menu opened");
			ArchipelagoItemTracker.ResyncFromServer();
			if (ArchipelagoHelper.IsConnectedAndEnabled)
			{
				if (ArchipelagoHelper.IsPuzzleRandomizationEnabled())
				{
					UITextureSwapper.ResetSwapFlag();
					UITextureSwapper.SwapPuzzlePieceIcons(((Component)__instance).gameObject);
				}
				int num = SetupCupTabs(___m_tabs, ___m_currentChampionshipIndex);
				if (num != -1)
				{
					___m_currentChampionshipIndex = num;
				}
				ButtonHelper.DisableLockedRaceButtons(__instance, ___m_buttons, (num != -1) ? num : ___m_currentChampionshipIndex);
			}
		}

		private static int SetupCupTabs(EnumArray<TAB, BetterToggle> tabs, int currentChampionshipId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			int num = -1;
			E_GameModeType gameModeType = Singleton<GameConfigurator>.Instance.GameModeType;
			for (int i = 0; i < tabs.Length; i++)
			{
				bool flag = false;
				bool flag2 = ArchipelagoItemTracker.HasRaceInCup(i);
				if ((int)gameModeType == 3 && ArchipelagoItemTracker.CanAccessCup(i))
				{
					flag = true;
				}
				else if ((int)gameModeType == 2 && flag2)
				{
					flag = true;
				}
				else if ((int)gameModeType == 4 && flag2)
				{
					flag = true;
				}
				if (!flag)
				{
					((Component)tabs[i]).gameObject.SetActive(false);
					continue;
				}
				if (num == -1)
				{
					GkEventSystem.Current.SelectTab((Toggle)(object)tabs[i], 0);
					num = i;
				}
				((Component)tabs[i]).gameObject.SetActive(true);
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(MenuHDTrackSelection), "OnSelectChampionship")]
	public class MenuHDTrackSelection_OnSelectChampionship_Patch
	{
		private static void Postfix(MenuHDTrackSelection __instance, object ___m_buttons, int iId)
		{
			ButtonHelper.DisableLockedRaceButtons(__instance, ___m_buttons, iId);
		}
	}
	[HarmonyPatch(typeof(MenuHDTrackSelection), "UpdateRacesButtons")]
	public class MenuHDTrackSelection_UpdateRacesButtons_Patch
	{
		private static bool Prefix(MenuHDTrackSelection __instance, int cup, List<HD_TrackSelection_Item> ___m_itemsButtons, int ___m_maxPuzzleNumber, int ___m_currentSelectedButton, bool ___m_hasFinishedEntering, TextMeshProUGUI ___m_textCupCircuit)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				return true;
			}
			for (int i = 0; i < ___m_itemsButtons.Count - 1; i++)
			{
				___m_itemsButtons[i].ChangeBackground(PlayerGameEntities.ChampionShipDataList[cup].Sprites[i]);
				string text = Singleton<GameConfigurator>.Instance.ChampionShipData.Tracks[i];
				int puzzlePieceCount = ArchipelagoItemTracker.GetPuzzlePieceCount(text);
				___m_itemsButtons[i].UpdatePuzzleText(puzzlePieceCount);
				___m_itemsButtons[i].UpdateTimeTrialText(text);
			}
			if (___m_currentSelectedButton != 4 && ___m_hasFinishedEntering)
			{
				AccessTools.Method(typeof(MenuHDTrackSelection), "UpdateTimeTrialValues", (Type[])null, (Type[])null).Invoke(__instance, new object[1] { ___m_currentSelectedButton });
			}
			if (___m_currentSelectedButton < Singleton<GameConfigurator>.Instance.ChampionShipData.TracksName.Length)
			{
				((TMP_Text)___m_textCupCircuit).text = Singleton<GameConfigurator>.Instance.ChampionShipData.ChampionShipName + " - " + Singleton<GameConfigurator>.Instance.ChampionShipData.TracksName[___m_currentSelectedButton];
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuHDTrackSelection), "UpdateRacesButtons")]
	public class MenuHDTrackSelection_UpdateRacesButtons_ChecksDisplay_Patch
	{
		private static void Postfix(List<HD_TrackSelection_Item> ___m_itemsButtons)
		{
			string[] tracks = Singleton<GameConfigurator>.Instance.ChampionShipData.Tracks;
			for (int i = 0; i < ___m_itemsButtons.Count - 1 && i < tracks.Length; i++)
			{
				TrackChecksDisplay.AttachOrUpdate(___m_itemsButtons[i], tracks[i]);
			}
		}
	}
	[HarmonyPatch(typeof(MenuHDTrackPresentation), "InitPuzzlePieces")]
	public class MenuHDTrackPresentation_InitPuzzlePieces_Patch
	{
		private static bool Prefix(Image[] puzzlePiecesImages, string trackName, bool isTimeTrial)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			if (!ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				return true;
			}
			if (GkNetMgr.Instance.IsConnected)
			{
				((Component)((Component)puzzlePiecesImages[0]).transform.parent).gameObject.SetActive(false);
				return false;
			}
			((Component)((Component)puzzlePiecesImages[0]).transform.parent).gameObject.SetActive(true);
			for (int i = 0; i < puzzlePiecesImages.Length; i++)
			{
				((Component)puzzlePiecesImages[i]).gameObject.SetActive(!isTimeTrial);
				bool flag = ArchipelagoItemTracker.HasLocation(ArchipelagoConstants.GetPuzzlePieceLoc(trackName, i));
				puzzlePiecesImages[i].sprite = (flag ? UITextureSwapper.puzzlePieceFilledSprite : UITextureSwapper.puzzlePieceEmptySprite);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(GkEventSystem), "OnSecondaryMove")]
	public class GkEventSystem_OnSecondaryMove_Patch
	{
		private static Exception Finalizer(Exception __exception)
		{
			if (!(__exception is InvalidCastException))
			{
				return __exception;
			}
			Log.Debug("Suppressed InvalidCastException in OnSecondaryMove (navigating to disabled tab)");
			return null;
		}
	}
	[HarmonyPatch(typeof(RcRace), "StartRace")]
	public class RcRace_StartRace_Patch
	{
		private static void Prefix(RcRace __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if (ArchipelagoHelper.IsConnectedAndEnabled && (int)Singleton<GameConfigurator>.Instance.GameModeType != 4)
			{
				int lapCount = ArchipelagoHelper.GetLapCount();
				__instance.SetRaceNbLap(lapCount);
			}
		}
	}
	[HarmonyPatch(typeof(RcVehicleRaceStats), "CrossStartLine")]
	public class RcVehicleRaceStats_CrossStartLine_Patch
	{
		private static void Prefix(int ___m_iNbLapCompleted, ref int __state)
		{
			__state = ___m_iNbLapCompleted;
		}

		private static void Postfix(RcVehicleRaceStats __instance, int ___m_iNbLapCompleted, RcVehicle ___m_pVehicle, int __state)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Log.Debug($"{__instance.GetRank()} RANK");
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoHelper.IsLapSanityEnabled() || (int)Singleton<GameConfigurator>.Instance.GameModeType == 4 || ___m_iNbLapCompleted < __state + 1 || ___m_pVehicle.IsAutoPilot() || (int)___m_pVehicle.m_eControlType == 1)
			{
				return;
			}
			if (!ArchipelagoHelper.MeetsCCRequirement(Singleton<GameConfigurator>.Instance.Difficulty))
			{
				Log.Message("Skipping lap sanity check due to CC requirement");
			}
			else if (__instance.GetRank() < GarfieldKartAPMod.lapSanityPlacementRequirement.Value)
			{
				string startScene = Singleton<GameConfigurator>.Instance.StartScene;
				int num = ___m_iNbLapCompleted - 2;
				long lapSanityLoc = ArchipelagoConstants.GetLapSanityLoc(startScene, num);
				if (lapSanityLoc != -1)
				{
					GarfieldKartAPMod.APClient.SendLocation(lapSanityLoc);
					Log.Message($"Sent lap sanity check for {startScene}, lap {num + 1}");
				}
			}
		}
	}
	[HarmonyPatch(typeof(Kart), "StartRace")]
	public class Kart_StartRace_Patch
	{
		private static void Prefix(Kart __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if (ArchipelagoHelper.IsConnectedAndEnabled && (int)Singleton<GameConfigurator>.Instance.GameModeType != 4)
			{
				Driver driver = __instance.Driver;
				if (!((Object)(object)driver == (Object)null) && driver.IsHuman && driver.IsLocal)
				{
					ArchipelagoFillerManager.OnRaceStart();
					ArchipelagoFillerEffects.TryApplyStartBoost(__instance);
					ArchipelagoTrapEffects.OnRaceStart(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Kart), "UpdateDriftState")]
	public class Kart_UpdateDriftState_Patch
	{
		private static readonly FieldRef<Kart, float> BoostChargedRef = AccessTools.FieldRefAccess<Kart, float>("m_boostAmountCharged");

		private static void Prefix(Kart __instance)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoFillerManager.IsFillerActive(1503L))
			{
				return;
			}
			Driver driver = __instance.Driver;
			if (!((Object)(object)driver == (Object)null) && driver.IsHuman && driver.IsLocal)
			{
				float num = __instance.FirstBoostThreshold - 0.01f;
				if (BoostChargedRef.Invoke(__instance) > num)
				{
					BoostChargedRef.Invoke(__instance) = num;
				}
			}
		}
	}
	[HarmonyPatch(typeof(RaceGameState), "OnLocalHumanDriverRaceEnded")]
	public class RaceGameState_OnLocalHumanDriverRaceEnded_Patch
	{
		private static void Postfix(RcVehicle pVehicle)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			if (ArchipelagoHelper.IsConnectedAndEnabled && (int)Singleton<GameConfigurator>.Instance.GameModeType != 4)
			{
				ArchipelagoFillerEffects.TryShowGarfieldQuote();
				ArchipelagoFillerManager.OnRaceEnd((Object)(object)((pVehicle != null) ? pVehicle.RaceStats : null) != (Object)null && pVehicle.RaceStats.GetRank() == 0);
				ArchipelagoTrapEffects.ClearAll();
			}
		}
	}
	public static class DrivingCaracStatsRando
	{
		private static readonly string[] CharacterNames = new string[8] { "Garfield", "Jon", "Liz", "Odie", "Arlene", "Nermal", "Squeak", "Harry" };

		private static readonly string[] KartNames = new string[8] { "Formula Zzzz", "Abstract-Kart", "Medi-Kart", "Woof-Mobile", "Kissy-Kart", "Cutie-Pie Cat", "Rat-Racer", "Muck-Madness" };

		private const float StatMin = -25f;

		private const float StatMax = 25f;

		public static void ApplyAll()
		{
			//IL_00a8: 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)
			Log.Info($"[StatsRando] ApplyAll called. Connected={ArchipelagoHelper.IsConnectedAndEnabled}");
			if (!ArchipelagoHelper.IsConnectedAndEnabled || GarfieldKartAPMod.disableStatRandomization.Value || GarfieldKartAPMod.sessionSlotData == null || !GarfieldKartAPMod.sessionSlotData.TryGetValue("randomized_stats", out var value))
			{
				return;
			}
			JObject val = (JObject)(((value is JObject) ? value : null) ?? ((value is Dictionary<string, object> dictionary) ? JObject.FromObject((object)dictionary) : null));
			if (val == null)
			{
				return;
			}
			JToken obj = val["karts"];
			JObject val2 = (JObject)(object)((obj is JObject) ? obj : null);
			JToken obj2 = val["characters"];
			JObject val3 = (JObject)(object)((obj2 is JObject) ? obj2 : null);
			foreach (CharacterCarac character in PlayerGameEntities.CharacterList)
			{
				string name = GetName(((DrivingCarac)character).Owner, CharacterNames);
				JToken obj3 = ((val3 != null) ? val3[name] : null);
				JObject val4 = (JObject)(object)((obj3 is JObject) ? obj3 : null);
				if (val4 != null)
				{
					ApplyStats((DrivingCarac)(object)character, val4);
				}
			}
			foreach (KartCarac kart in PlayerGameEntities.KartList)
			{
				string name2 = GetName(((DrivingCarac)kart).Owner, KartNames);
				JToken obj4 = ((val2 != null) ? val2[name2] : null);
				JObject val5 = (JObject)(object)((obj4 is JObject) ? obj4 : null);
				if (val5 != null)
				{
					ApplyStats((DrivingCarac)(object)kart, val5);
				}
			}
		}

		private unsafe static string GetName(ECharacter owner, string[] names)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			int num = (int)owner;
			if (num < 0 || num >= names.Length)
			{
				return ((object)(*(ECharacter*)(&owner))/*cast due to .constrained prefix*/).ToString();
			}
			return names[num];
		}

		private static void ApplyStats(DrivingCarac instance, JObject stats)
		{
			if (stats["Speed"] != null)
			{
				instance.Speed = Mathf.Clamp(Extensions.Value<float>((IEnumerable<JToken>)stats["Speed"]), -25f, 25f);
			}
			if (stats["Acceleration"] != null)
			{
				instance.Acceleration = Mathf.Clamp(Extensions.Value<float>((IEnumerable<JToken>)stats["Acceleration"]), -25f, 25f);
			}
			if (stats["Maniability"] != null)
			{
				instance.Maniability = Mathf.Clamp(Extensions.Value<float>((IEnumerable<JToken>)stats["Maniability"]), -25f, 25f);
			}
			Log.Info($"[StatsRando] {((Object)instance).name}: spd={instance.Speed:F2} acc={instance.Acceleration:F2} man={instance.Maniability:F2}");
		}
	}
	[HarmonyPatch(typeof(KartBonusMgr), "SetItem")]
	public class KartBonusMgr_SetItem_Patch
	{
		private static bool Prefix(KartBonusMgr __instance, Kart ___m_kart, ref BonusCategory bonus, ref int iQuantity, int byPassSlot = -1, bool isFromCheat = false)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected I4, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected I4, but got Unknown
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			if (isFromCheat)
			{
				return true;
			}
			if (!___m_kart.Driver.IsHuman)
			{
				if (ArchipelagoHelper.IsItemManiaEnabled())
				{
					iQuantity = 3;
				}
				if (ArchipelagoHelper.IsCPUItemsDisabled())
				{
					return false;
				}
				if (GarfieldKartAPMod.strictCpuItems.Value)
				{
					return ArchipelagoItemTracker.HasBonusAvailable(bonus);
				}
				return true;
			}
			if (ArchipelagoHelper.IsSpringsOnly())
			{
				bonus = (BonusCategory)3;
				return FinishItemRoll(__instance, ___m_kart, bonus);
			}
			if (ArchipelagoHelper.IsItemRandomizerEnabled())
			{
				List<BonusCategory> list = GetNeededItemsanityBonuses().Where(ArchipelagoItemTracker.HasBonusAvailable).ToList();
				if (list.Count > 0)
				{
					bonus = (BonusCategory)(int)list[Random.Range(0, list.Count)];
				}
				else if (!ArchipelagoItemTracker.HasBonusAvailable(bonus))
				{
					List<BonusCategory> availableItemsanityBonuses = GetAvailableItemsanityBonuses();
					if (availableItemsanityBonuses.Count > 0 && Random.value <= 0.5f)
					{
						bonus = (BonusCategory)(int)availableItemsanityBonuses[Random.Range(0, availableItemsanityBonuses.Count)];
					}
				}
			}
			if (ArchipelagoHelper.IsPuzzleRandomizationEnabled() && ArchipelagoItemTracker.HasBonusAvailable((BonusCategory)3) && ArchipelagoItemTracker.GetPuzzlePieceCount(Singleton<GameConfigurator>.Instance.StartScene) < 3 && Random.value < 0.5f)
			{
				bonus = (BonusCategory)3;
			}
			return FinishItemRoll(__instance, ___m_kart, bonus);
		}

		private static bool FinishItemRoll(KartBonusMgr bonusMgr, Kart kart, BonusCategory bonus)
		{
			//IL_0000: 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_0049: 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)
			if (ArchipelagoItemTracker.HasBonusAvailable(bonus))
			{
				return true;
			}
			((RcVehicleSnd)kart.KartSound).PlaySound(10, false);
			HUDBonusHD hUDBonus = bonusMgr.HUDBonus;
			if ((Object)(object)hUDBonus != (Object)null)
			{
				int num = -1;
				for (int i = 0; i < 2; i++)
				{
					if ((int)bonusMgr.GetItem(i) == 0)
					{
						num = i;
						break;
					}
				}
				if (num >= 0)
				{
					hUDBonus.StartAnimation(num, bonus);
					((MonoBehaviour)kart).StartCoroutine(ClearLockedItemSlot(bonusMgr, hUDBonus, num, bonus));
				}
			}
			return false;
		}

		private static IEnumerator ClearLockedItemSlot(KartBonusMgr bonusMgr, HUDBonusHD hud, int slot, BonusCategory bonus)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			while ((int)hud.Slots[slot].State != 0)
			{
				yield return null;
			}
			yield return (object)new WaitForSeconds(0.4f);
			if ((int)bonusMgr.GetItem(slot) == 0 && hud.Slots[slot].WantedBonus == bonus)
			{
				if (slot == 0)
				{
					hud.ResetSlots();
				}
				else
				{
					hud.ResetSlot2();
				}
			}
		}

		private static List<BonusCategory> GetAvailableItemsanityBonuses()
		{
			//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_0029: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			List<BonusCategory> list = new List<BonusCategory>();
			foreach (BonusCategory value in Enum.GetValues(typeof(BonusCategory)))
			{
				if ((int)value != 0 && ArchipelagoItemTracker.HasBonusAvailable(value))
				{
					list.Add(value);
				}
			}
			return list;
		}

		private static List<BonusCategory> GetNeededItemsanityBonuses()
		{
			List<BonusCategory> list = new List<BonusCategory>();
			if (!ArchipelagoItemTracker.HasLocation(1101L))
			{
				list.Add((BonusCategory)1);
			}
			if (!ArchipelagoItemTracker.HasLocation(1102L))
			{
				list.Add((BonusCategory)2);
			}
			if (!ArchipelagoItemTracker.HasLocation(1103L))
			{
				list.Add((BonusCategory)5);
			}
			if (!ArchipelagoItemTracker.HasLocation(1104L))
			{
				list.Add((BonusCategory)9);
			}
			if (!ArchipelagoItemTracker.HasLocation(1105L))
			{
				list.Add((BonusCategory)8);
			}
			if (!ArchipelagoItemTracker.HasLocation(1106L))
			{
				list.Add((BonusCategory)4);
			}
			if (!ArchipelagoItemTracker.HasLocation(1107L))
			{
				list.Add((BonusCategory)6);
			}
			if (!ArchipelagoItemTracker.HasLocation(1108L))
			{
				list.Add((BonusCategory)7);
			}
			if (!ArchipelagoItemTracker.HasLocation(1109L))
			{
				list.Add((BonusCategory)3);
			}
			return list;
		}

		private static void Postfix(KartBonusMgr __instance, Kart ___m_kart, BonusCategory bonus)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected I4, but got Unknown
			if (ArchipelagoHelper.IsConnectedAndEnabled && ___m_kart.Driver.IsHuman && !((RcVehicle)___m_kart).IsAutoPilot() && ArchipelagoItemTracker.HasBonusAvailable(bonus))
			{
				switch (bonus - 1)
				{
				case 0:
					GarfieldKartAPMod.APClient.SendLocation(1101L);
					break;
				case 1:
					GarfieldKartAPMod.APClient.SendLocation(1102L);
					break;
				case 3:
					GarfieldKartAPMod.APClient.SendLocation(1106L);
					break;
				case 2:
					GarfieldKartAPMod.APClient.SendLocation(1109L);
					break;
				case 4:
					GarfieldKartAPMod.APClient.SendLocation(1103L);
					break;
				case 8:
					GarfieldKartAPMod.APClient.SendLocation(1104L);
					break;
				case 6:
					GarfieldKartAPMod.APClient.SendLocation(1108L);
					break;
				case 7:
					GarfieldKartAPMod.APClient.SendLocation(1105L);
					break;
				case 5:
					GarfieldKartAPMod.APClient.SendLocation(1107L);
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(GkRacingAI), "ActivateBonus")]
	public class GkRacingAI_ActivateBonus_Patch
	{
		private static void Postfix(GkRacingAI __instance, Kart pKart)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (ArchipelagoHelper.IsConnectedAndEnabled && ArchipelagoHelper.IsItemManiaEnabled() && pKart.Driver.IsAi && (int)pKart.GetBonusMgr().GetItem(0) != 0)
			{
				((MonoBehaviour)pKart).StartCoroutine(FireNextItem(__instance, pKart));
			}
		}

		private static IEnumerator FireNextItem(GkRacingAI ai, Kart pKart)
		{
			yield return (object)new WaitForSeconds(2f);
			if ((int)pKart.GetBonusMgr().GetItem(0) != 0)
			{
				ai.ActivateBonus(pKart, Random.value < 0.5f);
			}
		}
	}
	[HarmonyPatch(typeof(RacePuzzlePiece), "DoTrigger")]
	public class RacePuzzlePiece_DoTrigger_Patch
	{
		private static void Postfix(RacePuzzlePiece __instance, RcVehicle pVehicle)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (ArchipelagoHelper.IsConnectedAndEnabled && Object.op_Implicit((Object)(object)pVehicle) && (int)pVehicle.GetControlType() == 0)
			{
				long puzzlePieceLoc = ArchipelagoConstants.GetPuzzlePieceLoc(Singleton<GameConfigurator>.Instance.StartScene, __instance.Index);
				GarfieldKartAPMod.APClient.SendLocation(puzzlePieceLoc);
				Log.Message($"Sending Puzzle Piece {Singleton<GameConfigurator>.Instance.StartScene}_{__instance.Index}");
			}
		}
	}
	[HarmonyPatch(typeof(RacePuzzlePiece), "Awake")]
	public class RacePuzzlePiece_Awake_Patch
	{
		private static void Postfix(RacePuzzlePiece __instance)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				return;
			}
			((Component)__instance).GetComponent<Renderer>().materials[0] = null;
			if (ArchipelagoItemTracker.HasLocation(ArchipelagoConstants.GetPuzzlePieceLoc(Singleton<GameConfigurator>.Instance.StartScene, __instance.Index)))
			{
				Material[] materials = ((Component)__instance).GetComponent<Renderer>().materials;
				if (materials.Length == 1)
				{
					materials[0] = __instance.TransparentMaterial;
				}
				((Component)__instance).GetComponent<Renderer>().materials = materials;
			}
		}
	}
	[HarmonyPatch(typeof(HUDPositionHD), "TakePuzzlePiece")]
	public class HUDPositionHD_TakePuzzlePiece_Patch
	{
		private static bool Prefix(HUDPositionHD __instance, int iIndex, List<Animation> ___m_puzzlesAnimation, List<Image> ___m_puzzleImages, int ___m_iLogPuzzle)
		{
			if ((iIndex < 0 || iIndex >= 3) ? true : false)
			{
				return false;
			}
			bool flag = true;
			for (int i = 0; i < 2; i++)
			{
				if (i != iIndex && !ArchipelagoItemTracker.HasLocation(ArchipelagoConstants.GetPuzzlePieceLoc(Singleton<GameConfigurator>.Instance.StartScene, i)))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				foreach (Animation item in ___m_puzzlesAnimation)
				{
					item.Play("PuzzlePiece_Turn");
				}
			}
			else if ((Object)(object)___m_puzzlesAnimation[iIndex] != (Object)null)
			{
				___m_puzzlesAnimation[iIndex].Play("PuzzlePiece_Turn");
			}
			if ((Object)(object)___m_puzzleImages[iIndex] == (Object)null)
			{
				return false;
			}
			___m_puzzleImages[iIndex].sprite = UITextureSwapper.puzzlePieceFilledSprite;
			if (LogManager.Instance != null)
			{
				___m_iLogPuzzle++;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(GameSaveManager), "IsPuzzlePieceUnlocked")]
	public class GameSaveManager_IsPuzzlePieceUnlocked_Patch
	{
		private static bool Prefix(GameSaveManager __instance, string piece, Dictionary<string, bool> ___m_puzzlePieces, ref bool __result)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				return true;
			}
			string[] array = piece.Split(new char[1] { '_' });
			int.TryParse(array[1], out var result);
			__result = ArchipelagoItemTracker.HasLocation(ArchipelagoConstants.GetPuzzlePieceLoc(array[0], result));
			return false;
		}
	}
	[HarmonyPatch(typeof(HD_TrackSelection_Item), "UpdatePuzzleText")]
	public class HD_TrackSelection_Item_UpdatePuzzleText_Patch
	{
		private static bool Prefix(HD_TrackSelection_Item __instance, int value, TextMeshProUGUI ___m_puzzleText, GameObject ___m_boardPuzzle, GameObject ___m_boardPuzzleFull, int ___m_maxPuzzleValue)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled || !ArchipelagoHelper.IsPuzzleRandomizationEnabled())
			{
				return true;
			}
			((TMP_Text)___m_puzzleText).text = $"{value}/{___m_maxPuzzleValue}";
			if (value == ___m_maxPuzzleValue)
			{
				if (___m_boardPuzzle.activeSelf)
				{
					___m_boardPuzzle.SetActive(false);
				}
				___m_boardPuzzleFull.SetActive(true);
			}
			else
			{
				if (___m_boardPuzzleFull.activeSelf)
				{
					___m_boardPuzzleFull.SetActive(false);
				}
				___m_boardPuzzle.SetActive(true);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuHDGallery), "Enter")]
	public class MenuHDGallery_Enter_Patch
	{
		private static void Postfix(MenuHDGallery __instance, TextMeshProUGUI ___m_titleLabel, Canvas ___m_listCanvas, GameObject ___m_submitButton, InfoBox ___m_infoBox)
		{
			ApGalleryMenu.Refresh(__instance, ___m_titleLabel, ___m_listCanvas, ___m_submitButton, ___m_infoBox);
		}
	}
	[HarmonyPatch(typeof(KartSelectionNavigation), "Enter")]
	public class KartSelectionNavigation_Enter_Patch
	{
		private static bool Prefix(KartSelectionNavigation __instance, EnumArray<KARTSELECT_TYPE, KartSelectionItem[]> ___m_items)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			DrivingCaracStatsRando.ApplyAll();
			UpdateCharacterUnlocks(__instance, ___m_items);
			UpdateKartUnlocks(__instance, ___m_items);
			return true;
		}

		private static void Postfix(KartSelectionNavigation __instance, EnumArray<KARTSELECT_TYPE, KartSelectionItem[]> ___m_items, EnumArray<KARTSELECT_TYPE, KartSelectionItem> ___m_selectedItems)
		{
			if (ArchipelagoHelper.IsConnectedAndEnabled)
			{
				ForceUnlockedSelection(__instance, ___m_items, ___m_selectedItems, (KARTSELECT_TYPE)0);
				ForceUnlockedSelection(__instance, ___m_items, ___m_selectedItems, (KARTSELECT_TYPE)1);
			}
		}

		private static void ForceUnlockedSelection(KartSelectionNavigation navigation, EnumArray<KARTSELECT_TYPE, KartSelectionItem[]> items, EnumArray<KARTSELECT_TYPE, KartSelectionItem> selectedItems, KARTSELECT_TYPE type)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_007f: 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 (items == null || selectedItems == null)
			{
				return;
			}
			KartSelectionItem val = selectedItems[(int)type];
			if (!((Object)(object)val != (Object)null) || val.Locked)
			{
				KartSelectionItem val2 = items[(int)type]?.FirstOrDefault((Func<KartSelectionItem, bool>)((KartSelectionItem item) => (Object)(object)item != (Object)null && !item.Locked && ((Component)item).gameObject.activeSelf));
				if ((Object)(object)val2 == (Object)null)
				{
					Log.Warning($"[KartSelect] Selected {type} is locked and there's no unlocked one to fall back to");
					return;
				}
				navigation.OnChangeSelectedItem(val2);
				Log.Message($"[KartSelect] Selected {type} was locked, switched to {((Object)val2.IconCarac).name}");
			}
		}

		private static void UpdateCharacterUnlocks(KartSelectionNavigation instance, EnumArray<KARTSELECT_TYPE, KartSelectionItem[]> items)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//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_0078: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			if (items == null)
			{
				return;
			}
			MethodInfo method = ((object)items).GetType().GetMethod("get_Item", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
			if (!(method == null))
			{
				KartSelectionItem[] array = (KartSelectionItem[])method.Invoke(items, new object[1] { 0 });
				foreach (KartSelectionItem val in array)
				{
					CharacterCarac val2 = (CharacterCarac)val.IconCarac;
					UnlockableItemSate characterState = Singleton<GameSaveManager>.Instance.GetCharacterState(((DrivingCarac)val2).Owner);
					bool flag = characterState - 3 <= 1;
					bool flag2 = flag;
					val.SetLock(!flag2);
					KartSelectionWinDisplay.AttachOrUpdate(val);
				}
			}
		}

		private static void UpdateKartUnlocks(KartSelectionNavigation instance, EnumArray<KARTSELECT_TYPE, KartSelectionItem[]> items)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0075: 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_007a: Invalid comparison between Unknown and I4
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			if (items == null)
			{
				return;
			}
			MethodInfo method = ((object)items).GetType().GetMethod("get_Item", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
			if (!(method == null))
			{
				KartSelectionItem[] array = (KartSelectionItem[])method.Invoke(items, new object[1] { 1 });
				foreach (KartSelectionItem obj in array)
				{
					KartCarac val = (KartCarac)obj.IconCarac;
					UnlockableItemSate kartState = Singleton<GameSaveManager>.Instance.GetKartState(((DrivingCarac)val).Owner);
					bool flag = (int)kartState == 4 || (int)kartState == 3;
					obj.SetLock(!flag);
					KartSelectionWinDisplay.AttachOrUpdate(obj);
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameSaveManager), "GetCharacterState")]
	public class GameSaveManager_GetCharacterState_Patch
	{
		private static bool Prefix(GameSaveManager __instance, ECharacter character, ref UnlockableItemSate __result)
		{
			//IL_002a: 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)
			bool flag = ArchipelagoHelper.IsCharRandomizerEnabled();
			Log.Info($"{flag} CHARACTER RANDO CHECK");
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			long num = 301 + (long)character;
			Log.Info($"{character}, {num}");
			__result = (UnlockableItemSate)((ArchipelagoItemTracker.HasItem(num) || !flag) ? 4 : 2);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameSaveManager), "GetKartState")]
	public class GameSaveManager_GetKartState_Patch
	{
		private static bool Prefix(GameSaveManager __instance, ECharacter kart, ref UnlockableItemSate __result)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ArchipelagoHelper.IsKartRandomizerEnabled();
			Log.Info($"{flag} KART RANDO CHECK");
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			long itemId = 351 + (long)kart;
			__result = (UnlockableItemSate)((ArchipelagoItemTracker.HasItem(itemId) || !flag) ? 4 : 2);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameSaveManager), "GetHatState")]
	public class GameSaveManager_GetHatState_Patch
	{
		private static bool Prefix(GameSaveManager __instance, string hat, ref UnlockableItemSate __result)
		{
			if (!ArchipelagoHelper.IsHatRandomizerEnabled() || !ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			long hatItemId = ArchipelagoConstants.GetHatItemId(hat);
			__result = (UnlockableItemSate)(ArchipelagoItemTracker.HasItem(hatItemId) ? 4 : 2);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameSaveManager), "GetCustomState")]
	public class GameSaveManager_GetCustomState_Patch
	{
		private static bool Prefix(GameSaveManager __instance, string custom, ref UnlockableItemSate __result)
		{
			if (!ArchipelagoHelper.IsSpoilerRandomizerEnabled() || !ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return true;
			}
			long spoilerItemId = ArchipelagoConstants.GetSpoilerItemId(custom);
			__result = (UnlockableItemSate)(ArchipelagoItemTracker.HasItem(spoilerItemId) ? 4 : 2);
			return false;
		}
	}
	[HarmonyPatch(typeof(Localization), "Get")]
	public class Localization_Get_Patch
	{
		private static void Postfix(string key, ref string __result)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			switch (key)
			{
			case "MENU_GARAGE_UNLOCK_SINGLE_RACE":
				if (ArchipelagoHelper.IsHatRandomizerEnabled())
				{
					__result = "You must be sent the Archipelago item for this hat!";
				}
				break;
			case "MENU_GARAGE_UNLOCK_GRAND_PRIX":
				Log.Info($"Grand Prix {ArchipelagoHelper.IsSpoilerRandomizerEnabled()}");
				if (ArchipelagoHelper.IsSpoilerRandomizerEnabled())
				{
					__result = "You must be sent the Archipelago item for this spoiler!";
				}
				break;
			case "MENU_GARAGE_UNLOCK_TIME_TRIAL":
				if (ArchipelagoHelper.IsHatRandomizerEnabled())
				{
					__result = "";
				}
				break;
			case "MENU_GARAGE_UNLOCK_OR":
				if (ArchipelagoHelper.IsHatRandomizerEnabled())
				{
					__result = "";
				}
				break;
			case "MENU_MAIN_GALLERY":
				__result = "Archipelago";
				break;
			}
		}
	}
	[HarmonyPatch(typeof(RcVehicle), "OnStartFallState")]
	public class RcVehicle_OnStartFallState_Patch
	{
		private static void Postfix(RcVehicle __instance)
		{
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			Kart val = (Kart)(object)((__instance is Kart) ? __instance : null);
			if (val != null)
			{
				Driver driver = val.Driver;
				if (!((Object)(object)driver == (Object)null) && driver.IsHuman && driver.IsLocal)
				{
					DeathLinkManager.OnLocalPlayerFell();
				}
			}
		}
	}
	[HarmonyPatch(typeof(RewardManager), "EarnReward")]
	public class RewardManager_EarnReward_Patch
	{
		private static void Postfix(RewardManager __instance, string track, int rank = 0, E_TimeTrialMedal medal = (E_TimeTrialMedal)0, float diffTime = 0f, int nbFirstPlace = 0, int cup = 0)
		{
			//IL_000d: 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_0014: Invalid comparison between Unknown and I4
			//IL_001e: Invalid comparison between Unknown and I4
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			E_GameModeType gameModeType = Singleton<GameConfigurator>.Instance.GameModeType;
			if ((int)gameModeType == 2)
			{
				ArchipelagoRaceVictory.SendChecks(track, rank);
			}
			if ((int)gameModeType != 3 || nbFirstPlace != 4)
			{
				return;
			}
			foreach (long spoilerLoc in ArchipelagoConstants.GetSpoilerLocs(cup))
			{
				GarfieldKartAPMod.APClient.SendLocation(spoilerLoc);
			}
		}
	}
	[HarmonyPatch(typeof(HUDPositionHD), "InitTimeTrial")]
	public class HUDPositionHD_InitTimeTrial_Patch
	{
		private static void Postfix(ref int ___m_raceTimeToBeat, ref int ___m_lapTimeToBeat, Image ___m_timeToBeatMedal, TextMeshProUGUI ___m_timeToBeatTimeLabel)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected I4, but got Unknown
			if (!ArchipelagoHelper.IsConnectedAndEnabled)
			{
				return;
			}
			E_TimeTrialMedal highestRequiredMedal = ArchipelagoHelper.GetHighestRequiredMedal();
			if ((int)highestRequiredMedal != 0)
			{
				int timeForMedal = ArchipelagoHelper.GetTimeForMedal(Singleton<GameConfigurator>.Instance.StartScene, highestRequiredMedal);
				if (timeForMedal > 0)
				{
					___m_raceTimeToBeat = timeForMedal;
					___m_lapTimeToBeat = timeForMedal / 3;
					___m_timeToBeatMedal.sprite = ((EnumArray<E_TimeTrialMedal, Sprite>)(object)UISprites.MedalIcons)[(int)highestRequiredMedal];
					((TMP_Text)___m_timeToBeatTimeLabel).text = TimeSpanExtensions.FormatRaceTime(TimeSpan.FromMilliseconds(timeForMedal));
				}
			}
		}
	}
	[HarmonyPatch(typeof(TimeTrialGameMode), "OnLocalHumanDriverRaceEnded")]
	public class TimeTrialGameMode_OnLocalHumanDriverRaceEnded_Patch
	{
		private static void Postfix(RcVehicle pVehicle)
		{
			//IL_0033: 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_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_009a: Unknown result type (might be due to invalid IL or missing references)
			if (!ArchipelagoHelper.IsConnectedAndEnabled || (Object)(object)((pVehicle != null) ? pVehicle.RaceStats : null) == (Object)null)
			{
				return;
			}
			string startScene = Singleton<GameConfigurator>.Instance.StartScene;
			E_TimeTrialMedal medalForRaceTime = ArchipelagoHelper.GetMedalForRaceTime(pVehicle.RaceStats.GetRaceTime());
			if ((int)medalForRaceTime == 0)
			{
				return;
			}
			foreach (long timeTrialLoc in ArchipelagoConstants.GetTimeTrialLocs(startScene, medalForRaceTime))
			{
				GarfieldKartAPMod.APClient.SendLocation(timeTrialLoc);
			}
			long hatLoc = ArchipelagoConstants.GetHatLoc(startScene);
			if (hatLoc != -1)
			{
				GarfieldKartAPMod.APClient.SendLocation(hatLoc);
			}
			if (ArchipelagoGoalManager.GetGoalId() != 2 || ArchipelagoHelper.MeetsTimeTrialGoalGrade(medalForRaceTime))
			{
				ApJsonSaveFile.RecordTimeTrialVictory(startScene);
				ArchipelagoGoalManager.CheckAndCompleteGoal();
			}
		}
	}
	[HarmonyPatch(typeof(ChampionShipGameMode), "OnLocalHumanDriverRaceEnded")]
	public class ChampionShipGameMode_OnLocalHumanDriverRaceEnded_Patch
	{
		private static void Postfix(RcVehicle pVehicle)
		{
			if (ArchipelagoHelper.IsConnectedAndEnabled && !((Object)(object)((pVehicle != null) ? pVehicle.RaceStats : null) == (Object)null))
			{
				ArchipelagoRaceVictory.SendChecks(Singleton<GameConfigurator>.Instance.StartScene, pVehicle.RaceStats.GetRank());
			}
		}
	}
	[HarmonyPatch(typeof(RewardManager), "EndChampionShip")]
	public class RewardManager_EndChampionShip_Patch
	{
		private static void Postfix(RewardManager __instance, int pFinalRank, int pNbFirstPlace, bool save)
		{
			if (ArchipelagoHelper.IsConnectedAndEnabled && pFinalRank == 0)
			{
				SendCupVictoryLocation();
				ArchipelagoGoalManager.CheckAndCompleteGoal();
			}
		}

		private static void SendCupVictoryLocation()
		{
			//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_007e: 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)
			string championShipNameId = Singleton<GameConfigurator>.Instance.ChampionShipData.ChampionShipNameId;
			Difficulty difficulty = Singleton<GameConfigurator>.Instance.Difficulty;
			int num = championShipNameId switch
			{
				"CHAMPIONSHIP_NAME_1" => 0, 
				"CHAMPIONSHIP_NAME_2" => 1, 
				"CHAMPIONSHIP_NAME_3" => 2, 
				"CHAMPIONSHIP_NAME_4" => 3, 
				_ => -1, 
			};
			if (num == -1)
			{
				return;
			}
			long goalId = ArchipelagoGoalManager.GetGoalId();
			if ((goalId == 0L || goalId == 1) && !ArchipelagoHelper.MeetsCCRequirement(difficulty))
			{
				Log.Message("Skipping cup victory location send due to CC requirement");
			}
			else
			{
				GarfieldKartAPMod.APClient.SendLocation(ArchipelagoConstants.GetCupVictoryLoc(num));
				ApJsonSaveFile.RecordCupVictory(num);
			}
			foreach (long cupVictoryCCLoc in ArchipelagoConstants.GetCupVictoryCCLocs(num, difficulty))
			{
				GarfieldKartAPMod.APClient.SendLocation(cupVictoryCCLoc);
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}