using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using HarmonyLib;
using Il2Cpp;
using Il2CppFishNet;
using Il2CppFishNet.Broadcast;
using Il2CppFishNet.Connection;
using Il2CppFishNet.Managing;
using Il2CppFishNet.Managing.Client;
using Il2CppFishNet.Managing.Object;
using Il2CppFishNet.Managing.Server;
using Il2CppFishNet.Managing.Transporting;
using Il2CppFishNet.Object;
using Il2CppFishNet.Serializing;
using Il2CppFishNet.Transporting;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne;
using Il2CppScheduleOne.AvatarFramework;
using Il2CppScheduleOne.AvatarFramework.Animation;
using Il2CppScheduleOne.AvatarFramework.Customization;
using Il2CppScheduleOne.AvatarFramework.Equipping;
using Il2CppScheduleOne.Building;
using Il2CppScheduleOne.Calling;
using Il2CppScheduleOne.Cartel;
using Il2CppScheduleOne.Casino;
using Il2CppScheduleOne.Clothing;
using Il2CppScheduleOne.Combat;
using Il2CppScheduleOne.Core.Equipping.Framework;
using Il2CppScheduleOne.Core.Items.Framework;
using Il2CppScheduleOne.Cutscenes;
using Il2CppScheduleOne.Delivery;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.Dialogue;
using Il2CppScheduleOne.Doors;
using Il2CppScheduleOne.Economy;
using Il2CppScheduleOne.Effects;
using Il2CppScheduleOne.Effects.MixMaps;
using Il2CppScheduleOne.Employees;
using Il2CppScheduleOne.EntityFramework;
using Il2CppScheduleOne.Equipping;
using Il2CppScheduleOne.Equipping.Framework;
using Il2CppScheduleOne.GameTime;
using Il2CppScheduleOne.Graffiti;
using Il2CppScheduleOne.Growing;
using Il2CppScheduleOne.Interaction;
using Il2CppScheduleOne.ItemFramework;
using Il2CppScheduleOne.Law;
using Il2CppScheduleOne.Levelling;
using Il2CppScheduleOne.Management;
using Il2CppScheduleOne.Map;
using Il2CppScheduleOne.Messaging;
using Il2CppScheduleOne.Misc;
using Il2CppScheduleOne.Money;
using Il2CppScheduleOne.NPCs;
using Il2CppScheduleOne.NPCs.Actions;
using Il2CppScheduleOne.NPCs.Behaviour;
using Il2CppScheduleOne.NPCs.Framework;
using Il2CppScheduleOne.NPCs.Other;
using Il2CppScheduleOne.NPCs.Relation;
using Il2CppScheduleOne.NPCs.Responses;
using Il2CppScheduleOne.NPCs.Schedules;
using Il2CppScheduleOne.Noise;
using Il2CppScheduleOne.ObjectScripts;
using Il2CppScheduleOne.Persistence;
using Il2CppScheduleOne.Persistence.Datas;
using Il2CppScheduleOne.Persistence.Loaders;
using Il2CppScheduleOne.PlayerScripts;
using Il2CppScheduleOne.PlayerScripts.Health;
using Il2CppScheduleOne.Police;
using Il2CppScheduleOne.Product;
using Il2CppScheduleOne.Product.Packaging;
using Il2CppScheduleOne.Property;
using Il2CppScheduleOne.Quests;
using Il2CppScheduleOne.ScriptableObjects;
using Il2CppScheduleOne.StationFramework;
using Il2CppScheduleOne.Storage;
using Il2CppScheduleOne.TV;
using Il2CppScheduleOne.Tiles;
using Il2CppScheduleOne.Tools;
using Il2CppScheduleOne.Trash;
using Il2CppScheduleOne.UI;
using Il2CppScheduleOne.UI.Items;
using Il2CppScheduleOne.UI.MainMenu;
using Il2CppScheduleOne.UI.Phone;
using Il2CppScheduleOne.UI.Phone.ContactsApp;
using Il2CppScheduleOne.UI.Phone.Delivery;
using Il2CppScheduleOne.UI.Phone.Map;
using Il2CppScheduleOne.UI.Phone.Messages;
using Il2CppScheduleOne.UI.Phone.ProductManagerApp;
using Il2CppScheduleOne.UI.Relations;
using Il2CppScheduleOne.UI.Shop;
using Il2CppScheduleOne.UI.Stations;
using Il2CppScheduleOne.UI.WorldspacePopup;
using Il2CppScheduleOne.Variables;
using Il2CppScheduleOne.Vehicles;
using Il2CppScheduleOne.Vehicles.Modification;
using Il2CppScheduleOne.Vision;
using Il2CppScheduleOne.VoiceOver;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using S1API;
using S1API.AssetBundles;
using S1API.Avatar;
using S1API.Building;
using S1API.Casino;
using S1API.Conditions;
using S1API.Console;
using S1API.Cutscenes;
using S1API.DeadDrops;
using S1API.Deliveries;
using S1API.Dialogues;
using S1API.Economy;
using S1API.Entities;
using S1API.Entities.Actions;
using S1API.Entities.Appearances.AccessoryFields;
using S1API.Entities.Appearances.Base;
using S1API.Entities.Appearances.BodyLayerFields;
using S1API.Entities.Appearances.CustomizationFields;
using S1API.Entities.Appearances.FaceLayerFields;
using S1API.Entities.Behaviour;
using S1API.Entities.Customer;
using S1API.Entities.Dealer;
using S1API.Entities.Dialogue;
using S1API.Entities.Equippables;
using S1API.Entities.Impostors;
using S1API.Entities.Interfaces;
using S1API.Entities.Relation;
using S1API.Entities.Schedule;
using S1API.Entities.Supplier;
using S1API.Entities.Voices;
using S1API.GameTime;
using S1API.Graffiti;
using S1API.Growing;
using S1API.Internal;
using S1API.Internal.Abstraction;
using S1API.Internal.Console;
using S1API.Internal.Cutscenes;
using S1API.Internal.Deliveries;
using S1API.Internal.Diagnostics;
using S1API.Internal.Entities;
using S1API.Internal.Entities.Suppliers;
using S1API.Internal.Items;
using S1API.Internal.Lifecycle;
using S1API.Internal.Map;
using S1API.Internal.NPCWorkbench;
using S1API.Internal.Patches;
using S1API.Internal.Phone;
using S1API.Internal.Products;
using S1API.Internal.Properties;
using S1API.Internal.Rendering;
using S1API.Internal.Shops;
using S1API.Internal.Utils;
using S1API.Items;
using S1API.Items.Additive;
using S1API.Items.Buildable;
using S1API.Items.Clothing;
using S1API.Items.Quality;
using S1API.Items.Storable;
using S1API.Law;
using S1API.Leveling;
using S1API.Lifecycle;
using S1API.Logging;
using S1API.Map;
using S1API.Map.Buildings;
using S1API.Map.DeliveryLocations;
using S1API.Messaging;
using S1API.Money;
using S1API.PhoneApp;
using S1API.PhoneCalls;
using S1API.PhoneCalls.Constants;
using S1API.Products;
using S1API.Products.Packaging;
using S1API.Properties;
using S1API.Properties.Interfaces;
using S1API.Properties.Tokens;
using S1API.Property;
using S1API.Quests;
using S1API.Quests.Constants;
using S1API.Quests.Identifiers;
using S1API.Rendering;
using S1API.Saveables;
using S1API.Shops;
using S1API.Stations;
using S1API.Storage;
using S1API.Storages;
using S1API.TVApp;
using S1API.Trash;
using S1API.Utils;
using S1API.Vehicles;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("S1API.Tests")]
[assembly: InternalsVisibleTo("S1API.CustomProductLifecycleSmoke")]
[assembly: MelonInfo(typeof(global::S1API.S1API), "S1API (Forked by Bars)", "3.1.8", "KaBooMa", null)]
[assembly: MelonPriority(int.MinValue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ifBars")]
[assembly: AssemblyConfiguration("Il2CppMelon")]
[assembly: AssemblyDescription("A Schedule One Mono / Il2Cpp Cross Compatibility Layer (Forked from the original S1API by Kabooma)")]
[assembly: AssemblyFileVersion("3.1.8.0")]
[assembly: AssemblyInformationalVersion("3.1.8+445586c624144aaaaf08ada54621558064b0ab7a")]
[assembly: AssemblyProduct("S1API")]
[assembly: AssemblyTitle("S1API")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ifBars/S1API")]
[assembly: AssemblyVersion("3.1.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[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;
		}
	}
}
public class ClickHandler
{
	private readonly UnityAction _callback;

	public ClickHandler(UnityAction callback)
	{
		_callback = callback;
	}

	public void OnClick()
	{
		_callback.Invoke();
	}
}
namespace S1API
{
	public class S1API : MelonMod
	{
		public override void OnInitializeMelon()
		{
			S1APIPreferences.Initialize();
			MelonPreferences_Entry<bool>? enableUnityNullReferenceTraceLogging = S1APIPreferences.EnableUnityNullReferenceTraceLogging;
			if (enableUnityNullReferenceTraceLogging != null && enableUnityNullReferenceTraceLogging.Value)
			{
				MelonLogger.Warning("Exception trace logging is enabled. If you are not a mod developer, you probably do not need this enabled.");
				UnityExceptionTraceHook.Install();
			}
		}

		public override void OnDeinitializeMelon()
		{
			NPCWorkbenchRuntime.Close();
			PresentationWorkbenchRuntime.Close();
			ProductPackagingContentRuntime.ResetForSceneChange();
			CutsceneManager.Deinitialize();
			MapPOIManager.RemoveAll();
			UnityExceptionTraceHook.Remove();
		}

		public override void OnUpdate()
		{
			PresentationWorkbenchRuntime.Tick();
			CutsceneManager.Tick(Time.unscaledDeltaTime);
			NPCWorkbenchRuntime.Tick();
		}

		public override void OnGUI()
		{
			CutsceneManager.DrawPresentation();
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			if (sceneName == "Main")
			{
				GameLifecycle.Initialize();
			}
		}

		public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
		{
			NPCWorkbenchRuntime.Close();
			PresentationWorkbenchRuntime.Close();
			CutsceneManager.CleanupForSceneChange();
			SceneStateCleaner.ResetForSceneChange(sceneName, afterUnload: true);
			if (sceneName == "Main" || sceneName == "Tutorial")
			{
				ProductPackagingContentRuntime.ResetForSceneChange();
				MapPOIManager.ResetForSceneChange();
			}
			if (sceneName == "Main")
			{
				GameLifecycle.Reset();
			}
		}

		public override void OnSceneWasInitialized(int buildIndex, string sceneName)
		{
			NPCNetworkBootstrap.EnsurePrefabsWarmup();
			SceneStateCleaner.ResetForSceneChange(sceneName, afterUnload: false);
		}
	}
}
namespace S1API.Vehicles
{
	public class LandVehicle
	{
		internal LandVehicle S1LandVehicle = null;

		internal bool _isDeferredByName = false;

		internal StorageInstance? _storage;

		private static readonly Log _logger = new Log("S1API.LandVehicle");

		private static readonly FieldInfo? VehiclePriceField = typeof(LandVehicle).GetField("vehiclePrice", BindingFlags.NonPublic);

		private NetworkConnection? _conn;

		private string _guid = string.Empty;

		public float VehiclePrice
		{
			get
			{
				return S1LandVehicle.VehiclePrice;
			}
			set
			{
				VehiclePriceField?.SetValue(S1LandVehicle, value);
			}
		}

		public float TopSpeed
		{
			get
			{
				return S1LandVehicle.TopSpeed;
			}
			set
			{
				S1LandVehicle.TopSpeed = value;
			}
		}

		public bool IsPlayerOwned
		{
			get
			{
				return S1LandVehicle.IsPlayerOwned;
			}
			set
			{
				SetIsPlayerOwned(value);
			}
		}

		public bool IsOccupied
		{
			get
			{
				return S1LandVehicle.IsOccupied;
			}
			set
			{
				S1LandVehicle.IsOccupied = value;
			}
		}

		public VehicleColor Color
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (VehicleColor)S1LandVehicle.OwnedColor;
			}
			set
			{
				SetColor(value);
			}
		}

		public string GUID => _guid;

		public StorageInstance? Storage => _storage;

		public event Action OnVehicleStart
		{
			add
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onVehicleStart += Action.op_Implicit(value);
			}
			remove
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onVehicleStart -= Action.op_Implicit(value);
			}
		}

		public event Action OnVehicleStop
		{
			add
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onVehicleStop += Action.op_Implicit(value);
			}
			remove
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onVehicleStop -= Action.op_Implicit(value);
			}
		}

		public event Action OnHandbrakeApplied
		{
			add
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onHandbrakeApplied += Action.op_Implicit(value);
			}
			remove
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onHandbrakeApplied -= Action.op_Implicit(value);
			}
		}

		public event Action<Collision> OnCollision
		{
			add
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onCollision += Action<Collision>.op_Implicit(value);
			}
			remove
			{
				LandVehicle s1LandVehicle = S1LandVehicle;
				s1LandVehicle.onCollision -= Action<Collision>.op_Implicit(value);
			}
		}

		public LandVehicle(string vehicleCode)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			LandVehicle vehiclePrefab = NetworkSingleton<VehicleManager>.Instance.GetVehiclePrefab(vehicleCode);
			if ((Object)(object)vehiclePrefab == (Object)null)
			{
				_logger.Error("SpawnVehicle: '" + vehicleCode + "' is not a valid vehicle code!");
				return;
			}
			LandVehicle component = Object.Instantiate<GameObject>(((Component)vehiclePrefab).gameObject).GetComponent<LandVehicle>();
			component.SetGUID(GUIDManager.GenerateUniqueGUID());
			NetworkSingleton<VehicleManager>.Instance.AllVehicles.Add(component);
			S1LandVehicle = component;
			SetConnection();
			UpdateGuidFromGame();
			_storage = new StorageInstance(component.Storage);
		}

		public void Spawn(Vector3 position, Quaternion rotation)
		{
			//IL_0046: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			if (!InstanceFinder.IsServer)
			{
				_logger.Warning("Spawn can only be called on the server!");
				return;
			}
			if ((Object)(object)S1LandVehicle == (Object)null)
			{
				throw new Exception("Unable to spawn vehicle, S1LandVehicle is null!");
			}
			((Component)S1LandVehicle).transform.position = position;
			((Component)S1LandVehicle).transform.rotation = rotation;
			((NetworkBehaviour)NetworkSingleton<VehicleManager>.Instance).Spawn(((Component)S1LandVehicle).gameObject, (NetworkConnection)null, default(Scene));
		}

		public void AlignTo(Transform target, ParkingAlignment type, bool network = false)
		{
			if ((Object)(object)S1LandVehicle == (Object)null)
			{
				throw new Exception("Unable to align to position, S1LandVehicle is null!");
			}
			S1LandVehicle.AlignTo(target, (EParkingAlignment)type, network);
		}

		public void ExitPark(bool moveToExitPoint = true)
		{
			S1LandVehicle.ExitPark(moveToExitPoint);
		}

		public void SetVisible(bool vis)
		{
			S1LandVehicle.SetVisible(vis);
		}

		public void DestroyVehichle()
		{
			S1LandVehicle.DestroyVehicle();
		}

		public void ApplyColor(VehicleColor col)
		{
			S1LandVehicle.ApplyColor((EVehicleColor)col);
		}

		public void Park(ParkingData parkData, bool network)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			ParkData val = new ParkData
			{
				lotGUID = Guid.Parse(parkData.LotId),
				spotIndex = parkData.Index,
				alignment = (EParkingAlignment)parkData.Alignment
			};
			S1LandVehicle.Park(_conn, val, network);
		}

		internal LandVehicle(LandVehicle landVehicle)
		{
			S1LandVehicle = landVehicle;
			SetConnection();
			UpdateGuidFromGame();
			_storage = new StorageInstance(landVehicle.Storage);
			_isDeferredByName = false;
		}

		internal LandVehicle(string vehicleName, bool isDeferred)
		{
			_isDeferredByName = isDeferred;
		}

		private void SetConnection()
		{
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if (networkManager.IsClientOnly)
			{
				NetworkConnection connection = InstanceFinder.ClientManager.Connection;
				if (connection != (NetworkConnection)null && connection.IsValid)
				{
					_conn = connection;
				}
			}
			else if (networkManager.IsServerOnly || (networkManager.IsServer && !networkManager.IsClient))
			{
				NetworkConnection owner = ((NetworkBehaviour)S1LandVehicle).Owner;
				if (owner != (NetworkConnection)null && owner.IsValid)
				{
					_conn = owner;
				}
			}
		}

		private void SetIsPlayerOwned(bool isPlayerOwned)
		{
			S1LandVehicle.SetIsPlayerOwned(_conn, isPlayerOwned);
			if (isPlayerOwned)
			{
				NetworkSingleton<VehicleManager>.Instance.PlayerOwnedVehicles.Add(S1LandVehicle);
			}
			else
			{
				NetworkSingleton<VehicleManager>.Instance.PlayerOwnedVehicles.Remove(S1LandVehicle);
			}
		}

		private void SetColor(VehicleColor color)
		{
			MethodInfo method = typeof(LandVehicle).GetMethod("SetOwnedColor", BindingFlags.Instance | BindingFlags.NonPublic);
			if (method == null)
			{
				_logger.Error("SetOwnedColor method not found!");
				return;
			}
			method.Invoke(S1LandVehicle, new object[2]
			{
				_conn,
				(object)(EVehicleColor)color
			});
		}

		private void UpdateGuidFromGame()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			try
			{
				PropertyInfo property = typeof(LandVehicle).GetProperty("GUID", BindingFlags.Instance | BindingFlags.Public);
				if (!(property == null))
				{
					_guid = ((object)(Guid)(property.GetValue(S1LandVehicle) ?? ((object)default(Guid)))/*cast due to .constrained prefix*/).ToString();
				}
			}
			catch
			{
			}
		}
	}
	public enum ParkingAlignment
	{
		FrontToKerb,
		RearToKerb
	}
	public enum VehicleColor
	{
		Black,
		DarkGrey,
		LightGrey,
		White,
		Yellow,
		Orange,
		Red,
		DullRed,
		Pink,
		Purple,
		Navy,
		DarkBlue,
		LightBlue,
		Cyan,
		LightGreen,
		DarkGreen,
		Custom
	}
	public static class VehicleRegistry
	{
		private static readonly Dictionary<object, LandVehicle> _cache = new Dictionary<object, LandVehicle>();

		public static LandVehicle[] GetAll()
		{
			try
			{
				List<LandVehicle> allVehicles = NetworkSingleton<VehicleManager>.Instance.AllVehicles;
				if (allVehicles == null)
				{
					return Array.Empty<LandVehicle>();
				}
				List<LandVehicle> list = new List<LandVehicle>();
				Enumerator<LandVehicle> enumerator = allVehicles.GetEnumerator();
				while (enumerator.MoveNext())
				{
					LandVehicle current = enumerator.Current;
					if ((Object)(object)current != (Object)null)
					{
						LandVehicle landVehicle = Wrap(current);
						if (landVehicle != null)
						{
							list.Add(landVehicle);
						}
					}
				}
				return list.ToArray();
			}
			catch
			{
				return Array.Empty<LandVehicle>();
			}
		}

		public static LandVehicle? GetByGUID(string guid)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			try
			{
				Guid val = default(Guid);
				((Guid)(ref val))..ctor(guid);
				LandVehicle val2 = GUIDManager.GetObject<LandVehicle>(val);
				if ((Object)(object)val2 == (Object)null)
				{
					return null;
				}
				return Wrap(val2);
			}
			catch
			{
				return null;
			}
		}

		public static LandVehicle? GetByName(string gameObjectName)
		{
			if (string.IsNullOrEmpty(gameObjectName))
			{
				return null;
			}
			try
			{
				GameObject val = GameObject.Find(gameObjectName);
				if ((Object)(object)val != (Object)null)
				{
					LandVehicle component = val.GetComponent<LandVehicle>();
					if ((Object)(object)component != (Object)null)
					{
						return Wrap(component);
					}
				}
				List<LandVehicle> allVehicles = NetworkSingleton<VehicleManager>.Instance.AllVehicles;
				if (allVehicles != null)
				{
					for (int i = 0; i < allVehicles.Count; i++)
					{
						LandVehicle val2 = allVehicles[i];
						if ((Object)(object)val2 != (Object)null && ((Object)((Component)val2).gameObject).name == gameObjectName)
						{
							return Wrap(val2);
						}
					}
				}
				if (DeferredMapResolver.IsMenuScene())
				{
					LandVehicle deferredVehicle = new LandVehicle(gameObjectName, isDeferred: true);
					DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(gameObjectName, delegate(object resolved)
					{
						if (resolved is LandVehicle landVehicle && landVehicle != null && (Object)(object)landVehicle.S1LandVehicle != (Object)null)
						{
							deferredVehicle.S1LandVehicle = landVehicle.S1LandVehicle;
							deferredVehicle._isDeferredByName = false;
						}
					}));
					return deferredVehicle;
				}
				return null;
			}
			catch
			{
				return null;
			}
		}

		public static LandVehicle? CreateVehicle(string vehicleCode)
		{
			if (!string.IsNullOrEmpty(vehicleCode))
			{
				try
				{
					return new LandVehicle(vehicleCode);
				}
				catch
				{
					return null;
				}
			}
			return null;
		}

		public static void RemoveVehicle(string guidString)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(guidString))
			{
				return;
			}
			VehicleManager instance = NetworkSingleton<VehicleManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Guid val = default(Guid);
			((Guid)(ref val))..ctor(guidString);
			int? num = null;
			LandVehicle val2 = null;
			List<LandVehicle> allVehicles = instance.AllVehicles;
			Guid gUID;
			if (allVehicles != null)
			{
				for (int i = 0; i < allVehicles.Count; i++)
				{
					LandVehicle obj = allVehicles[i];
					if (obj != null)
					{
						gUID = obj.GUID;
						if (((Guid)(ref gUID)).Equals(val))
						{
							num = i;
							val2 = allVehicles[i];
							break;
						}
					}
				}
			}
			int? num2 = null;
			List<LandVehicle> playerOwnedVehicles = instance.PlayerOwnedVehicles;
			if (playerOwnedVehicles != null)
			{
				for (int j = 0; j < playerOwnedVehicles.Count; j++)
				{
					LandVehicle obj2 = playerOwnedVehicles[j];
					if (obj2 != null)
					{
						gUID = obj2.GUID;
						if (((Guid)(ref gUID)).Equals(val))
						{
							num2 = j;
							break;
						}
					}
				}
			}
			if (num.HasValue)
			{
				allVehicles?.RemoveAt(num.Value);
			}
			if (num2.HasValue)
			{
				playerOwnedVehicles?.RemoveAt(num2.Value);
			}
			if ((Object)(object)val2 != (Object)null && _cache.ContainsKey(val2))
			{
				_cache.Remove(val2);
			}
		}

		private static LandVehicle? Wrap(LandVehicle? veh)
		{
			if ((Object)(object)veh == (Object)null)
			{
				return null;
			}
			if (_cache.TryGetValue(veh, out LandVehicle value))
			{
				return value;
			}
			LandVehicle landVehicle = new LandVehicle(veh);
			_cache[veh] = landVehicle;
			return landVehicle;
		}
	}
}
namespace S1API.Utils
{
	public static class ArrayExtensions
	{
		public static T[] AddItemToArray<T>(this T[]? array, T item)
		{
			return global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray(array, item);
		}

		public static Il2CppReferenceArray<T> AddItemToArray<T>(this Il2CppReferenceArray<T>? array, params T[]? itemsToAdd) where T : Object
		{
			return global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray(array, itemsToAdd);
		}
	}
	public static class ButtonUtils
	{
		public static void AddListener(Button button, Action action)
		{
			global::S1API.Internal.Utils.ButtonUtils.AddListener(button, action);
		}

		public static void RemoveListener(Button button, Action action)
		{
			global::S1API.Internal.Utils.ButtonUtils.RemoveListener(button, action);
		}

		public static void ClearListeners(Button button)
		{
			global::S1API.Internal.Utils.ButtonUtils.ClearListeners(button);
		}

		public static void Enable(Button button, Text? label = null, string? text = null)
		{
			global::S1API.Internal.Utils.ButtonUtils.Enable(button, label, text);
		}

		public static void Disable(Button button, Text? label = null, string? text = null)
		{
			global::S1API.Internal.Utils.ButtonUtils.Disable(button, label, text);
		}

		public static void SetLabel(Text label, string text)
		{
			global::S1API.Internal.Utils.ButtonUtils.SetLabel(label, text);
		}

		public static void SetStyle(Button button, Text label, string text, Color bg)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			global::S1API.Internal.Utils.ButtonUtils.SetStyle(button, label, text, bg);
		}
	}
	public static class ColorUtils
	{
		public static Color ToColor(this uint hexColor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return global::S1API.Internal.Utils.ColorUtils.ToColorInternal(hexColor);
		}
	}
	public static class EventHelper
	{
		internal static void AddListener(Action listener, Action<Action> subscribe)
		{
			global::S1API.Internal.Abstraction.EventHelper.AddListener(listener, subscribe);
		}

		internal static void RemoveListener(Action listener, Action<Action> unsubscribe)
		{
			global::S1API.Internal.Abstraction.EventHelper.RemoveListener(listener, unsubscribe);
		}

		public static void AddListener(Action listener, UnityEvent unityEvent)
		{
			global::S1API.Internal.Abstraction.EventHelper.AddListener(listener, unityEvent);
		}

		public static void RemoveListener(Action listener, UnityEvent unityEvent)
		{
			global::S1API.Internal.Abstraction.EventHelper.RemoveListener(listener, unityEvent);
		}

		public static void AddListener<T>(Action<T> listener, UnityEvent<T> unityEvent)
		{
			global::S1API.Internal.Abstraction.EventHelper.AddListener(listener, unityEvent);
		}

		public static void RemoveListener<T>(Action<T> listener, UnityEvent<T> unityEvent)
		{
			global::S1API.Internal.Abstraction.EventHelper.RemoveListener(listener, unityEvent);
		}

		public static void AddEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action listener)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			global::S1API.Internal.Abstraction.EventHelper.AddEventTrigger(trigger, eventType, listener);
		}

		public static void AddEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action<BaseEventData> listener)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			global::S1API.Internal.Abstraction.EventHelper.AddEventTrigger(trigger, eventType, listener);
		}

		public static void RemoveEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action<BaseEventData> listener)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			global::S1API.Internal.Abstraction.EventHelper.RemoveEventTrigger(trigger, eventType, listener);
		}
	}
	public static class ImageUtils
	{
		public static Sprite? LoadImage(string fileName)
		{
			return global::S1API.Internal.Utils.ImageUtils.LoadImage(fileName);
		}

		public static Sprite? LoadImageRaw(byte[] data)
		{
			return global::S1API.Internal.Utils.ImageUtils.LoadImageRaw(data);
		}

		public static Sprite? TextureToSprite(Texture2D? texture, float pixelsPerUnit = 100f)
		{
			return global::S1API.Internal.Utils.ImageUtils.TextureToSprite(texture, pixelsPerUnit);
		}

		public static Sprite? LoadImageFromResource(Assembly assembly, string resourceName, float pixelsPerUnit = 100f, FilterMode filterMode = (FilterMode)1)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return global::S1API.Internal.Utils.ImageUtils.LoadImageFromResource(assembly, resourceName, pixelsPerUnit, filterMode);
		}
	}
	public static class RandomUtils
	{
		public static T PickOne<T>(this IList<T> list)
		{
			return global::S1API.Internal.Utils.RandomUtils.PickOne(list);
		}

		public static T PickUnique<T>(this IList<T> list, Func<T, bool> isDuplicate, int maxTries = 10)
		{
			return global::S1API.Internal.Utils.RandomUtils.PickUnique(list, isDuplicate, maxTries);
		}

		public static List<T> PickMany<T>(this IList<T> list, int count)
		{
			return global::S1API.Internal.Utils.RandomUtils.PickMany(list, count);
		}

		public static int RangeInt(int minInclusive, int maxExclusive)
		{
			return global::S1API.Internal.Utils.RandomUtils.RangeInt(minInclusive, maxExclusive);
		}
	}
	public static class ReflectionUtils
	{
		public static MethodInfo? GetMethod(Type? type, string methodName, BindingFlags bindingFlags)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetMethod(type, methodName, bindingFlags);
		}

		public static bool IsValueTuple(this object obj)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.IsValueTuple(obj);
		}

		public static object?[]? GetValueTupleItems(this object obj)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetValueTupleItems(obj);
		}

		public static bool TrySetFieldOrProperty(object target, string memberName, object? value)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(target, memberName, value);
		}

		public static object? TryGetFieldOrProperty(object target, string memberName)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(target, memberName);
		}
	}
	public static class ToggleUtils
	{
		public static void AddListener(Toggle toggle, Action<bool> listener)
		{
			global::S1API.Internal.Utils.ToggleUtils.AddListener(toggle, listener);
		}

		public static void RemoveListener(Toggle toggle, Action<bool> listener)
		{
			global::S1API.Internal.Utils.ToggleUtils.RemoveListener(toggle, listener);
		}

		public static void ClearListeners(Toggle toggle)
		{
			global::S1API.Internal.Utils.ToggleUtils.ClearListeners(toggle);
		}

		public static void SetGraphic(Toggle toggle, Graphic graphic)
		{
			global::S1API.Internal.Utils.ToggleUtils.SetGraphic(toggle, graphic);
		}

		public static Graphic? GetGraphic(Toggle toggle)
		{
			return global::S1API.Internal.Utils.ToggleUtils.GetGraphic(toggle);
		}
	}
	public static class TransformUtils
	{
		public static Transform? FindDescendant(Transform root, string name)
		{
			return global::S1API.Internal.Utils.TransformUtils.FindDescendant(root, name);
		}
	}
}
namespace S1API.UI
{
	public static class CharacterCreatorManager
	{
		private static readonly Log Logger = new Log("CharacterCreatorManager");

		private static CharacterCreator? _s1Creator;

		private static bool _isInitialized;

		private static bool _eventsRegistered;

		public static bool IsOpen
		{
			get
			{
				EnsureInitialized();
				CharacterCreator? s1Creator = _s1Creator;
				return s1Creator != null && s1Creator.IsOpen;
			}
		}

		public static BasicAvatarSettings? ActiveSettings
		{
			get
			{
				EnsureInitialized();
				CharacterCreator? s1Creator = _s1Creator;
				if ((Object)(object)((s1Creator != null) ? s1Creator.ActiveSettings : null) == (Object)null)
				{
					return null;
				}
				return new BasicAvatarSettings(_s1Creator.ActiveSettings);
			}
		}

		public static event Action? OnOpened;

		public static event Action? OnClosed;

		public static event Action<BasicAvatarSettings>? OnCompleted;

		public static void Open(BasicAvatarSettings? initialSettings = null, bool showUI = true)
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Error("CharacterCreator singleton is not available");
				return;
			}
			if (_s1Creator.IsOpen)
			{
				Logger.Warning("CharacterCreator is already open");
				return;
			}
			RegisterEvents();
			if (initialSettings == null)
			{
				initialSettings = GetPlayerAvatarSettings();
			}
			BasicAvatarSettings val = initialSettings?.S1BasicAvatarSettings;
			_s1Creator.Open(val);
			if (!showUI && (Object)(object)_s1Creator.Canvas != (Object)null)
			{
				((Behaviour)_s1Creator.Canvas).enabled = false;
			}
			try
			{
				CharacterCreatorManager.OnOpened?.Invoke();
			}
			catch (Exception value)
			{
				Logger.Error($"Error in OnOpened event handler: {value}");
			}
		}

		public static void Close()
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Error("CharacterCreator singleton is not available");
				return;
			}
			if (!_s1Creator.IsOpen)
			{
				Logger.Warning("CharacterCreator is not open");
				return;
			}
			_s1Creator.Close();
			MelonCoroutines.Start(RestoreAfterClose());
			try
			{
				CharacterCreatorManager.OnClosed?.Invoke();
			}
			catch (Exception value)
			{
				Logger.Error($"Error in OnClosed event handler: {value}");
			}
		}

		public static void Complete()
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Error("CharacterCreator singleton is not available");
			}
			else if (!_s1Creator.IsOpen)
			{
				Logger.Warning("CharacterCreator is not open");
			}
			else
			{
				_s1Creator.Done();
			}
		}

		public static void SelectPreset(string presetName)
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Error("CharacterCreator singleton is not available");
			}
			else if (!_s1Creator.IsOpen)
			{
				Logger.Warning("CharacterCreator must be open to select a preset");
			}
			else if (string.IsNullOrWhiteSpace(presetName))
			{
				Logger.Warning("Preset name cannot be null or empty");
			}
			else
			{
				_s1Creator.SelectPreset(presetName);
			}
		}

		public static string[] GetAvailablePresets()
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null || _s1Creator.Presets == null)
			{
				return Array.Empty<string>();
			}
			List<string> list = new List<string>();
			for (int i = 0; i < _s1Creator.Presets.Count; i++)
			{
				BasicAvatarSettings val = _s1Creator.Presets[i];
				if ((Object)(object)val != (Object)null && !string.IsNullOrWhiteSpace(((Object)val).name))
				{
					list.Add(((Object)val).name);
				}
			}
			return list.ToArray();
		}

		public static void SetRigRotation(float normalizedValue)
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Error("CharacterCreator singleton is not available");
			}
			else if (!_s1Creator.IsOpen)
			{
				Logger.Warning("CharacterCreator must be open to set rig rotation");
			}
			else
			{
				_s1Creator.SliderChanged(Mathf.Clamp01(normalizedValue));
			}
		}

		public static void PreRegisterAsActiveUI()
		{
			EnsureInitialized();
			if ((Object)(object)_s1Creator == (Object)null)
			{
				Logger.Warning("CharacterCreator singleton is not available for pre-registration");
			}
			else if (PlayerSingleton<PlayerCamera>.InstanceExists)
			{
				PlayerSingleton<PlayerCamera>.Instance.AddActiveUIElement(((Object)_s1Creator).name);
			}
		}

		private static void EnsureInitialized()
		{
			if (_isInitialized)
			{
				return;
			}
			try
			{
				_s1Creator = Singleton<CharacterCreator>.Instance;
				if ((Object)(object)_s1Creator == (Object)null)
				{
					Logger.Warning("CharacterCreator singleton not found. Make sure you're in the correct scene.");
				}
				_isInitialized = true;
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to initialize CharacterCreatorManager: {value}");
				_isInitialized = true;
			}
		}

		private static void RegisterEvents()
		{
			if (_eventsRegistered || (Object)(object)_s1Creator == (Object)null)
			{
				return;
			}
			try
			{
				if (_s1Creator.onComplete != null)
				{
					_s1Creator.onComplete.AddListener(UnityAction<BasicAvatarSettings>.op_Implicit((Action<BasicAvatarSettings>)OnCreatorCompleted));
				}
				_eventsRegistered = true;
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to register CharacterCreator events: {value}");
			}
		}

		private static void OnCreatorCompleted(BasicAvatarSettings s1Settings)
		{
			try
			{
				if ((Object)(object)s1Settings == (Object)null)
				{
					Logger.Warning("CharacterCreator completed with null settings");
					return;
				}
				BasicAvatarSettings obj = new BasicAvatarSettings(s1Settings);
				MelonCoroutines.Start(RestoreGameState());
				CharacterCreatorManager.OnCompleted?.Invoke(obj);
			}
			catch (Exception value)
			{
				Logger.Error($"Error in OnCompleted event handler: {value}");
			}
		}

		private static IEnumerator RestoreAfterClose()
		{
			yield return RestoreGameState();
		}

		private static IEnumerator RestoreGameState()
		{
			yield return null;
			yield return (object)new WaitForSeconds(0.1f);
			if (PlayerSingleton<PlayerCamera>.InstanceExists)
			{
				PlayerCamera camera = PlayerSingleton<PlayerCamera>.Instance;
				CharacterCreator? s1Creator = _s1Creator;
				camera.RemoveActiveUIElement(((s1Creator != null) ? ((Object)s1Creator).name : null) ?? "CharacterCreator");
				if (GetActiveUIElementCount(camera) == 0)
				{
					camera.StopTransformOverride(0f, true, false);
					camera.StopFOVOverride(0f);
					camera.SetCanLook(true);
					camera.LockMouse(true);
				}
			}
			if (PlayerSingleton<PlayerMovement>.InstanceExists)
			{
				PlayerSingleton<PlayerMovement>.Instance.CanMove = true;
			}
			if (PlayerSingleton<PlayerInventory>.InstanceExists)
			{
				PlayerSingleton<PlayerInventory>.Instance.SetInventoryEnabled(true);
			}
			if (Singleton<HUD>.InstanceExists)
			{
				((Behaviour)Singleton<HUD>.Instance.canvas).enabled = true;
			}
		}

		private static BasicAvatarSettings? GetPlayerAvatarSettings()
		{
			try
			{
				Player local = Player.Local;
				if (local == null || (Object)(object)local.S1Player == (Object)null)
				{
					Logger.Warning("Local player not available");
					return null;
				}
				BasicAvatarSettings currentBasicAvatarSettings = local.GetCurrentBasicAvatarSettings();
				if (currentBasicAvatarSettings == null)
				{
					Logger.Debug("Player has no current avatar settings, using default");
					return null;
				}
				BasicAvatarSettings settings = Object.Instantiate<BasicAvatarSettings>(currentBasicAvatarSettings.S1BasicAvatarSettings);
				return new BasicAvatarSettings(settings);
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to get player avatar settings: {value}");
				return null;
			}
		}

		private static int GetActiveUIElementCount(PlayerCamera camera)
		{
			if ((Object)(object)camera == (Object)null)
			{
				return 0;
			}
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(camera, "ActiveUIElementCount") is int result)
			{
				return result;
			}
			return 0;
		}
	}
	public sealed class MainMenuRig
	{
		internal readonly MainMenuRig S1MainMenuRig;

		public global::S1API.Avatar.Avatar? Avatar
		{
			get
			{
				if ((Object)(object)S1MainMenuRig == (Object)null || (Object)(object)S1MainMenuRig.Avatar == (Object)null)
				{
					return null;
				}
				return new global::S1API.Avatar.Avatar(S1MainMenuRig.Avatar);
			}
		}

		internal MainMenuRig(MainMenuRig mainMenuRig)
		{
			S1MainMenuRig = mainMenuRig;
		}

		public static MainMenuRig[] FindInScene(bool includeInactive = false)
		{
			Il2CppArrayBase<MainMenuRig> val = Object.FindObjectsOfType<MainMenuRig>(includeInactive);
			if (val == null || val.Length == 0)
			{
				return Array.Empty<MainMenuRig>();
			}
			return (from r in (IEnumerable<MainMenuRig>)val
				where (Object)(object)r != (Object)null
				select new MainMenuRig(r)).ToArray();
		}
	}
	public static class UIFactory
	{
		private static Sprite? roundedSprite;

		public static GameObject Panel(string name, Transform parent, Color bgColor, Vector2? anchorMin = null, Vector2? anchorMax = null, bool fullAnchor = false)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			if (fullAnchor)
			{
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.one;
				val2.offsetMin = Vector2.zero;
				val2.offsetMax = Vector2.zero;
			}
			else
			{
				val2.anchorMin = (Vector2)(((??)anchorMin) ?? new Vector2(0.5f, 0.5f));
				val2.anchorMax = (Vector2)(((??)anchorMax) ?? new Vector2(0.5f, 0.5f));
			}
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = bgColor;
			return val;
		}

		public static Text Text(string name, string content, Transform parent, int fontSize = 14, TextAnchor anchor = (TextAnchor)0, FontStyle style = (FontStyle)0)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			Text val3 = val.AddComponent<Text>();
			val3.text = content;
			val3.fontSize = fontSize;
			val3.alignment = anchor;
			val3.fontStyle = style;
			val3.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			((Graphic)val3).color = Color.white;
			val3.horizontalOverflow = (HorizontalWrapMode)0;
			val3.verticalOverflow = (VerticalWrapMode)1;
			return val3;
		}

		public static RectTransform ScrollableVerticalList(string name, Transform parent, out ScrollRect scrollRect)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_0186: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			scrollRect = val.AddComponent<ScrollRect>();
			scrollRect.horizontal = false;
			GameObject val3 = new GameObject("Viewport");
			val3.transform.SetParent(val.transform, false);
			RectTransform val4 = val3.AddComponent<RectTransform>();
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)val3.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.05f);
			val3.AddComponent<Mask>().showMaskGraphic = false;
			scrollRect.viewport = val4;
			GameObject val5 = new GameObject("Content");
			val5.transform.SetParent(val3.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = new Vector2(0f, 1f);
			val6.anchorMax = new Vector2(1f, 1f);
			val6.pivot = new Vector2(0.5f, 1f);
			VerticalLayoutGroup val7 = val5.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val7).spacing = 10f;
			((LayoutGroup)val7).padding = new RectOffset(10, 10, 10, 10);
			((HorizontalOrVerticalLayoutGroup)val7).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val7).childForceExpandHeight = false;
			val5.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			scrollRect.content = val6;
			return val6;
		}

		public static void FitContentHeight(RectTransform content)
		{
			ContentSizeFitter val = ((Component)content).gameObject.GetComponent<ContentSizeFitter>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)content).gameObject.AddComponent<ContentSizeFitter>();
			}
			val.verticalFit = (FitMode)2;
		}

		public static (GameObject, Button, Text) RoundedButtonWithLabel(string name, string label, Transform parent, Color bgColor, float width, float height, int fontSize, Color textColor)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_002c: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name + "_RoundedMask");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(width, height);
			LayoutElement val3 = val.AddComponent<LayoutElement>();
			val3.preferredWidth = width;
			val3.preferredHeight = height;
			Image val4 = val.AddComponent<Image>();
			val4.sprite = GetRoundedSprite();
			val4.type = (Type)1;
			((Graphic)val4).color = Color.white;
			Mask val5 = val.AddComponent<Mask>();
			val5.showMaskGraphic = true;
			GameObject val6 = new GameObject(name);
			val6.transform.SetParent(val.transform, false);
			RectTransform val7 = val6.AddComponent<RectTransform>();
			val7.anchorMin = Vector2.zero;
			val7.anchorMax = Vector2.one;
			val7.offsetMin = Vector2.zero;
			val7.offsetMax = Vector2.zero;
			Image val8 = val6.AddComponent<Image>();
			((Graphic)val8).color = bgColor;
			val8.sprite = GetRoundedSprite();
			val8.type = (Type)1;
			Button val9 = val6.AddComponent<Button>();
			((Selectable)val9).targetGraphic = (Graphic)(object)val8;
			GameObject val10 = new GameObject("Label");
			val10.transform.SetParent(val6.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = Vector2.zero;
			val11.anchorMax = Vector2.one;
			val11.offsetMin = Vector2.zero;
			val11.offsetMax = Vector2.zero;
			Text val12 = val10.AddComponent<Text>();
			val12.text = label;
			val12.alignment = (TextAnchor)4;
			val12.fontSize = fontSize;
			val12.fontStyle = (FontStyle)1;
			((Graphic)val12).color = textColor;
			val12.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			return (val, val9, val12);
		}

		private static Sprite GetRoundedSprite()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)roundedSprite != (Object)null)
			{
				return roundedSprite;
			}
			int num = 32;
			Texture2D val = new Texture2D(num, num, (TextureFormat)5, false);
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)0, (byte)0, (byte)0, (byte)0);
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			float num2 = 6f;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					bool flag = ((float)j < num2 && (float)i < num2 && Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(num2, num2)) > num2) || ((float)j > (float)num - num2 - 1f && (float)i < num2 && Vector2.Distance(new Vector2((float)j, (float)i), new Vector2((float)num - num2 - 1f, num2)) > num2) || ((float)j < num2 && (float)i > (float)num - num2 - 1f && Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(num2, (float)num - num2 - 1f)) > num2) || ((float)j > (float)num - num2 - 1f && (float)i > (float)num - num2 - 1f && Vector2.Distance(new Vector2((float)j, (float)i), new Vector2((float)num - num2 - 1f, (float)num - num2 - 1f)) > num2);
					val.SetPixel(j, i, Color32.op_Implicit(flag ? val2 : val3));
				}
			}
			val.Apply();
			Vector4 val4 = default(Vector4);
			((Vector4)(ref val4))..ctor(8f, 8f, 8f, 8f);
			roundedSprite = Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val4);
			return roundedSprite;
		}

		public static GameObject ButtonRow(string name, Transform parent, float spacing = 12f, TextAnchor alignment = (TextAnchor)4)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			HorizontalLayoutGroup val3 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val3).spacing = spacing;
			((LayoutGroup)val3).childAlignment = alignment;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			return val;
		}

		public static (GameObject, Button, Text) ButtonWithLabel(string name, string label, Transform parent, Color bgColor, float Width, float Height)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(Width, Height);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = bgColor;
			val3.sprite = Resources.GetBuiltinResource<Sprite>("UI/Skin/UISprite.psd");
			val3.type = (Type)1;
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			GameObject val5 = new GameObject("Label");
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Text val7 = val5.AddComponent<Text>();
			val7.text = label;
			val7.alignment = (TextAnchor)4;
			val7.fontSize = 16;
			val7.fontStyle = (FontStyle)1;
			((Graphic)val7).color = Color.white;
			val7.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			return (val, val4, val7);
		}

		public static void SetIcon(Sprite sprite, Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0022: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Icon");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			Image val3 = val.AddComponent<Image>();
			val3.sprite = sprite;
			val3.preserveAspect = true;
		}

		public static void CreateTextBlock(Transform parent, string title, string subtitle, bool isCompleted)
		{
			Text(((Object)parent).name + "Title", title, parent, 16, (TextAnchor)3, (FontStyle)1);
			Text(((Object)parent).name + "Subtitle", subtitle, parent, 14, (TextAnchor)0, (FontStyle)0);
			if (isCompleted)
			{
				Text("CompletedLabel", "<color=#888888><i>Already Delivered</i></color>", parent, 12, (TextAnchor)0, (FontStyle)0);
			}
		}

		public static void CreateRowButton(GameObject go, UnityAction clickHandler, bool enabled)
		{
			Button val = go.AddComponent<Button>();
			Image component = go.GetComponent<Image>();
			((Selectable)val).targetGraphic = (Graphic)(object)component;
			((Selectable)val).interactable = enabled;
			((UnityEvent)val.onClick).AddListener(clickHandler);
		}

		public static void ClearChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Transform child = parent.GetChild(num);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
		}

		public static void VerticalLayoutOnGO(GameObject go, int spacing = 10, RectOffset? padding = null)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			VerticalLayoutGroup val = go.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).padding = (RectOffset)(((object)padding) ?? ((object)new RectOffset(10, 10, 10, 10)));
		}

		public static GameObject CreateQuestRow(string name, Transform parent, out GameObject iconPanel, out GameObject textPanel)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Row_" + name);
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(0f, 90f);
			val.AddComponent<LayoutElement>().minHeight = 50f;
			((Shadow)val.AddComponent<Outline>()).effectColor = new Color(0f, 0f, 0f, 0.2f);
			GameObject val3 = Panel("Separator", val.transform, new Color(1f, 1f, 1f, 0.05f));
			val3.GetComponent<RectTransform>().sizeDelta = new Vector2(300f, 1f);
			Image val4 = val.AddComponent<Image>();
			((Graphic)val4).color = new Color(0.12f, 0.12f, 0.12f);
			Button val5 = val.AddComponent<Button>();
			((Selectable)val5).targetGraphic = (Graphic)(object)val4;
			HorizontalLayoutGroup val6 = val.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val6).spacing = 20f;
			((LayoutGroup)val6).padding = new RectOffset(75, 10, 10, 10);
			((LayoutGroup)val6).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)val6).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val6).childForceExpandHeight = false;
			LayoutElement val7 = val.AddComponent<LayoutElement>();
			val7.minHeight = 90f;
			val7.flexibleWidth = 1f;
			iconPanel = Panel("IconPanel", val.transform, new Color(0.12f, 0.12f, 0.12f));
			RectTransform component = iconPanel.GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(80f, 80f);
			LayoutElement val8 = iconPanel.AddComponent<LayoutElement>();
			val8.preferredWidth = 80f;
			val8.preferredHeight = 80f;
			textPanel = Panel("TextPanel", val.transform, Color.clear);
			VerticalLayoutOnGO(textPanel, 2);
			LayoutElement val9 = textPanel.AddComponent<LayoutElement>();
			val9.minWidth = 200f;
			val9.flexibleWidth = 1f;
			return val;
		}

		public static GameObject TopBar(string name, Transform parent, string title, float topbarSize, int paddingLeft, int paddingRight, int paddingTop, int paddingBottom)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			GameObject val = Panel(name, parent, new Color(0.15f, 0.15f, 0.15f), (Vector2?)new Vector2(0f, topbarSize), (Vector2?)new Vector2(1f, 1f), fullAnchor: false);
			HorizontalLayoutGroup val2 = val.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)val2).padding = new RectOffset(paddingLeft, paddingRight, paddingTop, paddingBottom);
			((HorizontalOrVerticalLayoutGroup)val2).spacing = 20f;
			((LayoutGroup)val2).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val2).childForceExpandHeight = true;
			Text val3 = Text("TopBarTitle", title, val.transform, 26, (TextAnchor)3, (FontStyle)1);
			LayoutElement val4 = ((Component)val3).gameObject.AddComponent<LayoutElement>();
			val4.minWidth = 300f;
			val4.flexibleWidth = 1f;
			return val;
		}

		public static void HorizontalLayoutOnGO(GameObject go, int spacing = 10, int padLeft = 0, int padRight = 0, int padTop = 0, int padBottom = 0, TextAnchor alignment = (TextAnchor)4)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			HorizontalLayoutGroup val = go.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).childAlignment = alignment;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = false;
			((LayoutGroup)val).padding = new RectOffset(padLeft, padRight, padTop, padBottom);
		}

		public static void SetLayoutGroupPadding(LayoutGroup layoutGroup, int left, int right, int top, int bottom)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			layoutGroup.padding = new RectOffset(left, right, top, bottom);
		}

		public static void BindAcceptButton(Button btn, Text label, string text, UnityAction callback)
		{
			label.text = text;
			((UnityEventBase)btn.onClick).RemoveAllListeners();
			((UnityEvent)btn.onClick).AddListener(callback);
		}
	}
}
namespace S1API.TVApp
{
	public abstract class TVApp : Registerable
	{
		protected static readonly Log Logger = new Log("TVApp");

		private GameObject? _appRoot;

		private Canvas? _canvas;

		private CanvasGroup? _canvasGroup;

		private GameObject? _container;

		private TVHomeScreen? _homeScreen;

		private ExitDelegate? _exitDelegate;

		private bool _isOpen;

		private bool _isPaused;

		private bool _uiCreated;

		protected abstract string AppName { get; }

		protected abstract string AppTitle { get; }

		protected abstract Sprite Icon { get; }

		public bool IsOpen => _isOpen;

		public bool IsPaused => _isPaused;

		protected abstract void OnCreatedUI(GameObject container);

		protected virtual void OnUpdate()
		{
		}

		protected virtual void OnOpened()
		{
		}

		protected virtual void OnClosed()
		{
		}

		protected virtual void OnPaused()
		{
		}

		protected virtual void OnResumed()
		{
		}

		public void Open()
		{
			if (_isOpen)
			{
				return;
			}
			try
			{
				_isOpen = true;
				_isPaused = false;
				if ((Object)(object)_appRoot != (Object)null)
				{
					_appRoot.SetActive(true);
				}
				if ((Object)(object)_canvasGroup != (Object)null)
				{
					_canvasGroup.alpha = 1f;
				}
				if ((Object)(object)_container != (Object)null)
				{
					_container.SetActive(true);
				}
				OnOpened();
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to open TV app " + AppName + ": " + ex.Message);
			}
		}

		public void Close()
		{
			if (!_isOpen)
			{
				return;
			}
			try
			{
				_isOpen = false;
				_isPaused = false;
				if ((Object)(object)_canvasGroup != (Object)null)
				{
					_canvasGroup.alpha = 0f;
				}
				if ((Object)(object)_container != (Object)null)
				{
					_container.SetActive(false);
				}
				if ((Object)(object)_appRoot != (Object)null)
				{
					_appRoot.SetActive(false);
				}
				OnClosed();
				TVHomeScreen? homeScreen = _homeScreen;
				if (homeScreen != null)
				{
					((TVApp)homeScreen).Open();
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to close TV app " + AppName + ": " + ex.Message);
			}
		}

		internal void ForceClose()
		{
			if (!_isOpen)
			{
				return;
			}
			try
			{
				_isOpen = false;
				_isPaused = false;
				if ((Object)(object)_canvasGroup != (Object)null)
				{
					_canvasGroup.alpha = 0f;
				}
				if ((Object)(object)_container != (Object)null)
				{
					_container.SetActive(false);
				}
				if ((Object)(object)_appRoot != (Object)null)
				{
					_appRoot.SetActive(false);
				}
				OnClosed();
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to force close TV app " + AppName + ": " + ex.Message);
			}
		}

		public void Pause()
		{
			if (_isOpen && !_isPaused)
			{
				_isPaused = true;
				OnPaused();
			}
		}

		public void Resume()
		{
			if (_isOpen && _isPaused)
			{
				_isPaused = false;
				OnResumed();
			}
		}

		protected override void OnCreated()
		{
			TVAppRegistry.Register(this);
		}

		protected override void OnDestroyed()
		{
			if ((Delegate)(object)_exitDelegate != (Delegate)null)
			{
				GameInput.DeregisterExitListener(_exitDelegate);
				_exitDelegate = null;
			}
			if ((Object)(object)_appRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_appRoot);
				_appRoot = null;
			}
			_canvas = null;
			_canvasGroup = null;
			_container = null;
			_homeScreen = null;
			_uiCreated = false;
			_isOpen = false;
			_isPaused = false;
		}

		internal void SpawnUI(TVHomeScreen homeScreen)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			if (_uiCreated)
			{
				return;
			}
			_homeScreen = homeScreen;
			Transform parent = ((Component)homeScreen).transform.parent;
			if ((Object)(object)parent == (Object)null)
			{
				Logger.Error("Cannot find parent transform for TV app: " + AppName);
				return;
			}
			_appRoot = new GameObject(AppName + "_TVApp");
			_appRoot.transform.SetParent(parent, false);
			TVApp[] array = Il2CppArrayBase<TVApp>.op_Implicit((Il2CppArrayBase<TVApp>)(object)homeScreen.Apps);
			if (array != null && array.Length != 0 && (Object)(object)array[0].Canvas != (Object)null)
			{
				Transform transform = ((Component)array[0].Canvas).transform;
				_appRoot.transform.localPosition = transform.localPosition;
				_appRoot.transform.localRotation = transform.localRotation;
				_appRoot.transform.localScale = transform.localScale;
			}
			_canvas = _appRoot.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)2;
			if (array != null && array.Length != 0 && (Object)(object)array[0].Canvas != (Object)null)
			{
				Canvas canvas = array[0].Canvas;
				_canvas.sortingOrder = canvas.sortingOrder;
				_canvas.worldCamera = canvas.worldCamera;
				_appRoot.layer = ((Component)array[0].Canvas).gameObject.layer;
				RectTransform component = ((Component)canvas).GetComponent<RectTransform>();
				RectTransform component2 = _appRoot.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
				{
					component2.sizeDelta = component.sizeDelta;
				}
			}
			_canvasGroup = _appRoot.AddComponent<CanvasGroup>();
			_canvasGroup.alpha = 0f;
			_canvasGroup.interactable = true;
			_canvasGroup.blocksRaycasts = true;
			_appRoot.AddComponent<GraphicRaycaster>();
			_container = new GameObject("Container");
			_container.transform.SetParent(_appRoot.transform, false);
			RectTransform val = _container.AddComponent<RectTransform>();
			val.anchorMin = Vector2.zero;
			val.anchorMax = Vector2.one;
			val.offsetMin = Vector2.zero;
			val.offsetMax = Vector2.zero;
			OnCreatedUI(_container);
			TVAppUpdateHandler tVAppUpdateHandler = _appRoot.AddComponent<TVAppUpdateHandler>();
			tVAppUpdateHandler.tvApp = this;
			_exitDelegate = DelegateSupport.ConvertDelegate<ExitDelegate>((Delegate)new Action<ExitAction>(HandleExit));
			GameInput.RegisterExitListener(_exitDelegate, 3);
			_appRoot.SetActive(false);
			_uiCreated = true;
		}

		internal void SpawnButton(TVHomeScreen homeScreen)
		{
			if ((Object)(object)homeScreen.AppButtonPrefab == (Object)null || (Object)(object)homeScreen.AppButtonContainer == (Object)null)
			{
				Logger.Error("Cannot create button for TV app " + AppName + ": missing prefab or container");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(homeScreen.AppButtonPrefab, (Transform)(object)homeScreen.AppButtonContainer);
			((Object)val).name = "Button_" + AppName;
			Transform val2 = val.transform.Find("Icon");
			if ((Object)(object)val2 != (Object)null)
			{
				Image component = ((Component)val2).GetComponent<Image>();
				if ((Object)(object)component != (Object)null && (Object)(object)Icon != (Object)null)
				{
					component.sprite = Icon;
				}
			}
			Transform val3 = val.transform.Find("Name");
			if ((Object)(object)val3 != (Object)null)
			{
				TextMeshProUGUI component2 = ((Component)val3).GetComponent<TextMeshProUGUI>();
				if ((Object)(object)component2 != (Object)null)
				{
					((TMP_Text)component2).text = AppTitle;
				}
			}
			Button component3 = val.GetComponent<Button>();
			if ((Object)(object)component3 != (Object)null)
			{
				((UnityEventBase)component3.onClick).RemoveAllListeners();
				global::S1API.Utils.EventHelper.AddListener(OnButtonClicked, (UnityEvent)(object)component3.onClick);
			}
		}

		internal void InvokeUpdate()
		{
			if (_isOpen && !_isPaused)
			{
				OnUpdate();
			}
		}

		private void OnButtonClicked()
		{
			if ((Object)(object)_homeScreen == (Object)null)
			{
				return;
			}
			try
			{
				TVHomeScreen_Close_Patch.SkipInterfaceClose = true;
				((TVApp)_homeScreen).Close();
				Open();
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to open TV app " + AppName + ": " + ex.Message);
			}
		}

		private void HandleExit(ExitAction exit)
		{
			if (!exit.Used && _isOpen)
			{
				exit.Used = true;
				Close();
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	internal class TVAppUpdateHandler : MonoBehaviour
	{
		internal TVApp? tvApp;

		private void Update()
		{
			if (tvApp != null)
			{
				tvApp.InvokeUpdate();
			}
		}
	}
}
namespace S1API.Trash
{
	public static class TrashManager
	{
		private static readonly Log Logger = new Log("TrashManager");

		private static readonly object RegistrationGate = new object();

		private static readonly Dictionary<string, TrashItem> RegisteredPrefabs = new Dictionary<string, TrashItem>(StringComparer.OrdinalIgnoreCase);

		private static GameObject? _prefabRoot;

		private static bool _lifecycleSubscribed;

		public const int TrashItemLimit = 2000;

		public static GameObject? CreateTrashItem(string id, Vector3 position, Quaternion rotation, Vector3 initialVelocity = default(Vector3), string guid = "")
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			TrashItem val = NetworkSingleton<TrashManager>.Instance.CreateTrashItem(id, position, rotation, initialVelocity, guid, false);
			return (val != null) ? ((Component)val).gameObject : null;
		}

		public static void DestroyAllTrash()
		{
			NetworkSingleton<TrashManager>.Instance.DestroyAllTrash();
		}

		public static GameObject? GetTrashPrefab(string id)
		{
			TrashManager instance = NetworkSingleton<TrashManager>.Instance;
			TrashItem val = (((Object)(object)instance != (Object)null) ? instance.GetTrashPrefab(id) : null);
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).gameObject;
			}
			lock (RegistrationGate)
			{
				TrashItem value;
				return (RegisteredPrefabs.TryGetValue(id, out value) && (Object)(object)value != (Object)null) ? ((Component)value).gameObject : null;
			}
		}

		public static GameObject RegisterTrashPrefab(string id, GameObject trashPrefab, bool replaceExisting = false)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("Trash ID is required.", "id");
			}
			if ((Object)(object)trashPrefab == (Object)null)
			{
				throw new ArgumentNullException("trashPrefab");
			}
			TrashItem component = trashPrefab.GetComponent<TrashItem>();
			if ((Object)(object)component == (Object)null)
			{
				throw new ArgumentException("Trash prefab must have a TrashItem component.", "trashPrefab");
			}
			TrashItem val;
			lock (RegistrationGate)
			{
				if (RegisteredPrefabs.TryGetValue(id, out TrashItem value) && (Object)(object)value != (Object)null)
				{
					if (!replaceExisting)
					{
						Logger.Warning($"Trash ID '{id}' is already registered. Keeping '{((Object)((Component)value).gameObject).name}' and ignoring '{((Object)trashPrefab).name}'. Set replaceExisting to true " + "to replace the existing prefab.");
						return ((Component)value).gameObject;
					}
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				GameObject orCreatePrefabRoot = GetOrCreatePrefabRoot();
				val = Object.Instantiate<TrashItem>(component, orCreatePrefabRoot.transform, false);
				((Object)val).name = "S1API_Trash_" + id;
				val.ID = id;
				((Object)((Component)val).gameObject).hideFlags = (HideFlags)61;
				((Component)val).gameObject.SetActive(true);
				RegisteredPrefabs[id] = val;
				EnsureLifecycleSubscription();
			}
			ApplyRegistration(id, val, replaceExisting: true);
			return ((Component)val).gameObject;
		}

		public static GameObject? GetRandomTrashPrefab()
		{
			TrashItem randomGeneratableTrashPrefab = NetworkSingleton<TrashManager>.Instance.GetRandomGeneratableTrashPrefab();
			return (randomGeneratableTrashPrefab != null) ? ((Component)randomGeneratableTrashPrefab).gameObject : null;
		}

		private static void EnsureLifecycleSubscription()
		{
			if (!_lifecycleSubscribed)
			{
				GameLifecycle.OnPreLoad += ApplyAllRegistrations;
				GameLifecycle.OnLoadComplete += ApplyAllRegistrations;
				_lifecycleSubscribed = true;
			}
		}

		private static void ApplyAllRegistrations()
		{
			KeyValuePair<string, TrashItem>[] array;
			lock (RegistrationGate)
			{
				array = new KeyValuePair<string, TrashItem>[RegisteredPrefabs.Count];
				int num = 0;
				foreach (KeyValuePair<string, TrashItem> registeredPrefab in RegisteredPrefabs)
				{
					array[num++] = registeredPrefab;
				}
			}
			KeyValuePair<string, TrashItem>[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<string, TrashItem> keyValuePair = array2[i];
				if ((Object)(object)keyValuePair.Value != (Object)null)
				{
					ApplyRegistration(keyValuePair.Key, keyValuePair.Value, replaceExisting: true);
				}
			}
		}

		private static void ApplyRegistration(string id, TrashItem prefab, bool replaceExisting)
		{
			TrashManager instance = NetworkSingleton<TrashManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Il2CppReferenceArray<TrashItem> trashPrefabs = instance.TrashPrefabs;
			int num = ((Il2CppArrayBase<TrashItem>)(object)trashPrefabs)?.Length ?? 0;
			for (int i = 0; i < num; i++)
			{
				TrashItem val = ((Il2CppArrayBase<TrashItem>)(object)trashPrefabs)[i];
				if (string.Equals((val != null) ? val.ID : null, id, StringComparison.OrdinalIgnoreCase))
				{
					if (replaceExisting)
					{
						((Il2CppArrayBase<TrashItem>)(object)trashPrefabs)[i] = prefab;
						instance.TrashPrefabs = trashPrefabs;
					}
					return;
				}
			}
			Il2CppReferenceArray<TrashItem> val2 = new Il2CppReferenceArray<TrashItem>((long)(num + 1));
			for (int j = 0; j < num; j++)
			{
				((Il2CppArrayBase<TrashItem>)(object)val2)[j] = ((Il2CppArrayBase<TrashItem>)(object)trashPrefabs)[j];
			}
			((Il2CppArrayBase<TrashItem>)(object)val2)[num] = prefab;
			instance.TrashPrefabs = val2;
		}

		private static GameObject GetOrCreatePrefabRoot()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if ((Object)(object)_prefabRoot != (Object)null)
			{
				return _prefabRoot;
			}
			_prefabRoot = new GameObject("S1API_TrashPrefabs")
			{
				hideFlags = (HideFlags)61
			};
			_prefabRoot.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_prefabRoot);
			return _prefabRoot;
		}
	}
}
namespace S1API.Storages
{
	public enum StorageAccessSettings
	{
		Closed,
		SinglePlayerOnly,
		Full
	}
	public class StorageInstance
	{
		internal readonly StorageEntity S1Storage;

		public string Name => S1Storage.StorageEntityName;

		public string Subtitle => S1Storage.StorageEntitySubtitle;

		public int SlotCount => S1Storage.SlotCount;

		public int ItemCount => S1Storage.ItemCount;

		public StorageAccessSettings AccessSettings
		{
			get
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected I4, but got Unknown
				return (StorageAccessSettings)S1Storage.AccessSettings;
			}
			set
			{
				S1Storage.AccessSettings = (EAccessSettings)value;
			}
		}

		public bool IsOpened => S1Storage.IsOpened;

		public ItemSlotInstance[] Slots => ((IEnumerable<ItemSlot>)S1Storage.ItemSlots.ToArray()).Select((ItemSlot itemSlot) => new ItemSlotInstance(itemSlot)).ToArray();

		public event Action OnOpened
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onOpened += Action.op_Implicit(h);
				});
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onOpened -= Action.op_Implicit(h);
				});
			}
		}

		public event Action OnClosed
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onClosed += Action.op_Implicit(h);
				});
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onClosed -= Action.op_Implicit(h);
				});
			}
		}

		public event Action OnContentsChanged
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onContentsChanged += Action.op_Implicit(h);
				});
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, (Action<Action>)delegate(Action h)
				{
					StorageEntity s1Storage = S1Storage;
					s1Storage.onContentsChanged -= Action.op_Implicit(h);
				});
			}
		}

		internal StorageInstance(StorageEntity storage)
		{
			S1Storage = storage;
		}

		public static StorageInstance? FromGameObject(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning(Object.op_Implicit("[StorageInstance] FromGameObject called with null GameObject"));
				return null;
			}
			Debug.Log(Object.op_Implicit("[StorageInstance] Searching for StorageEntity on GameObject '" + ((Object)gameObject).name + "'"));
			StorageEntity component = gameObject.GetComponent<StorageEntity>();
			if ((Object)(object)component != (Object)null)
			{
				Debug.Log(Object.op_Implicit("[StorageInstance] Found StorageEntity directly on '" + ((Object)gameObject).name + "'"));
				return new StorageInstance(component);
			}
			Debug.Log(Object.op_Implicit("[StorageInstance] StorageEntity not found directly, searching parent hierarchy of '" + ((Object)gameObject).name + "'"));
			component = gameObject.GetComponentInParent<StorageEntity>();
			if ((Object)(object)component != (Object)null)
			{
				Debug.Log(Object.op_Implicit($"[StorageInstance] Found StorageEntity in parent hierarchy of '{((Object)gameObject).name}' on object '{((Object)((Component)component).gameObject).name}'"));
				return new StorageInstance(component);
			}
			Debug.LogWarning(Object.op_Implicit("[StorageInstance] No StorageEntity found on '" + ((Object)gameObject).name + "' or its parents"));
			return null;
		}

		public static StorageInstance? FromGameObjectInChildren(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Debug.LogWarning(Object.op_Implicit("[StorageInstance] FromGameObjectInChildren called with null GameObject"));
				return null;
			}
			Debug.Log(Object.op_Implicit("[StorageInstance] Searching for StorageEntity in children of '" + ((Object)gameObject).name + "'"));
			StorageEntity componentInChildren = gameObject.GetComponentInChildren<StorageEntity>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Debug.LogWarning(Object.op_Implicit("[StorageInstance] No StorageEntity found in children of '" + ((Object)gameObject).name + "'"));
				return null;
			}
			Debug.Log(Object.op_Implicit($"[StorageInstance] Found StorageEntity in children of '{((Object)gameObject).name}' on object '{((Object)((Component)componentInChildren).gameObject).name}'"));
			return new StorageInstance(componentInChildren);
		}

		public ItemInstance[] GetItems()
		{
			List<ItemInstance> allItems = S1Storage.GetAllItems();
			if (allItems == null || allItems.Count == 0)
			{
				return Array.Empty<ItemInstance>();
			}
			ItemInstance[] array = new ItemInstance[allItems.Count];
			for (int i = 0; i < allItems.Count; i++)
			{
				array[i] = new ItemInstance(allItems[i]);
			}
			return array;
		}

		public Dictionary<ItemInstance, int> GetContentsDictionary()
		{
			Dictionary<StorableItemInstance, int> contentsDictionary = S1Storage.GetContentsDictionary();
			Dictionary<ItemInstance, int> dictionary = new Dictionary<ItemInstance, int>();
			Enumerator<StorableItemInstance, int> enumerator = contentsDictionary.GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<StorableItemInstance, int> current = enumerator.Current;
				if (current.Key != null)
				{
					dictionary[new ItemInstance((ItemInstance)(object)current.Key)] = current.Value;
				}
			}
			return dictionary;
		}

		public bool CanItemFit(ItemInstance itemInstance, int quantity = 1)
		{
			return S1Storage.CanItemFit(itemInstance.S1ItemInstance, quantity);
		}

		public void AddItem(ItemInstance itemInstance)
		{
			S1Storage.InsertItem(itemInstance.S1ItemInstance, true);
		}

		public int RemoveItem(ItemInstance itemInstance)
		{
			if (itemInstance == null)
			{
				return 0;
			}
			int num = 0;
			List<ItemSlot> itemSlots = S1Storage.ItemSlots;
			for (int i = 0; i < itemSlots.Count; i++)
			{
				ItemSlot val = itemSlots[i];
				if (val.ItemInstance != null && val.ItemInstance == itemInstance.S1ItemInstance)
				{
					int quantity = val.Quantity;
					val.ClearStoredInstance(false);
					num += quantity;
					break;
				}
			}
			return num;
		}

		public int TryRemoveQuantity(string itemDefinitionId, int quantity)
		{
			if (string.IsNullOrEmpty(itemDefinitionId) || quantity <= 0)
			{
				return 0;
			}
			int num = quantity;
			List<ItemSlot> itemSlots = S1Storage.ItemSlots;
			for (int i = 0; i < itemSlots.Count; i++)
			{
				if (num <= 0)
				{
					break;
				}
				ItemSlot val = itemSlots[i];
				if (val.ItemInstance != null && ((BaseItemInstance)val.ItemInstance).ID == itemDefinitionId)
				{
					int quantity2 = val.Quantity;
					int num2 = Math.Min(num, quantity2);
					num -= num2;
					if (num2 >= quantity2)
					{
						val.ClearStoredInstance(false);
					}
					else
					{
						val.ChangeQuantity(-num2, false);
					}
				}
			}
			return quantity - num;
		}

		public int RemoveAllOfDefinition(string itemDefinitionId)
		{
			if (string.IsNullOrEmpty(itemDefinitionId))
			{
				return 0;
			}
			int num = 0;
			List<ItemSlot> itemSlots = S1Storage.ItemSlots;
			for (int i = 0; i < itemSlots.Count; i++)
			{
				ItemSlot val = itemSlots[i];
				if (val.ItemInstance != null && ((BaseItemInstance)val.ItemInstance).ID == itemDefinitionId)
				{
					num += val.Quantity;
					val.ClearStoredInstance(false);
				}
			}
			return num;
		}
	}
	public static class StorageManager
	{
		public static StorageInstance[] GetAll()
		{
			List<StorageInstance> list = new List<StorageInstance>();
			if (WorldStorageEntity.All == null)
			{
				return list.ToArray();
			}
			Enumerator<WorldStorageEntity> enumerator = WorldStorageEntity.All.GetEnumerator();
			while (enumerator.MoveNext())
			{
				WorldStorageEntity current = enumerator.Current;
				if ((Object)(object)current != (Object)null)
				{
					list.Add(new StorageInstance((StorageEntity)(object)current));
				}
			}
			return list.ToArray();
		}

		public static StorageInstance? FindByName(string name)
		{
			if (string.IsNullOrEmpty(name) || WorldStorageEntity.All == null)
			{
				return null;
			}
			Enumerator<WorldStorageEntity> enumerator = WorldStorageEntity.All.GetEnumerator();
			while (enumerator.MoveNext())
			{
				WorldStorageEntity current = enumerator.Current;
				if ((Object)(object)current != (Object)null && ((StorageEntity)current).StorageEntityName == name)
				{
					return new StorageInstance((StorageEntity)(object)current);
				}
			}
			return null;
		}

		public static StorageInstance[] FindByPredicate(Func<StorageInstance, bool> predicate)
		{
			if (predicate == null || WorldStorageEntity.All == null)
			{
				return Array.Empty<StorageInstance>();
			}
			List<StorageInstance> list = new List<StorageInstance>();
			Enumerator<WorldStorageEntity> enumerator = WorldStorageEntity.All.GetEnumerator();
			while (enumerator.MoveNext())
			{
				WorldStorageEntity current = enumerator.Current;
				if ((Object)(object)current != (Object)null)
				{
					StorageInstance storageInstance = new StorageInstance((StorageEntity)(object)current);
					if (predicate(storageInstance))
					{
						list.Add(storageInstance);
					}
				}
			}
			return list.ToArray();
		}
	}
}
namespace S1API.Storage
{
	public sealed class StorageEntity
	{
		private static readonly Log Logger = new Log("StorageEntity");

		internal readonly StorageEntity S1StorageEntity;

		internal readonly PlaceableStorageEntity? S1PlaceableStorageEntity;

		public string Name
		{
			get
			{
				return S1StorageEntity.StorageEntityName;
			}
			set
			{
				S1StorageEntity.StorageEntityName = value;
			}
		}

		public int SlotCount
		{
			get
			{
				return S1StorageEntity.SlotCount;
			}
			set
			{
				if (value < 0)
				{
					Logger.Warning("Cannot set SlotCount to negative value");
					return;
				}
				if (value > MaxSlots)
				{
					Logger.Warning($"Cannot set SlotCount to {value}, maximum is {MaxSlots}");
					return;
				}
				int count = S1StorageEntity.ItemSlots.Count;
				if (value > count)
				{
					AddSlots(value - count);
				}
				else if (value < count)
				{
					RemoveSlots(count - value);
				}
			}
		}

		public int MaxSlots { get; set; } = 20;

		public int DisplayRowCount
		{
			get
			{
				return S1StorageEntity.DisplayRowCount;
			}
			set
			{
				S1StorageEntity.DisplayRowCount = value;
			}
		}

		public bool SlotsAreFilterable => S1StorageEntity.SlotsAreFilterable;

		public ItemInstance? ItemInstance
		{
			get
			{
				PlaceableStorageEntity? s1PlaceableStorageEntity = S1PlaceableStorageEntity;
				if (((s1PlaceableStorageEntity != null) ? ((BuildableItem)s1PlaceableStorageEntity).ItemInstance : null) == null)
				{
					return null;
				}
				return new ItemInstance(((BuildableItem)S1PlaceableStorageEntity).ItemInstance);
			}
		}

		public string? ItemId
		{
			get
			{
				PlaceableStorageEntity? s1PlaceableStorageEntity = S1PlaceableStorageEntity;
				object result;
				if (s1PlaceableStorageEntity == null)
				{
					result = null;
				}
				else
				{
					ItemInstance itemInstance = ((BuildableItem)s1PlaceableStorageEntity).ItemInstance;
					if (itemInstance == null)
					{
						result = null;
					}
					else
					{
						ItemDefinition definition = itemInstance.Definition;
						result = ((definition != null) ? ((BaseItemDefinition)definition).ID : null);
					}
				}
				return (string?)result;
			}
		}

		public bool IsPlaceable => (Object)(object)S1PlaceableStorageEntity != (Object)null;

		public string? CustomName
		{
			get
			{
				PlaceableStorageEntity? s1PlaceableStorageEntity = S1PlaceableStorageEntity;
				object result;
				if (s1PlaceableStorageEntity == null)
				{
					result = null;
				}
				else
				{
					EntityConfiguration configuration = s1PlaceableStorageEntity.Configuration;
					if (configuration == null)
					{
						result = null;
					}
					else
					{
						StringField name = configuration.Name;
						result = ((name != null) ? name.Value : null);
					}
				}
				return (string?)result;
			}
			set
			{
				PlaceableStorageEntity? s1PlaceableStorageEntity = S1PlaceableStorageEntity;
				object obj;
				if (s1PlaceableStorageEntity == null)
				{
					obj = null;
				}
				else
				{
					EntityConfiguration configuration = s1PlaceableStorageEntity.Configuration;
					obj = ((configuration != null) ? configuration.Name : null);
				}
				if (obj != null && !string.IsNullOrEmpty(value))
				{
					S1PlaceableStorageEntity.Configuration.Name.SetValue(value, true);
				}
			}
		}

		public bool HasCustomName => !string.IsNullOrEmpty(CustomName);

		internal StorageEntity(StorageEntity storageEntity, PlaceableStorageEntity? placeableStorage = null)
		{
			S1StorageEntity = storageEntity ?? throw new ArgumentNullException("storageEntity");
			S1PlaceableStorageEntity = placeableStorage;
		}

		public void SyncCustomNameToDisplayName()
		{
			if (HasCustomName)
			{
				Name = CustomName ?? string.Empty;
			}
		}

		public bool AddSlots(int count)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			if (count <= 0)
			{
				Logger.Warning("AddSlots called with non-positive count");
				return false;
			}
			int count2 = S1StorageEntity.ItemSlots.Count;
			int num = count2 + count;
			if (num > MaxSlots)
			{
				Logger.Warning($"Cannot add {count} slots, would exceed MaxSlots ({MaxSlots})");
				return false;
			}
			try
			{
				for (int i = 0; i < count; i++)
				{
					ItemSlot val = new ItemSlot(S1StorageEntity.SlotsAreFilterable);
					val.SetSlotOwner(((Il2CppObjectBase)S1StorageEntity).Cast<IItemSlotOwner>());
				}
				S1StorageEntity.SlotCount = num;
				if ((Object)(object)S1PlaceableStorageEntity != (Object)null)
				{
					int count3 = S1StorageEntity.ItemSlots.Count;
					for (int j = count2; j < count3; j++)
					{
						ItemSlot val2 = S1StorageEntity.ItemSlots[j];
						S1PlaceableStorageEntity.InputSlots.Add(val2);
						S1PlaceableStorageEntity.OutputSlots.Add(val2);
					}
				}
				if (num > 6 && DisplayRowCount < 2)
				{
					DisplayRowCount = 2;
				}
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to add slots: " + ex.Message);
				return false;
			}
		}

		public bool RemoveSlots(int count)
		{
			if (count <= 0)
			{
				Logger.Warning("RemoveSlots called with non-positive count");
				return false;
			}
			int count2 = S1StorageEntity.ItemSlots.Count;
			if (count > count2)
			{
				Logger.Warning($"Cannot remove {count} slots, only {count2} exist");
				return false;
			}
			try
			{
				for (int i = count2 - count; i < count2; i++)
				{
					if (S1StorageEntity.ItemSlots[i].ItemInstance != null)
					{
						Logger.Warning($"Cannot remove slot {i}, it contains an item");
						return false;
					}
				}
				for (int j = 0; j < count; j++)
				{
					int num = S1StorageEntity.ItemSlots.Count - 1;
					ItemSlot val = S1StorageEntity.ItemSlots[num];
					if ((Object)(object)S1PlaceableStorageEntity != (Object)null)
					{
						S1PlaceableStorageEntity.InputSlots.Remove(val);
						S1PlaceableStorageEntity.OutputSlots.Remove(val);
					}
					S1StorageEntity.ItemSlots.RemoveAt(num);
				}
				S1StorageEntity.SlotCount = count2 - count;
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to remove slots: " + ex.Message);
				return false;
			}
		}

		public bool SetSlotCount(int targetSlotCount)
		{
			if (targetSlotCount < 0)
			{
				Logger.Warning("Cannot set negative slot count");
				return false;
			}
			int count = S1StorageEntity.ItemSlots.Count;
			int num = targetSlotCount - count;
			if (num > 0)
			{
				return AddSlots(num);
			}
			if (num < 0)
			{
				return RemoveSlots(-num);
			}
			return true;
		}

		public int GetEmptySlotCount()
		{
			int num = 0;
			Enumerator<ItemSlot> enumerator = S1StorageEntity.ItemSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				if (current.ItemInstance == null)
				{
					num++;
				}
			}
			return num;
		}

		public int GetOccupiedSlotCount()
		{
			return S1StorageEntity.ItemSlots.Count - GetEmptySlotCount();
		}

		public bool HasItems()
		{
			Enumerator<ItemSlot> enumerator = S1StorageEntity.ItemSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				if (current.ItemInstance != null)
				{
					return true;
				}
			}
			return false;
		}

		public bool IsEmpty()
		{
			return !HasItems();
		}
	}
	public class StorageEventArgs
	{
		public StorageEntity Storage { get; internal set; }

		public string? ItemId => Storage?.ItemId;

		internal StorageEventArgs(StorageEntity storage)
		{
			Storage = storage;
		}
	}
	public class StorageLoadingEventArgs : StorageEventArgs
	{
		public int ItemCountBeingLoaded { get; internal set; }

		public int CurrentSlotCount => base.Storage?.SlotCount ?? 0;

		public bool NeedsMoreSlots => ItemCountBeingLoaded > CurrentSlotCount;

		public int AdditionalSlotsNeeded => Math.Max(0, ItemCountBeingLoaded - CurrentSlotCount);

		internal StorageLoadingEventArgs(StorageEntity storage, int itemCount)
			: base(storage)
		{
			ItemCountBeingLoaded = itemCount;
		}
	}
	public static class StorageEvents
	{
		private static readonly Log Logger = new Log("StorageEvents");

		public static event Action<StorageEventArgs>? OnStorageCreated;

		public static event Action<StorageLoadingEventArgs>? OnStorageLoading;

		public static event Action<StorageEventArgs>? OnStorageOpening;

		internal static void RaiseStorageCreated(StorageEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				StorageEvents.OnStorageCreated?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnStorageCreated handler for storage '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}

		internal static void RaiseStorageLoading(StorageLoadingEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				StorageEvents.OnStorageLoading?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnStorageLoading handler for storage '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}

		internal static void RaiseStorageOpening(StorageEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				StorageEvents.OnStorageOpening?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnStorageOpening handler for storage '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}
	}
}
namespace S1API.Stations
{
	public sealed class ChemistryStationRecipe
	{
		internal StationRecipe S1StationRecipe { get; }

		internal bool HasExplicitRecipeId { get; }

		public string RecipeID { get; }

		public string Title { get; }

		public int CookTimeMinutes { get; }

		public ChemistryStationRecipeTemperature Temperature { get; }

		public Color FinalLiquidColor { get; }

		public ChemistryStationRecipeProduct Product { get; }

		public IReadOnlyList<ChemistryStationRecipeIngredient> Ingredients { get; }

		public QualityCalculationMethod QualityCalculationMethod { get; }

		public bool IsDiscovered => S1StationRecipe.IsDiscovered;

		public bool IsUnlocked => S1StationRecipe.Unlocked;

		public ItemDefinition? S1ProductItem
		{
			get
			{
				ItemQuantity product = S1StationRecipe.Product;
				return (product != null) ? product.Item : null;
			}
		}

		internal ChemistryStationRecipe(StationRecipe stationRecipe, string recipeId, string title, int cookTimeMinutes, ChemistryStationRecipeTemperature temperature, Color finalLiquidColor, ChemistryStationRecipeProduct product, IReadOnlyList<ChemistryStationRecipeIngredient> ingredients, QualityCalculationMethod qualityCalculationMethod, bool hasExplicitRecipeId)
		{
			//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)
			S1StationRecipe = stationRecipe;
			RecipeID = recipeId;
			Title = title;
			CookTimeMinutes = cookTimeMinutes;
			Temperature = temperature;
			FinalLiquidColor = finalLiquidColor;
			Product = product;
			Ingredients = ingredients;
			QualityCalculationMethod = qualityCalculationMethod;
			HasExplicitRecipeId = hasExplicitRecipeId;
		}

		public void SetAvailability(bool isDiscovered, bool isUnlocked)
		{
			S1StationRecipe.IsDiscovered = isDiscovered;
			S1StationRecipe.Unlocked = isUnlocked;
		}
	}
	public sealed class ChemistryStationRecipeProduct
	{
		public string ItemId { get; }

		public int Quantity { get; }

		internal ChemistryStationRecipeProduct(string itemId, int quantity)
		{
			ItemId = itemId;
			Quantity = quantity;
		}
	}
	public sealed class ChemistryStationRecipeIngredient
	{
		public IReadOnlyList<string> ItemIds { get; }

		public int Quantity { get; }

		internal ChemistryStationRecipeIngredient(IReadOnlyList<string> itemIds, int quantity)
		{
			ItemIds = itemIds;
			Quantity = quantity;
		}
	}
	public sealed class ChemistryStationRecipeTemperature
	{
		public float CookTemperature { get; }

		public float CookTemperatureTolerance { get; }

		public float CookTemperatureLowerBound => CookTemperature - CookTemperatureTolerance;

		public float CookTemperatureUpperBound => CookTemperature + CookTemperatureTolerance;

		internal ChemistryStationRecipeTemperature(float cookTemperature, float tolerance)
		{
			CookTemperature = cookTemperature;
			CookTemperatureTolerance = tolerance;
		}
	}
	public sealed class ChemistryStationRecipeBuilder
	{
		private sealed class IngredientSpec
		{
			public List<string> ItemIds { get; }

			public List<ItemDefinition> NativeItemDefs { get; }

			public int Quantity { get; }

			public IngredientSpec(List<string> itemIds, List<ItemDefinition> nativeItemDefs, int quantity)
			{
				ItemIds = itemIds;
				NativeItemDefs = nativeItemDefs;
				Quantity = quantity;
			}
		}

		private string? _recipeId;

		private bool _hasExplicitRecipeId;

		private string? _title;

		private int _cookTimeMinutes = 180;

		private float _cookTemperature = 250f;

		private float _cookTemperatureTolerance = 25f;

		private Color _finalLiquidColor = Color.white;

		private bool _initiallyDiscovered = true;

		private bool _initiallyUnlocked = true;

		private string? _productItemId;

		private int _productQuantity = 1;

		private ItemDefinition? _productItem;

		private QualityCalculationMethod _method = QualityCalculationMethod.Additive;

		private readonly List<IngredientSpec> _ingredients = new List<IngredientSpec>();

		public ChemistryStationRecipeBuilder WithRecipeId(string recipeId)
		{
			_recipeId = recipeId;
			_hasExplicitRecipeId = true;
			return this;
		}

		public ChemistryStationRecipeBuilder WithTitle(string title)
		{
			_title = title?.Trim();
			return this;
		}

		public ChemistryStationRecipeBuilder WithCookTimeMinutes(int minutes)
		{
			if (minutes <= 0)
			{
				throw new ArgumentOutOfRangeException("minutes", "Cook time must be > 0 minutes.");
			}
			_cookTimeMinutes = minutes;
			return this;
		}

		public ChemistryStationRecipeBuilder WithFinalLiquidColor(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			_finalLiquidColor = color;
			return this;
		}

		public ChemistryStationRecipeBuilder WithInitialAvailability(bool isDiscovered, bool isUnlocked)
		{
			_initiallyDiscovered = isDiscovered;
			_initiallyUnlocked = isUnlocked;
			return this;
		}

		public ChemistryStationRecipeBuilder WithIngredient(string itemId, int quantity)
		{
			return WithIngredientOptions(new string[1] { itemId }, quantity);
		}

		public ChemistryStationRecipeBuilder WithIngredientOptions(IEnumerable<string> itemIds, int quantity)
		{
			if (itemIds == null)
			{
				throw new ArgumentNullException("itemIds");
			}
			if (quantity <= 0)
			{
				throw new ArgumentOutOfRangeException("quantity", "Ingredient quantity must be > 0.");
			}
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			List<ItemDefinition> list2 = new List<ItemDefinition>();
			foreach (string itemId in itemIds)
			{
				string text = (itemId ?? string.Empty).Trim();
				if (!string.IsNullOrWhiteSpace(text) && hashSet.Add(text))
				{
					ItemDefinition item = ResolveIngredientItemOrThrow(text);
					list.Add(text);
					list2.Add(item);
				}
			}
			if (list.Count == 0)
			{
				throw new ArgumentException("Ingredient options must contain at least one valid item ID.", "itemIds");
			}
			_ingredients.Add(new IngredientSpec(list, list2, quantity));
			return this;
		}

		public ChemistryStationRecipeBuilder WithProduct(string itemId, int quantity)
		{
			string text = (itemId ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				throw new ArgumentException("Product item ID is required.", "itemId");
			}
			if (quantity <= 0)
			{
				throw new ArgumentOutOfRangeException("quantity", "Product quantity must be > 0.");
			}
			ItemDefinition val = ResolveProductItemOrThrow(text);
			_productItemId = text;
			_productQuantity = quantity;
			_productItem = val;
			if (string.IsNullOrWhiteSpace(_title))
			{
				try
				{
					_title = ((BaseItemDefinition)val).Name;
				}
				catch
				{
				}
			}
			return this;
		}

		public ChemistryStationRecipeBuilder WithCalculationMethod(QualityCalculationMethod method)
		{
			_method = method;
			return this;
		}

		public ChemistryStationRecipeBuilder WithTemperature(float cookTemperature, float tolerance)
		{
			if (cookTemperature <= 0f)
			{
				throw new ArgumentOutOfRangeException("cookTemperature", "Cook temperature must be > 0.");
			}
			if (tolerance < 0f)
			{
				throw new ArgumentOutOfRangeException("tolerance", "Cook temperature tolerance cannot be negative.");
			}
			_cookTemperature = cookTemperature;
			_cookTemperatureTolerance = tolerance;
			return this;
		}

		public ChemistryStationRecipe Build()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_productItem == (Object)null || string.IsNullOrWhiteSpace(_productItemId))
			{
				throw new InvalidOperationException("ChemistryStationRecipeBuilder requires WithProduct(...) to be called before Build().");
			}
			if (_ingredients.Count == 0)
			{
				throw new InvalidOperationException("ChemistryStationRecipeBuilder requires at least one ingredient (WithIngredient...).");
			}
			string title = (string.IsNullOrWhiteSpace(_title) ? _productItemId : _title);
			string recipeId = ChemistryStationRecipeId.Resolve(_hasExplicitRecipeId, _recipeId, _productQuantity, _productItemId);
			StationRecipe stationRecipe = BuildInternal();
			ChemistryStationRecipe recipe = new ChemistryStationRecipe(stationRecipe, recipeId, title, _cookTimeMinutes, new ChemistryStationRecipeTemperature(_cookTemperature, _cookTemperatureTolerance), _finalLiquidColor, new ChemistryStationRecipeProduct(_productItemId, _productQuantity), BuildIngredientWrappers(), _method, _hasExplicitRecipeId);
			return ChemistryStationRecipes.Register(recipe);
		}

		internal StationRecipe BuildInternal()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			if ((Object)(object)_productItem == (Object)null || string.IsNullOrWhiteSpace(_productItemId))
			{
				throw new InvalidOperationException("WithProduct(...) must be called before BuildInternal().");
			}
			StationRecipe val = ScriptableObject.CreateInstance<StationRecipe>();
			((Object)val).hideFlags = (HideFlags)32;
			val.IsDiscovered = _initiallyDiscovered;
			val.Unlocked = _initiallyUnlocked;
			val.RecipeTitle = (string.IsNullOrWhiteSpace(_title) ? _productItemId : _title);
			val.CookTime_Mins = _cookTimeMinutes;
			val.CookTemperature = _cookTemperature;
			val.CookTemperatureTolerance = _cookTemperatureTolerance;
			val.FinalLiquidColor = _finalLiquidColor;
			val.QualityCalculationMethod = (EQualityCalculationMethod)0;
			val.Product = new ItemQuantity
			{
				Item = _productItem,
				Quantity = _productQuantity
			};
			val.Ingredients.Clear();
			foreach (IngredientSpec ingredient in _ingredients)
			{
				IngredientQuantity val2 = new IngredientQuantity
				{
					Quantity = ingredient.Quantity
				};
				val2.Items.Clear();
				foreach (ItemDefinition nativeItemDef in ingredient.NativeItemDefs)
				{
					if ((Object)(object)nativeItemDef != (Object)null)
					{
						val2.Items.Add(nativeItemDef);
					}
				}
				val.Ingredients.Add(val2);
			}
			return val;
		}

		private IReadOnlyList<ChemistryStationRecipeIngredient> BuildIngredientWrappers()
		{
			List<ChemistryStationRecipeIngredient> list = new List<ChemistryStationRecipeIngredient>(_ingredients.Count);
			foreach (IngredientSpec ingredient in _ingredients)
			{
				list.Add(new ChemistryStationRecipeIngredient(ingredient.ItemIds.AsReadOnly(), ingredient.Quantity));
			}
			return list.AsReadOnly();
		}

		private static ItemDefinition ResolveProductItemOrThrow(string itemId)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(itemId);
				if ((Object)(object)item == (Object)null)
				{
					throw new InvalidOperationException("Missing item '" + itemId + "'. Ensure the item is registered before building Chemistry Station recipes.");
				}
				if (!CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition _))
				{
					throw new InvalidOperationException("Product '" + itemId + "' is not a storable item. Chemistry Station recipes must produce storable items.");
				}
				return item;
			}
			catch (Exception ex) when (!(ex is InvalidOperationException))
			{
				throw new InvalidOperationException("ScheduleOne.Registry is not available yet. Register chemistry recipes during S1API.Lifecycle.GameLifecycle.OnPreLoad.", ex);
			}
		}

		private static ItemDefinition ResolveIngredientItemOrThrow(string itemId)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(itemId);
				if ((Object)(object)item == (Object)null)
				{
					throw new InvalidOperationException("Missing ingredient item '" + itemId + "'. Ensure the item is registered before building Chemistry Station recipes.");
				}
				if (!CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result))
				{
					throw new InvalidOperationException("Ingredient '" + itemId + "' is not a storable item.");
				}
				if ((Object)(object)result.StationItem == (Object)null)
				{
					throw new InvalidOperationException("Ingredient '" + itemId + "' does not have a valid StationItem (cannot be used at stations).");
				}
				return item;
			}
			catch (Exception ex) when (!(ex is InvalidOperationException))
			{
				throw new InvalidOperationException("ScheduleOne.Registry is not available yet. Register chemistry recipes during S1API.Lifecycle.GameLifecycle.OnPreLoad.", ex);
			}
		}
	}
	internal static class ChemistryStationRecipeId
	{
		internal static StringComparer Comparer { get; } = StringComparer.OrdinalIgnoreCase;

		internal static string Resolve(bool hasExplicitId, string? explicitId, int productQuantity, string productItemId)
		{
			if (!hasExplicitId)
			{
				return $"{productQuantity}x{productItemId}";
			}
			string text = (explicitId ?? string.Empty).Trim();
			if (text.Length == 0)
			{
				throw new InvalidOperationException("Explicit Chemistry Station recipe IDs cannot be empty or whitespace. Use a namespaced ID such as 'my-mod:alternate-route'.");
			}
			int num = text.IndexOf(':');
			if (num <= 0 || num != text.LastIndexOf(':') || num == text.Length - 1 || !IsValidSegment(text, 0, num) || !IsValidSegment(text, num + 1, text.Length))
			{
				throw new InvalidOperationException("Explicit Chemistry Station recipe ID '" + text + "' is invalid. Use '<namespace>:<recipe>' with ASCII letters, numbers, '.', '_', or '-' in each segment (for example 'my-mod:alternate-route').");
			}
			return text;
		}

		private static bool IsValidSegment(string value, int startIndex, int endIndex)
		{
			bool result = false;
			for (int i = startIndex; i < endIndex; i++)
			{
				char c = value[i];
				bool flag = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
				bool flag2 = c >= '0' && c <= '9';
				bool flag3 = c == '.' || c == '_' || c == '-';
				if (!flag && !flag2 && !flag3)
				{
					return false;
				}
				if (flag || flag2)
				{
					result = true;
				}
			}
			return result;
		}
	}
	public static class ChemistryStationRecipes
	{
		private static readonly Log Logger = new Log("ChemistryStationRecipes");

		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ChemistryStationRecipe> ById = new Dictionary<string, ChemistryStationRecipe>(ChemistryStationRecipeId.Comparer);

		private static readonly Dictionary<int, string> NativeRecipeIds = new Dictionary<int, string>();

		private static readonly List<ChemistryStationRecipe> All = new List<ChemistryStationRecipe>();

		private static volatile bool _hasExplicitRecipeIds;

		public static ChemistryStationRecipe Register(ChemistryStationRecipe recipe)
		{
			if (recipe == null)
			{
				throw new ArgumentNullException("recipe");
			}
			if (string.IsNullOrWhiteSpace(recipe.RecipeID))
			{
				throw new ArgumentException("RecipeID is required.", "recipe");
			}
			lock (Gate)
			{
				if (ById.ContainsKey(recipe.RecipeID))
				{
					Logger.Warning("RecipeID conflict for '" + recipe.RecipeID + "'. Skipping registration (first wins).");
					return ById[recipe.RecipeID];
				}
				int key = 0;
				if (recipe.HasExplicitRecipeId)
				{
					key = ((Object)recipe.S1StationRecipe).GetInstanceID();
				}
				ById[recipe.RecipeID] = recipe;
				if (recipe.HasExplicitRecipeId)
				{
					NativeRecipeIds[key] = recipe.RecipeID;
					_hasExplicitRecipeIds = true;
				}
				All.Add(recipe);
				return recipe;
			}
		}

		public static ChemistryStationRecipe CreateAndRegister(Action<ChemistryStationRecipeBuilder> configure)
		{
			if (configure == null)
			{
				throw new ArgumentNullException("configure");
			}
			ChemistryStationRecipeBuilder chemistryStationRecipeBuilder = new ChemistryStationRecipeBuilder();
			configure(chemistryStationRecipeBuilder);
			return chemistryStationRecipeBuilder.Build();
		}

		public static IReadOnlyList<ChemistryStationRecipe> GetAll()
		{
			lock (Gate)
			{
				return All.ToArray();
			}
		}

		internal static IReadOnlyList<StationRecipe> GetAllNative()
		{
			lock (Gate)
			{
				StationRecipe[] array = (StationRecipe[])(object)new StationRecipe[All.Count];
				for (int i = 0; i < All.Count; i++)
				{
					array[i] = All[i].S1StationRecipe;
				}
				return array;
			}
		}

		internal static bool TryGetRegisteredId(StationRecipe? recipe, out string recipeId)
		{
			recipeId = string.Empty;
			if (recipe == null)
			{
				return false;
			}
			if (!_hasExplicitRecipeIds)
			{
				return false;
			}
			int instanceID;
			try
			{
				instanceID = ((Object)recipe).GetInstanceID();
			}
			catch
			{
				return false;
			}
			lock (Gate)
			{
				return NativeRecipeIds.TryGetValue(instanceID, out recipeId);
			}
		}
	}
	public enum QualityCalculationMethod
	{
		Additive,
		Absolute
	}
}
namespace S1API.Shops
{
	public sealed class Shop
	{
		internal ShopInterface S1ShopInterface { get; }

		public string Name => S1ShopInterface.ShopName;

		internal Shop(ShopInterface shopInterface)
		{
			S1ShopInterface = shopInterface;
		}

		public bool HasItem(string itemId)
		{
			if (string.IsNullOrEmpty(itemId))
			{
				return false;
			}
			Enumerator<ShopListing> enumerator = S1ShopInterface.Listings.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ShopListing current = enumerator.Current;
				object obj;
				if (current == null)
				{
					obj = null;
				}
				else
				{
					StorableItemDefinition item = current.Item;
					obj = ((item != null) ? ((BaseItemDefinition)item).ID : null);
				}
				if ((string?)obj == itemId)
				{
					return true;
				}
			}
			return false;
		}

		public bool SellsCategory(ItemCategory category)
		{
			//IL_0002: 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)
			EItemCategory val = (EItemCategory)category;
			Enumerator<ShopListing> enumerator = S1ShopInterface.Listings.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ShopListing current = enumerator.Current;
				if ((Object)(object)((current != null) ? current.Item : null) != (Object)null && ((BaseItemDefinition)current.Item).Category == val)
				{
					return true;
				}
			}
			return false;
		}

		public string[] GetItemIds()
		{
			List<string> list = new List<string>();
			Enumerator<ShopListing> enumerator = S1ShopInterface.Listings.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ShopListing current = enumerator.Current;
				if ((Object)(object)((current != null) ? current.Item : null) != (Object)null)
				{
					list.Add(((BaseItemDefinition)current.Item).ID);
				}
			}
			return list.ToArray();
		}

		public bool AddItem(ItemDefinition item, float? customPrice = null)
		{
			if (item == null)
			{
				return false;
			}
			if (HasItem(item.ID))
			{
				return false;
			}
			return ShopIntegration.AddItemToShop(this, item, customPrice);
		}

		public bool RemoveItem(string itemId)
		{
			if (string.IsNullOrEmpty(itemId))
			{
				return false;
			}
			return ShopIntegration.RemoveItemFromShop(this, itemId);
		}
	}
	public static class ShopManager
	{
		private static readonly Log Logger = new Log("ShopManager");

		private static readonly List<Shop> _cachedShops = new List<Shop>();

		private static bool _cacheValid = false;

		public static Shop[] GetAllShops()
		{
			RefreshCacheIfNeeded();
			return _cachedShops.ToArray();
		}

		public static Shop? GetShopByName(string shopName)
		{
			if (string.IsNullOrEmpty(shopName))
			{
				return null;
			}
			return GetAllShops().FirstOrDefault((Shop s) => string.Equals(s.Name, shopName, StringComparison.OrdinalIgnoreCase));
		}

		public static Shop[] FindShopsByCategory(ItemCategory category)
		{
			return (from s in GetAllShops()
				where s.SellsCategory(category)
				select s).ToArray();
		}

		public static Shop[] FindShopsByItem(string itemId)
		{
			if (string.IsNullOrEmpty(itemId))
			{
				return Array.Empty<Shop>();
			}
			return (from s in GetAllShops()
				where s.HasItem(itemId)
				select s).ToArray();
		}

		public static int AddToCompatibleShops(ItemDefinition item, float? customPrice = null)
		{
			if (item == null)
			{
				return 0;
			}
			Shop[] array = FindShopsByCategory(item.Category);
			int num = 0;
			Shop[] array2 = array;
			foreach (Shop shop in array2)
			{
				if (shop.AddItem(item, customPrice))
				{
					num++;
				}
			}
			if (num > 0)
			{
				Logger.Msg($"Added item '{item.Name}' to {num} compatible shop(s)");
			}
			return num;
		}

		public static int AddToShops(ItemDefinition item, params string[] shopNames)
		{
			return AddToShops(item, null, shopNames);
		}

		public static int AddToShops(ItemDefinition item, float? customPrice, params string[] shopNames)
		{
			if (item == null || shopNames == null || shopNames.Length == 0)
			{
				return 0;
			}
			int num = 0;
			foreach (string shopName in shopNames)
			{
				Shop shopByName = GetShopByName(shopName);
				if (shopByName != null && shopByName.AddItem(item, customPrice))
				{
					num++;
				}
			}
			return num;
		}

		public static int RefreshItemIcon(ItemDefinition item)
		{
			if (item == null)
			{
				return 0;
			}
			return ShopIntegration.RefreshItemIconInShops(item);
		}

		public static int RefreshItemIcon(string itemId)
		{
			if (string.IsNullOrEmpty(itemId))
			{
				return 0;
			}
			Shop[] array = FindShopsByItem(itemId);
			if (array.Length == 0)
			{
				return 0;
			}
			Shop[] array2 = array;
			foreach (Shop shop in array2)
			{
				Enumerator<ShopListing> enumerator = shop.S1ShopInterface.Listings.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ShopListing current = enumerator.Current;
					object obj;
					if (current == null)
					{
						obj = null;
					}
					else
					{
						StorableItemDefinition item = current.Item;
						obj = ((item != null) ? ((BaseItemDefinition)item).ID : null);
					}
					if ((string?)obj == itemId)
					{
						ItemDefinition definition = ItemManager.GetDefinition(itemId);
						if (definition != null)
						{
							return RefreshItemIcon(definition);
						}
						return 0;
					}
				}
			}
			return 0;
		}

		internal static void InvalidateCache()
		{
			_cacheValid = false;
			_cachedShops.Clear();
		}

		private static void RefreshCacheIfNeeded()
		{
			if (_cacheValid)
			{
				return;
			}
			_cachedShops.Clear();
			try
			{
				List<ShopInterface> allShops = ShopInterface.AllShops;
				if (allShops == null)
				{
					_cacheValid = true;
					return;
				}
				Enumerator<ShopInterface> enumerator = allShops.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ShopInterface current = enumerator.Current;
					if ((Object)(object)current != (Object)null)
					{
						_cachedShops.Add(new Shop(current));
					}
				}
				_cacheValid = true;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to refresh shop cache: " + ex.Message);
				_cacheValid = false;
			}
		}
	}
}
namespace S1API.Saveables
{
	internal static class SaveableAutoRegistry
	{
		private static readonly List<Type> _discoveredSaveableTypes = new List<Type>();

		private static readonly Dictionary<Type, Saveable> _instances = new Dictionary<Type, Saveable>();

		private static bool _discoveryPerformed = false;

		private static readonly object _lock = new object();

		public static IEnumerable<Saveable> GetRegisteredSaveables()
		{
			lock (_lock)
			{
				if (!_discoveryPerformed)
				{
					DiscoverSaveableTypes();
					_discoveryPerformed = true;
				}
				return GetOrCreateInstances();
			}
		}

		private static void DiscoverSaveableTypes()
		{
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly in assemblies)
				{
					try
					{
						if (assembly == executingAssembly)
						{
							continue;
						}
						string? fullName = assembly.FullName;
						if (fullName != null && fullName.StartsWith("System"))
						{
							continue;
						}
						string? fullName2 = assembly.FullName;
						if (fullName2 != null && fullName2.StartsWith("Unity"))
						{
							continue;
						}
						string? fullName3 = assembly.FullName;
						if (fullName3 != null && fullName3.StartsWith("mscorlib"))
						{
							continue;
						}
						string? fullName4 = assembly.FullName;
						if (fullName4 != null && fullName4.StartsWith("netstandard"))
						{
							continue;
						}
						string? fullName5 = assembly.FullName;
						if (fullName5 != null && fullName5.StartsWith("Microsoft"))
						{
							continue;
						}
						string? fullName6 = assembly.FullName;
						if (fullName6 != null && fullName6.StartsWith("Il2Cpp"))
						{
							continue;
						}
						string? fullName7 = assembly.FullName;
						if (fullName7 != null && fullName7.StartsWith("MelonLoader"))
						{
							continue;
						}
						string? fullName8 = assembly.FullName;
						if ((fullName8 != null && fullName8.StartsWith("0Harmony")) || assembly.IsDynamic)
						{
							continue;
						}
						Type[] array;
						try
						{
							array = assembly.GetTypes();
						}
						catch (ReflectionTypeLoadException ex)
						{
							array = ex.Types.OfType<Type>().ToArray();
						}
						catch
						{
							goto end_IL_0020;
						}
						Type[] array2 = array;
						foreach (Type type in array2)
						{
							try
							{
								if (!(type == null) && !type.IsAbstract && !type.IsInterface && !type.IsGenericTypeDefinition && IsDirectSaveableInheritor(type))
								{
									_discoveredSaveableTypes.Add(type);
								}
							}
							catch
							{
							}
						}
						end_IL_0020:;
					}
					catch
					{
					}
				}
			}
			catch (Exception ex2)
			{
				try
				{
					MelonLogger.Warning("[S1API] Error during saveable type discovery: " + ex2.Message);
				}
				catch
				{
				}
			}
		}

		private static bool IsDirectSaveableInheritor(Type type)
		{
			if (!typeof(Saveable).IsAssignableFrom(type))
			{
				return false;
			}
			if (type.IsAbstract || type.IsInterface)
			{
				return false;
			}
			Type baseType = type.BaseType;
			return baseType == typeof(Saveable);
		}

		private static IEnumerable<Saveable> GetOrCreateInstances()
		{
			foreach (Type saveableType in _discoveredSaveableTypes)
			{
				if (!_instances.TryGetValue(saveableType, out Saveable instance))
				{
					try
					{
						instance = Activator.CreateInstance(saveableType, nonPublic: true) as Saveable;
						if (instance != null)
						{
							_instances[saveableType] = instance;
						}
					}
					catch
					{
					}
				}
				if (instance != null)
				{
					yield return instance;
				}
				instance = null;
			}
		}

		internal static void ClearCache()
		{
			lock (_lock)
			{
				_discoveredSaveableTypes.Clear();
				_instances.Clear();
				_discoveryPerformed = false;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Field)]
	public class SaveableField : Attribute
	{
		internal string SaveName { get; }

		public SaveableField(string saveName)
		{
			SaveName = saveName;
		}
	}
	public enum SaveableLoadOrder
	{
		BeforeBaseGame,
		AfterBaseGame
	}
}
namespace S1API.Rendering
{
	public static class AccessoryFactory
	{
		private static readonly Log Logger = new Log("AccessoryFactory");

		internal static readonly Dictionary<string, Dictionary<string, Texture2D>> _accessoryTextureRegistry = new Dictionary<string, Dictionary<string, Texture2D>>();

		public static GameObject? CloneAccessoryWithCustomTextures(string sourceResourcePath, string newName, Dictionary<string, Texture2D>? textureReplacements = null, Color? colorTint = null, string? targetResourcePath = null)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = Resources.Load<GameObject>(sourceResourcePath);
				if ((Object)(object)val == (Object)null)
				{
					Logger.Error("Failed to load source accessory at path: " + sourceResourcePath);
					return null;
				}
				GameObject val2 = Object.Instantiate<GameObject>(val);
				((Object)val2).name = newName;
				Object.DontDestroyOnLoad((Object)(object)val2);
				val2.SetActive(false);
				Accessory component = val2.GetComponent<Accessory>();
				if ((Object)(object)component != (Object)null)
				{
					component.AssetPath = targetResourcePath ?? sourceResourcePath;
					component.Name = newName;
				}
				if (textureReplacements != null && textureReplacements.Count > 0)
				{
					ApplyTexturesToAccessory(val2, textureReplacements);
				}
				if (colorTint.HasValue && (Object)(object)component != (Object)null)
				{
					component.ApplyColor(colorTint.Value);
				}
				val2.SetActive(true);
				return val2;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to clone accessory '" + sourceResourcePath + "': " + ex.Message);
				Logger.Error(ex.StackTrace ?? ex.ToString());
				return null;
			}
		}

		private static void ApplyTexturesToAccessory(GameObject accessory, Dictionary<string, Texture2D> textureReplacements)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			Il2CppArrayBase<Renderer> componentsInChildren = accessory.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer item in componentsInChildren)
			{
				Il2CppReferenceArray<Material> materials = item.materials;
				for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)materials).Length; i++)
				{
					Material val = new Material(((Il2CppArrayBase<Material>)(object)materials)[i]);
					foreach (KeyValuePair<string, Texture2D> textureReplacement in textureReplacements)
					{
						if (val.HasProperty(textureReplacement.Key))
						{
							val.SetTexture(textureReplacement.Key, (Texture)(object)textureReplacement.Value);
						}
					}
					((Il2CppArrayBase<Material>)(object)materials)[i] = val;
				}
				item.materials = materials;
			}
		}

		public static bool RegisterAccessory(string resourcePath, GameObject accessory)
		{
			if ((Object)(object)accessory == (Object)null)
			{
				Logger.Error("Cannot register null accessory");
				return false;
			}
			Accessory component = accessory.GetComponent<Accessory>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.Warning("GameObject '" + ((Object)accessory).name + "' does not have an Accessory component. It may not work correctly as clothing.");
			}
			bool result = RuntimeResourceRegistry.RegisterGameObject(resourcePath, accessory);
			if ((Object)(object)component != (Object)null)
			{
				RuntimeResourceRegistry.RegisterAssetForType(resourcePath, (Object)(object)component, typeof(Accessory));
			}
			return result;
		}

		public static bool CreateAndRegisterAccessory(string sourceResourcePath, string targetResourcePath, string newName, Dictionary<string, Texture2D>? textureReplacements = null, Color? colorTint = null)
		{
			GameObject val = CloneAccessoryWithCustomTextures(sourceResourcePath, newName, textureReplacements, colorTint, targetResourcePath);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (textureReplacements != null && textureReplacements.Count > 0)
			{
				_accessoryTextureRegistry[targetResourcePath] = textureReplacements;
			}
			return RegisterAccessory(targetResourcePath, val);
		}

		internal static Dictionary<string, Texture2D>? GetTextureReplacements(string resourcePath)
		{
			_accessoryTextureRegistry.TryGetValue(resourcePath, out Dictionary<string, Texture2D> value);
			return value;
		}
	}
	public static class AvatarLayerFactory
	{
		private static readonly Log Logger = new Log("AvatarLayerFactory");

		public static Object? CloneAvatarLayerWithTexture(string sourceResourcePath, string newName, Texture2D replacementTexture, string? targetResourcePath = null)
		{
			if (string.IsNullOrWhiteSpace(sourceResourcePath))
			{
				Logger.Error("Cannot clone avatar layer: sourceResourcePath is null or empty");
				return null;
			}
			if ((Object)(object)replacementTexture == (Object)null)
			{
				Logger.Error("Cannot clone avatar layer '" + sourceResourcePath + "': replacementTexture is null");
				return null;
			}
			try
			{
				Object val = Resources.Load(sourceResourcePath);
				if (val == (Object)null)
				{
					Logger.Error("Failed to load source avatar layer at path: " + sourceResourcePath);
					return null;
				}
				Object val2 = Object.Instantiate(val);
				Object.DontDestroyOnLoad(val2);
				val2.hideFlags = (HideFlags)32;
				object obj = val2;
				Type typeFromHandle = typeof(AvatarLayer);
				if (!typeFromHandle.IsAssignableFrom(((object)val2).GetType()))
				{
					object obj2 = CreateTypedWrapper(val2, typeFromHandle);
					if (obj2 == null)
					{
						Logger.Error("Failed to create typed avatar layer wrapper for '" + sourceResourcePath + "'");
						return null;
					}
					obj = obj2;
				}
				string value = targetResourcePath ?? sourceResourcePath;
				if (!TrySetMember(typeFromHandle, obj, "Name", newName) || !TrySetMember(typeFromHandle, obj, "AssetPath", value) || !TrySetMember(typeFromHandle, obj, "Texture", replacementTexture))
				{
					Logger.Error("Failed to configure cloned avatar layer '" + sourceResourcePath + "'");
					return null;
				}
				return (Object?)(((obj is Object) ? obj : null) ?? val2);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to clone avatar layer '" + sourceResourcePath + "': " + ex.Message);
				Logger.Error(ex.StackTrace ?? ex.ToString());
				return null;
			}
		}

		public static bool RegisterAvatarLayer(string resourcePath, Object avatarLayer)
		{
			if (string.IsNullOrWhiteSpace(resourcePath))
			{
				Logger.Error("Cannot register avatar layer: resourcePath is null or empty");
				return false;
			}
			if (avatarLayer == (Object)null)
			{
				Logger.Error("Cannot register avatar layer at '" + resourcePath + "': avatarLayer is null");
				return false;
			}
			if (!RuntimeResourceRegistry.RegisterAsset(resourcePath, avatarLayer))
			{
				return false;
			}
			RuntimeResourceRegistry.RegisterAssetForType(resourcePath, avatarLayer, typeof(AvatarLayer));
			return true;
		}

		public static bool CreateAndRegisterAvatarLayer(string sourceResourcePath, string targetResourcePath, string newName, Texture2D replacementTexture)
		{
			Object val = CloneAvatarLayerWithTexture(sourceResourcePath, newName, replacementTexture, targetResourcePath);
			return val != (Object)null && RegisterAvatarLayer(targetResourcePath, val);
		}

		private static object? CreateTypedWrapper(Object sourceLayer, Type targetType)
		{
			Type type = ((object)sourceLayer).GetType();
			PropertyInfo propertyInfo = null;
			while (type != null && propertyInfo == null)
			{
				propertyInfo = type.GetProperty("Pointer", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				type = type.BaseType;
			}
			if (propertyInfo == null)
			{
				return null;
			}
			object value = propertyInfo.GetValue(sourceLayer);
			ConstructorInfo constructor = targetType.GetConstructor(new Type[1] { typeof(IntPtr) });
			if (constructor == null || value == null)
			{
				return null;
			}
			return constructor.Invoke(new object[1] { value });
		}

		private static bool TrySetMember(Type targetType, object target, string memberName, object value)
		{
			BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			PropertyInfo property = targetType.GetProperty(memberName, bindingAttr);
			if (property != null && property.CanWrite)
			{
				property.SetValue(target, value);
				return true;
			}
			FieldInfo field = targetType.GetField(memberName, bindingAttr);
			if (field != null)
			{
				field.SetValue(target, value);
				return true;
			}
			return false;
		}
	}
	public static class IconFactory
	{
		private class SkinnedMeshRendererState
		{
			public SkinnedMeshRenderer SkinnedRenderer { get; set; }

			public MeshFilter? MeshFilter { get; set; }

			public MeshRenderer? MeshRenderer { get; set; }

			public Mesh? BakedMesh { get; set; }

			public SkinnedMeshRendererState(SkinnedMeshRenderer skinnedRenderer)
			{
				SkinnedRenderer = skinnedRenderer;
			}
		}

		private class AccessoryIconRequest
		{
			public string AccessoryPath { get; set; } = string.Empty;

			public Color AccessoryColor { get; set; }

			public int IconSize { get; set; }

			public Action<Texture2D?>? Callback { get; set; }
		}

		private static readonly Log Logger = new Log("IconFactory");

		private static readonly object _accessoryIconQueueLock = new object();

		private static readonly Queue<AccessoryIconRequest> _accessoryIconQueue = new Queue<AccessoryIconRequest>();

		private static bool _isProcessingAccessoryIcons = false;

		internal static IconGenerator S1IconGenerator => Singleton<IconGenerator>.Instance;

		internal static bool IsItemIconGeneratorReady
		{
			get
			{
				try
				{
					IconGenerator s1IconGenerator = S1IconGenerator;
					return (Object)(object)s1IconGenerator != (Object)null && (Object)(object)s1IconGenerator.CameraPosition != (Object)null && (Object)(object)s1IconGenerator.MainContainer != (Object)null && (Object)(object)s1IconGenerator.ItemContainer != (Object)null;
				}
				catch
				{
					return false;
				}
			}
		}

		internal static MugshotGenerator S1MugshotGenerator => Singleton<MugshotGenerator>.Instance;

		public static Texture2D? GenerateIcon(Transform model, int size = 512, bool bakeSkinnedMeshes = true)
		{
			return GenerateIcon(model, size, bakeSkinnedMeshes, fitToCamera: true);
		}

		public static Texture2D? GenerateIcon(Transform model, int size, bool bakeSkinnedMeshes, bool fitToCamera, float cameraFill = 0.72f)
		{
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			if (cameraFill <= 0f || cameraFill > 2f)
			{
				throw new ArgumentOutOfRangeException("cameraFill", cameraFill, "Icon camera fill must be greater than zero and at most 2.");
			}
			IconGenerator s1IconGenerator = S1IconGenerator;
			if ((Object)(object)s1IconGenerator == (Object)null)
			{
				Logger.Error("IconGenerator not found in scene. Cannot generate icon.");
				return null;
			}
			if ((Object)(object)model == (Object)null)
			{
				Logger.Error("Model transform is null when generating icon.");
				return null;
			}
			Transform parent = model.parent;
			Vector3 localPosition = model.localPosition;
			Quaternion localRotation = model.localRotation;
			Vector3 localScale = model.localScale;
			bool activeSelf = ((Component)model).gameObject.activeSelf;
			int iconSize = s1IconGenerator.IconSize;
			bool modifyLighting = s1IconGenerator.ModifyLighting;
			List<SkinnedMeshRendererState> list = null;
			Texture2D val = null;
			try
			{
				model.SetParent(s1IconGenerator.ItemContainer, false);
				model.localPosition = Vector3.zero;
				model.localRotation = localRotation;
				model.localScale = localScale;
				((Component)model).gameObject.SetActive(true);
				int num = LayerMask.NameToLayer("IconGeneration");
				if (num != -1)
				{
					LayerUtility.SetLayerRecursively(((Component)s1IconGenerator.ItemContainer).gameObject, num);
				}
				Logger.Debug($"Icon generation for '{((Object)model).name}': world pos={model.position}, layer={((Component)model).gameObject.layer} ({LayerMask.LayerToName(((Component)model).gameObject.layer)}), container pos={s1IconGenerator.ItemContainer.position}");
				if (bakeSkinnedMeshes)
				{
					list = BakeSkinnedMeshRenderers(((Component)model).gameObject);
					Logger.Debug($"Baked {list.Count} SkinnedMeshRenderer(s)");
				}
				CenterModelInContainer(model, s1IconGenerator.ItemContainer);
				if (fitToCamera)
				{
					FitModelToGeneratorCamera(model, s1IconGenerator.ItemContainer, s1IconGenerator.CameraPosition, cameraFill);
					CenterModelInContainer(model, s1IconGenerator.ItemContainer);
				}
				s1IconGenerator.IconSize = size;
				s1IconGenerator.ModifyLighting = true;
				val = s1IconGenerator.GetTexture(model);
				Logger.Debug("Generated texture: " + (((Object)(object)val != (Object)null) ? $"{((Texture)val).width}x{((Texture)val).height}" : "null"));
				if ((Object)(object)val != (Object)null && !HasVisibleContent(val))
				{
					Logger.Warning("Generated texture for '" + ((Object)model).name + "' contains no visible pixels. Retry after the scene render pipeline has warmed up.");
					Object.Destroy((Object)(object)val);
					val = null;
				}
				return val;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to generate icon for " + ((Object)model).name + ": " + ex.Message);
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				return null;
			}
			finally
			{
				s1IconGenerator.IconSize = iconSize;
				s1IconGenerator.ModifyLighting = modifyLighting;
				if (list != null)
				{
					RestoreSkinnedMeshRenderers(list);
				}
				model.SetParent(parent, false);
				model.localPosition = localPosition;
				model.localRotation = localRotation;
				model.localScale = localScale;
				((Component)model).gameObject.SetActive(activeSelf);
			}
		}

		public static Texture2D? GeneratePackagingIcon(string packagingID, string productID)
		{
			if ((Object)(object)S1IconGenerator == (Object)null)
			{
				Logger.Error("IconGenerator not found in scene. Cannot generate icon.");
				return null;
			}
			try
			{
				return S1IconGenerator.GeneratePackagingIcon(packagingID, productID);
			}
			catch (Exception ex)
			{
				Logger.Error($"Failed to generate packaging icon for P:{packagingID} Prod:{productID}: {ex.Message}");
				return null;
			}
		}

		public static Sprite? GenerateIconSprite(Transform model, int size = 512, bool bakeSkinnedMeshes = true)
		{
			return CreateDurableIconSprite(GenerateIcon(model, size, bakeSkinnedMeshes), ((Object)(object)model != (Object)null) ? ((Object)model).name : "Item");
		}

		public static Sprite? GenerateIconSprite(Transform model, int size, bool bakeSkinnedMeshes, bool fitToCamera, float cameraFill = 0.72f)
		{
			return CreateDurableIconSprite(GenerateIcon(model, size, bakeSkinnedMeshes, fitToCamera, cameraFill), ((Object)(object)model != (Object)null) ? ((Object)model).name : "Item");
		}

		public static Sprite? GeneratePackagingIconSprite(string packagingID, string productID)
		{
			return CreateDurableIconSprite(GeneratePackagingIcon(packagingID, productID), packagingID + "_" + productID);
		}

		public static void GenerateAccessoryIcon(string accessoryPath, Action<Texture2D?>? callback, Color? accessoryColor = null, int size = 512)
		{
			//IL_006e: 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)
			if (string.IsNullOrEmpty(accessoryPath))
			{
				Logger.Error("Accessory path is null or empty when generating accessory icon.");
				callback?.Invoke(null);
				return;
			}
			if (callback == null)
			{
				Logger.Error("Callback is null when generating accessory icon.");
				return;
			}
			AccessoryIconRequest item = new AccessoryIconRequest
			{
				AccessoryPath = accessoryPath,
				AccessoryColor = (Color)(((??)accessoryColor) ?? Color.white),
				IconSize = size,
				Callback = callback
			};
			lock (_accessoryIconQueueLock)
			{
				_accessoryIconQueue.Enqueue(item);
				if (!_isProcessingAccessoryIcons)
				{
					_isProcessingAccessoryIcons = true;
					MelonCoroutines.Start(ProcessAccessoryIconQueue());
				}
			}
		}

		public static void GenerateAccessoryIconSprite(string accessoryPath, Action<Sprite?>? callback, Color? accessoryColor = null, int size = 512)
		{
			GenerateAccessoryIcon(accessoryPath, delegate(Texture2D? texture)
			{
				callback?.Invoke(CreateDurableIconSprite(texture, string.IsNullOrWhiteSpace(accessoryPath) ? "Accessory" : accessoryPath));
			}, accessoryColor, size);
		}

		private static Sprite? CreateDurableIconSprite(Texture2D? renderedTexture, string name)
		{
			if ((Object)(object)renderedTexture == (Object)null)
			{
				return null;
			}
			try
			{
				byte[] array = Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)ImageConversion.EncodeToPNG(renderedTexture));
				if (array == null || array.Length == 0)
				{
					Logger.Error("Generated icon texture for '" + name + "' could not be encoded into a durable UI texture.");
					return null;
				}
				Sprite val = global::S1API.Internal.Utils.ImageUtils.LoadImageRaw(array);
				if ((Object)(object)val == (Object)null)
				{
					Logger.Error("Generated icon texture for '" + name + "' could not be decoded into a durable UI sprite.");
					return null;
				}
				((Object)val).name = name + "_Icon";
				((Object)val.texture).name = name + "_IconTexture";
				((Texture)val.texture).filterMode = (FilterMode)1;
				((Texture)val.texture).wrapMode = (TextureWrapMode)1;
				return val;
			}
			catch (Exception ex)
			{
				Logger.Error($"Generated icon texture for '{name}' could not be normalized: {ex.Message}");
				return null;
			}
			finally
			{
				Object.Destroy((Object)(object)renderedTexture);
			}
		}

		private static List<SkinnedMeshRendererState> BakeSkinnedMeshRenderers(GameObject gameObject)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			List<SkinnedMeshRendererState> list = new List<SkinnedMeshRendererState>();
			Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren = gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
			try
			{
				foreach (SkinnedMeshRenderer item in componentsInChildren)
				{
					SkinnedMeshRendererState skinnedMeshRendererState = new SkinnedMeshRendererState(item);
					list.Add(skinnedMeshRendererState);
					skinnedMeshRendererState.BakedMesh = new Mesh();
					item.BakeMesh(skinnedMeshRendererState.BakedMesh);
					skinnedMeshRendererState.MeshFilter = ((Component)item).gameObject.AddComponent<MeshFilter>();
					skinnedMeshRendererState.MeshRenderer = ((Component)item).gameObject.AddComponent<MeshRenderer>();
					skinnedMeshRendererState.MeshFilter.sharedMesh = skinnedMeshRendererState.BakedMesh;
					((Renderer)skinnedMeshRendererState.MeshRenderer).sharedMaterials = ((Renderer)item).sharedMaterials;
					((Renderer)item).enabled = false;
				}
				return list;
			}
			catch
			{
				RestoreSkinnedMeshRenderers(list);
				throw;
			}
		}

		private static void RestoreSkinnedMeshRenderers(List<SkinnedMeshRendererState> states)
		{
			foreach (SkinnedMeshRendererState state in states)
			{
				if ((Object)(object)state.SkinnedRenderer != (Object)null)
				{
					((Renderer)state.SkinnedRenderer).enabled = true;
				}
				if ((Object)(object)state.MeshRenderer != (Object)null)
				{
					Object.Destroy((Object)(object)state.MeshRenderer);
				}
				if ((Object)(object)state.MeshFilter != (Object)null)
				{
					Object.Destroy((Object)(object)state.MeshFilter);
				}
				if ((Object)(object)state.BakedMesh != (Object)null)
				{
					Object.Destroy((Object)(object)state.BakedMesh);
				}
			}
		}

		private static void CenterModelInContainer(Transform model, Transform container)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetRendererBounds(model, out var bounds))
			{
				Vector3 val = container.position - ((Bounds)(ref bounds)).center;
				model.position += val;
				Logger.Debug($"Recentered model '{((Object)model).name}'. Old Bounds Center: {((Bounds)(ref bounds)).center}, New Center: {container.position}, Offset: {val}");
			}
			else
			{
				Logger.Warning("Could not calculate bounds for " + ((Object)model).name + " (no enabled renderers?). Icon might be empty.");
			}
		}

		private static void FitModelToGeneratorCamera(Transform model, Transform container, Camera camera, float cameraFill)
		{
			//IL_0019: 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_0031: 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_0052: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetRendererBounds(model, out var bounds))
			{
				float num = Mathf.Max(((Bounds)(ref bounds)).size.x, Mathf.Max(((Bounds)(ref bounds)).size.y, ((Bounds)(ref bounds)).size.z));
				float num2 = Vector3.Distance(((Component)camera).transform.position, container.position);
				float num3 = 2f * num2 * Mathf.Tan(camera.fieldOfView * 0.5f * ((float)Math.PI / 180f));
				float num4 = num3 * cameraFill;
				if (!(num <= Mathf.Epsilon) && !(num4 <= Mathf.Epsilon))
				{
					float num5 = num4 / num;
					model.localScale *= num5;
					Logger.Debug($"Fit model '{((Object)model).name}' to native icon camera. Bounds={((Bounds)(ref bounds)).size}, target={num4:F3}, scale={num5:F3}");
				}
			}
		}

		private static bool TryGetRendererBounds(Transform model, out Bounds bounds)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(((Component)model).GetComponentsInChildren<Renderer>());
			bounds = new Bounds(model.position, Vector3.zero);
			bool flag = false;
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if (val.enabled)
				{
					if (!flag)
					{
						bounds = val.bounds;
						flag = true;
					}
					else
					{
						((Bounds)(ref bounds)).Encapsulate(val.bounds);
					}
				}
			}
			return flag;
		}

		internal static bool HasVisibleContent(Texture2D texture)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)texture == (Object)null || ((Texture)texture).width <= 0 || ((Texture)texture).height <= 0)
			{
				return false;
			}
			for (int i = 0; i < 12; i++)
			{
				int num = Mathf.Clamp(Mathf.RoundToInt((float)(((Texture)texture).height - 1) * (((float)i + 0.5f) / 12f)), 0, ((Texture)texture).height - 1);
				for (int j = 0; j < 12; j++)
				{
					int num2 = Mathf.Clamp(Mathf.RoundToInt((float)(((Texture)texture).width - 1) * (((float)j + 0.5f) / 12f)), 0, ((Texture)texture).width - 1);
					if (texture.GetPixel(num2, num).a > 0.02f)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static IEnumerator ProcessAccessoryIconQueue()
		{
			while (true)
			{
				AccessoryIconRequest next = null;
				lock (_accessoryIconQueueLock)
				{
					if (_accessoryIconQueue.Count <= 0)
					{
						_isProcessingAccessoryIcons = false;
						break;
					}
					next = _accessoryIconQueue.Dequeue();
				}
				if (next == null)
				{
					yield return null;
					continue;
				}
				MugshotGenerator generator = S1MugshotGenerator;
				Avatar mugshotRig = (((Object)(object)generator != (Object)null) ? generator.MugshotRig : null);
				IconGenerator iconGenerator = (((Object)(object)generator != (Object)null) ? generator.Generator : null);
				if ((Object)(object)mugshotRig == (Object)null)
				{
					Logger.Error("MugshotGenerator or MugshotRig not found. Cannot generate accessory icon.");
					next.Callback?.Invoke(null);
					yield return null;
					continue;
				}
				Transform mugshotParent = ((Component)mugshotRig).transform.parent;
				if ((Object)(object)mugshotParent != (Object)null)
				{
					((Component)mugshotParent).gameObject.SetActive(true);
				}
				((Component)mugshotRig).gameObject.SetActive(true);
				AvatarSettings mugshotSettings = CreateMinimalAvatarSettings(next.AccessoryPath, next.AccessoryColor);
				mugshotSettings.Height = 1f;
				mugshotRig.LoadAvatarSettings(mugshotSettings);
				SetLayerRecursively(((Component)mugshotRig).gameObject, LayerMask.NameToLayer("IconGeneration"));
				Il2CppArrayBase<SkinnedMeshRenderer> skinnedMeshRenderers = ((Component)mugshotRig).GetComponentsInChildren<SkinnedMeshRenderer>();
				foreach (SkinnedMeshRenderer smr in skinnedMeshRenderers)
				{
					smr.updateWhenOffscreen = true;
				}
				int originalSize = (((Object)(object)iconGenerator != (Object)null) ? iconGenerator.IconSize : 512);
				if ((Object)(object)iconGenerator != (Object)null)
				{
					iconGenerator.IconSize = next.IconSize;
				}
				yield return (object)new WaitForEndOfFrame();
				bool completed = false;
				Texture2D capturedTexture = null;
				mugshotRig.GetMugshot(Action<Texture2D>.op_Implicit((Action<Texture2D>)delegate(Texture2D generatedMugshot)
				{
					try
					{
						if ((Object)(object)generatedMugshot != (Object)null)
						{
							generatedMugshot.Apply();
							capturedTexture = generatedMugshot;
							Logger.Debug($"Generated accessory icon for '{next.AccessoryPath}': {((Texture)generatedMugshot).width}x{((Texture)generatedMugshot).height}");
						}
						else
						{
							Logger.Error("Failed to generate accessory icon for '" + next.AccessoryPath + "': texture is null");
						}
					}
					catch (Exception ex)
					{
						Logger.Error("Failed to finalize accessory icon: " + ex.Message);
					}
					finally
					{
						completed = true;
					}
				}));
				while (!completed)
				{
					yield return null;
				}
				next.Callback?.Invoke(capturedTexture);
				if ((Object)(object)iconGenerator != (Object)null)
				{
					iconGenerator.IconSize = originalSize;
				}
				if ((Object)(object)generator != (Object)null && (Object)(object)generator.DefaultSettings != (Object)null)
				{
					mugshotRig.LoadAvatarSettings(generator.DefaultSettings);
				}
				((Component)mugshotRig).gameObject.SetActive(false);
				yield return (object)new WaitForSeconds(0.05f);
			}
		}

		private static AvatarSettings CreateMinimalAvatarSettings(string accessoryPath, Color accessoryColor)
		{
			//IL_004a: 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_0057: 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_0064: Expected O, but got Unknown
			BasicAvatarSettings basicAvatarSettings = Player.Local?.GetCurrentBasicAvatarSettings();
			AvatarSettings val;
			if (basicAvatarSettings != null)
			{
				val = basicAvatarSettings.ToAvatarSettings().S1AvatarSettings;
				Logger.Debug("Using local player's avatar settings for accessory icon");
			}
			else
			{
				val = CreateFallbackAvatarSettings();
			}
			val.AccessorySettings.Add(new AccessorySetting
			{
				path = accessoryPath,
				color = accessoryColor
			});
			return val;
		}

		private static AvatarSettings CreateFallbackAvatarSettings()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			Logger.Debug("Local player not available, using fallback avatar settings for accessory icon");
			AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
			val.SkinColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			val.Height = 1f;
			val.Gender = 0.5f;
			val.Weight = 0.5f;
			val.EyeBallTint = Color.white;
			val.PupilDilation = 1f;
			val.HairPath = string.Empty;
			val.HairColor = Color.black;
			val.LeftEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = 0.5f,
				bottomLidOpen = 0.5f
			};
			val.RightEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = 0.5f,
				bottomLidOpen = 0.5f
			};
			val.LeftEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			val.RightEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			val.EyebrowScale = 1f;
			val.EyebrowThickness = 1f;
			val.EyebrowRestingHeight = 0f;
			val.EyebrowRestingAngle = 0f;
			val.FaceLayerSettings.Add(new LayerSetting
			{
				layerPath = "Avatar/Layers/Face/Face_Neutral",
				layerTint = Color.white
			});
			val.FaceLayerSettings.Add(new LayerSetting
			{
				layerPath = "Avatar/Layers/Face/EyeShadow",
				layerTint = new Color(0f, 0f, 0f, 0.7f)
			});
			val.BodyLayerSettings.Add(new LayerSetting
			{
				layerPath = "Avatar/Layers/Top/T-Shirt",
				layerTint = Color.white
			});
			return val;
		}

		private static void SetLayerRecursively(GameObject obj, int layer)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				obj.layer = layer;
				for (int i = 0; i < obj.transform.childCount; i++)
				{
					SetLayerRecursively(((Component)obj.transform.GetChild(i)).gameObject, layer);
				}
			}
		}
	}
	public static class MaterialHelper
	{
		private static readonly Log Logger = new Log("MaterialHelper");

		public static void ReplaceMaterials(GameObject gameObject, Func<Material, bool> predicate, Action<Material> materialModifier)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Logger.Warning("ReplaceMaterials called with null GameObject");
				return;
			}
			if (predicate == null || materialModifier == null)
			{
				Logger.Warning("ReplaceMaterials called with null predicate or modifier");
				return;
			}
			try
			{
				foreach (Renderer componentsInChild in gameObject.GetComponentsInChildren<Renderer>(true))
				{
					if (!((Object)(object)componentsInChild == (Object)null))
					{
						ProcessRenderer(componentsInChild, predicate, materialModifier);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in ReplaceMaterials: " + ex.Message);
			}
		}

		public static Material? CreateMetallicVariant(Material baseMaterial, Color metalColor, float metallic = 0.8f, float smoothness = 0.5f)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_0051: 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)
			if ((Object)(object)baseMaterial == (Object)null)
			{
				Logger.Error("CreateMetallicVariant called with null baseMaterial");
				return null;
			}
			try
			{
				Material val = new Material(baseMaterial)
				{
					name = ((Object)baseMaterial).name + "_metallic"
				};
				RemoveAllTextures(val);
				SetColor(val, "_BaseColor", metalColor);
				SetColor(val, "_Color", metalColor);
				SetFloat(val, "_Metallic", Mathf.Clamp01(metallic));
				SetFloat(val, "_Smoothness", Mathf.Clamp01(smoothness));
				SetFloat(val, "_Glossiness", Mathf.Clamp01(smoothness));
				return val;
			}
			catch (Exception ex)
			{
				Logger.Error("Error creating metallic variant: " + ex.Message);
				return null;
			}
		}

		public static void RemoveAllTextures(Material material)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			if ((Object)(object)material == (Object)null)
			{
				return;
			}
			try
			{
				Shader shader = material.shader;
				int propertyCount = shader.GetPropertyCount();
				for (int i = 0; i < propertyCount; i++)
				{
					if ((int)shader.GetPropertyType(i) == 4)
					{
						string propertyName = shader.GetPropertyName(i);
						material.SetTexture(propertyName, (Texture)null);
					}
				}
				material.mainTexture = null;
			}
			catch (Exception ex)
			{
				Logger.Warning("Error removing textures: " + ex.Message);
			}
		}

		public static bool SetColor(Material material, string propertyName, Color color)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)material == (Object)null || string.IsNullOrEmpty(propertyName))
			{
				return false;
			}
			try
			{
				if (material.HasProperty(propertyName))
				{
					material.SetColor(propertyName, color);
					return true;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Error setting color property '" + propertyName + "': " + ex.Message);
			}
			return false;
		}

		public static bool SetFloat(Material material, string propertyName, float value)
		{
			if ((Object)(object)material == (Object)null || string.IsNullOrEmpty(propertyName))
			{
				return false;
			}
			try
			{
				if (material.HasProperty(propertyName))
				{
					material.SetFloat(propertyName, value);
					return true;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Error setting float property '" + propertyName + "': " + ex.Message);
			}
			return false;
		}

		public static bool SetTexture(Material material, string propertyName, Texture texture)
		{
			if ((Object)(object)material == (Object)null || string.IsNullOrEmpty(propertyName))
			{
				return false;
			}
			try
			{
				if (material.HasProperty(propertyName))
				{
					material.SetTexture(propertyName, texture);
					return true;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Error setting texture property '" + propertyName + "': " + ex.Message);
			}
			return false;
		}

		public static void ConfigureMaterial(Material material, Action<Material> configurator)
		{
			if ((Object)(object)material == (Object)null || configurator == null)
			{
				return;
			}
			try
			{
				configurator(material);
			}
			catch (Exception ex)
			{
				Logger.Error("Error configuring material: " + ex.Message);
			}
		}

		private static void ProcessRenderer(Renderer renderer, Func<Material, bool> predicate, Action<Material> materialModifier)
		{
			//IL_0035: 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_0053: Expected O, but got Unknown
			Il2CppReferenceArray<Material> materials = renderer.materials;
			bool flag = false;
			for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)materials).Length; i++)
			{
				Material val = ((Il2CppArrayBase<Material>)(object)materials)[i];
				if (!((Object)(object)val == (Object)null) && predicate(val))
				{
					Material val2 = new Material(val)
					{
						name = ((Object)val).name + "_modified"
					};
					materialModifier(val2);
					((Il2CppArrayBase<Material>)(object)materials)[i] = val2;
					flag = true;
				}
			}
			if (flag)
			{
				renderer.materials = materials;
			}
		}
	}
	public static class RuntimeResourceRegistry
	{
		private static readonly Log Logger = new Log("S1API.RuntimeResourceRegistry");

		private static readonly Dictionary<string, Object> _registeredAssets = new Dictionary<string, Object>();

		private static readonly Dictionary<string, Object> _typedAssets = new Dictionary<string, Object>();

		private static bool _isPatched;

		public static bool RegisterAsset(string resourcePath, Object asset)
		{
			if (string.IsNullOrEmpty(resourcePath))
			{
				Logger.Error("Cannot register asset: resourcePath is null or empty");
				return false;
			}
			if (asset == (Object)null)
			{
				Logger.Error("Cannot register asset at '" + resourcePath + "': asset is null");
				return false;
			}
			EnsurePatched();
			_registeredAssets[resourcePath] = asset;
			string typedKey = GetTypedKey(resourcePath, ((object)asset).GetType());
			_typedAssets[typedKey] = asset;
			Logger.Debug($"Registered '{resourcePath}' as type '{((object)asset).GetType().Name}'");
			return true;
		}

		public static bool RegisterAssetForType(string resourcePath, Object asset, Type forType)
		{
			if (string.IsNullOrEmpty(resourcePath))
			{
				Logger.Error("Cannot register asset: resourcePath is null or empty");
				return false;
			}
			if (asset == (Object)null)
			{
				Logger.Error("Cannot register asset at '" + resourcePath + "': asset is null");
				return false;
			}
			if (forType == null)
			{
				Logger.Error("Cannot register asset at '" + resourcePath + "': forType is null");
				return false;
			}
			EnsurePatched();
			string typedKey = GetTypedKey(resourcePath, forType);
			_typedAssets[typedKey] = asset;
			Logger.Debug($"Registered '{resourcePath}' for type '{NormalizeTypeName(forType.FullName)}'");
			return true;
		}

		public static bool RegisterGameObject(string resourcePath, GameObject gameObject)
		{
			return RegisterAsset(resourcePath, (Object)(object)gameObject);
		}

		public static bool IsRegistered(string resourcePath)
		{
			return _registeredAssets.ContainsKey(resourcePath);
		}

		public static Object? GetRegisteredAsset(string resourcePath)
		{
			_registeredAssets.TryGetValue(resourcePath, out Object value);
			return value;
		}

		public static T? GetRegisteredAsset<T>(string resourcePath) where T : Object
		{
			string typedKey = GetTypedKey(resourcePath, typeof(T));
			if (_typedAssets.TryGetValue(typedKey, out Object value))
			{
				return (T)(object)((value is T) ? value : null);
			}
			if (_registeredAssets.TryGetValue(resourcePath, out Object value2))
			{
				return (T)(object)((value2 is T) ? value2 : null);
			}
			return default(T);
		}

		internal static Object? GetRegisteredAssetForType(string resourcePath, Type type)
		{
			string typedKey = GetTypedKey(resourcePath, type);
			if (_typedAssets.TryGetValue(typedKey, out Object value))
			{
				return value;
			}
			foreach (KeyValuePair<string, Object> typedAsset in _typedAssets)
			{
				if (typedAsset.Key.StartsWith(resourcePath + "|") && type.IsInstanceOfType(typedAsset.Value))
				{
					return typedAsset.Value;
				}
			}
			_registeredAssets.TryGetValue(resourcePath, out Object value2);
			return value2;
		}

		internal static bool UnregisterAssetIfMatches(string resourcePath, Object expectedAsset)
		{
			if (string.IsNullOrEmpty(resourcePath) || expectedAsset == null)
			{
				return false;
			}
			bool flag = false;
			if (_registeredAssets.TryGetValue(resourcePath, out Object value) && AreSameAsset(value, expectedAsset))
			{
				flag = _registeredAssets.Remove(resourcePath);
			}
			string value2 = resourcePath + "|";
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, Object> typedAsset in _typedAssets)
			{
				if (typedAsset.Key.StartsWith(value2, StringComparison.Ordinal) && AreSameAsset(typedAsset.Value, expectedAsset))
				{
					list.Add(typedAsset.Key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				flag = _typedAssets.Remove(list[i]) || flag;
			}
			return flag;
		}

		private static bool AreSameAsset(Object left, Object right)
		{
			return left == right || (left != (Object)null && right != (Object)null && left == right);
		}

		private static string GetTypedKey(string resourcePath, Type type)
		{
			return resourcePath + "|" + NormalizeTypeName(type.FullName);
		}

		private static string NormalizeTypeName(string? typeName)
		{
			if (string.IsNullOrEmpty(typeName))
			{
				return typeName ?? string.Empty;
			}
			if (typeName.StartsWith("Il2Cpp"))
			{
				return typeName.Substring(6);
			}
			return typeName;
		}

		private static void EnsurePatched()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			if (_isPatched)
			{
				return;
			}
			try
			{
				Harmony val = new Harmony("S1API.RuntimeResourceRegistry");
				MethodInfo[] methods = typeof(Resources).GetMethods(BindingFlags.Static | BindingFlags.Public);
				MethodInfo methodInfo = null;
				MethodInfo methodInfo2 = null;
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo3 in array)
				{
					if (!(methodInfo3.Name != "Load"))
					{
						ParameterInfo[] parameters = methodInfo3.GetParameters();
						if (methodInfo == null && parameters.Length == 2 && parameters[0].ParameterType == typeof(string) && parameters[1].ParameterType.Name == "Type" && !methodInfo3.IsGenericMethod)
						{
							methodInfo = methodInfo3;
						}
						if (methodInfo2 == null && parameters.Length == 1 && parameters[0].ParameterType == typeof(string) && methodInfo3.ReturnType == typeof(Object) && !methodInfo3.IsGenericMethod)
						{
							methodInfo2 = methodInfo3;
						}
					}
				}
				if (methodInfo != null)
				{
					MethodInfo method = typeof(RuntimeResourceRegistry).GetMethod("ResourcesLoadPrefix", BindingFlags.Static | BindingFlags.NonPublic);
					if (method != null)
					{
						val.Patch((MethodBase)methodInfo, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
				}
				if (methodInfo2 != null)
				{
					MethodInfo method2 = typeof(RuntimeResourceRegistry).GetMethod("ResourcesLoadStringPrefix", BindingFlags.Static | BindingFlags.NonPublic);
					if (method2 != null)
					{
						val.Patch((MethodBase)methodInfo2, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
				}
				_isPatched = true;
				Logger.Debug($"Patched Resources.Load methods (typed={methodInfo != null}, string={methodInfo2 != null})");
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to patch Resources.Load: " + ex.Message);
				Logger.Error(ex.StackTrace ?? "No stack trace available");
			}
		}

		private static bool ResourcesLoadPrefix(string path, Type systemTypeInstance, ref Object __result)
		{
			if (string.IsNullOrEmpty(path))
			{
				return true;
			}
			string text = ((systemTypeInstance != null) ? systemTypeInstance.FullName : null);
			string text2 = ((systemTypeInstance != null) ? ((MemberInfo)systemTypeInstance).Name : null) ?? "null";
			if (!string.IsNullOrEmpty(text))
			{
				string text3 = NormalizeTypeName(text);
				string key = path + "|" + text3;
				if (_typedAssets.TryGetValue(key, out Object value))
				{
					__result = value;
					return false;
				}
				foreach (KeyValuePair<string, Object> typedAsset in _typedAssets)
				{
					if (typedAsset.Key.StartsWith(path + "|"))
					{
						__result = typedAsset.Value;
						return false;
					}
				}
			}
			if (_registeredAssets.TryGetValue(path, out Object value2))
			{
				if (systemTypeInstance == (Type)null)
				{
					__result = value2;
					return false;
				}
				GameObject val = (GameObject)(object)((value2 is GameObject) ? value2 : null);
				if (val == null)
				{
					__result = value2;
					return false;
				}
				try
				{
					Component component = val.GetComponent(systemTypeInstance);
					if ((Object)(object)component != (Object)null)
					{
						__result = (Object)(object)component;
						return false;
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to get component '" + text2 + "' from GameObject: " + ex.Message);
				}
				Logger.Warning($"Registered GameObject at '{path}' does not have component of type '{text2}'");
			}
			return true;
		}

		private static bool ResourcesLoadStringPrefix(string path, ref Object __result)
		{
			if (string.IsNullOrEmpty(path))
			{
				return true;
			}
			if (_registeredAssets.TryGetValue(path, out Object value))
			{
				__result = value;
				return false;
			}
			return true;
		}
	}
	public static class TextureUtils
	{
		private static readonly Log Logger = new Log("TextureUtils");

		public static Texture2D? LoadTextureFromResource(Assembly assembly, string resourceName, FilterMode filterMode = (FilterMode)1, TextureWrapMode wrapMode = (TextureWrapMode)1)
		{
			//IL_0074: 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)
			if (assembly == null)
			{
				Logger.Error("Assembly is null when loading texture resource: " + resourceName);
				return null;
			}
			try
			{
				using Stream stream = assembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					Logger.Error("Texture resource not found: " + resourceName);
					return null;
				}
				byte[] array = new byte[stream.Length];
				stream.Read(array, 0, array.Length);
				return LoadTextureFromBytes(array, filterMode, wrapMode);
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to load texture from resource '{resourceName}': {value}");
				return null;
			}
		}

		public static Texture2D? LoadTextureFromBytes(byte[] imageData, FilterMode filterMode = (FilterMode)1, TextureWrapMode wrapMode = (TextureWrapMode)1)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_001f: 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)
			try
			{
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(imageData), false))
				{
					((Texture)val).filterMode = filterMode;
					((Texture)val).wrapMode = wrapMode;
					return val;
				}
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to load texture from bytes: {value}");
			}
			return null;
		}

		public static Texture2D? LoadTextureFromFile(string filePath, FilterMode filterMode = (FilterMode)1, TextureWrapMode wrapMode = (TextureWrapMode)1)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(filePath))
			{
				Logger.Error("Texture file not found: " + filePath);
				return null;
			}
			try
			{
				byte[] imageData = File.ReadAllBytes(filePath);
				return LoadTextureFromBytes(imageData, filterMode, wrapMode);
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to load texture from file '{filePath}': {value}");
				return null;
			}
		}
	}
}
namespace S1API.Quests
{
	public abstract class Quest : Saveable
	{
		public readonly List<QuestEntry> QuestEntries = new List<QuestEntry>();

		[SaveableField("QuestData")]
		private readonly QuestData _questData;

		internal readonly Quest S1Quest;

		private readonly GameObject _gameObject;

		protected abstract string Title { get; }

		protected abstract string Description { get; }

		protected virtual bool AutoBegin => true;

		protected QuestState QuestState => (QuestState)S1Quest.State;

		internal string? SaveFolder => S1Quest.SaveFolderName;

		protected virtual Sprite? QuestIcon => null;

		public event Action OnComplete
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1Quest.onComplete);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1Quest.onComplete);
			}
		}

		public event Action? OnFail;

		public Quest()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			_questData = new QuestData(GetType().Name);
			_gameObject = new GameObject("Quest");
			S1Quest = _gameObject.AddComponent<Quest>();
			S1Quest.StaticGUID = string.Empty;
			S1Quest.title = Title;
			S1Quest.onActiveState = new UnityEvent();
			S1Quest.onComplete = new UnityEvent();
			S1Quest.onInitialComplete = new UnityEvent();
			S1Quest.onQuestBegin = new UnityEvent();
			S1Quest.onQuestEnd = new UnityEvent<EQuestState>();
			S1Quest.onTrackChange = new UnityEvent<bool>();
			S1Quest.TrackOnBegin = true;
			S1Quest.AutoCompleteOnAllEntriesComplete = true;
			S1Quest.autoInitialize = false;
			GameObject val = new GameObject("IconPrefab", (Type[])(object)new Type[3]
			{
				CrossType.Of<RectTransform>(),
				CrossType.Of<CanvasRenderer>(),
				CrossType.Of<Image>()
			});
			val.transform.SetParent(_gameObject.transform);
			Image component = val.GetComponent<Image>();
			component.sprite = QuestIcon ?? ((App<ContactsApp>)(object)PlayerSingleton<ContactsApp>.Instance).AppIcon;
			S1Quest.IconPrefab = val.GetComponent<RectTransform>();
			GameObject val2 = new GameObject("PoIUIPrefab", (Type[])(object)new Type[4]
			{
				CrossType.Of<RectTransform>(),
				CrossType.Of<CanvasRenderer>(),
				CrossType.Of<EventTrigger>(),
				CrossType.Of<Button>()
			});
			val2.transform.SetParent(_gameObject.transform);
			GameObject val3 = new GameObject("MainLabel", (Type[])(object)new Type[3]
			{
				CrossType.Of<RectTransform>(),
				CrossType.Of<CanvasRenderer>(),
				CrossType.Of<Text>()
			});
			val3.transform.SetParent(val2.transform);
			GameObject val4 = new GameObject("IconContainer", (Type[])(object)new Type[3]
			{
				CrossType.Of<RectTransform>(),
				CrossType.Of<CanvasRenderer>(),
				CrossType.Of<Image>()
			});
			val4.transform.SetParent(val2.transform);
			Image component2 = val4.GetComponent<Image>();
			component2.sprite = QuestIcon ?? ((App<ContactsApp>)(object)PlayerSingleton<ContactsApp>.Instance).AppIcon;
			RectTransform component3 = ((Component)component2).GetComponent<RectTransform>();
			component3.sizeDelta = new Vector2(20f, 20f);
			GameObject val5 = new GameObject("POIPrefab");
			val5.SetActive(false);
			val5.transform.SetParent(_gameObject.transform);
			POI val6 = val5.AddComponent<POI>();
			val6.DefaultMainText = "Did it work?";
			val6.UIPrefab = val2;
			S1Quest.PoIPrefab = val5;
			S1Quest.onQuestEnd.AddListener(UnityAction<EQuestState>.op_Implicit((Action<EQuestState>)OnQuestEnded));
		}

		internal override void CreateInternal()
		{
			base.CreateInternal();
			Quest s1Quest = S1Quest;
			string title = Title;
			string description = Description;
			Il2CppReferenceArray<QuestEntryData> obj = Il2CppReferenceArray<QuestEntryData>.op_Implicit(Array.Empty<QuestEntryData>());
			Quest s1Quest2 = S1Quest;
			s1Quest.InitializeQuest(title, description, obj, (s1Quest2 != null) ? s1Quest2.StaticGUID : null);
			if (AutoBegin)
			{
				Quest s1Quest3 = S1Quest;
				if (s1Quest3 != null)
				{
					s1Quest3.Begin(true);
				}
			}
		}

		internal override void SaveInternal(string folderPath, ref List<string> extraSaveables)
		{
			string text = Path.Combine(folderPath, S1Quest.SaveFolderName);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			base.SaveInternal(text, ref extraSaveables);
		}

		internal void OnQuestEnded(EQuestState questState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)questState == 3)
			{
				this.OnFail?.Invoke();
			}
			Quest.Quests.Remove(S1Quest);
			QuestManager.Quests.Remove(this);
		}

		protected QuestEntry AddEntry(string title, Vector3? poiPosition = null)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			QuestEntry questEntry = CreateEntry(title);
			if (poiPosition.HasValue)
			{
				questEntry.POIPosition = poiPosition.Value;
			}
			return questEntry;
		}

		protected QuestEntry AddEntry(string title, NPC npc)
		{
			if (npc == null)
			{
				throw new ArgumentNullException("npc");
			}
			QuestEntry questEntry = CreateEntry(title);
			questEntry.SetPOIToNPC(npc);
			return questEntry;
		}

		private QuestEntry CreateEntry(string title)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("QuestEntry");
			Transform transform = val.transform;
			GameObject gameObject = _gameObject;
			transform.SetParent((gameObject != null) ? gameObject.transform : null);
			QuestEntry val2 = val.AddComponent<QuestEntry>();
			val2.PoILocation = null;
			val2.AutoCreatePoI = false;
			val2.AutoUpdatePoILocation = false;
			S1Quest.Entries.Add(val2);
			QuestEntry questEntry = new QuestEntry(val2)
			{
				Title = title
			};
			QuestEntries.Add(questEntry);
			return questEntry;
		}

		public void Begin()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.Begin(true);
			}
		}

		public void Cancel()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.Cancel(true);
			}
		}

		public void Expire()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.Expire(true);
			}
		}

		public void Fail()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.Fail(true);
			}
		}

		public void Complete()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.Complete(true);
			}
		}

		public void End()
		{
			Quest s1Quest = S1Quest;
			if (s1Quest != null)
			{
				s1Quest.End();
			}
		}
	}
	public class QuestData
	{
		public readonly string ClassName;

		public QuestData(string className)
		{
			ClassName = className;
		}
	}
	public class QuestEntry
	{
		private const string FixedPoiAnchorName = "S1API.FixedPoiAnchor";

		internal readonly QuestEntry S1QuestEntry;

		private Transform? _fixedPoiAnchor;

		private object? _ensurePoiPresentationCoroutine;

		public QuestState State => (QuestState)S1QuestEntry.State;

		public string Title
		{
			get
			{
				return S1QuestEntry.Title;
			}
			set
			{
				S1QuestEntry.SetEntryTitle(value);
			}
		}

		public Vector3 POIPosition
		{
			get
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				Transform poILocation = S1QuestEntry.PoILocation;
				if ((Object)(object)poILocation != (Object)null)
				{
					return poILocation.position;
				}
				return Vector3.zero;
			}
			set
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				Transform orCreateFixedPoiAnchor = GetOrCreateFixedPoiAnchor();
				orCreateFixedPoiAnchor.position = value;
				BindPoiLocation(orCreateFixedPoiAnchor, autoUpdatePoILocation: false);
			}
		}

		public event Action OnComplete
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1QuestEntry.onComplete);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1QuestEntry.onComplete);
			}
		}

		internal QuestEntry(QuestEntry questEntry)
		{
			S1QuestEntry = questEntry;
		}

		public void Begin()
		{
			S1QuestEntry.Begin();
		}

		public void Complete()
		{
			S1QuestEntry.Complete();
		}

		public void SetState(QuestState questState)
		{
			S1QuestEntry.SetState((EQuestState)questState, true);
		}

		public bool SetPOIToNPC<T>() where T : NPC
		{
			NPC nPC = NPC.Get<T>();
			if (nPC == null)
			{
				return false;
			}
			return SetPOIToNPC(nPC);
		}

		public bool SetPOIToNPC(NPC npc)
		{
			if (npc == null || (Object)(object)npc.gameObject == (Object)null)
			{
				return false;
			}
			Transform transform = npc.Transform;
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			BindPoiLocation(transform, autoUpdatePoILocation: true);
			return true;
		}

		public bool SetPOIToSpraySurface(SpraySurface spraySurface)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (spraySurface == null)
			{
				return false;
			}
			POIPosition = spraySurface.Position;
			return true;
		}

		public void ClearPOI()
		{
			StopPendingPoiPresentation();
			S1QuestEntry.PoILocation = null;
			S1QuestEntry.AutoCreatePoI = false;
			S1QuestEntry.AutoUpdatePoILocation = false;
			if ((Object)(object)S1QuestEntry.PoI != (Object)null)
			{
				S1QuestEntry.DestroyPoI();
			}
			S1QuestEntry.UpdateCompassElement();
		}

		private void BindPoiLocation(Transform poiLocation, bool autoUpdatePoILocation)
		{
			S1QuestEntry.PoILocation = poiLocation;
			S1QuestEntry.AutoCreatePoI = true;
			S1QuestEntry.AutoUpdatePoILocation = autoUpdatePoILocation;
			SyncPoiInstancePosition();
			SchedulePoiPresentation();
		}

		private Transform GetOrCreateFixedPoiAnchor()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if ((Object)(object)_fixedPoiAnchor != (Object)null)
			{
				return _fixedPoiAnchor;
			}
			Transform val = ((Component)S1QuestEntry).transform.Find("S1API.FixedPoiAnchor");
			if ((Object)(object)val != (Object)null)
			{
				_fixedPoiAnchor = val;
				return _fixedPoiAnchor;
			}
			GameObject val2 = new GameObject("S1API.FixedPoiAnchor");
			val2.transform.SetParent(((Component)S1QuestEntry).transform, false);
			_fixedPoiAnchor = val2.transform;
			return _fixedPoiAnchor;
		}

		private void SchedulePoiPresentation()
		{
			StopPendingPoiPresentation();
			_ensurePoiPresentationCoroutine = MelonCoroutines.Start(EnsurePoiPresentation());
		}

		private void StopPendingPoiPresentation()
		{
			if (_ensurePoiPresentationCoroutine != null)
			{
				MelonCoroutines.Stop(_ensurePoiPresentationCoroutine);
				_ensurePoiPresentationCoroutine = null;
			}
		}

		private IEnumerator EnsurePoiPresentation()
		{
			yield return null;
			try
			{
				if (!((Object)(object)S1QuestEntry.PoILocation == (Object)null))
				{
					if (S1QuestEntry.AutoCreatePoI && (Object)(object)S1QuestEntry.PoI == (Object)null)
					{
						S1QuestEntry.CreatePoI();
					}
					if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(S1QuestEntry, "compassElement") == null)
					{
						S1QuestEntry.CreateCompassElement();
					}
					SyncPoiInstancePosition();
					S1QuestEntry.UpdateCompassElement();
				}
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Debug.LogWarning(Object.op_Implicit("[S1API] Failed to update POI presentation for quest entry: " + ex2.Message));
			}
			finally
			{
				_ensurePoiPresentationCoroutine = null;
			}
		}

		private void SyncPoiInstancePosition()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)S1QuestEntry.PoI == (Object)null) && !((Object)(object)S1QuestEntry.PoILocation == (Object)null))
			{
				((Component)S1QuestEntry.PoI).transform.position = S1QuestEntry.PoILocation.position;
				S1QuestEntry.PoI.UpdatePosition();
			}
		}
	}
	public static class QuestManager
	{
		internal static readonly List<Quest> Quests = new List<Quest>();

		public static Quest CreateQuest<T>(string? guid = null) where T : Quest
		{
			return CreateQuest(typeof(T), guid);
		}

		public static Quest CreateQuest(Type questType, string? guid = null)
		{
			Quest quest = (Quest)Activator.CreateInstance(questType);
			if (quest == null)
			{
				throw new Exception("Unable to create quest instance of " + questType.FullName + "!");
			}
			Quests.Add(quest);
			return quest;
		}

		public static Quest? GetQuestByGuid(string guid)
		{
			return Quests.FirstOrDefault((Quest x) => x.S1Quest.StaticGUID == guid);
		}

		public static Quest? GetQuestByName(string questName)
		{
			return Quests.FirstOrDefault((Quest x) => x.S1Quest.Title == questName);
		}

		internal static object? GetBaseGameQuestByName(string questTitle)
		{
			try
			{
				List<Quest> quests = Quest.Quests;
				if (quests != null)
				{
					for (int i = 0; i < quests.Count; i++)
					{
						Quest val = quests[i];
						if ((Object)(object)val != (Object)null && val.Title == questTitle)
						{
							return val;
						}
					}
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Error("[QuestManager] Exception while searching for base game quest '" + questTitle + "': " + ex.Message);
			}
			return null;
		}

		public static QuestWrapper? Get<T>() where T : IQuestIdentifier
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			Type typeFromHandle = typeof(T);
			string text = TryGetNameFromIdentifier(typeFromHandle);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			Quest questByName = GetQuestByName(text);
			if (questByName != null)
			{
				return new QuestWrapper(questByName);
			}
			object baseGameQuestByName = GetBaseGameQuestByName(text);
			if (baseGameQuestByName != null)
			{
				return new QuestWrapper((Quest)baseGameQuestByName);
			}
			return null;
		}

		private static string? TryGetNameFromIdentifier(Type t)
		{
			try
			{
				object obj = t.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().FullName == typeof(QuestNameAttribute).FullName);
				if (obj != null)
				{
					return obj.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) as string;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public sealed class QuestWrapper
	{
		private readonly Quest? _modQuest;

		private readonly Quest? _baseGameQuest;

		private readonly bool _isBaseGameQuest;

		private readonly Dictionary<Action, Action<EQuestState>> _failWrapperActions = new Dictionary<Action, Action<EQuestState>>();

		public string Title => _isBaseGameQuest ? _baseGameQuest.Title : _modQuest.S1Quest.Title;

		public List<QuestEntry> QuestEntries
		{
			get
			{
				if (_isBaseGameQuest)
				{
					List<QuestEntry> list = new List<QuestEntry>();
					if (_baseGameQuest.Entries != null)
					{
						Enumerator<QuestEntry> enumerator = _baseGameQuest.Entries.GetEnumerator();
						while (enumerator.MoveNext())
						{
							QuestEntry current = enumerator.Current;
							list.Add(new QuestEntry(current));
						}
					}
					return list;
				}
				return _modQuest.QuestEntries;
			}
		}

		public event Action OnComplete
		{
			add
			{
				if (_isBaseGameQuest)
				{
					global::S1API.Utils.EventHelper.AddListener(value, _baseGameQuest.onComplete);
				}
				else
				{
					_modQuest.OnComplete += value;
				}
			}
			remove
			{
				if (_isBaseGameQuest)
				{
					global::S1API.Utils.EventHelper.RemoveListener(value, _baseGameQuest.onComplete);
				}
				else
				{
					_modQuest.OnComplete -= value;
				}
			}
		}

		public event Action OnFail
		{
			add
			{
				if (_isBaseGameQuest)
				{
					Action<EQuestState> action = delegate(EQuestState state)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0003: Invalid comparison between Unknown and I4
						if ((int)state == 3)
						{
							value?.Invoke();
						}
					};
					_failWrapperActions[value] = action;
					global::S1API.Utils.EventHelper.AddListener(action, _baseGameQuest.onQuestEnd);
				}
				else
				{
					_modQuest.OnFail += value;
				}
			}
			remove
			{
				if (_isBaseGameQuest)
				{
					if (_failWrapperActions.TryGetValue(value, out Action<EQuestState> value2))
					{
						global::S1API.Utils.EventHelper.RemoveListener(value2, _baseGameQuest.onQuestEnd);
						_failWrapperActions.Remove(value);
					}
				}
				else
				{
					_modQuest.OnFail -= value;
				}
			}
		}

		internal QuestWrapper(Quest modQuest)
		{
			_modQuest = modQuest;
			_baseGameQuest = null;
			_isBaseGameQuest = false;
		}

		internal QuestWrapper(Quest baseGameQuest)
		{
			_modQuest = null;
			_baseGameQuest = baseGameQuest;
			_isBaseGameQuest = true;
		}
	}
}
namespace S1API.Quests.Identifiers
{
	[QuestName("Botanists")]
	public sealed class Botanists : IQuestIdentifier
	{
	}
	[QuestName("Chemists")]
	public sealed class Chemists : IQuestIdentifier
	{
	}
	[QuestName("Clean Cash")]
	public sealed class CleanCash : IQuestIdentifier
	{
	}
	[QuestName("Cleaners")]
	public sealed class Cleaners : IQuestIdentifier
	{
	}
	[QuestName("Deal for the Benzies Family")]
	public sealed class DealForCartel : IQuestIdentifier
	{
	}
	[QuestName("Finishing the Job")]
	public sealed class DefeatCartel : IQuestIdentifier
	{
	}
	[QuestName("Dodgy Dealing")]
	public sealed class DodgyDealing : IQuestIdentifier
	{
	}
	[QuestName("Gearing Up")]
	public sealed class GearingUp : IQuestIdentifier
	{
	}
	[QuestName("Getting Started")]
	public sealed class GettingStarted : IQuestIdentifier
	{
	}
	public interface IQuestIdentifier
	{
	}
	[QuestName("Keeping it Fresh")]
	public sealed class KeepingItFresh : IQuestIdentifier
	{
	}
	[QuestName("Making the Rounds")]
	public sealed class MakingTheRounds : IQuestIdentifier
	{
	}
	[QuestName("Mixing Mania")]
	public sealed class MixingMania : IQuestIdentifier
	{
	}
	[QuestName("Money Management")]
	public sealed class MoneyManagement : IQuestIdentifier
	{
	}
	[QuestName("Moving Up")]
	public sealed class MovingUp : IQuestIdentifier
	{
	}
	[QuestName("Needin' the Green")]
	public sealed class NeedingTheGreen : IQuestIdentifier
	{
	}
	[QuestName("On the Grind")]
	public sealed class OnTheGrind : IQuestIdentifier
	{
	}
	[QuestName("Handlers")]
	public sealed class Packagers : IQuestIdentifier
	{
	}
	[QuestName("Packin'")]
	public sealed class Packin : IQuestIdentifier
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class QuestNameAttribute : Attribute
	{
		public string Name { get; }

		public QuestNameAttribute(string name)
		{
			Name = name;
		}
	}
	[QuestName("Unfavourable Agreements")]
	public sealed class UnfavourableAgreements : IQuestIdentifier
	{
	}
	[QuestName("Wretched Hive of Scum and Villainy")]
	public sealed class Warehouse : IQuestIdentifier
	{
	}
	[QuestName("Welcome to Hyland Point")]
	public sealed class WelcomeToHylandPoint : IQuestIdentifier
	{
	}
	[QuestName("We Need To Cook")]
	public sealed class WeNeedToCook : IQuestIdentifier
	{
	}
}
namespace S1API.Quests.Constants
{
	public enum QuestAction
	{
		Begin,
		Success,
		Fail,
		Expire,
		Cancel
	}
	public enum QuestState
	{
		Inactive,
		Active,
		Completed,
		Failed,
		Expired,
		Cancelled
	}
}
namespace S1API.Property
{
	public abstract class BaseProperty
	{
		public abstract string PropertyName { get; }

		public abstract string PropertyCode { get; }

		public abstract float Price { get; set; }

		public abstract bool IsOwned { get; }

		public abstract int EmployeeCapacity { get; set; }

		public abstract void SetOwned();

		public abstract bool IsPointInside(Vector3 point);
	}
	public static class BusinessManager
	{
		public static List<BusinessWrapper> GetAllBusinesses()
		{
			List<BusinessWrapper> list = new List<BusinessWrapper>();
			Enumerator<Business> enumerator = Business.Businesses.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Business current = enumerator.Current;
				list.Add(new BusinessWrapper(current));
			}
			return list;
		}

		public static List<BusinessWrapper> GetOwnedBusinesses()
		{
			List<BusinessWrapper> list = new List<BusinessWrapper>();
			Enumerator<Business> enumerator = Business.OwnedBusinesses.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Business current = enumerator.Current;
				list.Add(new BusinessWrapper(current));
			}
			return list;
		}

		public static BusinessWrapper? FindBusinessByName(string name)
		{
			Enumerator<Business> enumerator = Business.Businesses.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Business current = enumerator.Current;
				if (((Property)current).PropertyName == name)
				{
					return new BusinessWrapper(current);
				}
			}
			return null;
		}
	}
	public class BusinessWrapper : PropertyWrapper
	{
		internal readonly Business InnerBusiness;

		public float LaunderCapacity
		{
			get
			{
				return InnerBusiness.LaunderCapacity;
			}
			set
			{
				InnerBusiness.LaunderCapacity = value;
				foreach (string launderingCapacityPath in LaunderingCapacityPaths)
				{
					if (TrySetTMPText(launderingCapacityPath, MoneyManager.FormatAmount(value, false, false), "laundering capacity"))
					{
						break;
					}
				}
			}
		}

		public List<LaunderingOperation> LaunderingOperations
		{
			get
			{
				List<LaunderingOperation> list = new List<LaunderingOperation>();
				Enumerator<LaunderingOperation> enumerator = InnerBusiness.LaunderingOperations.GetEnumerator();
				while (enumerator.MoveNext())
				{
					LaunderingOperation current = enumerator.Current;
					list.Add(new LaunderingOperation(current));
				}
				return list;
			}
		}

		public float CurrentLaunderTotal => InnerBusiness.currentLaunderTotal;

		public float AppliedLaunderLimit => InnerBusiness.appliedLaunderLimit;

		public int LaunderingOperationCount => InnerBusiness.LaunderingOperations.Count;

		public bool IsAtLaunderingCapacity => AppliedLaunderLimit <= 0f;

		public float LaunderingCapacityUsagePercent => (LaunderCapacity > 0f) ? (CurrentLaunderTotal / LaunderCapacity) : 0f;

		internal override string SignPrefix => "@Businesses/";

		internal override IEnumerable<string> SignPaths
		{
			get
			{
				string baseName = PropertyName.Replace(" ", "");
				yield return SignPrefix + baseName + "/ForSaleSign_Blue/Price";
				yield return SignPrefix + baseName + "/ForSaleSign_Blue (1)/Price";
				yield return SignPrefix + PropertyName + "/ForSaleSign_Blue/Price";
				yield return SignPrefix + PropertyName + "/ForSaleSign_Blue (1)/Price";
			}
		}

		internal override string WhiteboardPath => "Map/Container/RE Office/Interior/Whiteboard (1)/PropertyListing " + PropertyName + "/Price";

		internal IEnumerable<string> LaunderingCapacityPaths
		{
			get
			{
				string baseName = PropertyName.Replace(" ", "");
				yield return "@Businesses/" + baseName + "/Grid/ItemContainer/LaunderingStation_Built(Clone)/LaunderingInterface/CurrentOperations/Total/Max";
				yield return "@Businesses/" + PropertyName + "/Grid/ItemContainer/LaunderingStation_Built(Clone)/LaunderingInterface/CurrentOperations/Total/Max";
				yield return "@Businesses/" + baseName + "/Grid (1)/ItemContainer/LaunderingStation_Built(Clone)/LaunderingInterface/CurrentOperations/Total/Max";
				yield return "@Businesses/" + PropertyName + "/Grid (1)/ItemContainer/LaunderingStation_Built(Clone)/LaunderingInterface/CurrentOperations/Total/Max";
			}
		}

		public BusinessWrapper(Business business)
			: base((Property)(object)business)
		{
			InnerBusiness = business;
		}

		public void AddLaunderingOperation(float amount, int minutesSinceStarted)
		{
			InnerBusiness.StartLaunderingOperation(amount, minutesSinceStarted);
		}
	}
	public class LaunderingOperation
	{
		internal readonly LaunderingOperation InnerLaunderingOperation;

		public BusinessWrapper Business
		{
			get
			{
				return new BusinessWrapper(InnerLaunderingOperation.business);
			}
			set
			{
				InnerLaunderingOperation.business = value.InnerBusiness;
			}
		}

		public float Amount
		{
			get
			{
				return InnerLaunderingOperation.amount;
			}
			set
			{
				InnerLaunderingOperation.amount = value;
			}
		}

		public int MinutesSinceStarted
		{
			get
			{
				return InnerLaunderingOperation.minutesSinceStarted;
			}
			set
			{
				InnerLaunderingOperation.minutesSinceStarted = value;
			}
		}

		public int CompletionTimeInMinutes
		{
			get
			{
				return InnerLaunderingOperation.completionTime_Minutes;
			}
			set
			{
				InnerLaunderingOperation.completionTime_Minutes = value;
			}
		}

		public LaunderingOperation(LaunderingOperation launderingOperation)
		{
			InnerLaunderingOperation = launderingOperation;
		}

		public LaunderingOperation(BusinessWrapper business, float amount, int minutesSinceStarted, int completionTimeInMinutes = 1140)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			InnerLaunderingOperation = new LaunderingOperation(business.InnerBusiness, amount, minutesSinceStarted);
			InnerLaunderingOperation.completionTime_Minutes = completionTimeInMinutes;
		}
	}
	public static class PropertyManager
	{
		public static List<PropertyWrapper> GetAllProperties()
		{
			List<PropertyWrapper> list = new List<PropertyWrapper>();
			Enumerator<Property> enumerator = Property.Properties.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Property current = enumerator.Current;
				list.Add(new PropertyWrapper(current));
			}
			return list;
		}

		public static List<PropertyWrapper> GetOwnedProperties()
		{
			List<PropertyWrapper> list = new List<PropertyWrapper>();
			Enumerator<Property> enumerator = Property.OwnedProperties.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Property current = enumerator.Current;
				list.Add(new PropertyWrapper(current));
			}
			return list;
		}

		public static PropertyWrapper? FindPropertyByName(string name)
		{
			Enumerator<Property> enumerator = Property.Properties.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Property current = enumerator.Current;
				if (current.PropertyName == name)
				{
					return new PropertyWrapper(current);
				}
			}
			return null;
		}
	}
	public class PropertyWrapper : BaseProperty
	{
		private static readonly Log Logger = new Log("PropertyWrapper");

		internal readonly Property InnerProperty;

		public override string PropertyName => InnerProperty.PropertyName;

		public override string PropertyCode => InnerProperty.PropertyCode;

		public override float Price
		{
			get
			{
				return InnerProperty.Price;
			}
			set
			{
				InnerProperty.Price = value;
				UpdatePriceDisplay(value);
			}
		}

		public override bool IsOwned => InnerProperty.IsOwned;

		public override int EmployeeCapacity
		{
			get
			{
				return InnerProperty.EmployeeCapacity;
			}
			set
			{
				InnerProperty.EmployeeCapacity = value;
			}
		}

		public Vector3 ExteriorSpawnPosition => InnerProperty.SpawnPoint.position;

		public Vector3 InteriorSpawnPosition => InnerProperty.InteriorSpawnPoint.position;

		public int LoadingDockCount => InnerProperty.LoadingDockCount;

		public float DefaultRotation => InnerProperty.DefaultRotation;

		public bool AvailableInDemo => InnerProperty.AvailableInDemo;

		public bool IsContentCulled
		{
			get
			{
				return InnerProperty.IsContentCulled;
			}
			set
			{
				InnerProperty.SetContentCulled(value);
			}
		}

		public int EmployeeCount => InnerProperty.Employees.Count;

		public int BuildableItemCount => GetCollectionCount(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(InnerProperty, "BuildableItems"), "BuildableItems");

		public Vector3 NPCSpawnPosition => ((Object)(object)InnerProperty.NPCSpawnPoint != (Object)null) ? InnerProperty.NPCSpawnPoint.position : Vector3.zero;

		public int EmployeeIdlePointCount => ((Il2CppArrayBase<Transform>)(object)InnerProperty.EmployeeIdlePoints)?.Length ?? 0;

		internal virtual string SignPrefix => "@Properties/";

		internal virtual string WhiteboardPath => "Map/Container/RE Office/Interior/Whiteboard/PropertyListing " + PropertyName + "/Price";

		internal virtual IEnumerable<string> SignPaths
		{
			get
			{
				string baseName = PropertyName.Replace(" ", "");
				yield return SignPrefix + baseName + "/ForSaleSign/Price";
				yield return SignPrefix + PropertyName + "/ForSaleSign/Price";
				yield return SignPrefix + baseName + "/ForSaleSign (1)/Price";
				yield return SignPrefix + PropertyName + "/ForSaleSign (1)/Price";
			}
		}

		public PropertyWrapper(Property property)
		{
			InnerProperty = property;
		}

		public override void SetOwned()
		{
			InnerProperty.SetOwned();
		}

		public override bool IsPointInside(Vector3 point)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return InnerProperty.DoBoundsContainPoint(point);
		}

		private int GetCollectionCount(object? collectionValue, string memberName)
		{
			if (collectionValue == null)
			{
				return 0;
			}
			if (!(collectionValue is IList { Count: var count }))
			{
				Logger.Warning($"{GetType().Name}.{memberName}: value of type '{collectionValue.GetType().FullName}' does not implement IList; using fallback count path.");
				Type type = collectionValue.GetType();
				try
				{
					PropertyInfo property = type.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
					if (property != null && property.GetValue(collectionValue, null) is int result)
					{
						return result;
					}
					PropertyInfo property2 = type.GetProperty("Length", BindingFlags.Instance | BindingFlags.Public);
					if (property2 != null && property2.GetValue(collectionValue, null) is int result2)
					{
						return result2;
					}
				}
				catch (Exception ex)
				{
					Logger.Warning($"{GetType().Name}.{memberName}: failed reading Count/Length via reflection from '{type.FullName}': {ex.Message}");
				}
				if (collectionValue is IEnumerable enumerable)
				{
					int num = 0;
					{
						IEnumerator enumerator = enumerable.GetEnumerator();
						try
						{
							while (enumerator.MoveNext())
							{
								num++;
							}
						}
						finally
						{
							IDisposable disposable = enumerator as IDisposable;
							if (disposable != null)
							{
								disposable.Dispose();
							}
						}
					}
					return num;
				}
				Logger.Warning($"{GetType().Name}.{memberName}: unable to determine count for value of type '{type.FullName}'; returning 0.");
				return 0;
			}
			return count;
		}

		public Vector3 GetEmployeeIdlePointPosition(int index)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (InnerProperty.EmployeeIdlePoints != null && index >= 0 && index < ((Il2CppArrayBase<Transform>)(object)InnerProperty.EmployeeIdlePoints).Length && (Object)(object)((Il2CppArrayBase<Transform>)(object)InnerProperty.EmployeeIdlePoints)[index] != (Object)null)
			{
				return ((Il2CppArrayBase<Transform>)(object)InnerProperty.EmployeeIdlePoints)[index].position;
			}
			return Vector3.zero;
		}

		public int GetUnassignedBedCount()
		{
			return InnerProperty.GetUnassignedBeds().Count;
		}

		internal void UpdatePriceDisplay(float price)
		{
			string priceText = MoneyManager.FormatAmount(price, false, false);
			TrySetTMPText(WhiteboardPath, priceText, "whiteboard");
			foreach (string signPath in SignPaths)
			{
				if (TrySetTMPText(signPath, priceText, "sign"))
				{
					break;
				}
			}
		}

		internal bool TrySetTMPText(string path, string priceText, string context)
		{
			GameObject val = GameObject.Find(path);
			if ((Object)(object)val != (Object)null)
			{
				TMP_Text component = val.GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null)
				{
					component.text = priceText;
					return true;
				}
				Debug.LogWarning(Object.op_Implicit("TMP_Text not found on " + context + " price object."));
			}
			else
			{
				Debug.LogWarning(Object.op_Implicit(context + " price object not found at path: " + path));
			}
			return false;
		}
	}
}
namespace S1API.Properties
{
	public sealed class CustomEffect : ProductPropertyWrapper
	{
		internal CustomEffect(Effect effect)
			: base(effect)
		{
		}
	}
	public sealed class CustomEffectBuilder
	{
		private static readonly Log Logger = new Log("CustomEffectBuilder");

		private string _id = string.Empty;

		private string _name = string.Empty;

		private string _description = string.Empty;

		private int _tier = 1;

		private float _addictiveness = 0.1f;

		private Color _productColor = Color.white;

		private Color _labelColor = Color.white;

		private int _valueChange;

		private float _valueMultiplier = 1f;

		private float _addBaseValueMultiple;

		private Vector2 _mixDirection = Vector2.zero;

		private float _mixMagnitude = 1f;

		private Vector2? _mixMapPosition;

		private float _mixMapRadius;

		private DrugType[]? _drugs;

		private Action<Player>? _playerBehavior;

		private Action<NPC>? _npcBehavior;

		private Action<Player>? _playerClearBehavior;

		private Action<NPC>? _npcClearBehavior;

		public CustomEffectBuilder WithBasicInfo(string id, string name, string description)
		{
			_id = id ?? string.Empty;
			_name = name ?? string.Empty;
			_description = description ?? string.Empty;
			return this;
		}

		public CustomEffectBuilder WithTier(int tier)
		{
			_tier = Mathf.Clamp(tier, 1, 5);
			return this;
		}

		public CustomEffectBuilder WithAddictiveness(float addictiveness)
		{
			_addictiveness = Mathf.Clamp01(addictiveness);
			return this;
		}

		public CustomEffectBuilder WithValue(int valueChange, float valueMultiplier = 1f, float addBaseValueMultiple = 0f)
		{
			_valueChange = Mathf.Clamp(valueChange, -100, 100);
			_valueMultiplier = Mathf.Clamp(valueMultiplier, 0f, 2f);
			_addBaseValueMultiple = Mathf.Clamp(addBaseValueMultiple, -1f, 1f);
			return this;
		}

		public CustomEffectBuilder WithColors(Color productColor, Color labelColor)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			_productColor = productColor;
			_labelColor = labelColor;
			return this;
		}

		public CustomEffectBuilder WithMixGeometry(Vector2 direction, float magnitude)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			_mixDirection = direction;
			_mixMagnitude = magnitude;
			return this;
		}

		public CustomEffectBuilder WithMixMapPlacement(Vector2 position, float radius)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_mixMapPosition = position;
			_mixMapRadius = radius;
			return this;
		}

		public CustomEffectBuilder ForDrugs(params DrugType[] drugs)
		{
			_drugs = drugs;
			return this;
		}

		public CustomEffectBuilder WithBehavior(Action<Player> onApply)
		{
			_playerBehavior = onApply;
			return this;
		}

		public CustomEffectBuilder WithNpcBehavior(Action<NPC> onApply)
		{
			_npcBehavior = onApply;
			return this;
		}

		public CustomEffectBuilder WithClearBehavior(Action<Player> onClear)
		{
			_playerClearBehavior = onClear;
			return this;
		}

		public CustomEffectBuilder WithNpcClearBehavior(Action<NPC> onClear)
		{
			_npcClearBehavior = onClear;
			return this;
		}

		public CustomEffect Build()
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(_id))
			{
				Logger.Error("Cannot build custom effect: ID is required. Use WithBasicInfo(...) to set the ID.");
				throw new InvalidOperationException("Cannot build custom effect: ID is required.");
			}
			if (CustomEffectRegistry.TryGetExisting(_id, out Effect effect))
			{
				Logger.Warning("Custom effect '" + _id + "' is already registered; returning the existing effect.");
				return new CustomEffect(effect);
			}
			Effect val = (Effect)(object)ScriptableObject.CreateInstance<Refreshing>();
			((Object)val).name = _id;
			val.ID = _id;
			val.Name = (string.IsNullOrEmpty(_name) ? _id : _name);
			val.Description = _description;
			val.Tier = _tier;
			val.Addictiveness = _addictiveness;
			val.ProductColor = _productColor;
			val.LabelColor = _labelColor;
			val.ValueChange = _valueChange;
			val.ValueMultiplier = _valueMultiplier;
			val.AddBaseValueMultiple = _addBaseValueMultiple;
			val.MixDirection = _mixDirection;
			val.MixMagnitude = _mixMagnitude;
			val.ImplementedPriorMixingRework = true;
			if (_playerBehavior != null)
			{
				ProductManager.SetEffectCallback(_id, _playerBehavior);
			}
			if (_npcBehavior != null)
			{
				ProductManager.SetNpcEffectCallback(_id, _npcBehavior);
			}
			if (_playerClearBehavior != null)
			{
				ProductManager.SetEffectClearCallback(_id, _playerClearBehavior);
			}
			if (_npcClearBehavior != null)
			{
				ProductManager.SetNpcEffectClearCallback(_id, _npcClearBehavior);
			}
			CustomEffectRegistry.Register(val, ResolveDrugs(), _mixMapPosition, _mixMapRadius);
			return new CustomEffect(val);
		}

		private EDrugType[] ResolveDrugs()
		{
			DrugType[] array = ((_drugs != null && _drugs.Length != 0) ? _drugs : new DrugType[4]
			{
				DrugType.Marijuana,
				DrugType.Methamphetamine,
				DrugType.Cocaine,
				DrugType.Shrooms
			});
			List<EDrugType> list = new List<EDrugType>(array.Length);
			DrugType[] array2 = array;
			foreach (DrugType drugType in array2)
			{
				list.Add((EDrugType)drugType);
			}
			return list.ToArray();
		}
	}
	public static class EffectCreator
	{
		public static CustomEffectBuilder CreateBuilder()
		{
			return new CustomEffectBuilder();
		}
	}
	public class ProductPropertyWrapper : PropertyBase
	{
		private readonly Effect _innerProperty;

		public override string ID => _innerProperty.ID;

		public override string Name => _innerProperty.Name;

		public override string name => ((Object)_innerProperty).name;

		public override string Description => _innerProperty.Description;

		public override int Tier => _innerProperty.Tier;

		public override float Addictiveness => _innerProperty.Addictiveness;

		internal Effect InnerProperty => _innerProperty;

		internal ProductPropertyWrapper(Effect property)
		{
			_innerProperty = property;
		}
	}
	public static class Property
	{
		public static readonly PropertyBase Munchies = new Munchies();

		public static readonly PropertyBase AntiGravity = new AntiGravity();

		public static readonly PropertyBase Energizing = new Energizing();

		public static readonly PropertyBase Focused = new Focused();

		public static readonly PropertyBase Smelly = new Smelly();

		public static readonly PropertyBase Euphoric = new Euphoric();

		public static readonly PropertyBase Cyclopean = new Cyclopean();

		public static readonly PropertyBase Slippery = new Slippery();

		public static readonly PropertyBase Shrinking = new Shrinking();

		public static readonly PropertyBase Seizure = new Seizure();

		public static readonly PropertyBase Electrifying = new Electrifying();

		public static readonly PropertyBase Zombifying = new Zombifying();

		public static readonly PropertyBase Disorienting = new Disorienting();

		public static readonly PropertyBase Sedating = new Sedating();

		public static readonly PropertyBase CalorieDense = new CalorieDense();

		public static readonly PropertyBase TropicThunder = new TropicThunder();

		public static readonly PropertyBase Toxic = new Toxic();

		public static readonly PropertyBase ThoughtProvoking = new ThoughtProvoking();

		public static readonly PropertyBase Lethal = new Lethal();

		public static readonly PropertyBase Calming = new Calming();

		public static readonly PropertyBase Schizophrenic = new Schizophrenic();

		public static readonly PropertyBase Spicy = new Spicy();

		public static readonly PropertyBase Laxative = new Laxative();

		public static readonly PropertyBase BrightEyed = new BrightEyed();

		public static readonly PropertyBase Sneaky = new Sneaky();

		public static readonly PropertyBase Jennerising = new Jennerising();

		public static readonly PropertyBase Balding = new Balding();

		public static readonly PropertyBase Glowie = new Glowie();

		public static readonly PropertyBase Refreshing = new Refreshing();

		public static readonly PropertyBase Athletic = new Athletic();

		public static readonly PropertyBase LongFaced = new LongFaced();

		public static readonly PropertyBase Paranoia = new Paranoia();

		public static readonly PropertyBase Gingeritis = new Gingeritis();

		public static readonly PropertyBase Foggy = new Foggy();

		public static readonly PropertyBase Explosive = new Explosive();
	}
}
namespace S1API.Properties.Tokens
{
	public sealed class AntiGravity : PropertyToken
	{
		public AntiGravity()
			: base("antigravity", "AntiGravity")
		{
		}
	}
	public sealed class Athletic : PropertyToken
	{
		public Athletic()
			: base("athletic", "Athletic")
		{
		}
	}
	public sealed class Balding : PropertyToken
	{
		public Balding()
			: base("balding", "Balding")
		{
		}
	}
	public sealed class BrightEyed : PropertyToken
	{
		public BrightEyed()
			: base("brighteyed", "BrightEyed")
		{
		}
	}
	public sealed class Calming : PropertyToken
	{
		public Calming()
			: base("calming", "Calming")
		{
		}
	}
	public sealed class CalorieDense : PropertyToken
	{
		public CalorieDense()
			: base("caloriedense", "CalorieDense")
		{
		}
	}
	public sealed class Cyclopean : PropertyToken
	{
		public Cyclopean()
			: base("cyclopean", "Cyclopean")
		{
		}
	}
	public sealed class Disorienting : PropertyToken
	{
		public Disorienting()
			: base("disorienting", "Disorienting")
		{
		}
	}
	public sealed class Electrifying : PropertyToken
	{
		public Electrifying()
			: base("electrifying", "Electrifying")
		{
		}
	}
	public sealed class Energizing : PropertyToken
	{
		public Energizing()
			: base("energizing", "Energizing")
		{
		}
	}
	public sealed class Euphoric : PropertyToken
	{
		public Euphoric()
			: base("euphoric", "Euphoric")
		{
		}
	}
	public sealed class Explosive : PropertyToken
	{
		public Explosive()
			: base("explosive", "Explosive")
		{
		}
	}
	public sealed class Focused : PropertyToken
	{
		public Focused()
			: base("focused", "Focused")
		{
		}
	}
	public sealed class Foggy : PropertyToken
	{
		public Foggy()
			: base("foggy", "Foggy")
		{
		}
	}
	public sealed class Gingeritis : PropertyToken
	{
		public Gingeritis()
			: base("gingeritis", "Gingeritis")
		{
		}
	}
	public sealed class Glowie : PropertyToken
	{
		public Glowie()
			: base("glowie", "Glowie")
		{
		}
	}
	public sealed class Jennerising : PropertyToken
	{
		public Jennerising()
			: base("jennerising", "Jennerising")
		{
		}
	}
	public sealed class Laxative : PropertyToken
	{
		public Laxative()
			: base("laxative", "Laxative")
		{
		}
	}
	public sealed class Lethal : PropertyToken
	{
		public Lethal()
			: base("lethal", "Lethal")
		{
		}
	}
	public sealed class LongFaced : PropertyToken
	{
		public LongFaced()
			: base("longfaced", "LongFaced")
		{
		}
	}
	public sealed class Munchies : PropertyToken
	{
		public Munchies()
			: base("munchies", "Munchies")
		{
		}
	}
	public sealed class Paranoia : PropertyToken
	{
		public Paranoia()
			: base("paranoia", "Paranoia")
		{
		}
	}
	public abstract class PropertyToken : PropertyBase
	{
		private readonly string _id;

		private readonly string _unityName;

		private readonly string _displayName;

		private readonly string _description;

		private readonly int _tier;

		private readonly float _addictiveness;

		public override string ID => _id;

		public override string Name => _displayName;

		public override string name => _unityName;

		public override string Description => _description;

		public override int Tier => _tier;

		public override float Addictiveness => _addictiveness;

		protected PropertyToken(string id, string? unityName = null, string? displayName = null, string? description = null, int tier = 1, float addictiveness = 0f)
		{
			_id = id ?? string.Empty;
			_unityName = unityName ?? id ?? string.Empty;
			_displayName = displayName ?? id ?? string.Empty;
			_description = description ?? string.Empty;
			_tier = tier;
			_addictiveness = addictiveness;
		}
	}
	public sealed class Refreshing : PropertyToken
	{
		public Refreshing()
			: base("refreshing", "Refreshing")
		{
		}
	}
	public sealed class Schizophrenic : PropertyToken
	{
		public Schizophrenic()
			: base("schizophrenic", "Schizophrenic")
		{
		}
	}
	public sealed class Sedating : PropertyToken
	{
		public Sedating()
			: base("sedating", "Sedating")
		{
		}
	}
	public sealed class Seizure : PropertyToken
	{
		public Seizure()
			: base("seizure", "Seizure")
		{
		}
	}
	public sealed class Shrinking : PropertyToken
	{
		public Shrinking()
			: base("shrinking", "Shrinking")
		{
		}
	}
	public sealed class Slippery : PropertyToken
	{
		public Slippery()
			: base("slippery", "Slippery")
		{
		}
	}
	public sealed class Smelly : PropertyToken
	{
		public Smelly()
			: base("smelly", "Smelly")
		{
		}
	}
	public sealed class Sneaky : PropertyToken
	{
		public Sneaky()
			: base("sneaky", "Sneaky")
		{
		}
	}
	public sealed class Spicy : PropertyToken
	{
		public Spicy()
			: base("spicy", "Spicy")
		{
		}
	}
	public sealed class ThoughtProvoking : PropertyToken
	{
		public ThoughtProvoking()
			: base("thoughtprovoking", "ThoughtProvoking")
		{
		}
	}
	public sealed class Toxic : PropertyToken
	{
		public Toxic()
			: base("toxic", "Toxic")
		{
		}
	}
	public sealed class TropicThunder : PropertyToken
	{
		public TropicThunder()
			: base("tropicthunder", "TropicThunder")
		{
		}
	}
	public sealed class Zombifying : PropertyToken
	{
		public Zombifying()
			: base("zombifying", "Zombifying")
		{
		}
	}
}
namespace S1API.Properties.Interfaces
{
	public abstract class PropertyBase
	{
		public abstract string ID { get; }

		public abstract string Name { get; }

		public abstract string name { get; }

		public abstract string Description { get; }

		public abstract int Tier { get; }

		public abstract float Addictiveness { get; }
	}
}
namespace S1API.Products
{
	public class CocaineDefinition : ProductDefinition
	{
		internal CocaineDefinition S1CocaineDefinition => CrossType.As<CocaineDefinition>((object)base.S1ItemDefinition);

		internal CocaineDefinition(CocaineDefinition definition)
			: base((ProductDefinition)(object)definition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new ProductInstance(CrossType.As<ProductItemInstance>((object)((ItemDefinition)S1CocaineDefinition).GetDefaultInstance(quantity)));
		}

		public List<PropertyBase> GetProperties()
		{
			List<PropertyBase> list = new List<PropertyBase>();
			CocaineDefinition s1CocaineDefinition = S1CocaineDefinition;
			List<Effect> val = ((s1CocaineDefinition != null) ? ((PropertyItemDefinition)s1CocaineDefinition).Properties : null);
			if (val != null)
			{
				for (int i = 0; i < val.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(val[i]));
				}
			}
			return list;
		}
	}
	public sealed class CustomProductDefinition : ProductDefinition
	{
		private readonly CustomProductDefinitionMetadata _metadata;

		public ProductKind ProductKind => _metadata.ProductKind;

		public Quality DefaultQuality => _metadata.DefaultQuality;

		public float BaseAddictiveness => base.S1ProductDefinition.BaseAddictiveness;

		public int PlayerEffectDurationSeconds => base.S1ProductDefinition.PlayerEffectDuration;

		public int NpcEffectDurationSeconds => base.S1ProductDefinition.NPCEffectDuration;

		public IReadOnlyList<PackagingDefinition> ValidPackaging => _metadata.ValidPackaging;

		internal CustomProductDefinition(ProductDefinition productDefinition, CustomProductDefinitionMetadata metadata)
			: base(productDefinition)
		{
			_metadata = metadata;
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return CreateInstance(quantity, DefaultQuality);
		}

		public ProductInstance CreateInstance(int quantity, Quality quality)
		{
			//IL_0015: 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_0025: Expected O, but got Unknown
			CustomProductDefinitionBuilderContract.ValidateQuality(quality, "quality");
			return new ProductInstance(new ProductItemInstance((ItemDefinition)(object)base.S1ProductDefinition, quantity, quality.ToInternal(), (PackagingDefinition)null));
		}

		public new ProductInstance? CreatePackagedInstance(int quantity, PackagingDefinition packaging)
		{
			return CreatePackagedInstance(quantity, packaging, DefaultQuality);
		}

		public ProductInstance? CreatePackagedInstance(int quantity, PackagingDefinition packaging, Quality quality)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			CustomProductDefinitionBuilderContract.ValidateQuality(quality, "quality");
			if (!SupportsPackaging(packaging))
			{
				return null;
			}
			try
			{
				PackagingDefinition val = CrossType.As<PackagingDefinition>((object)packaging.S1ItemDefinition);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				return new ProductInstance(new ProductItemInstance((ItemDefinition)(object)base.S1ProductDefinition, quantity, quality.ToInternal(), val));
			}
			catch (Exception)
			{
				return null;
			}
		}

		public bool SupportsPackaging(PackagingDefinition packaging)
		{
			if (packaging == null || base.S1ProductDefinition.ValidPackaging == null)
			{
				return false;
			}
			string iD = packaging.ID;
			for (int i = 0; i < ((Il2CppArrayBase<PackagingDefinition>)(object)base.S1ProductDefinition.ValidPackaging).Length; i++)
			{
				PackagingDefinition val = ((Il2CppArrayBase<PackagingDefinition>)(object)base.S1ProductDefinition.ValidPackaging)[i];
				if ((Object)(object)val != (Object)null && string.Equals(((BaseItemDefinition)val).ID, iD, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public void Discover(bool listForSale = false)
		{
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				throw new InvalidOperationException("Cannot discover a custom product before ProductManager is available.");
			}
			instance.SetProductDiscovered((NetworkConnection)null, base.ID, listForSale);
		}

		public void SetListed(bool listed = true)
		{
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				throw new InvalidOperationException("Cannot change custom product listing before ProductManager is available.");
			}
			instance.SetProductListed(base.ID, listed);
		}
	}
	public sealed class CustomProductDefinitionBuilder
	{
		private readonly string _id;

		private readonly string _ownerId;

		private readonly ProductKind _productKind;

		private readonly List<PropertyBase> _properties = new List<PropertyBase>();

		private readonly List<PackagingDefinition> _validPackaging = new List<PackagingDefinition>();

		private string? _name;

		private string _description = string.Empty;

		private float _productPrice;

		private bool _hasProductPrice;

		private LegalStatus _legalStatus = LegalStatus.Illegal;

		private float _baseAddictiveness;

		private Quality _defaultQuality = Quality.Standard;

		private ProductDefinition? _representationTemplate;

		private int? _playerEffectDurationSeconds;

		private int? _npcEffectDurationSeconds;

		private ProductMixingMap? _nativeMixerMap;

		private string? _saveProviderId;

		private int _saveProviderVersion;

		private string _saveProviderData = string.Empty;

		private CustomProductDefinition? _builtDefinition;

		public string ProductId => _id;

		public CustomProductDefinitionBuilder(string id, ProductKind productKind)
		{
			_id = CustomProductDefinitionBuilderContract.NormalizeId(id);
			_ownerId = CustomProductDefinitionBuilderContract.GetOwnerId(_id);
			_productKind = productKind ?? throw new ArgumentNullException("productKind");
		}

		public CustomProductDefinitionBuilder WithName(string name)
		{
			EnsureMutable();
			_name = CustomProductDefinitionBuilderContract.NormalizeName(name);
			return this;
		}

		public CustomProductDefinitionBuilder WithDescription(string description)
		{
			EnsureMutable();
			_description = CustomProductDefinitionBuilderContract.NormalizeDescription(description);
			return this;
		}

		public CustomProductDefinitionBuilder WithProductPrice(float productPrice)
		{
			EnsureMutable();
			_productPrice = CustomProductDefinitionBuilderContract.NormalizeProductPrice(productPrice);
			_hasProductPrice = true;
			return this;
		}

		public CustomProductDefinitionBuilder WithProperty(PropertyBase property)
		{
			EnsureMutable();
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			_properties.Add(property);
			return this;
		}

		public CustomProductDefinitionBuilder WithProperties(params PropertyBase[] properties)
		{
			EnsureMutable();
			if (properties == null)
			{
				throw new ArgumentNullException("properties");
			}
			for (int i = 0; i < properties.Length; i++)
			{
				if (properties[i] == null)
				{
					throw new ArgumentException("Custom product properties cannot contain null values.", "properties");
				}
			}
			_properties.Clear();
			_properties.AddRange(properties);
			return this;
		}

		public CustomProductDefinitionBuilder WithLegalStatus(LegalStatus legalStatus)
		{
			EnsureMutable();
			if (!Enum.IsDefined(typeof(LegalStatus), legalStatus))
			{
				throw new ArgumentOutOfRangeException("legalStatus", legalStatus, "Legal status must be a defined S1API.Items.LegalStatus value.");
			}
			_legalStatus = legalStatus;
			return this;
		}

		public CustomProductDefinitionBuilder WithBaseAddictiveness(float baseAddictiveness)
		{
			EnsureMutable();
			_baseAddictiveness = CustomProductDefinitionBuilderContract.NormalizeAddictiveness(baseAddictiveness);
			return this;
		}

		public CustomProductDefinitionBuilder WithDefaultQuality(Quality quality)
		{
			EnsureMutable();
			CustomProductDefinitionBuilderContract.ValidateQuality(quality, "quality");
			_defaultQuality = quality;
			return this;
		}

		public CustomProductDefinitionBuilder WithValidPackaging(params PackagingDefinition[] packaging)
		{
			EnsureMutable();
			if (packaging == null)
			{
				throw new ArgumentNullException("packaging");
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (PackagingDefinition packagingDefinition in packaging)
			{
				if (packagingDefinition == null)
				{
					throw new ArgumentException("Valid packaging cannot contain null values.", "packaging");
				}
				if (!hashSet.Add(packagingDefinition.ID))
				{
					throw new ArgumentException("Packaging ID '" + packagingDefinition.ID + "' was supplied more than once. Packaging IDs are case-insensitive.", "packaging");
				}
			}
			_validPackaging.Clear();
			_validPackaging.AddRange(packaging);
			return this;
		}

		public CustomProductDefinitionBuilder WithRepresentationsFrom(ProductDefinition template)
		{
			EnsureMutable();
			_representationTemplate = template ?? throw new ArgumentNullException("template");
			return this;
		}

		public CustomProductDefinitionBuilder WithEffectDurations(int playerSeconds, int npcSeconds)
		{
			EnsureMutable();
			CustomProductDefinitionBuilderContract.ValidateEffectDuration(playerSeconds, "playerSeconds");
			CustomProductDefinitionBuilderContract.ValidateEffectDuration(npcSeconds, "npcSeconds");
			_playerEffectDurationSeconds = playerSeconds;
			_npcEffectDurationSeconds = npcSeconds;
			return this;
		}

		public CustomProductDefinitionBuilder WithNativeMixerMap(ProductMixingMap mixerMap)
		{
			EnsureMutable();
			if (!Enum.IsDefined(typeof(ProductMixingMap), mixerMap))
			{
				throw new ArgumentOutOfRangeException("mixerMap");
			}
			_nativeMixerMap = mixerMap;
			return this;
		}

		public CustomProductDefinitionBuilder WithSaveProvider(string providerId, int providerVersion, string providerData = "")
		{
			EnsureMutable();
			if (providerVersion < 0)
			{
				throw new ArgumentOutOfRangeException("providerVersion");
			}
			if (providerData == null)
			{
				throw new ArgumentNullException("providerData");
			}
			if (providerData.Length > 4096)
			{
				throw new ArgumentOutOfRangeException("providerData");
			}
			_saveProviderId = ProductKindId.Normalize(providerId, "providerId");
			_saveProviderVersion = providerVersion;
			_saveProviderData = providerData;
			return this;
		}

		public CustomProductDefinition Build()
		{
			if (_builtDefinition != null)
			{
				return _builtDefinition;
			}
			if (_name == null)
			{
				throw new InvalidOperationException("WithName must be called before Build().");
			}
			if (!_hasProductPrice)
			{
				throw new InvalidOperationException("WithProductPrice must be called before Build().");
			}
			if (_representationTemplate == null)
			{
				throw new InvalidOperationException("WithRepresentationsFrom must be called before Build().");
			}
			if (!_productKind.CompatibilityDrugType.HasValue && !_nativeMixerMap.HasValue)
			{
				throw new InvalidOperationException("Product kind '" + _productKind.Id + "' does not define a compatibility drug type. Configure WithNativeMixerMap(...) to select an explicit native execution strategy.");
			}
			DrugType compatibilityDrugType = (_nativeMixerMap.HasValue ? ProductMixingMapContract.GetNativeDrugType(_nativeMixerMap.Value) : _productKind.CompatibilityDrugType.Value);
			List<Effect> list = PropertyResolver.ResolveToGameProperties(_properties);
			CustomProductDefinitionBuilderContract.ValidatePropertyCounts(_properties.Count, list.Count);
			_validPackaging.Sort(delegate(PackagingDefinition left, PackagingDefinition right)
			{
				int num3 = left.Quantity.CompareTo(right.Quantity);
				return (num3 != 0) ? num3 : StringComparer.OrdinalIgnoreCase.Compare(left.ID, right.ID);
			});
			List<PackagingDefinition> list2 = new List<PackagingDefinition>(_validPackaging.Count);
			for (int num = 0; num < _validPackaging.Count; num++)
			{
				list2.Add(_validPackaging[num].S1PackagingDefinition);
			}
			ProductDefinition val = CustomProductDefinitionFactory.Create(_id, _name, _description, _productPrice, _legalStatus, _baseAddictiveness, _playerEffectDurationSeconds ?? _representationTemplate.S1ProductDefinition.PlayerEffectDuration, _npcEffectDurationSeconds ?? _representationTemplate.S1ProductDefinition.NPCEffectDuration, compatibilityDrugType, list, list2, _representationTemplate.S1ProductDefinition);
			List<PackagingDefinition> list3 = new List<PackagingDefinition>(list2.Count);
			for (int num2 = 0; num2 < list2.Count; num2++)
			{
				list3.Add(new PackagingDefinition((ItemDefinition)(object)list2[num2]));
			}
			CustomProductDefinitionMetadata metadata = new CustomProductDefinitionMetadata(_productKind, _defaultQuality, list3, _representationTemplate.S1ProductDefinition);
			CustomProductSaveDescriptorData saveDescriptor = new CustomProductSaveDescriptorData
			{
				ProductId = _id,
				OwnerId = _ownerId,
				ProductName = _name,
				Description = _description,
				InitialPrice = _productPrice,
				LegalStatus = (int)_legalStatus,
				BaseAddictiveness = _baseAddictiveness,
				DefaultQuality = (int)_defaultQuality,
				ProductKindId = _productKind.Id,
				CompatibilityDrugType = (int)compatibilityDrugType,
				RepresentationTemplateId = _representationTemplate.ID,
				PlayerEffectDurationSeconds = (_playerEffectDurationSeconds ?? _representationTemplate.S1ProductDefinition.PlayerEffectDuration),
				NpcEffectDurationSeconds = (_npcEffectDurationSeconds ?? _representationTemplate.S1ProductDefinition.NPCEffectDuration),
				PropertyIds = list.ConvertAll((Effect property) => property.ID).ToArray(),
				PackagingIds = _validPackaging.ConvertAll((PackagingDefinition packaging) => packaging.ID).ToArray(),
				ProviderId = _saveProviderId,
				ProviderVersion = _saveProviderVersion,
				ProviderData = _saveProviderData
			};
			RegisterCreatedDefinition(_ownerId, _id, _name, _productPrice, val, metadata, saveDescriptor, CustomProductDefinitionFactory.Destroy);
			_builtDefinition = new CustomProductDefinition(val, metadata);
			return _builtDefinition;
		}

		internal static ProductDefinition RegisterCreatedDefinition(string ownerId, string productId, string productName, float initialPrice, ProductDefinition nativeDefinition, CustomProductDefinitionMetadata metadata, Action<ProductDefinition> destroy)
		{
			return RegisterCreatedDefinition(ownerId, productId, productName, initialPrice, nativeDefinition, metadata, null, destroy);
		}

		internal static ProductDefinition RegisterCreatedDefinition(string ownerId, string productId, string productName, float initialPrice, ProductDefinition nativeDefinition, CustomProductDefinitionMetadata metadata, CustomProductSaveDescriptorData? saveDescriptor, Action<ProductDefinition> destroy)
		{
			if (destroy == null)
			{
				throw new ArgumentNullException("destroy");
			}
			try
			{
				ProductDefinition val = CustomProductDefinitionRegistry.Register(ownerId, productId, productName, initialPrice, nativeDefinition, metadata, saveDescriptor);
				if (val == nativeDefinition)
				{
					return val;
				}
				throw new InvalidOperationException("Product ID '" + productId + "' is already registered by this owner with another definition. Product IDs are case-insensitive; reuse the original builder or choose a unique stable namespaced ID.");
			}
			catch
			{
				try
				{
					destroy(nativeDefinition);
				}
				catch (Exception ex)
				{
					MelonLogger.Error("Failed to destroy rejected custom product '" + productId + "': " + ex);
				}
				throw;
			}
		}

		private void EnsureMutable()
		{
			if (_builtDefinition != null)
			{
				throw new InvalidOperationException("A custom product builder cannot be changed after a successful Build(). Create a new builder for another product.");
			}
		}
	}
	internal static class CustomProductDefinitionBuilderContract
	{
		internal const int MaximumPropertyCount = 8;

		internal const float MinimumProductPrice = 1f;

		internal const float MaximumProductPrice = 999f;

		internal static string NormalizeId(string id)
		{
			return ProductKindId.Normalize(id, "id");
		}

		internal static string GetOwnerId(string productId)
		{
			return productId[..productId.IndexOf(':')];
		}

		internal static string NormalizeName(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			string text = name.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Custom product names cannot be empty or whitespace.", "name");
			}
			return text;
		}

		internal static string NormalizeDescription(string description)
		{
			if (description == null)
			{
				throw new ArgumentNullException("description");
			}
			return description.Trim();
		}

		internal static float NormalizeProductPrice(float productPrice)
		{
			if (float.IsNaN(productPrice) || float.IsInfinity(productPrice))
			{
				throw new ArgumentOutOfRangeException("productPrice", productPrice, "Product price must be finite.");
			}
			float num = Math.Max(1f, Math.Min(999f, productPrice));
			return (float)Math.Round(num);
		}

		internal static float NormalizeAddictiveness(float addictiveness)
		{
			if (float.IsNaN(addictiveness) || float.IsInfinity(addictiveness))
			{
				throw new ArgumentOutOfRangeException("addictiveness", addictiveness, "Base addictiveness must be finite.");
			}
			return Math.Max(0f, Math.Min(1f, addictiveness));
		}

		internal static void ValidateQuality(Quality quality, string parameterName)
		{
			if (!Enum.IsDefined(typeof(Quality), quality))
			{
				throw new ArgumentOutOfRangeException(parameterName, quality, "Quality must be a defined S1API.Products.Quality value.");
			}
		}

		internal static void ValidateEffectDuration(int seconds, string parameterName)
		{
			if (seconds < 0)
			{
				throw new ArgumentOutOfRangeException(parameterName, seconds, "Effect durations cannot be negative.");
			}
		}

		internal static void ValidatePropertyCounts(int requestedCount, int resolvedCount)
		{
			if (requestedCount != resolvedCount)
			{
				throw new InvalidOperationException("Every supplied property must resolve to a distinct native property. Use vanilla property tokens or registered custom properties and remove duplicates.");
			}
			if (resolvedCount > 8)
			{
				throw new InvalidOperationException($"A custom product can have at most {8} properties.");
			}
		}
	}
	public static class CustomProductItemCreator
	{
		public static CustomProductDefinitionBuilder CreateBuilder(string id, ProductKind productKind)
		{
			return new CustomProductDefinitionBuilder(id, productKind);
		}
	}
	public enum CustomProductMultiplayerPolicy
	{
		Reject
	}
	public static class CustomProductMultiplayer
	{
		public static CustomProductMultiplayerPolicy MissingContentPolicy => CustomProductMultiplayerPolicy.Reject;

		public static string GetCompatibilityManifestHash()
		{
			return CustomProductManifestRuntime.GetLocalCompatibilityHash();
		}
	}
	public sealed class CustomProductSaveDescriptor
	{
		public int FormatVersion { get; }

		public string ProductId { get; }

		public string OwnerId { get; }

		public string ProductName { get; }

		public string Description { get; }

		public float InitialPrice { get; }

		public string ProductKindId { get; }

		public string? ProviderId { get; }

		public int ProviderVersion { get; }

		public string ProviderData { get; }

		internal CustomProductSaveDescriptorData? Data { get; set; }

		public CustomProductSaveDescriptor(int formatVersion, string productId, string ownerId, string productName, string description, float initialPrice, string productKindId, string? providerId, int providerVersion, string providerData)
		{
			FormatVersion = formatVersion;
			ProductId = productId ?? throw new ArgumentNullException("productId");
			OwnerId = ownerId ?? throw new ArgumentNullException("ownerId");
			ProductName = productName ?? throw new ArgumentNullException("productName");
			Description = description ?? throw new ArgumentNullException("description");
			InitialPrice = initialPrice;
			ProductKindId = productKindId ?? throw new ArgumentNullException("productKindId");
			ProviderId = providerId;
			ProviderVersion = providerVersion;
			ProviderData = providerData ?? throw new ArgumentNullException("providerData");
		}
	}
	public interface ICustomProductSaveProvider
	{
		string ProviderId { get; }

		int MaximumDescriptorVersion { get; }

		CustomProductDefinitionBuilder? Restore(CustomProductSaveDescriptor descriptor);
	}
	public static class CustomProductSaveProviderRegistry
	{
		public static ICustomProductSaveProvider Register(ICustomProductSaveProvider provider)
		{
			return CustomProductSavePersistence.RegisterProvider(provider);
		}
	}
	public enum DrugType
	{
		Marijuana,
		Methamphetamine,
		Cocaine,
		MDMA,
		Shrooms,
		Heroin
	}
	internal static class DrugTypeExtensions
	{
		internal static DrugType ToAPI(this EDrugType drugType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			DrugType result = (int)drugType switch
			{
				0 => DrugType.Marijuana, 
				1 => DrugType.Methamphetamine, 
				2 => DrugType.Cocaine, 
				3 => DrugType.MDMA, 
				4 => DrugType.Shrooms, 
				5 => DrugType.Heroin, 
				_ => (DrugType)drugType, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static EDrugType ToInternal(this DrugType drugType)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			EDrugType result = (EDrugType)(drugType switch
			{
				DrugType.Marijuana => 0, 
				DrugType.Methamphetamine => 1, 
				DrugType.Cocaine => 2, 
				DrugType.MDMA => 3, 
				DrugType.Shrooms => 4, 
				DrugType.Heroin => 5, 
				_ => drugType, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class MethDefinition : ProductDefinition
	{
		internal MethDefinition S1MethDefinition => CrossType.As<MethDefinition>((object)base.S1ItemDefinition);

		internal MethDefinition(MethDefinition definition)
			: base((ProductDefinition)(object)definition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new ProductInstance(CrossType.As<ProductItemInstance>((object)((ItemDefinition)S1MethDefinition).GetDefaultInstance(quantity)));
		}

		public List<PropertyBase> GetProperties()
		{
			List<PropertyBase> list = new List<PropertyBase>();
			MethDefinition s1MethDefinition = S1MethDefinition;
			List<Effect> val = ((s1MethDefinition != null) ? ((PropertyItemDefinition)s1MethDefinition).Properties : null);
			if (val != null)
			{
				for (int i = 0; i < val.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(val[i]));
				}
			}
			return list;
		}
	}
	public static class MixReactions
	{
		internal sealed class Rule
		{
			internal string MixerEffectId { get; set; } = string.Empty;

			internal string WhenContainsId { get; set; } = string.Empty;

			internal PropertyBase AddResult { get; set; } = null;

			internal DrugType? Drug { get; set; }

			internal bool Replace { get; set; }

			internal Effect? S1Resolved { get; set; }
		}

		private static readonly object Gate = new object();

		private static readonly List<Rule> Rules = new List<Rule>();

		public static void AddRule(PropertyBase mixerEffect, PropertyBase whenResultContains, PropertyBase addResult, DrugType? drug = null, bool replaceMatched = false)
		{
			if (mixerEffect == null)
			{
				throw new ArgumentNullException("mixerEffect");
			}
			if (whenResultContains == null)
			{
				throw new ArgumentNullException("whenResultContains");
			}
			if (addResult == null)
			{
				throw new ArgumentNullException("addResult");
			}
			lock (Gate)
			{
				Rules.Add(new Rule
				{
					MixerEffectId = mixerEffect.ID,
					WhenContainsId = whenResultContains.ID,
					AddResult = addResult,
					Drug = drug,
					Replace = replaceMatched
				});
			}
		}

		public static void Clear()
		{
			lock (Gate)
			{
				Rules.Clear();
			}
		}

		internal static Rule[] Snapshot()
		{
			lock (Gate)
			{
				return Rules.ToArray();
			}
		}

		internal static Effect? ResolveAddResult(Rule rule)
		{
			if ((Object)(object)rule.S1Resolved != (Object)null)
			{
				return rule.S1Resolved;
			}
			List<Effect> list = PropertyResolver.ResolveToGameProperties(new PropertyBase[1] { rule.AddResult });
			if (list.Count > 0)
			{
				rule.S1Resolved = list[0];
			}
			return rule.S1Resolved;
		}
	}
	public class PackagingDefinition : ItemDefinition
	{
		internal PackagingDefinition S1PackagingDefinition => CrossType.As<PackagingDefinition>((object)base.S1ItemDefinition);

		public int Quantity => S1PackagingDefinition.Quantity;

		public StealthLevel StealthLevel => S1PackagingDefinition.StealthLevel.ToAPI();

		internal PackagingDefinition(ItemDefinition s1ItemDefinition)
			: base(s1ItemDefinition)
		{
		}
	}
	public sealed class ProductConsumptionContext
	{
		private readonly string _productId;

		private readonly ProductKind _productKind;

		private readonly Quality _quality;

		private readonly IReadOnlyList<PropertyBase> _properties;

		public ProductInstance Product { get; }

		public CustomProductDefinition Definition { get; }

		public string ProductId => _productId;

		public ProductKind ProductKind => _productKind;

		public Quality Quality => _quality;

		public IReadOnlyList<PropertyBase> Properties => _properties;

		public Player? Player { get; }

		public NPC? NPC { get; }

		public string TargetId { get; }

		public bool IsLocalPlayer => Player != null;

		internal ProductConsumptionContext(ProductInstance product, CustomProductDefinition definition, Player? player, NPC? npc, string targetId)
		{
			Product = product;
			Definition = definition;
			_productId = definition.ID;
			_productKind = definition.ProductKind;
			_quality = product.Quality;
			_properties = product.Properties;
			Player = player;
			NPC = npc;
			TargetId = targetId;
		}

		internal ProductConsumptionContext(string productId, ProductKind productKind, Player? player, NPC? npc, string targetId)
		{
			Product = null;
			Definition = null;
			_productId = productId;
			_productKind = productKind;
			_quality = Quality.Standard;
			_properties = Array.Empty<PropertyBase>();
			Player = player;
			NPC = npc;
			TargetId = targetId;
		}
	}
	public sealed class ProductConsumptionProfile
	{
		public string ProviderId { get; }

		public int ProviderVersion { get; }

		internal Action<ProductConsumptionContext>? OnPlayerApply { get; }

		internal Action<ProductConsumptionContext>? OnPlayerClear { get; }

		internal Action<ProductConsumptionContext>? OnNpcApply { get; }

		internal Action<ProductConsumptionContext>? OnNpcClear { get; }

		internal ProductConsumptionProfile(string providerId, int providerVersion, Action<ProductConsumptionContext>? onPlayerApply, Action<ProductConsumptionContext>? onPlayerClear, Action<ProductConsumptionContext>? onNpcApply, Action<ProductConsumptionContext>? onNpcClear)
		{
			ProviderId = providerId;
			ProviderVersion = providerVersion;
			OnPlayerApply = onPlayerApply;
			OnPlayerClear = onPlayerClear;
			OnNpcApply = onNpcApply;
			OnNpcClear = onNpcClear;
		}
	}
	public sealed class ProductConsumptionProfileBuilder
	{
		private string? _providerId;

		private int _providerVersion;

		private Action<ProductConsumptionContext>? _onPlayerApply;

		private Action<ProductConsumptionContext>? _onPlayerClear;

		private Action<ProductConsumptionContext>? _onNpcApply;

		private Action<ProductConsumptionContext>? _onNpcClear;

		public ProductConsumptionProfileBuilder WithProviderCompatibility(string providerId, int providerVersion)
		{
			if (providerVersion <= 0)
			{
				throw new ArgumentOutOfRangeException("providerVersion");
			}
			_providerId = ProductKindId.Normalize(providerId, "providerId");
			_providerVersion = providerVersion;
			return this;
		}

		public ProductConsumptionProfileBuilder OnPlayerApply(Action<ProductConsumptionContext> callback)
		{
			_onPlayerApply = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public ProductConsumptionProfileBuilder OnPlayerClear(Action<ProductConsumptionContext> callback)
		{
			_onPlayerClear = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public ProductConsumptionProfileBuilder OnNpcApply(Action<ProductConsumptionContext> callback)
		{
			_onNpcApply = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public ProductConsumptionProfileBuilder OnNpcClear(Action<ProductConsumptionContext> callback)
		{
			_onNpcClear = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public ProductConsumptionProfile Build()
		{
			if (_providerId == null)
			{
				throw new InvalidOperationException("WithProviderCompatibility must be called before Build().");
			}
			if (_onPlayerApply == null && _onPlayerClear == null && _onNpcApply == null && _onNpcClear == null)
			{
				throw new InvalidOperationException("Configure at least one consumption lifecycle callback before Build().");
			}
			return new ProductConsumptionProfile(_providerId, _providerVersion, _onPlayerApply, _onPlayerClear, _onNpcApply, _onNpcClear);
		}
	}
	public static class ProductConsumptionProfileRegistry
	{
		public static ProductConsumptionProfile RegisterForProduct(string productId, ProductConsumptionProfile profile)
		{
			return ProductConsumptionProfileRegistrationRegistry.RegisterForProduct(productId, profile);
		}

		public static ProductConsumptionProfile RegisterForProductKind(ProductKind productKind, ProductConsumptionProfile profile)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return ProductConsumptionProfileRegistrationRegistry.RegisterForProductKind(productKind, profile);
		}
	}
	public class ProductDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal ProductDefinition S1ProductDefinition => CrossType.As<ProductDefinition>((object)base.S1ItemDefinition);

		public float Price => S1ProductDefinition.Price;

		public float BasePrice => S1ProductDefinition.BasePrice;

		public float MarketValue => S1ProductDefinition.MarketValue;

		public new Sprite Icon => ((BaseItemDefinition)S1ProductDefinition).Icon;

		public IReadOnlyList<PropertyBase> Properties
		{
			get
			{
				List<Effect> properties = ((PropertyItemDefinition)S1ProductDefinition).Properties;
				List<PropertyBase> list = new List<PropertyBase>(properties.Count);
				for (int i = 0; i < properties.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(properties[i]));
				}
				return list.AsReadOnly();
			}
		}

		public IReadOnlyList<DrugType> DrugTypeValues
		{
			get
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				List<DrugTypeContainer> drugTypes = S1ProductDefinition.DrugTypes;
				List<DrugType> list = new List<DrugType>(drugTypes?.Count ?? 0);
				if (drugTypes != null)
				{
					for (int i = 0; i < drugTypes.Count; i++)
					{
						DrugTypeContainer val = drugTypes[i];
						if (val != null)
						{
							list.Add(val.DrugType.ToAPI());
						}
					}
				}
				return list.AsReadOnly();
			}
		}

		public DrugType PrimaryDrugType => S1ProductDefinition.DrugType.ToAPI();

		[Obsolete("Use DrugTypeValues instead.", false)]
		public IReadOnlyList<DrugTypeContainer> DrugTypes
		{
			get
			{
				List<DrugTypeContainer> drugTypes = S1ProductDefinition.DrugTypes;
				List<DrugTypeContainer> list = new List<DrugTypeContainer>(drugTypes?.Count ?? 0);
				if (drugTypes != null)
				{
					for (int i = 0; i < drugTypes.Count; i++)
					{
						list.Add(drugTypes[i]);
					}
				}
				return list.AsReadOnly();
			}
		}

		[Obsolete("Use PrimaryDrugType instead.", false)]
		public EDrugType DrugType => S1ProductDefinition.DrugType;

		internal ProductDefinition(ProductDefinition productDefinition)
			: base((StorableItemDefinition)(object)productDefinition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new ProductInstance(CrossType.As<ProductItemInstance>((object)((ItemDefinition)S1ProductDefinition).GetDefaultInstance(quantity)));
		}

		public ProductInstance? CreatePackagedInstance(int quantity, PackagingDefinition packaging)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			try
			{
				PackagingDefinition val = CrossType.As<PackagingDefinition>((object)packaging.S1ItemDefinition);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				ProductItemInstance productInstance = new ProductItemInstance((ItemDefinition)(object)S1ProductDefinition, quantity, (EQuality)2, val);
				return new ProductInstance(productInstance);
			}
			catch (Exception)
			{
				return null;
			}
		}
	}
	public static class ProductDefinitionWrapper
	{
		public static ProductDefinition Wrap(ProductDefinition def)
		{
			return Wrap(def.S1ProductDefinition, def);
		}

		internal static ProductDefinition Wrap(ProductDefinition definition)
		{
			return Wrap(definition, null);
		}

		private static ProductDefinition Wrap(ProductDefinition definition, ProductDefinition? fallback)
		{
			if (CrossType.Is<WeedDefinition>((object)definition, out WeedDefinition result))
			{
				return new WeedDefinition(result);
			}
			if (CrossType.Is<MethDefinition>((object)definition, out MethDefinition result2))
			{
				return new MethDefinition(result2);
			}
			if (CrossType.Is<CocaineDefinition>((object)definition, out CocaineDefinition result3))
			{
				return new CocaineDefinition(result3);
			}
			if (CrossType.Is<ShroomDefinition>((object)definition, out ShroomDefinition result4))
			{
				return new ShroomDefinition(result4);
			}
			if (CustomProductDefinitionRegistry.TryGetMetadata(definition, out CustomProductDefinitionMetadata metadata))
			{
				return new CustomProductDefinition(definition, metadata);
			}
			return fallback ?? new ProductDefinition(definition);
		}
	}
	public class ProductInstance : ItemInstance
	{
		internal ProductItemInstance S1ProductInstance => CrossType.As<ProductItemInstance>((object)S1ItemInstance);

		public bool IsPackaged => Object.op_Implicit((Object)(object)S1ProductInstance.AppliedPackaging);

		public PackagingDefinition AppliedPackaging => new PackagingDefinition((ItemDefinition)(object)S1ProductInstance.AppliedPackaging);

		public Quality Quality => ((QualityItemInstance)S1ProductInstance).Quality.ToAPI();

		public new ProductDefinition Definition => ProductDefinitionWrapper.Wrap(CrossType.As<ProductDefinition>((object)((ItemInstance)S1ProductInstance).Definition));

		public IReadOnlyList<PropertyBase> Properties => Definition.Properties;

		internal ProductInstance(ProductItemInstance productInstance)
			: base((ItemInstance)(object)productInstance)
		{
		}
	}
	public sealed class ProductKind
	{
		public string Id { get; }

		public DrugType? CompatibilityDrugType { get; }

		internal ProductKind(string id, DrugType? compatibilityDrugType)
		{
			Id = id;
			CompatibilityDrugType = compatibilityDrugType;
		}

		internal bool IsEquivalentTo(ProductKind other)
		{
			return string.Equals(Id, other.Id, StringComparison.OrdinalIgnoreCase) && CompatibilityDrugType == other.CompatibilityDrugType;
		}

		public override string ToString()
		{
			return Id;
		}
	}
	public sealed class ProductKindBuilder
	{
		private readonly string _id;

		private DrugType? _compatibilityDrugType;

		public ProductKindBuilder(string id)
		{
			_id = ProductKindId.Normalize(id, "id");
		}

		public ProductKindBuilder WithCompatibilityDrugType(DrugType drugType)
		{
			if (!Enum.IsDefined(typeof(DrugType), drugType))
			{
				throw new ArgumentOutOfRangeException("drugType", drugType, "Compatibility drug type must be a defined S1API.Products.DrugType value.");
			}
			_compatibilityDrugType = drugType;
			return this;
		}

		public ProductKind Build()
		{
			ProductKind productKind = new ProductKind(_id, _compatibilityDrugType);
			return ProductKindRegistry.Register(productKind);
		}
	}
	public sealed class ProductKindMetadata
	{
		private readonly IReadOnlyList<string> _searchAliases;

		public ProductKind ProductKind { get; }

		public string DisplayName { get; }

		public Color Color { get; }

		public Sprite? Icon { get; }

		public int SortOrder { get; }

		public IReadOnlyList<string> SearchAliases => _searchAliases;

		public bool IsVisibleInProductManager { get; }

		internal ProductKindMetadata(ProductKind productKind, string displayName, Color color, Sprite? icon, int sortOrder, IReadOnlyList<string> searchAliases, bool isVisibleInProductManager)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			ProductKind = productKind;
			DisplayName = displayName;
			Color = color;
			Icon = icon;
			SortOrder = sortOrder;
			_searchAliases = searchAliases;
			IsVisibleInProductManager = isVisibleInProductManager;
		}

		public bool MatchesSearch(string searchTerm)
		{
			if (searchTerm == null)
			{
				throw new ArgumentNullException("searchTerm");
			}
			string text = searchTerm.Trim();
			if (text.Length == 0)
			{
				return true;
			}
			if (Contains(ProductKind.Id, text) || Contains(DisplayName, text))
			{
				return true;
			}
			for (int i = 0; i < _searchAliases.Count; i++)
			{
				if (Contains(_searchAliases[i], text))
				{
					return true;
				}
			}
			return false;
		}

		internal bool IsEquivalentTo(ProductKindMetadata other)
		{
			if (!ProductKind.IsEquivalentTo(other.ProductKind) || !string.Equals(DisplayName, other.DisplayName, StringComparison.Ordinal) || !HasSameColor(other) || Icon != other.Icon || SortOrder != other.SortOrder || IsVisibleInProductManager != other.IsVisibleInProductManager || _searchAliases.Count != other._searchAliases.Count)
			{
				return false;
			}
			for (int i = 0; i < _searchAliases.Count; i++)
			{
				if (!string.Equals(_searchAliases[i], other._searchAliases[i], StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
			}
			return true;
		}

		internal bool HasSameColor(ProductKindMetadata other)
		{
			//IL_0002: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			return Color.r.Equals(other.Color.r) && Color.g.Equals(other.Color.g) && Color.b.Equals(other.Color.b) && Color.a.Equals(other.Color.a);
		}

		private static bool Contains(string value, string searchTerm)
		{
			return value.IndexOf(searchTerm, StringComparison.OrdinalIgnoreCase) >= 0;
		}
	}
	public sealed class ProductKindMetadataBuilder
	{
		private readonly ProductKind _productKind;

		private string? _displayName;

		private Color? _color;

		private Sprite? _icon;

		private int _sortOrder;

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

		private bool _isVisibleInProductManager;

		public ProductKindMetadataBuilder(ProductKind productKind)
		{
			_productKind = productKind ?? throw new ArgumentNullException("productKind");
		}

		public ProductKindMetadataBuilder WithDisplayName(string displayName)
		{
			_displayName = NormalizeRequired(displayName, "displayName");
			return this;
		}

		public ProductKindMetadataBuilder WithColor(Color color)
		{
			//IL_0001: 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_001b: 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_0043: 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)
			if (!IsFinite(color.r) || !IsFinite(color.g) || !IsFinite(color.b) || !IsFinite(color.a))
			{
				throw new ArgumentOutOfRangeException("color", color, "Product-kind color components must be finite values.");
			}
			_color = color;
			return this;
		}

		public ProductKindMetadataBuilder WithIcon(Sprite icon)
		{
			if (ProductKindIconLifetime.IsNullOrDestroyed(icon))
			{
				throw new ArgumentNullException("icon");
			}
			_icon = icon;
			return this;
		}

		public ProductKindMetadataBuilder WithSortOrder(int sortOrder)
		{
			_sortOrder = sortOrder;
			return this;
		}

		public ProductKindMetadataBuilder WithSearchAliases(params string[] searchAliases)
		{
			if (searchAliases == null)
			{
				throw new ArgumentNullException("searchAliases");
			}
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < searchAliases.Length; i++)
			{
				string item = NormalizeRequired(searchAliases[i], "searchAliases");
				if (hashSet.Add(item))
				{
					list.Add(item);
				}
			}
			_searchAliases.Clear();
			_searchAliases.AddRange(list);
			return this;
		}

		public ProductKindMetadataBuilder WithProductManagerVisibility(bool visible = true)
		{
			_isVisibleInProductManager = visible;
			return this;
		}

		public ProductKindMetadata Build()
		{
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			if (_displayName == null)
			{
				throw new InvalidOperationException("A product-kind display name is required.");
			}
			if (!_color.HasValue)
			{
				throw new InvalidOperationException("A product-kind color is required.");
			}
			if (_isVisibleInProductManager)
			{
				if (!_productKind.CompatibilityDrugType.HasValue)
				{
					throw new InvalidOperationException("A visible Product Manager section requires a compatibility drug type.");
				}
				if (ProductKindIconLifetime.IsNullOrDestroyed(_icon))
				{
					throw new InvalidOperationException("A visible Product Manager section requires an icon.");
				}
			}
			ProductKindMetadata metadata = new ProductKindMetadata(_productKind, _displayName, _color.Value, _icon, _sortOrder, new List<string>(_searchAliases).AsReadOnly(), _isVisibleInProductManager);
			return ProductKindMetadataRegistry.Register(metadata);
		}

		private static string NormalizeRequired(string value, string parameterName)
		{
			if (value == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = value.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Value cannot be empty or whitespace.", parameterName);
			}
			return text;
		}

		private static bool IsFinite(float value)
		{
			return !float.IsNaN(value) && !float.IsInfinity(value);
		}
	}
	public static class ProductKindMetadataRegistry
	{
		public static IReadOnlyCollection<ProductKindMetadata> All => ProductKindMetadataRegistrationRegistry.All;

		public static ProductKindMetadata? Get(string productKindId)
		{
			TryGet(productKindId, out ProductKindMetadata metadata);
			return metadata;
		}

		public static ProductKindMetadata? Get(ProductKind productKind)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return Get(productKind.Id);
		}

		public static bool TryGet(string productKindId, out ProductKindMetadata? metadata)
		{
			return ProductKindMetadataRegistrationRegistry.TryGet(productKindId, out metadata);
		}

		public static bool TryGet(ProductKind productKind, out ProductKindMetadata? metadata)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return TryGet(productKind.Id, out metadata);
		}

		internal static ProductKindMetadata Register(ProductKindMetadata metadata)
		{
			return ProductKindMetadataRegistrationRegistry.Register(metadata);
		}
	}
	public static class ProductKindRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ProductKind> Kinds = new Dictionary<string, ProductKind>(StringComparer.OrdinalIgnoreCase);

		public static IReadOnlyCollection<ProductKind> All
		{
			get
			{
				lock (Gate)
				{
					List<ProductKind> list = new List<ProductKind>(Kinds.Values);
					list.Sort((ProductKind left, ProductKind right) => StringComparer.OrdinalIgnoreCase.Compare(left.Id, right.Id));
					return list.AsReadOnly();
				}
			}
		}

		public static ProductKind? Get(string id)
		{
			TryGet(id, out ProductKind productKind);
			return productKind;
		}

		public static bool TryGet(string id, out ProductKind? productKind)
		{
			string key = ProductKindId.Normalize(id, "id");
			lock (Gate)
			{
				return Kinds.TryGetValue(key, out productKind);
			}
		}

		internal static ProductKind Register(ProductKind productKind)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			lock (Gate)
			{
				if (!Kinds.TryGetValue(productKind.Id, out ProductKind value))
				{
					Kinds.Add(productKind.Id, productKind);
					return productKind;
				}
				if (value.IsEquivalentTo(productKind))
				{
					return value;
				}
				throw new InvalidOperationException($"Product kind ID '{productKind.Id}' is already registered with compatibility drug type '{FormatCompatibility(value.CompatibilityDrugType)}'; the conflicting registration requested '{FormatCompatibility(productKind.CompatibilityDrugType)}'. Product kind IDs are case-insensitive. " + "Use a unique namespaced ID or register equivalent metadata.");
			}
		}

		private static string FormatCompatibility(DrugType? drugType)
		{
			return drugType?.ToString() ?? "none";
		}
	}
	public static class ProductManager
	{
		private sealed class EffectCallbackRegistration<T>
		{
			internal Action<T> Callback { get; }

			internal bool AllowDefaultEffect { get; }

			internal EffectCallbackRegistration(Action<T> callback, bool allowDefaultEffect)
			{
				Callback = callback;
				AllowDefaultEffect = allowDefaultEffect;
			}
		}

		private static readonly Dictionary<string, EffectCallbackRegistration<Player>> EffectCallbacks = new Dictionary<string, EffectCallbackRegistration<Player>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, EffectCallbackRegistration<NPC>> NpcEffectCallbacks = new Dictionary<string, EffectCallbackRegistration<NPC>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, EffectCallbackRegistration<Player>> EffectClearCallbacks = new Dictionary<string, EffectCallbackRegistration<Player>>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, EffectCallbackRegistration<NPC>> NpcEffectClearCallbacks = new Dictionary<string, EffectCallbackRegistration<NPC>>(StringComparer.OrdinalIgnoreCase);

		public const int MinPrice = 1;

		public const int MaxPrice = 999;

		public static ProductDefinition[] DiscoveredProducts => ((IEnumerable<ProductDefinition>)ProductManager.DiscoveredProducts.ToArray()).Select((ProductDefinition productDefinition) => ProductDefinitionWrapper.Wrap(productDefinition)).ToArray();

		public static ProductDefinition[] ListedProducts => ((IEnumerable<ProductDefinition>)ProductManager.ListedProducts.ToArray()).Select((ProductDefinition productDefinition) => ProductDefinitionWrapper.Wrap(productDefinition)).ToArray();

		public static ProductDefinition[] FavouritedProducts => ((IEnumerable<ProductDefinition>)ProductManager.FavouritedProducts.ToArray()).Select((ProductDefinition productDefinition) => ProductDefinitionWrapper.Wrap(productDefinition)).ToArray();

		public static bool IsAcceptingOrders => ProductManager.IsAcceptingOrders;

		public static bool MethDiscovered => ProductManager.MethDiscovered;

		public static bool CocaineDiscovered => ProductManager.CocaineDiscovered;

		public static bool ShroomsDiscovered => ProductManager.ShroomsDiscovered;

		public static float GetPrice(ProductDefinition product)
		{
			return NetworkSingleton<ProductManager>.Instance.GetPrice(product.S1ProductDefinition);
		}

		public static float CalculateProductValue(ProductDefinition product, float baseValue)
		{
			return ProductManager.CalculateProductValue(product.S1ProductDefinition, baseValue);
		}

		public static void SetEffectCallback(PropertyBase property, Action<Player> callback, bool allowDefaultEffect = false)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			SetEffectCallback(property.ID, callback, allowDefaultEffect);
		}

		public static void SetEffectCallback(string effectId, Action<Player> callback, bool allowDefaultEffect = false)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				throw new ArgumentException("Effect ID cannot be null or whitespace.", "effectId");
			}
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			EffectCallbacks[effectId] = new EffectCallbackRegistration<Player>(callback, allowDefaultEffect);
		}

		public static bool RemoveEffectCallback(PropertyBase property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			return RemoveEffectCallback(property.ID);
		}

		public static bool RemoveEffectCallback(string effectId)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				return false;
			}
			return EffectCallbacks.Remove(effectId);
		}

		public static void ClearEffectCallbacks()
		{
			EffectCallbacks.Clear();
		}

		public static void SetNpcEffectCallback(PropertyBase property, Action<NPC> callback, bool allowDefaultEffect = false)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			SetNpcEffectCallback(property.ID, callback, allowDefaultEffect);
		}

		public static void SetNpcEffectCallback(string effectId, Action<NPC> callback, bool allowDefaultEffect = false)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				throw new ArgumentException("Effect ID cannot be null or whitespace.", "effectId");
			}
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			NpcEffectCallbacks[effectId] = new EffectCallbackRegistration<NPC>(callback, allowDefaultEffect);
		}

		public static bool RemoveNpcEffectCallback(PropertyBase property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			return RemoveNpcEffectCallback(property.ID);
		}

		public static bool RemoveNpcEffectCallback(string effectId)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				return false;
			}
			return NpcEffectCallbacks.Remove(effectId);
		}

		public static void ClearNpcEffectCallbacks()
		{
			NpcEffectCallbacks.Clear();
		}

		public static void SetEffectClearCallback(PropertyBase property, Action<Player> callback, bool allowDefaultEffect = false)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			SetEffectClearCallback(property.ID, callback, allowDefaultEffect);
		}

		public static void SetEffectClearCallback(string effectId, Action<Player> callback, bool allowDefaultEffect = false)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				throw new ArgumentException("Effect ID cannot be null or whitespace.", "effectId");
			}
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			EffectClearCallbacks[effectId] = new EffectCallbackRegistration<Player>(callback, allowDefaultEffect);
		}

		public static bool RemoveEffectClearCallback(PropertyBase property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			return RemoveEffectClearCallback(property.ID);
		}

		public static bool RemoveEffectClearCallback(string effectId)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				return false;
			}
			return EffectClearCallbacks.Remove(effectId);
		}

		public static void ResetEffectClearCallbacks()
		{
			EffectClearCallbacks.Clear();
		}

		public static void SetNpcEffectClearCallback(PropertyBase property, Action<NPC> callback, bool allowDefaultEffect = false)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			SetNpcEffectClearCallback(property.ID, callback, allowDefaultEffect);
		}

		public static void SetNpcEffectClearCallback(string effectId, Action<NPC> callback, bool allowDefaultEffect = false)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				throw new ArgumentException("Effect ID cannot be null or whitespace.", "effectId");
			}
			if (callback == null)
			{
				throw new ArgumentNullException("callback");
			}
			NpcEffectClearCallbacks[effectId] = new EffectCallbackRegistration<NPC>(callback, allowDefaultEffect);
		}

		public static bool RemoveNpcEffectClearCallback(PropertyBase property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			return RemoveNpcEffectClearCallback(property.ID);
		}

		public static bool RemoveNpcEffectClearCallback(string effectId)
		{
			if (string.IsNullOrWhiteSpace(effectId))
			{
				return false;
			}
			return NpcEffectClearCallbacks.Remove(effectId);
		}

		public static void ResetNpcEffectClearCallbacks()
		{
			NpcEffectClearCallbacks.Clear();
		}

		internal static bool TryInvokeEffectCallback(string effectId, Player player, out bool allowDefaultEffect)
		{
			allowDefaultEffect = false;
			if (string.IsNullOrWhiteSpace(effectId) || player == null)
			{
				return false;
			}
			if (!EffectCallbacks.TryGetValue(effectId, out EffectCallbackRegistration<Player> value) || value?.Callback == null)
			{
				return false;
			}
			allowDefaultEffect = value.AllowDefaultEffect;
			value.Callback(player);
			return true;
		}

		internal static bool TryInvokeNpcEffectCallback(string effectId, NPC npc, out bool allowDefaultEffect)
		{
			allowDefaultEffect = false;
			if (string.IsNullOrWhiteSpace(effectId) || npc == null)
			{
				return false;
			}
			if (!NpcEffectCallbacks.TryGetValue(effectId, out EffectCallbackRegistration<NPC> value) || value?.Callback == null)
			{
				return false;
			}
			allowDefaultEffect = value.AllowDefaultEffect;
			value.Callback(npc);
			return true;
		}

		internal static bool TryInvokeEffectClearCallback(string effectId, Player player, out bool allowDefaultEffect)
		{
			allowDefaultEffect = false;
			if (string.IsNullOrWhiteSpace(effectId) || player == null)
			{
				return false;
			}
			if (!EffectClearCallbacks.TryGetValue(effectId, out EffectCallbackRegistration<Player> value) || value?.Callback == null)
			{
				return false;
			}
			allowDefaultEffect = value.AllowDefaultEffect;
			value.Callback(player);
			return true;
		}

		internal static bool TryInvokeNpcEffectClearCallback(string effectId, NPC npc, out bool allowDefaultEffect)
		{
			allowDefaultEffect = false;
			if (string.IsNullOrWhiteSpace(effectId) || npc == null)
			{
				return false;
			}
			if (!NpcEffectClearCallbacks.TryGetValue(effectId, out EffectCallbackRegistration<NPC> value) || value?.Callback == null)
			{
				return false;
			}
			allowDefaultEffect = value.AllowDefaultEffect;
			value.Callback(npc);
			return true;
		}
	}
	public enum ProductMixingMap
	{
		Marijuana,
		Methamphetamine,
		Cocaine,
		Shrooms
	}
	public sealed class ProductMixingOutput
	{
		public string OutputId { get; }

		public string MixName { get; }

		public string SourceProductId { get; }

		public ProductKind SourceKind { get; }

		public float SourcePrice { get; }

		internal ProductMixingOutput(string outputId, string mixName, string sourceProductId, ProductKind sourceKind, float sourcePrice)
		{
			OutputId = outputId;
			MixName = mixName;
			SourceProductId = sourceProductId;
			SourceKind = sourceKind;
			SourcePrice = sourcePrice;
		}
	}
	public sealed class ProductMixingOutputDefinition
	{
		public string Name { get; }

		public ProductKind ProductKind { get; }

		public float Price { get; }

		public ProductMixingOutputDefinition(string name, ProductKind productKind, float price)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				throw new ArgumentException("Output name cannot be empty or whitespace.", "name");
			}
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			if (float.IsNaN(price) || float.IsInfinity(price) || price < 1f || price > 999f)
			{
				throw new ArgumentOutOfRangeException("price", "Output price must be finite and within the native 1 through 999 range.");
			}
			Name = name.Trim();
			ProductKind = productKind;
			Price = price;
		}
	}
	public sealed class ProductMixingProfile
	{
		public ProductKind ProductKind { get; }

		public ProductMixingMap MixerMap { get; }

		public string OutputFactoryIdentity { get; }

		public int OutputFactoryVersion { get; }

		public bool UsePropertyColorMixing { get; }

		internal Func<ProductMixingOutput, ProductMixingOutputDefinition> OutputFactory { get; }

		internal ProductMixingProfile(ProductKind productKind, ProductMixingMap mixerMap, Func<ProductMixingOutput, ProductMixingOutputDefinition> outputFactory, string outputFactoryIdentity, int outputFactoryVersion, bool usePropertyColorMixing)
		{
			ProductKind = productKind;
			MixerMap = mixerMap;
			OutputFactory = outputFactory;
			OutputFactoryIdentity = outputFactoryIdentity;
			OutputFactoryVersion = outputFactoryVersion;
			UsePropertyColorMixing = usePropertyColorMixing;
		}
	}
	public sealed class ProductMixingProfileBuilder
	{
		private readonly ProductKind _productKind;

		private ProductMixingMap _mixerMap;

		private Func<ProductMixingOutput, ProductMixingOutputDefinition>? _outputFactory;

		private string? _outputFactoryIdentity;

		private int _outputFactoryVersion;

		private bool _usePropertyColorMixing;

		public ProductMixingProfileBuilder(ProductKind productKind)
		{
			_productKind = productKind ?? throw new ArgumentNullException("productKind");
		}

		public ProductMixingProfileBuilder WithMixerMap(ProductMixingMap mixerMap)
		{
			if (!Enum.IsDefined(typeof(ProductMixingMap), mixerMap))
			{
				throw new ArgumentOutOfRangeException("mixerMap");
			}
			_mixerMap = mixerMap;
			return this;
		}

		public ProductMixingProfileBuilder WithOutputFactory(Func<ProductMixingOutput, ProductMixingOutputDefinition> outputFactory)
		{
			_outputFactory = outputFactory ?? throw new ArgumentNullException("outputFactory");
			return this;
		}

		public ProductMixingProfileBuilder WithOutputFactoryCompatibility(string identity, int version)
		{
			if (string.IsNullOrWhiteSpace(identity))
			{
				throw new ArgumentException("Output-factory compatibility identity cannot be empty or whitespace.", "identity");
			}
			if (version < 0)
			{
				throw new ArgumentOutOfRangeException("version");
			}
			_outputFactoryIdentity = ProductKindId.Normalize(identity, "identity");
			_outputFactoryVersion = version;
			return this;
		}

		public ProductMixingProfileBuilder WithPropertyColorMixing()
		{
			_usePropertyColorMixing = true;
			return this;
		}

		public ProductMixingProfile Build()
		{
			if (_outputFactory == null)
			{
				throw new InvalidOperationException("WithOutputFactory must be called before Build().");
			}
			string outputFactoryIdentity = _outputFactoryIdentity ?? ("s1api:factory/" + CustomProductManifestData.ComputeHash((_outputFactory.Method.DeclaringType?.AssemblyQualifiedName ?? string.Empty) + "|" + _outputFactory.Method.Name));
			return ProductMixingProfileRegistry.Register(new ProductMixingProfile(_productKind, _mixerMap, _outputFactory, outputFactoryIdentity, _outputFactoryVersion, _usePropertyColorMixing));
		}
	}
	public static class ProductMixingProfiles
	{
		public static ProductMixingProfile? Get(ProductKind productKind)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return Get(productKind.Id);
		}

		public static ProductMixingProfile? Get(string productKindId)
		{
			ProductMixingProfileRegistry.TryGet(productKindId, out ProductMixingProfile profile);
			return profile;
		}

		internal static bool TryGet(string productKindId, out ProductMixingProfile? profile)
		{
			return ProductMixingProfileRegistry.TryGet(productKindId, out profile);
		}
	}
	public sealed class ProductPackagingContentProfile
	{
		internal ProductPackagingContentSource Source { get; }

		internal Func<GameObject?>? ContentProvider { get; }

		internal IReadOnlyList<ProductPresentationTransform> Placements { get; }

		internal ProductPresentationTransform? CompleteVisualTransform { get; }

		internal ProductPackagingVisualTemplate? NativeVisualTemplate { get; }

		internal Action<GameObject>? NativeVisualCustomizer { get; }

		internal ProductPackagingContentProfile(ProductPackagingContentSource source, Func<GameObject?>? contentProvider, IReadOnlyList<ProductPresentationTransform> placements, ProductPresentationTransform? completeVisualTransform, ProductPackagingVisualTemplate? nativeVisualTemplate, Action<GameObject>? nativeVisualCustomizer)
		{
			Source = source;
			ContentProvider = contentProvider;
			Placements = placements;
			CompleteVisualTransform = completeVisualTransform;
			NativeVisualTemplate = nativeVisualTemplate;
			NativeVisualCustomizer = nativeVisualCustomizer;
		}
	}
	internal enum ProductPackagingContentSource
	{
		RepeatedContent,
		CompleteFilledVisual,
		NativeFilledVisualScaffold
	}
	public sealed class ProductPackagingContentProfileBuilder
	{
		private readonly List<ProductPresentationTransform> _placements = new List<ProductPresentationTransform>();

		private ProductPackagingContentSource _source = ProductPackagingContentSource.RepeatedContent;

		private Func<GameObject?>? _contentProvider;

		private ProductPresentationTransform? _completeVisualTransform;

		private ProductPackagingVisualTemplate? _nativeVisualTemplate;

		private Action<GameObject>? _nativeVisualCustomizer;

		public ProductPackagingContentProfileBuilder WithContent(Func<GameObject?> provider)
		{
			_contentProvider = provider ?? throw new ArgumentNullException("provider");
			_source = ProductPackagingContentSource.RepeatedContent;
			_completeVisualTransform = null;
			_nativeVisualTemplate = null;
			_nativeVisualCustomizer = null;
			return this;
		}

		public ProductPackagingContentProfileBuilder WithCompleteFilledVisual(Func<GameObject?> provider, ProductPresentationTransform? transform = null)
		{
			_contentProvider = provider ?? throw new ArgumentNullException("provider");
			_source = ProductPackagingContentSource.CompleteFilledVisual;
			_completeVisualTransform = transform;
			_nativeVisualTemplate = null;
			_nativeVisualCustomizer = null;
			return this;
		}

		public ProductPackagingContentProfileBuilder WithNativeFilledVisualScaffold(ProductPackagingVisualTemplate template, Action<GameObject>? customize = null, ProductPresentationTransform? transform = null)
		{
			if (!Enum.IsDefined(typeof(ProductPackagingVisualTemplate), template))
			{
				throw new ArgumentOutOfRangeException("template");
			}
			_source = ProductPackagingContentSource.NativeFilledVisualScaffold;
			_contentProvider = null;
			_completeVisualTransform = transform;
			_nativeVisualTemplate = template;
			_nativeVisualCustomizer = customize;
			return this;
		}

		public ProductPackagingContentProfileBuilder AddPlacement(ProductPresentationTransform placement)
		{
			_placements.Add(placement ?? throw new ArgumentNullException("placement"));
			return this;
		}

		public ProductPackagingContentProfileBuilder AddPlacements(params ProductPresentationTransform[] placements)
		{
			if (placements == null)
			{
				throw new ArgumentNullException("placements");
			}
			for (int i = 0; i < placements.Length; i++)
			{
				AddPlacement(placements[i]);
			}
			return this;
		}

		public ProductPackagingContentProfile Build()
		{
			if (_source != ProductPackagingContentSource.NativeFilledVisualScaffold && _contentProvider == null)
			{
				throw new InvalidOperationException("A packaging content provider must be configured before Build().");
			}
			if (_source != ProductPackagingContentSource.RepeatedContent && _placements.Count > 0)
			{
				throw new InvalidOperationException("Explicit content placements cannot be combined with a complete filled visual or a native filled visual scaffold. Configure the optional transform instead.");
			}
			return new ProductPackagingContentProfile(_source, _contentProvider, new List<ProductPresentationTransform>(_placements).AsReadOnly(), _completeVisualTransform, _nativeVisualTemplate, _nativeVisualCustomizer);
		}
	}
	public static class ProductPackagingContentProfileRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<ProductPackagingContentKey, ProductPackagingContentProfileRegistration> Registrations = new Dictionary<ProductPackagingContentKey, ProductPackagingContentProfileRegistration>();

		private static readonly Dictionary<ProductPackagingContentKey, ProductPackagingContentProfileRegistration> KindRegistrations = new Dictionary<ProductPackagingContentKey, ProductPackagingContentProfileRegistration>();

		public static ProductPackagingContentProfile Register(string ownerId, string productId, string packagingId, ProductPackagingContentProfile profile)
		{
			string text = NormalizeRequired(ownerId, "ownerId");
			string text2 = ProductKindId.Normalize(productId, "productId");
			string text3 = NormalizeRequired(packagingId, "packagingId");
			if (profile == null)
			{
				throw new ArgumentNullException("profile");
			}
			ProductPackagingContentKey key = new ProductPackagingContentKey(text2, text3);
			lock (Gate)
			{
				if (Registrations.TryGetValue(key, out ProductPackagingContentProfileRegistration value))
				{
					if (!string.Equals(value.OwnerId, text, StringComparison.OrdinalIgnoreCase))
					{
						throw new InvalidOperationException($"Packaging content for product '{text2}' and packaging '{text3}' is already owned by '{value.OwnerId}' and cannot be registered by '{text}'. Registration keys are case-insensitive.");
					}
					if (value.Profile != profile)
					{
						throw new InvalidOperationException($"Packaging content for product '{text2}' and packaging '{text3}' is already registered by " + "this owner with another profile. Reuse the original profile.");
					}
					return value.Profile;
				}
				Registrations.Add(key, new ProductPackagingContentProfileRegistration(text, key, profile));
				return profile;
			}
		}

		public static ProductPackagingContentProfile RegisterForProductKind(string ownerId, string productKindId, string packagingId, ProductPackagingContentProfile profile)
		{
			string text = NormalizeRequired(ownerId, "ownerId");
			string text2 = ProductKindId.Normalize(productKindId, "productKindId");
			string text3 = NormalizeRequired(packagingId, "packagingId");
			if (profile == null)
			{
				throw new ArgumentNullException("profile");
			}
			ProductPackagingContentKey key = new ProductPackagingContentKey(text2, text3);
			lock (Gate)
			{
				if (KindRegistrations.TryGetValue(key, out ProductPackagingContentProfileRegistration value))
				{
					if (!string.Equals(value.OwnerId, text, StringComparison.OrdinalIgnoreCase) || value.Profile != profile)
					{
						throw new InvalidOperationException($"Packaging content fallback for logical kind '{text2}' and packaging '{text3}' is already registered.");
					}
					return value.Profile;
				}
				KindRegistrations.Add(key, new ProductPackagingContentProfileRegistration(text, key, profile));
				return profile;
			}
		}

		internal static bool TryResolve(string productId, string packagingId, out ProductPackagingContentProfileRegistration? registration)
		{
			ProductPackagingContentKey key = new ProductPackagingContentKey(productId, packagingId);
			lock (Gate)
			{
				if (Registrations.TryGetValue(key, out registration))
				{
					return true;
				}
			}
			if (CustomProductDefinitionRegistry.TryGetMetadata(productId, out CustomProductDefinitionMetadata metadata) && metadata != null)
			{
				return TryResolveForProductKind(metadata.ProductKind.Id, packagingId, out registration);
			}
			registration = null;
			return false;
		}

		internal static bool TryResolveForProductKind(string productKindId, string packagingId, out ProductPackagingContentProfileRegistration? registration)
		{
			ProductPackagingContentKey key = new ProductPackagingContentKey(productKindId, packagingId);
			lock (Gate)
			{
				return KindRegistrations.TryGetValue(key, out registration);
			}
		}

		internal static ProductPackagingContentProfileRegistration[] Snapshot()
		{
			lock (Gate)
			{
				ProductPackagingContentProfileRegistration[] array = new ProductPackagingContentProfileRegistration[Registrations.Count + KindRegistrations.Count];
				Registrations.Values.CopyTo(array, 0);
				KindRegistrations.Values.CopyTo(array, Registrations.Count);
				return array;
			}
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				Registrations.Clear();
				KindRegistrations.Clear();
			}
			ProductPackagingContentRuntime.ResetForSceneChange();
		}

		private static string NormalizeRequired(string value, string parameterName)
		{
			if (value == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = value.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Value cannot be empty or whitespace.", parameterName);
			}
			return text;
		}
	}
	public enum ProductPackagingVisualTemplate
	{
		Marijuana,
		Methamphetamine,
		Cocaine,
		Shrooms
	}
	public static class ProductPopulator
	{
		public static PackagingDefinition? GetPackaging(string packagingId)
		{
			ItemDefinition definition = ItemManager.GetDefinition(packagingId);
			if (definition is PackagingDefinition packagingDefinition)
			{
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Found packaging: {packagingDefinition.Name} (ID: {packagingId})"));
				return packagingDefinition;
			}
			Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Could not find packaging with ID '" + packagingId + "'"));
			return null;
		}

		public static List<ProductDefinition> GetAllProductDefinitions()
		{
			Debug.Log(Object.op_Implicit("[ProductPopulator] Getting all product definitions from ProductManager.DiscoveredProducts"));
			ProductDefinition[] discoveredProducts = ProductManager.DiscoveredProducts;
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Found {discoveredProducts.Length} discovered products in save"));
			List<ProductDefinition> list = new List<ProductDefinition>();
			ProductDefinition[] array = discoveredProducts;
			foreach (ProductDefinition productDefinition in array)
			{
				list.Add(productDefinition);
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Found product: {productDefinition.Name} (ID: {productDefinition.ID})"));
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Total product definitions found: {list.Count}"));
			return list;
		}

		public static List<WeedDefinition> GetWeedDefinitions()
		{
			return (from p in GetAllProductDefinitions()
				where p is WeedDefinition
				select p).Cast<WeedDefinition>().ToList();
		}

		public static List<MethDefinition> GetMethDefinitions()
		{
			return (from p in GetAllProductDefinitions()
				where p is MethDefinition
				select p).Cast<MethDefinition>().ToList();
		}

		public static List<CocaineDefinition> GetCocaineDefinitions()
		{
			return (from p in GetAllProductDefinitions()
				where p is CocaineDefinition
				select p).Cast<CocaineDefinition>().ToList();
		}

		public static List<ShroomDefinition> GetShroomDefinitions()
		{
			return (from p in GetAllProductDefinitions()
				where p is ShroomDefinition
				select p).Cast<ShroomDefinition>().ToList();
		}

		public static int PopulateWithPackagedProducts(StorageInstance storage, string packagingId, int quantityPerItem = 1)
		{
			Debug.Log(Object.op_Implicit("[ProductPopulator] PopulateWithPackagedProducts called with packaging: " + packagingId));
			if (storage == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Cannot populate null storage"));
				return 0;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Storage name: '{storage.Name}', SlotCount: {storage.SlotCount}, ItemCount: {storage.ItemCount}"));
			PackagingDefinition packaging = GetPackaging(packagingId);
			if (packaging == null)
			{
				Debug.LogError(Object.op_Implicit("[ProductPopulator] Failed to get packaging '" + packagingId + "' - cannot create packaged products"));
				return 0;
			}
			List<ProductDefinition> allProductDefinitions = GetAllProductDefinitions();
			if (allProductDefinitions.Count == 0)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] No product definitions found in discovered products"));
				return 0;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Found {allProductDefinitions.Count} product definitions, filling {storage.SlotCount} slots"));
			int num = 0;
			int num2 = 0;
			while (num2 < storage.SlotCount && num < storage.SlotCount)
			{
				ProductDefinition productDefinition = allProductDefinitions[num2 % allProductDefinitions.Count];
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Slot {num2 + 1}/{storage.SlotCount}: Creating {quantityPerItem}g of '{productDefinition.Name}' in {packaging.Name}"));
				ProductInstance productInstance = CreatePackagedProduct(productDefinition, packaging, quantityPerItem);
				if (productInstance == null)
				{
					Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Failed to create packaged instance for '" + productDefinition.Name + "'"));
					num2++;
					continue;
				}
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Created packaged product: {productInstance.Definition.Name}, Quality: {productInstance.Quality}, Quantity: {productInstance.Quantity}, Packaged: {productInstance.IsPackaged}"));
				if (storage.CanItemFit(productInstance, productInstance.Quantity))
				{
					Debug.Log(Object.op_Implicit("[ProductPopulator] Item fits, adding to storage..."));
					storage.AddItem(productInstance);
					num++;
					Debug.Log(Object.op_Implicit($"[ProductPopulator] Successfully added {quantityPerItem}g of '{productDefinition.Name}' in {packaging.Name} to slot {num2 + 1}"));
					num2++;
					continue;
				}
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Item does not fit in storage: " + productDefinition.Name));
				break;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Finished populating storage. Added {num}/{storage.SlotCount} items. Storage now has {storage.ItemCount} items"));
			return num;
		}

		public static int PopulateWithSpecificPackagedProducts(StorageInstance storage, List<string> productIds, string packagingId, int quantityPerProduct = 1)
		{
			if (storage == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Cannot populate null storage"));
				return 0;
			}
			if (productIds == null || productIds.Count == 0)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] No product IDs provided"));
				return 0;
			}
			PackagingDefinition packaging = GetPackaging(packagingId);
			if (packaging == null)
			{
				Debug.LogError(Object.op_Implicit("[ProductPopulator] Failed to get packaging '" + packagingId + "'"));
				return 0;
			}
			int num = 0;
			foreach (string productId in productIds)
			{
				ItemDefinition definition = ItemManager.GetDefinition(productId);
				if (definition is ProductDefinition productDefinition)
				{
					ProductInstance productInstance = CreatePackagedProduct(productDefinition, packaging, quantityPerProduct);
					if (productInstance != null && storage.CanItemFit(productInstance, quantityPerProduct))
					{
						storage.AddItem(productInstance);
						num++;
						Debug.Log(Object.op_Implicit($"[ProductPopulator] Added {quantityPerProduct}x {productDefinition.Name} in {packaging.Name} to {storage.Name}"));
					}
				}
				else
				{
					Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Product '" + productId + "' not found or is not a product"));
				}
			}
			return num;
		}

		public static ProductInstance? CreatePackagedProduct(ProductDefinition productDef, PackagingDefinition packaging, int quantity)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			try
			{
				ProductDefinition s1ProductDefinition = productDef.S1ProductDefinition;
				PackagingDefinition val = CrossType.As<PackagingDefinition>((object)packaging.S1ItemDefinition);
				if ((Object)(object)val == (Object)null)
				{
					Debug.LogError(Object.op_Implicit("[ProductPopulator] Failed to get S1 packaging definition"));
					return null;
				}
				ProductItemInstance productInstance = new ProductItemInstance((ItemDefinition)(object)s1ProductDefinition, quantity, (EQuality)2, val);
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Created {packaging.Name} containing {quantity}g of {productDef.Name}"));
				return new ProductInstance(productInstance);
			}
			catch (Exception ex)
			{
				Debug.LogError(Object.op_Implicit("[ProductPopulator] Exception creating packaged product: " + ex.Message));
				return null;
			}
		}

		public static int PopulateWithUnpackagedProducts(StorageInstance storage, int quantityPerItem = 1)
		{
			Debug.Log(Object.op_Implicit("[ProductPopulator] PopulateWithUnpackagedProducts called"));
			if (storage == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Cannot populate null storage"));
				return 0;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Storage name: '{storage.Name}', SlotCount: {storage.SlotCount}, ItemCount: {storage.ItemCount}"));
			List<ProductDefinition> allProductDefinitions = GetAllProductDefinitions();
			if (allProductDefinitions.Count == 0)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] No product definitions found in discovered products"));
				return 0;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Found {allProductDefinitions.Count} product definitions, filling {storage.SlotCount} slots"));
			int num = 0;
			int num2 = 0;
			while (num2 < storage.SlotCount && num < storage.SlotCount)
			{
				ProductDefinition productDefinition = allProductDefinitions[num2 % allProductDefinitions.Count];
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Slot {num2 + 1}/{storage.SlotCount}: Creating {quantityPerItem}g of unpackaged '{productDefinition.Name}'"));
				if (!(productDefinition.CreateInstance(quantityPerItem) is ProductInstance productInstance))
				{
					Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Failed to create instance for '" + productDefinition.Name + "'"));
					num2++;
					continue;
				}
				Debug.Log(Object.op_Implicit($"[ProductPopulator] Created unpackaged product: {productInstance.Definition.Name}, Quality: {productInstance.Quality}, Quantity: {productInstance.Quantity}, Packaged: {productInstance.IsPackaged}"));
				if (storage.CanItemFit(productInstance, productInstance.Quantity))
				{
					Debug.Log(Object.op_Implicit("[ProductPopulator] Item fits, adding to storage..."));
					storage.AddItem(productInstance);
					num++;
					Debug.Log(Object.op_Implicit($"[ProductPopulator] Successfully added {quantityPerItem}g of unpackaged '{productDefinition.Name}' to slot {num2 + 1}"));
					num2++;
					continue;
				}
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Item does not fit in storage: " + productDefinition.Name));
				break;
			}
			Debug.Log(Object.op_Implicit($"[ProductPopulator] Finished populating storage. Added {num}/{storage.SlotCount} items. Storage now has {storage.ItemCount} items"));
			return num;
		}

		public static int PopulateWithSpecificProducts(StorageInstance storage, List<string> productIds, int quantityPerProduct = 1)
		{
			if (storage == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Cannot populate null storage"));
				return 0;
			}
			if (productIds == null || productIds.Count == 0)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] No product IDs provided"));
				return 0;
			}
			int num = 0;
			foreach (string productId in productIds)
			{
				ItemDefinition definition = ItemManager.GetDefinition(productId);
				if (definition is ProductDefinition productDefinition)
				{
					if (productDefinition.CreateInstance(quantityPerProduct) is ProductInstance itemInstance && storage.CanItemFit(itemInstance, quantityPerProduct))
					{
						storage.AddItem(itemInstance);
						num++;
						Debug.Log(Object.op_Implicit($"[ProductPopulator] Added {quantityPerProduct}x {productDefinition.Name} to {storage.Name}"));
					}
				}
				else
				{
					Debug.LogWarning(Object.op_Implicit("[ProductPopulator] Product '" + productId + "' not found or is not a product"));
				}
			}
			return num;
		}

		public static int PopulateWithWeedProducts(StorageInstance storage)
		{
			return PopulateWithPackagedProducts(storage, "jar", 20);
		}

		public static int PopulateFromGameObject(GameObject gameObject, string packagingId, int quantityPerItem = 1)
		{
			Debug.Log(Object.op_Implicit($"[ProductPopulator] PopulateFromGameObject called for '{((gameObject != null) ? ((Object)gameObject).name : null)}' with packaging '{packagingId}'"));
			if (gameObject == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] PopulateFromGameObject called with null GameObject"));
				return -1;
			}
			StorageInstance storageInstance = StorageInstance.FromGameObject(gameObject);
			if (storageInstance == null)
			{
				Debug.LogWarning(Object.op_Implicit("[ProductPopulator] No StorageEntity found on GameObject '" + ((gameObject != null) ? ((Object)gameObject).name : null) + "', trying FromGameObjectInChildren..."));
				storageInstance = StorageInstance.FromGameObjectInChildren(gameObject);
			}
			if (storageInstance == null)
			{
				Debug.LogError(Object.op_Implicit("[ProductPopulator] Failed to find StorageEntity on '" + ((gameObject != null) ? ((Object)gameObject).name : null) + "' or its children"));
				return -1;
			}
			Debug.Log(Object.op_Implicit("[ProductPopulator] Found storage, proceeding to populate..."));
			return PopulateWithPackagedProducts(storageInstance, packagingId, quantityPerItem);
		}
	}
	public enum ProductPresentationContext
	{
		Loose,
		Stored,
		Held,
		Station,
		FunctionalProduct,
		Icon,
		Consumption
	}
	public sealed class ProductPresentationProfile
	{
		internal IReadOnlyDictionary<ProductPresentationContext, Func<GameObject?>> VisualProviders { get; }

		internal IReadOnlyDictionary<ProductPresentationContext, ProductPresentationTransform> VisualTransforms { get; }

		internal Func<Sprite?>? IconProvider { get; }

		internal Func<GameObject?>? ConsumptionPrefabProvider { get; }

		internal bool GenerateIconFromLooseVisual { get; }

		internal int GeneratedIconSize { get; }

		internal bool FitGeneratedIconToCamera { get; }

		internal float GeneratedIconCameraFill { get; }

		internal ProductPresentationTransform? GeneratedIconTransform { get; }

		internal Func<GameObject?>? AvatarHeldVisualProvider { get; }

		internal ProductPresentationTransform? AvatarHeldTransform { get; }

		internal bool UseFunctionalProductConvexMeshColliders { get; }

		internal IReadOnlyCollection<ProductPresentationContext> RequiredContexts { get; }

		internal ProductPresentationProfile(IReadOnlyDictionary<ProductPresentationContext, Func<GameObject?>> visualProviders, IReadOnlyDictionary<ProductPresentationContext, ProductPresentationTransform> visualTransforms, Func<Sprite?>? iconProvider, Func<GameObject?>? consumptionPrefabProvider, bool generateIconFromLooseVisual, int generatedIconSize, bool fitGeneratedIconToCamera, float generatedIconCameraFill, ProductPresentationTransform? generatedIconTransform, Func<GameObject?>? avatarHeldVisualProvider, ProductPresentationTransform? avatarHeldTransform, bool useFunctionalProductConvexMeshColliders, IReadOnlyCollection<ProductPresentationContext> requiredContexts)
		{
			VisualProviders = visualProviders;
			VisualTransforms = visualTransforms;
			IconProvider = iconProvider;
			ConsumptionPrefabProvider = consumptionPrefabProvider;
			GenerateIconFromLooseVisual = generateIconFromLooseVisual;
			GeneratedIconSize = generatedIconSize;
			FitGeneratedIconToCamera = fitGeneratedIconToCamera;
			GeneratedIconCameraFill = generatedIconCameraFill;
			GeneratedIconTransform = generatedIconTransform;
			AvatarHeldVisualProvider = avatarHeldVisualProvider;
			AvatarHeldTransform = avatarHeldTransform;
			UseFunctionalProductConvexMeshColliders = useFunctionalProductConvexMeshColliders;
			RequiredContexts = requiredContexts;
		}

		internal bool IsRequired(ProductPresentationContext context)
		{
			foreach (ProductPresentationContext requiredContext in RequiredContexts)
			{
				if (requiredContext == context)
				{
					return true;
				}
			}
			return false;
		}

		internal bool TryGetVisualProvider(ProductPresentationContext context, out Func<GameObject?>? provider)
		{
			if (VisualProviders.TryGetValue(context, out provider))
			{
				return true;
			}
			if (context != ProductPresentationContext.Loose && VisualProviders.TryGetValue(ProductPresentationContext.Loose, out provider))
			{
				return true;
			}
			provider = null;
			return false;
		}

		internal bool TryGetVisualTransform(ProductPresentationContext context, out ProductPresentationTransform? presentationTransform)
		{
			if (VisualTransforms.TryGetValue(context, out presentationTransform))
			{
				return true;
			}
			if (context != ProductPresentationContext.Loose && !VisualProviders.ContainsKey(context) && VisualTransforms.TryGetValue(ProductPresentationContext.Loose, out presentationTransform))
			{
				return true;
			}
			presentationTransform = null;
			return false;
		}

		internal bool TryGetAvatarHeldVisualProvider(out Func<GameObject?>? provider)
		{
			if (AvatarHeldVisualProvider != null)
			{
				provider = AvatarHeldVisualProvider;
				return true;
			}
			return TryGetVisualProvider(ProductPresentationContext.Held, out provider);
		}

		internal bool TryGetAvatarHeldTransform(out ProductPresentationTransform? presentationTransform)
		{
			if (AvatarHeldTransform != null)
			{
				presentationTransform = AvatarHeldTransform;
				return true;
			}
			return TryGetVisualTransform(ProductPresentationContext.Held, out presentationTransform);
		}
	}
	public sealed class ProductPresentationProfileBuilder
	{
		private readonly Dictionary<ProductPresentationContext, Func<GameObject?>> _visualProviders = new Dictionary<ProductPresentationContext, Func<GameObject>>();

		private readonly HashSet<ProductPresentationContext> _requiredContexts = new HashSet<ProductPresentationContext>();

		private readonly Dictionary<ProductPresentationContext, ProductPresentationTransform> _visualTransforms = new Dictionary<ProductPresentationContext, ProductPresentationTransform>();

		private Func<Sprite?>? _iconProvider;

		private Func<GameObject?>? _consumptionPrefabProvider;

		private bool _generateIconFromLooseVisual;

		private int _generatedIconSize = 512;

		private bool _fitGeneratedIconToCamera = true;

		private float _generatedIconCameraFill = 0.72f;

		private ProductPresentationTransform? _generatedIconTransform;

		private Func<GameObject?>? _avatarHeldVisualProvider;

		private ProductPresentationTransform? _avatarHeldTransform;

		private bool _useFunctionalProductConvexMeshColliders;

		public ProductPresentationProfileBuilder WithLooseVisual(Func<GameObject?> provider)
		{
			return SetVisualProvider(ProductPresentationContext.Loose, provider);
		}

		public ProductPresentationProfileBuilder WithLooseVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			return SetVisualProvider(ProductPresentationContext.Loose, provider, presentationTransform);
		}

		public ProductPresentationProfileBuilder WithStoredVisual(Func<GameObject?> provider)
		{
			return SetVisualProvider(ProductPresentationContext.Stored, provider);
		}

		public ProductPresentationProfileBuilder WithStoredVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			return SetVisualProvider(ProductPresentationContext.Stored, provider, presentationTransform);
		}

		public ProductPresentationProfileBuilder WithHeldVisual(Func<GameObject?> provider)
		{
			return SetVisualProvider(ProductPresentationContext.Held, provider);
		}

		public ProductPresentationProfileBuilder WithHeldVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			return SetVisualProvider(ProductPresentationContext.Held, provider, presentationTransform);
		}

		public ProductPresentationProfileBuilder WithAvatarHeldVisual(Func<GameObject?> provider)
		{
			_avatarHeldVisualProvider = provider ?? throw new ArgumentNullException("provider");
			return this;
		}

		public ProductPresentationProfileBuilder WithAvatarHeldVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			_avatarHeldVisualProvider = provider ?? throw new ArgumentNullException("provider");
			_avatarHeldTransform = presentationTransform ?? throw new ArgumentNullException("presentationTransform");
			return this;
		}

		public ProductPresentationProfileBuilder WithAvatarHeldTransform(ProductPresentationTransform presentationTransform)
		{
			_avatarHeldTransform = presentationTransform ?? throw new ArgumentNullException("presentationTransform");
			return this;
		}

		public ProductPresentationProfileBuilder WithStationVisual(Func<GameObject?> provider)
		{
			return SetVisualProvider(ProductPresentationContext.Station, provider);
		}

		public ProductPresentationProfileBuilder WithStationVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			return SetVisualProvider(ProductPresentationContext.Station, provider, presentationTransform);
		}

		public ProductPresentationProfileBuilder WithFunctionalProductVisual(Func<GameObject?> provider)
		{
			return SetVisualProvider(ProductPresentationContext.FunctionalProduct, provider);
		}

		public ProductPresentationProfileBuilder WithFunctionalProductVisual(Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			return SetVisualProvider(ProductPresentationContext.FunctionalProduct, provider, presentationTransform);
		}

		public ProductPresentationProfileBuilder WithFunctionalProductConvexMeshColliders()
		{
			_useFunctionalProductConvexMeshColliders = true;
			return this;
		}

		public ProductPresentationProfileBuilder WithIcon(Func<Sprite?> provider)
		{
			_iconProvider = provider ?? throw new ArgumentNullException("provider");
			_generateIconFromLooseVisual = false;
			return this;
		}

		public ProductPresentationProfileBuilder WithGeneratedIconFromLooseVisual(int size = 512)
		{
			return ConfigureGeneratedIcon(size, fitToCamera: true, 0.72f);
		}

		public ProductPresentationProfileBuilder WithGeneratedIconFromLooseVisual(int size, bool fitToCamera, float cameraFill = 0.72f)
		{
			return ConfigureGeneratedIcon(size, fitToCamera, cameraFill);
		}

		public ProductPresentationProfileBuilder WithGeneratedIconTransform(ProductPresentationTransform presentationTransform)
		{
			_generatedIconTransform = presentationTransform ?? throw new ArgumentNullException("presentationTransform");
			return this;
		}

		public ProductPresentationProfileBuilder WithConsumptionPrefab(Func<GameObject?> provider)
		{
			_consumptionPrefabProvider = provider ?? throw new ArgumentNullException("provider");
			return this;
		}

		public ProductPresentationProfileBuilder Require(params ProductPresentationContext[] contexts)
		{
			if (contexts == null)
			{
				throw new ArgumentNullException("contexts");
			}
			foreach (ProductPresentationContext productPresentationContext in contexts)
			{
				if (!Enum.IsDefined(typeof(ProductPresentationContext), productPresentationContext))
				{
					throw new ArgumentOutOfRangeException("contexts", productPresentationContext, "Presentation contexts must be defined values.");
				}
				_requiredContexts.Add(productPresentationContext);
			}
			return this;
		}

		public ProductPresentationProfile Build()
		{
			ValidateRequiredProviders();
			return new ProductPresentationProfile(new Dictionary<ProductPresentationContext, Func<GameObject>>(_visualProviders), new Dictionary<ProductPresentationContext, ProductPresentationTransform>(_visualTransforms), _iconProvider, _consumptionPrefabProvider, _generateIconFromLooseVisual, _generatedIconSize, _fitGeneratedIconToCamera, _generatedIconCameraFill, _generatedIconTransform, _avatarHeldVisualProvider, _avatarHeldTransform, _useFunctionalProductConvexMeshColliders, new List<ProductPresentationContext>(_requiredContexts).AsReadOnly());
		}

		private ProductPresentationProfileBuilder SetVisualProvider(ProductPresentationContext context, Func<GameObject?> provider)
		{
			_visualProviders[context] = provider ?? throw new ArgumentNullException("provider");
			_visualTransforms.Remove(context);
			return this;
		}

		private ProductPresentationProfileBuilder SetVisualProvider(ProductPresentationContext context, Func<GameObject?> provider, ProductPresentationTransform presentationTransform)
		{
			_visualProviders[context] = provider ?? throw new ArgumentNullException("provider");
			_visualTransforms[context] = presentationTransform ?? throw new ArgumentNullException("presentationTransform");
			return this;
		}

		private ProductPresentationProfileBuilder ConfigureGeneratedIcon(int size, bool fitToCamera, float cameraFill)
		{
			if (size < 32 || size > 2048)
			{
				throw new ArgumentOutOfRangeException("size", size, "Generated icon size must be between 32 and 2048 pixels.");
			}
			if (cameraFill <= 0f || cameraFill > 2f)
			{
				throw new ArgumentOutOfRangeException("cameraFill", cameraFill, "Generated icon camera fill must be greater than zero and at most 2.");
			}
			_iconProvider = null;
			_generateIconFromLooseVisual = true;
			_generatedIconSize = size;
			_fitGeneratedIconToCamera = fitToCamera;
			_generatedIconCameraFill = cameraFill;
			return this;
		}

		private void ValidateRequiredProviders()
		{
			if (_useFunctionalProductConvexMeshColliders && !_visualProviders.ContainsKey(ProductPresentationContext.FunctionalProduct) && !_visualProviders.ContainsKey(ProductPresentationContext.Loose))
			{
				throw new InvalidOperationException("Functional-product convex mesh colliders require a functional-product visual or loose-visual fallback before Build().");
			}
			foreach (ProductPresentationContext requiredContext in _requiredContexts)
			{
				if (requiredContext switch
				{
					ProductPresentationContext.Icon => (_iconProvider != null || (_generateIconFromLooseVisual && _visualProviders.ContainsKey(ProductPresentationContext.Loose))) ? 1 : 0, 
					ProductPresentationContext.Consumption => (_consumptionPrefabProvider != null) ? 1 : 0, 
					_ => (_visualProviders.ContainsKey(requiredContext) || (requiredContext != ProductPresentationContext.Loose && _visualProviders.ContainsKey(ProductPresentationContext.Loose))) ? 1 : 0, 
				} == 0)
				{
					throw new InvalidOperationException($"Required presentation context '{requiredContext}' does not have a provider. " + "Configure that context or a supported loose-visual fallback before Build().");
				}
			}
		}
	}
	public static class ProductPresentationProfileRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ProductPresentationProfileRegistration> ProductProfiles = new Dictionary<string, ProductPresentationProfileRegistration>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, ProductPresentationProfileRegistration> KindProfiles = new Dictionary<string, ProductPresentationProfileRegistration>(StringComparer.OrdinalIgnoreCase);

		public static ProductPresentationProfile RegisterForProduct(string ownerId, string productId, ProductPresentationProfile profile)
		{
			return Register(ProductProfiles, "product ID", ownerId, ProductKindId.Normalize(productId, "productId"), profile);
		}

		public static ProductPresentationProfile RegisterForProductKind(string ownerId, ProductKind productKind, ProductPresentationProfile profile)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return Register(KindProfiles, "product-kind ID", ownerId, productKind.Id, profile);
		}

		private static ProductPresentationProfile Register(Dictionary<string, ProductPresentationProfileRegistration> registrations, string keyDescription, string ownerId, string key, ProductPresentationProfile profile)
		{
			string text = NormalizeRequired(ownerId, "ownerId");
			string text2 = NormalizeRequired(key, "key");
			if (profile == null)
			{
				throw new ArgumentNullException("profile");
			}
			bool flag = false;
			ProductPresentationProfileRegistration productPresentationProfileRegistration;
			lock (Gate)
			{
				if (registrations.TryGetValue(text2, out ProductPresentationProfileRegistration value))
				{
					if (!string.Equals(value.OwnerId, text, StringComparison.OrdinalIgnoreCase))
					{
						throw new InvalidOperationException($"Presentation profile {keyDescription} '{text2}' is already owned by '{value.OwnerId}' and cannot be registered by '{text}'. Registration keys are case-insensitive.");
					}
					if (value.Profile != profile)
					{
						throw new InvalidOperationException($"Presentation profile {keyDescription} '{text2}' is already " + "registered by this owner with another profile. Reuse the original profile or choose another stable key.");
					}
					return value.Profile;
				}
				productPresentationProfileRegistration = new ProductPresentationProfileRegistration(text, text2, profile);
				registrations.Add(text2, productPresentationProfileRegistration);
				flag = true;
			}
			try
			{
				CustomProductDefinitionRegistry.ApplyPresentationProfiles();
				return productPresentationProfileRegistration.Profile;
			}
			catch
			{
				if (flag)
				{
					lock (Gate)
					{
						if (registrations.TryGetValue(text2, out ProductPresentationProfileRegistration value2) && value2 == productPresentationProfileRegistration)
						{
							registrations.Remove(text2);
						}
					}
					try
					{
						CustomProductDefinitionRegistry.ApplyPresentationProfiles();
					}
					catch (Exception ex)
					{
						MelonLogger.Error("[ProductPresentationProfileRegistry] Failed to restore presentation fallbacks after rejecting '" + text2 + "': " + ex);
					}
				}
				throw;
			}
		}

		internal static bool TryResolve(string productId, string productKindId, out ProductPresentationProfileRegistration? registration)
		{
			lock (Gate)
			{
				if (ProductProfiles.TryGetValue(productId, out registration))
				{
					return true;
				}
				return KindProfiles.TryGetValue(productKindId, out registration);
			}
		}

		internal static bool TryGetWorkbenchProfile(string key, out ProductPresentationProfile? profile)
		{
			lock (Gate)
			{
				if (ProductProfiles.TryGetValue(key, out ProductPresentationProfileRegistration value))
				{
					profile = value.Profile;
					return true;
				}
				if (KindProfiles.TryGetValue(key, out ProductPresentationProfileRegistration value2))
				{
					profile = value2.Profile;
					return true;
				}
			}
			if (CustomProductDefinitionRegistry.TryGetMetadata(key, out CustomProductDefinitionMetadata metadata) && metadata != null)
			{
				lock (Gate)
				{
					if (KindProfiles.TryGetValue(metadata.ProductKind.Id, out ProductPresentationProfileRegistration value3))
					{
						profile = value3.Profile;
						return true;
					}
				}
			}
			profile = null;
			return false;
		}

		internal static bool TryGetManifestIdentity(string productId, string productKindId, out string identity)
		{
			if (TryResolve(productId, productKindId, out ProductPresentationProfileRegistration registration) && registration != null)
			{
				string text = registration.OwnerId.Length + ":" + registration.OwnerId + registration.Key.Length + ":" + registration.Key;
				identity = ((text.Length <= 256) ? text : ("sha256:" + CustomProductManifestData.ComputeHash(text.ToLowerInvariant())));
				return true;
			}
			identity = string.Empty;
			return false;
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				ProductProfiles.Clear();
				KindProfiles.Clear();
			}
		}

		private static string NormalizeRequired(string value, string parameterName)
		{
			if (value == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = value.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Value cannot be empty or whitespace.", parameterName);
			}
			return text;
		}
	}
	public sealed class ProductPresentationTransform
	{
		public Vector3 LocalPosition { get; }

		public Vector3 LocalEulerAngles { get; }

		public Vector3 LocalScale { get; }

		public ProductPresentationTransform(Vector3 localPosition, Vector3 localEulerAngles, Vector3 localScale)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			LocalPosition = localPosition;
			LocalEulerAngles = localEulerAngles;
			LocalScale = localScale;
		}

		internal void ApplyTo(Transform target)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			target.localPosition = LocalPosition;
			target.localEulerAngles = LocalEulerAngles;
			target.localScale = LocalScale;
		}
	}
	public enum Quality
	{
		Trash,
		Poor,
		Standard,
		Premium,
		Heavenly
	}
	internal static class QualityExtensions
	{
		internal static Quality ToAPI(this EQuality quality)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			Quality result = (int)quality switch
			{
				0 => Quality.Trash, 
				1 => Quality.Poor, 
				2 => Quality.Standard, 
				3 => Quality.Premium, 
				4 => Quality.Heavenly, 
				_ => Quality.Trash, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static EQuality ToInternal(this Quality quality)
		{
			//IL_0022: 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_002a: 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_0032: 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_003d: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			EQuality result = (EQuality)(quality switch
			{
				Quality.Trash => 0, 
				Quality.Poor => 1, 
				Quality.Standard => 2, 
				Quality.Premium => 3, 
				Quality.Heavenly => 4, 
				_ => 0, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public sealed class ShroomAppearanceSettings
	{
		internal readonly ShroomAppearanceSettings S1AppearanceSettings;

		public static Color32 DefaultPrimaryColor => ShroomAppearanceSettings.DefaultPrimaryColor;

		public static Color32 DefaultSecondaryColor => ShroomAppearanceSettings.DefaultSecondaryColor;

		public static Color32 DefaultSpotsColor => ShroomAppearanceSettings.DefaultSpotsColor;

		public Color32 PrimaryColor => S1AppearanceSettings.PrimaryColor;

		public Color32 SecondaryColor => S1AppearanceSettings.SecondaryColor;

		public bool HasSpots => S1AppearanceSettings.HasSpots;

		public Color32 SpotsColor => S1AppearanceSettings.SpotsColor;

		internal ShroomAppearanceSettings(ShroomAppearanceSettings settings)
		{
			S1AppearanceSettings = settings;
		}

		public bool IsUninitialized()
		{
			return S1AppearanceSettings.IsUnintialized();
		}
	}
	public sealed class ShroomDefinition : ProductDefinition
	{
		internal ShroomDefinition S1ShroomDefinition => CrossType.As<ShroomDefinition>((object)base.S1ItemDefinition);

		public Material ShroomMaterial => S1ShroomDefinition.ShroomMaterial;

		public Material BulkMaterial => S1ShroomDefinition.BulkMaterial;

		public Material EyeballMaterial => S1ShroomDefinition.EyeballMaterial;

		public ShroomAppearanceSettings AppearanceSettings => new ShroomAppearanceSettings(S1ShroomDefinition.AppearanceSettings);

		internal ShroomDefinition(ShroomDefinition definition)
			: base((ProductDefinition)(object)definition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new ProductInstance(CrossType.As<ProductItemInstance>((object)((ItemDefinition)S1ShroomDefinition).GetDefaultInstance(quantity)));
		}

		public List<PropertyBase> GetProperties()
		{
			List<PropertyBase> list = new List<PropertyBase>();
			ShroomDefinition s1ShroomDefinition = S1ShroomDefinition;
			List<Effect> val = ((s1ShroomDefinition != null) ? ((PropertyItemDefinition)s1ShroomDefinition).Properties : null);
			if (val != null)
			{
				for (int i = 0; i < val.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(val[i]));
				}
			}
			return list;
		}
	}
	public sealed class ShroomInstance : ProductInstance
	{
		internal ShroomInstance S1ShroomInstance => CrossType.As<ShroomInstance>((object)S1ItemInstance);

		public new ShroomDefinition Definition => new ShroomDefinition(CrossType.As<ShroomDefinition>((object)((ItemInstance)S1ShroomInstance).Definition));

		public string Name => ((BaseItemInstance)S1ShroomInstance).Name;

		internal ShroomInstance(ShroomInstance shroomInstance)
			: base((ProductItemInstance)(object)shroomInstance)
		{
		}
	}
	public sealed class WeedAppearanceSettings
	{
		public Color32 MainColor { get; }

		public Color32 SecondaryColor { get; }

		public Color32 LeafColor { get; }

		public Color32 StemColor { get; }

		public WeedAppearanceSettings(Color32 mainColor, Color32 secondaryColor, Color32 leafColor, Color32 stemColor)
		{
			//IL_0008: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			ValidateColor(mainColor, "mainColor");
			ValidateColor(secondaryColor, "secondaryColor");
			ValidateColor(leafColor, "leafColor");
			ValidateColor(stemColor, "stemColor");
			MainColor = mainColor;
			SecondaryColor = secondaryColor;
			LeafColor = leafColor;
			StemColor = stemColor;
		}

		internal WeedAppearanceSettings ToNative()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new WeedAppearanceSettings(MainColor, SecondaryColor, LeafColor, StemColor);
		}

		private static void ValidateColor(Color32 color, string parameterName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (color.r == 0 && color.g == 0 && color.b == 0 && color.a == 0)
			{
				throw new ArgumentException("Weed appearance colors must not be Color.clear.", parameterName);
			}
		}
	}
	public class WeedDefinition : ProductDefinition
	{
		internal WeedDefinition S1WeedDefinition => CrossType.As<WeedDefinition>((object)base.S1ItemDefinition);

		internal WeedDefinition(WeedDefinition definition)
			: base((ProductDefinition)(object)definition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new ProductInstance(CrossType.As<ProductItemInstance>((object)((ItemDefinition)S1WeedDefinition).GetDefaultInstance(quantity)));
		}

		public List<PropertyBase> GetProperties()
		{
			List<PropertyBase> list = new List<PropertyBase>();
			WeedDefinition s1WeedDefinition = S1WeedDefinition;
			List<Effect> val = ((s1WeedDefinition != null) ? ((PropertyItemDefinition)s1WeedDefinition).Properties : null);
			if (val != null)
			{
				for (int i = 0; i < val.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(val[i]));
				}
			}
			return list;
		}
	}
	public sealed class WeedDefinitionBuilder
	{
		private static readonly Log Logger = new Log("WeedDefinitionBuilder");

		private readonly string _id;

		private readonly List<PropertyBase> _properties = new List<PropertyBase>();

		private string? _name;

		private WeedAppearanceSettings? _appearance;

		public WeedDefinitionBuilder(string id)
		{
			_id = WeedDefinitionBuilderContract.NormalizeId(id);
		}

		public WeedDefinitionBuilder WithName(string name)
		{
			_name = WeedDefinitionBuilderContract.NormalizeName(name);
			return this;
		}

		public WeedDefinitionBuilder WithProperty(PropertyBase property)
		{
			if (property == null)
			{
				throw new ArgumentNullException("property");
			}
			_properties.Add(property);
			return this;
		}

		public WeedDefinitionBuilder WithProperties(params PropertyBase[] properties)
		{
			if (properties == null)
			{
				throw new ArgumentNullException("properties");
			}
			_properties.Clear();
			for (int i = 0; i < properties.Length; i++)
			{
				if (properties[i] == null)
				{
					throw new ArgumentException("Weed properties cannot contain null values.", "properties");
				}
				_properties.Add(properties[i]);
			}
			return this;
		}

		public WeedDefinitionBuilder WithAppearance(WeedAppearanceSettings appearance)
		{
			_appearance = appearance ?? throw new ArgumentNullException("appearance");
			return this;
		}

		public WeedDefinition Build()
		{
			if (_name == null)
			{
				throw new InvalidOperationException("WithName must be called before Build().");
			}
			string text = WeedDefinitionBuilderContract.NormalizeName(_name);
			ProductManager instance = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				throw new InvalidOperationException("Cannot build a weed product before ProductManager is available. Build from GameLifecycle.OnLoadComplete or later.");
			}
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				throw new InvalidOperationException("Cannot build a weed product before the item registry is available. Build from GameLifecycle.OnLoadComplete or later.");
			}
			ItemDefinition item = Registry.GetItem(_id);
			if ((Object)(object)item != (Object)null)
			{
				return WrapExisting(item, isDuplicate: true);
			}
			List<Effect> list = PropertyResolver.ResolveToGameProperties(_properties);
			WeedDefinitionBuilderContract.ValidatePropertyCounts(_properties.Count, list.Count);
			List<string> val = new List<string>();
			for (int i = 0; i < list.Count; i++)
			{
				val.Add(list[i].ID);
			}
			instance.CreateWeed_Server(text, _id, (EDrugType)0, val, _appearance?.ToNative());
			ItemDefinition item2 = Registry.GetItem(_id);
			if ((Object)(object)item2 == (Object)null)
			{
				throw new InvalidOperationException("The native product creator did not register weed product '" + _id + "'. Ensure Build() runs on a connected host/server after the save has loaded.");
			}
			return WrapExisting(item2, isDuplicate: false);
		}

		private WeedDefinition WrapExisting(object item, bool isDuplicate)
		{
			if (CrossType.Is<WeedDefinition>(item, out WeedDefinition result))
			{
				if (isDuplicate)
				{
					Logger.Warning("Weed product '" + _id + "' is already registered; returning the existing native definition.");
				}
				return new WeedDefinition(result);
			}
			throw new InvalidOperationException("Item ID '" + _id + "' is already registered by a non-weed definition. Choose a different namespaced ID.");
		}
	}
	internal static class WeedDefinitionBuilderContract
	{
		internal const int MaximumPropertyCount = 8;

		internal static string NormalizeId(string id)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("Weed product ID cannot be null or whitespace.", "id");
			}
			string text = id.Trim();
			int num = text.IndexOf(':');
			if (num <= 0 || num == text.Length - 1 || num != text.LastIndexOf(':'))
			{
				throw new ArgumentException("Weed product ID must be namespaced in the form 'mod-id:product-id'.", "id");
			}
			foreach (char c in text)
			{
				if (c != ':' && !IsSafeIdCharacter(c))
				{
					throw new ArgumentException("Weed product ID may only contain ASCII letters, digits, '.', '_' and '-' around its namespace separator.", "id");
				}
			}
			return text;
		}

		internal static string NormalizeName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				throw new ArgumentException("Weed product name cannot be null or whitespace.", "name");
			}
			return name.Trim();
		}

		internal static void ValidatePropertyCounts(int requestedCount, int resolvedCount)
		{
			if (requestedCount < 1)
			{
				throw new InvalidOperationException("Cannot build a weed product without a property. Use WithProperty(...) or WithProperties(...).");
			}
			if (requestedCount != resolvedCount)
			{
				throw new InvalidOperationException("Every supplied property must resolve to a distinct native property. Use vanilla property tokens or registered custom properties and remove duplicates.");
			}
			if (resolvedCount > 8)
			{
				throw new InvalidOperationException($"A weed product can have at most {8} properties.");
			}
		}

		private static bool IsSafeIdCharacter(char character)
		{
			return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9') || character == '.' || character == '_' || character == '-';
		}
	}
	public static class WeedItemCreator
	{
		public static WeedDefinitionBuilder CreateBuilder(string id)
		{
			return new WeedDefinitionBuilder(id);
		}
	}
}
namespace S1API.Products.Packaging
{
	public enum StealthLevel
	{
		None,
		Basic,
		Advanced
	}
	internal static class StealthLevelExtensions
	{
		internal static StealthLevel ToAPI(this EStealthLevel stealthLevel)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			StealthLevel result = (int)stealthLevel switch
			{
				0 => StealthLevel.None, 
				1 => StealthLevel.Basic, 
				2 => StealthLevel.Advanced, 
				_ => StealthLevel.None, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static EStealthLevel ToInternal(this StealthLevel stealthLevel)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			EStealthLevel result = (EStealthLevel)(stealthLevel switch
			{
				StealthLevel.None => 0, 
				StealthLevel.Basic => 1, 
				StealthLevel.Advanced => 2, 
				_ => 0, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
}
namespace S1API.PhoneCalls
{
	public class CallerDefinition
	{
		internal readonly CallerID S1CallerIDEntry;

		public string Name
		{
			get
			{
				return S1CallerIDEntry.Name;
			}
			set
			{
				S1CallerIDEntry.Name = value;
			}
		}

		public Sprite? ProfilePicture
		{
			get
			{
				return S1CallerIDEntry.ProfilePicture;
			}
			set
			{
				S1CallerIDEntry.ProfilePicture = value;
			}
		}

		internal CallerDefinition(CallerID s1CallerID)
		{
			S1CallerIDEntry = s1CallerID;
		}
	}
	public static class CallManager
	{
		private static readonly Queue<PhoneCallData> PendingCalls = new Queue<PhoneCallData>();

		internal static bool IsDispatchingToGameQueue;

		public static int PendingCount => PendingCalls.Count;

		public static void QueueCall(PhoneCallDefinition phoneCallDefinition)
		{
			if (phoneCallDefinition == null)
			{
				throw new ArgumentNullException("phoneCallDefinition");
			}
			PendingCalls.Enqueue(phoneCallDefinition.S1PhoneCallData);
			TryProcessQueue();
		}

		internal static void QueueCall(PhoneCallData phoneCallData)
		{
			if ((Object)(object)phoneCallData == (Object)null)
			{
				throw new ArgumentNullException("phoneCallData");
			}
			PendingCalls.Enqueue(phoneCallData);
			TryProcessQueue();
		}

		public static void ClearPendingQueue()
		{
			PendingCalls.Clear();
		}

		private static PhoneCallData? GetQueuedCallData(CallManager manager)
		{
			object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(manager, "QueuedCallData");
			return (PhoneCallData?)((obj is PhoneCallData) ? obj : null);
		}

		internal static void TryProcessQueue()
		{
			CallManager instance = Singleton<CallManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			CallInterface instance2 = Singleton<CallInterface>.Instance;
			if ((Object)(object)instance2 == (Object)null || (Object)(object)instance2.ActiveCallData != (Object)null || (Object)(object)GetQueuedCallData(instance) != (Object)null || PendingCalls.Count == 0)
			{
				return;
			}
			PhoneCallData val = null;
			while (PendingCalls.Count > 0)
			{
				PhoneCallData val2 = PendingCalls.Dequeue();
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					if ((Object)(object)val2.CallerID == (Object)null)
					{
						CallerID val3 = ScriptableObject.CreateInstance<CallerID>();
						val3.Name = "Unknown Caller";
						val3.ProfilePicture = null;
						val2.CallerID = val3;
					}
					if (val2.Stages == null)
					{
						val2.Stages = Il2CppReferenceArray<Stage>.op_Implicit(Array.Empty<Stage>());
					}
				}
				catch
				{
				}
				if (val2.Stages == null || ((Il2CppArrayBase<Stage>)(object)val2.Stages).Length == 0)
				{
					continue;
				}
				val = val2;
				break;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			IsDispatchingToGameQueue = true;
			try
			{
				instance.QueueCall(val);
			}
			finally
			{
				IsDispatchingToGameQueue = false;
			}
		}
	}
	public class CallStageEntry
	{
		internal readonly Stage S1Stage;

		protected readonly List<SystemTriggerEntry> StartTriggerEntries = new List<SystemTriggerEntry>();

		protected readonly List<SystemTriggerEntry> DoneTriggerEntries = new List<SystemTriggerEntry>();

		public string Text
		{
			get
			{
				return S1Stage.Text;
			}
			set
			{
				S1Stage.Text = value;
			}
		}

		internal CallStageEntry(Stage stage)
		{
			S1Stage = stage;
		}

		public SystemTriggerEntry AddSystemTrigger(SystemTriggerType triggerType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SystemTrigger val = new SystemTrigger();
			SystemTriggerEntry systemTriggerEntry = new SystemTriggerEntry(val);
			switch (triggerType)
			{
			case SystemTriggerType.StartTrigger:
				S1Stage.OnStartTriggers = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<SystemTrigger>(S1Stage.OnStartTriggers, (SystemTrigger[]?)(object)new SystemTrigger[1] { val });
				StartTriggerEntries.Add(systemTriggerEntry);
				break;
			case SystemTriggerType.DoneTrigger:
				S1Stage.OnDoneTriggers = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<SystemTrigger>(S1Stage.OnDoneTriggers, (SystemTrigger[]?)(object)new SystemTrigger[1] { val });
				DoneTriggerEntries.Add(systemTriggerEntry);
				break;
			}
			return systemTriggerEntry;
		}
	}
	public abstract class PhoneCallDefinition
	{
		public CallerDefinition? Caller;

		public readonly PhoneCallData S1PhoneCallData;

		protected readonly List<CallStageEntry> StageEntries = new List<CallStageEntry>();

		protected PhoneCallDefinition(string name, Sprite? profilePicture = null)
		{
			S1PhoneCallData = ScriptableObject.CreateInstance<PhoneCallData>();
			PhoneCallData s1PhoneCallData = S1PhoneCallData;
			if (s1PhoneCallData.Stages == null)
			{
				Il2CppReferenceArray<Stage> val = (s1PhoneCallData.Stages = Il2CppReferenceArray<Stage>.op_Implicit(Array.Empty<Stage>()));
			}
			AddCallerID(name, profilePicture);
		}

		protected PhoneCallDefinition(NPC? npcCallerID)
		{
			S1PhoneCallData = ScriptableObject.CreateInstance<PhoneCallData>();
			PhoneCallData s1PhoneCallData = S1PhoneCallData;
			if (s1PhoneCallData.Stages == null)
			{
				Il2CppReferenceArray<Stage> val = (s1PhoneCallData.Stages = Il2CppReferenceArray<Stage>.op_Implicit(Array.Empty<Stage>()));
			}
			AddCallerID(npcCallerID);
		}

		protected CallerDefinition AddCallerID(string name, Sprite? profilePicture = null)
		{
			CallerID val = ScriptableObject.CreateInstance<CallerID>();
			val.Name = name;
			val.ProfilePicture = profilePicture;
			S1PhoneCallData.CallerID = val;
			Caller = new CallerDefinition(val)
			{
				Name = name,
				ProfilePicture = profilePicture
			};
			return Caller;
		}

		protected CallerDefinition AddCallerID(NPC? npc)
		{
			CallerID val = ScriptableObject.CreateInstance<CallerID>();
			val.Name = npc?.FullName ?? "Unknown Caller";
			val.ProfilePicture = npc?.Icon;
			S1PhoneCallData.CallerID = val;
			Caller = new CallerDefinition(val)
			{
				Name = (npc?.FullName ?? "Unknown Caller"),
				ProfilePicture = npc?.Icon
			};
			return Caller;
		}

		protected CallStageEntry AddStage(string text)
		{
			//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_000f: Expected O, but got Unknown
			Stage val = new Stage
			{
				Text = text
			};
			S1PhoneCallData.Stages = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<Stage>(S1PhoneCallData.Stages, (Stage[]?)(object)new Stage[1] { val });
			CallStageEntry callStageEntry = new CallStageEntry(val)
			{
				Text = text
			};
			StageEntries.Add(callStageEntry);
			return callStageEntry;
		}

		public void Completed()
		{
			S1PhoneCallData.Completed();
		}
	}
}
namespace S1API.PhoneCalls.Constants
{
	public enum EvaluationType
	{
		PassOnTrue,
		PassOnFalse
	}
	public enum SystemTriggerType
	{
		StartTrigger,
		DoneTrigger
	}
}
namespace S1API.PhoneApp
{
	public sealed class ExitAction
	{
		private readonly Func<bool> _getUsed;

		private readonly Action<bool> _setUsed;

		public bool Used
		{
			get
			{
				return _getUsed();
			}
			set
			{
				_setUsed(value);
			}
		}

		internal ExitAction(Func<bool> getUsed, Action<bool> setUsed)
		{
			_getUsed = getUsed ?? throw new ArgumentNullException("getUsed");
			_setUsed = setUsed ?? throw new ArgumentNullException("setUsed");
		}
	}
	public abstract class PhoneApp : Registerable
	{
		public enum EOrientation
		{
			Horizontal,
			Vertical
		}

		protected static readonly Log Logger = new Log("PhoneApp");

		private GameObject? _appPanel;

		private GameObject? _appContainer;

		private bool _isDestroying;

		private bool _iconModified;

		private Image? _iconImage;

		private Sprite? _pendingIconSprite;

		private HomeScreen? _homeScreenInstance;

		private Action? _closeAppAction;

		private ExitDelegate? _exitDelegate;

		private Action? _onPhoneClosedAction;

		internal bool IsDestroying => _isDestroying;

		protected abstract string AppName { get; }

		protected abstract string AppTitle { get; }

		protected abstract string IconLabel { get; }

		protected abstract string IconFileName { get; }

		protected virtual Sprite? IconSprite => null;

		protected virtual EOrientation Orientation => EOrientation.Horizontal;

		protected abstract void OnCreatedUI(GameObject container);

		protected override void OnCreated()
		{
			PhoneAppRegistry.Register(this);
		}

		protected override void OnDestroyed()
		{
			if (!_isDestroying)
			{
				_isDestroying = true;
				if ((Object)(object)_appPanel != (Object)null)
				{
					Object.Destroy((Object)(object)_appPanel);
					_appPanel = null;
				}
				_appContainer = null;
				_iconModified = false;
				_iconImage = null;
				_pendingIconSprite = null;
				if (PlayerSingleton<Phone>.InstanceExists && _closeAppAction != null)
				{
					Phone instance = PlayerSingleton<Phone>.Instance;
					instance.closeApps -= Action.op_Implicit(_closeAppAction);
					_closeAppAction = null;
				}
				if ((Delegate)(object)_exitDelegate != (Delegate)null)
				{
					GameInput.DeregisterExitListener(_exitDelegate);
					_exitDelegate = null;
				}
				if (PlayerSingleton<Phone>.InstanceExists && _onPhoneClosedAction != null)
				{
					Phone instance2 = PlayerSingleton<Phone>.Instance;
					instance2.onPhoneClosed -= Action.op_Implicit(_onPhoneClosedAction);
					_onPhoneClosedAction = null;
				}
			}
		}

		public virtual void Exit(ExitAction exit)
		{
			if (!exit.Used && IsOpen() && PlayerSingleton<Phone>.InstanceExists && PlayerSingleton<Phone>.Instance.IsOpen)
			{
				exit.Used = true;
				CloseApp();
			}
		}

		protected virtual void OnPhoneClosed()
		{
		}

		public bool IsOpen()
		{
			return (Object)(object)_appPanel != (Object)null && _appPanel.activeInHierarchy && (Object)(object)Phone.ActiveApp == (Object)(object)_appPanel;
		}

		internal void SpawnUI(HomeScreen homeScreenInstance)
		{
			_homeScreenInstance = homeScreenInstance;
			Transform obj = ((Component)homeScreenInstance).transform.parent.Find("AppsCanvas");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.Error("AppsCanvas not found.");
				return;
			}
			Transform val2 = val.transform.Find(AppName);
			if ((Object)(object)val2 != (Object)null)
			{
				_appPanel = ((Component)val2).gameObject;
				SetupExistingAppPanel(_appPanel);
			}
			else
			{
				_appPanel = CreateAppPanel(AppName, val.transform);
				_appContainer = CreateAppContainer(_appPanel.transform);
			}
			_appPanel.SetActive(true);
			PhoneAppButtonHandler phoneAppButtonHandler = _appPanel.GetComponent<PhoneAppButtonHandler>() ?? _appPanel.AddComponent<PhoneAppButtonHandler>();
			phoneAppButtonHandler.phoneApp = this;
			if (PlayerSingleton<Phone>.InstanceExists)
			{
				_closeAppAction = CloseApp;
				Phone instance = PlayerSingleton<Phone>.Instance;
				instance.closeApps += Action.op_Implicit(_closeAppAction);
				_exitDelegate = DelegateSupport.ConvertDelegate<ExitDelegate>((Delegate)new Action<ExitAction>(HandleNativeExit));
				GameInput.RegisterExitListener(_exitDelegate, 1);
				_onPhoneClosedAction = OnPhoneClosed;
				Phone instance2 = PlayerSingleton<Phone>.Instance;
				instance2.onPhoneClosed += Action.op_Implicit(_onPhoneClosedAction);
			}
		}

		private void HandleNativeExit(ExitAction exit)
		{
			Exit(new ExitAction(() => exit.Used, delegate(bool used)
			{
				exit.Used = used;
			}));
		}

		internal void SpawnIcon(HomeScreen homeScreenInstance)
		{
			if (_iconModified)
			{
				return;
			}
			Transform? obj = global::S1API.Internal.Utils.TransformUtils.FindDescendant(((Component)homeScreenInstance).transform, "AppIcons");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.Error("AppIcons not found under HomeScreen.");
				return;
			}
			GameObject val2 = CreateAppIcon(homeScreenInstance, val.transform);
			if ((Object)(object)val2 == (Object)null)
			{
				Logger.Error("Failed to create an icon for " + AppName + ".");
				return;
			}
			((Object)val2).name = AppName;
			Transform val3 = val2.transform.Find("Mask/Image");
			_iconImage = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<Image>() : null);
			Transform val4 = val2.transform.Find("Label");
			Text val5 = ((val4 != null) ? ((Component)val4).GetComponent<Text>() : null);
			if ((Object)(object)val5 != (Object)null)
			{
				val5.text = IconLabel;
			}
			if ((Object)(object)_iconImage != (Object)null)
			{
				Sprite val6 = (((Object)(object)_pendingIconSprite != (Object)null) ? _pendingIconSprite : IconSprite);
				if ((Object)(object)val6 != (Object)null)
				{
					_iconImage.sprite = val6;
					_iconModified = true;
					_pendingIconSprite = null;
				}
				else
				{
					_iconModified = ChangeAppIconImage(val2, IconFileName);
				}
			}
			else
			{
				_iconModified = ChangeAppIconImage(val2, IconFileName);
			}
			Button component = val2.GetComponent<Button>();
			if ((Object)(object)component != (Object)null)
			{
				((UnityEventBase)component.onClick).RemoveAllListeners();
				global::S1API.Utils.EventHelper.AddListener(OpenApp, (UnityEvent)(object)component.onClick);
			}
		}

		private static GameObject? CreateAppIcon(HomeScreen homeScreenInstance, Transform parent)
		{
			GameObject appIconPrefab = homeScreenInstance.appIconPrefab;
			if ((Object)(object)appIconPrefab == (Object)null)
			{
				Logger.Error("HomeScreen appIconPrefab was unavailable.");
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(appIconPrefab, parent);
			Button component = val.GetComponent<Button>();
			UISelectable component2 = val.GetComponent<UISelectable>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null)
			{
				Logger.Error("Native phone app icon prefab is missing Button or UISelectable.");
				Object.Destroy((Object)(object)val);
				return null;
			}
			List<Button> appIcons = homeScreenInstance.appIcons;
			UIPanel uiPanel = homeScreenInstance.uiPanel;
			if (appIcons == null || (Object)(object)uiPanel == (Object)null)
			{
				Logger.Error("HomeScreen icon registration fields were unavailable.");
				Object.Destroy((Object)(object)val);
				return null;
			}
			appIcons.Add(component);
			uiPanel.AddSelectable(component2);
			return val;
		}

		public void OpenApp()
		{
			try
			{
				if ((Object)(object)Phone.ActiveApp != (Object)null && (Object)(object)Phone.ActiveApp != (Object)(object)_appPanel)
				{
					PlayerSingleton<Phone>.Instance.RequestCloseApp();
				}
				SetAppOpen(open: true);
				Logger.Debug("Opened phone app: " + AppName);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to open phone app " + AppName + ": " + ex.Message);
			}
		}

		public void CloseApp()
		{
			try
			{
				if (IsOpen())
				{
					SetAppOpen(open: false);
				}
				Logger.Debug("Closed phone app: " + AppName);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to close phone app " + AppName + ": " + ex.Message);
			}
		}

		private void SetAppOpen(bool open)
		{
			if (open && (Object)(object)Phone.ActiveApp != (Object)null && (Object)(object)Phone.ActiveApp != (Object)(object)_appPanel)
			{
				Logger.Warning(((Object)Phone.ActiveApp).name + " is already open");
				return;
			}
			if (PlayerSingleton<AppsCanvas>.InstanceExists)
			{
				PlayerSingleton<AppsCanvas>.Instance.SetIsOpen(open);
			}
			if (PlayerSingleton<HomeScreen>.InstanceExists)
			{
				PlayerSingleton<HomeScreen>.Instance.SetIsOpen(!open);
			}
			if (open)
			{
				if (Orientation == EOrientation.Horizontal)
				{
					if (PlayerSingleton<Phone>.InstanceExists)
					{
						PlayerSingleton<Phone>.Instance.SetIsHorizontal(true);
						PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(0.6f);
					}
				}
				else if (PlayerSingleton<Phone>.InstanceExists)
				{
					PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(1f);
				}
				Phone.ActiveApp = _appPanel;
				GameObject? appContainer = _appContainer;
				if (appContainer != null)
				{
					appContainer.SetActive(true);
				}
			}
			else
			{
				if ((Object)(object)Phone.ActiveApp == (Object)(object)_appPanel)
				{
					Phone.ActiveApp = null;
				}
				if (PlayerSingleton<Phone>.InstanceExists)
				{
					PlayerSingleton<Phone>.Instance.SetIsHorizontal(false);
					PlayerSingleton<Phone>.Instance.SetLookOffsetMultiplier(1f);
				}
				GameObject? appContainer2 = _appContainer;
				if (appContainer2 != null)
				{
					appContainer2.SetActive(false);
				}
			}
		}

		private void SetupExistingAppPanel(GameObject panel)
		{
			panel.SetActive(false);
			for (int num = panel.transform.childCount - 1; num >= 0; num--)
			{
				Transform child = panel.transform.GetChild(num);
				((Component)child).gameObject.SetActive(false);
				child.SetParent((Transform)null, false);
				Object.Destroy((Object)(object)((Component)child).gameObject);
			}
			ConfigureAppPanel(panel.GetComponent<RectTransform>() ?? panel.AddComponent<RectTransform>());
			_appContainer = CreateAppContainer(panel.transform);
		}

		private GameObject CreateAppPanel(string name, Transform parent)
		{
			GameObject val = CreateFullStretchObject(name, parent);
			ConfigureAppPanel(val.GetComponent<RectTransform>());
			return val;
		}

		private void ConfigureAppPanel(RectTransform rectTransform)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			if (Orientation == EOrientation.Horizontal)
			{
				ConfigureFullStretch(rectTransform);
				return;
			}
			Transform parent = ((Transform)rectTransform).parent;
			RectTransform val = ((parent != null) ? ((Component)parent).GetComponent<RectTransform>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Logger.Warning("Cannot configure vertical layout for " + AppName + ": parent is not a RectTransform.");
				ConfigureFullStretch(rectTransform);
				return;
			}
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			rectTransform.anchorMin = val2;
			rectTransform.anchorMax = val2;
			rectTransform.pivot = val2;
			rectTransform.anchoredPosition = Vector2.zero;
			Rect rect = val.rect;
			float height = ((Rect)(ref rect)).height;
			rect = val.rect;
			rectTransform.sizeDelta = new Vector2(height, ((Rect)(ref rect)).width);
			((Transform)rectTransform).localRotation = Quaternion.Euler(0f, 0f, 90f);
			((Transform)rectTransform).localScale = Vector3.one;
		}

		private GameObject CreateAppContainer(Transform parent)
		{
			GameObject val = CreateFullStretchObject("Container", parent);
			OnCreatedUI(val);
			val.SetActive(false);
			return val;
		}

		private static GameObject CreateFullStretchObject(string name, Transform parent)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			RectTransform val2 = val.AddComponent<RectTransform>();
			((Transform)val2).SetParent(parent, false);
			ConfigureFullStretch(val2);
			val.layer = ((Component)parent).gameObject.layer;
			return val;
		}

		private static void ConfigureFullStretch(RectTransform rectTransform)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_003c: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((Transform)rectTransform).localRotation = Quaternion.identity;
			((Transform)rectTransform).localScale = Vector3.one;
		}

		private bool ChangeAppIconImage(GameObject iconObj, string filename)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Transform val = iconObj.transform.Find("Mask/Image");
			Image val2 = ((val != null) ? ((Component)val).GetComponent<Image>() : null);
			if ((Object)(object)val2 == (Object)null)
			{
				Logger.Error("Image component not found in icon.");
				return false;
			}
			string text = Path.Combine(MelonEnvironment.ModsDirectory, filename);
			if (!File.Exists(text))
			{
				Logger.Error("Icon file not found: " + text);
				return false;
			}
			try
			{
				byte[] array = File.ReadAllBytes(text);
				Texture2D val3 = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val3, Il2CppStructArray<byte>.op_Implicit(array)))
				{
					val2.sprite = Sprite.Create(val3, new Rect(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height), new Vector2(0.5f, 0.5f));
					return true;
				}
				Object.Destroy((Object)(object)val3);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to load image: " + ex.Message);
			}
			return false;
		}

		public bool SetIconSprite(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return false;
			}
			if ((Object)(object)_iconImage != (Object)null)
			{
				_iconImage.sprite = sprite;
				_iconModified = true;
				_pendingIconSprite = null;
				return true;
			}
			_pendingIconSprite = sprite;
			return true;
		}

		public bool SetIconTexture(Texture2D texture)
		{
			//IL_0029: 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)
			if ((Object)(object)texture == (Object)null)
			{
				return false;
			}
			Sprite iconSprite = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f));
			return SetIconSprite(iconSprite);
		}
	}
	[RegisterTypeInIl2Cpp]
	internal class PhoneAppButtonHandler : MonoBehaviour
	{
		internal PhoneApp? phoneApp;

		private void Update()
		{
			if (phoneApp != null && phoneApp.IsOpen() && PlayerSingleton<Phone>.InstanceExists && PlayerSingleton<Phone>.Instance.IsOpen && IsHoveringButton() && GameInput.GetButtonDown((ButtonCode)0))
			{
				phoneApp.CloseApp();
			}
		}

		private void OnDestroy()
		{
			if (phoneApp != null && !phoneApp.IsDestroying)
			{
				phoneApp.DestroyInternal();
			}
		}

		private bool IsHoveringButton()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(Singleton<GameplayMenu>.Instance.OverlayCamera.ScreenPointToRay(Input.mousePosition), ref val, 2f, 1 << LayerMask.NameToLayer("Overlay")) && ((Object)((Component)((RaycastHit)(ref val)).collider).gameObject).name == "Button")
			{
				return true;
			}
			return false;
		}
	}
}
namespace S1API.Money
{
	public class CashDefinition : ItemDefinition
	{
		internal CashDefinition S1CashDefinition => CrossType.As<CashDefinition>((object)base.S1ItemDefinition);

		internal CashDefinition(CashDefinition s1ItemDefinition)
			: base((ItemDefinition)(object)s1ItemDefinition)
		{
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return new CashInstance(((ItemDefinition)S1CashDefinition).GetDefaultInstance(quantity));
		}
	}
	public class CashInstance : ItemInstance
	{
		internal CashInstance S1CashInstance => CrossType.As<CashInstance>((object)S1ItemInstance);

		internal CashInstance(ItemInstance itemInstance)
			: base(itemInstance)
		{
		}

		public void AddQuantity(float amount)
		{
			S1CashInstance.SetBalance(Mathf.Clamp(S1CashInstance.Balance + amount, 0f, float.MaxValue), false);
		}

		public void SetQuantity(float newQuantity)
		{
			S1CashInstance.SetBalance(newQuantity, false);
		}
	}
	public static class Money
	{
		private static MoneyManager Internal => NetworkSingleton<MoneyManager>.Instance;

		public static event Action? OnBalanceChanged;

		public static void ChangeCashBalance(float amount, bool visualizeChange = true, bool playCashSound = false)
		{
			MoneyManager obj = Internal;
			if (obj != null)
			{
				obj.ChangeCashBalance(amount, visualizeChange, playCashSound);
			}
			Money.OnBalanceChanged?.Invoke();
		}

		public static void CreateOnlineTransaction(string transactionName, float unitAmount, float quantity, string transactionNote)
		{
			MoneyManager obj = Internal;
			if (obj != null)
			{
				obj.CreateOnlineTransaction(transactionName, unitAmount, quantity, transactionNote);
			}
			Money.OnBalanceChanged?.Invoke();
		}

		public static float GetNetWorth()
		{
			return ((Object)(object)Internal != (Object)null) ? Internal.GetNetWorth() : 0f;
		}

		public static float GetCashBalance()
		{
			return ((Object)(object)Internal != (Object)null) ? Internal.cashBalance : 0f;
		}

		public static float GetOnlineBalance()
		{
			return ((Object)(object)Internal != (Object)null) ? Internal.sync___get_value_onlineBalance() : 0f;
		}

		public static void AddNetworthCalculation(Action<object> callback)
		{
			if ((Object)(object)Internal != (Object)null)
			{
				MoneyManager obj = Internal;
				obj.onNetworthCalculation += Action<FloatContainer>.op_Implicit((Action<FloatContainer>)callback);
			}
		}

		public static void RemoveNetworthCalculation(Action<object> callback)
		{
			if ((Object)(object)Internal != (Object)null)
			{
				MoneyManager obj = Internal;
				obj.onNetworthCalculation -= Action<FloatContainer>.op_Implicit((Action<FloatContainer>)callback);
			}
		}

		public static CashInstance CreateCashInstance(float amount)
		{
			CashDefinition item = Registry.GetItem<CashDefinition>("cash");
			ItemInstance itemInstance = CrossType.As<ItemInstance>((object)((ItemDefinition)item).GetDefaultInstance(1));
			CashInstance cashInstance = new CashInstance(itemInstance);
			cashInstance.SetQuantity(amount);
			return cashInstance;
		}
	}
}
namespace S1API.Misc
{
	public sealed class ModularSwitch
	{
		private readonly ModularSwitch _switch;

		private string _onMessage = "Switch Off";

		private string _offMessage = "Switch On";

		private bool _hoverListenerAdded = false;

		internal ModularSwitch Switch => _switch;

		public bool IsOn
		{
			get
			{
				return _switch.isOn;
			}
			set
			{
				_switch.isOn = value;
			}
		}

		public event Action<bool>? OnToggled;

		public event Action? OnSwitchedOn;

		public event Action? OnSwitchedOff;

		public ModularSwitch(GameObject gameObject)
		{
			_switch = gameObject.GetComponent<ModularSwitch>();
			if ((Object)(object)_switch == (Object)null)
			{
				throw new ArgumentException("GameObject '" + ((Object)gameObject).name + "' does not contain a ModularSwitch component");
			}
			SubscribeToEvents();
		}

		private void SubscribeToEvents()
		{
			ModularSwitch obj = _switch;
			obj.onToggled += ButtonChange.op_Implicit((Action<bool>)HandleToggled);
			global::S1API.Utils.EventHelper.AddListener(HandleSwitchedOn, _switch.switchedOn);
			global::S1API.Utils.EventHelper.AddListener(HandleSwitchedOff, _switch.switchedOff);
		}

		private void HandleToggled(bool isOn)
		{
			this.OnToggled?.Invoke(isOn);
		}

		private void HandleSwitchedOn()
		{
			this.OnSwitchedOn?.Invoke();
		}

		private void HandleSwitchedOff()
		{
			this.OnSwitchedOff?.Invoke();
		}

		public void SetInteractionMessages(string messageWhenOn, string messageWhenOff)
		{
			_onMessage = messageWhenOn;
			_offMessage = messageWhenOff;
			if (_hoverListenerAdded)
			{
				return;
			}
			InteractableObject intObj = default(InteractableObject);
			ref InteractableObject reference = ref intObj;
			object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(_switch, "intObj");
			reference = (InteractableObject)((obj is InteractableObject) ? obj : null);
			if (!((Object)(object)intObj != (Object)null))
			{
				return;
			}
			Action listener = delegate
			{
				if (_switch.isOn)
				{
					intObj.SetMessage(_onMessage);
				}
				else
				{
					intObj.SetMessage(_offMessage);
				}
			};
			global::S1API.Utils.EventHelper.AddListener(listener, intObj.onHovered);
			_hoverListenerAdded = true;
		}

		public void SwitchOn()
		{
			_switch.SwitchOn();
		}

		public void SwitchOff()
		{
			_switch.SwitchOff();
		}
	}
}
namespace S1API.Messaging
{
	public class Response
	{
		internal readonly Response S1Response;

		public Action? OnTriggered
		{
			get
			{
				return ((Delegate)(object)S1Response.callback == (Delegate)null) ? null : ((Action)delegate
				{
					S1Response.callback.Invoke();
				});
			}
			set
			{
				S1Response.callback = Action.op_Implicit(value);
			}
		}

		public string Label
		{
			get
			{
				return S1Response.label;
			}
			set
			{
				S1Response.label = value;
			}
		}

		public string Text
		{
			get
			{
				return S1Response.text;
			}
			set
			{
				S1Response.text = value;
			}
		}

		public Response()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			S1Response = new Response();
		}

		internal Response(Response response)
		{
			S1Response = response;
		}
	}
}
namespace S1API.Map
{
	public sealed class Building
	{
		public static readonly List<Building> All = new List<Building>();

		private string _name;

		internal object? _gameBuilding;

		private bool _isDeferred;

		private Type? _deferredIdentifierType;

		public string Name => _name;

		internal Type? DeferredIdentifierType => _isDeferred ? _deferredIdentifierType : null;

		internal bool IsDeferred => _isDeferred;

		internal Building(string name, object gameBuilding)
		{
			_name = name;
			_gameBuilding = gameBuilding;
			_isDeferred = false;
		}

		internal Building(Type identifierType, string name)
		{
			_name = name;
			_gameBuilding = null;
			_isDeferred = true;
			_deferredIdentifierType = identifierType;
		}

		internal object? ResolveGameBuilding()
		{
			if (_gameBuilding != null)
			{
				return _gameBuilding;
			}
			if (_isDeferred)
			{
				if (_deferredIdentifierType != null)
				{
					Building building = TryResolveDeferred(_deferredIdentifierType);
					if (building != null)
					{
						_gameBuilding = building._gameBuilding;
						_name = building._name;
						_isDeferred = false;
						return _gameBuilding;
					}
				}
				else if (!string.IsNullOrEmpty(_name))
				{
					Building byName = GetByName(_name);
					if (byName != null && !byName._isDeferred)
					{
						_gameBuilding = byName._gameBuilding;
						_isDeferred = false;
						return _gameBuilding;
					}
				}
			}
			try
			{
				Il2CppArrayBase<NPCEnterableBuilding> val = Object.FindObjectsOfType<NPCEnterableBuilding>(true);
				for (int i = 0; i < val.Length; i++)
				{
					NPCEnterableBuilding val2 = val[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						Type type = ((object)val2).GetType();
						string text = type.GetField("BuildingName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(val2) as string;
						if (!string.IsNullOrEmpty(text) && string.Equals(text, _name, StringComparison.OrdinalIgnoreCase))
						{
							_gameBuilding = val2;
							break;
						}
					}
				}
			}
			catch
			{
			}
			return _gameBuilding;
		}

		private static Building? TryResolveDeferred(Type identifierType)
		{
			try
			{
				string text = TryGetNameFromIdentifier(identifierType);
				if (!string.IsNullOrEmpty(text))
				{
					return GetByName(text);
				}
				return GetByName(identifierType.Name);
			}
			catch
			{
				return null;
			}
		}

		internal static void Register(object gameBuilding)
		{
			if (gameBuilding == null)
			{
				return;
			}
			try
			{
				Type type = gameBuilding.GetType();
				FieldInfo field = type.GetField("BuildingName", BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo property = type.GetProperty("BuildingName", BindingFlags.Instance | BindingFlags.Public);
				string name = field?.GetValue(gameBuilding) as string;
				if (string.IsNullOrEmpty(name))
				{
					name = property?.GetValue(gameBuilding) as string;
				}
				if (!string.IsNullOrEmpty(name))
				{
					Building building = All.FirstOrDefault((Building b) => b != null && string.Equals(b._name, name, StringComparison.OrdinalIgnoreCase));
					if (building != null)
					{
						building._gameBuilding = gameBuilding;
						building._isDeferred = false;
						TryResolvePendingScheduleActions(name, gameBuilding);
					}
					else
					{
						Building item = new Building(name, gameBuilding);
						All.Add(item);
						TryResolvePendingScheduleActions(name, gameBuilding);
					}
				}
			}
			catch
			{
			}
		}

		internal static void Unregister(object gameBuilding)
		{
			if (gameBuilding == null)
			{
				return;
			}
			try
			{
				for (int num = All.Count - 1; num >= 0; num--)
				{
					if (All[num]?._gameBuilding == gameBuilding)
					{
						All.RemoveAt(num);
					}
				}
			}
			catch
			{
			}
		}

		public static Building[] GetAll()
		{
			return All.OrderBy((Building b) => b.Name).ToArray();
		}

		public static Building? GetByName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			Building building = GetAll().FirstOrDefault((Building b) => string.Equals(b.Name, name, StringComparison.OrdinalIgnoreCase));
			if (building != null)
			{
				return building;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				Building deferredWrapper = new Building(typeof(object), name);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(name, delegate(object resolved)
				{
					if (resolved is Building building2 && building2 != null && building2._gameBuilding != null)
					{
						deferredWrapper._gameBuilding = building2._gameBuilding;
						deferredWrapper._name = building2._name;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		public static Building? Get<T>() where T : IBuildingIdentifier
		{
			Type typeFromHandle = typeof(T);
			string text = TryGetNameFromIdentifier(typeFromHandle);
			if (!string.IsNullOrEmpty(text))
			{
				Building byName = GetByName(text);
				if (byName != null)
				{
					return byName;
				}
			}
			Building byName2 = GetByName(typeFromHandle.Name);
			if (byName2 != null)
			{
				return byName2;
			}
			if (ShouldDeferTypedLookup(DeferredMapResolver.IsMenuScene(), DeferredMapResolver.IsMainSceneReady))
			{
				string name = ((!string.IsNullOrEmpty(text)) ? text : typeFromHandle.Name);
				Building deferredWrapper = new Building(typeFromHandle, name);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(typeFromHandle, delegate(object resolved)
				{
					if (resolved is Building building && building != null && building._gameBuilding != null)
					{
						deferredWrapper._gameBuilding = building._gameBuilding;
						deferredWrapper._name = building._name;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		internal static bool ShouldDeferTypedLookup(bool isMenuScene, bool isMainSceneReady)
		{
			return isMenuScene || !isMainSceneReady;
		}

		private static string? TryGetNameFromIdentifier(Type t)
		{
			try
			{
				object obj = t.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().FullName == typeof(BuildingNameAttribute).FullName);
				if (obj != null)
				{
					return obj.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) as string;
				}
			}
			catch
			{
			}
			return null;
		}

		private static void TryResolvePendingScheduleActions(string buildingName, object gameBuilding)
		{
			try
			{
				StayInBuildingSpec.TryResolvePendingActions();
			}
			catch
			{
			}
		}
	}
	public sealed class DeliveryLocation
	{
		internal static readonly List<DeliveryLocation> All = new List<DeliveryLocation>();

		internal DeliveryLocation? S1Location;

		private bool _isDeferred;

		private Type? _deferredIdentifierType;

		public string Name
		{
			get
			{
				if (_isDeferred && (Object)(object)S1Location == (Object)null)
				{
					TryResolveDeferred();
				}
				return ((Object)(object)S1Location != (Object)null) ? S1Location.LocationName : string.Empty;
			}
		}

		public string Description => ((Object)(object)S1Location != (Object)null) ? S1Location.LocationDescription : string.Empty;

		public string GUID
		{
			get
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					return ((Object)(object)S1Location != (Object)null) ? ((object)S1Location.GUID/*cast due to .constrained prefix*/).ToString() : string.Empty;
				}
				catch
				{
					return string.Empty;
				}
			}
		}

		public Transform? CustomerStandPoint => ((Object)(object)S1Location != (Object)null) ? S1Location.CustomerStandPoint : null;

		public Transform? TeleportPoint => ((Object)(object)S1Location != (Object)null) ? S1Location.TeleportPoint : null;

		internal DeliveryLocation(DeliveryLocation s1)
		{
			S1Location = s1;
			_isDeferred = false;
		}

		internal DeliveryLocation(Type identifierType, string name)
		{
			S1Location = null;
			_isDeferred = true;
			_deferredIdentifierType = identifierType;
		}

		private void TryResolveDeferred()
		{
			if (!_isDeferred || (Object)(object)S1Location != (Object)null || !(_deferredIdentifierType != null))
			{
				return;
			}
			string text = TryGetNameFromIdentifier(_deferredIdentifierType);
			if (!string.IsNullOrEmpty(text))
			{
				DeliveryLocation byName = GetByName(text);
				if (byName != null && !byName._isDeferred && (Object)(object)byName.S1Location != (Object)null)
				{
					S1Location = byName.S1Location;
					_isDeferred = false;
					return;
				}
			}
			DeliveryLocation byName2 = GetByName(_deferredIdentifierType.Name);
			if (byName2 != null && !byName2._isDeferred && (Object)(object)byName2.S1Location != (Object)null)
			{
				S1Location = byName2.S1Location;
				_isDeferred = false;
			}
		}

		public static DeliveryLocation[] GetAll()
		{
			return All.OrderBy((DeliveryLocation l) => l.Name).ToArray();
		}

		public static DeliveryLocation? GetByName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			DeliveryLocation deliveryLocation = All.FirstOrDefault((DeliveryLocation l) => string.Equals(l?.Name, name, StringComparison.OrdinalIgnoreCase));
			if (deliveryLocation != null)
			{
				return deliveryLocation;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				DeliveryLocation deferredWrapper = new DeliveryLocation(typeof(object), name);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(name, delegate(object resolved)
				{
					if (resolved is DeliveryLocation deliveryLocation2 && deliveryLocation2 != null && (Object)(object)deliveryLocation2.S1Location != (Object)null)
					{
						deferredWrapper.S1Location = deliveryLocation2.S1Location;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		public static DeliveryLocation? GetByGuid(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			return All.FirstOrDefault((DeliveryLocation l) => string.Equals(l?.GUID, guid, StringComparison.OrdinalIgnoreCase));
		}

		internal static void Register(object gameDeliveryLocation)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			if (gameDeliveryLocation == null)
			{
				return;
			}
			try
			{
				Type type = gameDeliveryLocation.GetType();
				string guid = (type.GetProperty("GUID", BindingFlags.Instance | BindingFlags.Public)?.GetValue(gameDeliveryLocation))?.ToString() ?? string.Empty;
				if (!string.IsNullOrEmpty(guid) && !All.Any((DeliveryLocation l) => string.Equals(l?.GUID, guid, StringComparison.OrdinalIgnoreCase)))
				{
					All.Add(new DeliveryLocation((DeliveryLocation)gameDeliveryLocation));
				}
			}
			catch
			{
			}
		}

		internal static void Unregister(object gameDeliveryLocation)
		{
			if (gameDeliveryLocation == null)
			{
				return;
			}
			try
			{
				for (int num = All.Count - 1; num >= 0; num--)
				{
					if (All[num]?.S1Location == gameDeliveryLocation)
					{
						All.RemoveAt(num);
					}
				}
			}
			catch
			{
			}
		}

		internal static void Clear()
		{
			All.Clear();
		}

		public static DeliveryLocation? Get<T>() where T : IDeliveryLocationIdentifier
		{
			Type typeFromHandle = typeof(T);
			string text = TryGetNameFromIdentifier(typeFromHandle);
			if (!string.IsNullOrEmpty(text))
			{
				DeliveryLocation byName = GetByName(text);
				if (byName != null)
				{
					return byName;
				}
			}
			DeliveryLocation byName2 = GetByName(typeFromHandle.Name);
			if (byName2 != null)
			{
				return byName2;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				string name = ((!string.IsNullOrEmpty(text)) ? text : typeFromHandle.Name);
				DeliveryLocation deferredWrapper = new DeliveryLocation(typeFromHandle, name);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(typeFromHandle, delegate(object resolved)
				{
					if (resolved is DeliveryLocation deliveryLocation && deliveryLocation != null && (Object)(object)deliveryLocation.S1Location != (Object)null)
					{
						deferredWrapper.S1Location = deliveryLocation.S1Location;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		private static string? TryGetNameFromIdentifier(Type t)
		{
			try
			{
				object obj = t.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().FullName == typeof(DeliveryLocationNameAttribute).FullName);
				if (obj != null)
				{
					return obj.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) as string;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public interface IParkingLotIdentifier
	{
	}
	public sealed class MapPOI : IDisposable
	{
		private readonly MapPOIRuntime _runtime;

		private Vector3 _position;

		private Transform? _target;

		private bool _removed;

		public string Id { get; }

		public string Label { get; private set; }

		public Sprite? Icon { get; private set; }

		public MapPOITextVisibility TextVisibility { get; private set; }

		public bool RotateWithTarget { get; private set; }

		public bool IsVisible { get; private set; }

		public bool IsReady => !_removed && _runtime.IsReady;

		public bool IsUIReady => !_removed && _runtime.IsUIReady;

		public bool IsRemoved => _removed;

		public Transform? Target => ((Object)(object)_target != (Object)null) ? _target : null;

		public Vector3 Position => ((Object)(object)Target != (Object)null) ? Target.position : _position;

		public RectTransform? UI => _runtime.UI;

		internal bool IsRegistryValid => !_removed && _runtime.CanContinue;

		internal MapPOI(MapPOIBuilder builder)
		{
			//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)
			Id = builder.Id;
			Label = builder.Label;
			_position = builder.Position;
			_target = builder.Target;
			Icon = builder.Icon;
			TextVisibility = builder.TextVisibility;
			RotateWithTarget = builder.RotateWithTarget;
			IsVisible = builder.Visible;
			_runtime = new MapPOIRuntime(this);
		}

		public MapPOI SetLabel(string label)
		{
			ThrowIfRemoved();
			Label = label ?? throw new ArgumentNullException("label");
			_runtime.ApplyLabel();
			return this;
		}

		public MapPOI SetIcon(Sprite? icon)
		{
			ThrowIfRemoved();
			Icon = icon;
			_runtime.ApplyIcon();
			return this;
		}

		public MapPOI SetPosition(Vector3 position)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			ThrowIfRemoved();
			_target = null;
			_position = position;
			_runtime.ApplyLocation();
			return this;
		}

		public MapPOI SetTarget(Transform target)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			ThrowIfRemoved();
			if (!((Object)(object)target != (Object)null))
			{
				throw new ArgumentNullException("target");
			}
			_target = target;
			_position = target.position;
			_runtime.ApplyLocation();
			return this;
		}

		public MapPOI SetTextVisibility(MapPOITextVisibility visibility)
		{
			ThrowIfRemoved();
			if (!Enum.IsDefined(typeof(MapPOITextVisibility), visibility))
			{
				throw new ArgumentOutOfRangeException("visibility");
			}
			TextVisibility = visibility;
			_runtime.ApplyTextVisibility();
			return this;
		}

		public MapPOI SetRotation(bool rotateWithTarget)
		{
			ThrowIfRemoved();
			RotateWithTarget = rotateWithTarget;
			_runtime.ApplyRotation();
			return this;
		}

		public MapPOI SetVisible(bool visible)
		{
			ThrowIfRemoved();
			IsVisible = visible;
			_runtime.ApplyVisibility();
			return this;
		}

		public bool Focus(bool openMap = true)
		{
			ThrowIfRemoved();
			return _runtime.Focus(openMap);
		}

		public bool Remove()
		{
			if (_removed)
			{
				return false;
			}
			_removed = true;
			_runtime.Dispose(destroyRuntimeObject: true);
			MapPOIManager.Unregister(this);
			return true;
		}

		public void Dispose()
		{
			Remove();
		}

		internal void StartInitialization()
		{
			_runtime.Start();
		}

		internal void InvalidateForSceneChange()
		{
			if (!_removed)
			{
				_removed = true;
				_runtime.Dispose(destroyRuntimeObject: false);
			}
		}

		private void ThrowIfRemoved()
		{
			if (_removed)
			{
				throw new ObjectDisposedException("MapPOI", "Map POI '" + Id + "' has been removed.");
			}
		}
	}
	public sealed class MapPOIBuilder
	{
		internal string Id { get; }

		internal string Label { get; private set; }

		internal Vector3 Position { get; private set; }

		internal Transform? Target { get; private set; }

		internal Sprite? Icon { get; private set; }

		internal MapPOITextVisibility TextVisibility { get; private set; } = MapPOITextVisibility.Always;

		internal bool RotateWithTarget { get; private set; }

		internal bool Visible { get; private set; } = true;

		public MapPOIBuilder(string id)
		{
			Id = MapPOIManager.NormalizeId(id, "id");
			Label = Id;
		}

		public MapPOIBuilder WithLabel(string label)
		{
			Label = label ?? throw new ArgumentNullException("label");
			return this;
		}

		public MapPOIBuilder WithPosition(Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Position = position;
			Target = null;
			return this;
		}

		public MapPOIBuilder WithTarget(Transform target)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target != (Object)null))
			{
				throw new ArgumentNullException("target");
			}
			Target = target;
			Position = target.position;
			return this;
		}

		public MapPOIBuilder WithIcon(Sprite? icon)
		{
			Icon = icon;
			return this;
		}

		public MapPOIBuilder WithTextVisibility(MapPOITextVisibility visibility)
		{
			if (!Enum.IsDefined(typeof(MapPOITextVisibility), visibility))
			{
				throw new ArgumentOutOfRangeException("visibility");
			}
			TextVisibility = visibility;
			return this;
		}

		public MapPOIBuilder WithRotation(bool rotateWithTarget = true)
		{
			RotateWithTarget = rotateWithTarget;
			return this;
		}

		public MapPOIBuilder WithVisibility(bool visible)
		{
			Visible = visible;
			return this;
		}

		public MapPOI Build()
		{
			return MapPOIManager.Create(this);
		}
	}
	public static class MapPOIManager
	{
		private static readonly Dictionary<string, MapPOI> Markers = new Dictionary<string, MapPOI>(StringComparer.Ordinal);

		public static IReadOnlyCollection<MapPOI> All
		{
			get
			{
				PruneInvalidMarkers();
				return new List<MapPOI>(Markers.Values).AsReadOnly();
			}
		}

		public static MapPOI? Get(string id)
		{
			TryGet(id, out MapPOI marker);
			return marker;
		}

		public static bool TryGet(string id, out MapPOI? marker)
		{
			string key = NormalizeId(id, "id");
			if (!Markers.TryGetValue(key, out marker))
			{
				return false;
			}
			if (marker.IsRegistryValid)
			{
				return true;
			}
			Markers.Remove(key);
			marker = null;
			return false;
		}

		public static bool Remove(string id)
		{
			MapPOI marker;
			return TryGet(id, out marker) && marker.Remove();
		}

		public static void RemoveAll()
		{
			List<MapPOI> list = new List<MapPOI>(Markers.Values);
			foreach (MapPOI item in list)
			{
				item.Remove();
			}
			Markers.Clear();
		}

		internal static MapPOI Create(MapPOIBuilder builder)
		{
			PruneInvalidMarkers();
			if (Markers.ContainsKey(builder.Id))
			{
				throw new InvalidOperationException("A map POI with ID '" + builder.Id + "' is already registered.");
			}
			MapPOI mapPOI = new MapPOI(builder);
			Markers.Add(mapPOI.Id, mapPOI);
			mapPOI.StartInitialization();
			return mapPOI;
		}

		internal static void Unregister(MapPOI marker)
		{
			if (Markers.TryGetValue(marker.Id, out MapPOI value) && marker == value)
			{
				Markers.Remove(marker.Id);
			}
		}

		internal static void ResetForSceneChange()
		{
			List<MapPOI> list = new List<MapPOI>(Markers.Values);
			Markers.Clear();
			foreach (MapPOI item in list)
			{
				item.InvalidateForSceneChange();
			}
		}

		internal static string NormalizeId(string id, string parameterName)
		{
			if (id == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = id.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Map POI IDs cannot be empty or whitespace.", parameterName);
			}
			return text;
		}

		private static void PruneInvalidMarkers()
		{
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, MapPOI> marker in Markers)
			{
				if (!marker.Value.IsRegistryValid)
				{
					list.Add(marker.Key);
				}
			}
			foreach (string item in list)
			{
				Markers.Remove(item);
			}
		}
	}
	public enum MapPOITextVisibility
	{
		Off,
		Always,
		OnHover
	}
	public sealed class ParkingLotWrapper
	{
		internal string _guid;

		internal string _gameObjectName;

		internal ParkingLot? _lot;

		internal bool _isDeferred;

		private Type? _deferredIdentifierType;

		public string GUID => _guid;

		public string GameObjectName => _gameObjectName;

		public Vector3? EntryPointPosition
		{
			get
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				ParkingLot? lot = _lot;
				return ((Object)(object)((lot != null) ? lot.EntryPoint : null) != (Object)null) ? new Vector3?(_lot.EntryPoint.position) : ((Vector3?)null);
			}
		}

		public int ParkingSpotsCount => (!((Object)(object)_lot == (Object)null)) ? _lot.ParkingSpots.Count : 0;

		internal ParkingLotWrapper(ParkingLot lot)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			_lot = lot;
			_guid = ((object)lot.GUID/*cast due to .constrained prefix*/).ToString();
			_gameObjectName = ((Object)((Component)lot).gameObject).name;
			_isDeferred = false;
		}

		internal ParkingLotWrapper(Type identifierType, string name)
		{
			_guid = string.Empty;
			_gameObjectName = name;
			_lot = null;
			_isDeferred = true;
			_deferredIdentifierType = identifierType;
		}

		public ParkingSpotWrapper GetSpot(int index)
		{
			return new ParkingSpotWrapper(ResolveGameLot().ParkingSpots[index]);
		}

		internal ParkingLot? ResolveGameLot()
		{
			if (_isDeferred && (Object)(object)_lot == (Object)null)
			{
				if (_deferredIdentifierType != null)
				{
					ParkingLotWrapper parkingLotWrapper = TryResolveDeferred(_deferredIdentifierType);
					if (parkingLotWrapper != null)
					{
						_lot = parkingLotWrapper._lot;
						_isDeferred = false;
						return _lot;
					}
				}
				else if (!string.IsNullOrEmpty(_gameObjectName))
				{
					ParkingLotWrapper byName = ParkingLotRegistry.GetByName(_gameObjectName);
					if (byName != null && !byName._isDeferred)
					{
						_lot = byName._lot;
						_isDeferred = false;
						return _lot;
					}
				}
			}
			return _lot;
		}

		private static ParkingLotWrapper? TryResolveDeferred(Type identifierType)
		{
			try
			{
				string text = TryGetNameFromIdentifier(identifierType);
				if (!string.IsNullOrEmpty(text))
				{
					return ParkingLotRegistry.GetByName(text);
				}
				return ParkingLotRegistry.GetByName(identifierType.Name);
			}
			catch
			{
				return null;
			}
		}

		private static string? TryGetNameFromIdentifier(Type t)
		{
			try
			{
				object obj = t.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().FullName == typeof(ParkingLotNameAttribute).FullName);
				if (obj != null)
				{
					return obj.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) as string;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public sealed class ParkingSpotWrapper
	{
		internal readonly ParkingSpot _spot;

		public bool IsFree => (Object)(object)_spot != (Object)null && (Object)(object)_spot.OccupantVehicle == (Object)null;

		public ParkingAlignment Alignment => (ParkingAlignment)_spot.Alignment;

		public Transform AlignmentPoint => _spot.AlignmentPoint;

		internal LandVehicle? _OccupantVehicle => new LandVehicle(_spot.OccupantVehicle);

		public LandVehicle? OccupantVehicle => _OccupantVehicle;

		internal ParkingSpotWrapper(ParkingSpot spot)
		{
			_spot = spot;
		}

		public void SetOccupant(LandVehicle vehicle)
		{
			_spot.SetOccupant(vehicle.S1LandVehicle);
		}
	}
	public class ParkingData(string _lotId, int _index, ParkingAlignment _align)
	{
		public string LotId => _lotId;

		public int Index => _index;

		public ParkingAlignment Alignment => _align;

		internal ParkingData(ParkData data)
			: this(((object)data.lotGUID/*cast due to .constrained prefix*/).ToString(), data.spotIndex, (ParkingAlignment)data.alignment)
		{
		}//IL_0002: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected I4, but got Unknown

	}
	public static class ParkingLotRegistry
	{
		internal static readonly List<ParkingLotWrapper> All = new List<ParkingLotWrapper>();

		public static ParkingLotWrapper[] GetAll()
		{
			return All.OrderBy((ParkingLotWrapper l) => l.GameObjectName).ToArray();
		}

		public static ParkingLotWrapper? GetByGUID(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			return All.FirstOrDefault((ParkingLotWrapper l) => string.Equals(l?.GUID, guid, StringComparison.OrdinalIgnoreCase));
		}

		public static ParkingLotWrapper? GetByName(string gameObjectName)
		{
			if (string.IsNullOrEmpty(gameObjectName))
			{
				return null;
			}
			ParkingLotWrapper parkingLotWrapper = All.FirstOrDefault((ParkingLotWrapper l) => string.Equals(l?.GameObjectName, gameObjectName, StringComparison.OrdinalIgnoreCase));
			if (parkingLotWrapper != null)
			{
				return parkingLotWrapper;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				ParkingLotWrapper deferredWrapper = new ParkingLotWrapper(typeof(object), gameObjectName);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(gameObjectName, delegate(object resolved)
				{
					if (resolved is ParkingLotWrapper parkingLotWrapper2 && parkingLotWrapper2 != null && (Object)(object)parkingLotWrapper2._lot != (Object)null)
					{
						deferredWrapper._lot = parkingLotWrapper2._lot;
						deferredWrapper._guid = parkingLotWrapper2._guid;
						deferredWrapper._gameObjectName = parkingLotWrapper2._gameObjectName;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		public static ParkingSpotWrapper[] GetFreeSpots(string lotGuid)
		{
			ParkingLotWrapper byGUID = GetByGUID(lotGuid);
			if (byGUID == null)
			{
				return Array.Empty<ParkingSpotWrapper>();
			}
			try
			{
				ParkingLot val = byGUID.ResolveGameLot();
				if ((Object)(object)val == (Object)null)
				{
					return Array.Empty<ParkingSpotWrapper>();
				}
				List<ParkingSpot> freeParkingSpots = val.GetFreeParkingSpots();
				List<ParkingSpotWrapper> list = new List<ParkingSpotWrapper>();
				Enumerator<ParkingSpot> enumerator = freeParkingSpots.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ParkingSpot current = enumerator.Current;
					list.Add(new ParkingSpotWrapper(current));
				}
				return list.ToArray();
			}
			catch
			{
				return Array.Empty<ParkingSpotWrapper>();
			}
		}

		public static ParkingSpotWrapper[] GetFreeSpotsByName(string lotGameObjectName)
		{
			ParkingLotWrapper byName = GetByName(lotGameObjectName);
			if (byName == null)
			{
				return Array.Empty<ParkingSpotWrapper>();
			}
			try
			{
				ParkingLot val = byName.ResolveGameLot();
				if ((Object)(object)val == (Object)null)
				{
					return Array.Empty<ParkingSpotWrapper>();
				}
				List<ParkingSpot> freeParkingSpots = val.GetFreeParkingSpots();
				List<ParkingSpotWrapper> list = new List<ParkingSpotWrapper>();
				Enumerator<ParkingSpot> enumerator = freeParkingSpots.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ParkingSpot current = enumerator.Current;
					list.Add(new ParkingSpotWrapper(current));
				}
				return list.ToArray();
			}
			catch
			{
				return Array.Empty<ParkingSpotWrapper>();
			}
		}

		internal static void Register(object gameParkingLot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (gameParkingLot == null)
			{
				return;
			}
			try
			{
				ParkingLot val = (ParkingLot)gameParkingLot;
				string guid = ((object)val.GUID/*cast due to .constrained prefix*/).ToString();
				if (!All.Any((ParkingLotWrapper l) => string.Equals(l?.GUID, guid, StringComparison.OrdinalIgnoreCase)))
				{
					All.Add(new ParkingLotWrapper(val));
				}
			}
			catch
			{
			}
		}

		internal static void Unregister(object gameParkingLot)
		{
			if (gameParkingLot == null)
			{
				return;
			}
			try
			{
				for (int num = All.Count - 1; num >= 0; num--)
				{
					if (All[num]?._lot == gameParkingLot)
					{
						All.RemoveAt(num);
					}
				}
			}
			catch
			{
			}
		}

		public static ParkingLotWrapper? Get<T>() where T : IParkingLotIdentifier
		{
			Type typeFromHandle = typeof(T);
			string text = TryGetNameFromIdentifier(typeFromHandle);
			if (!string.IsNullOrEmpty(text))
			{
				ParkingLotWrapper byName = GetByName(text);
				if (byName != null)
				{
					return byName;
				}
			}
			ParkingLotWrapper byName2 = GetByName(typeFromHandle.Name);
			if (byName2 != null)
			{
				return byName2;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				string name = ((!string.IsNullOrEmpty(text)) ? text : typeFromHandle.Name);
				ParkingLotWrapper deferredWrapper = new ParkingLotWrapper(typeFromHandle, name);
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(typeFromHandle, delegate(object resolved)
				{
					if (resolved is ParkingLotWrapper parkingLotWrapper && parkingLotWrapper != null && (Object)(object)parkingLotWrapper._lot != (Object)null)
					{
						deferredWrapper._lot = parkingLotWrapper._lot;
						deferredWrapper._guid = parkingLotWrapper._guid;
						deferredWrapper._gameObjectName = parkingLotWrapper._gameObjectName;
						deferredWrapper._isDeferred = false;
					}
				}));
				return deferredWrapper;
			}
			return null;
		}

		internal static void Clear()
		{
			All.Clear();
		}

		private static string? TryGetNameFromIdentifier(Type t)
		{
			try
			{
				object obj = t.GetCustomAttributes(inherit: false).FirstOrDefault((object a) => a.GetType().FullName == typeof(ParkingLotNameAttribute).FullName);
				if (obj != null)
				{
					return obj.GetType().GetProperty("Name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) as string;
				}
			}
			catch
			{
			}
			return null;
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	public sealed class ParkingLotNameAttribute : Attribute
	{
		public string Name { get; }

		public ParkingLotNameAttribute(string name)
		{
			Name = name ?? throw new ArgumentNullException("name");
		}
	}
	public enum Region
	{
		Northtown,
		Westville,
		Downtown,
		Docks,
		Suburbia,
		Uptown
	}
}
namespace S1API.Map.ParkingLots
{
	[ParkingLotName("Billy parking")]
	public sealed class BillyParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("chemicalplantbase")]
	public sealed class ChemicalPlantBase : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Construction parking")]
	public sealed class ConstructionParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Corporate plaza parking lot")]
	public sealed class CorporatePlazaParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Dealership Parking Lot")]
	public sealed class DealershipParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Fast food parking lot")]
	public sealed class FastFoodParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Hanson house parking")]
	public sealed class HansonHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Holt house parking")]
	public sealed class HoltHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Kennedy House Parking")]
	public sealed class KennedyHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Knight house parking")]
	public sealed class KnightHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Manor parking")]
	public sealed class ManorParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Mansion parking")]
	public sealed class MansionParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Medical center parking lot")]
	public sealed class MedicalCenterParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Meeting point")]
	public sealed class MeetingPoint : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Mick's house parking")]
	public sealed class MicksHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("ParkingGarage")]
	public sealed class ParkingGarage : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Parking lot")]
	public sealed class ParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Parking lot")]
	public sealed class ParkingLot2 : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Pizzeria parking lot")]
	public sealed class PizzeriaParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Thompson house parking")]
	public sealed class ThompsonHouseParking : IParkingLotIdentifier
	{
	}
	[ParkingLotName("West parking lot")]
	public sealed class WestParkingLot : IParkingLotIdentifier
	{
	}
	[ParkingLotName("Wilkinson house parking")]
	public sealed class WilkinsonHouseParking : IParkingLotIdentifier
	{
	}
}
namespace S1API.Map.DeliveryLocations
{
	[DeliveryLocationName("Alleyway next to HAM legal services")]
	public sealed class AlleywayHAMLegal : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Alleyway behind Top Tattoo")]
	public sealed class AlleywayTopTattoo : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Basketball court")]
	public sealed class BasketballCourt : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the auto shop")]
	public sealed class BehindAutoShop : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Bank")]
	public sealed class BehindBank : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the casino")]
	public sealed class BehindCasino : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the construction site")]
	public sealed class BehindConstructionSite : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the Crimson Canary")]
	public sealed class BehindCrimsonCanary : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the dealership")]
	public sealed class BehindDealership : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind diner")]
	public sealed class BehindDiner : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind green house")]
	public sealed class BehindGreenHouse : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Handy Hank's")]
	public sealed class BehindHandyHanks : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Hyland Range")]
	public sealed class BehindHylandRange : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind pawn shop")]
	public sealed class BehindPawnShop : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the Post Office")]
	public sealed class BehindPostOffice : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Randy's bait & tackle")]
	public sealed class BehindRandysBaitTackle : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Ray's Realty")]
	public sealed class BehindRaysRealty : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Sauerkraut Supreme Pizzeria")]
	public sealed class BehindSauerkrautSupreme : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the shipping containers at the docks")]
	public sealed class BehindShippingContainersDocks : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the suburbs bus stop")]
	public sealed class BehindSuburbsBusStop : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Taco Ticklers")]
	public sealed class BehindTacoTicklers : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Thompson construction and demolition")]
	public sealed class BehindThompsonConstruction : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind Thrifty Threads")]
	public sealed class BehindThriftyThreads : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Behind the western Gas Mart")]
	public sealed class BehindWesternGasMart : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Brick warehouse at the docks")]
	public sealed class BrickWarehouseDocks : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Central canal")]
	public sealed class CentralCanal : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Construction site")]
	public sealed class ConstructionSite : IDeliveryLocationIdentifier
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class DeliveryLocationNameAttribute : Attribute
	{
		public string Name { get; }

		public DeliveryLocationNameAttribute(string name)
		{
			Name = name;
		}
	}
	[DeliveryLocationName("Destroyed RV")]
	public sealed class DestroyedRV : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Graveyard")]
	public sealed class Graveyard : IDeliveryLocationIdentifier
	{
	}
	public interface IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("In front of motel")]
	public sealed class InFrontOfMotel : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to barbershop")]
	public sealed class NextToBarbershop : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to Bud's Bar")]
	public sealed class NextToBudsBar : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to the courthouse")]
	public sealed class NextToCourthouse : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to Medical Center")]
	public sealed class NextToMedicalCenter : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to parking garage")]
	public sealed class NextToParkingGarage : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Next to the statue in the west park")]
	public sealed class NextToWestParkStatue : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("North waterfront")]
	public sealed class NorthWaterfront : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Outside brown apartment block room #2")]
	public sealed class OutsideBrownApartmentRoom2 : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Residential park")]
	public sealed class ResidentialPark : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Shipping containers near Sauerkraut Supreme")]
	public sealed class ShippingContainersSauerkrautSupreme : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Skatepark")]
	public sealed class Skatepark : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("South Overpass")]
	public sealed class SouthOverpass : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Under west bridge")]
	public sealed class UnderWestBridge : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Western wharf")]
	public sealed class WesternWharf : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("West Warehouse Wharf")]
	public sealed class WestWarehouseWharf : IDeliveryLocationIdentifier
	{
	}
	[DeliveryLocationName("Wharf near french restaurant")]
	public sealed class WharfFrenchRestaurant : IDeliveryLocationIdentifier
	{
	}
}
namespace S1API.Map.Buildings
{
	[BuildingName("Apartment Buiding")]
	public sealed class ApartmentBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("Arcade")]
	public sealed class Arcade : IBuildingIdentifier
	{
	}
	[BuildingName("Benji's Motel Room")]
	public sealed class BenjisMotelRoom : IBuildingIdentifier
	{
	}
	[BuildingName("Beth's Room")]
	public sealed class BethsRoom : IBuildingIdentifier
	{
	}
	[BuildingName("Boutique Store")]
	public sealed class BoutiqueStore : IBuildingIdentifier
	{
	}
	[BuildingName("Brad's Tent")]
	public sealed class BradsTent : IBuildingIdentifier
	{
	}
	[BuildingName("Bud's Bar")]
	public sealed class BudsBar : IBuildingIdentifier
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class BuildingNameAttribute : Attribute
	{
		public string Name { get; }

		public BuildingNameAttribute(string name)
		{
			Name = name;
		}
	}
	[BuildingName("Cafe")]
	public sealed class Cafe : IBuildingIdentifier
	{
	}
	[BuildingName("Caravan")]
	public sealed class Caravan : IBuildingIdentifier
	{
	}
	[BuildingName("Carl's House")]
	public sealed class CarlsHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Casino")]
	public sealed class Casino : IBuildingIdentifier
	{
	}
	[BuildingName("Charles' House")]
	public sealed class CharlesHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Chemical Plant A")]
	public sealed class ChemicalPlantA : IBuildingIdentifier
	{
	}
	[BuildingName("Chinese Restaurant")]
	public sealed class ChineseRestaurant : IBuildingIdentifier
	{
	}
	[BuildingName("Church")]
	public sealed class Church : IBuildingIdentifier
	{
	}
	[BuildingName("Community Center")]
	public sealed class CommunityCenter : IBuildingIdentifier
	{
	}
	[BuildingName("Corner Store")]
	public sealed class CornerStore : IBuildingIdentifier
	{
	}
	[BuildingName("Courthouse")]
	public sealed class Courthouse : IBuildingIdentifier
	{
	}
	[BuildingName("Dan's Hardware Upstairs")]
	public sealed class DansHardwareUpstairs : IBuildingIdentifier
	{
	}
	[BuildingName("Docks Industrial Building")]
	public sealed class DocksIndustrialBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("Docks Shipping Container")]
	public sealed class DocksShippingContainer : IBuildingIdentifier
	{
	}
	[BuildingName("Fire station")]
	public sealed class FireStation : IBuildingIdentifier
	{
	}
	[BuildingName("Fish Warehouse")]
	public sealed class FishWarehouse : IBuildingIdentifier
	{
	}
	[BuildingName("George and Molly's House")]
	public sealed class GeorgeAndMollysHouse : IBuildingIdentifier
	{
	}
	[BuildingName("NPC Hiding Building")]
	public sealed class GoblinHideBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("HAM Legal")]
	public sealed class HAMLegal : IBuildingIdentifier
	{
	}
	[BuildingName("Holt House")]
	public sealed class HoltHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Hyland Bank")]
	public sealed class HylandBank : IBuildingIdentifier
	{
	}
	[BuildingName("Hyland Medical")]
	public sealed class HylandMedical : IBuildingIdentifier
	{
	}
	public interface IBuildingIdentifier
	{
	}
	[BuildingName("Jane's Caravan")]
	public sealed class JanesCaravan : IBuildingIdentifier
	{
	}
	[BuildingName("Jerry's Tent")]
	public sealed class JerrysTent : IBuildingIdentifier
	{
	}
	[BuildingName("Jessi's Room")]
	public sealed class JessisRoom : IBuildingIdentifier
	{
	}
	[BuildingName("Kennedy House")]
	public sealed class KennedyHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Knight House")]
	public sealed class KnightHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Kyle and Austin's House")]
	public sealed class KyleAndAustinsHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Leos' Shipping Container")]
	public sealed class LeosShippingContainer : IBuildingIdentifier
	{
	}
	[BuildingName("Les Ordures Puantes")]
	public sealed class LesOrduresPuantes : IBuildingIdentifier
	{
	}
	[BuildingName("Mayor's House")]
	public sealed class MayorsHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Mick's House")]
	public sealed class MicksHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Modern Mansion")]
	public sealed class ModernMansion : IBuildingIdentifier
	{
	}
	[BuildingName("Motel Office")]
	public sealed class MotelOffice : IBuildingIdentifier
	{
	}
	[BuildingName("Nightclub")]
	public sealed class Nightclub : IBuildingIdentifier
	{
	}
	[BuildingName("North apartments")]
	public sealed class NorthApartments : IBuildingIdentifier
	{
	}
	[BuildingName("North Industrial Building")]
	public sealed class NorthIndustrialBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("North Warehouse")]
	public sealed class NorthWarehouse : IBuildingIdentifier
	{
	}
	[BuildingName("Overpass Building")]
	public sealed class OverpassBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("Pawn Shop")]
	public sealed class PawnShop : IBuildingIdentifier
	{
	}
	[BuildingName("Peter's Room")]
	public sealed class PetersRoom : IBuildingIdentifier
	{
	}
	[BuildingName("Pillville")]
	public sealed class Pillville : IBuildingIdentifier
	{
	}
	[BuildingName("Police Station")]
	public sealed class PoliceStation : IBuildingIdentifier
	{
	}
	[BuildingName("Randy's Bait & Tackle")]
	public sealed class RandysBaitTackle : IBuildingIdentifier
	{
	}
	[BuildingName("Room 1")]
	public sealed class Room1 : IBuildingIdentifier
	{
	}
	[BuildingName("Room 2")]
	public sealed class Room2 : IBuildingIdentifier
	{
	}
	[BuildingName("Room 3")]
	public sealed class Room3 : IBuildingIdentifier
	{
	}
	[BuildingName("Sauerkraut Supreme")]
	public sealed class SauerkrautSupreme : IBuildingIdentifier
	{
	}
	[BuildingName("Shack")]
	public sealed class Shack : IBuildingIdentifier
	{
	}
	[BuildingName("Sherman House")]
	public sealed class ShermanHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Shooting Range")]
	public sealed class ShootingRange : IBuildingIdentifier
	{
	}
	[BuildingName("Slop Shop")]
	public sealed class SlopShop : IBuildingIdentifier
	{
	}
	[BuildingName("South Overpass Building")]
	public sealed class SouthOverpassBuilding : IBuildingIdentifier
	{
	}
	[BuildingName("Stevenson House")]
	public sealed class StevensonHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Storage Unit #2")]
	public sealed class StorageUnit2 : IBuildingIdentifier
	{
	}
	[BuildingName("Storage Unit #3")]
	public sealed class StorageUnit3 : IBuildingIdentifier
	{
	}
	[BuildingName("Supermarket")]
	public sealed class Supermarket : IBuildingIdentifier
	{
	}
	[BuildingName("Tall Tower")]
	public sealed class TallTower : IBuildingIdentifier
	{
	}
	[BuildingName("The Crimson Canary")]
	public sealed class TheCrimsonCanary : IBuildingIdentifier
	{
	}
	[BuildingName("The Piss Hut")]
	public sealed class ThePissHut : IBuildingIdentifier
	{
	}
	[BuildingName("Thompson Construction & Demo")]
	public sealed class ThompsonConstructionDemo : IBuildingIdentifier
	{
	}
	[BuildingName("Thompson House")]
	public sealed class ThompsonHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Town hall")]
	public sealed class TownHall : IBuildingIdentifier
	{
	}
	[BuildingName("Upscale Apartments")]
	public sealed class UpscaleApartments : IBuildingIdentifier
	{
	}
	[BuildingName("Webster House")]
	public sealed class WebsterHouse : IBuildingIdentifier
	{
	}
	[BuildingName("Wei's Cabin")]
	public sealed class WeisCabin : IBuildingIdentifier
	{
	}
	[BuildingName("West Gas-Mart")]
	public sealed class WestGasMart : IBuildingIdentifier
	{
	}
	[BuildingName("Wilkinson House")]
	public sealed class WilkinsonHouse : IBuildingIdentifier
	{
	}
}
namespace S1API.Logging
{
	public class Log
	{
		private readonly Instance _loggerInstance;

		public Log(string sourceName)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			_loggerInstance = new Instance(sourceName);
		}

		public void Msg(string message)
		{
			_loggerInstance.Msg(message);
		}

		internal void Debug(string message)
		{
			MelonPreferences_Entry<bool>? enableVerboseLogging = S1APIPreferences.EnableVerboseLogging;
			if (enableVerboseLogging != null && enableVerboseLogging.Value)
			{
				_loggerInstance.Msg(message);
			}
		}

		public void Warning(string message)
		{
			_loggerInstance.Warning(message);
		}

		public void Error(string message)
		{
			_loggerInstance.Error(message);
		}

		public void BigError(string message)
		{
			_loggerInstance.BigError(message);
		}
	}
}
namespace S1API.Lifecycle
{
	public static class GameLifecycle
	{
		private static bool _initialized;

		public static event Action? OnPreLoad;

		public static event Action? OnLoadComplete;

		public static event Action? OnPreSceneChange;

		public static event Action? OnSaveInfoLoaded;

		public static event Action? OnSaveStart;

		public static event Action? OnSaveComplete;

		internal static void Initialize()
		{
			if (!_initialized)
			{
				LoadManager instance = Singleton<LoadManager>.Instance;
				SaveManager instance2 = Singleton<SaveManager>.Instance;
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance2 == (Object)null))
				{
					instance.onPreLoad.AddListener(UnityAction.op_Implicit((Action)InvokeOnPreLoad));
					instance.onLoadComplete.AddListener(UnityAction.op_Implicit((Action)InvokeOnLoadComplete));
					instance.onPreSceneChange.AddListener(UnityAction.op_Implicit((Action)InvokeOnPreSceneChange));
					instance.onSaveInfoLoaded.AddListener(UnityAction.op_Implicit((Action)InvokeOnSaveInfoLoaded));
					instance2.onSaveStart.AddListener(UnityAction.op_Implicit((Action)InvokeOnSaveStart));
					instance2.onSaveComplete.AddListener(UnityAction.op_Implicit((Action)InvokeOnSaveComplete));
					_initialized = true;
				}
			}
		}

		internal static void Reset()
		{
			_initialized = false;
		}

		private static void InvokeOnPreLoad()
		{
			try
			{
				GameLifecycle.OnPreLoad?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnPreLoad: {value}");
			}
		}

		private static void InvokeOnLoadComplete()
		{
			try
			{
				DeferredMapResolver.ResolveAll();
				GameLifecycle.OnLoadComplete?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnLoadComplete: {value}");
			}
		}

		private static void InvokeOnPreSceneChange()
		{
			try
			{
				GameLifecycle.OnPreSceneChange?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnPreSceneChange: {value}");
			}
		}

		private static void InvokeOnSaveInfoLoaded()
		{
			try
			{
				GameLifecycle.OnSaveInfoLoaded?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnSaveInfoLoaded: {value}");
			}
		}

		private static void InvokeOnSaveStart()
		{
			try
			{
				GameLifecycle.OnSaveStart?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnSaveStart: {value}");
			}
		}

		private static void InvokeOnSaveComplete()
		{
			try
			{
				GameLifecycle.OnSaveComplete?.Invoke();
			}
			catch (Exception value)
			{
				MelonLogger.Error($"Error in GameLifecycle.OnSaveComplete: {value}");
			}
		}
	}
}
namespace S1API.Leveling
{
	public readonly struct FullRank : IEquatable<FullRank>, IComparable<FullRank>
	{
		public Rank Rank { get; }

		public int Tier { get; }

		public FullRank(Rank rank, int tier)
		{
			Rank = rank;
			Tier = Math.Max(1, tier);
		}

		public FullRank NextRank()
		{
			return (Rank == Rank.Kingpin) ? new FullRank(Rank.Kingpin, Tier + 1) : ((Tier < 5) ? new FullRank(Rank, Tier + 1) : new FullRank(Rank + 1, 1));
		}

		public float ToFloat()
		{
			return (float)Rank + (float)Tier / 5f;
		}

		public int GetRankIndex()
		{
			return (int)Rank * 5 + (Tier - 1);
		}

		public override string ToString()
		{
			Rank rank = Rank;
			if (1 == 0)
			{
			}
			string text = rank switch
			{
				Rank.StreetRat => "Street Rat", 
				Rank.ShotCaller => "Shot Caller", 
				Rank.BlockBoss => "Block Boss", 
				_ => Rank.ToString(), 
			};
			if (1 == 0)
			{
			}
			string text2 = text;
			int tier = Tier;
			if (1 == 0)
			{
			}
			text = tier switch
			{
				1 => "I", 
				2 => "II", 
				3 => "III", 
				4 => "IV", 
				5 => "V", 
				_ => Tier.ToString(), 
			};
			if (1 == 0)
			{
			}
			string text3 = text;
			return text2 + " " + text3;
		}

		public bool Equals(FullRank other)
		{
			return Rank == other.Rank && Tier == other.Tier;
		}

		public override bool Equals(object? obj)
		{
			return obj is FullRank other && Equals(other);
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Rank, Tier);
		}

		public int CompareTo(FullRank other)
		{
			int num = Rank.CompareTo(other.Rank);
			if (num != 0)
			{
				return num;
			}
			return Tier.CompareTo(other.Tier);
		}

		public static bool operator >(FullRank a, FullRank b)
		{
			return a.CompareTo(b) > 0;
		}

		public static bool operator <(FullRank a, FullRank b)
		{
			return a.CompareTo(b) < 0;
		}

		public static bool operator >=(FullRank a, FullRank b)
		{
			return a.CompareTo(b) >= 0;
		}

		public static bool operator <=(FullRank a, FullRank b)
		{
			return a.CompareTo(b) <= 0;
		}

		public static bool operator ==(FullRank a, FullRank b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(FullRank a, FullRank b)
		{
			return !a.Equals(b);
		}

		internal static FullRank FromNative(FullRank rank)
		{
			//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_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected I4, but got Unknown
			return new FullRank((Rank)rank.Rank, rank.Tier);
		}

		internal FullRank ToNative()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new FullRank((ERank)Rank, Tier);
		}
	}
	public static class LevelManager
	{
		private static LevelManager? _hookedManager;

		private static Action<FullRank, FullRank>? _rankChangedIl2Cpp;

		private static Action<FullRank, FullRank>? _rankUpIl2Cpp;

		public static bool Exists => (Object)(object)Internal != (Object)null;

		public static Rank Rank => ((Object)(object)Internal != (Object)null) ? ((Rank)Internal.Rank) : Rank.StreetRat;

		public static int Tier
		{
			get
			{
				LevelManager? obj = Internal;
				return (obj == null) ? 1 : obj.Tier;
			}
		}

		public static int XP
		{
			get
			{
				LevelManager? obj = Internal;
				return (obj != null) ? obj.XP : 0;
			}
		}

		public static int TotalXP
		{
			get
			{
				LevelManager? obj = Internal;
				return (obj != null) ? obj.TotalXP : 0;
			}
		}

		public static float XPToNextTier
		{
			get
			{
				LevelManager? obj = Internal;
				return (obj != null) ? obj.XPToNextTier : 0f;
			}
		}

		public static FullRank CurrentRank => ((Object)(object)Internal != (Object)null) ? FullRank.FromNative(Internal.GetFullRank()) : new FullRank(Rank.StreetRat, 1);

		private static LevelManager? Internal
		{
			get
			{
				LevelManager instance = NetworkSingleton<LevelManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					TryHookEvents(instance);
				}
				return instance;
			}
		}

		public static event Action<FullRank, FullRank>? OnXPChanged;

		public static event Action<FullRank, FullRank>? OnRankUp;

		public static void AddXP(int amount)
		{
			LevelManager? obj = Internal;
			if (obj != null)
			{
				obj.AddXP(amount);
			}
		}

		public static int GetXPForTier(Rank rank)
		{
			return ((Object)(object)Internal != (Object)null) ? Internal.GetXPForTier((ERank)rank) : 0;
		}

		public static FullRank GetFullRankForXP(int totalXp)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(object)Internal != (Object)null) ? FullRank.FromNative(Internal.GetFullRank(totalXp)) : new FullRank(Rank.StreetRat, 1);
		}

		public static int GetTotalXPForRank(FullRank rank)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(object)Internal != (Object)null) ? Internal.GetTotalXPForRank(rank.ToNative()) : 0;
		}

		public static float GetOrderLimitMultiplier(FullRank rank)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return LevelManager.GetOrderLimitMultiplier(rank.ToNative());
		}

		public static void AddUnlockable(Unlockable unlockable)
		{
			if (unlockable == null)
			{
				throw new ArgumentNullException("unlockable");
			}
			LevelManager? obj = Internal;
			if (obj != null)
			{
				obj.AddUnlockable(unlockable.Native);
			}
		}

		public static IEnumerable<Unlockable> GetUnlockables(FullRank rank)
		{
			LevelManager manager = Internal;
			List<Unlockable> unlockables = default(List<Unlockable>);
			if (!((Object)(object)manager == (Object)null) && manager.Unlockables.TryGetValue(rank.ToNative(), ref unlockables) && unlockables != null)
			{
				for (int i = 0; i < unlockables.Count; i++)
				{
					yield return new Unlockable(unlockables[i]);
				}
			}
		}

		private static void TryHookEvents(LevelManager manager)
		{
			if (_hookedManager != manager)
			{
				if (_rankChangedIl2Cpp == null)
				{
					_rankChangedIl2Cpp = DelegateSupport.ConvertDelegate<Action<FullRank, FullRank>>((Delegate)new Action<FullRank, FullRank>(HandleRankChanged));
				}
				if (_rankUpIl2Cpp == null)
				{
					_rankUpIl2Cpp = DelegateSupport.ConvertDelegate<Action<FullRank, FullRank>>((Delegate)new Action<FullRank, FullRank>(HandleRankUp));
				}
				manager.onRankChanged = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)manager.onRankChanged, (Delegate)(object)_rankChangedIl2Cpp)).Cast<Action<FullRank, FullRank>>();
				manager.onRankUp = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)manager.onRankUp, (Delegate)(object)_rankUpIl2Cpp)).Cast<Action<FullRank, FullRank>>();
				_hookedManager = manager;
			}
		}

		private static void HandleRankChanged(FullRank before, FullRank after)
		{
			//IL_000c: 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)
			LevelManager.OnXPChanged?.Invoke(FullRank.FromNative(before), FullRank.FromNative(after));
		}

		private static void HandleRankUp(FullRank before, FullRank after)
		{
			//IL_000c: 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)
			LevelManager.OnRankUp?.Invoke(FullRank.FromNative(before), FullRank.FromNative(after));
		}
	}
	public enum Rank
	{
		StreetRat,
		Hoodlum,
		Peddler,
		Hustler,
		Bagman,
		Enforcer,
		ShotCaller,
		BlockBoss,
		Underlord,
		Baron,
		Kingpin
	}
	public sealed class Unlockable
	{
		internal Unlockable Native { get; }

		public FullRank Rank
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return FullRank.FromNative(Native.Rank);
			}
			set
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				Native.Rank = value.ToNative();
			}
		}

		public string Title
		{
			get
			{
				return Native.Title;
			}
			set
			{
				Native.Title = value;
			}
		}

		public Sprite Icon
		{
			get
			{
				return Native.Icon;
			}
			set
			{
				Native.Icon = value;
			}
		}

		public Unlockable(FullRank rank, string title, Sprite icon)
		{
			//IL_000b: 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_001c: Expected O, but got Unknown
			Native = new Unlockable(rank.ToNative(), title, icon);
		}

		internal Unlockable(Unlockable unlockable)
		{
			Native = unlockable;
		}
	}
}
namespace S1API.Law
{
	public sealed class CheckpointInfo
	{
		public CheckpointLocation Location { get; internal set; }

		public bool IsEnabled { get; internal set; }

		public Vector3 Position { get; internal set; }

		public int AssignedOfficerCount { get; internal set; }

		public bool IsGate1Open { get; internal set; }

		public bool IsGate2Open { get; internal set; }

		public bool AreBothGatesClosed => !IsGate1Open && !IsGate2Open;

		public bool IsAnyGateOpen => IsGate1Open || IsGate2Open;

		public bool IsOperational => IsEnabled && AssignedOfficerCount > 0;
	}
	public static class CheckpointManager
	{
		private static CheckpointManager Internal => NetworkSingleton<CheckpointManager>.Instance;

		public static void SetCheckpointEnabled(CheckpointLocation location, bool enabled, int requestedOfficers = 2)
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.SetCheckpointEnabled((ECheckpointLocation)location, enabled, requestedOfficers);
			}
		}

		public static bool IsCheckpointEnabled(CheckpointLocation location)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			if ((Object)(object)Internal == (Object)null)
			{
				return false;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return false;
			}
			return (int)checkpoint.ActivationState == 1;
		}

		public static void EnableAllCheckpoints(int officersPerCheckpoint = 2)
		{
			SetCheckpointEnabled(CheckpointLocation.Western, enabled: true, officersPerCheckpoint);
			SetCheckpointEnabled(CheckpointLocation.Docks, enabled: true, officersPerCheckpoint);
			SetCheckpointEnabled(CheckpointLocation.NorthResidential, enabled: true, officersPerCheckpoint);
			SetCheckpointEnabled(CheckpointLocation.WestResidential, enabled: true, officersPerCheckpoint);
		}

		public static void DisableAllCheckpoints()
		{
			SetCheckpointEnabled(CheckpointLocation.Western, enabled: false, 0);
			SetCheckpointEnabled(CheckpointLocation.Docks, enabled: false, 0);
			SetCheckpointEnabled(CheckpointLocation.NorthResidential, enabled: false, 0);
			SetCheckpointEnabled(CheckpointLocation.WestResidential, enabled: false, 0);
		}

		public static Vector3 GetCheckpointPosition(CheckpointLocation location)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Internal == (Object)null)
			{
				return Vector3.zero;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return Vector3.zero;
			}
			return ((Component)checkpoint).transform.position;
		}

		public static int GetAssignedOfficerCount(CheckpointLocation location)
		{
			if ((Object)(object)Internal == (Object)null)
			{
				return 0;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return 0;
			}
			return checkpoint.AssignedNPCs.Count;
		}

		public static List<NPC> GetAssignedOfficers(CheckpointLocation location)
		{
			List<NPC> list = new List<NPC>();
			if ((Object)(object)Internal == (Object)null)
			{
				return list;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return list;
			}
			for (int i = 0; i < checkpoint.AssignedNPCs.Count; i++)
			{
				list.Add(checkpoint.AssignedNPCs[i]);
			}
			return list;
		}

		public static bool IsGate1Open(CheckpointLocation location)
		{
			if ((Object)(object)Internal == (Object)null)
			{
				return false;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return false;
			}
			return checkpoint.Gate1Open;
		}

		public static bool IsGate2Open(CheckpointLocation location)
		{
			if ((Object)(object)Internal == (Object)null)
			{
				return false;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return false;
			}
			return checkpoint.Gate2Open;
		}

		public static CheckpointInfo? GetCheckpointInfo(CheckpointLocation location)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Internal == (Object)null)
			{
				return null;
			}
			RoadCheckpoint checkpoint = Internal.GetCheckpoint((ECheckpointLocation)location);
			if ((Object)(object)checkpoint == (Object)null)
			{
				return null;
			}
			return new CheckpointInfo
			{
				Location = location,
				IsEnabled = ((int)checkpoint.ActivationState == 1),
				Position = ((Component)checkpoint).transform.position,
				AssignedOfficerCount = checkpoint.AssignedNPCs.Count,
				IsGate1Open = checkpoint.Gate1Open,
				IsGate2Open = checkpoint.Gate2Open
			};
		}

		public static List<CheckpointInfo> GetAllCheckpointInfo()
		{
			List<CheckpointInfo> list = new List<CheckpointInfo>();
			foreach (CheckpointLocation value in Enum.GetValues(typeof(CheckpointLocation)))
			{
				CheckpointInfo checkpointInfo = GetCheckpointInfo(value);
				if (checkpointInfo != null)
				{
					list.Add(checkpointInfo);
				}
			}
			return list;
		}
	}
	public enum CheckpointLocation
	{
		Western,
		Docks,
		NorthResidential,
		WestResidential
	}
	public static class CurfewManager
	{
		public const int HourBeforeCurfew = 2000;

		public const int WarningTime = 2030;

		public const int CurfewStartTime = 2100;

		public const int HardCurfewStartTime = 2115;

		public const int CurfewEndTime = 500;

		private static CurfewManager Internal => NetworkSingleton<CurfewManager>.Instance;

		public static bool IsEnabled => (Object)(object)Internal != (Object)null && Internal.IsEnabled;

		public static bool IsCurrentlyActive => (Object)(object)Internal != (Object)null && Internal.IsCurrentlyActive;

		public static bool IsHardCurfewActive => (Object)(object)Internal != (Object)null && Internal.IsHardCurfewActive;

		public static void EnableCurfew()
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.Enable((NetworkConnection)null);
			}
		}

		public static void DisableCurfew()
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.Disable();
			}
		}

		public static bool IsWithinCurfewHours()
		{
			if (!NetworkSingleton<TimeManager>.InstanceExists)
			{
				return false;
			}
			return NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(2100, 500);
		}

		public static bool IsWithinHardCurfewHours()
		{
			if (!NetworkSingleton<TimeManager>.InstanceExists)
			{
				return false;
			}
			return NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(2115, 500);
		}

		public static int MinutesUntilCurfew()
		{
			if (!NetworkSingleton<TimeManager>.InstanceExists)
			{
				return 0;
			}
			int currentTime = NetworkSingleton<TimeManager>.Instance.CurrentTime;
			if (NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(2100, 500))
			{
				return 0;
			}
			return TimeManager.GetMinSumFrom24HourTime(2100) - TimeManager.GetMinSumFrom24HourTime(currentTime);
		}

		public static int MinutesUntilCurfewEnds()
		{
			if (!NetworkSingleton<TimeManager>.InstanceExists)
			{
				return 0;
			}
			int currentTime = NetworkSingleton<TimeManager>.Instance.CurrentTime;
			if (!NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(2100, 500))
			{
				return 0;
			}
			return TimeManager.GetMinSumFrom24HourTime(500) - TimeManager.GetMinSumFrom24HourTime(currentTime);
		}
	}
	public sealed class FootPatrolRoute
	{
		internal readonly FootPatrolRoute S1Route;

		public string RouteName
		{
			get
			{
				FootPatrolRoute s1Route = S1Route;
				return ((s1Route != null) ? s1Route.RouteName : null) ?? string.Empty;
			}
		}

		public int WaypointCount
		{
			get
			{
				FootPatrolRoute s1Route = S1Route;
				return ((s1Route == null) ? ((int?)null) : ((Il2CppArrayBase<Transform>)(object)s1Route.Waypoints)?.Length).GetValueOrDefault();
			}
		}

		public int StartWaypointIndex
		{
			get
			{
				FootPatrolRoute s1Route = S1Route;
				return (s1Route != null) ? s1Route.StartWaypointIndex : 0;
			}
		}

		public Vector3 Position
		{
			get
			{
				//IL_0016: 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)
				FootPatrolRoute s1Route = S1Route;
				return (s1Route != null) ? ((Component)s1Route).transform.position : Vector3.zero;
			}
		}

		internal FootPatrolRoute(FootPatrolRoute s1Route)
		{
			S1Route = s1Route;
		}

		public Vector3 GetWaypointPosition(int index)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			FootPatrolRoute s1Route = S1Route;
			if (((s1Route != null) ? s1Route.Waypoints : null) == null || index < 0 || index >= ((Il2CppArrayBase<Transform>)(object)S1Route.Waypoints).Length)
			{
				return Vector3.zero;
			}
			return ((Il2CppArrayBase<Transform>)(object)S1Route.Waypoints)[index].position;
		}
	}
	public static class LawController
	{
		public const int MinIntensity = 1;

		public const int MaxIntensity = 10;

		public const float DailyIntensityDrain = 0.05f;

		private static LawController Internal => Singleton<LawController>.Instance;

		public static int Intensity
		{
			get
			{
				if ((Object)(object)Internal == (Object)null)
				{
					return 1;
				}
				return Internal.LE_Intensity;
			}
		}

		public static float InternalIntensity
		{
			get
			{
				if ((Object)(object)Internal == (Object)null)
				{
					return 0f;
				}
				return 0f;
			}
		}

		public static bool IsUsingOverrideSettings
		{
			get
			{
				if ((Object)(object)Internal == (Object)null)
				{
					return false;
				}
				return Internal.OverrideSettings;
			}
		}

		public static void ChangeIntensity(float change)
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.ChangeInternalIntensity(change);
			}
		}

		public static void SetInternalIntensity(float intensity)
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.SetInternalIntensity(intensity);
			}
		}

		public static void SetIntensityLevel(int level)
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				float internalIntensity = Mathf.InverseLerp(1f, 10f, (float)level);
				Internal.SetInternalIntensity(internalIntensity);
			}
		}

		public static void OverrideActivitySettings(LawActivitySettings settings)
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				if (settings != null)
				{
					Internal.OverrideSetings(settings);
				}
				else
				{
					Internal.EndOverride();
				}
			}
		}

		public static void ClearActivitySettingsOverride()
		{
			if (!((Object)(object)Internal == (Object)null))
			{
				Internal.EndOverride();
			}
		}
	}
	public static class LawManager
	{
		private static LawManager Internal => Singleton<LawManager>.Instance;

		public static int DispatchOfficerCount => 2;

		public static float DispatchVehicleUseThreshold => 25f;

		public static float SearchTimeInvestigating => 60f;

		public static float SearchTimeArresting => 25f;

		public static float SearchTimeNonLethal => 30f;

		public static float SearchTimeLethal => 40f;

		public static float EscalationTimeArresting => 25f;

		public static float EscalationTimeNonLethal => 120f;

		public static int ActiveOfficerCount => PoliceOfficer.Officers.Count;

		public static void CallPolice(Player target)
		{
			if (!((Object)(object)Internal == (Object)null) && target != null)
			{
				Internal.PoliceCalled(target.S1Player, (Crime)null);
			}
		}

		public static void SetWantedLevel(Player target, PursuitLevel level)
		{
			target?.CrimeData.SetPursuitLevel(level);
		}

		public static void ClearWantedLevel(Player target)
		{
			target?.CrimeData.SetPursuitLevel(PursuitLevel.None);
		}

		public static PursuitLevel GetWantedLevel(Player target)
		{
			return target?.CrimeData.CurrentPursuitLevel ?? PursuitLevel.None;
		}

		public static void EscalateWantedLevel(Player target)
		{
			target?.CrimeData.Escalate();
		}

		public static void DeescalateWantedLevel(Player target)
		{
			target?.CrimeData.Deescalate();
		}

		public static bool IsPlayerWanted(Player target)
		{
			if (target == null)
			{
				return false;
			}
			return target.CrimeData.CurrentPursuitLevel != PursuitLevel.None;
		}

		public static bool IsUnderInvestigation(Player target)
		{
			if (target == null)
			{
				return false;
			}
			return target.CrimeData.CurrentPursuitLevel >= PursuitLevel.Investigating;
		}

		public static bool IsLethalForceAuthorized(Player target)
		{
			if (target == null)
			{
				return false;
			}
			return target.CrimeData.CurrentPursuitLevel == PursuitLevel.Lethal;
		}

		public static PatrolGroup? StartFootPatrol(FootPatrolRoute route, int requestedMembers = 2)
		{
			if ((Object)(object)Internal == (Object)null || (Object)(object)route?.S1Route == (Object)null)
			{
				return null;
			}
			PatrolGroup val = Internal.StartFootpatrol(route.S1Route, requestedMembers);
			return (val != null) ? new PatrolGroup(val) : null;
		}

		public static bool StartVehiclePatrol(VehiclePatrolRoute route)
		{
			if ((Object)(object)Internal == (Object)null || (Object)(object)route?.S1Route == (Object)null)
			{
				return false;
			}
			PoliceOfficer val = Internal.StartVehiclePatrol(route.S1Route);
			return (Object)(object)val != (Object)null;
		}

		public static FootPatrolRoute? FindFootPatrolRoute(string routeName)
		{
			if (string.IsNullOrEmpty(routeName))
			{
				return null;
			}
			Il2CppArrayBase<FootPatrolRoute> val = Object.FindObjectsOfType<FootPatrolRoute>();
			for (int i = 0; i < val.Length; i++)
			{
				if (val[i].RouteName == routeName)
				{
					return new FootPatrolRoute(val[i]);
				}
			}
			return null;
		}

		public static VehiclePatrolRoute? FindVehiclePatrolRoute(string routeName)
		{
			if (string.IsNullOrEmpty(routeName))
			{
				return null;
			}
			Il2CppArrayBase<VehiclePatrolRoute> val = Object.FindObjectsOfType<VehiclePatrolRoute>();
			for (int i = 0; i < val.Length; i++)
			{
				if (val[i].RouteName == routeName)
				{
					return new VehiclePatrolRoute(val[i]);
				}
			}
			return null;
		}

		public static FootPatrolRoute[] GetAllFootPatrolRoutes()
		{
			Il2CppArrayBase<FootPatrolRoute> val = Object.FindObjectsOfType<FootPatrolRoute>();
			FootPatrolRoute[] array = new FootPatrolRoute[val.Length];
			for (int i = 0; i < val.Length; i++)
			{
				array[i] = new FootPatrolRoute(val[i]);
			}
			return array;
		}

		public static VehiclePatrolRoute[] GetAllVehiclePatrolRoutes()
		{
			Il2CppArrayBase<VehiclePatrolRoute> val = Object.FindObjectsOfType<VehiclePatrolRoute>();
			VehiclePatrolRoute[] array = new VehiclePatrolRoute[val.Length];
			for (int i = 0; i < val.Length; i++)
			{
				array[i] = new VehiclePatrolRoute(val[i]);
			}
			return array;
		}
	}
	public sealed class PatrolGroup
	{
		internal readonly PatrolGroup S1PatrolGroup;

		public int MemberCount
		{
			get
			{
				PatrolGroup s1PatrolGroup = S1PatrolGroup;
				return (s1PatrolGroup != null) ? s1PatrolGroup.Members.Count : 0;
			}
		}

		public int CurrentWaypoint
		{
			get
			{
				PatrolGroup s1PatrolGroup = S1PatrolGroup;
				return (s1PatrolGroup != null) ? s1PatrolGroup.CurrentWaypoint : 0;
			}
		}

		public FootPatrolRoute? Route
		{
			get
			{
				PatrolGroup s1PatrolGroup = S1PatrolGroup;
				if ((Object)(object)((s1PatrolGroup != null) ? s1PatrolGroup.Route : null) == (Object)null)
				{
					return null;
				}
				return new FootPatrolRoute(S1PatrolGroup.Route);
			}
		}

		internal PatrolGroup(PatrolGroup s1PatrolGroup)
		{
			S1PatrolGroup = s1PatrolGroup;
		}

		public void DisbandGroup()
		{
			PatrolGroup s1PatrolGroup = S1PatrolGroup;
			if (s1PatrolGroup != null)
			{
				s1PatrolGroup.DisbandGroup();
			}
		}

		public void AdvanceGroup()
		{
			PatrolGroup s1PatrolGroup = S1PatrolGroup;
			if (s1PatrolGroup != null)
			{
				s1PatrolGroup.AdvanceGroup();
			}
		}

		public bool IsGroupReadyToAdvance()
		{
			PatrolGroup s1PatrolGroup = S1PatrolGroup;
			return s1PatrolGroup != null && s1PatrolGroup.IsGroupReadyToAdvance();
		}

		public bool IsPaused()
		{
			PatrolGroup s1PatrolGroup = S1PatrolGroup;
			return s1PatrolGroup == null || s1PatrolGroup.IsPaused();
		}
	}
	public sealed class PlayerCrimeData
	{
		internal readonly PlayerCrimeData S1CrimeData;

		public PursuitLevel CurrentPursuitLevel => (PursuitLevel)S1CrimeData.CurrentPursuitLevel;

		public Vector3 LastKnownPosition => S1CrimeData.LastKnownPosition;

		public float TimeSinceSighted => S1CrimeData.TimeSinceSighted;

		public bool BodySearchPending => S1CrimeData.BodySearchPending;

		public bool EvadedArrest => S1CrimeData.EvadedArrest;

		internal PlayerCrimeData(PlayerCrimeData crimeData)
		{
			S1CrimeData = crimeData;
		}

		public float GetSearchTime()
		{
			return S1CrimeData.GetSearchTime();
		}

		public void SetPursuitLevel(PursuitLevel level)
		{
			S1CrimeData.SetPursuitLevel((EPursuitLevel)level);
		}

		public void Escalate()
		{
			S1CrimeData.Escalate();
		}

		public void Deescalate()
		{
			S1CrimeData.Deescalate();
		}

		public void ClearCrimes()
		{
			S1CrimeData.ClearCrimes();
		}

		public void RecordLastKnownPosition(bool resetTimeSinceSighted = true)
		{
			S1CrimeData.RecordLastKnownPosition(resetTimeSinceSighted);
		}
	}
	public enum PursuitLevel
	{
		None,
		Investigating,
		Arresting,
		NonLethal,
		Lethal
	}
	public sealed class VehiclePatrolRoute
	{
		internal readonly VehiclePatrolRoute S1Route;

		public string RouteName
		{
			get
			{
				VehiclePatrolRoute s1Route = S1Route;
				return ((s1Route != null) ? s1Route.RouteName : null) ?? string.Empty;
			}
		}

		public int WaypointCount
		{
			get
			{
				VehiclePatrolRoute s1Route = S1Route;
				return ((s1Route == null) ? ((int?)null) : ((Il2CppArrayBase<Transform>)(object)s1Route.Waypoints)?.Length).GetValueOrDefault();
			}
		}

		public int StartWaypointIndex
		{
			get
			{
				VehiclePatrolRoute s1Route = S1Route;
				return (s1Route != null) ? s1Route.StartWaypointIndex : 0;
			}
		}

		public Vector3 Position
		{
			get
			{
				//IL_0016: 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)
				VehiclePatrolRoute s1Route = S1Route;
				return (s1Route != null) ? ((Component)s1Route).transform.position : Vector3.zero;
			}
		}

		internal VehiclePatrolRoute(VehiclePatrolRoute s1Route)
		{
			S1Route = s1Route;
		}

		public Vector3 GetWaypointPosition(int index)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			VehiclePatrolRoute s1Route = S1Route;
			if (((s1Route != null) ? s1Route.Waypoints : null) == null || index < 0 || index >= ((Il2CppArrayBase<Transform>)(object)S1Route.Waypoints).Length)
			{
				return Vector3.zero;
			}
			return ((Il2CppArrayBase<Transform>)(object)S1Route.Waypoints)[index].position;
		}
	}
}
namespace S1API.Items
{
	[Obsolete("Use S1API.Items.Additive.AdditiveDefinition instead")]
	public sealed class AdditiveDefinition : StorableItemDefinition
	{
		internal AdditiveDefinition S1AdditiveDefinition { get; }

		public Material DisplayMaterial => S1AdditiveDefinition.DisplayMaterial;

		public float QualityChange => S1AdditiveDefinition.QualityChange;

		public float YieldMultiplier => S1AdditiveDefinition.YieldMultiplier;

		public float InstantGrowth => S1AdditiveDefinition.InstantGrowth;

		internal AdditiveDefinition(AdditiveDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1AdditiveDefinition = definition;
		}
	}
	[Obsolete("Use S1API.Items.Additive.AdditiveDefinitionBuilder instead")]
	public sealed class AdditiveDefinitionBuilder
	{
		private static readonly Log Logger = new Log("AdditiveDefinitionBuilder");

		private readonly AdditiveDefinition _definition;

		private readonly GameObject _storedItemPlaceholder;

		internal AdditiveDefinitionBuilder()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<AdditiveDefinition>();
			((BaseItemDefinition)_definition).StackLimit = 10;
			((StorableItemDefinition)_definition).BasePurchasePrice = 10f;
			((StorableItemDefinition)_definition).ResellMultiplier = 0.5f;
			((BaseItemDefinition)_definition).Category = (EItemCategory)2;
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)_definition).AvailableInDemo = true;
			((BaseItemDefinition)_definition).UsableInFilters = true;
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			((StorableItemDefinition)_definition).StoredItem = storedItem;
		}

		internal AdditiveDefinitionBuilder(AdditiveDefinition source)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<AdditiveDefinition>();
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			((StorableItemDefinition)_definition).StoredItem = storedItem;
			CopyPropertiesFrom(source);
		}

		private void CopyPropertiesFrom(AdditiveDefinition source)
		{
			//IL_003c: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null))
			{
				((BaseItemDefinition)_definition).Name = ((BaseItemDefinition)source).Name;
				((BaseItemDefinition)_definition).Description = ((BaseItemDefinition)source).Description;
				((BaseItemDefinition)_definition).Category = ((BaseItemDefinition)source).Category;
				((BaseItemDefinition)_definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
				((ItemDefinition)_definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
				((BaseItemDefinition)_definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
				((BaseItemDefinition)_definition).Icon = ((BaseItemDefinition)source).Icon;
				((BaseItemDefinition)_definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
				((StorableItemDefinition)_definition).PickpocketDifficultyMultiplier = ((StorableItemDefinition)source).PickpocketDifficultyMultiplier;
				((StorableItemDefinition)_definition).CombatUtility = ((StorableItemDefinition)source).CombatUtility;
				((StorableItemDefinition)_definition).BasePurchasePrice = ((StorableItemDefinition)source).BasePurchasePrice;
				((StorableItemDefinition)_definition).ResellMultiplier = ((StorableItemDefinition)source).ResellMultiplier;
				((StorableItemDefinition)_definition).ShopCategories = ((StorableItemDefinition)source).ShopCategories;
				((StorableItemDefinition)_definition).RequiresLevelToPurchase = ((StorableItemDefinition)source).RequiresLevelToPurchase;
				((StorableItemDefinition)_definition).RequiredRank = ((StorableItemDefinition)source).RequiredRank;
				((StorableItemDefinition)_definition).StoredItem = (((Object)(object)((StorableItemDefinition)source).StoredItem != (Object)null) ? ((StorableItemDefinition)source).StoredItem : ((StorableItemDefinition)_definition).StoredItem);
				((StorableItemDefinition)_definition).StationItem = ((StorableItemDefinition)source).StationItem;
				((ItemDefinition)_definition).Equippable = ((ItemDefinition)source).Equippable;
				AutoPropertySetter.TrySet(_definition, "DisplayMaterial", source.DisplayMaterial);
				AutoPropertySetter.TrySet(_definition, "QualityChange", source.QualityChange);
				AutoPropertySetter.TrySet(_definition, "YieldMultiplier", source.YieldMultiplier);
				AutoPropertySetter.TrySet(_definition, "InstantGrowth", source.InstantGrowth);
			}
		}

		public AdditiveDefinitionBuilder WithBasicInfo(string id, string name, string description, ItemCategory category)
		{
			((BaseItemDefinition)_definition).ID = id;
			((BaseItemDefinition)_definition).Name = name;
			((BaseItemDefinition)_definition).Description = description;
			((BaseItemDefinition)_definition).Category = (EItemCategory)category;
			string text = (string.IsNullOrEmpty(name) ? id : name);
			if (!string.IsNullOrEmpty(text))
			{
				((Object)_definition).name = text;
				if ((Object)(object)_storedItemPlaceholder != (Object)null)
				{
					((Object)_storedItemPlaceholder).name = text + "_StoredItem";
				}
			}
			return this;
		}

		public AdditiveDefinitionBuilder WithStackLimit(int limit)
		{
			((BaseItemDefinition)_definition).StackLimit = Mathf.Clamp(limit, 1, 999);
			return this;
		}

		public AdditiveDefinitionBuilder WithIcon(Sprite icon)
		{
			((BaseItemDefinition)_definition).Icon = icon;
			return this;
		}

		public AdditiveDefinitionBuilder WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			((StorableItemDefinition)_definition).BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			((StorableItemDefinition)_definition).ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return this;
		}

		public AdditiveDefinitionBuilder WithLegalStatus(LegalStatus status)
		{
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)status;
			return this;
		}

		public AdditiveDefinitionBuilder WithDemoAvailability(bool available)
		{
			((ItemDefinition)_definition).AvailableInDemo = available;
			return this;
		}

		public AdditiveDefinitionBuilder WithDisplayMaterial(Material material)
		{
			if (!AutoPropertySetter.TrySet(_definition, "DisplayMaterial", material))
			{
				Logger.Warning("Failed to set DisplayMaterial on AdditiveDefinition '" + (((BaseItemDefinition)_definition).ID ?? "<no id>") + "'.");
			}
			return this;
		}

		public AdditiveDefinitionBuilder WithEffects(float yieldMultiplier, float instantGrowth, float qualityChange)
		{
			if (!AutoPropertySetter.TrySet(_definition, "YieldMultiplier", yieldMultiplier))
			{
				Logger.Warning("Failed to set YieldMultiplier on AdditiveDefinition '" + (((BaseItemDefinition)_definition).ID ?? "<no id>") + "'.");
			}
			if (!AutoPropertySetter.TrySet(_definition, "InstantGrowth", instantGrowth))
			{
				Logger.Warning("Failed to set InstantGrowth on AdditiveDefinition '" + (((BaseItemDefinition)_definition).ID ?? "<no id>") + "'.");
			}
			if (!AutoPropertySetter.TrySet(_definition, "QualityChange", qualityChange))
			{
				Logger.Warning("Failed to set QualityChange on AdditiveDefinition '" + (((BaseItemDefinition)_definition).ID ?? "<no id>") + "'.");
			}
			return this;
		}

		public AdditiveDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)_definition).ID))
			{
				throw new InvalidOperationException("AdditiveDefinitionBuilder requires WithBasicInfo(...) to be called before Build().");
			}
			if (!string.IsNullOrEmpty(((BaseItemDefinition)_definition).Name) && (Object)(object)_storedItemPlaceholder != (Object)null)
			{
				((Object)_storedItemPlaceholder).name = ((BaseItemDefinition)_definition).Name + "_StoredItem";
			}
			Registry instance;
			try
			{
				instance = Singleton<Registry>.Instance;
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("ScheduleOne.Registry is not available yet. Register additives during S1API.Lifecycle.GameLifecycle.OnPreLoad.", innerException);
			}
			if ((Object)(object)instance == (Object)null)
			{
				throw new InvalidOperationException("ScheduleOne.Registry is not available yet. Register additives during S1API.Lifecycle.GameLifecycle.OnPreLoad.");
			}
			instance.AddToRegistry((ItemDefinition)(object)_definition);
			return new AdditiveDefinition(_definition);
		}

		internal AdditiveDefinition BuildInternal()
		{
			return _definition;
		}
	}
	[Obsolete("Use S1API.Items.Additive.AdditiveItemCreator instead")]
	public static class AdditiveItemCreator
	{
		public static AdditiveDefinitionBuilder CreateBuilder()
		{
			return new AdditiveDefinitionBuilder();
		}

		public static AdditiveDefinitionBuilder CloneFrom(string sourceItemId)
		{
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<AdditiveDefinition>((object)item, out AdditiveDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an AdditiveDefinition", "sourceItemId");
			}
			return new AdditiveDefinitionBuilder(result);
		}

		public static AdditiveDefinitionBuilder CloneFrom(AdditiveDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source additive definition cannot be null");
			}
			return new AdditiveDefinitionBuilder(source.S1AdditiveDefinition);
		}
	}
	public static class AvatarEquippablePaths
	{
		public const string BasePath = "avatar/equippables";

		public const string Baton = "avatar/equippables/Baton";

		public const string Beer = "avatar/equippables/Beer";

		public const string BrokenBottle = "avatar/equippables/BrokenBottle";

		public const string Coffee = "avatar/equippables/Coffee";

		public const string Cuke = "avatar/equippables/Cuke";

		public const string Hammer = "avatar/equippables/Hammer";

		public const string Joint = "avatar/equippables/Joint";

		public const string Knife = "avatar/equippables/Knife";

		public const string M1911 = "avatar/equippables/M1911";

		public const string PhoneLowered = "avatar/equippables/Phone_Lowered";

		public const string PhoneRaised = "avatar/equippables/Phone_Raised";

		public const string Pipe = "avatar/equippables/Pipe";

		public const string Revolver = "avatar/equippables/Revolver";

		public const string Taser = "avatar/equippables/Taser";

		public const string TrashBag = "avatar/equippables/TrashBag";
	}
	public static class AvatarEquippableRegistry
	{
		private static readonly Log _logger = new Log("AvatarEquippableRegistry");

		public static bool RegisterAvatarEquippable(string assetPath, GameObject prefab)
		{
			if (string.IsNullOrEmpty(assetPath))
			{
				_logger.Error("Cannot register AvatarEquippable: assetPath is null or empty");
				return false;
			}
			if ((Object)(object)prefab == (Object)null)
			{
				_logger.Error("Cannot register AvatarEquippable at '" + assetPath + "': prefab is null");
				return false;
			}
			AvatarEquippable component = prefab.GetComponent<AvatarEquippable>();
			if ((Object)(object)component == (Object)null)
			{
				_logger.Warning("Prefab '" + ((Object)prefab).name + "' does not have an AvatarEquippable component. It will still be registered, but may not work correctly.");
			}
			bool flag = RuntimeResourceRegistry.RegisterGameObject(assetPath, prefab);
			if (flag)
			{
				_logger.Debug("Registered AvatarEquippable prefab: " + assetPath);
			}
			return flag;
		}

		public static bool LoadAndRegisterFromBundle(WrappedAssetBundle bundle, string prefabName, string assetPath)
		{
			if (bundle == null)
			{
				_logger.Error("Cannot load AvatarEquippable: bundle is null");
				return false;
			}
			try
			{
				GameObject val = bundle.LoadAsset<GameObject>(prefabName);
				if ((Object)(object)val == (Object)null)
				{
					_logger.Error("Failed to load prefab '" + prefabName + "' from AssetBundle");
					return false;
				}
				return RegisterAvatarEquippable(assetPath, val);
			}
			catch (Exception ex)
			{
				_logger.Error("Exception loading AvatarEquippable from bundle: " + ex.Message);
				_logger.Error(ex.StackTrace ?? ex.ToString());
				return false;
			}
		}

		public static bool LoadAndRegisterFromEmbeddedBundle(string bundleName, string prefabName, string assetPath, Assembly? assemblyOverride = null)
		{
			try
			{
				Assembly assembly = assemblyOverride ?? Assembly.GetExecutingAssembly();
				WrappedAssetBundle assetBundleFromStream = AssetLoader.GetAssetBundleFromStream(assembly.GetName().Name + "." + bundleName, assembly);
				return LoadAndRegisterFromBundle(assetBundleFromStream, prefabName, assetPath);
			}
			catch (Exception ex)
			{
				_logger.Error("Exception loading AvatarEquippable from embedded bundle '" + bundleName + "': " + ex.Message);
				_logger.Error(ex.StackTrace ?? ex.ToString());
				return false;
			}
		}

		public static bool IsRegistered(string assetPath)
		{
			return RuntimeResourceRegistry.IsRegistered(assetPath);
		}

		public static GameObject? GetRegisteredPrefab(string assetPath)
		{
			return RuntimeResourceRegistry.GetRegisteredAsset<GameObject>(assetPath);
		}
	}
	[Obsolete("Use S1API.Items.Buildable.BuildableItemCreator instead")]
	public static class BuildableItemCreator
	{
		public static BuildableItemDefinitionBuilder CreateBuilder()
		{
			return new BuildableItemDefinitionBuilder();
		}

		public static BuildableItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<BuildableItemDefinition>((object)item, out BuildableItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not a BuildableItemDefinition", "sourceItemId");
			}
			return new BuildableItemDefinitionBuilder(result);
		}

		public static BuildableItemDefinitionBuilder CloneFrom(BuildableItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source item definition cannot be null");
			}
			return new BuildableItemDefinitionBuilder(source.S1BuildableItemDefinition);
		}
	}
	[Obsolete("Use S1API.Items.Buildable.BuildableItemDefinition instead")]
	public sealed class BuildableItemDefinition : StorableItemDefinition
	{
		internal BuildableItemDefinition S1BuildableItemDefinition { get; }

		public BuildSoundType BuildSoundType
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (BuildSoundType)S1BuildableItemDefinition.BuildSoundType;
			}
			set
			{
				S1BuildableItemDefinition.BuildSoundType = (EBuildSoundType)value;
			}
		}

		internal BuildableItemDefinition(BuildableItemDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1BuildableItemDefinition = definition;
		}
	}
	public enum BuildSoundType
	{
		Wood,
		Metal,
		Plastic,
		Cardboard
	}
	[Obsolete("Use S1API.Items.Buildable.BuildableItemDefinitionBuilder instead")]
	public sealed class BuildableItemDefinitionBuilder
	{
		private readonly BuildableItemDefinition _definition;

		internal BuildableItemDefinitionBuilder()
		{
			_definition = ScriptableObject.CreateInstance<BuildableItemDefinition>();
			((BaseItemDefinition)_definition).StackLimit = 10;
			((StorableItemDefinition)_definition).BasePurchasePrice = 10f;
			((StorableItemDefinition)_definition).ResellMultiplier = 0.5f;
			((BaseItemDefinition)_definition).Category = (EItemCategory)4;
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)_definition).AvailableInDemo = true;
			((BaseItemDefinition)_definition).UsableInFilters = true;
			_definition.BuildSoundType = (EBuildSoundType)1;
		}

		internal BuildableItemDefinitionBuilder(BuildableItemDefinition source)
		{
			_definition = ScriptableObject.CreateInstance<BuildableItemDefinition>();
			CopyPropertiesFrom(source);
		}

		private void CopyPropertiesFrom(BuildableItemDefinition source)
		{
			//IL_002c: 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_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			((BaseItemDefinition)_definition).Name = ((BaseItemDefinition)source).Name;
			((BaseItemDefinition)_definition).Description = ((BaseItemDefinition)source).Description;
			((BaseItemDefinition)_definition).Category = ((BaseItemDefinition)source).Category;
			((BaseItemDefinition)_definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
			((ItemDefinition)_definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
			((BaseItemDefinition)_definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
			((BaseItemDefinition)_definition).Icon = ((BaseItemDefinition)source).Icon;
			((BaseItemDefinition)_definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
			((StorableItemDefinition)_definition).PickpocketDifficultyMultiplier = ((StorableItemDefinition)source).PickpocketDifficultyMultiplier;
			((StorableItemDefinition)_definition).CombatUtility = ((StorableItemDefinition)source).CombatUtility;
			((StorableItemDefinition)_definition).BasePurchasePrice = ((StorableItemDefinition)source).BasePurchasePrice;
			((StorableItemDefinition)_definition).ResellMultiplier = ((StorableItemDefinition)source).ResellMultiplier;
			((StorableItemDefinition)_definition).ShopCategories = ((StorableItemDefinition)source).ShopCategories;
			((StorableItemDefinition)_definition).RequiresLevelToPurchase = ((StorableItemDefinition)source).RequiresLevelToPurchase;
			((StorableItemDefinition)_definition).RequiredRank = ((StorableItemDefinition)source).RequiredRank;
			_definition.BuildSoundType = source.BuildSoundType;
			_definition.BuiltItem = source.BuiltItem;
			((StorableItemDefinition)_definition).StoredItem = ((StorableItemDefinition)source).StoredItem;
			((ItemDefinition)_definition).Equippable = ((ItemDefinition)source).Equippable;
		}

		public BuildableItemDefinitionBuilder WithBasicInfo(string id, string name, string description)
		{
			((BaseItemDefinition)_definition).ID = id;
			((BaseItemDefinition)_definition).Name = name;
			((BaseItemDefinition)_definition).Description = description;
			if (!string.IsNullOrEmpty(name))
			{
				((Object)_definition).name = name;
			}
			return this;
		}

		public BuildableItemDefinitionBuilder WithBuildSound(BuildSoundType soundType)
		{
			_definition.BuildSoundType = (EBuildSoundType)soundType;
			return this;
		}

		public BuildableItemDefinitionBuilder WithIcon(Sprite icon)
		{
			((BaseItemDefinition)_definition).Icon = icon;
			return this;
		}

		public BuildableItemDefinitionBuilder WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			((StorableItemDefinition)_definition).BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			((StorableItemDefinition)_definition).ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return this;
		}

		public BuildableItemDefinitionBuilder WithCategory(ItemCategory category)
		{
			((BaseItemDefinition)_definition).Category = (EItemCategory)category;
			return this;
		}

		public BuildableItemDefinitionBuilder WithStackLimit(int limit)
		{
			((BaseItemDefinition)_definition).StackLimit = Mathf.Clamp(limit, 1, 999);
			return this;
		}

		public BuildableItemDefinitionBuilder WithLegalStatus(LegalStatus status)
		{
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)status;
			return this;
		}

		public BuildableItemDefinitionBuilder WithEquippable(Equippable equippable)
		{
			if (equippable != null)
			{
				((ItemDefinition)_definition).Equippable = equippable.S1Equippable;
			}
			return this;
		}

		public BuildableItemDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)_definition).ID))
			{
				throw new ArgumentException("Item ID cannot be null, empty, or whitespace.", "ID");
			}
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)_definition);
			return new BuildableItemDefinition(_definition);
		}

		internal BuildableItemDefinition BuildInternal()
		{
			return _definition;
		}
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingApplicationType instead")]
	public enum ClothingApplicationType
	{
		BodyLayer,
		FaceLayer,
		Accessory
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingColor instead")]
	public enum ClothingColor
	{
		White,
		LightGrey,
		DarkGrey,
		Charcoal,
		Black,
		LightRed,
		Red,
		Crimson,
		Orange,
		Tan,
		Brown,
		Coral,
		Beige,
		Yellow,
		Lime,
		LightGreen,
		DarkGreen,
		Cyan,
		SkyBlue,
		Blue,
		DeepBlue,
		Navy,
		DeepPurple,
		Purple,
		Magenta,
		BrightPink,
		HotPink
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingItemCreator instead")]
	public static class ClothingItemCreator
	{
		private static readonly Log Logger = new Log("ClothingItemCreator");

		public static ClothingItemDefinitionBuilder CreateBuilder()
		{
			return new ClothingItemDefinitionBuilder();
		}

		public static ClothingItemDefinitionBuilder? CloneFrom(string sourceItemId)
		{
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				Logger.Error("Cannot clone clothing item '" + sourceItemId + "': source item not found in registry");
				return null;
			}
			if (!CrossType.Is<ClothingDefinition>((object)item, out ClothingDefinition result))
			{
				Logger.Error($"Cannot clone item '{sourceItemId}': it is not a clothing item (found type: {((object)item).GetType().Name})");
				return null;
			}
			return new ClothingItemDefinitionBuilder(result);
		}

		public static ClothingItemDefinitionBuilder? CloneFrom(ClothingItemDefinition source)
		{
			if (source == null)
			{
				Logger.Error("Cannot clone from null clothing item definition");
				return null;
			}
			return new ClothingItemDefinitionBuilder(source.S1ClothingDefinition);
		}
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingItemDefinition instead")]
	public sealed class ClothingItemDefinition : StorableItemDefinition
	{
		internal ClothingDefinition S1ClothingDefinition { get; }

		public ClothingSlot Slot
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingSlot)S1ClothingDefinition.Slot;
			}
			set
			{
				S1ClothingDefinition.Slot = (EClothingSlot)value;
			}
		}

		public ClothingApplicationType ApplicationType
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingApplicationType)S1ClothingDefinition.ApplicationType;
			}
			set
			{
				S1ClothingDefinition.ApplicationType = (EClothingApplicationType)value;
			}
		}

		public string ClothingAssetPath
		{
			get
			{
				return S1ClothingDefinition.ClothingAssetPath;
			}
			set
			{
				S1ClothingDefinition.ClothingAssetPath = value;
			}
		}

		public bool Colorable
		{
			get
			{
				return S1ClothingDefinition.Colorable;
			}
			set
			{
				S1ClothingDefinition.Colorable = value;
			}
		}

		public ClothingColor DefaultColor
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingColor)S1ClothingDefinition.DefaultColor;
			}
			set
			{
				S1ClothingDefinition.DefaultColor = (EClothingColor)value;
			}
		}

		public List<ClothingSlot> SlotsToBlock
		{
			get
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected I4, but got Unknown
				List<ClothingSlot> list = new List<ClothingSlot>();
				if (S1ClothingDefinition.SlotsToBlock != null)
				{
					Enumerator<EClothingSlot> enumerator = S1ClothingDefinition.SlotsToBlock.GetEnumerator();
					while (enumerator.MoveNext())
					{
						EClothingSlot current = enumerator.Current;
						list.Add((ClothingSlot)current);
					}
				}
				return list;
			}
			set
			{
				S1ClothingDefinition.SlotsToBlock = new List<EClothingSlot>();
				if (value == null)
				{
					return;
				}
				foreach (ClothingSlot item in value)
				{
					S1ClothingDefinition.SlotsToBlock.Add((EClothingSlot)item);
				}
			}
		}

		internal ClothingItemDefinition(ClothingDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1ClothingDefinition = definition;
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return CreateInstance(quantity, DefaultColor);
		}

		public ClothingItemInstance CreateInstance(ClothingColor color)
		{
			return CreateInstance(1, color);
		}

		public ClothingItemInstance CreateInstance(int quantity, ClothingColor color)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new ClothingItemInstance(new ClothingInstance((ItemDefinition)(object)S1ClothingDefinition, quantity, (EClothingColor)color));
		}
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingItemDefinitionBuilder instead")]
	public sealed class ClothingItemDefinitionBuilder
	{
		private static readonly Log Logger = new Log("ClothingItemDefinitionBuilder");

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

		private static readonly object WarnedMissingNativeClothingItemUiLock = new object();

		private static ItemUI? s_cachedNativeCustomItemUI;

		private readonly ClothingDefinition _definition;

		internal ClothingItemDefinitionBuilder()
		{
			_definition = ScriptableObject.CreateInstance<ClothingDefinition>();
			((BaseItemDefinition)_definition).StackLimit = 1;
			((StorableItemDefinition)_definition).BasePurchasePrice = 10f;
			((StorableItemDefinition)_definition).ResellMultiplier = 0.5f;
			((BaseItemDefinition)_definition).Category = (EItemCategory)11;
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)_definition).AvailableInDemo = true;
			((BaseItemDefinition)_definition).UsableInFilters = true;
			_definition.Slot = (EClothingSlot)8;
			_definition.ApplicationType = (EClothingApplicationType)2;
			_definition.ClothingAssetPath = "Path/To/Clothing/Asset";
			_definition.Colorable = true;
			_definition.DefaultColor = (EClothingColor)0;
			_definition.SlotsToBlock = new List<EClothingSlot>();
		}

		internal ClothingItemDefinitionBuilder(ClothingDefinition source)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null)
			{
				throw new ArgumentNullException("source");
			}
			_definition = ScriptableObject.CreateInstance<ClothingDefinition>();
			((BaseItemDefinition)_definition).ID = ((BaseItemDefinition)source).ID;
			((BaseItemDefinition)_definition).Name = ((BaseItemDefinition)source).Name;
			((BaseItemDefinition)_definition).Description = ((BaseItemDefinition)source).Description;
			((BaseItemDefinition)_definition).Icon = ((BaseItemDefinition)source).Icon;
			((BaseItemDefinition)_definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
			((StorableItemDefinition)_definition).BasePurchasePrice = ((StorableItemDefinition)source).BasePurchasePrice;
			((StorableItemDefinition)_definition).ResellMultiplier = ((StorableItemDefinition)source).ResellMultiplier;
			((BaseItemDefinition)_definition).Category = ((BaseItemDefinition)source).Category;
			((BaseItemDefinition)_definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
			((ItemDefinition)_definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
			((BaseItemDefinition)_definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
			((StorableItemDefinition)_definition).StoredItem = ((StorableItemDefinition)source).StoredItem;
			((ItemDefinition)_definition).Equippable = ((ItemDefinition)source).Equippable;
			((ItemDefinition)_definition).CustomItemUI = ((ItemDefinition)source).CustomItemUI;
			_definition.Slot = source.Slot;
			_definition.ApplicationType = source.ApplicationType;
			_definition.ClothingAssetPath = source.ClothingAssetPath;
			_definition.Colorable = source.Colorable;
			_definition.DefaultColor = source.DefaultColor;
			_definition.SlotsToBlock = new List<EClothingSlot>();
			if (source.SlotsToBlock != null)
			{
				Enumerator<EClothingSlot> enumerator = source.SlotsToBlock.GetEnumerator();
				while (enumerator.MoveNext())
				{
					EClothingSlot current = enumerator.Current;
					_definition.SlotsToBlock.Add(current);
				}
			}
		}

		public ClothingItemDefinitionBuilder WithBasicInfo(string id, string name, string description)
		{
			((BaseItemDefinition)_definition).ID = id;
			((BaseItemDefinition)_definition).Name = name;
			((BaseItemDefinition)_definition).Description = description;
			((Object)_definition).name = (string.IsNullOrEmpty(name) ? id : name);
			return this;
		}

		public ClothingItemDefinitionBuilder WithSlot(ClothingSlot slot)
		{
			_definition.Slot = (EClothingSlot)slot;
			return this;
		}

		public ClothingItemDefinitionBuilder WithApplicationType(ClothingApplicationType applicationType)
		{
			_definition.ApplicationType = (EClothingApplicationType)applicationType;
			return this;
		}

		public ClothingItemDefinitionBuilder WithClothingAsset(string assetPath)
		{
			_definition.ClothingAssetPath = assetPath;
			return this;
		}

		public ClothingItemDefinitionBuilder WithColorable(bool colorable)
		{
			_definition.Colorable = colorable;
			return this;
		}

		public ClothingItemDefinitionBuilder WithDefaultColor(ClothingColor color)
		{
			_definition.DefaultColor = (EClothingColor)color;
			return this;
		}

		public ClothingItemDefinitionBuilder WithBlockedSlots(params ClothingSlot[] slots)
		{
			_definition.SlotsToBlock = new List<EClothingSlot>();
			foreach (ClothingSlot clothingSlot in slots)
			{
				_definition.SlotsToBlock.Add((EClothingSlot)clothingSlot);
			}
			return this;
		}

		public ClothingItemDefinitionBuilder WithIcon(Sprite icon)
		{
			((BaseItemDefinition)_definition).Icon = icon;
			return this;
		}

		public ClothingItemDefinitionBuilder WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			((StorableItemDefinition)_definition).BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			((StorableItemDefinition)_definition).ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return this;
		}

		public ClothingItemDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)_definition).ID))
			{
				throw new ArgumentException("Item ID cannot be null, empty, or whitespace.", "ID");
			}
			EnsureNativeClothingItemUi();
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)_definition);
			return new ClothingItemDefinition(_definition);
		}

		internal ClothingDefinition BuildInternal()
		{
			EnsureNativeClothingItemUi();
			return _definition;
		}

		private void EnsureNativeClothingItemUi()
		{
			if ((Object)(object)((ItemDefinition)_definition).CustomItemUI != (Object)null)
			{
				return;
			}
			if ((Object)(object)s_cachedNativeCustomItemUI != (Object)null)
			{
				((ItemDefinition)_definition).CustomItemUI = s_cachedNativeCustomItemUI;
				return;
			}
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				WarnMissingNativeClothingItemUi("S1Registry.Instance is null");
				return;
			}
			List<ItemDefinition> allItems = Singleton<Registry>.Instance.GetAllItems();
			if (allItems == null)
			{
				WarnMissingNativeClothingItemUi("S1Registry.Instance.GetAllItems() returned null");
				return;
			}
			Enumerator<ItemDefinition> enumerator = allItems.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemDefinition current = enumerator.Current;
				if (!((Object)(object)current == (Object)null) && CrossType.Is<ClothingDefinition>((object)current, out ClothingDefinition result))
				{
					ItemUI customItemUI = ((ItemDefinition)result).CustomItemUI;
					if (!((Object)(object)customItemUI == (Object)null))
					{
						s_cachedNativeCustomItemUI = customItemUI;
						((ItemDefinition)_definition).CustomItemUI = customItemUI;
						return;
					}
				}
			}
			WarnMissingNativeClothingItemUi("no S1Clothing.ClothingDefinition with S1Clothing.ClothingDefinition.CustomItemUI was found");
		}

		private static void WarnMissingNativeClothingItemUi(string reason)
		{
			if (!string.IsNullOrWhiteSpace(reason))
			{
				bool flag;
				lock (WarnedMissingNativeClothingItemUiLock)
				{
					flag = WarnedMissingNativeClothingItemUiReasons.Add(reason);
				}
				if (flag)
				{
					Logger.Warning("Could not borrow a native clothing CustomItemUI template (" + reason + "). Custom clothing inventory UI may be incomplete. This usually means Build() was called before any native clothing registered.");
				}
			}
		}
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingItemInstance instead")]
	public class ClothingItemInstance : ItemInstance
	{
		internal readonly ClothingInstance S1ClothingInstance;

		public ClothingColor Color
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingColor)S1ClothingInstance.Color;
			}
			set
			{
				S1ClothingInstance.Color = (EClothingColor)value;
			}
		}

		public new ClothingItemDefinition Definition => new ClothingItemDefinition(CrossType.As<ClothingDefinition>((object)((ItemInstance)S1ClothingInstance).Definition));

		internal ClothingItemInstance(ClothingInstance itemInstance)
			: base((ItemInstance)(object)itemInstance)
		{
			S1ClothingInstance = itemInstance;
		}
	}
	[Obsolete("Use S1API.Items.Clothing.ClothingSlot instead")]
	public enum ClothingSlot
	{
		Feet,
		Bottom,
		Waist,
		Top,
		Outerwear,
		Hands,
		Neck,
		Eyes,
		Head,
		Wrist
	}
	public class Equippable
	{
		internal Equippable S1Equippable { get; }

		public bool CanInteractWhenEquipped
		{
			get
			{
				return S1Equippable.CanInteractWhenEquipped;
			}
			set
			{
				S1Equippable.CanInteractWhenEquipped = value;
			}
		}

		public bool CanPickUpWhenEquipped
		{
			get
			{
				return S1Equippable.CanPickUpWhenEquipped;
			}
			set
			{
				S1Equippable.CanPickUpWhenEquipped = value;
			}
		}

		internal Equippable(Equippable equippable)
		{
			S1Equippable = equippable;
		}

		public virtual void Equip(ItemInstance item)
		{
			ItemInstance val = item?.S1ItemInstance;
			if (val != null)
			{
				S1Equippable.Equip(val);
			}
		}

		public virtual void Unequip()
		{
			S1Equippable.Unequip();
		}
	}
	public sealed class EquippableBuilder
	{
		private GameObject? _gameObject;

		private Equippable? _equippable;

		private bool _canInteract = true;

		private bool _canPickup = true;

		private Vector3? _viewmodelPosition;

		private Vector3? _viewmodelRotation;

		private Vector3? _viewmodelScale;

		private string? _avatarEquippableAssetPath;

		private EHand _avatarHand = (EHand)1;

		private string? _avatarAnimationTrigger;

		private readonly List<Action<ItemInstance>> _useCallbacks = new List<Action<ItemInstance>>();

		public EquippableBuilder CreateEquippable<T>(string? name = null) where T : Equippable
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			string text = (string.IsNullOrEmpty(name) ? ("Equippable_" + typeof(T).Name) : name);
			_gameObject = new GameObject(text);
			_equippable = (Equippable?)(object)_gameObject.AddComponent<T>();
			return this;
		}

		public EquippableBuilder CreateBasicEquippable(string? name = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			string text = (string.IsNullOrEmpty(name) ? "Equippable_Basic" : name);
			_gameObject = new GameObject(text);
			_equippable = _gameObject.AddComponent<Equippable>();
			return this;
		}

		public EquippableBuilder CreateViewmodelEquippable(string? name = null)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			string text = (string.IsNullOrEmpty(name) ? "Equippable_Viewmodel" : name);
			_gameObject = new GameObject(text);
			_equippable = (Equippable?)(object)_gameObject.AddComponent<Equippable_Viewmodel>();
			return this;
		}

		public EquippableBuilder WithInteraction(bool canInteract, bool canPickup)
		{
			_canInteract = canInteract;
			_canPickup = canPickup;
			return this;
		}

		public EquippableBuilder WithViewmodelTransform(Vector3 position, Vector3 rotation, Vector3? scale = null)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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)
			_viewmodelPosition = position;
			_viewmodelRotation = rotation;
			_viewmodelScale = (Vector3)(((??)scale) ?? Vector3.one);
			return this;
		}

		public EquippableBuilder WithAvatarEquippable(string assetPath, AvatarHand hand = AvatarHand.Right, string animationTrigger = "RightArm_Hold_ClosedHand")
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			_avatarEquippableAssetPath = assetPath;
			_avatarHand = (EHand)((hand != AvatarHand.Left) ? 1 : 0);
			_avatarAnimationTrigger = animationTrigger;
			return this;
		}

		public EquippableBuilder WithUseCallback(Action<ItemInstance> callback)
		{
			if (callback != null && !_useCallbacks.Contains(callback))
			{
				_useCallbacks.Add(callback);
			}
			return this;
		}

		public Equippable Build()
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_equippable == (Object)null || (Object)(object)_gameObject == (Object)null)
			{
				throw new InvalidOperationException("Cannot build equippable: No equippable component created. Call CreateEquippable<T>(), CreateBasicEquippable(), or CreateViewmodelEquippable() first.");
			}
			_equippable.CanInteractWhenEquipped = _canInteract;
			_equippable.CanPickUpWhenEquipped = _canPickup;
			Equippable? equippable = _equippable;
			Equippable_Viewmodel val = (Equippable_Viewmodel)(object)((equippable is Equippable_Viewmodel) ? equippable : null);
			if (val != null)
			{
				if (_useCallbacks != null && _useCallbacks.Count > 0)
				{
					Vector3 localPosition = (Vector3)(((??)_viewmodelPosition) ?? val.localPosition);
					Vector3 localEulerAngles = (Vector3)(((??)_viewmodelRotation) ?? val.localEulerAngles);
					Vector3 localScale = (Vector3)(((??)_viewmodelScale) ?? val.localScale);
					AvatarEquippable avatarEquippable = val.AvatarEquippable;
					Object.DestroyImmediate((Object)(object)val);
					EquippableUseCallback equippableUseCallback = _gameObject.AddComponent<EquippableUseCallback>();
					foreach (Action<ItemInstance> useCallback in _useCallbacks)
					{
						equippableUseCallback.AddCallback(useCallback);
					}
					((Equippable_Viewmodel)equippableUseCallback).localPosition = localPosition;
					((Equippable_Viewmodel)equippableUseCallback).localEulerAngles = localEulerAngles;
					((Equippable_Viewmodel)equippableUseCallback).localScale = localScale;
					((Equippable_Viewmodel)equippableUseCallback).AvatarEquippable = avatarEquippable;
					_equippable = (Equippable?)(object)equippableUseCallback;
					val = (Equippable_Viewmodel)(object)equippableUseCallback;
				}
				if (_viewmodelPosition.HasValue)
				{
					val.localPosition = _viewmodelPosition.Value;
				}
				if (_viewmodelRotation.HasValue)
				{
					val.localEulerAngles = _viewmodelRotation.Value;
				}
				if (_viewmodelScale.HasValue)
				{
					val.localScale = _viewmodelScale.Value;
				}
			}
			ApplyAvatarPresentation();
			ApplyInteractionSettings(_equippable);
			RuntimePrefabCache.Store(_gameObject);
			return new Equippable(_equippable);
		}

		internal Equippable BuildInternal()
		{
			if ((Object)(object)_equippable == (Object)null || (Object)(object)_gameObject == (Object)null)
			{
				throw new InvalidOperationException("Cannot build equippable: No equippable component created. Call CreateEquippable<T>() or CreateBasicEquippable() first.");
			}
			ApplyAvatarPresentation();
			ApplyInteractionSettings(_equippable);
			RuntimePrefabCache.Store(_gameObject);
			return _equippable;
		}

		private void ApplyAvatarPresentation()
		{
			//IL_00ba: 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_005a: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			if (!((Object)(object)_gameObject == (Object)null) && !((Object)(object)_equippable == (Object)null) && !string.IsNullOrEmpty(_avatarEquippableAssetPath))
			{
				AvatarEquippable val = _gameObject.GetComponentInChildren<AvatarEquippable>(true);
				if ((Object)(object)val == (Object)null)
				{
					GameObject val2 = new GameObject("AvatarEquippable");
					val2.transform.SetParent(_gameObject.transform, false);
					val = val2.AddComponent<AvatarEquippable>();
					GameObject val3 = new GameObject("AlignmentPoint");
					val3.transform.SetParent(val2.transform, false);
					val.AlignmentPoint = val3.transform;
				}
				val.AssetPath = _avatarEquippableAssetPath;
				val.Hand = _avatarHand;
				val.AnimationTrigger = _avatarAnimationTrigger;
				Equippable? equippable = _equippable;
				Equippable_Viewmodel val4 = (Equippable_Viewmodel)(object)((equippable is Equippable_Viewmodel) ? equippable : null);
				if (val4 != null)
				{
					val4.AvatarEquippable = val;
				}
			}
		}

		private void ApplyInteractionSettings(Equippable equippable)
		{
			if (!((Object)(object)equippable == (Object)null))
			{
				try
				{
					equippable.CanInteractWhenEquipped = _canInteract;
				}
				catch
				{
				}
				try
				{
					equippable.CanPickUpWhenEquipped = _canPickup;
				}
				catch
				{
				}
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(equippable, "CanInteractWhenEquipped", _canInteract);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(equippable, "canInteractWhenEquipped", _canInteract);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(equippable, "CanPickUpWhenEquipped", _canPickup);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(equippable, "canPickUpWhenEquipped", _canPickup);
			}
		}
	}
	public enum AvatarHand
	{
		Left,
		Right
	}
	public enum ItemCategory
	{
		Product,
		Packaging,
		Growing,
		Tools,
		Furniture,
		Lighting,
		Cash,
		Consumable,
		Equipment,
		Ingredient,
		Decoration,
		Clothing
	}
	[Obsolete("Use S1API.Items.Storable.ItemCreator instead")]
	public static class ItemCreator
	{
		public static StorableItemDefinitionBuilder CreateBuilder()
		{
			return new StorableItemDefinitionBuilder();
		}

		public static StorableItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an StorableItemDefinition", "sourceItemId");
			}
			return new StorableItemDefinitionBuilder(result);
		}

		public static StorableItemDefinitionBuilder CloneFrom(StorableItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source storable item definition cannot be null");
			}
			return new StorableItemDefinitionBuilder(source.S1StorableItemDefinition);
		}

		public static StorableItemDefinition CreateItem(string id, string name, string description, ItemCategory category, int stackLimit = 10, float basePurchasePrice = 10f, float resellMultiplier = 0.5f, LegalStatus legalStatus = LegalStatus.Legal, bool requiresLevelToPurchase = false, FullRank? requiredRank = null, Sprite? icon = null, Equippable? equippable = null)
		{
			StorableItemDefinitionBuilder storableItemDefinitionBuilder = new StorableItemDefinitionBuilder().WithBasicInfo(id, name, description, category).WithStackLimit(stackLimit).WithPricing(basePurchasePrice, resellMultiplier)
				.WithRequiredRank(requiresLevelToPurchase ? requiredRank : ((FullRank?)null))
				.WithLegalStatus(legalStatus);
			if ((Object)(object)icon != (Object)null)
			{
				storableItemDefinitionBuilder.WithIcon(icon);
			}
			if (equippable != null)
			{
				storableItemDefinitionBuilder.WithEquippable(equippable);
			}
			return storableItemDefinitionBuilder.Build();
		}

		public static EquippableBuilder CreateEquippableBuilder()
		{
			return new EquippableBuilder();
		}
	}
	public class ItemDefinition : IGUIDReference
	{
		internal ItemDefinition S1ItemDefinition { get; }

		public string ID
		{
			get
			{
				return ((BaseItemDefinition)S1ItemDefinition).ID;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).ID = value;
			}
		}

		public string Name
		{
			get
			{
				return ((BaseItemDefinition)S1ItemDefinition).Name;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).Name = value;
			}
		}

		public string Description
		{
			get
			{
				return ((BaseItemDefinition)S1ItemDefinition).Description;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).Description = value;
			}
		}

		public int StackLimit
		{
			get
			{
				return ((BaseItemDefinition)S1ItemDefinition).StackLimit;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).StackLimit = value;
			}
		}

		public ItemCategory Category
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ItemCategory)((BaseItemDefinition)S1ItemDefinition).Category;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).Category = (EItemCategory)value;
			}
		}

		public Sprite Icon
		{
			get
			{
				return ((BaseItemDefinition)S1ItemDefinition).Icon;
			}
			set
			{
				ItemIconRuntime.SetIcon(S1ItemDefinition, value);
			}
		}

		public bool AvailableInDemo
		{
			get
			{
				return S1ItemDefinition.AvailableInDemo;
			}
			set
			{
				S1ItemDefinition.AvailableInDemo = value;
			}
		}

		public LegalStatus LegalStatus
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (LegalStatus)((BaseItemDefinition)S1ItemDefinition).legalStatus;
			}
			set
			{
				((BaseItemDefinition)S1ItemDefinition).legalStatus = (ELegalStatus)value;
			}
		}

		public string GUID => ID;

		internal ItemDefinition(ItemDefinition definition)
		{
			S1ItemDefinition = definition;
		}

		public virtual ItemInstance CreateInstance(int quantity = 1)
		{
			ItemInstance defaultInstance = S1ItemDefinition.GetDefaultInstance(quantity);
			return new ItemInstance(defaultInstance);
		}

		public override bool Equals(object? obj)
		{
			return obj is ItemDefinition itemDefinition && (Object)(object)S1ItemDefinition == (Object)(object)itemDefinition.S1ItemDefinition;
		}

		public override int GetHashCode()
		{
			return ((Object)S1ItemDefinition).GetHashCode();
		}

		public static bool operator ==(ItemDefinition? a, ItemDefinition? b)
		{
			if ((object)a == b)
			{
				return true;
			}
			if ((object)a == null || (object)b == null)
			{
				return false;
			}
			return a.S1ItemDefinition == b.S1ItemDefinition;
		}

		public static bool operator !=(ItemDefinition? a, ItemDefinition? b)
		{
			if ((object)a == b)
			{
				return false;
			}
			if ((object)a == null || (object)b == null)
			{
				return true;
			}
			return a.S1ItemDefinition != b.S1ItemDefinition;
		}
	}
	public enum LegalStatus
	{
		Legal,
		Illegal
	}
	public class ItemInstance
	{
		internal readonly ItemInstance S1ItemInstance;

		public ItemDefinition Definition => new ItemDefinition(S1ItemInstance.Definition);

		public int Quantity
		{
			get
			{
				return ((BaseItemInstance)S1ItemInstance).Quantity;
			}
			set
			{
				((BaseItemInstance)S1ItemInstance).SetQuantity(value);
			}
		}

		public bool IsStackable => Definition.StackLimit > 1;

		internal ItemInstance(ItemInstance itemInstance)
		{
			S1ItemInstance = itemInstance;
		}
	}
	public static class ItemManager
	{
		[Obsolete("Use S1API.Items.ItemManager.GetDefinition instead.")]
		public static ItemDefinition? GetItemDefinition(string itemID)
		{
			ItemDefinition item = Registry.GetItem(itemID);
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if (CrossType.Is<ProductDefinition>((object)item, out ProductDefinition result))
			{
				return ProductDefinitionWrapper.Wrap(result);
			}
			if (CrossType.Is<CashDefinition>((object)item, out CashDefinition result2))
			{
				return new CashDefinition(result2);
			}
			if (CrossType.Is<ClothingDefinition>((object)item, out ClothingDefinition result3))
			{
				return new ClothingItemDefinition(result3);
			}
			if (CrossType.Is<BuildableItemDefinition>((object)item, out BuildableItemDefinition result4))
			{
				return new BuildableItemDefinition(result4);
			}
			if (CrossType.Is<PackagingDefinition>((object)item, out PackagingDefinition result5))
			{
				return new PackagingDefinition((ItemDefinition)(object)result5);
			}
			if (CrossType.Is<AdditiveDefinition>((object)item, out AdditiveDefinition result6))
			{
				return new AdditiveDefinition(result6);
			}
			if (CrossType.Is<QualityItemDefinition>((object)item, out QualityItemDefinition result7))
			{
				return new QualityItemDefinition(result7);
			}
			if (CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result8))
			{
				return new StorableItemDefinition(result8);
			}
			return new ItemDefinition(item);
		}

		public static ItemDefinition? GetDefinition(string itemID)
		{
			ItemDefinition item = Registry.GetItem(itemID);
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if (CrossType.Is<ProductDefinition>((object)item, out ProductDefinition result))
			{
				return ProductDefinitionWrapper.Wrap(result);
			}
			if (CrossType.Is<CashDefinition>((object)item, out CashDefinition result2))
			{
				return new CashDefinition(result2);
			}
			if (CrossType.Is<ClothingDefinition>((object)item, out ClothingDefinition result3))
			{
				return new global::S1API.Items.Clothing.ClothingItemDefinition(result3);
			}
			if (CrossType.Is<BuildableItemDefinition>((object)item, out BuildableItemDefinition result4))
			{
				return new global::S1API.Items.Buildable.BuildableItemDefinition(result4);
			}
			if (CrossType.Is<PackagingDefinition>((object)item, out PackagingDefinition result5))
			{
				return new PackagingDefinition((ItemDefinition)(object)result5);
			}
			if (CrossType.Is<AdditiveDefinition>((object)item, out AdditiveDefinition result6))
			{
				return new global::S1API.Items.Additive.AdditiveDefinition(result6);
			}
			if (CrossType.Is<QualityItemDefinition>((object)item, out QualityItemDefinition result7))
			{
				return new global::S1API.Items.Quality.QualityItemDefinition(result7);
			}
			if (CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result8))
			{
				return new global::S1API.Items.Storable.StorableItemDefinition(result8);
			}
			return new ItemDefinition(item);
		}

		public static void RegisterItem(ItemDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition", "Cannot register null item definition");
			}
			Singleton<Registry>.Instance.AddToRegistry(definition.S1ItemDefinition);
		}

		public static bool IsItemRegistered(string itemID)
		{
			if (string.IsNullOrWhiteSpace(itemID) || (Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				return false;
			}
			return Registry.ItemExists(itemID);
		}

		public static bool EnsureItemRegistered(ItemDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition", "Cannot register null item definition");
			}
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				return false;
			}
			if (IsItemRegistered(definition.ID))
			{
				return true;
			}
			Singleton<Registry>.Instance.AddToRegistry(definition.S1ItemDefinition);
			return IsItemRegistered(definition.ID);
		}

		public static bool PreserveRuntimeItem(ItemDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition", "Cannot preserve a null item definition");
			}
			return RemoveFromRuntimeCleanupQueue(definition.S1ItemDefinition, definition.ID);
		}

		public static bool UnregisterItem(string itemID)
		{
			if (string.IsNullOrWhiteSpace(itemID) || (Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				return false;
			}
			ItemDefinition definition = GetDefinition(itemID);
			if (definition == null)
			{
				return false;
			}
			RemoveFromRuntimeCleanupQueue(definition.S1ItemDefinition, definition.ID);
			Singleton<Registry>.Instance.RemoveFromRegistry(definition.S1ItemDefinition);
			bool flag = GetDefinition(itemID) == null;
			if (flag)
			{
				RuntimeItemDefinitionRegistry.Forget(itemID);
			}
			return flag;
		}

		public static List<ItemDefinition> GetAllItemDefinitions()
		{
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				return new List<ItemDefinition>();
			}
			List<ItemDefinition> allItems = Singleton<Registry>.Instance.GetAllItems();
			if (allItems == null)
			{
				return new List<ItemDefinition>();
			}
			List<ItemDefinition> list = new List<ItemDefinition>();
			Enumerator<ItemDefinition> enumerator = allItems.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemDefinition current = enumerator.Current;
				if ((Object)(object)current == (Object)null)
				{
					continue;
				}
				string text = null;
				try
				{
					text = ((BaseItemDefinition)current).ID;
				}
				catch
				{
					continue;
				}
				if (!string.IsNullOrEmpty(text))
				{
					ItemDefinition definition = GetDefinition(text);
					if (definition != null)
					{
						list.Add(definition);
					}
				}
			}
			return list;
		}

		private static bool RemoveFromRuntimeCleanupQueue(ItemDefinition nativeDefinition, string itemId)
		{
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null || (Object)(object)nativeDefinition == (Object)null || string.IsNullOrWhiteSpace(itemId))
			{
				return false;
			}
			FieldInfo field = typeof(Registry).GetField("ItemsAddedAtRuntime", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return false;
			}
			object value = field.GetValue(Singleton<Registry>.Instance);
			if (value == null)
			{
				return false;
			}
			Type type = value.GetType();
			PropertyInfo property = type.GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
			PropertyInfo property2 = type.GetProperty("Item", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method = type.GetMethod("RemoveAt", BindingFlags.Instance | BindingFlags.Public);
			if (property == null || property2 == null || method == null)
			{
				return false;
			}
			int num = Convert.ToInt32(property.GetValue(value));
			bool result = false;
			for (int num2 = num - 1; num2 >= 0; num2--)
			{
				object value2 = property2.GetValue(value, new object[1] { num2 });
				if (value2 != null)
				{
					Type type2 = value2.GetType();
					FieldInfo field2 = type2.GetField("ID", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field3 = type2.GetField("Definition", BindingFlags.Instance | BindingFlags.Public);
					string a = field2?.GetValue(value2) as string;
					object obj = field3?.GetValue(value2);
					if (string.Equals(a, itemId, StringComparison.OrdinalIgnoreCase) || obj == nativeDefinition)
					{
						method.Invoke(value, new object[1] { num2 });
						result = true;
					}
				}
			}
			return result;
		}
	}
	public class ItemSlotInstance
	{
		internal readonly ItemSlot S1ItemSlot;

		public int Quantity => S1ItemSlot.Quantity;

		public ItemInstance? ItemInstance
		{
			get
			{
				if (CrossType.Is<ProductItemInstance>((object)S1ItemSlot.ItemInstance, out ProductItemInstance result))
				{
					return new ProductInstance(result);
				}
				if (CrossType.Is<CashInstance>((object)S1ItemSlot.ItemInstance, out CashInstance result2))
				{
					return new CashInstance((ItemInstance)(object)result2);
				}
				if (CrossType.Is<ItemInstance>((object)S1ItemSlot.ItemInstance, out ItemInstance result3))
				{
					return new ItemInstance(result3);
				}
				return null;
			}
		}

		internal ItemSlotInstance(ItemSlot itemSlot)
		{
			S1ItemSlot = itemSlot;
		}

		public void AddQuantity(int amount)
		{
			S1ItemSlot.ChangeQuantity(amount, false);
		}
	}
	[Obsolete("Use S1API.Items.Quality.QualityItemCreator instead")]
	public class QualityItemCreator
	{
		public static QualityItemDefinitionBuilder CreateBuilder()
		{
			return new QualityItemDefinitionBuilder();
		}

		public static QualityItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<QualityItemDefinition>((object)item, out QualityItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an QualityItemDefinition", "sourceItemId");
			}
			return new QualityItemDefinitionBuilder(result);
		}

		public static QualityItemDefinitionBuilder CloneFrom(QualityItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source storable item definition cannot be null");
			}
			return new QualityItemDefinitionBuilder(source.S1QualityDefinition);
		}
	}
	[Obsolete("Use S1API.Items.Quality.QualityItemDefinition instead")]
	public class QualityItemDefinition : StorableItemDefinition
	{
		internal QualityItemDefinition S1QualityDefinition { get; }

		public global::S1API.Products.Quality DefaultQuality
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (global::S1API.Products.Quality)S1QualityDefinition.DefaultQuality;
			}
			set
			{
				S1QualityDefinition.DefaultQuality = (EQuality)value;
			}
		}

		internal QualityItemDefinition(QualityItemDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1QualityDefinition = definition;
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return CreateInstance(quantity, DefaultQuality);
		}

		public QualityItemInstance CreateInstance(global::S1API.Products.Quality quality)
		{
			return CreateInstance(1, quality);
		}

		public QualityItemInstance CreateInstance(int quantity, global::S1API.Products.Quality quality)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new QualityItemInstance(new QualityItemInstance((ItemDefinition)(object)S1QualityDefinition, quantity, (EQuality)quality));
		}
	}
	[Obsolete("Use S1API.Items.Quality.QualityItemDefinitionBuilder instead")]
	public sealed class QualityItemDefinitionBuilder
	{
		private static readonly Log Logger = new Log("QualityItemDefinitionBuilder");

		private static readonly object StationItemGate = new object();

		private static readonly Dictionary<int, StationItem> StationItemCache = new Dictionary<int, StationItem>();

		private static readonly HashSet<int> WarnedStationItemModuleMissing = new HashSet<int>();

		private static GameObject? _stationItemRoot;

		private readonly QualityItemDefinition _definition;

		private readonly GameObject _storedItemPlaceholder;

		private bool _hasCustomStoredItem;

		internal QualityItemDefinitionBuilder()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<QualityItemDefinition>();
			((BaseItemDefinition)_definition).StackLimit = 10;
			((StorableItemDefinition)_definition).BasePurchasePrice = 10f;
			((StorableItemDefinition)_definition).ResellMultiplier = 0.5f;
			((BaseItemDefinition)_definition).Category = (EItemCategory)3;
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)_definition).AvailableInDemo = true;
			((BaseItemDefinition)_definition).UsableInFilters = true;
			((StorableItemDefinition)_definition).RequiresLevelToPurchase = false;
			((StorableItemDefinition)_definition).RequiredRank = new FullRank((ERank)0, 1);
			_definition.DefaultQuality = (EQuality)2;
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			((StorableItemDefinition)_definition).StoredItem = storedItem;
		}

		internal QualityItemDefinitionBuilder(QualityItemDefinition source)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<QualityItemDefinition>();
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			((StorableItemDefinition)_definition).StoredItem = storedItem;
			CopyPropertiesFrom(source);
		}

		public QualityItemDefinitionBuilder WithBasicInfo(string id, string name, string description, ItemCategory category)
		{
			((BaseItemDefinition)_definition).ID = id;
			((BaseItemDefinition)_definition).Name = name;
			((BaseItemDefinition)_definition).Description = description;
			((BaseItemDefinition)_definition).Category = (EItemCategory)category;
			string text = (string.IsNullOrEmpty(name) ? id : name);
			if (!string.IsNullOrEmpty(text))
			{
				((Object)_definition).name = text;
				if ((Object)(object)_storedItemPlaceholder != (Object)null && !_hasCustomStoredItem)
				{
					((Object)_storedItemPlaceholder).name = text + "_StoredItem";
				}
			}
			return this;
		}

		public QualityItemDefinitionBuilder WithStackLimit(int limit)
		{
			((BaseItemDefinition)_definition).StackLimit = Mathf.Clamp(limit, 1, 999);
			return this;
		}

		public QualityItemDefinitionBuilder WithIcon(Sprite icon)
		{
			((BaseItemDefinition)_definition).Icon = icon;
			return this;
		}

		public QualityItemDefinitionBuilder WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			((StorableItemDefinition)_definition).BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			((StorableItemDefinition)_definition).ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return this;
		}

		public QualityItemDefinitionBuilder WithLegalStatus(LegalStatus status)
		{
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)status;
			return this;
		}

		public QualityItemDefinitionBuilder WithEquippable(Equippable equippable)
		{
			if (equippable != null)
			{
				((ItemDefinition)_definition).Equippable = equippable.S1Equippable;
			}
			return this;
		}

		public QualityItemDefinitionBuilder WithStoredItem(GameObject storedItemPrefab)
		{
			if ((Object)(object)storedItemPrefab == (Object)null)
			{
				return this;
			}
			StoredItem storedItem = storedItemPrefab.GetComponent<StoredItem>() ?? storedItemPrefab.AddComponent<StoredItem>();
			((StorableItemDefinition)_definition).StoredItem = storedItem;
			_hasCustomStoredItem = true;
			return this;
		}

		public QualityItemDefinitionBuilder WithStationItem(GameObject stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				throw new ArgumentNullException("stationItemPrefab");
			}
			StationItem component = stationItemPrefab.GetComponent<StationItem>();
			if ((Object)(object)component == (Object)null)
			{
				throw new ArgumentException("Station item prefab must have a StationItem component.", "stationItemPrefab");
			}
			StationItem orCreateStationItemPrefab = GetOrCreateStationItemPrefab(component);
			((StorableItemDefinition)_definition).StationItem = orCreateStationItemPrefab;
			WarnIfStationItemMissingChemistryModules(orCreateStationItemPrefab);
			return this;
		}

		public QualityItemDefinitionBuilder WithoutStationItem()
		{
			((StorableItemDefinition)_definition).StationItem = null;
			return this;
		}

		public QualityItemDefinitionBuilder WithDemoAvailability(bool available)
		{
			((ItemDefinition)_definition).AvailableInDemo = available;
			return this;
		}

		public QualityItemDefinitionBuilder WithRequiredRank(FullRank? rank)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!rank.HasValue)
			{
				((StorableItemDefinition)_definition).RequiresLevelToPurchase = false;
				return this;
			}
			((StorableItemDefinition)_definition).RequiredRank = rank.Value.ToNative();
			((StorableItemDefinition)_definition).RequiresLevelToPurchase = true;
			return this;
		}

		public QualityItemDefinitionBuilder WithDefaultQuality(global::S1API.Products.Quality quality)
		{
			_definition.DefaultQuality = (EQuality)quality;
			return this;
		}

		public QualityItemDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)_definition).ID))
			{
				throw new ArgumentException("Item ID cannot be null, empty, or whitespace.", "ID");
			}
			if (!_hasCustomStoredItem && (Object)(object)((StorableItemDefinition)_definition).StoredItem != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)_definition).Name) && (Object)(object)_storedItemPlaceholder != (Object)null)
			{
				((Object)_storedItemPlaceholder).name = ((BaseItemDefinition)_definition).Name + "_StoredItem";
			}
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)_definition);
			return new QualityItemDefinition(_definition);
		}

		internal QualityItemDefinition BuildInternal()
		{
			return _definition;
		}

		private void CopyPropertiesFrom(QualityItemDefinition source)
		{
			//IL_003c: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null))
			{
				((BaseItemDefinition)_definition).Name = ((BaseItemDefinition)source).Name;
				((BaseItemDefinition)_definition).Description = ((BaseItemDefinition)source).Description;
				((BaseItemDefinition)_definition).Category = ((BaseItemDefinition)source).Category;
				((BaseItemDefinition)_definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
				((ItemDefinition)_definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
				((BaseItemDefinition)_definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
				((BaseItemDefinition)_definition).Icon = ((BaseItemDefinition)source).Icon;
				((BaseItemDefinition)_definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
				((StorableItemDefinition)_definition).PickpocketDifficultyMultiplier = ((StorableItemDefinition)source).PickpocketDifficultyMultiplier;
				((StorableItemDefinition)_definition).CombatUtility = ((StorableItemDefinition)source).CombatUtility;
				((StorableItemDefinition)_definition).BasePurchasePrice = ((StorableItemDefinition)source).BasePurchasePrice;
				((StorableItemDefinition)_definition).ResellMultiplier = ((StorableItemDefinition)source).ResellMultiplier;
				((StorableItemDefinition)_definition).ShopCategories = ((StorableItemDefinition)source).ShopCategories;
				((StorableItemDefinition)_definition).RequiresLevelToPurchase = ((StorableItemDefinition)source).RequiresLevelToPurchase;
				((StorableItemDefinition)_definition).RequiredRank = ((StorableItemDefinition)source).RequiredRank;
				((StorableItemDefinition)_definition).StoredItem = (((Object)(object)((StorableItemDefinition)source).StoredItem != (Object)null) ? ((StorableItemDefinition)source).StoredItem : ((StorableItemDefinition)_definition).StoredItem);
				((StorableItemDefinition)_definition).StationItem = ((StorableItemDefinition)source).StationItem;
				((ItemDefinition)_definition).Equippable = ((ItemDefinition)source).Equippable;
				_definition.DefaultQuality = source.DefaultQuality;
				((ItemDefinition)_definition).CustomItemUI = ((ItemDefinition)source).CustomItemUI;
			}
		}

		private static StationItem GetOrCreateStationItemPrefab(StationItem stationItemPrefab)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (StationItemCache.TryGetValue(instanceID, out StationItem value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				GameObject stationItemRoot = GetStationItemRoot();
				StationItem val = Object.Instantiate<StationItem>(stationItemPrefab, stationItemRoot.transform);
				((Object)((Component)val).gameObject).hideFlags = (HideFlags)61;
				((Object)val).name = ((Object)stationItemPrefab).name + "_S1API_StationItem";
				((Component)val).transform.position = stationItemRoot.transform.position;
				StationItemCache[instanceID] = val;
				return val;
			}
		}

		private static GameObject GetStationItemRoot()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_stationItemRoot != (Object)null)
			{
				return _stationItemRoot;
			}
			lock (StationItemGate)
			{
				if ((Object)(object)_stationItemRoot != (Object)null)
				{
					return _stationItemRoot;
				}
				GameObject val = new GameObject("S1API_StationItemCache");
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)val);
				val.transform.position = new Vector3(0f, -10000f, 0f);
				_stationItemRoot = val;
				return val;
			}
		}

		private static void WarnIfStationItemMissingChemistryModules(StationItem stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (!WarnedStationItemModuleMissing.Add(instanceID))
				{
					return;
				}
			}
			try
			{
				bool flag = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<IngredientModule>(true) != (Object)null;
				bool flag2 = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<PourableModule>(true) != (Object)null;
				if (!(flag || flag2))
				{
					Logger.Warning("[S1API] StationItem prefab '" + ((Object)stationItemPrefab).name + "' does not contain an IngredientModule or PourableModule. Chemistry station tasks may log errors or skip this ingredient at runtime.");
				}
			}
			catch
			{
			}
		}
	}
	[Obsolete("Use S1API.Items.Quality.QualityItemInstance instead")]
	public class QualityItemInstance : ItemInstance
	{
		internal readonly QualityItemInstance S1QualityInstance;

		public global::S1API.Products.Quality Quality
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (global::S1API.Products.Quality)S1QualityInstance.Quality;
			}
			set
			{
				S1QualityInstance.Quality = (EQuality)value;
			}
		}

		public new QualityItemDefinition Definition => new QualityItemDefinition(CrossType.As<QualityItemDefinition>((object)((ItemInstance)S1QualityInstance).Definition));

		internal QualityItemInstance(QualityItemInstance itemInstance)
			: base((ItemInstance)(object)itemInstance)
		{
			S1QualityInstance = itemInstance;
		}
	}
	[Obsolete("Use S1API.Items.Storable.StorableItemDefinition instead")]
	public class StorableItemDefinition : ItemDefinition
	{
		internal StorableItemDefinition S1StorableItemDefinition { get; }

		public float BasePurchasePrice
		{
			get
			{
				return S1StorableItemDefinition.BasePurchasePrice;
			}
			set
			{
				S1StorableItemDefinition.BasePurchasePrice = value;
			}
		}

		public float ResellMultiplier
		{
			get
			{
				return S1StorableItemDefinition.ResellMultiplier;
			}
			set
			{
				S1StorableItemDefinition.ResellMultiplier = value;
			}
		}

		public bool IsUnlocked => S1StorableItemDefinition.IsUnlocked;

		public bool RequiresLevelToPurchase
		{
			get
			{
				return S1StorableItemDefinition.RequiresLevelToPurchase;
			}
			set
			{
				S1StorableItemDefinition.RequiresLevelToPurchase = value;
			}
		}

		public FullRank RequiredRank
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return FullRank.FromNative(S1StorableItemDefinition.RequiredRank);
			}
			set
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				S1StorableItemDefinition.RequiredRank = value.ToNative();
			}
		}

		public bool HasStationItem => (Object)(object)S1StorableItemDefinition.StationItem != (Object)null;

		public GameObject? StationItemPrefab
		{
			get
			{
				StationItem stationItem = S1StorableItemDefinition.StationItem;
				return (stationItem != null) ? ((Component)stationItem).gameObject : null;
			}
		}

		internal StorableItemDefinition(StorableItemDefinition definition)
			: base((ItemDefinition)(object)definition)
		{
			S1StorableItemDefinition = definition;
		}
	}
	[Obsolete("Use S1API.Items.Storable.StorableItemDefinitionBuilder instead")]
	public sealed class StorableItemDefinitionBuilder
	{
		private static readonly Log Logger = new Log("StorableItemDefinitionBuilder");

		private static readonly object StationItemGate = new object();

		private static readonly Dictionary<int, StationItem> StationItemCache = new Dictionary<int, StationItem>();

		private static readonly HashSet<int> WarnedStationItemModuleMissing = new HashSet<int>();

		private static GameObject? _stationItemRoot;

		private readonly StorableItemDefinition _definition;

		private readonly GameObject _storedItemPlaceholder;

		private bool _hasCustomStoredItem;

		internal StorableItemDefinitionBuilder()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<StorableItemDefinition>();
			((BaseItemDefinition)_definition).StackLimit = 10;
			_definition.BasePurchasePrice = 10f;
			_definition.ResellMultiplier = 0.5f;
			((BaseItemDefinition)_definition).Category = (EItemCategory)3;
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)_definition).AvailableInDemo = true;
			((BaseItemDefinition)_definition).UsableInFilters = true;
			_definition.RequiresLevelToPurchase = false;
			_definition.RequiredRank = new FullRank((ERank)0, 1);
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			_definition.StoredItem = storedItem;
		}

		internal StorableItemDefinitionBuilder(StorableItemDefinition source)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			_definition = ScriptableObject.CreateInstance<StorableItemDefinition>();
			_storedItemPlaceholder = new GameObject("S1API_DefaultStoredItem");
			_storedItemPlaceholder.SetActive(false);
			((Object)_storedItemPlaceholder).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)_storedItemPlaceholder);
			StoredItem storedItem = _storedItemPlaceholder.AddComponent<StoredItem>();
			_definition.StoredItem = storedItem;
			CopyPropertiesFrom(source);
		}

		public StorableItemDefinitionBuilder WithBasicInfo(string id, string name, string description, ItemCategory category)
		{
			((BaseItemDefinition)_definition).ID = id;
			((BaseItemDefinition)_definition).Name = name;
			((BaseItemDefinition)_definition).Description = description;
			((BaseItemDefinition)_definition).Category = (EItemCategory)category;
			string text = (string.IsNullOrEmpty(name) ? id : name);
			if (!string.IsNullOrEmpty(text))
			{
				((Object)_definition).name = text;
				if ((Object)(object)_storedItemPlaceholder != (Object)null && !_hasCustomStoredItem)
				{
					((Object)_storedItemPlaceholder).name = text + "_StoredItem";
				}
			}
			return this;
		}

		public StorableItemDefinitionBuilder WithStackLimit(int limit)
		{
			((BaseItemDefinition)_definition).StackLimit = Mathf.Clamp(limit, 1, 999);
			return this;
		}

		public StorableItemDefinitionBuilder WithIcon(Sprite icon)
		{
			((BaseItemDefinition)_definition).Icon = icon;
			return this;
		}

		public StorableItemDefinitionBuilder WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			_definition.BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			_definition.ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return this;
		}

		public StorableItemDefinitionBuilder WithLegalStatus(LegalStatus status)
		{
			((BaseItemDefinition)_definition).legalStatus = (ELegalStatus)status;
			return this;
		}

		public StorableItemDefinitionBuilder WithEquippable(Equippable equippable)
		{
			if (equippable != null)
			{
				((ItemDefinition)_definition).Equippable = equippable.S1Equippable;
			}
			return this;
		}

		public StorableItemDefinitionBuilder WithStoredItem(GameObject storedItemPrefab)
		{
			if ((Object)(object)storedItemPrefab == (Object)null)
			{
				return this;
			}
			StoredItem storedItem = storedItemPrefab.GetComponent<StoredItem>() ?? storedItemPrefab.AddComponent<StoredItem>();
			_definition.StoredItem = storedItem;
			_hasCustomStoredItem = true;
			return this;
		}

		public StorableItemDefinitionBuilder WithStationItem(GameObject stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				throw new ArgumentNullException("stationItemPrefab");
			}
			StationItem component = stationItemPrefab.GetComponent<StationItem>();
			if ((Object)(object)component == (Object)null)
			{
				throw new ArgumentException("Station item prefab must have a StationItem component.", "stationItemPrefab");
			}
			StationItem orCreateStationItemPrefab = GetOrCreateStationItemPrefab(component);
			_definition.StationItem = orCreateStationItemPrefab;
			WarnIfStationItemMissingChemistryModules(orCreateStationItemPrefab);
			return this;
		}

		public StorableItemDefinitionBuilder WithoutStationItem()
		{
			_definition.StationItem = null;
			return this;
		}

		public StorableItemDefinitionBuilder WithDemoAvailability(bool available)
		{
			((ItemDefinition)_definition).AvailableInDemo = available;
			return this;
		}

		public StorableItemDefinitionBuilder WithRequiredRank(FullRank? rank)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!rank.HasValue)
			{
				_definition.RequiresLevelToPurchase = false;
				return this;
			}
			_definition.RequiredRank = rank.Value.ToNative();
			_definition.RequiresLevelToPurchase = true;
			return this;
		}

		public StorableItemDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)_definition).ID))
			{
				throw new ArgumentException("Item ID cannot be null, empty, or whitespace.", "ID");
			}
			if (!_hasCustomStoredItem && (Object)(object)_definition.StoredItem != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)_definition).Name) && (Object)(object)_storedItemPlaceholder != (Object)null)
			{
				((Object)_storedItemPlaceholder).name = ((BaseItemDefinition)_definition).Name + "_StoredItem";
			}
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)_definition);
			return new StorableItemDefinition(_definition);
		}

		internal StorableItemDefinition BuildInternal()
		{
			return _definition;
		}

		private void CopyPropertiesFrom(StorableItemDefinition source)
		{
			//IL_003c: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null))
			{
				((BaseItemDefinition)_definition).Name = ((BaseItemDefinition)source).Name;
				((BaseItemDefinition)_definition).Description = ((BaseItemDefinition)source).Description;
				((BaseItemDefinition)_definition).Category = ((BaseItemDefinition)source).Category;
				((BaseItemDefinition)_definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
				((ItemDefinition)_definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
				((BaseItemDefinition)_definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
				((BaseItemDefinition)_definition).Icon = ((BaseItemDefinition)source).Icon;
				((BaseItemDefinition)_definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
				_definition.PickpocketDifficultyMultiplier = source.PickpocketDifficultyMultiplier;
				_definition.CombatUtility = source.CombatUtility;
				_definition.BasePurchasePrice = source.BasePurchasePrice;
				_definition.ResellMultiplier = source.ResellMultiplier;
				_definition.ShopCategories = source.ShopCategories;
				_definition.RequiresLevelToPurchase = source.RequiresLevelToPurchase;
				_definition.RequiredRank = source.RequiredRank;
				_definition.StoredItem = (((Object)(object)source.StoredItem != (Object)null) ? source.StoredItem : _definition.StoredItem);
				_definition.StationItem = source.StationItem;
				((ItemDefinition)_definition).Equippable = ((ItemDefinition)source).Equippable;
			}
		}

		private static StationItem GetOrCreateStationItemPrefab(StationItem stationItemPrefab)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (StationItemCache.TryGetValue(instanceID, out StationItem value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				GameObject stationItemRoot = GetStationItemRoot();
				StationItem val = Object.Instantiate<StationItem>(stationItemPrefab, stationItemRoot.transform);
				((Object)((Component)val).gameObject).hideFlags = (HideFlags)61;
				((Object)val).name = ((Object)stationItemPrefab).name + "_S1API_StationItem";
				((Component)val).transform.position = stationItemRoot.transform.position;
				StationItemCache[instanceID] = val;
				return val;
			}
		}

		private static GameObject GetStationItemRoot()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_stationItemRoot != (Object)null)
			{
				return _stationItemRoot;
			}
			lock (StationItemGate)
			{
				if ((Object)(object)_stationItemRoot != (Object)null)
				{
					return _stationItemRoot;
				}
				GameObject val = new GameObject("S1API_StationItemCache");
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)val);
				val.transform.position = new Vector3(0f, -10000f, 0f);
				_stationItemRoot = val;
				return val;
			}
		}

		private static void WarnIfStationItemMissingChemistryModules(StationItem stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (!WarnedStationItemModuleMissing.Add(instanceID))
				{
					return;
				}
			}
			try
			{
				bool flag = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<IngredientModule>(true) != (Object)null;
				bool flag2 = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<PourableModule>(true) != (Object)null;
				if (!(flag || flag2))
				{
					Logger.Warning("[S1API] StationItem prefab '" + ((Object)stationItemPrefab).name + "' does not contain an IngredientModule or PourableModule. Chemistry station tasks may log errors or skip this ingredient at runtime.");
				}
			}
			catch
			{
			}
		}
	}
}
namespace S1API.Items.Storable
{
	public static class ItemCreator
	{
		public static StorableItemDefinitionBuilder CreateBuilder()
		{
			return new StorableItemDefinitionBuilder();
		}

		public static StorableItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an StorableItemDefinition", "sourceItemId");
			}
			return new StorableItemDefinitionBuilder(result);
		}

		public static StorableItemDefinitionBuilder CloneFrom(StorableItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source storable item definition cannot be null");
			}
			return new StorableItemDefinitionBuilder(source.S1StorableItemDefinition);
		}

		public static StorableItemDefinition CreateItem(string id, string name, string description, ItemCategory category, int stackLimit = 10, float basePurchasePrice = 10f, float resellMultiplier = 0.5f, LegalStatus legalStatus = LegalStatus.Legal, FullRank? requiredRank = null, Sprite? icon = null, Equippable? equippable = null)
		{
			StorableItemDefinitionBuilder storableItemDefinitionBuilder = new StorableItemDefinitionBuilder().WithBasicInfo(id, name, description, category).WithStackLimit(stackLimit).WithPricing(basePurchasePrice, resellMultiplier)
				.WithRequiredRank(requiredRank)
				.WithLegalStatus(legalStatus);
			if ((Object)(object)icon != (Object)null)
			{
				storableItemDefinitionBuilder.WithIcon(icon);
			}
			if (equippable != null)
			{
				storableItemDefinitionBuilder.WithEquippable(equippable);
			}
			return storableItemDefinitionBuilder.Build();
		}

		public static EquippableBuilder CreateEquippableBuilder()
		{
			return new EquippableBuilder();
		}
	}
	public class StorableItemDefinition : ItemDefinition
	{
		internal StorableItemDefinition S1StorableItemDefinition { get; }

		public float BasePurchasePrice
		{
			get
			{
				return S1StorableItemDefinition.BasePurchasePrice;
			}
			set
			{
				S1StorableItemDefinition.BasePurchasePrice = value;
			}
		}

		public float ResellMultiplier
		{
			get
			{
				return S1StorableItemDefinition.ResellMultiplier;
			}
			set
			{
				S1StorableItemDefinition.ResellMultiplier = value;
			}
		}

		public bool IsUnlocked => S1StorableItemDefinition.IsUnlocked;

		public bool RequiresLevelToPurchase
		{
			get
			{
				return S1StorableItemDefinition.RequiresLevelToPurchase;
			}
			set
			{
				S1StorableItemDefinition.RequiresLevelToPurchase = value;
			}
		}

		public FullRank RequiredRank
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return FullRank.FromNative(S1StorableItemDefinition.RequiredRank);
			}
			set
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				S1StorableItemDefinition.RequiredRank = value.ToNative();
			}
		}

		public bool HasStationItem => (Object)(object)S1StorableItemDefinition.StationItem != (Object)null;

		public GameObject? StationItemPrefab
		{
			get
			{
				StationItem stationItem = S1StorableItemDefinition.StationItem;
				return (stationItem != null) ? ((Component)stationItem).gameObject : null;
			}
		}

		internal StorableItemDefinition(StorableItemDefinition definition)
			: base((ItemDefinition)(object)definition)
		{
			S1StorableItemDefinition = definition;
		}
	}
	public sealed class StorableItemDefinitionBuilder : StorableItemDefinitionBuilderBase<StorableItemDefinitionBuilder>
	{
		internal StorableItemDefinitionBuilder(StorableItemDefinition source)
			: base(source, (Func<StorableItemDefinition>?)null)
		{
		}

		internal StorableItemDefinitionBuilder()
			: base((Func<StorableItemDefinition>?)null)
		{
		}

		public new StorableItemDefinition Build()
		{
			return base.Build();
		}
	}
	internal static class StorableItemDefinitionBuilderState
	{
		internal static readonly Log Logger = new Log("StorableItemDefinitionBuilder");

		internal static readonly object StationItemGate = new object();

		internal static readonly Dictionary<int, StationItem> StationItemCache = new Dictionary<int, StationItem>();

		internal static readonly HashSet<int> WarnedStationItemModuleMissing = new HashSet<int>();

		internal static GameObject? _stationItemRoot;
	}
	public abstract class StorableItemDefinitionBuilderBase<TSelf> where TSelf : StorableItemDefinitionBuilderBase<TSelf>
	{
		protected readonly StorableItemDefinition Definition;

		private readonly GameObject _storedItemPlaceholder;

		private bool _hasCustomStoredItem;

		private GameObject? _trashPrefab;

		private string? _trashId;

		private bool _replaceExistingTrash;

		private static Log Logger => StorableItemDefinitionBuilderState.Logger;

		private static object StationItemGate => StorableItemDefinitionBuilderState.StationItemGate;

		private static Dictionary<int, StationItem> StationItemCache => StorableItemDefinitionBuilderState.StationItemCache;

		private static HashSet<int> WarnedStationItemModuleMissing => StorableItemDefinitionBuilderState.WarnedStationItemModuleMissing;

		private static GameObject? StationItemRoot
		{
			get
			{
				return StorableItemDefinitionBuilderState._stationItemRoot;
			}
			set
			{
				StorableItemDefinitionBuilderState._stationItemRoot = value;
			}
		}

		protected bool HasCustomStoredItem => _hasCustomStoredItem;

		private TSelf Self => (TSelf)this;

		internal StorableItemDefinitionBuilderBase(Func<StorableItemDefinition>? definitionFactory = null)
		{
			Definition = ((definitionFactory != null) ? definitionFactory() : ScriptableObject.CreateInstance<StorableItemDefinition>());
			ApplyDefaults();
			_storedItemPlaceholder = CreateStoredItemPlaceholder();
		}

		internal StorableItemDefinitionBuilderBase(StorableItemDefinition source, Func<StorableItemDefinition>? definitionFactory = null)
			: this(definitionFactory)
		{
			CopyPropertiesFrom(source);
		}

		protected virtual void CopyPropertiesFrom(StorableItemDefinition source)
		{
			//IL_003c: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)source == (Object)null))
			{
				((BaseItemDefinition)Definition).Name = ((BaseItemDefinition)source).Name;
				((BaseItemDefinition)Definition).Description = ((BaseItemDefinition)source).Description;
				((BaseItemDefinition)Definition).Category = ((BaseItemDefinition)source).Category;
				((BaseItemDefinition)Definition).StackLimit = ((BaseItemDefinition)source).StackLimit;
				((ItemDefinition)Definition).AvailableInDemo = ((ItemDefinition)source).AvailableInDemo;
				((BaseItemDefinition)Definition).UsableInFilters = ((BaseItemDefinition)source).UsableInFilters;
				((BaseItemDefinition)Definition).Icon = ((BaseItemDefinition)source).Icon;
				((BaseItemDefinition)Definition).legalStatus = ((BaseItemDefinition)source).legalStatus;
				Definition.PickpocketDifficultyMultiplier = source.PickpocketDifficultyMultiplier;
				Definition.CombatUtility = source.CombatUtility;
				Definition.BasePurchasePrice = source.BasePurchasePrice;
				Definition.ResellMultiplier = source.ResellMultiplier;
				Definition.ShopCategories = source.ShopCategories;
				Definition.RequiresLevelToPurchase = source.RequiresLevelToPurchase;
				Definition.RequiredRank = source.RequiredRank;
				Definition.StoredItem = (((Object)(object)source.StoredItem != (Object)null) ? source.StoredItem : Definition.StoredItem);
				Definition.StationItem = source.StationItem;
				((ItemDefinition)Definition).Equippable = ((ItemDefinition)source).Equippable;
				((ItemDefinition)Definition).CustomItemUI = ((ItemDefinition)source).CustomItemUI;
			}
		}

		private void ApplyDefaults()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			((BaseItemDefinition)Definition).StackLimit = 10;
			Definition.BasePurchasePrice = 10f;
			Definition.ResellMultiplier = 0.5f;
			((BaseItemDefinition)Definition).Category = (EItemCategory)3;
			((BaseItemDefinition)Definition).legalStatus = (ELegalStatus)0;
			((ItemDefinition)Definition).AvailableInDemo = true;
			((BaseItemDefinition)Definition).UsableInFilters = true;
			Definition.RequiresLevelToPurchase = false;
			Definition.RequiredRank = new FullRank((ERank)0, 1);
		}

		private GameObject CreateStoredItemPlaceholder()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("S1API_DefaultStoredItem");
			val.SetActive(false);
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)val);
			StoredItem storedItem = val.AddComponent<StoredItem>();
			Definition.StoredItem = storedItem;
			return val;
		}

		public TSelf WithBasicInfo(string id, string name, string description, ItemCategory category)
		{
			((BaseItemDefinition)Definition).ID = id;
			((BaseItemDefinition)Definition).Name = name;
			((BaseItemDefinition)Definition).Description = description;
			((BaseItemDefinition)Definition).Category = (EItemCategory)category;
			string text = (string.IsNullOrEmpty(name) ? id : name);
			if (!string.IsNullOrEmpty(text))
			{
				((Object)Definition).name = text;
				if ((Object)(object)_storedItemPlaceholder != (Object)null && !_hasCustomStoredItem)
				{
					((Object)_storedItemPlaceholder).name = text + "_StoredItem";
				}
			}
			return Self;
		}

		public TSelf WithStackLimit(int limit)
		{
			((BaseItemDefinition)Definition).StackLimit = Mathf.Clamp(limit, 1, 999);
			return Self;
		}

		public TSelf WithIcon(Sprite icon)
		{
			((BaseItemDefinition)Definition).Icon = icon;
			return Self;
		}

		public TSelf WithPricing(float basePurchasePrice, float resellMultiplier = 0.5f)
		{
			Definition.BasePurchasePrice = Mathf.Max(0f, basePurchasePrice);
			Definition.ResellMultiplier = Mathf.Clamp01(resellMultiplier);
			return Self;
		}

		public TSelf WithLegalStatus(LegalStatus status)
		{
			((BaseItemDefinition)Definition).legalStatus = (ELegalStatus)status;
			return Self;
		}

		public TSelf WithEquippable(Equippable equippable)
		{
			if (equippable != null)
			{
				((ItemDefinition)Definition).Equippable = equippable.S1Equippable;
			}
			return Self;
		}

		public TSelf WithStoredItem(GameObject storedItemPrefab)
		{
			if ((Object)(object)storedItemPrefab == (Object)null)
			{
				return Self;
			}
			StoredItem storedItem = storedItemPrefab.GetComponent<StoredItem>() ?? storedItemPrefab.AddComponent<StoredItem>();
			Definition.StoredItem = storedItem;
			_hasCustomStoredItem = true;
			return Self;
		}

		public TSelf WithStationItem(GameObject stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				throw new ArgumentNullException("stationItemPrefab");
			}
			StationItem component = stationItemPrefab.GetComponent<StationItem>();
			if ((Object)(object)component == (Object)null)
			{
				throw new ArgumentException("Station item prefab must have a StationItem component.", "stationItemPrefab");
			}
			StationItem orCreateStationItemPrefab = GetOrCreateStationItemPrefab(component);
			Definition.StationItem = orCreateStationItemPrefab;
			WarnIfStationItemMissingChemistryModules(orCreateStationItemPrefab);
			return Self;
		}

		public TSelf WithoutStationItem()
		{
			Definition.StationItem = null;
			return Self;
		}

		public TSelf WithTrashPrefab(GameObject trashPrefab, bool replaceExisting = false)
		{
			return WithTrashPrefab(null, trashPrefab, replaceExisting);
		}

		public TSelf WithTrashPrefab(string? trashId, GameObject trashPrefab, bool replaceExisting = false)
		{
			if ((Object)(object)trashPrefab == (Object)null)
			{
				throw new ArgumentNullException("trashPrefab");
			}
			if ((Object)(object)trashPrefab.GetComponent<TrashItem>() == (Object)null)
			{
				throw new ArgumentException("Trash prefab must have a TrashItem component.", "trashPrefab");
			}
			if (trashId != null && string.IsNullOrWhiteSpace(trashId))
			{
				throw new ArgumentException("Trash ID cannot be empty.", "trashId");
			}
			_trashId = trashId;
			_trashPrefab = trashPrefab;
			_replaceExistingTrash = replaceExisting;
			return Self;
		}

		public TSelf WithDemoAvailability(bool available)
		{
			((ItemDefinition)Definition).AvailableInDemo = available;
			return Self;
		}

		public TSelf WithRequiredRank(FullRank? rank)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!rank.HasValue)
			{
				Definition.RequiresLevelToPurchase = false;
				return Self;
			}
			Definition.RequiredRank = rank.Value.ToNative();
			Definition.RequiresLevelToPurchase = true;
			return Self;
		}

		protected virtual StorableItemDefinition Build()
		{
			if (string.IsNullOrWhiteSpace(((BaseItemDefinition)Definition).ID))
			{
				Logger.Error("Cannot build item definition: ID is required. Use WithBasicInfo(...) to set the ID.");
				throw new InvalidOperationException("Cannot build item definition: ID is required.");
			}
			if (!_hasCustomStoredItem && (Object)(object)Definition.StoredItem != (Object)null && !string.IsNullOrEmpty(((BaseItemDefinition)Definition).Name) && (Object)(object)_storedItemPlaceholder != (Object)null)
			{
				((Object)_storedItemPlaceholder).name = ((BaseItemDefinition)Definition).Name + "_StoredItem";
			}
			ApplyTrashPrefab();
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)Definition);
			RuntimeItemDefinitionRegistry.Retain(((BaseItemDefinition)Definition).ID, (ItemDefinition)(object)Definition);
			return CreateWrapper(Definition);
		}

		private void ApplyTrashPrefab()
		{
			if (!((Object)(object)_trashPrefab == (Object)null))
			{
				if ((Object)(object)Definition.StationItem == (Object)null)
				{
					throw new InvalidOperationException("A station item is required before configuring its trash prefab.");
				}
				string text = ResolveTrashId(((BaseItemDefinition)Definition).ID, _trashId);
				GameObject trashPrefab = TrashManager.GetTrashPrefab(text);
				if (!_replaceExistingTrash && (Object)(object)trashPrefab != (Object)null)
				{
					Logger.Warning($"Item '{((BaseItemDefinition)Definition).ID}' requested trash ID '{text}', but '{((Object)trashPrefab).name}' is already registered and will be reused.");
				}
				GameObject val = TrashManager.RegisterTrashPrefab(text, _trashPrefab, _replaceExistingTrash);
				Definition.StationItem.TrashPrefab = val.GetComponent<TrashItem>();
			}
		}

		internal static string ResolveTrashId(string itemId, string? trashId)
		{
			return trashId ?? (itemId + "_trash");
		}

		internal virtual StorableItemDefinition BuildInternal()
		{
			return Definition;
		}

		protected virtual StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new StorableItemDefinition(definition);
		}

		private static StationItem GetOrCreateStationItemPrefab(StationItem stationItemPrefab)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (StationItemCache.TryGetValue(instanceID, out StationItem value) && (Object)(object)value != (Object)null)
				{
					return value;
				}
				GameObject stationItemRoot = GetStationItemRoot();
				StationItem val = Object.Instantiate<StationItem>(stationItemPrefab, stationItemRoot.transform);
				((Object)((Component)val).gameObject).hideFlags = (HideFlags)61;
				((Object)val).name = ((Object)stationItemPrefab).name + "_S1API_StationItem";
				((Component)val).transform.position = stationItemRoot.transform.position;
				StationItemCache[instanceID] = val;
				return val;
			}
		}

		private static GameObject GetStationItemRoot()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)StationItemRoot != (Object)null)
			{
				return StationItemRoot;
			}
			lock (StationItemGate)
			{
				if ((Object)(object)StationItemRoot != (Object)null)
				{
					return StationItemRoot;
				}
				GameObject val = new GameObject("S1API_StationItemCache");
				((Object)val).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)val);
				val.transform.position = new Vector3(0f, -10000f, 0f);
				StationItemRoot = val;
				return val;
			}
		}

		private static void WarnIfStationItemMissingChemistryModules(StationItem stationItemPrefab)
		{
			if ((Object)(object)stationItemPrefab == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)stationItemPrefab).GetInstanceID();
			lock (StationItemGate)
			{
				if (!WarnedStationItemModuleMissing.Add(instanceID))
				{
					return;
				}
			}
			try
			{
				bool flag = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<IngredientModule>(true) != (Object)null;
				bool flag2 = (Object)(object)((Component)stationItemPrefab).GetComponentInChildren<PourableModule>(true) != (Object)null;
				if (!(flag || flag2))
				{
					Logger.Warning("[S1API] StationItem prefab '" + ((Object)stationItemPrefab).name + "' does not contain an IngredientModule or PourableModule. Chemistry station tasks may log errors or skip this ingredient at runtime.");
				}
			}
			catch
			{
			}
		}
	}
}
namespace S1API.Items.Quality
{
	public class QualityItemCreator
	{
		public static QualityItemDefinitionBuilder CreateBuilder()
		{
			return new QualityItemDefinitionBuilder();
		}

		public static QualityItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<QualityItemDefinition>((object)item, out QualityItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an QualityItemDefinition", "sourceItemId");
			}
			return new QualityItemDefinitionBuilder(result);
		}

		public static QualityItemDefinitionBuilder CloneFrom(QualityItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source storable item definition cannot be null");
			}
			return new QualityItemDefinitionBuilder(source.S1QualityDefinition);
		}
	}
	public class QualityItemDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal QualityItemDefinition S1QualityDefinition { get; }

		public global::S1API.Products.Quality DefaultQuality
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (global::S1API.Products.Quality)S1QualityDefinition.DefaultQuality;
			}
			set
			{
				S1QualityDefinition.DefaultQuality = (EQuality)value;
			}
		}

		internal QualityItemDefinition(QualityItemDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1QualityDefinition = definition;
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return CreateInstance(quantity, DefaultQuality);
		}

		public QualityItemInstance CreateInstance(global::S1API.Products.Quality quality)
		{
			return CreateInstance(1, quality);
		}

		public QualityItemInstance CreateInstance(int quantity, global::S1API.Products.Quality quality)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new QualityItemInstance(new QualityItemInstance((ItemDefinition)(object)S1QualityDefinition, quantity, (EQuality)quality));
		}
	}
	public sealed class QualityItemDefinitionBuilder : StorableItemDefinitionBuilderBase<QualityItemDefinitionBuilder>
	{
		private QualityItemDefinition QualityDefinition => CrossType.As<QualityItemDefinition>((object)Definition);

		internal QualityItemDefinitionBuilder()
			: base((Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<QualityItemDefinition>)
		{
			QualityDefinition.DefaultQuality = (EQuality)2;
		}

		internal QualityItemDefinitionBuilder(QualityItemDefinition source)
			: base((StorableItemDefinition)(object)source, (Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<QualityItemDefinition>)
		{
		}

		protected override void CopyPropertiesFrom(StorableItemDefinition source)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			base.CopyPropertiesFrom(source);
			QualityItemDefinition val = CrossType.As<QualityItemDefinition>((object)source);
			QualityDefinition.DefaultQuality = val.DefaultQuality;
		}

		public QualityItemDefinitionBuilder WithDefaultQuality(global::S1API.Products.Quality quality)
		{
			QualityDefinition.DefaultQuality = (EQuality)quality;
			return this;
		}

		public new QualityItemDefinition Build()
		{
			return (QualityItemDefinition)base.Build();
		}

		internal new QualityItemDefinition BuildInternal()
		{
			return QualityDefinition;
		}

		protected override global::S1API.Items.Storable.StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new QualityItemDefinition(CrossType.As<QualityItemDefinition>((object)definition));
		}
	}
	public class QualityItemInstance : ItemInstance
	{
		internal readonly QualityItemInstance S1QualityInstance;

		public global::S1API.Products.Quality Quality
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (global::S1API.Products.Quality)S1QualityInstance.Quality;
			}
			set
			{
				S1QualityInstance.Quality = (EQuality)value;
			}
		}

		public new QualityItemDefinition Definition => new QualityItemDefinition(CrossType.As<QualityItemDefinition>((object)((ItemInstance)S1QualityInstance).Definition));

		internal QualityItemInstance(QualityItemInstance itemInstance)
			: base((ItemInstance)(object)itemInstance)
		{
			S1QualityInstance = itemInstance;
		}
	}
}
namespace S1API.Items.Ingredient
{
	public sealed class MixIngredientDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal PropertyItemDefinition S1IngredientDefinition { get; }

		public IReadOnlyList<PropertyBase> Properties
		{
			get
			{
				List<Effect> properties = S1IngredientDefinition.Properties;
				if (properties == null)
				{
					return new List<PropertyBase>().AsReadOnly();
				}
				List<PropertyBase> list = new List<PropertyBase>(properties.Count);
				for (int i = 0; i < properties.Count; i++)
				{
					list.Add(new ProductPropertyWrapper(properties[i]));
				}
				return list.AsReadOnly();
			}
		}

		internal MixIngredientDefinition(PropertyItemDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1IngredientDefinition = definition;
		}
	}
	public sealed class MixIngredientDefinitionBuilder : StorableItemDefinitionBuilderBase<MixIngredientDefinitionBuilder>
	{
		private static readonly Log Logger = new Log("MixIngredientDefinitionBuilder");

		private static readonly string[] MixerTemplateIds = new string[14]
		{
			"iodine", "cuke", "banana", "donut", "chili", "paracetamol", "energydrink", "motoroil", "mouthwash", "megabean",
			"battery", "addy", "flumedicine", "gasoline"
		};

		private PropertyItemDefinition IngredientDefinition => CrossType.As<PropertyItemDefinition>((object)Definition);

		internal MixIngredientDefinitionBuilder()
			: base((Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<PropertyItemDefinition>)
		{
			((BaseItemDefinition)Definition).Category = (EItemCategory)9;
		}

		internal MixIngredientDefinitionBuilder(PropertyItemDefinition source)
			: base((StorableItemDefinition)(object)source, (Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<PropertyItemDefinition>)
		{
		}

		protected override void CopyPropertiesFrom(StorableItemDefinition source)
		{
			base.CopyPropertiesFrom(source);
			PropertyItemDefinition val = CrossType.As<PropertyItemDefinition>((object)source);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			List<Effect> list = new List<Effect>();
			List<Effect> properties = val.Properties;
			if (properties != null)
			{
				for (int i = 0; i < properties.Count; i++)
				{
					list.Add(properties[i]);
				}
			}
			IngredientDefinition.Properties = ToIl2CppList(list);
		}

		public MixIngredientDefinitionBuilder WithEffect(PropertyBase effect)
		{
			return WithEffects(effect);
		}

		public MixIngredientDefinitionBuilder WithEffects(params PropertyBase[] effects)
		{
			if (effects == null || effects.Length == 0)
			{
				Logger.Warning("WithEffects called with no effects; the ingredient will not imprint anything when mixed.");
				return this;
			}
			List<Effect> list = PropertyResolver.ResolveToGameProperties(effects);
			if (list.Count == 0)
			{
				Logger.Warning("None of the supplied effects resolved to a game effect. Use a vanilla token or a registered custom effect.");
			}
			IngredientDefinition.Properties = ToIl2CppList(list);
			return this;
		}

		public new MixIngredientDefinition Build()
		{
			string iD = ((BaseItemDefinition)Definition).ID;
			if (CustomIngredientRegistry.TryGetExisting(iD, out PropertyItemDefinition definition) && (Object)(object)definition != (Object)null)
			{
				Logger.Warning("Mixing ingredient '" + iD + "' is already registered; returning the existing one.");
				return new MixIngredientDefinition(definition);
			}
			List<Effect> properties = IngredientDefinition.Properties;
			if (properties == null || properties.Count == 0)
			{
				Logger.Error("Cannot build mixing ingredient: it carries no effects. Use WithEffect(...) with a vanilla token or a registered custom effect.");
				throw new InvalidOperationException("Cannot build mixing ingredient: at least one effect is required.");
			}
			EnsureStoredItem();
			MixIngredientDefinition result = (MixIngredientDefinition)base.Build();
			CustomIngredientRegistry.Register(IngredientDefinition);
			return result;
		}

		private void EnsureStoredItem()
		{
			if (base.HasCustomStoredItem)
			{
				return;
			}
			StoredItem val = FindMixerStoredItem();
			if ((Object)(object)val != (Object)null)
			{
				Definition.StoredItem = val;
				return;
			}
			StoredItem storedItem = Definition.StoredItem;
			if (!((Object)(object)storedItem == (Object)null))
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(storedItem, "footprintX", 1);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(storedItem, "footprintY", 1);
			}
		}

		private static StoredItem? FindMixerStoredItem()
		{
			string[] mixerTemplateIds = MixerTemplateIds;
			foreach (string text in mixerTemplateIds)
			{
				ItemDefinition item = Registry.GetItem(text);
				if (!((Object)(object)item == (Object)null) && CrossType.Is<StorableItemDefinition>((object)item, out StorableItemDefinition result) && (Object)(object)result.StoredItem != (Object)null)
				{
					return result.StoredItem;
				}
			}
			return null;
		}

		internal new PropertyItemDefinition BuildInternal()
		{
			return IngredientDefinition;
		}

		protected override global::S1API.Items.Storable.StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new MixIngredientDefinition(CrossType.As<PropertyItemDefinition>((object)definition));
		}

		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
	public static class MixIngredientItemCreator
	{
		public static MixIngredientDefinitionBuilder CreateBuilder()
		{
			return new MixIngredientDefinitionBuilder();
		}

		public static MixIngredientDefinitionBuilder CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<PropertyItemDefinition>((object)item, out PropertyItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not a PropertyItemDefinition and cannot be used as a mixing ingredient", "sourceItemId");
			}
			return new MixIngredientDefinitionBuilder(result);
		}

		public static MixIngredientDefinitionBuilder CloneFrom(MixIngredientDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source ingredient definition cannot be null");
			}
			return new MixIngredientDefinitionBuilder(source.S1IngredientDefinition);
		}
	}
}
namespace S1API.Items.Clothing
{
	public enum ClothingApplicationType
	{
		BodyLayer,
		FaceLayer,
		Accessory
	}
	public enum ClothingColor
	{
		White,
		LightGrey,
		DarkGrey,
		Charcoal,
		Black,
		LightRed,
		Red,
		Crimson,
		Orange,
		Tan,
		Brown,
		Coral,
		Beige,
		Yellow,
		Lime,
		LightGreen,
		DarkGreen,
		Cyan,
		SkyBlue,
		Blue,
		DeepBlue,
		Navy,
		DeepPurple,
		Purple,
		Magenta,
		BrightPink,
		HotPink
	}
	public static class ClothingItemCreator
	{
		private static readonly Log Logger = new Log("ClothingItemCreator");

		public static ClothingItemDefinitionBuilder CreateBuilder()
		{
			return new ClothingItemDefinitionBuilder();
		}

		public static ClothingItemDefinitionBuilder? CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				Logger.Error("Cannot clone clothing item '" + sourceItemId + "': source item not found in registry");
				return null;
			}
			if (!CrossType.Is<ClothingDefinition>((object)item, out ClothingDefinition result))
			{
				Logger.Error($"Cannot clone item '{sourceItemId}': it is not a clothing item (found type: {((object)item).GetType().Name})");
				return null;
			}
			return new ClothingItemDefinitionBuilder(result);
		}

		public static ClothingItemDefinitionBuilder? CloneFrom(ClothingItemDefinition source)
		{
			if (source == null)
			{
				Logger.Error("Cannot clone from null clothing item definition");
				return null;
			}
			return new ClothingItemDefinitionBuilder(source.S1ClothingDefinition);
		}
	}
	public sealed class ClothingItemDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal ClothingDefinition S1ClothingDefinition { get; }

		public ClothingSlot Slot
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingSlot)S1ClothingDefinition.Slot;
			}
			set
			{
				S1ClothingDefinition.Slot = (EClothingSlot)value;
			}
		}

		public ClothingApplicationType ApplicationType
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingApplicationType)S1ClothingDefinition.ApplicationType;
			}
			set
			{
				S1ClothingDefinition.ApplicationType = (EClothingApplicationType)value;
			}
		}

		public string ClothingAssetPath
		{
			get
			{
				return S1ClothingDefinition.ClothingAssetPath;
			}
			set
			{
				S1ClothingDefinition.ClothingAssetPath = value;
			}
		}

		public bool Colorable
		{
			get
			{
				return S1ClothingDefinition.Colorable;
			}
			set
			{
				S1ClothingDefinition.Colorable = value;
			}
		}

		public ClothingColor DefaultColor
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingColor)S1ClothingDefinition.DefaultColor;
			}
			set
			{
				S1ClothingDefinition.DefaultColor = (EClothingColor)value;
			}
		}

		public List<ClothingSlot> SlotsToBlock
		{
			get
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected I4, but got Unknown
				List<ClothingSlot> list = new List<ClothingSlot>();
				if (S1ClothingDefinition.SlotsToBlock != null)
				{
					Enumerator<EClothingSlot> enumerator = S1ClothingDefinition.SlotsToBlock.GetEnumerator();
					while (enumerator.MoveNext())
					{
						EClothingSlot current = enumerator.Current;
						list.Add((ClothingSlot)current);
					}
				}
				return list;
			}
			set
			{
				S1ClothingDefinition.SlotsToBlock = new List<EClothingSlot>();
				if (value == null)
				{
					return;
				}
				foreach (ClothingSlot item in value)
				{
					S1ClothingDefinition.SlotsToBlock.Add((EClothingSlot)item);
				}
			}
		}

		internal ClothingItemDefinition(ClothingDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1ClothingDefinition = definition;
		}

		public override ItemInstance CreateInstance(int quantity = 1)
		{
			return CreateInstance(quantity, DefaultColor);
		}

		public ClothingItemInstance CreateInstance(ClothingColor color)
		{
			return CreateInstance(1, color);
		}

		public ClothingItemInstance CreateInstance(int quantity, ClothingColor color)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			return new ClothingItemInstance(new ClothingInstance((ItemDefinition)(object)S1ClothingDefinition, quantity, (EClothingColor)color));
		}
	}
	public class ClothingItemDefinitionBuilder : StorableItemDefinitionBuilderBase<ClothingItemDefinitionBuilder>
	{
		private static readonly Log Logger = new Log("ClothingItemDefinitionBuilder");

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

		private static readonly object WarnedMissingNativeClothingItemUiLock = new object();

		private static ItemUI? s_cachedNativeCustomItemUI;

		private ClothingDefinition ClothingDefinition => CrossType.As<ClothingDefinition>((object)Definition);

		internal ClothingItemDefinitionBuilder()
			: base((StorableItemDefinition)(object)ScriptableObject.CreateInstance<ClothingDefinition>(), (Func<StorableItemDefinition>?)null)
		{
			((BaseItemDefinition)Definition).Category = (EItemCategory)11;
			ClothingDefinition.Slot = (EClothingSlot)8;
			ClothingDefinition.ApplicationType = (EClothingApplicationType)2;
			ClothingDefinition.ClothingAssetPath = "Path/To/Clothing/Asset";
			ClothingDefinition.Colorable = true;
			ClothingDefinition.DefaultColor = (EClothingColor)0;
			ClothingDefinition.SlotsToBlock = new List<EClothingSlot>();
		}

		internal ClothingItemDefinitionBuilder(ClothingDefinition source)
			: base((StorableItemDefinition)(object)source, (Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<ClothingDefinition>)
		{
		}

		protected override void CopyPropertiesFrom(StorableItemDefinition source)
		{
			//IL_0017: 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_005f: 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_009e: 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)
			base.CopyPropertiesFrom(source);
			ClothingDefinition val = CrossType.As<ClothingDefinition>((object)source);
			ClothingDefinition.Slot = val.Slot;
			ClothingDefinition.ApplicationType = val.ApplicationType;
			ClothingDefinition.ClothingAssetPath = val.ClothingAssetPath;
			ClothingDefinition.Colorable = val.Colorable;
			ClothingDefinition.DefaultColor = val.DefaultColor;
			ClothingDefinition.SlotsToBlock = new List<EClothingSlot>();
			if (val.SlotsToBlock != null)
			{
				Enumerator<EClothingSlot> enumerator = val.SlotsToBlock.GetEnumerator();
				while (enumerator.MoveNext())
				{
					EClothingSlot current = enumerator.Current;
					ClothingDefinition.SlotsToBlock.Add(current);
				}
			}
		}

		public ClothingItemDefinitionBuilder WithSlot(ClothingSlot slot)
		{
			ClothingDefinition.Slot = (EClothingSlot)slot;
			return this;
		}

		public ClothingItemDefinitionBuilder WithApplicationType(ClothingApplicationType applicationType)
		{
			ClothingDefinition.ApplicationType = (EClothingApplicationType)applicationType;
			return this;
		}

		public ClothingItemDefinitionBuilder WithClothingAsset(string assetPath)
		{
			ClothingDefinition.ClothingAssetPath = assetPath;
			return this;
		}

		public ClothingItemDefinitionBuilder WithColorable(bool colorable)
		{
			ClothingDefinition.Colorable = colorable;
			return this;
		}

		public ClothingItemDefinitionBuilder WithDefaultColor(ClothingColor color)
		{
			ClothingDefinition.DefaultColor = (EClothingColor)color;
			return this;
		}

		public ClothingItemDefinitionBuilder WithBlockedSlots(params ClothingSlot[] slots)
		{
			ClothingDefinition.SlotsToBlock = new List<EClothingSlot>();
			foreach (ClothingSlot clothingSlot in slots)
			{
				ClothingDefinition.SlotsToBlock.Add((EClothingSlot)clothingSlot);
			}
			return this;
		}

		public new ClothingItemDefinition Build()
		{
			EnsureNativeClothingItemUi();
			return (ClothingItemDefinition)base.Build();
		}

		internal new ClothingDefinition BuildInternal()
		{
			EnsureNativeClothingItemUi();
			return ClothingDefinition;
		}

		protected override global::S1API.Items.Storable.StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new ClothingItemDefinition(CrossType.As<ClothingDefinition>((object)definition));
		}

		private void EnsureNativeClothingItemUi()
		{
			if ((Object)(object)((ItemDefinition)ClothingDefinition).CustomItemUI != (Object)null)
			{
				return;
			}
			if ((Object)(object)s_cachedNativeCustomItemUI != (Object)null)
			{
				((ItemDefinition)ClothingDefinition).CustomItemUI = s_cachedNativeCustomItemUI;
				return;
			}
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				WarnMissingNativeClothingItemUi("S1Registry.Instance is null");
				return;
			}
			List<ItemDefinition> allItems = Singleton<Registry>.Instance.GetAllItems();
			if (allItems == null)
			{
				WarnMissingNativeClothingItemUi("S1Registry.Instance.GetAllItems() returned null");
				return;
			}
			Enumerator<ItemDefinition> enumerator = allItems.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemDefinition current = enumerator.Current;
				if (!((Object)(object)current == (Object)null) && CrossType.Is<ClothingDefinition>((object)current, out ClothingDefinition result))
				{
					ItemUI customItemUI = ((ItemDefinition)result).CustomItemUI;
					if (!((Object)(object)customItemUI == (Object)null))
					{
						s_cachedNativeCustomItemUI = customItemUI;
						((ItemDefinition)ClothingDefinition).CustomItemUI = customItemUI;
						return;
					}
				}
			}
			WarnMissingNativeClothingItemUi("no S1Clothing.ClothingDefinition with S1Clothing.ClothingDefinition.CustomItemUI was found");
		}

		private static void WarnMissingNativeClothingItemUi(string reason)
		{
			if (!string.IsNullOrWhiteSpace(reason))
			{
				bool flag;
				lock (WarnedMissingNativeClothingItemUiLock)
				{
					flag = WarnedMissingNativeClothingItemUiReasons.Add(reason);
				}
				if (flag)
				{
					Logger.Warning("Could not borrow a native clothing CustomItemUI template (" + reason + "). Custom clothing inventory UI may be incomplete. This usually means Build() was called before any native clothing registered.");
				}
			}
		}
	}
	public class ClothingItemInstance : ItemInstance
	{
		internal readonly ClothingInstance S1ClothingInstance;

		public ClothingColor Color
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (ClothingColor)S1ClothingInstance.Color;
			}
			set
			{
				S1ClothingInstance.Color = (EClothingColor)value;
			}
		}

		public new ClothingItemDefinition Definition => new ClothingItemDefinition(CrossType.As<ClothingDefinition>((object)((ItemInstance)S1ClothingInstance).Definition));

		internal ClothingItemInstance(ClothingInstance itemInstance)
			: base((ItemInstance)(object)itemInstance)
		{
			S1ClothingInstance = itemInstance;
		}
	}
	public enum ClothingSlot
	{
		Feet,
		Bottom,
		Waist,
		Top,
		Outerwear,
		Hands,
		Neck,
		Eyes,
		Head,
		Wrist
	}
}
namespace S1API.Items.Buildable
{
	public static class BuildableItemCreator
	{
		public static BuildableItemDefinitionBuilder CreateBuilder()
		{
			return new BuildableItemDefinitionBuilder();
		}

		public static BuildableItemDefinitionBuilder CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<BuildableItemDefinition>((object)item, out BuildableItemDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not a BuildableItemDefinition", "sourceItemId");
			}
			return new BuildableItemDefinitionBuilder(result);
		}

		public static BuildableItemDefinitionBuilder CloneFrom(BuildableItemDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source item definition cannot be null");
			}
			return new BuildableItemDefinitionBuilder(source.S1BuildableItemDefinition);
		}
	}
	public sealed class BuildableItemDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal BuildableItemDefinition S1BuildableItemDefinition { get; }

		public BuildSoundType BuildSoundType
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (BuildSoundType)S1BuildableItemDefinition.BuildSoundType;
			}
			set
			{
				S1BuildableItemDefinition.BuildSoundType = (EBuildSoundType)value;
			}
		}

		internal BuildableItemDefinition(BuildableItemDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1BuildableItemDefinition = definition;
		}
	}
	public enum BuildSoundType
	{
		Wood,
		Metal,
		Plastic,
		Cardboard
	}
	public class BuildableItemDefinitionBuilder : StorableItemDefinitionBuilderBase<BuildableItemDefinitionBuilder>
	{
		private BuildableItemDefinition BuildableDefinition => CrossType.As<BuildableItemDefinition>((object)Definition);

		internal BuildableItemDefinitionBuilder()
			: base((Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<BuildableItemDefinition>)
		{
			((BaseItemDefinition)Definition).Category = (EItemCategory)4;
			BuildableDefinition.BuildSoundType = (EBuildSoundType)1;
		}

		internal BuildableItemDefinitionBuilder(BuildableItemDefinition source)
			: base((StorableItemDefinition)(object)source, (Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<BuildableItemDefinition>)
		{
		}

		protected override void CopyPropertiesFrom(StorableItemDefinition source)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			base.CopyPropertiesFrom(source);
			BuildableItemDefinition val = CrossType.As<BuildableItemDefinition>((object)source);
			BuildableDefinition.BuildSoundType = val.BuildSoundType;
			BuildableDefinition.BuiltItem = val.BuiltItem;
		}

		public BuildableItemDefinitionBuilder WithBuildSound(BuildSoundType soundType)
		{
			BuildableDefinition.BuildSoundType = (EBuildSoundType)soundType;
			return this;
		}

		public new BuildableItemDefinition Build()
		{
			return (BuildableItemDefinition)base.Build();
		}

		internal new BuildableItemDefinition BuildInternal()
		{
			return BuildableDefinition;
		}

		protected override global::S1API.Items.Storable.StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new BuildableItemDefinition(CrossType.As<BuildableItemDefinition>((object)definition));
		}
	}
}
namespace S1API.Items.Additive
{
	public sealed class AdditiveDefinition : global::S1API.Items.Storable.StorableItemDefinition
	{
		internal AdditiveDefinition S1AdditiveDefinition { get; }

		public Material DisplayMaterial => S1AdditiveDefinition.DisplayMaterial;

		public float QualityChange => S1AdditiveDefinition.QualityChange;

		public float YieldMultiplier => S1AdditiveDefinition.YieldMultiplier;

		public float InstantGrowth => S1AdditiveDefinition.InstantGrowth;

		internal AdditiveDefinition(AdditiveDefinition definition)
			: base((StorableItemDefinition)(object)definition)
		{
			S1AdditiveDefinition = definition;
		}
	}
	public sealed class AdditiveDefinitionBuilder : StorableItemDefinitionBuilderBase<AdditiveDefinitionBuilder>
	{
		private static readonly Log Logger = new Log("AdditiveDefinitionBuilder");

		private AdditiveDefinition AdditiveDefinition => CrossType.As<AdditiveDefinition>((object)Definition);

		internal AdditiveDefinitionBuilder()
			: base((Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<AdditiveDefinition>)
		{
			((BaseItemDefinition)Definition).Category = (EItemCategory)2;
		}

		internal AdditiveDefinitionBuilder(AdditiveDefinition source)
			: base((StorableItemDefinition)(object)source, (Func<StorableItemDefinition>?)ScriptableObject.CreateInstance<AdditiveDefinition>)
		{
		}

		protected override void CopyPropertiesFrom(StorableItemDefinition source)
		{
			base.CopyPropertiesFrom(source);
			AdditiveDefinition val = CrossType.As<AdditiveDefinition>((object)source);
			AutoPropertySetter.TrySet(AdditiveDefinition, "DisplayMaterial", val.DisplayMaterial);
			AutoPropertySetter.TrySet(AdditiveDefinition, "QualityChange", val.QualityChange);
			AutoPropertySetter.TrySet(AdditiveDefinition, "YieldMultiplier", val.YieldMultiplier);
			AutoPropertySetter.TrySet(AdditiveDefinition, "InstantGrowth", val.InstantGrowth);
		}

		public AdditiveDefinitionBuilder WithDisplayMaterial(Material material)
		{
			if (!AutoPropertySetter.TrySet(AdditiveDefinition, "DisplayMaterial", material))
			{
				Logger.Warning("Failed to set DisplayMaterial on AdditiveDefinition '" + (((BaseItemDefinition)AdditiveDefinition).ID ?? "<no id>") + "'.");
			}
			return this;
		}

		public AdditiveDefinitionBuilder WithEffects(float yieldMultiplier, float instantGrowth, float qualityChange)
		{
			instantGrowth = Mathf.Clamp01(instantGrowth);
			if (!AutoPropertySetter.TrySet(AdditiveDefinition, "YieldMultiplier", yieldMultiplier))
			{
				Logger.Warning("Failed to set YieldMultiplier on AdditiveDefinition '" + (((BaseItemDefinition)AdditiveDefinition).ID ?? "<no id>") + "'.");
			}
			if (!AutoPropertySetter.TrySet(AdditiveDefinition, "InstantGrowth", instantGrowth))
			{
				Logger.Warning("Failed to set InstantGrowth on AdditiveDefinition '" + (((BaseItemDefinition)AdditiveDefinition).ID ?? "<no id>") + "'.");
			}
			if (!AutoPropertySetter.TrySet(AdditiveDefinition, "QualityChange", qualityChange))
			{
				Logger.Warning("Failed to set QualityChange on AdditiveDefinition '" + (((BaseItemDefinition)AdditiveDefinition).ID ?? "<no id>") + "'.");
			}
			return this;
		}

		public new AdditiveDefinition Build()
		{
			return (AdditiveDefinition)base.Build();
		}

		internal new AdditiveDefinition BuildInternal()
		{
			return AdditiveDefinition;
		}

		protected override global::S1API.Items.Storable.StorableItemDefinition CreateWrapper(StorableItemDefinition definition)
		{
			return new AdditiveDefinition(CrossType.As<AdditiveDefinition>((object)definition));
		}
	}
	public static class AdditiveItemCreator
	{
		public static AdditiveDefinitionBuilder CreateBuilder()
		{
			return new AdditiveDefinitionBuilder();
		}

		public static AdditiveDefinitionBuilder CloneFrom(string sourceItemId)
		{
			if (string.IsNullOrWhiteSpace(sourceItemId))
			{
				throw new ArgumentException("Source item ID cannot be null or whitespace", "sourceItemId");
			}
			ItemDefinition item = Registry.GetItem(sourceItemId);
			if ((Object)(object)item == (Object)null)
			{
				throw new ArgumentException("Source item with ID '" + sourceItemId + "' not found in registry", "sourceItemId");
			}
			if (!CrossType.Is<AdditiveDefinition>((object)item, out AdditiveDefinition result))
			{
				throw new ArgumentException("Item '" + sourceItemId + "' is not an AdditiveDefinition", "sourceItemId");
			}
			return new AdditiveDefinitionBuilder(result);
		}

		public static AdditiveDefinitionBuilder CloneFrom(AdditiveDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source", "Source additive definition cannot be null");
			}
			return new AdditiveDefinitionBuilder(source.S1AdditiveDefinition);
		}
	}
}
namespace S1API.Internal
{
	internal static class S1APIPreferences
	{
		internal static MelonPreferences_Entry<bool>? EnableMugshotLoadingScreen { get; private set; }

		internal static MelonPreferences_Entry<bool>? EnableUnityNullReferenceTraceLogging { get; private set; }

		internal static MelonPreferences_Entry<bool>? EnableVerboseLogging { get; private set; }

		internal static void Initialize()
		{
			MelonPreferences_Category val = MelonPreferences.CreateCategory("S1API");
			EnableMugshotLoadingScreen = val.CreateEntry<bool>("EnableMugshotLoadingScreen", true, "When true, the loading screen stays open until custom NPC mugshots finish generating. Set to false to let the base game close the loading screen immediately.", (string)null, false, false, (ValueValidator)null, (string)null);
			EnableUnityNullReferenceTraceLogging = val.CreateEntry<bool>("EnableUnityNullReferenceTraceLogging", false, "When true, S1API subscribes to Unity's threaded log callback and emits stack traces for NullReferenceException logs to help diagnose runtime issues.", (string)null, false, false, (ValueValidator)null, (string)null);
			EnableVerboseLogging = val.CreateEntry<bool>("EnableVerboseLogging", false, "When true, S1API emits internal implementation diagnostics for rendering, resource registration, and runtime fallback behavior.", (string)null, false, false, (ValueValidator)null, (string)null);
		}
	}
}
namespace S1API.Internal.Utils
{
	internal static class ArrayExtensions
	{
		internal static T[] AddItemToArray<T>(this T[]? array, T item)
		{
			if (array == null)
			{
				array = Array.Empty<T>();
			}
			Array.Resize(ref array, array.Length + 1);
			array[^1] = item;
			return array;
		}

		internal static Il2CppReferenceArray<T> AddItemToArray<T>(this Il2CppReferenceArray<T>? array, params T[]? itemsToAdd) where T : Object
		{
			int num = ((Il2CppArrayBase<T>)(object)array)?.Length ?? 0;
			int num2 = ((itemsToAdd != null) ? itemsToAdd.Length : 0);
			int num3 = num + num2;
			Il2CppReferenceArray<T> val = new Il2CppReferenceArray<T>((long)num3);
			if (array != null)
			{
				for (int i = 0; i < num; i++)
				{
					((Il2CppArrayBase<T>)(object)val)[i] = ((Il2CppArrayBase<T>)(object)array)[i];
				}
			}
			if (itemsToAdd != null)
			{
				for (int j = 0; j < num2; j++)
				{
					((Il2CppArrayBase<T>)(object)val)[num + j] = itemsToAdd[j];
				}
			}
			return val;
		}
	}
	internal static class AutoPropertySetter
	{
		private const BindingFlags InstanceFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private static bool TryInvokeSetter(MethodInfo setter, object target, object value)
		{
			try
			{
				setter.Invoke(target, new object[1] { value });
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static bool TrySet(object target, string propertyName, object value)
		{
			if (string.IsNullOrWhiteSpace(propertyName))
			{
				return false;
			}
			Type type = target.GetType();
			MethodInfo methodInfo = type.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetSetMethod(nonPublic: true);
			if (methodInfo != null && TryInvokeSetter(methodInfo, target, value))
			{
				return true;
			}
			try
			{
				return ReflectionUtils.TrySetFieldOrProperty(target, "<" + propertyName + ">k__BackingField", value);
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class ButtonUtils
	{
		internal static void AddListener(Button button, Action action)
		{
			if (!((Object)(object)button == (Object)null) && action != null)
			{
				global::S1API.Utils.EventHelper.AddListener(action, (UnityEvent)(object)button.onClick);
			}
		}

		internal static void RemoveListener(Button button, Action action)
		{
			if (!((Object)(object)button == (Object)null) && action != null)
			{
				global::S1API.Utils.EventHelper.RemoveListener(action, (UnityEvent)(object)button.onClick);
			}
		}

		internal static void ClearListeners(Button button)
		{
			if (!((Object)(object)button == (Object)null))
			{
				((UnityEventBase)button.onClick).RemoveAllListeners();
			}
		}

		internal static void Enable(Button button, Text? label = null, string? text = null)
		{
			if ((Object)(object)button != (Object)null)
			{
				((Selectable)button).interactable = true;
			}
			if ((Object)(object)label != (Object)null && !string.IsNullOrEmpty(text))
			{
				label.text = text;
			}
		}

		internal static void Disable(Button button, Text? label = null, string? text = null)
		{
			if ((Object)(object)button != (Object)null)
			{
				((Selectable)button).interactable = false;
			}
			if ((Object)(object)label != (Object)null && !string.IsNullOrEmpty(text))
			{
				label.text = text;
			}
		}

		internal static void SetLabel(Text label, string text)
		{
			if ((Object)(object)label != (Object)null)
			{
				label.text = text;
			}
		}

		internal static void SetStyle(Button button, Text label, string text, Color bg)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null) && !((Object)(object)label == (Object)null))
			{
				label.text = text;
				((Graphic)((Selectable)button).image).color = bg;
			}
		}
	}
	internal static class ColorUtils
	{
		internal static Color ToColorInternal(uint hexColor)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)((hexColor >> 24) & 0xFF) / 255f;
			float num2 = (float)((hexColor >> 16) & 0xFF) / 255f;
			float num3 = (float)((hexColor >> 8) & 0xFF) / 255f;
			float num4 = (float)(hexColor & 0xFF) / 255f;
			return new Color(num2, num3, num4, num);
		}
	}
	internal static class CrossType
	{
		internal static Type Of<T>()
		{
			return Il2CppType.Of<T>();
		}

		internal static bool Is<T>(object obj, out T result) where T : Il2CppObjectBase
		{
			Object val = (Object)((obj is Object) ? obj : null);
			if (val != null)
			{
				Type val2 = Il2CppType.Of<T>();
				if (val2.IsAssignableFrom(val.GetIl2CppType()))
				{
					result = ((Il2CppObjectBase)val).TryCast<T>();
					return true;
				}
			}
			result = default(T);
			return false;
		}

		internal static T As<T>(object obj) where T : Il2CppObjectBase
		{
			Object val = (Object)((obj is Object) ? obj : null);
			return (val != null) ? ((Il2CppObjectBase)val).Cast<T>() : default(T);
		}
	}
	internal static class ImageUtils
	{
		private static readonly Log LoggerInstance = new Log("ImageUtils");

		internal static Sprite? LoadImage(string fileName)
		{
			string text = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, fileName);
			if (!File.Exists(text))
			{
				LoggerInstance.Error("❌ Icon file not found: " + text);
				return null;
			}
			try
			{
				byte[] data = File.ReadAllBytes(text);
				return LoadImageRaw(data);
			}
			catch (Exception ex)
			{
				LoggerInstance.Error("❌ Failed to load sprite: " + ex);
			}
			return null;
		}

		internal static Sprite? LoadImageRaw(byte[] data)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			try
			{
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(data)))
				{
					return TextureToSprite(val);
				}
			}
			catch (Exception ex)
			{
				LoggerInstance.Error("❌ Failed to load sprite: " + ex);
			}
			return null;
		}

		internal static Sprite? TextureToSprite(Texture2D? texture, float pixelsPerUnit = 100f)
		{
			//IL_0029: 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)
			if ((Object)(object)texture == (Object)null)
			{
				return null;
			}
			return Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
		}

		internal static Sprite? LoadImageFromResource(Assembly assembly, string resourceName, float pixelsPerUnit = 100f, FilterMode filterMode = (FilterMode)1)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0079: 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)
			try
			{
				using Stream stream = assembly.GetManifestResourceStream(resourceName);
				if (stream == null)
				{
					LoggerInstance.Error("❌ Resource not found: " + resourceName);
					return null;
				}
				byte[] array;
				using (MemoryStream memoryStream = new MemoryStream())
				{
					stream.CopyTo(memoryStream);
					array = memoryStream.ToArray();
				}
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array), false))
				{
					((Texture)val).filterMode = filterMode;
					return Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), pixelsPerUnit);
				}
			}
			catch (Exception value)
			{
				LoggerInstance.Error($"❌ Failed to load sprite from resource '{resourceName}': {value}");
			}
			return null;
		}
	}
	internal static class InactiveObjectCloner
	{
		internal static T CloneComponent<T>(T source, Transform? parent) where T : Component
		{
			if ((Object)(object)source == (Object)null)
			{
				throw new ArgumentNullException("source");
			}
			GameObject val = CreateInactiveStagingRoot();
			try
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)source).gameObject, val.transform, false);
				val2.SetActive(false);
				val2.transform.SetParent(parent, false);
				T component = val2.GetComponent<T>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
				Object.DestroyImmediate((Object)(object)val2);
				throw new InvalidOperationException("Cloned object has no " + typeof(T).Name + " component.");
			}
			finally
			{
				Object.DestroyImmediate((Object)(object)val);
			}
		}

		internal static GameObject CloneGameObject(GameObject source)
		{
			if ((Object)(object)source == (Object)null)
			{
				throw new ArgumentNullException("source");
			}
			GameObject val = CreateInactiveStagingRoot();
			try
			{
				GameObject val2 = Object.Instantiate<GameObject>(source, val.transform, false);
				val2.SetActive(false);
				val2.transform.SetParent((Transform)null, false);
				return val2;
			}
			finally
			{
				Object.DestroyImmediate((Object)(object)val);
			}
		}

		private static GameObject CreateInactiveStagingRoot()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("S1API_InactiveCloneStaging");
			val.SetActive(false);
			return val;
		}
	}
	internal static class NPCTypeUtils
	{
		private static readonly Log Logger = new Log("NPCTypeUtils");

		internal static string? TryGetStaticNPCId(Type? npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			try
			{
				PropertyInfo property = npcType.GetProperty("NPCId", BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
				if (property?.PropertyType == typeof(string))
				{
					return property.GetValue(null) as string;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("TryGetStaticNPCId: Failed reading static NPCId for '" + npcType.Name + "': " + ex.Message);
			}
			return null;
		}

		internal static string? TryResolveNPCIdFromType(Type? npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			try
			{
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				if (nPCRegistry == null)
				{
					return null;
				}
				List<string> list = new List<string> { npcType.Name.ToLowerInvariant() };
				string item = Regex.Replace(npcType.Name, "([a-z])([A-Z])", "$1_$2").ToLowerInvariant();
				if (!list.Contains(item))
				{
					list.Add(item);
				}
				foreach (string item2 in list)
				{
					Enumerator<NPC> enumerator2 = nPCRegistry.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						NPC current2 = enumerator2.Current;
						if ((Object)(object)current2 != (Object)null && string.Equals(current2.ID, item2, StringComparison.OrdinalIgnoreCase))
						{
							return current2.ID;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("TryResolveNPCIdFromType: Failed resolving ID for '" + npcType.Name + "': " + ex.Message);
			}
			return null;
		}

		internal static Type? TryResolveBuiltInNPCType(string? npcId)
		{
			if (string.IsNullOrWhiteSpace(npcId))
			{
				return null;
			}
			foreach (Type derivedClass in ReflectionUtils.GetDerivedClasses<NPC>())
			{
				if (!(derivedClass == null) && !derivedClass.IsAbstract && !(derivedClass.Assembly != typeof(NPC).Assembly))
				{
					string a = TryGetStaticNPCId(derivedClass);
					if (string.Equals(a, npcId, StringComparison.OrdinalIgnoreCase))
					{
						return derivedClass;
					}
				}
			}
			return null;
		}
	}
	internal static class RandomUtils
	{
		private static readonly Random SystemRng = new Random();

		internal static T PickOne<T>(this IList<T> list)
		{
			if (list.Count == 0)
			{
				return default(T);
			}
			return list[Random.Range(0, list.Count)];
		}

		internal static T PickUnique<T>(this IList<T> list, Func<T, bool> isDuplicate, int maxTries = 10)
		{
			if (list.Count == 0)
			{
				return default(T);
			}
			for (int i = 0; i < maxTries; i++)
			{
				T val = list.PickOne();
				if (!isDuplicate(val))
				{
					return val;
				}
			}
			return default(T);
		}

		internal static List<T> PickMany<T>(this IList<T> list, int count)
		{
			if (list.Count == 0)
			{
				return new List<T>();
			}
			List<T> list2 = new List<T>(list);
			List<T> list3 = new List<T>();
			for (int i = 0; i < count; i++)
			{
				if (list2.Count <= 0)
				{
					break;
				}
				int index = Random.Range(0, list2.Count);
				list3.Add(list2[index]);
				list2.RemoveAt(index);
			}
			return list3;
		}

		internal static int RangeInt(int minInclusive, int maxExclusive)
		{
			return SystemRng.Next(minInclusive, maxExclusive);
		}
	}
	internal static class ReflectionUtils
	{
		private static readonly HashSet<Type> ValueTupleTypes = new HashSet<Type>
		{
			typeof(ValueTuple<>),
			typeof(ValueTuple<, >),
			typeof(ValueTuple<, , >),
			typeof(ValueTuple<, , , >),
			typeof(ValueTuple<, , , , >),
			typeof(ValueTuple<, , , , , >),
			typeof(ValueTuple<, , , , , , >),
			typeof(ValueTuple<, , , , , , , >)
		};

		private static readonly Dictionary<Type, List<string>> ConstStringFieldsCache = new Dictionary<Type, List<string>>();

		internal static List<Type> GetDerivedClasses<TBaseClass>()
		{
			List<Type> list = new List<Type>();
			Assembly[] array = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
				where !ShouldSkipAssembly(assembly)
				select assembly).ToArray();
			Assembly[] array2 = array;
			foreach (Assembly asm in array2)
			{
				foreach (Type item in SafeGetTypes(asm))
				{
					try
					{
						if (!(item == null) && typeof(TBaseClass).IsAssignableFrom(item) && item != typeof(TBaseClass) && !item.IsAbstract)
						{
							list.Add(item);
						}
					}
					catch (TypeLoadException)
					{
					}
					catch (Exception)
					{
					}
				}
			}
			return list;
		}

		internal static Type? GetTypeByName(string typeName)
		{
			try
			{
				Type type = Type.GetType(typeName, throwOnError: false, ignoreCase: false);
				if (type != null)
				{
					return type;
				}
			}
			catch
			{
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly item in assemblies.Where((Assembly a) => !ShouldSkipAssembly(a)))
			{
				foreach (Type item2 in SafeGetTypes(item))
				{
					if (item2 == null || (!(item2.Name == typeName) && !(item2.FullName == typeName)))
					{
						continue;
					}
					return item2;
				}
			}
			Assembly[] array = assemblies;
			foreach (Assembly asm in array)
			{
				foreach (Type item3 in SafeGetTypes(asm))
				{
					if (item3 == null || (!(item3.Name == typeName) && !(item3.FullName == typeName) && (item3.FullName == null || !item3.FullName.EndsWith("." + typeName))))
					{
						continue;
					}
					return item3;
				}
			}
			return null;
		}

		private static bool ShouldSkipAssembly(Assembly assembly)
		{
			string fullName = assembly.FullName;
			if (string.IsNullOrEmpty(fullName))
			{
				return false;
			}
			string text = assembly.GetName().Name ?? string.Empty;
			return fullName.StartsWith("System") || fullName.StartsWith("Unity") || fullName.StartsWith("Il2Cpp") || text.StartsWith("Unity") || text.StartsWith("Il2Cpp") || text.StartsWith("Assembly-CSharp") || fullName.StartsWith("mscorlib") || fullName.StartsWith("Mono.") || fullName.StartsWith("netstandard") || fullName.StartsWith("com.rlabrecque") || fullName.StartsWith("__Generated");
		}

		private static IEnumerable<Type> SafeGetTypes(Assembly asm)
		{
			try
			{
				return asm.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null).Cast<Type>();
			}
			catch
			{
				return Array.Empty<Type>();
			}
		}

		internal static FieldInfo[] GetAllFields(Type? type, BindingFlags bindingFlags)
		{
			List<FieldInfo> list = new List<FieldInfo>();
			while (type != null && type != typeof(object))
			{
				list.AddRange(type.GetFields(bindingFlags));
				type = type.BaseType;
			}
			return list.ToArray();
		}

		internal static MethodInfo? GetMethod(Type? type, string methodName, BindingFlags bindingFlags)
		{
			while (type != null && type != typeof(object))
			{
				MethodInfo method = type.GetMethod(methodName, bindingFlags);
				if (method != null)
				{
					return method;
				}
				type = type.BaseType;
			}
			return null;
		}

		internal static bool IsValueTuple(this object obj)
		{
			if (obj == null)
			{
				return false;
			}
			Type type = obj.GetType();
			if (!type.IsValueType || !type.IsGenericType)
			{
				return false;
			}
			Type genericTypeDefinition = type.GetGenericTypeDefinition();
			return ValueTupleTypes.Contains(genericTypeDefinition);
		}

		internal static object?[]? GetValueTupleItems(this object obj)
		{
			if (!obj.IsValueTuple())
			{
				return null;
			}
			FieldInfo[] allFields = GetAllFields(obj.GetType(), BindingFlags.Instance | BindingFlags.Public);
			if (allFields == null || allFields.Length == 0)
			{
				return null;
			}
			return allFields.Select((FieldInfo f) => f.GetValue(obj)).ToArray();
		}

		internal static List<string> GetConstStringFields(Type type)
		{
			if (ConstStringFieldsCache.TryGetValue(type, out List<string> value))
			{
				return value;
			}
			List<string> list = new List<string>();
			FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				if ((object)fieldInfo != null && fieldInfo.IsLiteral && !fieldInfo.IsInitOnly && !(fieldInfo.FieldType != typeof(string)) && !fieldInfo.IsDefined(typeof(ObsoleteAttribute), inherit: false))
				{
					string text = fieldInfo.GetRawConstantValue() as string;
					if (!string.IsNullOrWhiteSpace(text))
					{
						list.Add(text);
					}
				}
			}
			ConstStringFieldsCache[type] = list;
			return list;
		}

		internal static bool TrySetFieldOrProperty(object? target, string memberName, object? value)
		{
			if (target == null)
			{
				return false;
			}
			Type type = target.GetType();
			FieldInfo field = GetField(type, memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					if (CanAssignValue(field.FieldType, value))
					{
						field.SetValue(target, value);
						return true;
					}
				}
				catch
				{
				}
			}
			PropertyInfo property = GetProperty(type, memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanWrite)
			{
				try
				{
					if (CanAssignValue(property.PropertyType, value))
					{
						property.SetValue(target, value);
						return true;
					}
				}
				catch
				{
				}
			}
			string[] array = new string[2]
			{
				"<" + memberName + ">k__BackingField",
				"_" + memberName + "_k__BackingField"
			};
			string[] array2 = array;
			foreach (string fieldName in array2)
			{
				FieldInfo field2 = GetField(type, fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field2 == null)
				{
					continue;
				}
				try
				{
					if (CanAssignValue(field2.FieldType, value))
					{
						field2.SetValue(target, value);
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		internal static object? TryGetFieldOrProperty(object target, string memberName)
		{
			Type type = target.GetType();
			FieldInfo field = GetField(type, memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					return field.GetValue(target);
				}
				catch
				{
				}
			}
			PropertyInfo property = GetProperty(type, memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanRead)
			{
				try
				{
					return property.GetValue(target);
				}
				catch
				{
				}
			}
			string[] array = new string[2]
			{
				"<" + memberName + ">k__BackingField",
				"_" + memberName + "_k__BackingField"
			};
			string[] array2 = array;
			foreach (string fieldName in array2)
			{
				FieldInfo field2 = GetField(type, fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(field2 == null))
				{
					try
					{
						return field2.GetValue(target);
					}
					catch
					{
					}
				}
			}
			return null;
		}

		private static FieldInfo? GetField(Type? type, string fieldName, BindingFlags bindingFlags)
		{
			while (type != null && type != typeof(object))
			{
				FieldInfo field = type.GetField(fieldName, bindingFlags);
				if (field != null)
				{
					return field;
				}
				type = type.BaseType;
			}
			return null;
		}

		private static PropertyInfo? GetProperty(Type? type, string propertyName, BindingFlags bindingFlags)
		{
			while (type != null && type != typeof(object))
			{
				PropertyInfo property = type.GetProperty(propertyName, bindingFlags);
				if (property != null)
				{
					return property;
				}
				type = type.BaseType;
			}
			return null;
		}

		internal static object? TryGetStaticFieldOrProperty(Type type, string memberName)
		{
			FieldInfo field = type.GetField(memberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					return field.GetValue(null);
				}
				catch
				{
				}
			}
			PropertyInfo property = type.GetProperty(memberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null || !property.CanRead)
			{
				return null;
			}
			try
			{
				return property.GetValue(null);
			}
			catch
			{
			}
			return null;
		}

		internal static void TrySetStaticFieldOrProperty(Type type, string memberName, object? value)
		{
			FieldInfo field = type.GetField(memberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				try
				{
					if (CanAssignValue(field.FieldType, value))
					{
						field.SetValue(null, value);
						return;
					}
				}
				catch
				{
				}
			}
			PropertyInfo property = type.GetProperty(memberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (property == null || !property.CanWrite)
			{
				return;
			}
			try
			{
				if (CanAssignValue(property.PropertyType, value))
				{
					property.SetValue(null, value);
				}
			}
			catch
			{
			}
		}

		private static bool CanAssignValue(Type memberType, object? value)
		{
			if (value != null)
			{
				return memberType.IsInstanceOfType(value);
			}
			return !memberType.IsValueType || Nullable.GetUnderlyingType(memberType) != null;
		}
	}
	internal static class RuntimePrefabCache
	{
		private static GameObject? _root;

		internal static void Store(GameObject prefab)
		{
			//IL_0029: 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)
			GameObject orCreateRoot = GetOrCreateRoot();
			((Object)prefab).hideFlags = (HideFlags)61;
			prefab.transform.SetParent(orCreateRoot.transform, false);
			prefab.transform.localPosition = Vector3.zero;
			prefab.transform.localRotation = Quaternion.identity;
			prefab.SetActive(true);
		}

		private static GameObject GetOrCreateRoot()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if ((Object)(object)_root != (Object)null)
			{
				return _root;
			}
			_root = new GameObject("S1API_RuntimePrefabCache")
			{
				hideFlags = (HideFlags)61
			};
			_root.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_root);
			return _root;
		}
	}
	internal static class ToggleUtils
	{
		private static FieldInfo? _onValueChangedField;

		private static PropertyInfo? _onValueChangedProperty;

		private static FieldInfo? _graphicField;

		private static PropertyInfo? _graphicProperty;

		internal static void AddListener(Toggle toggle, Action<bool> listener)
		{
			if (!((Object)(object)toggle == (Object)null) && TryGetOnValueChanged(toggle, out UnityEvent<bool> evt) && evt != null)
			{
				global::S1API.Utils.EventHelper.AddListener(listener, evt);
			}
		}

		internal static void RemoveListener(Toggle toggle, Action<bool> listener)
		{
			if (!((Object)(object)toggle == (Object)null) && TryGetOnValueChanged(toggle, out UnityEvent<bool> evt) && evt != null)
			{
				global::S1API.Utils.EventHelper.RemoveListener(listener, evt);
			}
		}

		internal static void ClearListeners(Toggle toggle)
		{
			if (TryGetOnValueChanged(toggle, out UnityEvent<bool> evt) && evt != null)
			{
				((UnityEventBase)evt).RemoveAllListeners();
			}
		}

		private static bool TryGetOnValueChanged(Toggle toggle, out UnityEvent<bool>? evt)
		{
			evt = null;
			if ((object)_onValueChangedField == null)
			{
				_onValueChangedField = typeof(Toggle).GetField("onValueChanged", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_onValueChangedField != null && _onValueChangedField.GetValue(toggle) is UnityEvent<bool> val)
			{
				evt = val;
				return true;
			}
			if ((object)_onValueChangedProperty == null)
			{
				_onValueChangedProperty = typeof(Toggle).GetProperty("onValueChanged", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_onValueChangedProperty?.GetMethod != null && _onValueChangedProperty.GetValue(toggle) is UnityEvent<bool> val2)
			{
				evt = val2;
				return true;
			}
			return false;
		}

		internal static void SetGraphic(Toggle toggle, Graphic graphic)
		{
			if ((Object)(object)toggle == (Object)null)
			{
				return;
			}
			if ((object)_graphicField == null)
			{
				_graphicField = typeof(Toggle).GetField("graphic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_graphicField != null)
			{
				_graphicField.SetValue(toggle, graphic);
				return;
			}
			if ((object)_graphicProperty == null)
			{
				_graphicProperty = typeof(Toggle).GetProperty("graphic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_graphicProperty?.SetMethod != null)
			{
				_graphicProperty.SetValue(toggle, graphic);
			}
		}

		internal static Graphic? GetGraphic(Toggle toggle)
		{
			if ((Object)(object)toggle == (Object)null)
			{
				return null;
			}
			if ((object)_graphicField == null)
			{
				_graphicField = typeof(Toggle).GetField("graphic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_graphicField != null)
			{
				object? value = _graphicField.GetValue(toggle);
				return (Graphic?)((value is Graphic) ? value : null);
			}
			if ((object)_graphicProperty == null)
			{
				_graphicProperty = typeof(Toggle).GetProperty("graphic", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (_graphicProperty?.GetMethod != null)
			{
				object? value2 = _graphicProperty.GetValue(toggle);
				return (Graphic?)((value2 is Graphic) ? value2 : null);
			}
			return null;
		}
	}
	internal static class TransformUtils
	{
		internal static Transform? FindDescendant(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (string.Equals(((Object)root).name, name, StringComparison.Ordinal))
			{
				return root;
			}
			for (int i = 0; i < root.childCount; i++)
			{
				Transform val = FindDescendant(root.GetChild(i), name);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}
	}
}
namespace S1API.Internal.Shops
{
	internal static class ShopIntegration
	{
		private static readonly Log Logger = new Log("ShopIntegration");

		internal static bool AddItemToShop(Shop shop, ItemDefinition item, float? customPrice)
		{
			if ((Object)(object)shop?.S1ShopInterface == (Object)null || (Object)(object)item?.S1ItemDefinition == (Object)null)
			{
				return false;
			}
			StorableItemDefinition val = (item as global::S1API.Items.Storable.StorableItemDefinition)?.S1StorableItemDefinition;
			if (val == null)
			{
				val = (item as global::S1API.Items.StorableItemDefinition)?.S1StorableItemDefinition;
			}
			if ((Object)(object)val == (Object)null)
			{
				Logger.Warning("Item '" + item.ID + "' is not storable and cannot be sold in shops.");
				return false;
			}
			try
			{
				ShopListing val2 = CreateListing(item, val, customPrice);
				shop.S1ShopInterface.Listings.Add(val2);
				val2.Initialize(shop.S1ShopInterface);
				CreateListingUI(shop.S1ShopInterface, val2);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error($"Failed to add item '{item.ID}' to shop '{shop.Name}': {ex.Message}");
				return false;
			}
		}

		internal static bool RemoveItemFromShop(Shop shop, string itemId)
		{
			if ((Object)(object)shop?.S1ShopInterface == (Object)null || string.IsNullOrEmpty(itemId))
			{
				return false;
			}
			try
			{
				ShopListing val = null;
				Enumerator<ShopListing> enumerator = shop.S1ShopInterface.Listings.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ShopListing current = enumerator.Current;
					object obj;
					if (current == null)
					{
						obj = null;
					}
					else
					{
						StorableItemDefinition item = current.Item;
						obj = ((item != null) ? ((BaseItemDefinition)item).ID : null);
					}
					if ((string?)obj == itemId)
					{
						val = current;
						break;
					}
				}
				if (val == null)
				{
					return false;
				}
				shop.S1ShopInterface.Listings.Remove(val);
				RemoveListingUI(shop.S1ShopInterface, val);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error($"Failed to remove item '{itemId}' from shop '{shop.Name}': {ex.Message}");
				return false;
			}
		}

		private static ShopListing CreateListing(ItemDefinition item, StorableItemDefinition storableDefinition, float? customPrice)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ShopListing result = new ShopListing
			{
				Item = storableDefinition,
				name = item.Name
			};
			if (customPrice.HasValue && customPrice.Value != storableDefinition.BasePurchasePrice)
			{
				Logger.Warning("Custom price override requested but not fully supported. Using item's BasePurchasePrice.");
			}
			return result;
		}

		private static void CreateListingUI(ShopInterface shop, ShopListing listing)
		{
			if ((Object)(object)shop.ListingUIPrefab == (Object)null || (Object)(object)shop.ListingContainer == (Object)null)
			{
				Logger.Warning("Shop '" + shop.ShopName + "' missing UI prefab or container");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)shop.ListingUIPrefab).gameObject, (Transform)(object)shop.ListingContainer);
			ListingUI component = val.GetComponent<ListingUI>();
			if ((Object)(object)component == (Object)null)
			{
				Logger.Error("Failed to get ListingUI component from instantiated prefab");
				Object.Destroy((Object)(object)val);
				return;
			}
			component.Initialize(listing);
			BindListingUIEvents(shop, component);
			AddToListingUICollection(shop, component);
			AddToListingPanel(shop, component);
		}

		private static void BindListingUIEvents(ShopInterface shop, ListingUI listingUI)
		{
			listingUI.onAddItem = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.onAddItem, (Delegate)(object)DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
			{
				shop.AddItem(listingUI);
			}))).Cast<Action>();
			listingUI.onRemoveItem = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.onRemoveItem, (Delegate)(object)DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
			{
				shop.RemoveItem(listingUI);
			}))).Cast<Action>();
			listingUI.onSetAmount = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.onSetAmount, (Delegate)(object)DelegateSupport.ConvertDelegate<Action<int>>((Delegate)(Action<int>)delegate(int amount)
			{
				shop.SetAmount(listingUI, amount);
			}))).Cast<Action<int>>();
			listingUI.onAdjustAmount = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.onAdjustAmount, (Delegate)(object)DelegateSupport.ConvertDelegate<Action<int>>((Delegate)(Action<int>)delegate(int amount)
			{
				shop.AdjustAmount(listingUI, amount);
			}))).Cast<Action<int>>();
			listingUI.hoverStart = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.hoverStart, (Delegate)(object)DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
			{
				shop.EntryHovered(listingUI);
			}))).Cast<Action>();
			listingUI.hoverEnd = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)listingUI.hoverEnd, (Delegate)(object)DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
			{
				shop.EntryUnhovered();
			}))).Cast<Action>();
		}

		private static void AddToListingUICollection(ShopInterface shop, ListingUI listingUI)
		{
			try
			{
				shop.listingUI.Add(listingUI);
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not add ListingUI to shop's internal collection: " + ex.Message);
			}
		}

		private static void AddToListingPanel(ShopInterface shop, ListingUI listingUI)
		{
			try
			{
				UIPanel listingPanel = shop.listingPanel;
				if (listingPanel != null)
				{
					listingPanel.AddSelectable(listingUI.Selectable);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not add ListingUI to the shop navigation panel: " + ex.Message);
			}
		}

		internal static int RefreshItemIconInShops(ItemDefinition item)
		{
			if ((Object)(object)item?.S1ItemDefinition == (Object)null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				Shop[] allShops = ShopManager.GetAllShops();
				Shop[] array = allShops;
				foreach (Shop shop in array)
				{
					if ((Object)(object)shop?.S1ShopInterface == (Object)null)
					{
						continue;
					}
					Enumerator<ShopListing> enumerator = shop.S1ShopInterface.Listings.GetEnumerator();
					while (enumerator.MoveNext())
					{
						ShopListing current = enumerator.Current;
						object obj;
						if (current == null)
						{
							obj = null;
						}
						else
						{
							StorableItemDefinition item2 = current.Item;
							obj = ((item2 != null) ? ((BaseItemDefinition)item2).ID : null);
						}
						if ((string?)obj == item.ID)
						{
							num += UpdateListingUIcons(shop.S1ShopInterface, current, item.Icon);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to refresh item icon for '" + item.ID + "': " + ex.Message);
			}
			return num;
		}

		private static int UpdateListingUIcons(ShopInterface shop, ShopListing listing, Sprite newIcon)
		{
			if ((Object)(object)newIcon == (Object)null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				List<ListingUI> listingUI = shop.listingUI;
				if (listingUI != null)
				{
					Enumerator<ListingUI> enumerator = listingUI.GetEnumerator();
					while (enumerator.MoveNext())
					{
						ListingUI current = enumerator.Current;
						if (((current != null) ? current.Listing : null) == listing && (Object)(object)current.Icon != (Object)null)
						{
							current.Icon.sprite = newIcon;
							num++;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not update ListingUI icons: " + ex.Message);
			}
			return num;
		}

		private static void RemoveListingUI(ShopInterface shop, ShopListing listing)
		{
			try
			{
				List<ListingUI> listingUI = shop.listingUI;
				if (listingUI == null)
				{
					return;
				}
				for (int num = listingUI.Count - 1; num >= 0; num--)
				{
					ListingUI val = listingUI[num];
					if (((val != null) ? val.Listing : null) == listing)
					{
						UIPanel listingPanel = shop.listingPanel;
						if (listingPanel != null)
						{
							listingPanel.RemoveSelectable(val.Selectable, true);
						}
						if ((Object)(object)((Component)val).gameObject != (Object)null)
						{
							Object.Destroy((Object)(object)((Component)val).gameObject);
						}
						listingUI.RemoveAt(num);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not remove ListingUI from shop: " + ex.Message);
			}
		}
	}
}
namespace S1API.Internal.Rendering
{
	internal static class ItemPresentationWorkbenchAdapter
	{
		private const int DefaultIconSize = 512;

		private const float DefaultCameraFill = 0.72f;

		internal static bool TryCreateDefinition(string itemId, out PresentationWorkbenchDefinition? definition)
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			definition = null;
			ItemDefinition definition2 = ItemManager.GetDefinition(itemId);
			if ((Object)(object)(((object)definition2 != null) ? definition2.S1ItemDefinition.Equippable : null) == (Object)null)
			{
				return false;
			}
			GameObject gameObject = ((Component)definition2.S1ItemDefinition.Equippable).gameObject;
			PresentationWorkbenchDefinition.AvatarPreviewContext avatarPreviewContext = TryCreateAvatarContext(gameObject);
			GameObject val = PresentationWorkbenchVisualResolver.FindVisibleRoot(gameObject);
			if ((Object)(object)val == (Object)null && avatarPreviewContext == null)
			{
				return false;
			}
			PresentationWorkbenchDefinition.PreviewContext firstPerson = (((Object)(object)val == (Object)null) ? null : new PresentationWorkbenchDefinition.PreviewContext(() => ResolveItemVisual(itemId), PresentationWorkbenchTransform.From(val.transform), PresentationWorkbenchExportKind.LocalTransformAssignments));
			GameObject val2 = val ?? avatarPreviewContext.Provider();
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			Func<GameObject> provider = (Func<GameObject>)(((Object)(object)val != (Object)null) ? ((MulticastDelegate)(Func<GameObject>)(() => ResolveItemVisual(itemId))) : ((MulticastDelegate)avatarPreviewContext.Provider));
			PresentationWorkbenchDefinition.IconPreviewContext icon = new PresentationWorkbenchDefinition.IconPreviewContext(provider, new PresentationWorkbenchTransform(Vector3.zero, val2.transform.localEulerAngles, val2.transform.localScale), 512, fitToCamera: true, 0.72f);
			definition = new PresentationWorkbenchDefinition(definition2.ID, "Item presentation: " + definition2.Name, firstPerson, avatarPreviewContext, icon);
			return true;
		}

		private static PresentationWorkbenchDefinition.AvatarPreviewContext? TryCreateAvatarContext(GameObject equippableRoot)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			AvatarEquippable componentInChildren = equippableRoot.GetComponentInChildren<AvatarEquippable>(true);
			if ((Object)(object)componentInChildren == (Object)null || string.IsNullOrWhiteSpace(componentInChildren.AssetPath))
			{
				return null;
			}
			string assetPath = componentInChildren.AssetPath;
			GameObject val = ResolveAvatarVisual(assetPath);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			AvatarHand hand = (((int)componentInChildren.Hand != 0) ? AvatarHand.Right : AvatarHand.Left);
			string animationTrigger = (string.IsNullOrWhiteSpace(componentInChildren.AnimationTrigger) ? "RightArm_Hold_ClosedHand" : componentInChildren.AnimationTrigger);
			return new PresentationWorkbenchDefinition.AvatarPreviewContext(() => ResolveAvatarVisual(assetPath), PresentationWorkbenchTransform.From(val.transform), hand, animationTrigger, PresentationWorkbenchExportKind.LocalTransformAssignments, () => ResolveAvatarPrefab(assetPath), PresentationWorkbenchVisualResolver.FindVisibleRoot, alignAvatarEquippable: true, (int)componentInChildren.TriggerType == 1);
		}

		private static GameObject? ResolveItemVisual(string itemId)
		{
			ItemDefinition definition = ItemManager.GetDefinition(itemId);
			object source;
			if ((object)definition == null)
			{
				source = null;
			}
			else
			{
				Equippable equippable = definition.S1ItemDefinition.Equippable;
				source = ((equippable != null) ? ((Component)equippable).gameObject : null);
			}
			return PresentationWorkbenchVisualResolver.FindVisibleRoot((GameObject?)source);
		}

		private static GameObject? ResolveAvatarVisual(string assetPath)
		{
			return PresentationWorkbenchVisualResolver.FindVisibleRoot(ResolveAvatarPrefab(assetPath));
		}

		private static GameObject? ResolveAvatarPrefab(string assetPath)
		{
			return AvatarEquippableRegistry.GetRegisteredPrefab(assetPath) ?? Resources.Load<GameObject>(assetPath);
		}
	}
	internal static class PresentationWorkbenchExporter
	{
		internal static string FormatTransform(PresentationWorkbenchExportKind exportKind, Vector3 position, Vector3 eulerAngles, Vector3 scale)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (exportKind == PresentationWorkbenchExportKind.ProductTransform)
			{
				return "new ProductPresentationTransform(\n    " + FormatVector(position) + ",\n    " + FormatVector(eulerAngles) + ",\n    " + FormatVector(scale) + ")";
			}
			return $"visual.transform.localPosition = {FormatVector(position)};\nvisual.transform.localEulerAngles = {FormatVector(eulerAngles)};\nvisual.transform.localScale = {FormatVector(scale)};";
		}

		internal static string FormatIcon(Vector3 eulerAngles, Vector3 scale, bool fitToCamera, float cameraFill, int size)
		{
			//IL_0012: 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)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("iconSource.transform.localEulerAngles = ").Append(FormatVector(eulerAngles)).AppendLine(";");
			stringBuilder.Append("iconSource.transform.localScale = ").Append(FormatVector(scale)).AppendLine(";");
			stringBuilder.AppendLine("IconFactory.GenerateIconSprite(");
			stringBuilder.AppendLine("    iconSource.transform,");
			stringBuilder.Append("    size: ").Append(size.ToString(CultureInfo.InvariantCulture)).AppendLine(",");
			stringBuilder.AppendLine("    bakeSkinnedMeshes: true,");
			stringBuilder.Append("    fitToCamera: ").Append(fitToCamera ? "true" : "false").AppendLine(",");
			stringBuilder.Append("    cameraFill: ").Append(FormatFloat(cameraFill)).Append(");");
			return stringBuilder.ToString();
		}

		private static string FormatVector(Vector3 value)
		{
			//IL_0019: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			return $"new Vector3({FormatFloat(value.x)}, {FormatFloat(value.y)}, {FormatFloat(value.z)})";
		}

		private static string FormatFloat(float value)
		{
			if (Mathf.Abs(value) < 5E-07f)
			{
				value = 0f;
			}
			return value.ToString("0.######", CultureInfo.InvariantCulture) + "f";
		}
	}
	internal enum PresentationWorkbenchMode
	{
		FirstPerson,
		Avatar,
		Icon
	}
	internal enum PresentationWorkbenchExportKind
	{
		ProductTransform,
		LocalTransformAssignments,
		IconFactory
	}
	internal sealed class PresentationWorkbenchTransform
	{
		internal Vector3 LocalPosition { get; }

		internal Vector3 LocalEulerAngles { get; }

		internal Vector3 LocalScale { get; }

		internal PresentationWorkbenchTransform(Vector3 localPosition, Vector3 localEulerAngles, Vector3 localScale)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			LocalPosition = localPosition;
			LocalEulerAngles = localEulerAngles;
			LocalScale = localScale;
		}

		internal void ApplyTo(Transform target)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			target.localPosition = LocalPosition;
			target.localEulerAngles = LocalEulerAngles;
			target.localScale = LocalScale;
		}

		internal static PresentationWorkbenchTransform From(Transform target)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return new PresentationWorkbenchTransform(target.localPosition, target.localEulerAngles, target.localScale);
		}
	}
	internal sealed class PresentationWorkbenchDefinition
	{
		internal class PreviewContext
		{
			internal Func<GameObject?> Provider { get; }

			internal PresentationWorkbenchTransform? InitialTransform { get; }

			internal PresentationWorkbenchExportKind ExportKind { get; }

			internal PreviewContext(Func<GameObject?> provider, PresentationWorkbenchTransform? initialTransform, PresentationWorkbenchExportKind exportKind)
			{
				Provider = provider;
				InitialTransform = initialTransform;
				ExportKind = exportKind;
			}
		}

		internal sealed class AvatarPreviewContext : PreviewContext
		{
			internal AvatarHand Hand { get; }

			internal string AnimationTrigger { get; }

			internal Func<GameObject?> PreviewRootProvider { get; }

			internal Func<GameObject, GameObject?> EditableVisualResolver { get; }

			internal bool AlignAvatarEquippable { get; }

			internal bool AnimationUsesBool { get; }

			internal AvatarPreviewContext(Func<GameObject?> provider, PresentationWorkbenchTransform? initialTransform, AvatarHand hand, string animationTrigger, PresentationWorkbenchExportKind exportKind, Func<GameObject?>? previewRootProvider = null, Func<GameObject, GameObject?>? editableVisualResolver = null, bool alignAvatarEquippable = false, bool animationUsesBool = true)
				: base(provider, initialTransform, exportKind)
			{
				Hand = hand;
				AnimationTrigger = animationTrigger;
				PreviewRootProvider = previewRootProvider ?? provider;
				EditableVisualResolver = editableVisualResolver ?? ((Func<GameObject, GameObject>)((GameObject root) => root));
				AlignAvatarEquippable = alignAvatarEquippable;
				AnimationUsesBool = animationUsesBool;
			}
		}

		internal sealed class IconPreviewContext : PreviewContext
		{
			internal int Size { get; }

			internal bool FitToCamera { get; }

			internal float CameraFill { get; }

			internal IconPreviewContext(Func<GameObject?> provider, PresentationWorkbenchTransform initialTransform, int size, bool fitToCamera, float cameraFill)
				: base(provider, initialTransform, PresentationWorkbenchExportKind.IconFactory)
			{
				Size = size;
				FitToCamera = fitToCamera;
				CameraFill = cameraFill;
			}
		}

		internal string Id { get; }

		internal string DisplayName { get; }

		internal bool SupportsFirstPerson => FirstPerson != null;

		internal bool SupportsAvatar => Avatar != null;

		internal bool SupportsIcon => Icon != null;

		internal PreviewContext? FirstPerson { get; }

		internal AvatarPreviewContext? Avatar { get; }

		internal IconPreviewContext? Icon { get; }

		internal PresentationWorkbenchDefinition(string id, string displayName, PreviewContext? firstPerson, AvatarPreviewContext? avatar, IconPreviewContext? icon)
		{
			if (firstPerson == null && avatar == null && icon == null)
			{
				throw new ArgumentException("A presentation target must provide at least one preview.", "firstPerson");
			}
			Id = id;
			DisplayName = displayName;
			FirstPerson = firstPerson;
			Avatar = avatar;
			Icon = icon;
		}
	}
	internal static class PresentationWorkbenchResolver
	{
		internal const string ProductTarget = "product";

		internal const string ItemTarget = "item";

		internal static bool IsTargetKind(string value)
		{
			return value.Equals("product", StringComparison.OrdinalIgnoreCase) || value.Equals("item", StringComparison.OrdinalIgnoreCase);
		}

		internal static bool TryResolve(string id, string? targetKind, out PresentationWorkbenchDefinition? definition, out string failure)
		{
			definition = null;
			failure = string.Empty;
			if (string.IsNullOrWhiteSpace(id))
			{
				failure = "A product ID or item ID is required.";
				return false;
			}
			string text = id.Trim();
			string text2 = (string.IsNullOrWhiteSpace(targetKind) ? null : targetKind.Trim().ToLowerInvariant());
			if (text2 == "product")
			{
				if (ProductPresentationWorkbenchAdapter.TryCreateDefinition(text, out definition))
				{
					return true;
				}
				failure = "No product presentation profile is registered for '" + text + "'.";
				return false;
			}
			if (text2 == "item")
			{
				if (ItemPresentationWorkbenchAdapter.TryCreateDefinition(text, out definition))
				{
					return true;
				}
				failure = "Item '" + text + "' has no discoverable equippable visual.";
				return false;
			}
			if (text2 != null)
			{
				failure = "Unknown presentation target '" + targetKind + "'. Expected product or item.";
				return false;
			}
			if (ProductPresentationWorkbenchAdapter.TryCreateDefinition(text, out definition) || ItemPresentationWorkbenchAdapter.TryCreateDefinition(text, out definition))
			{
				return true;
			}
			failure = "No product profile or item equippable was found for '" + text + "'.";
			return false;
		}
	}
	internal static class PresentationWorkbenchRuntime
	{
		private sealed class Session : IDisposable
		{
			private readonly PlayerInventory _inventory;

			private readonly PlayerCamera _playerCamera;

			private readonly PlayerMovement _movement;

			private readonly bool _previousCanLook;

			private readonly bool _previousCanMove;

			private readonly bool _previousHotbarEnabled;

			private readonly bool _previousEquippingEnabled;

			private readonly CursorLockMode _previousCursorLockMode;

			private readonly bool _previousCursorVisible;

			private readonly GameObject? _previousEquippable;

			private readonly bool _previousEquippableActive;

			private readonly PreviewState? _firstPerson;

			private readonly PreviewState? _avatar;

			private readonly IconState? _icon;

			private readonly PresentationWorkbenchView _view;

			private PresentationWorkbenchMode _mode;

			private GameObject? _previewVisual;

			private GameObject? _avatarPreviewRoot;

			private GameObject? _avatarAnchor;

			private GameObject? _avatarStage;

			private Avatar? _avatarRig;

			private AvatarSettings? _avatarSettings;

			private Camera? _avatarCamera;

			private RenderTexture? _avatarTexture;

			private Vector3 _avatarLastMousePosition;

			private float _avatarYaw;

			private float _avatarPitch;

			private float _avatarDistance = 2.8f;

			private int _avatarSettleFrames;

			private int _avatarRendererRefreshFrames;

			private bool _avatarAppearanceApplied;

			private bool _avatarAnimationApplied;

			private bool _avatarHasMousePosition;

			private Texture2D? _iconTexture;

			private Sprite? _iconSprite;

			private float _iconRefreshAt = -1f;

			private int _iconCaptureRevision;

			private bool _iconCaptureRunning;

			private bool _disposed;

			internal PresentationWorkbenchDefinition Definition { get; }

			internal Session(PresentationWorkbenchDefinition definition, PlayerInventory inventory, PlayerCamera playerCamera, PlayerMovement movement)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				Definition = definition;
				_inventory = inventory;
				_playerCamera = playerCamera;
				_movement = movement;
				_previousCanLook = playerCamera.CanLook;
				_previousCanMove = movement.CanMove;
				_previousHotbarEnabled = inventory.HotbarEnabled;
				_previousEquippingEnabled = inventory.EquippingEnabled;
				_previousCursorLockMode = Cursor.lockState;
				_previousCursorVisible = Cursor.visible;
				Equippable equippable = inventory.Equippable;
				_previousEquippable = ((equippable != null) ? ((Component)equippable).gameObject : null);
				_previousEquippableActive = (Object)(object)_previousEquippable != (Object)null && _previousEquippable.activeSelf;
				_firstPerson = CreateState(definition.FirstPerson);
				_avatar = CreateState(definition.Avatar);
				_icon = CreateIconState(definition.Icon);
				_mode = GetFirstMode(definition);
				_view = new PresentationWorkbenchView(definition, SelectMode, UpdateTransform, ToggleFit, UpdateCameraFill, Reset, Copy, Close);
			}

			internal void Open()
			{
				_playerCamera.AddActiveUIElement("S1API.PresentationWorkbench");
				_playerCamera.SetCanLook(false);
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				_movement.CanMove = false;
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(_inventory, "HotbarEnabled", false);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(_inventory, "EquippingEnabled", false);
				GameObject? previousEquippable = _previousEquippable;
				if (previousEquippable != null)
				{
					previousEquippable.SetActive(false);
				}
				SelectMode(_mode);
			}

			internal void Tick()
			{
				if (_mode == PresentationWorkbenchMode.Icon && _iconRefreshAt >= 0f && Time.unscaledTime >= _iconRefreshAt && !_iconCaptureRunning)
				{
					_iconRefreshAt = -1f;
					_iconCaptureRunning = true;
					MelonCoroutines.Start(CaptureIconAfterRender(_iconCaptureRevision));
				}
				if (_mode == PresentationWorkbenchMode.Avatar && (Object)(object)_avatarCamera != (Object)null)
				{
					TickAvatarStage();
					UpdateAvatarCameraInput();
					UpdateAvatarCamera();
					_avatarCamera.Render();
				}
			}

			public void Dispose()
			{
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				if (!_disposed)
				{
					_disposed = true;
					DestroyPreview();
					DestroyIconTexture();
					_view.Dispose();
					if ((Object)(object)_previousEquippable != (Object)null)
					{
						_previousEquippable.SetActive(_previousEquippableActive);
					}
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(_inventory, "HotbarEnabled", _previousHotbarEnabled);
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(_inventory, "EquippingEnabled", _previousEquippingEnabled);
					_movement.CanMove = _previousCanMove;
					_playerCamera.RemoveActiveUIElement("S1API.PresentationWorkbench");
					_playerCamera.SetCanLook(_previousCanLook);
					Cursor.lockState = _previousCursorLockMode;
					Cursor.visible = _previousCursorVisible;
				}
			}

			private void SelectMode(PresentationWorkbenchMode mode)
			{
				if (Supports(mode))
				{
					DestroyPreview();
					_mode = mode;
					switch (mode)
					{
					case PresentationWorkbenchMode.FirstPerson:
						CreateFirstPersonPreview();
						break;
					case PresentationWorkbenchMode.Avatar:
						CreateAvatarPreview();
						break;
					case PresentationWorkbenchMode.Icon:
						ScheduleIconCapture(immediate: true);
						break;
					}
					PreviewState state = GetState(mode);
					_view.SetMode(mode, state.Current, _icon?.FitToCamera ?? false, _icon?.CameraFill ?? 0.72f);
				}
			}

			private void CreateFirstPersonPreview()
			{
				PreviewState firstPerson = _firstPerson;
				_previewVisual = CloneSource(firstPerson.Provider, "FirstPerson");
				_previewVisual.transform.SetParent(_inventory.EquipContainer, false);
				firstPerson.Current.ApplyTo(_previewVisual.transform);
				SetLayerRecursively(_previewVisual, "Viewmodel");
				DisablePhysics(_previewVisual);
				_previewVisual.SetActive(true);
				_view.SetPreview(null);
			}

			private void CreateAvatarPreview()
			{
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Expected O, but got Unknown
				//IL_00b9: 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)
				PreviewState avatar = _avatar;
				PresentationWorkbenchDefinition.AvatarPreviewContext avatar2 = Definition.Avatar;
				object avatar3 = CreateAvatarStage();
				ResolveAvatarHand(avatar3, avatar2.Hand, out Transform handContainer, out Transform alignmentPoint);
				_avatarPreviewRoot = CloneSource(avatar2.PreviewRootProvider, "Avatar");
				_previewVisual = avatar2.EditableVisualResolver(_avatarPreviewRoot) ?? throw new InvalidOperationException("The avatar preview prefab has no editable visual.");
				if (avatar2.AlignAvatarEquippable)
				{
					AlignAvatarEquippable(_avatarPreviewRoot, handContainer, alignmentPoint);
				}
				else
				{
					_avatarAnchor = new GameObject("S1API Avatar Preview Anchor");
					_avatarAnchor.transform.SetParent(handContainer, false);
					_avatarAnchor.transform.SetPositionAndRotation(alignmentPoint.position, alignmentPoint.rotation);
					_avatarPreviewRoot.transform.SetParent(_avatarAnchor.transform, false);
				}
				avatar.Current.ApplyTo(_previewVisual.transform);
				SetLayerRecursively(_avatarPreviewRoot, "IconGeneration");
				DisablePhysics(_avatarPreviewRoot);
				_avatarPreviewRoot.SetActive(true);
				CreateAvatarCamera();
			}

			private static void AlignAvatarEquippable(GameObject root, Transform handContainer, Transform handAlignmentPoint)
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: 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_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: 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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				AvatarEquippable componentInChildren = root.GetComponentInChildren<AvatarEquippable>(true);
				Transform val = ((componentInChildren != null) ? componentInChildren.AlignmentPoint : null);
				if ((Object)(object)val == (Object)null)
				{
					throw new InvalidOperationException("The avatar equippable preview has no alignment point.");
				}
				root.transform.SetParent(handContainer);
				root.transform.rotation = handAlignmentPoint.rotation * (Quaternion.Inverse(val.rotation) * root.transform.rotation);
				root.transform.position = handAlignmentPoint.position + (root.transform.position - val.position);
			}

			private object CreateAvatarStage()
			{
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				MugshotGenerator instance = Singleton<MugshotGenerator>.Instance;
				Avatar val = (((Object)(object)instance != (Object)null) ? instance.MugshotRig : null);
				if ((Object)(object)val == (Object)null)
				{
					throw new InvalidOperationException("The native avatar preview rig is not ready.");
				}
				int num = LayerMask.NameToLayer("IconGeneration");
				if (num < 0)
				{
					num = 30;
				}
				_avatarStage = new GameObject("S1API Presentation Workbench Avatar Stage");
				_avatarStage.transform.position = new Vector3(0f, -1000f, 0f);
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, _avatarStage.transform, false);
				((Object)val2).name = "Detached Avatar";
				val2.SetActive(true);
				LayerUtility.SetLayerRecursively(val2, num);
				Avatar val3 = (_avatarRig = val2.GetComponent<Avatar>() ?? throw new InvalidOperationException("The native avatar preview rig has no Avatar component."));
				AvatarSettings val4 = ((instance != null) ? instance.DefaultSettings : null);
				_avatarSettings = (AvatarSettings?)(((Object)(object)val.CurrentSettings != (Object)null) ? Object.Instantiate<AvatarSettings>(val.CurrentSettings) : (((Object)(object)val4 != (Object)null) ? ((object)Object.Instantiate<AvatarSettings>(val4)) : ((object)CreateFallbackAvatarSettings())));
				_avatarSettleFrames = 1;
				val3.SetVisible(true);
				if ((Object)(object)val3.Animation != (Object)null)
				{
					val3.Animation.AllowCulling = false;
				}
				RefreshAvatarRenderers();
				return val3;
			}

			private void TickAvatarStage()
			{
				if ((Object)(object)_avatarRig == (Object)null)
				{
					return;
				}
				if (!_avatarAppearanceApplied)
				{
					if (_avatarSettleFrames-- <= 0)
					{
						_avatarRig.LoadAvatarSettings(_avatarSettings);
						_avatarRig.SetVisible(true);
						_avatarRig.Impostor.DisableImpostor();
						if ((Object)(object)_avatarRig.Animation != (Object)null)
						{
							_avatarRig.Animation.AllowCulling = false;
						}
						_avatarRendererRefreshFrames = 2;
						_avatarAppearanceApplied = true;
						_avatarSettleFrames = 2;
						RefreshAvatarRenderers();
					}
					return;
				}
				if (!_avatarAnimationApplied)
				{
					if (_avatarSettleFrames-- > 0)
					{
						RefreshAvatarRenderers();
						return;
					}
					ApplyAvatarAnimation();
				}
				if (_avatarRendererRefreshFrames-- > 0)
				{
					RefreshAvatarRenderers();
				}
			}

			private static AvatarSettings CreateFallbackAvatarSettings()
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
				val.SkinColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
				val.Height = 1f;
				val.Gender = 0.5f;
				val.Weight = 0.5f;
				val.EyeBallTint = Color.white;
				val.PupilDilation = 1f;
				val.HairPath = string.Empty;
				val.HairColor = Color.black;
				val.LeftEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = 0.5f,
					bottomLidOpen = 0.5f
				};
				val.RightEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = 0.5f,
					bottomLidOpen = 0.5f
				};
				val.LeftEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
				val.RightEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
				return val;
			}

			private void ApplyAvatarAnimation()
			{
				if ((Object)(object)_avatarRig == (Object)null || _avatarAnimationApplied)
				{
					return;
				}
				_avatarAnimationApplied = true;
				PresentationWorkbenchDefinition.AvatarPreviewContext avatar = Definition.Avatar;
				if (!string.IsNullOrWhiteSpace(avatar.AnimationTrigger))
				{
					if (avatar.AnimationUsesBool)
					{
						_avatarRig.SetAnimationBool(avatar.AnimationTrigger, true);
					}
					else
					{
						_avatarRig.SetAnimationTrigger(avatar.AnimationTrigger);
					}
				}
			}

			private void RefreshAvatarRenderers()
			{
				if (!((Object)(object)_avatarRig == (Object)null))
				{
					SetLayerRecursively(((Component)_avatarRig).gameObject, "IconGeneration");
					Il2CppArrayBase<SkinnedMeshRenderer> componentsInChildren = ((Component)_avatarRig).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						componentsInChildren[i].updateWhenOffscreen = true;
					}
				}
			}

			private void CreateAvatarCamera()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Expected O, but got Unknown
				//IL_014c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0165: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_avatarStage == (Object)null)
				{
					throw new InvalidOperationException("The avatar preview stage is unavailable.");
				}
				int num = LayerMask.NameToLayer("IconGeneration");
				if (num < 0)
				{
					num = 30;
				}
				GameObject val = new GameObject("S1API Presentation Workbench Camera");
				val.transform.SetParent(_avatarStage.transform, false);
				_avatarCamera = val.AddComponent<Camera>();
				((Behaviour)_avatarCamera).enabled = true;
				_avatarCamera.clearFlags = (CameraClearFlags)2;
				_avatarCamera.backgroundColor = new Color(0.025f, 0.03f, 0.04f, 1f);
				_avatarCamera.fieldOfView = 34f;
				_avatarCamera.nearClipPlane = 0.05f;
				_avatarCamera.farClipPlane = 20f;
				_avatarCamera.cullingMask = 1 << num;
				_avatarTexture = new RenderTexture(640, 800, 24, (RenderTextureFormat)0)
				{
					name = "S1API Presentation Workbench Avatar",
					antiAliasing = 2
				};
				_avatarTexture.Create();
				_avatarCamera.targetTexture = _avatarTexture;
				CreateAvatarKeyLight(num);
				CreateAvatarLight("Fill Light", new Vector3(30f, 210f, 0f), 0.65f, new Color(0.55f, 0.72f, 1f), num);
				UpdateAvatarCamera();
				_view.SetPreview((Texture?)(object)_avatarTexture);
			}

			private void CreateAvatarKeyLight(int layer)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				//IL_0039: 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_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("Key Light");
				val.transform.SetParent(_avatarStage.transform, false);
				val.transform.localPosition = new Vector3(-2f, 3f, -3f);
				val.transform.LookAt(_avatarStage.transform.position + Vector3.up);
				Light val2 = val.AddComponent<Light>();
				val2.type = (LightType)1;
				val2.intensity = 1.25f;
				val2.color = new Color(1f, 0.88f, 0.76f);
				val2.cullingMask = 1 << layer;
			}

			private void UpdateAvatarCameraInput()
			{
				//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_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: 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_004e: 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_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 mousePosition = Input.mousePosition;
				if (!_avatarHasMousePosition)
				{
					_avatarLastMousePosition = mousePosition;
					_avatarHasMousePosition = true;
					return;
				}
				if (_view.IsPointerOverPreview(Vector2.op_Implicit(mousePosition)))
				{
					if (Input.GetMouseButton(0))
					{
						Vector3 val = mousePosition - _avatarLastMousePosition;
						_avatarYaw += val.x * 0.35f;
						_avatarPitch = Mathf.Clamp(_avatarPitch - val.y * 0.35f, -25f, 45f);
					}
					_avatarDistance = Mathf.Clamp(_avatarDistance - Input.mouseScrollDelta.y * 0.2f, 1.45f, 4.5f);
				}
				_avatarLastMousePosition = mousePosition;
			}

			private void UpdateAvatarCamera()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_avatarCamera == (Object)null) && !((Object)(object)_avatarStage == (Object)null))
				{
					Vector3 val = _avatarStage.transform.position + new Vector3(0f, 1.05f, 0f);
					Quaternion val2 = Quaternion.Euler(_avatarPitch, _avatarYaw, 0f);
					((Component)_avatarCamera).transform.position = val + val2 * new Vector3(0f, 0f, _avatarDistance);
					((Component)_avatarCamera).transform.LookAt(val);
				}
			}

			private void CreateAvatarLight(string name, Vector3 rotation, float intensity, Color color, int layer)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject(name);
				val.transform.SetParent(_avatarStage.transform, false);
				val.transform.localEulerAngles = rotation;
				Light val2 = val.AddComponent<Light>();
				val2.type = (LightType)1;
				val2.intensity = intensity;
				val2.color = color;
				val2.cullingMask = 1 << layer;
			}

			private void ResolveAvatarHand(object avatar, AvatarHand hand, out Transform handContainer, out Transform alignmentPoint)
			{
				object target = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(avatar, "Animation") ?? throw new InvalidOperationException("The local player avatar animation rig is unavailable.");
				string text = ((hand == AvatarHand.Left) ? "LeftHand" : "RightHand");
				object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(target, text + "Container");
				handContainer = (Transform)(((obj is Transform) ? obj : null) ?? throw new InvalidOperationException(text + "Container is unavailable."));
				object? obj2 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(target, text + "AlignmentPoint");
				alignmentPoint = (Transform)(((obj2 is Transform) ? obj2 : null) ?? throw new InvalidOperationException(text + "AlignmentPoint is unavailable."));
			}

			private void UpdateTransform(Vector3 position, Vector3 rotation, Vector3 scale)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				if (!IsFinite(position) || !IsFinite(rotation) || !IsFinite(scale))
				{
					_view.SetStatus("Transform values must be finite.");
					return;
				}
				PresentationWorkbenchTransform presentationWorkbenchTransform = new PresentationWorkbenchTransform(position, rotation, scale);
				PreviewState state = GetState(_mode);
				state.Current = presentationWorkbenchTransform;
				if ((Object)(object)_previewVisual != (Object)null)
				{
					presentationWorkbenchTransform.ApplyTo(_previewVisual.transform);
				}
				if (_mode == PresentationWorkbenchMode.Icon)
				{
					ScheduleIconCapture(immediate: false);
				}
				_view.SetStatus("Preview updated.");
			}

			private void ToggleFit()
			{
				if (_mode == PresentationWorkbenchMode.Icon && _icon != null)
				{
					_icon.FitToCamera = !_icon.FitToCamera;
					_view.SetMode(_mode, _icon.Current, _icon.FitToCamera, _icon.CameraFill);
					ScheduleIconCapture(immediate: false);
				}
			}

			private void UpdateCameraFill(float value)
			{
				if (_mode == PresentationWorkbenchMode.Icon && _icon != null)
				{
					if (value <= 0f || value > 2f)
					{
						_view.SetStatus("Camera fill must be greater than zero and at most 2.");
						return;
					}
					_icon.CameraFill = value;
					ScheduleIconCapture(immediate: false);
					_view.SetStatus("Icon recapture scheduled.");
				}
			}

			private void Reset()
			{
				PreviewState state = GetState(_mode);
				state.Current = state.Initial;
				if (_icon != null && _mode == PresentationWorkbenchMode.Icon)
				{
					_icon.FitToCamera = _icon.InitialFitToCamera;
					_icon.CameraFill = _icon.InitialCameraFill;
					ScheduleIconCapture(immediate: false);
				}
				else if ((Object)(object)_previewVisual != (Object)null)
				{
					state.Current.ApplyTo(_previewVisual.transform);
				}
				if (_mode == PresentationWorkbenchMode.Avatar)
				{
					_avatarYaw = 0f;
					_avatarPitch = 0f;
					_avatarDistance = 2.8f;
					UpdateAvatarCamera();
				}
				_view.SetMode(_mode, state.Current, _icon?.FitToCamera ?? false, _icon?.CameraFill ?? 0.72f);
				_view.SetStatus("Initial values restored.");
			}

			private void Copy()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: 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)
				PreviewState state = GetState(_mode);
				string systemCopyBuffer = ((_mode == PresentationWorkbenchMode.Icon && _icon != null) ? PresentationWorkbenchExporter.FormatIcon(state.Current.LocalEulerAngles, state.Current.LocalScale, _icon.FitToCamera, _icon.CameraFill, _icon.Size) : PresentationWorkbenchExporter.FormatTransform(state.ExportKind, state.Current.LocalPosition, state.Current.LocalEulerAngles, state.Current.LocalScale));
				GUIUtility.systemCopyBuffer = systemCopyBuffer;
				_view.SetStatus("Copied C# values to the clipboard.");
			}

			private void ScheduleIconCapture(bool immediate)
			{
				_iconCaptureRevision++;
				_iconRefreshAt = Time.unscaledTime + (immediate ? 0f : 0.12f);
				_view.SetStatus(immediate ? "Preparing icon preview..." : "Icon recapture scheduled.");
			}

			private IEnumerator CaptureIconAfterRender(int revision)
			{
				try
				{
					for (int attempt = 1; attempt <= 8; attempt++)
					{
						yield return null;
						yield return (object)new WaitForEndOfFrame();
						if (_disposed || _mode != PresentationWorkbenchMode.Icon || revision != _iconCaptureRevision)
						{
							yield break;
						}
						if (TryCaptureIcon())
						{
							_view.SetStatus($"Icon preview captured after {attempt} attempt(s).");
							yield break;
						}
					}
					_view.SetStatus("Icon capture produced no visible pixels after 8 attempts.");
				}
				finally
				{
					_iconCaptureRunning = false;
					if (!_disposed && _mode == PresentationWorkbenchMode.Icon && revision != _iconCaptureRevision)
					{
						_iconRefreshAt = Time.unscaledTime;
					}
				}
			}

			private bool TryCaptureIcon()
			{
				IconState icon = _icon;
				GameObject val = CloneSource(icon.Provider, "Icon");
				try
				{
					icon.Current.ApplyTo(val.transform);
					Sprite val2 = IconFactory.GenerateIconSprite(val.transform, icon.Size, bakeSkinnedMeshes: true, icon.FitToCamera, icon.CameraFill);
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.texture == (Object)null)
					{
						if ((Object)(object)val2 != (Object)null)
						{
							Object.Destroy((Object)(object)val2);
						}
						return false;
					}
					DestroyIconTexture();
					_iconSprite = val2;
					_iconTexture = val2.texture;
					_view.SetPreview((Texture?)(object)_iconTexture);
					return true;
				}
				finally
				{
					Object.Destroy((Object)(object)val);
				}
			}

			private void DestroyPreview()
			{
				if ((Object)(object)_avatarPreviewRoot != (Object)null)
				{
					Object.Destroy((Object)(object)_avatarPreviewRoot);
				}
				else if ((Object)(object)_previewVisual != (Object)null)
				{
					Object.Destroy((Object)(object)_previewVisual);
				}
				if ((Object)(object)_avatarAnchor != (Object)null)
				{
					Object.Destroy((Object)(object)_avatarAnchor);
				}
				if ((Object)(object)_avatarCamera != (Object)null)
				{
					_avatarCamera.targetTexture = null;
					Object.Destroy((Object)(object)((Component)_avatarCamera).gameObject);
				}
				if ((Object)(object)_avatarTexture != (Object)null)
				{
					_avatarTexture.Release();
					Object.Destroy((Object)(object)_avatarTexture);
				}
				if ((Object)(object)_avatarStage != (Object)null)
				{
					Object.Destroy((Object)(object)_avatarStage);
				}
				if ((Object)(object)_avatarSettings != (Object)null)
				{
					Object.Destroy((Object)(object)_avatarSettings);
				}
				_previewVisual = null;
				_avatarPreviewRoot = null;
				_avatarAnchor = null;
				_avatarStage = null;
				_avatarRig = null;
				_avatarSettings = null;
				_avatarCamera = null;
				_avatarTexture = null;
				_avatarSettleFrames = 0;
				_avatarRendererRefreshFrames = 0;
				_avatarAppearanceApplied = false;
				_avatarAnimationApplied = false;
				_avatarHasMousePosition = false;
				_view.SetPreview(null);
			}

			private void DestroyIconTexture()
			{
				if ((Object)(object)_iconSprite != (Object)null)
				{
					Object.Destroy((Object)(object)_iconSprite);
				}
				if ((Object)(object)_iconTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_iconTexture);
				}
				_iconSprite = null;
				_iconTexture = null;
			}

			private bool Supports(PresentationWorkbenchMode mode)
			{
				return mode switch
				{
					PresentationWorkbenchMode.Avatar => _avatar != null, 
					PresentationWorkbenchMode.FirstPerson => _firstPerson != null, 
					_ => _icon != null, 
				};
			}

			private PreviewState GetState(PresentationWorkbenchMode mode)
			{
				return mode switch
				{
					PresentationWorkbenchMode.Avatar => _avatar, 
					PresentationWorkbenchMode.FirstPerson => _firstPerson, 
					_ => _icon, 
				};
			}

			private static PreviewState? CreateState(PresentationWorkbenchDefinition.PreviewContext? context)
			{
				if (context == null)
				{
					return null;
				}
				return new PreviewState(context.Provider, context.InitialTransform ?? CaptureAuthoredTransform(context.Provider), context.ExportKind);
			}

			private static PreviewState? CreateState(PresentationWorkbenchDefinition.AvatarPreviewContext? context)
			{
				if (context == null)
				{
					return null;
				}
				return new PreviewState(context.Provider, context.InitialTransform ?? CaptureAuthoredTransform(context.Provider), context.ExportKind);
			}

			private static IconState? CreateIconState(PresentationWorkbenchDefinition.IconPreviewContext? context)
			{
				if (context == null)
				{
					return null;
				}
				return new IconState(context.Provider, context.InitialTransform ?? CaptureAuthoredTransform(context.Provider), context.Size, context.FitToCamera, context.CameraFill);
			}

			private static PresentationWorkbenchTransform CaptureAuthoredTransform(Func<GameObject?> provider)
			{
				GameObject source = GetSource(provider, "initial");
				return PresentationWorkbenchTransform.From(source.transform);
			}

			private static GameObject CloneSource(Func<GameObject?> provider, string context)
			{
				GameObject source = GetSource(provider, context);
				GameObject val = Object.Instantiate<GameObject>(source);
				val.SetActive(false);
				DisableBehaviours(val);
				((Object)val).name = $"S1API {context} Preview ({((Object)source).name})";
				return val;
			}

			private static GameObject GetSource(Func<GameObject?> provider, string context)
			{
				GameObject val;
				try
				{
					val = provider();
				}
				catch (Exception innerException)
				{
					throw new InvalidOperationException(context + " preview source provider threw an exception.", innerException);
				}
				return val ?? throw new InvalidOperationException(context + " preview source provider returned null.");
			}

			private static PresentationWorkbenchMode GetFirstMode(PresentationWorkbenchDefinition definition)
			{
				if (definition.SupportsFirstPerson)
				{
					return PresentationWorkbenchMode.FirstPerson;
				}
				if (definition.SupportsAvatar)
				{
					return PresentationWorkbenchMode.Avatar;
				}
				return PresentationWorkbenchMode.Icon;
			}

			private static void SetLayerRecursively(GameObject root, string layerName)
			{
				int num = LayerMask.NameToLayer(layerName);
				if (num >= 0)
				{
					LayerUtility.SetLayerRecursively(root, num);
				}
			}

			private static void DisablePhysics(GameObject root)
			{
				Il2CppArrayBase<Collider> componentsInChildren = root.GetComponentsInChildren<Collider>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
				}
				Il2CppArrayBase<Rigidbody> componentsInChildren2 = root.GetComponentsInChildren<Rigidbody>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					Rigidbody val = componentsInChildren2[j];
					val.isKinematic = true;
					val.detectCollisions = false;
				}
			}

			private static void DisableBehaviours(GameObject root)
			{
				Il2CppArrayBase<Behaviour> componentsInChildren = root.GetComponentsInChildren<Behaviour>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = false;
				}
			}

			private static bool IsFinite(Vector3 value)
			{
				//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
				return IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z);
			}

			private static bool IsFinite(float value)
			{
				return !float.IsNaN(value) && !float.IsInfinity(value);
			}
		}

		private class PreviewState
		{
			internal Func<GameObject?> Provider { get; }

			internal PresentationWorkbenchTransform Initial { get; }

			internal PresentationWorkbenchTransform Current { get; set; }

			internal PresentationWorkbenchExportKind ExportKind { get; }

			internal PreviewState(Func<GameObject?> provider, PresentationWorkbenchTransform initial, PresentationWorkbenchExportKind exportKind)
			{
				Provider = provider;
				Initial = initial;
				Current = initial;
				ExportKind = exportKind;
			}
		}

		private sealed class IconState : PreviewState
		{
			internal int Size { get; }

			internal bool InitialFitToCamera { get; }

			internal bool FitToCamera { get; set; }

			internal float InitialCameraFill { get; }

			internal float CameraFill { get; set; }

			internal IconState(Func<GameObject?> provider, PresentationWorkbenchTransform initial, int size, bool fitToCamera, float cameraFill)
				: base(provider, initial, PresentationWorkbenchExportKind.IconFactory)
			{
				Size = size;
				InitialFitToCamera = fitToCamera;
				FitToCamera = fitToCamera;
				InitialCameraFill = cameraFill;
				CameraFill = cameraFill;
			}
		}

		private const string ActiveUiName = "S1API.PresentationWorkbench";

		private const float IconDebounceSeconds = 0.12f;

		private static readonly Log Logger = new Log("PresentationWorkbench");

		private static Session? _session;

		internal static bool IsOpen => _session != null;

		internal static string? ActiveDefinitionId => _session?.Definition.Id;

		internal static bool Open(string id, string? targetKind = null)
		{
			Close();
			PresentationWorkbenchDefinition definition = null;
			try
			{
				if (!PresentationWorkbenchResolver.TryResolve(id, targetKind, out definition, out string failure) || definition == null)
				{
					Logger.Warning(failure);
					return false;
				}
				if (!TryGetGameplayState(out Player _, out PlayerInventory inventory, out PlayerCamera playerCamera, out PlayerMovement movement))
				{
					Logger.Warning("The presentation workbench requires a spawned local player in a render-ready Main or Tutorial scene.");
					return false;
				}
				(_session = new Session(definition, inventory, playerCamera, movement)).Open();
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Could not open presentation workbench '" + (definition?.Id ?? id) + "': " + ex);
				Close();
				return false;
			}
		}

		internal static void Tick()
		{
			try
			{
				_session?.Tick();
			}
			catch (Exception value)
			{
				Logger.Error($"Presentation workbench update failed: {value}");
				Close();
			}
		}

		internal static void Close()
		{
			Session session = _session;
			_session = null;
			if (session == null)
			{
				return;
			}
			try
			{
				session.Dispose();
			}
			catch (Exception value)
			{
				Logger.Error($"Presentation workbench cleanup failed: {value}");
			}
		}

		private static bool TryGetGameplayState(out Player? player, out PlayerInventory? inventory, out PlayerCamera? playerCamera, out PlayerMovement? movement)
		{
			player = Player.Local;
			inventory = (PlayerSingleton<PlayerInventory>.InstanceExists ? PlayerSingleton<PlayerInventory>.Instance : null);
			playerCamera = (PlayerSingleton<PlayerCamera>.InstanceExists ? PlayerSingleton<PlayerCamera>.Instance : null);
			movement = (PlayerSingleton<PlayerMovement>.InstanceExists ? PlayerSingleton<PlayerMovement>.Instance : null);
			return (Object)(object)player != (Object)null && (Object)(object)inventory != (Object)null && (Object)(object)playerCamera != (Object)null && (Object)(object)movement != (Object)null && (Object)(object)inventory.EquipContainer != (Object)null;
		}
	}
	internal sealed class PresentationWorkbenchView : IDisposable
	{
		private sealed class ButtonBinding
		{
			internal Button Button { get; }

			internal Action Action { get; }

			internal ButtonBinding(Button button, Action action)
			{
				Button = button;
				Action = action;
			}
		}

		private sealed class InputBinding
		{
			internal InputField Input { get; }

			internal Action<string> Action { get; }

			internal bool Live { get; }

			internal InputBinding(InputField input, Action<string> action, bool live)
			{
				Input = input;
				Action = action;
				Live = live;
			}
		}

		private readonly List<ButtonBinding> _buttonBindings = new List<ButtonBinding>();

		private readonly List<InputBinding> _inputBindings = new List<InputBinding>();

		private readonly GameObject _root;

		private readonly Transform _modeRow;

		private readonly Text _contextText;

		private readonly RawImage _preview;

		private readonly GameObject _previewPanel;

		private readonly InputField[] _positionFields;

		private readonly InputField[] _rotationFields;

		private readonly InputField[] _scaleFields;

		private readonly GameObject _positionRow;

		private readonly GameObject _scaleRow;

		private readonly GameObject _iconRow;

		private readonly Text _fitLabel;

		private readonly InputField _cameraFillField;

		private readonly Text _status;

		internal PresentationWorkbenchView(PresentationWorkbenchDefinition definition, Action<PresentationWorkbenchMode> selectMode, Action<Vector3, Vector3, Vector3> updateTransform, Action toggleFit, Action<float> updateCameraFill, Action reset, Action copy, Action close)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Expected O, but got Unknown
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_059a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Expected O, but got Unknown
			//IL_05f2: Unknown result type (might be due to invalid IL or missing references)
			PresentationWorkbenchView presentationWorkbenchView = this;
			_root = new GameObject("S1API Presentation Workbench");
			Canvas val = _root.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			val.sortingOrder = 32000;
			_root.AddComponent<GraphicRaycaster>();
			CanvasScaler val2 = _root.AddComponent<CanvasScaler>();
			val2.uiScaleMode = (ScaleMode)1;
			val2.referenceResolution = new Vector2(1920f, 1080f);
			val2.matchWidthOrHeight = 0.5f;
			GameObject val3 = Panel("Shell", _root.transform, new Color(0.035f, 0.04f, 0.05f, 0.97f));
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.025f, 0.04f);
			component.anchorMax = new Vector2(0.975f, 0.96f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Text val4 = CreateText("Title", definition.DisplayName + "\n<size=18><color=#92A1B5>" + definition.Id + "</color></size>", val3.transform, 28, (TextAnchor)0, (FontStyle)1);
			SetRect(((Graphic)val4).rectTransform, 0.025f, 0.88f, 0.72f, 0.975f);
			Button val5 = CreateButton("Close", "Close", val3.transform);
			SetRect(((Component)val5).GetComponent<RectTransform>(), 0.87f, 0.91f, 0.97f, 0.97f);
			Bind(val5, close);
			GameObject val6 = Panel("Controls", val3.transform, new Color(0.075f, 0.085f, 0.105f, 1f));
			SetRect(val6.GetComponent<RectTransform>(), 0.025f, 0.05f, 0.47f, 0.865f);
			GameObject val7 = new GameObject("Modes");
			val7.transform.SetParent(val6.transform, false);
			val7.AddComponent<RectTransform>();
			_modeRow = val7.transform;
			SetRect(val7.GetComponent<RectTransform>(), 0.04f, 0.88f, 0.96f, 0.965f);
			float nextX = 0f;
			AddModeButton(definition.SupportsFirstPerson, "First person", PresentationWorkbenchMode.FirstPerson, ref nextX, selectMode);
			AddModeButton(definition.SupportsAvatar, "Avatar", PresentationWorkbenchMode.Avatar, ref nextX, selectMode);
			AddModeButton(definition.SupportsIcon, "Icon", PresentationWorkbenchMode.Icon, ref nextX, selectMode);
			_contextText = CreateText("Context", string.Empty, val6.transform, 18, (TextAnchor)3, (FontStyle)1);
			SetRect(((Graphic)_contextText).rectTransform, 0.04f, 0.81f, 0.96f, 0.875f);
			_positionRow = CreateVectorRow("Position", val6.transform, 0.68f, out _positionFields);
			GameObject val8 = CreateVectorRow("Rotation", val6.transform, 0.54f, out _rotationFields);
			_scaleRow = CreateVectorRow("Scale", val6.transform, 0.4f, out _scaleFields);
			BindVectorFields(_positionFields, _rotationFields, _scaleFields, updateTransform);
			_iconRow = new GameObject("IconSettings");
			_iconRow.transform.SetParent(val6.transform, false);
			_iconRow.AddComponent<RectTransform>();
			SetRect(_iconRow.GetComponent<RectTransform>(), 0.04f, 0.28f, 0.96f, 0.385f);
			Button val9 = CreateButton("Fit", "Fit: On", _iconRow.transform);
			SetRect(((Component)val9).GetComponent<RectTransform>(), 0f, 0.12f, 0.39f, 0.88f);
			_fitLabel = ((Component)val9).GetComponentInChildren<Text>();
			Bind(val9, toggleFit);
			_cameraFillField = CreateInput("CameraFill", _iconRow.transform, "Fill");
			SetRect(((Component)_cameraFillField).GetComponent<RectTransform>(), 0.43f, 0.12f, 1f, 0.88f);
			Bind(_cameraFillField, delegate(string value)
			{
				if (TryParse(value, out var result))
				{
					updateCameraFill(result);
				}
				else if (!IsIncompleteNumericInput(value))
				{
					presentationWorkbenchView.SetStatus("Camera fill must be a finite number.");
				}
			}, live: true);
			Button val10 = CreateButton("Reset", "Reset", val6.transform);
			SetRect(((Component)val10).GetComponent<RectTransform>(), 0.04f, 0.17f, 0.47f, 0.245f);
			Bind(val10, reset);
			Button val11 = CreateButton("Copy", "Copy C#", val6.transform);
			SetRect(((Component)val11).GetComponent<RectTransform>(), 0.53f, 0.17f, 0.96f, 0.245f);
			Bind(val11, copy);
			_status = CreateText("Status", "Preview edits are temporary. Copy C# to persist them.", val6.transform, 15, (TextAnchor)0, (FontStyle)0);
			SetRect(((Graphic)_status).rectTransform, 0.04f, 0.025f, 0.96f, 0.145f);
			_previewPanel = Panel("Preview", val3.transform, new Color(0.015f, 0.018f, 0.022f, 1f));
			SetRect(_previewPanel.GetComponent<RectTransform>(), 0.495f, 0.05f, 0.975f, 0.865f);
			GameObject val12 = new GameObject("PreviewTexture");
			val12.transform.SetParent(_previewPanel.transform, false);
			RectTransform rect = val12.AddComponent<RectTransform>();
			SetRect(rect, 0.025f, 0.025f, 0.975f, 0.975f);
			_preview = val12.AddComponent<RawImage>();
			((Graphic)_preview).color = Color.white;
		}

		internal void SetMode(PresentationWorkbenchMode mode, PresentationWorkbenchTransform transform, bool fitToCamera, float cameraFill)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			_contextText.text = mode switch
			{
				PresentationWorkbenchMode.Avatar => "Third-person avatar", 
				PresentationWorkbenchMode.FirstPerson => "First-person viewmodel", 
				_ => "Native icon capture", 
			};
			bool flag = mode == PresentationWorkbenchMode.Icon;
			_positionRow.SetActive(!flag);
			_scaleRow.SetActive(!flag || !fitToCamera);
			_iconRow.SetActive(flag);
			_previewPanel.SetActive(mode != PresentationWorkbenchMode.FirstPerson);
			_fitLabel.text = (fitToCamera ? "Fit: On" : "Fit: Off");
			_cameraFillField.SetTextWithoutNotify(Format(cameraFill));
			SetVector(_positionFields, transform.LocalPosition);
			SetVector(_rotationFields, transform.LocalEulerAngles);
			SetVector(_scaleFields, transform.LocalScale);
			SetStatus((mode == PresentationWorkbenchMode.Avatar) ? "Drag to orbit and scroll to zoom. Preview edits are temporary." : "Preview edits update live. Copy C# to persist them.");
		}

		internal void SetPreview(Texture? texture)
		{
			_preview.texture = texture;
		}

		internal bool IsPointerOverPreview(Vector2 screenPoint)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return _previewPanel.activeInHierarchy && RectTransformUtility.RectangleContainsScreenPoint(((Graphic)_preview).rectTransform, screenPoint);
		}

		internal void SetStatus(string message)
		{
			_status.text = message;
		}

		public void Dispose()
		{
			foreach (ButtonBinding buttonBinding in _buttonBindings)
			{
				global::S1API.Utils.EventHelper.RemoveListener(buttonBinding.Action, (UnityEvent)(object)buttonBinding.Button.onClick);
			}
			foreach (InputBinding inputBinding in _inputBindings)
			{
				global::S1API.Utils.EventHelper.RemoveListener(inputBinding.Action, (UnityEvent<string>)(inputBinding.Live ? ((object)inputBinding.Input.onValueChanged) : ((object)inputBinding.Input.onEndEdit)));
			}
			_buttonBindings.Clear();
			_inputBindings.Clear();
			Object.Destroy((Object)(object)_root);
		}

		private void AddModeButton(bool supported, string label, PresentationWorkbenchMode mode, ref float nextX, Action<PresentationWorkbenchMode> selectMode)
		{
			if (supported)
			{
				Button val = CreateButton(mode.ToString(), label, _modeRow);
				SetRect(((Component)val).GetComponent<RectTransform>(), nextX, 0f, Mathf.Min(nextX + 0.31f, 1f), 1f);
				Bind(val, delegate
				{
					selectMode(mode);
				});
				nextX += 0.335f;
			}
		}

		private void BindVectorFields(IReadOnlyList<InputField> position, IReadOnlyList<InputField> rotation, IReadOnlyList<InputField> scale, Action<Vector3, Vector3, Vector3> update)
		{
			for (int i = 0; i < 3; i++)
			{
				Bind(position[i], Apply, live: true);
				Bind(rotation[i], Apply, live: true);
				Bind(scale[i], Apply, live: true);
			}
			void Apply(string _)
			{
				//IL_003a: 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_003c: Unknown result type (might be due to invalid IL or missing references)
				if (TryRead(position, out var result) && TryRead(rotation, out var result2) && TryRead(scale, out var result3))
				{
					update(result, result2, result3);
				}
				else if (!HasIncompleteNumericInput(position) && !HasIncompleteNumericInput(rotation) && !HasIncompleteNumericInput(scale))
				{
					SetStatus("Enter finite numeric values for every axis.");
				}
			}
		}

		private void Bind(Button button, Action action)
		{
			global::S1API.Utils.EventHelper.AddListener(action, (UnityEvent)(object)button.onClick);
			_buttonBindings.Add(new ButtonBinding(button, action));
		}

		private void Bind(InputField input, Action<string> action, bool live = false)
		{
			Action<string> action2 = CreateInputBindingAction(action);
			global::S1API.Utils.EventHelper.AddListener(action2, (UnityEvent<string>)(live ? ((object)input.onValueChanged) : ((object)input.onEndEdit)));
			_inputBindings.Add(new InputBinding(input, action2, live));
		}

		internal static Action<string> CreateInputBindingAction(Action<string> action)
		{
			return delegate(string value)
			{
				action(value);
			};
		}

		private static GameObject CreateVectorRow(string label, Transform parent, float y, out InputField[] fields)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(label);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			SetRect(val.GetComponent<RectTransform>(), 0.04f, y, 0.96f, y + 0.115f);
			Text val2 = CreateText("Label", label, val.transform, 15, (TextAnchor)0, (FontStyle)1);
			SetRect(((Graphic)val2).rectTransform, 0f, 0.62f, 1f, 1f);
			fields = (InputField[])(object)new InputField[3];
			string[] array = new string[3] { "X", "Y", "Z" };
			for (int i = 0; i < array.Length; i++)
			{
				fields[i] = CreateInput(array[i], val.transform, array[i]);
				float num = (float)i * 0.335f;
				SetRect(((Component)fields[i]).GetComponent<RectTransform>(), num, 0f, Mathf.Min(num + 0.31f, 1f), 0.56f);
			}
			return val;
		}

		private static InputField CreateInput(string name, Transform parent, string placeholder)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(name, parent, new Color(0.12f, 0.135f, 0.16f, 1f));
			InputField val2 = val.AddComponent<InputField>();
			Text val3 = CreateText("Text", string.Empty, val.transform, 16, (TextAnchor)3, (FontStyle)0);
			SetRect(((Graphic)val3).rectTransform, 0.06f, 0f, 0.94f, 1f);
			Text val4 = CreateText("Placeholder", placeholder, val.transform, 16, (TextAnchor)3, (FontStyle)2);
			((Graphic)val4).color = new Color(0.55f, 0.6f, 0.67f, 1f);
			SetRect(((Graphic)val4).rectTransform, 0.06f, 0f, 0.94f, 1f);
			val2.textComponent = val3;
			val2.placeholder = (Graphic)(object)val4;
			val2.contentType = (ContentType)3;
			return val2;
		}

		private static Button CreateButton(string name, string label, Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(name, parent, new Color(0.16f, 0.32f, 0.5f, 1f));
			Button val2 = val.AddComponent<Button>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			Text val3 = CreateText("Label", label, val.transform, 16, (TextAnchor)4, (FontStyle)1);
			SetRect(((Graphic)val3).rectTransform, 0f, 0f, 1f, 1f);
			return val2;
		}

		private static GameObject Panel(string name, Transform parent, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			((Graphic)val.AddComponent<Image>()).color = color;
			return val;
		}

		private static Text CreateText(string name, string value, Transform parent, int size, TextAnchor anchor, FontStyle style)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_003f: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			Text val2 = val.AddComponent<Text>();
			val2.text = value;
			val2.font = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
			val2.fontSize = size;
			val2.alignment = anchor;
			val2.fontStyle = style;
			((Graphic)val2).color = Color.white;
			val2.supportRichText = true;
			val2.horizontalOverflow = (HorizontalWrapMode)0;
			val2.verticalOverflow = (VerticalWrapMode)0;
			return val2;
		}

		private static void SetRect(RectTransform rect, float minX, float minY, float maxX, float maxY)
		{
			//IL_0004: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = new Vector2(minX, minY);
			rect.anchorMax = new Vector2(maxX, maxY);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private static void SetVector(InputField[] fields, Vector3 value)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			fields[0].SetTextWithoutNotify(Format(value.x));
			fields[1].SetTextWithoutNotify(Format(value.y));
			fields[2].SetTextWithoutNotify(Format(value.z));
		}

		private static bool TryRead(IReadOnlyList<InputField> fields, out Vector3 result)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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)
			if (TryParse(fields[0].text, out var result2) && TryParse(fields[1].text, out var result3) && TryParse(fields[2].text, out var result4))
			{
				result = new Vector3(result2, result3, result4);
				return true;
			}
			result = Vector3.zero;
			return false;
		}

		private static bool TryParse(string value, out float result)
		{
			return float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out result) && !float.IsNaN(result) && !float.IsInfinity(result);
		}

		internal static bool IsIncompleteNumericInput(string value)
		{
			string text = value?.Trim() ?? string.Empty;
			if (text.Length != 0)
			{
				switch (text)
				{
				default:
					if (!(text == "-."))
					{
						int num = text.IndexOf('e');
						if (num < 0)
						{
							num = text.IndexOf('E');
						}
						if (num < 0)
						{
							return false;
						}
						return (text.Length - num - 1) switch
						{
							1 => text[text.Length - 1] == '+' || text[text.Length - 1] == '-', 
							0 => true, 
							_ => false, 
						};
					}
					break;
				case "+":
				case "-":
				case ".":
				case "+.":
					break;
				}
			}
			return true;
		}

		private static bool HasIncompleteNumericInput(IReadOnlyList<InputField> fields)
		{
			for (int i = 0; i < fields.Count; i++)
			{
				if (IsIncompleteNumericInput(fields[i].text))
				{
					return true;
				}
			}
			return false;
		}

		private static string Format(float value)
		{
			return value.ToString("0.######", CultureInfo.InvariantCulture);
		}
	}
	internal static class PresentationWorkbenchVisualResolver
	{
		internal static GameObject? FindVisibleRoot(GameObject? source)
		{
			if ((Object)(object)source == (Object)null)
			{
				return null;
			}
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(source.GetComponentsInChildren<Renderer>(true));
			Transform val = null;
			foreach (Renderer val2 in array)
			{
				if (val2.enabled)
				{
					val = (Transform)(((Object)(object)val == (Object)null) ? ((object)((Component)val2).transform) : ((object)FindCommonAncestor(val, ((Component)val2).transform, source.transform)));
				}
			}
			return (val != null) ? ((Component)val).gameObject : null;
		}

		private static Transform FindCommonAncestor(Transform left, Transform right, Transform boundary)
		{
			Transform val = left;
			while ((Object)(object)val != (Object)(object)boundary && !IsAncestorOf(val, right))
			{
				val = val.parent;
			}
			return (Transform)(IsAncestorOf(val, right) ? ((object)val) : ((object)boundary));
		}

		private static bool IsAncestorOf(Transform ancestor, Transform target)
		{
			Transform val = target;
			while ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)val == (Object)(object)ancestor)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}
	}
}
namespace S1API.Internal.Properties
{
	internal static class CustomEffectRegistry
	{
		private sealed class Entry
		{
			internal Effect S1Effect { get; set; } = null;

			internal EDrugType[] S1Drugs { get; set; } = Array.Empty<EDrugType>();

			internal Vector2? MixMapPosition { get; set; }

			internal float MixMapRadius { get; set; }
		}

		private static readonly Log Logger = new Log("CustomEffectRegistry");

		private static readonly object Gate = new object();

		private static readonly Dictionary<string, Entry> Effects = new Dictionary<string, Entry>(StringComparer.OrdinalIgnoreCase);

		private static bool _hooked;

		internal static void Register(Effect effect, EDrugType[] drugs, Vector2? mixMapPosition, float mixMapRadius)
		{
			if ((Object)(object)effect == (Object)null)
			{
				return;
			}
			string iD = effect.ID;
			if (string.IsNullOrWhiteSpace(iD))
			{
				Logger.Warning("Custom effect has no ID; it will not be tracked.");
				return;
			}
			Entry entry = new Entry
			{
				S1Effect = effect,
				S1Drugs = (drugs ?? Array.Empty<EDrugType>()),
				MixMapPosition = mixMapPosition,
				MixMapRadius = mixMapRadius
			};
			lock (Gate)
			{
				Effects[iD] = entry;
				EnsureHooked();
			}
			Apply(entry);
		}

		internal static bool TryGetExisting(string id, out Effect effect)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				effect = null;
				return false;
			}
			lock (Gate)
			{
				if (Effects.TryGetValue(id, out Entry value))
				{
					effect = value.S1Effect;
					return true;
				}
			}
			effect = null;
			return false;
		}

		private static void EnsureHooked()
		{
			if (!_hooked)
			{
				GameLifecycle.OnPreLoad += ApplyAll;
				GameLifecycle.OnLoadComplete += ApplyAll;
				_hooked = true;
			}
		}

		private static void ApplyAll()
		{
			Entry[] array = Snapshot();
			foreach (Entry entry in array)
			{
				Apply(entry);
			}
		}

		private static Entry[] Snapshot()
		{
			lock (Gate)
			{
				Entry[] array = new Entry[Effects.Count];
				Effects.Values.CopyTo(array, 0);
				return array;
			}
		}

		private static void Apply(Entry entry)
		{
			EnsureInPropertyUtility(entry);
			EnsureInMixMaps(entry);
		}

		private static void EnsureInPropertyUtility(Entry entry)
		{
			if ((Object)(object)entry?.S1Effect == (Object)null || string.IsNullOrWhiteSpace(entry.S1Effect.ID))
			{
				return;
			}
			try
			{
				PropertyUtility instance = Singleton<PropertyUtility>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				List<Effect> allProperties = instance.AllProperties;
				if (allProperties == null)
				{
					return;
				}
				Effect s1Effect = entry.S1Effect;
				bool flag = EnsureInPropertiesDict(instance, s1Effect);
				bool flag2 = false;
				for (int i = 0; i < allProperties.Count; i++)
				{
					Effect val = allProperties[i];
					if ((Object)(object)val != (Object)null && string.Equals(val.ID, s1Effect.ID, StringComparison.OrdinalIgnoreCase))
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2 && flag)
				{
					allProperties.Add(s1Effect);
				}
			}
			catch (Exception value)
			{
				Log logger = Logger;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(51, 2);
				defaultInterpolatedStringHandler.AppendLiteral("Failed to add custom effect '");
				Effect s1Effect2 = entry.S1Effect;
				defaultInterpolatedStringHandler.AppendFormatted((s1Effect2 != null) ? s1Effect2.ID : null);
				defaultInterpolatedStringHandler.AppendLiteral("' to PropertyUtility: ");
				defaultInterpolatedStringHandler.AppendFormatted(value);
				logger.Error(defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static bool EnsureInPropertiesDict(PropertyUtility propertyUtility, Effect effect)
		{
			Dictionary<string, Effect> propertiesDict = propertyUtility.PropertiesDict;
			if (propertiesDict == null)
			{
				return false;
			}
			if (!propertiesDict.ContainsKey(effect.ID))
			{
				propertiesDict.Add(effect.ID, effect);
			}
			return true;
		}

		private static void EnsureInMixMaps(Entry entry)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)entry?.S1Effect == (Object)null || entry.S1Drugs == null)
			{
				return;
			}
			try
			{
				ProductManager instance = NetworkSingleton<ProductManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				EDrugType[] s1Drugs = entry.S1Drugs;
				foreach (EDrugType val in s1Drugs)
				{
					MixerMap mixerMap = instance.GetMixerMap(val);
					if (!((Object)(object)mixerMap == (Object)null) && mixerMap.Effects != null && !ContainsEffect(mixerMap, entry.S1Effect.ID))
					{
						MixerMapEffect val2 = new MixerMapEffect();
						val2.Property = entry.S1Effect;
						val2.Position = (Vector2)(((??)entry.MixMapPosition) ?? DefaultPosition(entry.S1Effect, mixerMap.MapRadius));
						val2.Radius = ((entry.MixMapRadius > 0f) ? entry.MixMapRadius : 0.01f);
						mixerMap.Effects.Add(val2);
					}
				}
			}
			catch (Exception value)
			{
				Log logger = Logger;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(48, 2);
				defaultInterpolatedStringHandler.AppendLiteral("Failed to place custom effect '");
				Effect s1Effect = entry.S1Effect;
				defaultInterpolatedStringHandler.AppendFormatted((s1Effect != null) ? s1Effect.ID : null);
				defaultInterpolatedStringHandler.AppendLiteral("' on a MixerMap: ");
				defaultInterpolatedStringHandler.AppendFormatted(value);
				logger.Error(defaultInterpolatedStringHandler.ToStringAndClear());
			}
		}

		private static bool ContainsEffect(MixerMap map, string effectId)
		{
			for (int i = 0; i < map.Effects.Count; i++)
			{
				MixerMapEffect val = map.Effects[i];
				if ((Object)(object)((val != null) ? val.Property : null) != (Object)null && string.Equals(val.Property.ID, effectId, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static Vector2 DefaultPosition(Effect effect, float mapRadius)
		{
			//IL_0052: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			int num = (effect.ID ?? string.Empty).GetHashCode() & 0x7FFFFFFF;
			float num2 = (float)(num % 360) * ((float)Math.PI / 180f);
			float num3 = ((mapRadius > 0f) ? mapRadius : 5f) + 1f;
			return new Vector2(Mathf.Cos(num2) * num3, Mathf.Sin(num2) * num3);
		}
	}
	internal static class PropertyResolver
	{
		private static readonly string[] SearchPaths = new string[5] { "Properties/Tier1", "Properties/Tier2", "Properties/Tier3", "Properties/Tier4", "Properties/Tier5" };

		internal static List<Effect> ResolveToGameProperties(IEnumerable<PropertyBase> items)
		{
			List<Effect> list = new List<Effect>();
			if (items == null)
			{
				return list;
			}
			foreach (PropertyBase item in items)
			{
				if (item == null)
				{
					continue;
				}
				if (item is ProductPropertyWrapper productPropertyWrapper)
				{
					Effect innerProperty = productPropertyWrapper.InnerProperty;
					if ((Object)(object)innerProperty != (Object)null && !list.Contains(innerProperty))
					{
						list.Add(innerProperty);
					}
				}
				else
				{
					Effect val = FindByIdOrName(item.ID, item.name);
					if ((Object)(object)val != (Object)null && !list.Contains(val))
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		internal static List<Effect> ResolveToGamePropertiesById(IEnumerable<string> ids)
		{
			List<Effect> list = new List<Effect>();
			if (ids == null)
			{
				return list;
			}
			foreach (string id in ids)
			{
				if (!string.IsNullOrWhiteSpace(id))
				{
					Effect effect = null;
					if (!CustomEffectRegistry.TryGetExisting(id, out effect))
					{
						effect = FindByIdOrName(id, string.Empty);
					}
					if ((Object)(object)effect != (Object)null && !list.Contains(effect))
					{
						list.Add(effect);
					}
				}
			}
			return list;
		}

		private static Effect? FindByIdOrName(string id, string unityName)
		{
			string idNorm = (id ?? string.Empty).Trim();
			string nameNorm = (unityName ?? string.Empty).Trim();
			string[] searchPaths = SearchPaths;
			foreach (string text in searchPaths)
			{
				Il2CppArrayBase<Effect> val = Resources.LoadAll<Effect>(text);
				if (val == null || val.Length == 0)
				{
					continue;
				}
				if (!string.IsNullOrEmpty(idNorm))
				{
					Effect val2 = ((IEnumerable<Effect>)val).FirstOrDefault((Func<Effect, bool>)((Effect p) => (Object)(object)p != (Object)null && string.Equals(p.ID, idNorm, StringComparison.OrdinalIgnoreCase)));
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
				if (!string.IsNullOrEmpty(nameNorm))
				{
					Effect val3 = ((IEnumerable<Effect>)val).FirstOrDefault((Func<Effect, bool>)((Effect p) => (Object)(object)p != (Object)null && string.Equals(((Object)p).name, nameNorm, StringComparison.OrdinalIgnoreCase)));
					if ((Object)(object)val3 != (Object)null)
					{
						return val3;
					}
				}
			}
			return null;
		}
	}
}
namespace S1API.Internal.Products
{
	internal static class CustomProductDefinitionFactory
	{
		internal static ProductDefinition Create(string productId, string productName, string description, float productPrice, LegalStatus legalStatus, float baseAddictiveness, int playerEffectDurationSeconds, int npcEffectDurationSeconds, DrugType compatibilityDrugType, IReadOnlyList<Effect> properties, IReadOnlyList<PackagingDefinition> validPackaging, ProductDefinition representationTemplate)
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			ProductDefinition val = ScriptableObject.CreateInstance<ProductDefinition>();
			((BaseItemDefinition)val).ID = productId;
			((BaseItemDefinition)val).Name = productName;
			((BaseItemDefinition)val).Description = description;
			((Object)val).name = productName;
			((BaseItemDefinition)val).Category = (EItemCategory)0;
			((BaseItemDefinition)val).StackLimit = ((BaseItemDefinition)representationTemplate).StackLimit;
			((ItemDefinition)val).AvailableInDemo = ((ItemDefinition)representationTemplate).AvailableInDemo;
			((BaseItemDefinition)val).UsableInFilters = ((BaseItemDefinition)representationTemplate).UsableInFilters;
			((BaseItemDefinition)val).Icon = ((BaseItemDefinition)representationTemplate).Icon;
			((BaseItemDefinition)val).legalStatus = (ELegalStatus)legalStatus;
			((StorableItemDefinition)val).PickpocketDifficultyMultiplier = ((StorableItemDefinition)representationTemplate).PickpocketDifficultyMultiplier;
			((StorableItemDefinition)val).CombatUtility = ((StorableItemDefinition)representationTemplate).CombatUtility;
			((StorableItemDefinition)val).BasePurchasePrice = productPrice;
			((StorableItemDefinition)val).ResellMultiplier = ((StorableItemDefinition)representationTemplate).ResellMultiplier;
			((StorableItemDefinition)val).ShopCategories = ((StorableItemDefinition)representationTemplate).ShopCategories;
			((StorableItemDefinition)val).RequiresLevelToPurchase = ((StorableItemDefinition)representationTemplate).RequiresLevelToPurchase;
			((StorableItemDefinition)val).RequiredRank = ((StorableItemDefinition)representationTemplate).RequiredRank;
			((StorableItemDefinition)val).StoredItem = ((StorableItemDefinition)representationTemplate).StoredItem;
			((StorableItemDefinition)val).StationItem = null;
			((ItemDefinition)val).Equippable = ((ItemDefinition)representationTemplate).Equippable;
			((ItemDefinition)val).EquipMode = ((ItemDefinition)representationTemplate).EquipMode;
			((ItemDefinition)val).CustomItemUI = ((ItemDefinition)representationTemplate).CustomItemUI;
			((ItemDefinition)val).CustomInfoContent = ((ItemDefinition)representationTemplate).CustomInfoContent;
			((PropertyItemDefinition)val).Properties = new List<Effect>();
			for (int i = 0; i < properties.Count; i++)
			{
				((PropertyItemDefinition)val).Properties.Add(properties[i]);
			}
			val.DrugTypes = new List<DrugTypeContainer>();
			val.DrugTypes.Add(new DrugTypeContainer
			{
				DrugType = compatibilityDrugType.ToInternal()
			});
			val.LawIntensityChange = representationTemplate.LawIntensityChange;
			val.BasePrice = productPrice;
			val.MarketValue = productPrice;
			val.FunctionalProduct = representationTemplate.FunctionalProduct;
			val.NPCEffectDuration = npcEffectDurationSeconds;
			val.PlayerEffectDuration = playerEffectDurationSeconds;
			val.BaseAddictiveness = baseAddictiveness;
			val.ValidPackaging = CreatePackagingArray(validPackaging);
			val.ConsumeAnimation = representationTemplate.ConsumeAnimation;
			return val;
		}

		internal static void Destroy(ProductDefinition definition)
		{
			if (definition != null)
			{
				Object.Destroy((Object)(object)definition);
			}
		}

		private static Il2CppReferenceArray<PackagingDefinition> CreatePackagingArray(IReadOnlyList<PackagingDefinition> validPackaging)
		{
			Il2CppReferenceArray<PackagingDefinition> val = new Il2CppReferenceArray<PackagingDefinition>((long)validPackaging.Count);
			for (int i = 0; i < validPackaging.Count; i++)
			{
				((Il2CppArrayBase<PackagingDefinition>)(object)val)[i] = validPackaging[i];
			}
			return val;
		}
	}
	internal sealed class CustomProductDefinitionMetadata
	{
		internal ProductKind ProductKind { get; }

		internal Quality DefaultQuality { get; }

		internal IReadOnlyList<PackagingDefinition> ValidPackaging { get; }

		internal ProductDefinition? RepresentationTemplate { get; }

		internal Color32? GeneratedMixColor { get; }

		internal CustomProductDefinitionMetadata(ProductKind productKind, Quality defaultQuality)
			: this(productKind, defaultQuality, Array.Empty<PackagingDefinition>(), null)
		{
		}

		internal CustomProductDefinitionMetadata(ProductKind productKind, Quality defaultQuality, IReadOnlyList<PackagingDefinition> validPackaging)
			: this(productKind, defaultQuality, validPackaging, null)
		{
		}

		internal CustomProductDefinitionMetadata(ProductKind productKind, Quality defaultQuality, IReadOnlyList<PackagingDefinition> validPackaging, ProductDefinition? representationTemplate, Color32? generatedMixColor = null)
		{
			ProductKind = productKind;
			DefaultQuality = defaultQuality;
			if (validPackaging == null)
			{
				throw new ArgumentNullException("validPackaging");
			}
			ValidPackaging = new List<PackagingDefinition>(validPackaging).AsReadOnly();
			RepresentationTemplate = representationTemplate;
			GeneratedMixColor = generatedMixColor;
		}
	}
	internal sealed class CustomProductDefinitionRegistration
	{
		internal string OwnerId { get; }

		internal string ProductId { get; }

		internal string ProductName { get; }

		internal float InitialPrice { get; }

		internal ProductDefinition Definition { get; }

		internal CustomProductDefinitionMetadata? Metadata { get; }

		internal CustomProductSaveDescriptorData? SaveDescriptor { get; }

		internal CustomProductPresentationState? PresentationState { get; set; }

		internal CustomProductDefinitionRegistration(string ownerId, string productId, string productName, float initialPrice, ProductDefinition definition)
			: this(ownerId, productId, productName, initialPrice, definition, null)
		{
		}

		internal CustomProductDefinitionRegistration(string ownerId, string productId, string productName, float initialPrice, ProductDefinition definition, CustomProductDefinitionMetadata? metadata, CustomProductSaveDescriptorData? saveDescriptor = null)
		{
			OwnerId = ownerId;
			ProductId = productId;
			ProductName = productName;
			InitialPrice = initialPrice;
			Definition = definition;
			Metadata = metadata;
			SaveDescriptor = saveDescriptor;
		}
	}
	internal static class CustomProductDefinitionRegistry
	{
		private static readonly object Gate = new object();

		private static readonly object ApplyGate = new object();

		private static readonly Dictionary<string, CustomProductDefinitionRegistration> Registrations = new Dictionary<string, CustomProductDefinitionRegistration>(StringComparer.OrdinalIgnoreCase);

		private static ICustomProductDefinitionRuntimeAdapter _runtimeAdapter = CustomProductDefinitionRuntimeAdapter.Instance;

		private static ICustomProductPresentationRuntime _presentationRuntime = CustomProductPresentationRuntime.Instance;

		private static bool _hooked;

		internal static ProductDefinition Register(string ownerId, string productId, string productName, float initialPrice, ProductDefinition definition)
		{
			return Register(ownerId, productId, productName, initialPrice, definition, null);
		}

		internal static ProductDefinition Register(string ownerId, string productId, string productName, float initialPrice, ProductDefinition definition, CustomProductDefinitionMetadata? metadata)
		{
			return Register(ownerId, productId, productName, initialPrice, definition, metadata, null);
		}

		internal static ProductDefinition Register(string ownerId, string productId, string productName, float initialPrice, ProductDefinition definition, CustomProductDefinitionMetadata? metadata, CustomProductSaveDescriptorData? saveDescriptor)
		{
			string text = NormalizeRequired(ownerId, "ownerId");
			string text2 = NormalizeRequired(productId, "productId");
			string productName2 = NormalizeRequired(productName, "productName");
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			if (float.IsNaN(initialPrice) || float.IsInfinity(initialPrice))
			{
				throw new ArgumentOutOfRangeException("initialPrice", initialPrice, "Initial product price must be a finite value.");
			}
			lock (ApplyGate)
			{
				bool flag = false;
				CustomProductDefinitionRegistration customProductDefinitionRegistration;
				lock (Gate)
				{
					if (Registrations.TryGetValue(text2, out CustomProductDefinitionRegistration value))
					{
						if (!string.Equals(value.OwnerId, text, StringComparison.OrdinalIgnoreCase))
						{
							throw new InvalidOperationException($"Custom product ID '{text2}' is already owned by '{value.OwnerId}' and cannot be registered by '{text}'. Product ownership is " + "case-insensitive.");
						}
						customProductDefinitionRegistration = value;
					}
					else
					{
						customProductDefinitionRegistration = new CustomProductDefinitionRegistration(text, text2, productName2, initialPrice, definition, metadata, saveDescriptor);
						Registrations.Add(text2, customProductDefinitionRegistration);
						flag = true;
					}
					EnsureHooked();
				}
				try
				{
					ProductPresentationProfileRegistration productPresentationProfileRegistration = ResolvePresentationProfile(customProductDefinitionRegistration);
					if (productPresentationProfileRegistration != null)
					{
						_presentationRuntime.Apply(customProductDefinitionRegistration, productPresentationProfileRegistration);
					}
					_runtimeAdapter.Apply(customProductDefinitionRegistration);
					if (flag)
					{
						CustomProductManifestRuntime.RefreshHostManifestIfReady();
					}
					if (productPresentationProfileRegistration == null)
					{
						_presentationRuntime.Apply(customProductDefinitionRegistration, null);
					}
				}
				catch
				{
					if (flag)
					{
						if (customProductDefinitionRegistration.PresentationState != null)
						{
							try
							{
								_presentationRuntime.Apply(customProductDefinitionRegistration, null);
							}
							catch (Exception value2)
							{
								MelonLogger.Error("[CustomProductDefinitionRegistry] Failed to restore presentation fallbacks after rejecting " + $"'{text2}': {value2}");
							}
						}
						lock (Gate)
						{
							if (Registrations.TryGetValue(text2, out CustomProductDefinitionRegistration value3) && value3 == customProductDefinitionRegistration)
							{
								Registrations.Remove(text2);
							}
						}
					}
					throw;
				}
				return customProductDefinitionRegistration.Definition;
			}
		}

		internal static bool TryGetMetadata(ProductDefinition definition, out CustomProductDefinitionMetadata? metadata)
		{
			metadata = null;
			if (definition == null)
			{
				return false;
			}
			string iD;
			try
			{
				iD = ((BaseItemDefinition)definition).ID;
			}
			catch (Exception)
			{
				return false;
			}
			return TryGetMetadata(iD, definition, out metadata);
		}

		internal static bool TryGetMetadata(string productId, ProductDefinition definition, out CustomProductDefinitionMetadata? metadata)
		{
			metadata = null;
			if (string.IsNullOrEmpty(productId) || definition == null)
			{
				return false;
			}
			lock (Gate)
			{
				if (!Registrations.TryGetValue(productId, out CustomProductDefinitionRegistration value) || value.Metadata == null || !AreSameDefinition(value.Definition, definition))
				{
					return false;
				}
				metadata = value.Metadata;
				return true;
			}
		}

		internal static bool TryGetMetadata(string productId, out CustomProductDefinitionMetadata? metadata)
		{
			metadata = null;
			if (string.IsNullOrWhiteSpace(productId))
			{
				return false;
			}
			lock (Gate)
			{
				if (!Registrations.TryGetValue(productId, out CustomProductDefinitionRegistration value) || value.Metadata == null)
				{
					return false;
				}
				metadata = value.Metadata;
				return true;
			}
		}

		private static string NormalizeRequired(string value, string parameterName)
		{
			if (value == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = value.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Value cannot be empty or whitespace.", parameterName);
			}
			return text;
		}

		private static void EnsureHooked()
		{
			if (!_hooked)
			{
				GameLifecycle.OnPreLoad += OnPreLoad;
				GameLifecycle.OnLoadComplete += OnLoadComplete;
				_hooked = true;
			}
		}

		private static void OnPreLoad()
		{
			ApplyAll("pre-load");
		}

		private static void OnLoadComplete()
		{
			ApplyAll("load-complete");
		}

		private static void ApplyAll(string phase)
		{
			lock (ApplyGate)
			{
				CustomProductDefinitionRegistration[] array = Snapshot();
				foreach (CustomProductDefinitionRegistration customProductDefinitionRegistration in array)
				{
					try
					{
						_runtimeAdapter.Apply(customProductDefinitionRegistration);
						ApplyPresentationProfile(customProductDefinitionRegistration);
					}
					catch (Exception value)
					{
						MelonLogger.Error($"[CustomProductDefinitionRegistry] Failed to restore product '{customProductDefinitionRegistration.ProductId}' owned by '{customProductDefinitionRegistration.OwnerId}' during {phase}: {value}");
					}
				}
			}
		}

		private static CustomProductDefinitionRegistration[] Snapshot()
		{
			lock (Gate)
			{
				CustomProductDefinitionRegistration[] array = new CustomProductDefinitionRegistration[Registrations.Count];
				Registrations.Values.CopyTo(array, 0);
				return array;
			}
		}

		internal static void ResetForTesting(ICustomProductDefinitionRuntimeAdapter runtimeAdapter, ICustomProductPresentationRuntime? presentationRuntime = null)
		{
			if (runtimeAdapter == null)
			{
				throw new ArgumentNullException("runtimeAdapter");
			}
			lock (ApplyGate)
			{
				lock (Gate)
				{
					if (_hooked)
					{
						GameLifecycle.OnPreLoad -= OnPreLoad;
						GameLifecycle.OnLoadComplete -= OnLoadComplete;
					}
					Registrations.Clear();
					_runtimeAdapter = runtimeAdapter;
					_presentationRuntime = presentationRuntime ?? CustomProductPresentationRuntime.Instance;
					_hooked = false;
				}
			}
			ProductPresentationProfileRegistry.ResetForTesting();
		}

		internal static void RestoreRuntimeAdapterForTesting()
		{
			ResetForTesting(CustomProductDefinitionRuntimeAdapter.Instance, CustomProductPresentationRuntime.Instance);
		}

		internal static void ApplyPresentationProfiles()
		{
			lock (ApplyGate)
			{
				CustomProductDefinitionRegistration[] array = Snapshot();
				foreach (CustomProductDefinitionRegistration registration in array)
				{
					ApplyPresentationProfile(registration);
				}
			}
		}

		internal static void InvokePreLoadForTesting()
		{
			OnPreLoad();
		}

		internal static void InvokeLoadCompleteForTesting()
		{
			OnLoadComplete();
		}

		internal static bool IsRegistered(string productId)
		{
			lock (Gate)
			{
				return Registrations.ContainsKey(productId);
			}
		}

		internal static CustomProductSaveDescriptorData[] GetSaveDescriptors()
		{
			lock (Gate)
			{
				List<CustomProductSaveDescriptorData> list = new List<CustomProductSaveDescriptorData>();
				foreach (CustomProductDefinitionRegistration value in Registrations.Values)
				{
					if (value.SaveDescriptor != null)
					{
						list.Add(value.SaveDescriptor);
					}
				}
				list.Sort((CustomProductSaveDescriptorData left, CustomProductSaveDescriptorData right) => StringComparer.OrdinalIgnoreCase.Compare(left.ProductId, right.ProductId));
				return list.ToArray();
			}
		}

		internal static CustomProductManifestData CreateManifest()
		{
			return CustomProductManifestData.Create(Snapshot());
		}

		private static bool AreSameDefinition(ProductDefinition left, ProductDefinition right)
		{
			int result;
			if (left != right)
			{
				if (left != null)
				{
					if (right != null)
					{
						result = (((Object)(object)left == (Object)(object)right) ? 1 : 0);
						goto IL_001c;
					}
				}
				result = 0;
			}
			else
			{
				result = 1;
			}
			goto IL_001c;
			IL_001c:
			return (byte)result != 0;
		}

		private static void ApplyPresentationProfile(CustomProductDefinitionRegistration registration)
		{
			_presentationRuntime.Apply(registration, ResolvePresentationProfile(registration));
		}

		private static ProductPresentationProfileRegistration? ResolvePresentationProfile(CustomProductDefinitionRegistration registration)
		{
			if (registration.Metadata == null)
			{
				return null;
			}
			ProductPresentationProfileRegistry.TryResolve(registration.ProductId, registration.Metadata.ProductKind.Id, out ProductPresentationProfileRegistration registration2);
			return registration2;
		}
	}
	internal interface ICustomProductDefinitionRuntimeAdapter
	{
		bool Apply(CustomProductDefinitionRegistration registration);
	}
	internal sealed class CustomProductDefinitionRuntimeAdapter : ICustomProductDefinitionRuntimeAdapter
	{
		internal static readonly CustomProductDefinitionRuntimeAdapter Instance = new CustomProductDefinitionRuntimeAdapter();

		private CustomProductDefinitionRuntimeAdapter()
		{
		}

		public bool Apply(CustomProductDefinitionRegistration registration)
		{
			EnsureDefinitionIdentity(registration);
			Registry instance = Singleton<Registry>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			EnsureItemRegistry(instance, registration);
			ProductManager instance2 = NetworkSingleton<ProductManager>.Instance;
			if ((Object)(object)instance2 == (Object)null)
			{
				return false;
			}
			EnsureAllProducts(instance2, registration);
			EnsureProductName(instance2, registration);
			EnsureInitialPrice(instance2, registration);
			return true;
		}

		private static void EnsureDefinitionIdentity(CustomProductDefinitionRegistration registration)
		{
			if (string.Equals(((BaseItemDefinition)registration.Definition).ID, registration.ProductId, StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			throw new InvalidOperationException($"Cannot register custom product '{registration.ProductId}' owned by '{registration.OwnerId}': the native definition ID is '{((BaseItemDefinition)registration.Definition).ID ?? "<null>"}'. Stable registration IDs " + "must match the native definition ID case-insensitively.");
		}

		private static void EnsureItemRegistry(Registry registry, CustomProductDefinitionRegistration registration)
		{
			ItemDefinition item = Registry.GetItem(registration.ProductId);
			if ((Object)(object)item == (Object)null)
			{
				registry.AddToRegistry((ItemDefinition)(object)registration.Definition);
			}
			else if (!AreSameDefinition(item, (ItemDefinition)(object)registration.Definition))
			{
				throw CreateRuntimeConflict(registration, "ScheduleOne.Registry", item);
			}
		}

		private static void EnsureAllProducts(ProductManager productManager, CustomProductDefinitionRegistration registration)
		{
			List<ProductDefinition> allProducts = productManager.AllProducts;
			if (allProducts == null)
			{
				throw new InvalidOperationException("ProductManager.AllProducts is unavailable. The game update may have changed product registration internals.");
			}
			for (int i = 0; i < allProducts.Count; i++)
			{
				ProductDefinition val = allProducts[i];
				if (!((Object)(object)val == (Object)null) && string.Equals(((BaseItemDefinition)val).ID, registration.ProductId, StringComparison.OrdinalIgnoreCase))
				{
					if (!AreSameDefinition((ItemDefinition)(object)val, (ItemDefinition)(object)registration.Definition))
					{
						throw CreateRuntimeConflict(registration, "ProductManager.AllProducts", (ItemDefinition)(object)val);
					}
					return;
				}
			}
			allProducts.Add(registration.Definition);
		}

		private static void EnsureProductName(ProductManager productManager, CustomProductDefinitionRegistration registration)
		{
			List<string> productNames = productManager.ProductNames;
			if (productNames == null)
			{
				throw new InvalidOperationException("ProductManager.ProductNames is unavailable. The game update may have changed product registration internals.");
			}
			if (!productNames.Contains(registration.ProductName))
			{
				productNames.Add(registration.ProductName);
			}
		}

		private static void EnsureInitialPrice(ProductManager productManager, CustomProductDefinitionRegistration registration)
		{
			Dictionary<ProductDefinition, float> productPrices = GetProductPrices(productManager);
			if (!productPrices.ContainsKey(registration.Definition))
			{
				productPrices.Add(registration.Definition, registration.InitialPrice);
			}
		}

		private static Dictionary<ProductDefinition, float> GetProductPrices(ProductManager productManager)
		{
			Dictionary<ProductDefinition, float> productPrices = productManager.ProductPrices;
			return productPrices ?? throw new InvalidOperationException("ProductManager.ProductPrices is unavailable. The game update may have changed product registration internals.");
		}

		private static InvalidOperationException CreateRuntimeConflict(CustomProductDefinitionRegistration registration, string collectionName, ItemDefinition existing)
		{
			string value = ((object)existing).GetType().FullName ?? ((object)existing).GetType().Name;
			return new InvalidOperationException($"Cannot restore custom product '{registration.ProductId}' owned by '{registration.OwnerId}': {collectionName} already contains a different definition of type '{value}'. Check for a native ID collision or " + "another mod registering the same case-insensitive product ID.");
		}

		private static bool AreSameDefinition(ItemDefinition left, ItemDefinition right)
		{
			int result;
			if (left != right)
			{
				if (left != null)
				{
					if (right != null)
					{
						result = (((Object)(object)left == (Object)(object)right) ? 1 : 0);
						goto IL_001c;
					}
				}
				result = 0;
			}
			else
			{
				result = 1;
			}
			goto IL_001c;
			IL_001c:
			return (byte)result != 0;
		}
	}
	internal sealed class CustomProductManifestClientGate
	{
		private Action? _deferredPlayerDataRequest;

		internal bool IsWaiting { get; private set; }

		internal void Begin(bool requiresValidation)
		{
			IsWaiting = requiresValidation;
			_deferredPlayerDataRequest = null;
		}

		internal bool AuthorizePlayerDataRequest(Action request)
		{
			if (request == null)
			{
				throw new ArgumentNullException("request");
			}
			if (!IsWaiting)
			{
				return true;
			}
			if (_deferredPlayerDataRequest == null)
			{
				_deferredPlayerDataRequest = request;
			}
			return false;
		}

		internal CustomProductManifestAcceptance Accept(string hostCompatibilityHash, string localCompatibilityHash, out Action? deferredPlayerDataRequest)
		{
			deferredPlayerDataRequest = null;
			if (!string.Equals(hostCompatibilityHash, localCompatibilityHash, StringComparison.Ordinal))
			{
				return CustomProductManifestAcceptance.Incompatible;
			}
			if (!IsWaiting)
			{
				return CustomProductManifestAcceptance.AlreadyAccepted;
			}
			IsWaiting = false;
			deferredPlayerDataRequest = _deferredPlayerDataRequest;
			_deferredPlayerDataRequest = null;
			return CustomProductManifestAcceptance.Accepted;
		}

		internal void End()
		{
			IsWaiting = false;
			_deferredPlayerDataRequest = null;
		}
	}
	internal enum CustomProductManifestAcceptance
	{
		Accepted,
		AlreadyAccepted,
		Incompatible
	}
	internal sealed class CustomProductManifestData
	{
		internal const int CurrentProtocolVersion = 3;

		internal const int MaximumEntryCount = 256;

		internal const int MaximumPayloadLength = 65536;

		internal const int MaximumIdentifierLength = 256;

		internal const int MaximumPackagingCount = 32;

		public int ProtocolVersion = 3;

		public string SessionId = string.Empty;

		public string CompatibilityHash = string.Empty;

		public CustomProductManifestEntryData[] Entries = Array.Empty<CustomProductManifestEntryData>();

		public CustomProductMixingProfileManifestEntryData[] MixingProfiles = Array.Empty<CustomProductMixingProfileManifestEntryData>();

		public CustomProductSaveDescriptorData[] GeneratedDescriptors = Array.Empty<CustomProductSaveDescriptorData>();

		internal static CustomProductManifestData Create(IEnumerable<CustomProductDefinitionRegistration> registrations)
		{
			if (registrations == null)
			{
				throw new ArgumentNullException("registrations");
			}
			List<CustomProductManifestEntryData> list = new List<CustomProductManifestEntryData>();
			foreach (CustomProductDefinitionRegistration registration in registrations)
			{
				if (registration.Metadata != null && registration.SaveDescriptor != null)
				{
					CustomProductManifestEntryData customProductManifestEntryData = CustomProductManifestEntryData.Create(registration);
					if (!customProductManifestEntryData.IsValid())
					{
						throw new InvalidOperationException("Custom product '" + registration.ProductId + "' cannot be represented by the bounded multiplayer manifest.");
					}
					list.Add(customProductManifestEntryData);
				}
			}
			list.Sort(CustomProductManifestEntryData.Compare);
			if (list.Count > 256)
			{
				throw new InvalidOperationException("The custom-product manifest exceeds the supported product count.");
			}
			ProductMixingProfile[] array = ProductMixingProfileRegistry.Snapshot();
			List<CustomProductMixingProfileManifestEntryData> list2 = new List<CustomProductMixingProfileManifestEntryData>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				list2.Add(CustomProductMixingProfileManifestEntryData.Create(array[i]));
			}
			list2.Sort(CustomProductMixingProfileManifestEntryData.Compare);
			List<CustomProductSaveDescriptorData> list3 = new List<CustomProductSaveDescriptorData>();
			foreach (CustomProductDefinitionRegistration registration2 in registrations)
			{
				if (registration2.SaveDescriptor != null && registration2.SaveDescriptor.IsGeneratedMix)
				{
					list3.Add(registration2.SaveDescriptor);
				}
			}
			list3.Sort((CustomProductSaveDescriptorData left, CustomProductSaveDescriptorData right) => StringComparer.OrdinalIgnoreCase.Compare(left.ProductId, right.ProductId));
			CustomProductManifestData customProductManifestData = new CustomProductManifestData
			{
				Entries = list.ToArray(),
				MixingProfiles = list2.ToArray(),
				GeneratedDescriptors = list3.ToArray()
			};
			customProductManifestData.CompatibilityHash = ComputeManifestHash(customProductManifestData.Entries, customProductManifestData.MixingProfiles);
			return customProductManifestData;
		}

		internal string Serialize(string sessionId)
		{
			if (!IsSessionId(sessionId))
			{
				throw new InvalidOperationException("The custom-product session ID is invalid.");
			}
			CustomProductManifestData customProductManifestData = new CustomProductManifestData
			{
				ProtocolVersion = ProtocolVersion,
				SessionId = sessionId,
				CompatibilityHash = CompatibilityHash,
				Entries = Entries,
				MixingProfiles = MixingProfiles,
				GeneratedDescriptors = GeneratedDescriptors
			};
			string text = JsonConvert.SerializeObject((object)customProductManifestData, (Formatting)0);
			if (text.Length > 65536 || Encoding.UTF8.GetByteCount(text) > 65536)
			{
				throw new InvalidOperationException("The custom-product manifest exceeds the supported payload size.");
			}
			return text;
		}

		internal static bool TryDeserialize(string? payload, out CustomProductManifestData manifest, out string failure)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0072: 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_0084: Expected O, but got Unknown
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			manifest = null;
			failure = string.Empty;
			if (payload == null || payload.Length == 0 || payload.Length > 65536 || Encoding.UTF8.GetByteCount(payload) > 65536)
			{
				failure = "manifest payload size is invalid";
				return false;
			}
			try
			{
				using StringReader stringReader = new StringReader(payload);
				JsonTextReader val = new JsonTextReader((TextReader)stringReader)
				{
					DateParseHandling = (DateParseHandling)0,
					MaxDepth = 16
				};
				try
				{
					JObject val2 = JObject.Load((JsonReader)(object)val, new JsonLoadSettings
					{
						DuplicatePropertyNameHandling = (DuplicatePropertyNameHandling)2
					});
					if (((JsonReader)val).Read())
					{
						failure = "manifest payload contains trailing data";
						return false;
					}
					CustomProductManifestData customProductManifestData = ((JToken)val2).ToObject<CustomProductManifestData>(JsonSerializer.Create(new JsonSerializerSettings
					{
						MissingMemberHandling = (MissingMemberHandling)1,
						MaxDepth = 16
					}));
					if (!TryValidate(customProductManifestData, out failure))
					{
						return false;
					}
					manifest = customProductManifestData;
					return true;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception)
			{
				failure = "manifest payload is malformed";
				return false;
			}
		}

		internal static bool TryValidate(CustomProductManifestData? manifest, out string failure)
		{
			failure = string.Empty;
			if (manifest == null || manifest.ProtocolVersion != 3 || !IsSessionId(manifest.SessionId) || !IsHash(manifest.CompatibilityHash) || manifest.Entries == null || manifest.MixingProfiles == null || manifest.GeneratedDescriptors == null || manifest.Entries.Length > 256 || manifest.MixingProfiles.Length > 256 || manifest.GeneratedDescriptors.Length > 256)
			{
				failure = "manifest protocol, session, hash, or entry count is invalid";
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < manifest.MixingProfiles.Length; i++)
			{
				if (!manifest.MixingProfiles[i].IsValid() || !hashSet.Add(manifest.MixingProfiles[i].ProductKindId) || (i > 0 && CustomProductMixingProfileManifestEntryData.Compare(manifest.MixingProfiles[i - 1], manifest.MixingProfiles[i]) >= 0))
				{
					failure = "manifest contains an invalid or duplicate mixing profile";
					return false;
				}
			}
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			for (int j = 0; j < manifest.GeneratedDescriptors.Length; j++)
			{
				CustomProductSaveDescriptorData customProductSaveDescriptorData = manifest.GeneratedDescriptors[j];
				if (!customProductSaveDescriptorData.IsGeneratedMix || !hashSet2.Add(customProductSaveDescriptorData.ProductId) || !CustomProductSavePersistence.IsNetworkGeneratedDescriptorValid(customProductSaveDescriptorData))
				{
					failure = "manifest contains an invalid generated descriptor";
					return false;
				}
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			CustomProductManifestEntryData[] entries = manifest.Entries;
			for (int k = 0; k < entries.Length; k++)
			{
				if (!entries[k].IsValid() || !hashSet3.Add(entries[k].ProductId))
				{
					failure = "manifest contains an invalid or duplicate product entry";
					return false;
				}
				if (k > 0 && CustomProductManifestEntryData.Compare(entries[k - 1], entries[k]) >= 0)
				{
					failure = "manifest entries are not in canonical order";
					return false;
				}
			}
			if (!string.Equals(manifest.CompatibilityHash, ComputeManifestHash(entries, manifest.MixingProfiles), StringComparison.Ordinal))
			{
				failure = "manifest compatibility hash is invalid";
				return false;
			}
			return true;
		}

		internal static string ComputeManifestHash(IReadOnlyList<CustomProductManifestEntryData> entries)
		{
			return ComputeManifestHash(entries, Array.Empty<CustomProductMixingProfileManifestEntryData>());
		}

		internal static string ComputeManifestHash(IReadOnlyList<CustomProductManifestEntryData> entries, IReadOnlyList<CustomProductMixingProfileManifestEntryData> mixingProfiles)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(3).Append('|');
			for (int i = 0; i < entries.Count; i++)
			{
				entries[i].AppendCanonical(stringBuilder, includeHash: true);
			}
			stringBuilder.Append("profiles|");
			for (int j = 0; j < mixingProfiles.Count; j++)
			{
				mixingProfiles[j].AppendCanonical(stringBuilder);
			}
			return ComputeHash(stringBuilder.ToString());
		}

		internal static string DescribeCompatibilityMismatch(CustomProductManifestData host, CustomProductManifestData local)
		{
			int num = 0;
			int num2 = 0;
			while (num < host.Entries.Length && num2 < local.Entries.Length)
			{
				CustomProductManifestEntryData customProductManifestEntryData = host.Entries[num];
				CustomProductManifestEntryData customProductManifestEntryData2 = local.Entries[num2];
				int num3 = CustomProductManifestEntryData.Compare(customProductManifestEntryData, customProductManifestEntryData2);
				if (num3 < 0)
				{
					return "local content is missing host product '" + customProductManifestEntryData.ProductId + "'";
				}
				if (num3 > 0)
				{
					return "local product '" + customProductManifestEntryData2.ProductId + "' is not registered by the host";
				}
				string text = customProductManifestEntryData.DescribeMismatch(customProductManifestEntryData2);
				if (text != null)
				{
					return "product '" + customProductManifestEntryData.ProductId + "' " + text;
				}
				num++;
				num2++;
			}
			if (num < host.Entries.Length)
			{
				return "local content is missing host product '" + host.Entries[num].ProductId + "'";
			}
			if (num2 < local.Entries.Length)
			{
				return "local product '" + local.Entries[num2].ProductId + "' is not registered by the host";
			}
			int i;
			for (i = 0; i < host.MixingProfiles.Length && i < local.MixingProfiles.Length; i++)
			{
				CustomProductMixingProfileManifestEntryData customProductMixingProfileManifestEntryData = host.MixingProfiles[i];
				CustomProductMixingProfileManifestEntryData customProductMixingProfileManifestEntryData2 = local.MixingProfiles[i];
				if (CustomProductMixingProfileManifestEntryData.Compare(customProductMixingProfileManifestEntryData, customProductMixingProfileManifestEntryData2) != 0)
				{
					return "mixing profile registrations differ";
				}
				string text2 = customProductMixingProfileManifestEntryData.DescribeMismatch(customProductMixingProfileManifestEntryData2);
				if (text2 != null)
				{
					return "mixing profile '" + customProductMixingProfileManifestEntryData.ProductKindId + "' " + text2;
				}
			}
			if (i < host.MixingProfiles.Length || i < local.MixingProfiles.Length)
			{
				return "mixing profile registrations differ";
			}
			return "manifest hash differs despite matching scalar identities";
		}

		internal static string ComputeHash(string value)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(bytes);
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			for (int i = 0; i < array.Length; i++)
			{
				stringBuilder.Append(array[i].ToString("x2", CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		internal static bool IsBoundedIdentifier(string? value)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length > 256 || !string.Equals(value, value.Trim(), StringComparison.Ordinal))
			{
				return false;
			}
			for (int i = 0; i < value.Length; i++)
			{
				if (char.IsControl(value[i]))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool IsSessionId(string? value)
		{
			return value != null && value.Length == 32 && IsLowerHex(value);
		}

		internal static bool IsHash(string? value)
		{
			return value != null && value.Length == 64 && IsLowerHex(value);
		}

		private static bool IsLowerHex(string value)
		{
			foreach (char c in value)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal sealed class CustomProductManifestEntryData
	{
		public string ProductId = string.Empty;

		public string OwnerId = string.Empty;

		public string ProductKindId = string.Empty;

		public int CompatibilityDrugType;

		public int DescriptorFormatVersion;

		public string? ProviderId;

		public int ProviderVersion;

		public bool ProviderAvailable;

		public string RepresentationTemplateId = string.Empty;

		public string PresentationProfileId = string.Empty;

		public string ConsumptionProfileProviderId = string.Empty;

		public int ConsumptionProfileProviderVersion;

		public string[] PackagingIds = Array.Empty<string>();

		public string CompatibilityHash = string.Empty;

		internal static CustomProductManifestEntryData Create(CustomProductDefinitionRegistration registration)
		{
			CustomProductSaveDescriptorData customProductSaveDescriptorData = registration.SaveDescriptor ?? throw new InvalidOperationException("Custom product has no descriptor.");
			CustomProductDefinitionMetadata customProductDefinitionMetadata = registration.Metadata ?? throw new InvalidOperationException("Custom product has no metadata.");
			List<string> list = new List<string>(customProductDefinitionMetadata.ValidPackaging.Count);
			for (int i = 0; i < customProductDefinitionMetadata.ValidPackaging.Count; i++)
			{
				list.Add(customProductDefinitionMetadata.ValidPackaging[i].ID);
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			ProductPresentationProfileRegistry.TryGetManifestIdentity(registration.ProductId, customProductDefinitionMetadata.ProductKind.Id, out string identity);
			ProductConsumptionProfileRegistrationRegistry.TryGetManifestIdentity(registration.ProductId, customProductDefinitionMetadata.ProductKind.Id, out string providerId, out int providerVersion);
			CustomProductManifestEntryData customProductManifestEntryData = new CustomProductManifestEntryData
			{
				ProductId = registration.ProductId,
				OwnerId = registration.OwnerId,
				ProductKindId = customProductDefinitionMetadata.ProductKind.Id,
				CompatibilityDrugType = customProductSaveDescriptorData.CompatibilityDrugType,
				DescriptorFormatVersion = customProductSaveDescriptorData.FormatVersion,
				ProviderId = customProductSaveDescriptorData.ProviderId,
				ProviderVersion = customProductSaveDescriptorData.ProviderVersion,
				ProviderAvailable = CustomProductSavePersistence.IsProviderAvailable(customProductSaveDescriptorData.ProviderId, customProductSaveDescriptorData.ProviderVersion),
				RepresentationTemplateId = customProductSaveDescriptorData.RepresentationTemplateId,
				PresentationProfileId = identity,
				ConsumptionProfileProviderId = providerId,
				ConsumptionProfileProviderVersion = providerVersion,
				PackagingIds = list.ToArray()
			};
			customProductManifestEntryData.CompatibilityHash = ComputeCompatibilityHash(customProductManifestEntryData, customProductSaveDescriptorData);
			return customProductManifestEntryData;
		}

		internal bool IsValid()
		{
			if (!CustomProductManifestData.IsBoundedIdentifier(ProductId) || !CustomProductManifestData.IsBoundedIdentifier(OwnerId) || !CustomProductManifestData.IsBoundedIdentifier(ProductKindId) || !CustomProductManifestData.IsBoundedIdentifier(RepresentationTemplateId) || PresentationProfileId == null || PresentationProfileId.Length > 256 || ConsumptionProfileProviderId == null || (ConsumptionProfileProviderId.Length != 0 && !CustomProductManifestData.IsBoundedIdentifier(ConsumptionProfileProviderId)) || (ConsumptionProfileProviderId.Length == 0 && ConsumptionProfileProviderVersion != 0) || (ConsumptionProfileProviderId.Length != 0 && ConsumptionProfileProviderVersion <= 0) || (ProviderId != null && !CustomProductManifestData.IsBoundedIdentifier(ProviderId)) || !Enum.IsDefined(typeof(DrugType), CompatibilityDrugType) || (ProviderId == null && ProviderVersion != 0) || ProviderVersion < 0 || DescriptorFormatVersion != 1 || PackagingIds == null || PackagingIds.Length > 32 || !CustomProductManifestData.IsHash(CompatibilityHash))
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < PackagingIds.Length; i++)
			{
				if (!CustomProductManifestData.IsBoundedIdentifier(PackagingIds[i]) || !hashSet.Add(PackagingIds[i]) || (i > 0 && StringComparer.OrdinalIgnoreCase.Compare(PackagingIds[i - 1], PackagingIds[i]) >= 0))
				{
					return false;
				}
			}
			return true;
		}

		internal static int Compare(CustomProductManifestEntryData left, CustomProductManifestEntryData right)
		{
			return StringComparer.OrdinalIgnoreCase.Compare(left.ProductId, right.ProductId);
		}

		internal void AppendCanonical(StringBuilder builder, bool includeHash)
		{
			AppendIdentifier(builder, ProductId);
			AppendIdentifier(builder, OwnerId);
			AppendIdentifier(builder, ProductKindId);
			Append(builder, CompatibilityDrugType.ToString(CultureInfo.InvariantCulture));
			Append(builder, DescriptorFormatVersion.ToString(CultureInfo.InvariantCulture));
			AppendIdentifier(builder, ProviderId ?? string.Empty);
			Append(builder, ProviderVersion.ToString(CultureInfo.InvariantCulture));
			Append(builder, ProviderAvailable ? "1" : "0");
			AppendIdentifier(builder, RepresentationTemplateId);
			AppendIdentifier(builder, PresentationProfileId);
			AppendIdentifier(builder, ConsumptionProfileProviderId);
			Append(builder, ConsumptionProfileProviderVersion.ToString(CultureInfo.InvariantCulture));
			for (int i = 0; i < PackagingIds.Length; i++)
			{
				AppendIdentifier(builder, PackagingIds[i]);
			}
			if (includeHash)
			{
				Append(builder, CompatibilityHash);
			}
		}

		internal string? DescribeMismatch(CustomProductManifestEntryData local)
		{
			if (!string.Equals(OwnerId, local.OwnerId, StringComparison.OrdinalIgnoreCase))
			{
				return "owner ID differs";
			}
			if (!string.Equals(ProductKindId, local.ProductKindId, StringComparison.OrdinalIgnoreCase) || CompatibilityDrugType != local.CompatibilityDrugType)
			{
				return "logical kind or native compatibility mapping differs";
			}
			if (DescriptorFormatVersion != local.DescriptorFormatVersion)
			{
				return "descriptor format version differs (host " + DescriptorFormatVersion.ToString(CultureInfo.InvariantCulture) + ", local " + local.DescriptorFormatVersion.ToString(CultureInfo.InvariantCulture) + ")";
			}
			if (!string.Equals(ProviderId, local.ProviderId, StringComparison.OrdinalIgnoreCase) || ProviderVersion != local.ProviderVersion || ProviderAvailable != local.ProviderAvailable)
			{
				return "provider compatibility differs (host '" + (ProviderId ?? "<none>") + "' version " + ProviderVersion.ToString(CultureInfo.InvariantCulture) + " available " + ProviderAvailable.ToString(CultureInfo.InvariantCulture) + ", local '" + (local.ProviderId ?? "<none>") + "' version " + local.ProviderVersion.ToString(CultureInfo.InvariantCulture) + " available " + local.ProviderAvailable.ToString(CultureInfo.InvariantCulture) + ")";
			}
			if (!string.Equals(RepresentationTemplateId, local.RepresentationTemplateId, StringComparison.OrdinalIgnoreCase))
			{
				return "native representation template differs";
			}
			if (!string.Equals(PresentationProfileId, local.PresentationProfileId, StringComparison.OrdinalIgnoreCase))
			{
				return "presentation profile registration differs";
			}
			if (!string.Equals(ConsumptionProfileProviderId, local.ConsumptionProfileProviderId, StringComparison.OrdinalIgnoreCase) || ConsumptionProfileProviderVersion != local.ConsumptionProfileProviderVersion)
			{
				return "consumption profile provider compatibility differs";
			}
			if (PackagingIds.Length != local.PackagingIds.Length)
			{
				return "packaging registration set differs";
			}
			for (int i = 0; i < PackagingIds.Length; i++)
			{
				if (!string.Equals(PackagingIds[i], local.PackagingIds[i], StringComparison.OrdinalIgnoreCase))
				{
					return "packaging registration set differs";
				}
			}
			if (!string.Equals(CompatibilityHash, local.CompatibilityHash, StringComparison.Ordinal))
			{
				return "descriptor scalar or provider-data hash differs";
			}
			return null;
		}

		private static string ComputeCompatibilityHash(CustomProductManifestEntryData entry, CustomProductSaveDescriptorData descriptor)
		{
			StringBuilder stringBuilder = new StringBuilder();
			entry.AppendCanonical(stringBuilder, includeHash: false);
			Append(stringBuilder, descriptor.ProductName);
			Append(stringBuilder, descriptor.Description);
			Append(stringBuilder, descriptor.InitialPrice.ToString("R", CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.LegalStatus.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.BaseAddictiveness.ToString("R", CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.DefaultQuality.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.PlayerEffectDurationSeconds.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.NpcEffectDurationSeconds.ToString(CultureInfo.InvariantCulture));
			Append(stringBuilder, descriptor.HasGeneratedMixColor ? "1" : "0");
			if (descriptor.HasGeneratedMixColor)
			{
				Append(stringBuilder, descriptor.GeneratedMixColorR.ToString(CultureInfo.InvariantCulture));
				Append(stringBuilder, descriptor.GeneratedMixColorG.ToString(CultureInfo.InvariantCulture));
				Append(stringBuilder, descriptor.GeneratedMixColorB.ToString(CultureInfo.InvariantCulture));
				Append(stringBuilder, descriptor.GeneratedMixColorA.ToString(CultureInfo.InvariantCulture));
			}
			for (int i = 0; i < descriptor.PropertyIds.Length; i++)
			{
				AppendIdentifier(stringBuilder, descriptor.PropertyIds[i]);
			}
			Append(stringBuilder, CustomProductManifestData.ComputeHash(descriptor.ProviderData));
			return CustomProductManifestData.ComputeHash(stringBuilder.ToString());
		}

		private static void Append(StringBuilder builder, string value)
		{
			builder.Append(value.Length).Append(':').Append(value)
				.Append('|');
		}

		private static void AppendIdentifier(StringBuilder builder, string value)
		{
			Append(builder, value.ToUpperInvariant());
		}
	}
	internal static class CustomProductManifestRuntime
	{
		private sealed class PendingHostData
		{
			private readonly object _player;

			private readonly object[] _arguments;

			private readonly MethodBase _method;

			internal PendingHostData(object player, object[] arguments, MethodBase method)
			{
				_player = player;
				_arguments = arguments;
				_method = method;
			}

			internal void Invoke()
			{
				_method.Invoke(_player, _arguments);
			}
		}

		private sealed class PendingConnection
		{
			internal int ConnectionId { get; }

			internal NetworkConnection Connection { get; }

			internal DateTime Deadline { get; }

			internal PendingConnection(int connectionId, NetworkConnection connection, DateTime deadline)
			{
				ConnectionId = connectionId;
				Connection = connection;
				Deadline = deadline;
			}
		}

		private const int HandshakeTimeoutSeconds = 15;

		private static readonly object Gate = new object();

		private static readonly Dictionary<int, PendingHostData> PendingHostDataByConnection = new Dictionary<int, PendingHostData>();

		private static readonly Dictionary<int, PendingConnection> PendingConnections = new Dictionary<int, PendingConnection>();

		private static readonly HashSet<int> AcceptedConnections = new HashSet<int>();

		private static readonly CustomProductManifestClientGate ClientGate = new CustomProductManifestClientGate();

		private static bool _serializersConfigured;

		private static bool _hostSubscribed;

		private static bool _clientSubscribed;

		private static bool _clientLifecycleSubscribed;

		private static bool _clientSessionActive;

		private static bool _clientDefinitionsReady;

		private static bool _hostActive;

		private static bool _hostManifestReady;

		private static bool _hostRequiresValidation;

		private static DateTime _clientDeadline;

		private static int _hostEntryCount;

		private static string _sessionId = string.Empty;

		private static string _hostPayload = string.Empty;

		private static string _hostHash = string.Empty;

		private static CustomProductManifestData? _pendingClientManifest;

		private static CustomProductManifestData? _localClientManifest;

		private static MethodInfo? _broadcastToConnectionMethod;

		private static Type? _broadcastServerManagerType;

		private static Action<NetworkConnection, CustomProductManifestAckBroadcast>? _acknowledgementReceiver;

		private static Action<NetworkConnection, RemoteConnectionStateArgs>? _remoteConnectionStateReceiver;

		private static Action<NetworkConnection, bool>? _authenticationResultReceiver;

		private static Action<CustomProductManifestBroadcast>? _manifestReceiver;

		private static Action<ClientConnectionStateArgs>? _clientConnectionStateReceiver;

		private static Action<Writer, CustomProductManifestBroadcast>? _manifestWriter;

		private static Func<Reader, CustomProductManifestBroadcast>? _manifestReader;

		private static Action<Writer, CustomProductManifestAckBroadcast>? _acknowledgementWriter;

		private static Func<Reader, CustomProductManifestAckBroadcast>? _acknowledgementReader;

		internal static void BeginHostSession()
		{
			ConfigureSerializers();
			CustomProductManifestIl2CppWire.Reset();
			lock (Gate)
			{
				_hostActive = true;
				_hostManifestReady = false;
				_sessionId = Guid.NewGuid().ToString("N");
				_hostPayload = string.Empty;
				_hostHash = string.Empty;
				_hostRequiresValidation = false;
				PendingConnections.Clear();
				PendingHostDataByConnection.Clear();
				AcceptedConnections.Clear();
				if (!_hostSubscribed)
				{
					if (_acknowledgementReceiver == null)
					{
						_acknowledgementReceiver = DelegateSupport.ConvertDelegate<Action<NetworkConnection, CustomProductManifestAckBroadcast>>((Delegate)new Action<NetworkConnection, CustomProductManifestAckBroadcast>(ReceiveAcknowledgement));
					}
					if (_remoteConnectionStateReceiver == null)
					{
						_remoteConnectionStateReceiver = DelegateSupport.ConvertDelegate<Action<NetworkConnection, RemoteConnectionStateArgs>>((Delegate)new Action<NetworkConnection, RemoteConnectionStateArgs>(OnRemoteConnectionState));
					}
					if (_authenticationResultReceiver == null)
					{
						_authenticationResultReceiver = DelegateSupport.ConvertDelegate<Action<NetworkConnection, bool>>((Delegate)new Action<NetworkConnection, bool>(OnAuthenticationResult));
					}
					InstanceFinder.NetworkManager.ServerManager.RegisterBroadcast<CustomProductManifestAckBroadcast>(_acknowledgementReceiver, true);
					ServerManager serverManager = InstanceFinder.NetworkManager.ServerManager;
					serverManager.OnRemoteConnectionState += _remoteConnectionStateReceiver;
					ServerManager serverManager2 = InstanceFinder.NetworkManager.ServerManager;
					serverManager2.OnAuthenticationResult += _authenticationResultReceiver;
					_hostSubscribed = true;
				}
			}
		}

		internal static void FinalizeHostManifestAfterDescriptorRestore()
		{
			List<PendingHostData> list = new List<PendingHostData>();
			bool hostRequiresValidation;
			lock (Gate)
			{
				if (!_hostActive || _hostManifestReady)
				{
					return;
				}
				try
				{
					CustomProductManifestData customProductManifestData = CustomProductDefinitionRegistry.CreateManifest();
					_hostPayload = customProductManifestData.Serialize(_sessionId);
					_hostHash = customProductManifestData.CompatibilityHash;
					_hostEntryCount = customProductManifestData.Entries.Length;
					_hostRequiresValidation = RequiresValidation(customProductManifestData);
				}
				catch (Exception ex)
				{
					_hostPayload = string.Empty;
					_hostHash = string.Empty;
					_hostEntryCount = CustomProductDefinitionRegistry.GetSaveDescriptors().Length;
					_hostRequiresValidation = _hostEntryCount != 0;
					Warn("custom-product manifest is unavailable; multiplayer joins will be rejected while single-player loading continues: " + ex.GetType().Name);
				}
				_hostManifestReady = true;
				Info("host manifest finalized after descriptor restore; entries=" + _hostEntryCount);
				if (!_hostRequiresValidation)
				{
					list.AddRange(PendingHostDataByConnection.Values);
					PendingHostDataByConnection.Clear();
				}
				hostRequiresValidation = _hostRequiresValidation;
			}
			if (hostRequiresValidation)
			{
				SendManifestToAuthenticatedClients();
				return;
			}
			for (int i = 0; i < list.Count; i++)
			{
				list[i].Invoke();
			}
		}

		internal static void RefreshHostManifestIfReady()
		{
			lock (Gate)
			{
				if (_hostActive && _hostManifestReady)
				{
					CustomProductManifestData customProductManifestData = CustomProductDefinitionRegistry.CreateManifest();
					_hostPayload = customProductManifestData.Serialize(_sessionId);
					_hostHash = customProductManifestData.CompatibilityHash;
					_hostEntryCount = customProductManifestData.Entries.Length;
					_hostRequiresValidation = RequiresValidation(customProductManifestData);
					Info("host manifest refreshed after dynamic custom-product registration; entries=" + _hostEntryCount);
				}
			}
		}

		internal static void BeginClientSession()
		{
			ConfigureSerializers();
			CustomProductManifestIl2CppWire.Reset();
			lock (Gate)
			{
				_clientSessionActive = true;
				_clientDefinitionsReady = false;
				_pendingClientManifest = null;
				_localClientManifest = null;
				ClientGate.Begin(requiresValidation: true);
				_clientDeadline = DateTime.MaxValue;
				if (!_clientLifecycleSubscribed)
				{
					GameLifecycle.OnPreLoad += OnClientDefinitionsReady;
					_clientLifecycleSubscribed = true;
				}
				if (!_clientSubscribed)
				{
					if (_manifestReceiver == null)
					{
						_manifestReceiver = DelegateSupport.ConvertDelegate<Action<CustomProductManifestBroadcast>>((Delegate)new Action<CustomProductManifestBroadcast>(ReceiveManifest));
					}
					if (_clientConnectionStateReceiver == null)
					{
						_clientConnectionStateReceiver = DelegateSupport.ConvertDelegate<Action<ClientConnectionStateArgs>>((Delegate)new Action<ClientConnectionStateArgs>(OnClientConnectionState));
					}
					InstanceFinder.NetworkManager.ClientManager.RegisterBroadcast<CustomProductManifestBroadcast>(_manifestReceiver);
					ClientManager clientManager = InstanceFinder.NetworkManager.ClientManager;
					clientManager.OnClientConnectionState += _clientConnectionStateReceiver;
					_clientSubscribed = true;
				}
			}
		}

		internal static void EndHostSession()
		{
			CustomProductManifestIl2CppWire.Reset();
			lock (Gate)
			{
				_hostActive = false;
				_hostManifestReady = false;
				_hostRequiresValidation = false;
				_sessionId = string.Empty;
				_hostPayload = string.Empty;
				_hostHash = string.Empty;
				_hostEntryCount = 0;
				PendingConnections.Clear();
				PendingHostDataByConnection.Clear();
				AcceptedConnections.Clear();
				if (_hostSubscribed)
				{
					if ((Object)(object)InstanceFinder.NetworkManager == (Object)null)
					{
						_hostSubscribed = false;
						return;
					}
					InstanceFinder.NetworkManager.ServerManager.UnregisterBroadcast<CustomProductManifestAckBroadcast>(_acknowledgementReceiver);
					ServerManager serverManager = InstanceFinder.NetworkManager.ServerManager;
					serverManager.OnRemoteConnectionState -= _remoteConnectionStateReceiver;
					ServerManager serverManager2 = InstanceFinder.NetworkManager.ServerManager;
					serverManager2.OnAuthenticationResult -= _authenticationResultReceiver;
					_hostSubscribed = false;
				}
			}
		}

		internal static void EndClientSession()
		{
			CustomProductManifestIl2CppWire.Reset();
			lock (Gate)
			{
				_clientSessionActive = false;
				_clientDefinitionsReady = false;
				_pendingClientManifest = null;
				_localClientManifest = null;
				ClientGate.End();
				if (_clientLifecycleSubscribed)
				{
					GameLifecycle.OnPreLoad -= OnClientDefinitionsReady;
					_clientLifecycleSubscribed = false;
				}
				if (_clientSubscribed)
				{
					if ((Object)(object)InstanceFinder.NetworkManager == (Object)null)
					{
						_clientSubscribed = false;
						return;
					}
					InstanceFinder.NetworkManager.ClientManager.UnregisterBroadcast<CustomProductManifestBroadcast>(_manifestReceiver);
					ClientManager clientManager = InstanceFinder.NetworkManager.ClientManager;
					clientManager.OnClientConnectionState -= _clientConnectionStateReceiver;
					_clientSubscribed = false;
				}
			}
		}

		internal static void Tick()
		{
			DateTime utcNow = DateTime.UtcNow;
			List<PendingConnection> list = new List<PendingConnection>();
			bool flag;
			lock (Gate)
			{
				flag = ClientGate.IsWaiting && utcNow >= _clientDeadline;
				if (flag)
				{
					ClientGate.End();
				}
				foreach (KeyValuePair<int, PendingConnection> pendingConnection in PendingConnections)
				{
					if (utcNow >= pendingConnection.Value.Deadline)
					{
						list.Add(pendingConnection.Value);
					}
				}
				for (int i = 0; i < list.Count; i++)
				{
					int connectionId = list[i].ConnectionId;
					PendingConnections.Remove(connectionId);
					PendingHostDataByConnection.Remove(connectionId);
				}
			}
			if (flag)
			{
				Warn("custom-product manifest was not received before player data; disconnecting safely");
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if (networkManager != null)
				{
					networkManager.ClientManager.StopConnection();
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Warn("custom-product manifest acknowledgement timed out; rejecting the joining client");
				list[j].Connection.Disconnect(true);
			}
		}

		internal static bool AuthorizeClientPlayerDataRequest(Action request)
		{
			if (request == null)
			{
				throw new ArgumentNullException("request");
			}
			lock (Gate)
			{
				if (!InstanceFinder.IsClient || InstanceFinder.IsServer)
				{
					return true;
				}
				bool flag = ClientGate.AuthorizePlayerDataRequest(request);
				if (!flag)
				{
					_clientDeadline = DateTime.UtcNow.AddSeconds(15.0);
					Info("client player-data request deferred until manifest validation");
				}
				return flag;
			}
		}

		internal static bool AuthorizeHostPlayerData(object player, NetworkConnection connection, object[] arguments, MethodBase originalMethod)
		{
			if (player == null || connection == (NetworkConnection)null || arguments == null || originalMethod == null)
			{
				return true;
			}
			int clientId = connection.ClientId;
			lock (Gate)
			{
				if (!_hostActive)
				{
					return true;
				}
				if (!_hostManifestReady)
				{
					if (!PendingHostDataByConnection.ContainsKey(clientId))
					{
						PendingHostDataByConnection.Add(clientId, new PendingHostData(player, (object[])arguments.Clone(), originalMethod));
					}
					return false;
				}
				if (!_hostRequiresValidation)
				{
					return true;
				}
				if (AcceptedConnections.Contains(clientId))
				{
					return true;
				}
			}
			bool flag = SendManifest(connection);
			lock (Gate)
			{
				if (AcceptedConnections.Contains(clientId))
				{
					return true;
				}
				if (!flag)
				{
					return false;
				}
				if (!PendingHostDataByConnection.ContainsKey(clientId))
				{
					PendingHostDataByConnection.Add(clientId, new PendingHostData(player, (object[])arguments.Clone(), originalMethod));
				}
				return false;
			}
		}

		internal static string GetLocalCompatibilityHash()
		{
			return CustomProductDefinitionRegistry.CreateManifest().CompatibilityHash;
		}

		private static void ConfigureSerializers()
		{
			lock (Gate)
			{
				if (!_serializersConfigured)
				{
					if (_manifestWriter == null)
					{
						_manifestWriter = DelegateSupport.ConvertDelegate<Action<Writer, CustomProductManifestBroadcast>>((Delegate)new Action<Writer, CustomProductManifestBroadcast>(WriteManifest));
					}
					if (_manifestReader == null)
					{
						_manifestReader = DelegateSupport.ConvertDelegate<Func<Reader, CustomProductManifestBroadcast>>((Delegate)new Func<Reader, CustomProductManifestBroadcast>(ReadManifest));
					}
					if (_acknowledgementWriter == null)
					{
						_acknowledgementWriter = DelegateSupport.ConvertDelegate<Action<Writer, CustomProductManifestAckBroadcast>>((Delegate)new Action<Writer, CustomProductManifestAckBroadcast>(WriteAcknowledgement));
					}
					if (_acknowledgementReader == null)
					{
						_acknowledgementReader = DelegateSupport.ConvertDelegate<Func<Reader, CustomProductManifestAckBroadcast>>((Delegate)new Func<Reader, CustomProductManifestAckBroadcast>(ReadAcknowledgement));
					}
					GenericWriter<CustomProductManifestBroadcast>.Write = _manifestWriter;
					GenericReader<CustomProductManifestBroadcast>.Read = _manifestReader;
					GenericWriter<CustomProductManifestAckBroadcast>.Write = _acknowledgementWriter;
					GenericReader<CustomProductManifestAckBroadcast>.Read = _acknowledgementReader;
					_serializersConfigured = true;
				}
			}
		}

		private static void OnRemoteConnectionState(NetworkConnection connection, RemoteConnectionStateArgs arguments)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)arguments.ConnectionState == 0)
			{
				int clientId = connection.ClientId;
				lock (Gate)
				{
					PendingConnections.Remove(clientId);
					PendingHostDataByConnection.Remove(clientId);
					AcceptedConnections.Remove(clientId);
				}
			}
		}

		private static void OnAuthenticationResult(NetworkConnection connection, bool authenticated)
		{
			if (authenticated)
			{
				SendManifestOrReject(connection);
			}
		}

		private static void SendManifestToAuthenticatedClients()
		{
			if ((Object)(object)InstanceFinder.NetworkManager == (Object)null)
			{
				return;
			}
			Enumerator<int, NetworkConnection> enumerator = InstanceFinder.NetworkManager.ServerManager.Clients.GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<int, NetworkConnection> current = enumerator.Current;
				NetworkConnection value = current.Value;
				if (value != (NetworkConnection)null && value.Authenticated && !value.IsLocalClient)
				{
					SendManifestOrReject(value);
				}
			}
		}

		private static void SendManifestOrReject(NetworkConnection connection)
		{
			if (!SendManifest(connection))
			{
				bool flag;
				lock (Gate)
				{
					flag = _hostActive && _hostManifestReady && _hostRequiresValidation;
				}
				if (flag)
				{
					Warn("custom-product manifest is unavailable; rejecting the joining client");
					connection.Disconnect(true);
				}
			}
		}

		private static bool SendManifest(NetworkConnection connection)
		{
			if (connection == (NetworkConnection)null || connection.IsLocalClient || !connection.Authenticated)
			{
				return false;
			}
			int clientId = connection.ClientId;
			string hostPayload;
			lock (Gate)
			{
				if (!_hostActive || !_hostManifestReady || !_hostRequiresValidation || string.IsNullOrEmpty(_hostPayload))
				{
					return false;
				}
				if (PendingConnections.ContainsKey(clientId) || AcceptedConnections.Contains(clientId))
				{
					return true;
				}
				hostPayload = _hostPayload;
				PendingConnections[clientId] = new PendingConnection(clientId, connection, DateTime.UtcNow.AddSeconds(15.0));
			}
			try
			{
				CustomProductManifestIl2CppWire.PrepareOutgoingManifest(hostPayload);
				BroadcastToConnection(InstanceFinder.NetworkManager.ServerManager, connection, new CustomProductManifestBroadcast());
				Info("host manifest sent to authenticated client; entries=" + _hostEntryCount);
				return true;
			}
			catch (Exception ex)
			{
				CustomProductManifestIl2CppWire.ClearOutgoingManifest();
				lock (Gate)
				{
					PendingConnections.Remove(clientId);
				}
				Warn("custom-product manifest could not be sent; rejecting the joining client: " + ex.GetType().Name);
				connection.Disconnect(true);
				return false;
			}
		}

		private static void BroadcastToConnection<T>(object serverManager, object connection, T message)
		{
			MethodInfo methodInfo = ResolveBroadcastToConnectionMethod(serverManager.GetType());
			methodInfo.MakeGenericMethod(typeof(T)).Invoke(serverManager, new object[4]
			{
				connection,
				message,
				true,
				(object)(Channel)0
			});
		}

		private static MethodInfo ResolveBroadcastToConnectionMethod(Type serverManagerType)
		{
			lock (Gate)
			{
				if (_broadcastToConnectionMethod != null && _broadcastServerManagerType == serverManagerType)
				{
					return _broadcastToConnectionMethod;
				}
				MethodInfo[] methods = serverManagerType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
				foreach (MethodInfo methodInfo in methods)
				{
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (!(methodInfo.Name != "Broadcast") && methodInfo.IsGenericMethodDefinition && methodInfo.GetGenericArguments().Length == 1 && parameters.Length == 4 && !(parameters[0].ParameterType != typeof(NetworkConnection)) && parameters[1].ParameterType.IsGenericParameter && !(parameters[2].ParameterType != typeof(bool)) && !(parameters[3].ParameterType != typeof(Channel)))
					{
						_broadcastServerManagerType = serverManagerType;
						_broadcastToConnectionMethod = methodInfo;
						return methodInfo;
					}
				}
			}
			throw new MissingMethodException("FishNet ServerManager.Broadcast<T>(NetworkConnection, T, bool, Channel)");
		}

		private static void ReceiveManifest(CustomProductManifestBroadcast message)
		{
			string payload = CustomProductManifestIl2CppWire.TakeIncomingManifest();
			if (!CustomProductManifestData.TryDeserialize(payload, out CustomProductManifestData manifest, out string failure))
			{
				RejectClient("received " + failure);
				return;
			}
			bool flag = false;
			bool flag2 = false;
			lock (Gate)
			{
				if (!_clientSessionActive)
				{
					return;
				}
				if (!_clientDefinitionsReady)
				{
					if (_pendingClientManifest != null && (!string.Equals(_pendingClientManifest.SessionId, manifest.SessionId, StringComparison.Ordinal) || !string.Equals(_pendingClientManifest.CompatibilityHash, manifest.CompatibilityHash, StringComparison.Ordinal)))
					{
						flag = true;
					}
					else
					{
						_pendingClientManifest = manifest;
						flag2 = true;
					}
				}
			}
			if (flag)
			{
				RejectClient("received conflicting manifests before local definitions were ready");
			}
			else if (flag2)
			{
				Info("client manifest queued until pre-load custom definitions are registered");
			}
			else
			{
				ProcessManifest(manifest);
			}
		}

		private static void OnClientDefinitionsReady()
		{
			CustomProductManifestData customProductManifestData;
			try
			{
				customProductManifestData = CustomProductDefinitionRegistry.CreateManifest();
			}
			catch (Exception ex)
			{
				RejectClient("local custom-product registrations cannot be represented safely: " + ex.GetType().Name);
				return;
			}
			CustomProductManifestData pendingClientManifest;
			lock (Gate)
			{
				if (!_clientSessionActive)
				{
					return;
				}
				_localClientManifest = customProductManifestData;
				_clientDefinitionsReady = true;
				ClientGate.Begin(RequiresValidation(customProductManifestData));
				pendingClientManifest = _pendingClientManifest;
				_pendingClientManifest = null;
			}
			Info("client pre-load custom definitions ready; entries=" + customProductManifestData.Entries.Length);
			if (pendingClientManifest != null)
			{
				ProcessManifest(pendingClientManifest);
			}
		}

		internal static bool RequiresValidation(CustomProductManifestData manifest)
		{
			return manifest.Entries.Length != 0 || manifest.MixingProfiles.Length != 0;
		}

		private static void ProcessManifest(CustomProductManifestData manifest)
		{
			CustomProductManifestData localClientManifest;
			lock (Gate)
			{
				if (!_clientSessionActive || !_clientDefinitionsReady || _localClientManifest == null)
				{
					return;
				}
				localClientManifest = _localClientManifest;
			}
			for (int i = 0; i < manifest.GeneratedDescriptors.Length; i++)
			{
				if (!CustomProductSavePersistence.TryRestoreGeneratedDescriptorFromNetwork(manifest.GeneratedDescriptors[i]))
				{
					RejectClient("generated custom-product descriptor could not be restored safely");
					return;
				}
			}
			try
			{
				localClientManifest = CustomProductDefinitionRegistry.CreateManifest();
				lock (Gate)
				{
					_localClientManifest = localClientManifest;
				}
			}
			catch (Exception ex)
			{
				RejectClient("generated custom-product manifest could not be recreated: " + ex.GetType().Name);
				return;
			}
			string compatibilityHash = localClientManifest.CompatibilityHash;
			CustomProductManifestAcceptance customProductManifestAcceptance;
			Action deferredPlayerDataRequest;
			lock (Gate)
			{
				customProductManifestAcceptance = ClientGate.Accept(manifest.CompatibilityHash, compatibilityHash, out deferredPlayerDataRequest);
			}
			switch (customProductManifestAcceptance)
			{
			case CustomProductManifestAcceptance.AlreadyAccepted:
				return;
			case CustomProductManifestAcceptance.Incompatible:
				RejectClient(CustomProductManifestData.DescribeCompatibilityMismatch(manifest, localClientManifest));
				return;
			}
			try
			{
				CustomProductManifestIl2CppWire.PrepareOutgoingAcknowledgement(manifest.SessionId, manifest.CompatibilityHash);
				InstanceFinder.NetworkManager.ClientManager.Broadcast<CustomProductManifestAckBroadcast>(new CustomProductManifestAckBroadcast(), (Channel)0);
			}
			catch (Exception ex2)
			{
				CustomProductManifestIl2CppWire.ClearOutgoingAcknowledgement();
				RejectClient("manifest acknowledgement could not be sent safely: " + ex2.GetType().Name);
				return;
			}
			Info("client manifest accepted before player-data request; entries=" + manifest.Entries.Length);
			deferredPlayerDataRequest?.Invoke();
		}

		private static void ReceiveAcknowledgement(NetworkConnection connection, CustomProductManifestAckBroadcast acknowledgement)
		{
			(string SessionId, string CompatibilityHash) tuple = CustomProductManifestIl2CppWire.TakeIncomingAcknowledgement();
			string item = tuple.SessionId;
			string item2 = tuple.CompatibilityHash;
			PendingHostData value = null;
			string text = null;
			int clientId = connection.ClientId;
			lock (Gate)
			{
				if (!CustomProductManifestData.IsSessionId(item) || !CustomProductManifestData.IsHash(item2))
				{
					text = "manifest acknowledgement bounds are invalid";
				}
				else if (!_hostActive || !string.Equals(item, _sessionId, StringComparison.Ordinal) || !string.Equals(item2, _hostHash, StringComparison.Ordinal))
				{
					text = "manifest acknowledgement does not match this host session";
				}
				else
				{
					if (AcceptedConnections.Contains(clientId))
					{
						return;
					}
					if (!PendingConnections.Remove(clientId))
					{
						text = "manifest acknowledgement was unsolicited or replayed";
					}
					else
					{
						AcceptedConnections.Add(clientId);
						if (PendingHostDataByConnection.TryGetValue(clientId, out value))
						{
							PendingHostDataByConnection.Remove(clientId);
						}
					}
				}
			}
			if (text != null)
			{
				RejectConnection(connection, text);
				return;
			}
			Info("host manifest acknowledgement accepted; deferredPlayerData=" + (value != null));
			value?.Invoke();
		}

		private static void OnClientConnectionState(ClientConnectionStateArgs arguments)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000a: 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_0011: Invalid comparison between Unknown and I4
			if ((int)arguments.ConnectionState == 3 || (int)arguments.ConnectionState == 0)
			{
				EndClientSession();
			}
		}

		private static void RejectClient(string reason)
		{
			Warn("custom-product manifest rejected: " + reason);
			lock (Gate)
			{
				ClientGate.End();
				_clientSessionActive = false;
				_clientDefinitionsReady = false;
				_pendingClientManifest = null;
				_localClientManifest = null;
			}
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if (networkManager != null)
			{
				networkManager.ClientManager.StopConnection();
			}
		}

		private static void RejectConnection(NetworkConnection connection, string reason)
		{
			int clientId = connection.ClientId;
			lock (Gate)
			{
				PendingConnections.Remove(clientId);
				PendingHostDataByConnection.Remove(clientId);
				AcceptedConnections.Remove(clientId);
			}
			Warn("custom-product manifest acknowledgement rejected: " + reason);
			connection.Disconnect(true);
		}

		private static void WriteManifest(Writer writer, CustomProductManifestBroadcast value)
		{
			writer.WriteString(CustomProductManifestIl2CppWire.TakeOutgoingManifest());
		}

		private static CustomProductManifestBroadcast ReadManifest(Reader reader)
		{
			CustomProductManifestIl2CppWire.SetIncomingManifest(reader.ReadString());
			return new CustomProductManifestBroadcast();
		}

		private static void WriteAcknowledgement(Writer writer, CustomProductManifestAckBroadcast value)
		{
			var (text, text2) = CustomProductManifestIl2CppWire.TakeOutgoingAcknowledgement();
			writer.WriteString(text);
			writer.WriteString(text2);
		}

		private static CustomProductManifestAckBroadcast ReadAcknowledgement(Reader reader)
		{
			CustomProductManifestIl2CppWire.SetIncomingAcknowledgement(reader.ReadString(), reader.ReadString());
			return new CustomProductManifestAckBroadcast();
		}

		private static void Warn(string message)
		{
			try
			{
				MelonLogger.Warning("[CustomProductManifest] " + message);
			}
			catch (Exception)
			{
			}
		}

		private static void Info(string message)
		{
			try
			{
				MelonLogger.Msg("[CustomProductManifest] " + message);
			}
			catch (Exception)
			{
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	[Il2CppImplements(new Type[] { typeof(IBroadcast) })]
	internal sealed class CustomProductManifestBroadcast : Object
	{
		public CustomProductManifestBroadcast(IntPtr pointer)
			: base(pointer)
		{
		}

		public CustomProductManifestBroadcast()
			: base(ClassInjector.DerivedConstructorPointer<CustomProductManifestBroadcast>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}
	}
	[RegisterTypeInIl2Cpp]
	[Il2CppImplements(new Type[] { typeof(IBroadcast) })]
	internal sealed class CustomProductManifestAckBroadcast : Object
	{
		public CustomProductManifestAckBroadcast(IntPtr pointer)
			: base(pointer)
		{
		}

		public CustomProductManifestAckBroadcast()
			: base(ClassInjector.DerivedConstructorPointer<CustomProductManifestAckBroadcast>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}
	}
	internal static class CustomProductManifestIl2CppWire
	{
		private static readonly object Sync = new object();

		private static string? _outgoingManifest;

		private static string? _incomingManifest;

		private static (string SessionId, string CompatibilityHash)? _outgoingAcknowledgement;

		private static (string SessionId, string CompatibilityHash)? _incomingAcknowledgement;

		internal static void PrepareOutgoingManifest(string payload)
		{
			Set(ref _outgoingManifest, payload, "outgoing manifest");
		}

		internal static string TakeOutgoingManifest()
		{
			return Take(ref _outgoingManifest, "outgoing manifest");
		}

		internal static void ClearOutgoingManifest()
		{
			Clear(ref _outgoingManifest);
		}

		internal static void SetIncomingManifest(string payload)
		{
			Set(ref _incomingManifest, payload, "incoming manifest");
		}

		internal static string TakeIncomingManifest()
		{
			return Take(ref _incomingManifest, "incoming manifest");
		}

		internal static void PrepareOutgoingAcknowledgement(string sessionId, string compatibilityHash)
		{
			Set<(string, string)>(ref _outgoingAcknowledgement, (sessionId, compatibilityHash), "outgoing acknowledgement");
		}

		internal static (string SessionId, string CompatibilityHash) TakeOutgoingAcknowledgement()
		{
			return Take<(string, string)>(ref _outgoingAcknowledgement, "outgoing acknowledgement");
		}

		internal static void ClearOutgoingAcknowledgement()
		{
			Clear<(string, string)>(ref _outgoingAcknowledgement);
		}

		internal static void SetIncomingAcknowledgement(string sessionId, string compatibilityHash)
		{
			Set<(string, string)>(ref _incomingAcknowledgement, (sessionId, compatibilityHash), "incoming acknowledgement");
		}

		internal static (string SessionId, string CompatibilityHash) TakeIncomingAcknowledgement()
		{
			return Take<(string, string)>(ref _incomingAcknowledgement, "incoming acknowledgement");
		}

		internal static void Reset()
		{
			lock (Sync)
			{
				_outgoingManifest = null;
				_incomingManifest = null;
				_outgoingAcknowledgement = null;
				_incomingAcknowledgement = null;
			}
		}

		private static void Set<T>(ref T? slot, T value, string name) where T : struct
		{
			lock (Sync)
			{
				if (slot.HasValue)
				{
					throw new InvalidOperationException("IL2CPP custom-product " + name + " overlapped another message.");
				}
				slot = value;
			}
		}

		private static void Set(ref string? slot, string value, string name)
		{
			lock (Sync)
			{
				if (slot != null)
				{
					throw new InvalidOperationException("IL2CPP custom-product " + name + " overlapped another message.");
				}
				slot = value;
			}
		}

		private static T Take<T>(ref T? slot, string name) where T : struct
		{
			lock (Sync)
			{
				if (!slot.HasValue)
				{
					throw new InvalidOperationException("IL2CPP custom-product " + name + " was not prepared.");
				}
				T value = slot.Value;
				slot = null;
				return value;
			}
		}

		private static string Take(ref string? slot, string name)
		{
			lock (Sync)
			{
				string result = slot ?? throw new InvalidOperationException("IL2CPP custom-product " + name + " was not prepared.");
				slot = null;
				return result;
			}
		}

		private static void Clear<T>(ref T? slot) where T : struct
		{
			lock (Sync)
			{
				slot = null;
			}
		}

		private static void Clear(ref string? slot)
		{
			lock (Sync)
			{
				slot = null;
			}
		}
	}
	internal static class CustomProductMixingIdentity
	{
		private const string FallbackOwnerId = "s1api";

		internal static string CreateGeneratedProductId(string sourceProductId, string nativeMixId)
		{
			string text = ProductKindId.Normalize(sourceProductId, "sourceProductId");
			if (string.IsNullOrWhiteSpace(nativeMixId))
			{
				throw new InvalidOperationException("The native mix-name sanitizer produced an empty ID.");
			}
			string ownerId = text[..text.IndexOf(':')];
			string sourceHash = CustomProductManifestData.ComputeHash(text);
			string text2 = CustomProductManifestData.ComputeHash(nativeMixId);
			return ProductKindId.Normalize(CreateGeneratedPrefix(text, ownerId, sourceHash) + text2, "nativeMixId");
		}

		internal static bool IsGeneratedIdForSource(string sourceProductId, string productId)
		{
			string text = ProductKindId.Normalize(sourceProductId, "sourceProductId");
			int num = text.IndexOf(':');
			string text2 = text.Substring(0, num);
			string value = CreateGeneratedPrefix(text, text2, CustomProductManifestData.ComputeHash(text));
			if (productId.StartsWith(value, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string value2 = CreateBoundedSourceHashPrefix(text2, CustomProductManifestData.ComputeHash(text));
			if (productId.StartsWith(value2, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			string value3 = text2 + ":mix/" + text.Substring(num + 1) + "/";
			return productId.StartsWith(value3, StringComparison.OrdinalIgnoreCase);
		}

		private static string CreateGeneratedPrefix(string sourceId, string ownerId, string sourceHash)
		{
			int num = sourceId.IndexOf(':');
			string text = ownerId + ":mix/" + sourceId.Substring(num + 1) + "/";
			return (text.Length + 64 <= 256) ? text : CreateBoundedSourceHashPrefix(ownerId, sourceHash);
		}

		private static string CreateBoundedSourceHashPrefix(string ownerId, string sourceHash)
		{
			string text = ownerId + ":mix/" + sourceHash + "/";
			return (text.Length + 64 <= 256) ? text : ("s1api:mix/" + sourceHash + "/");
		}
	}
	internal sealed class CustomProductMixingProfileManifestEntryData
	{
		public string ProductKindId = string.Empty;

		public int MixerMap;

		public string OutputFactoryIdentity = string.Empty;

		public int OutputFactoryVersion;

		public bool UsePropertyColorMixing;

		internal static CustomProductMixingProfileManifestEntryData Create(ProductMixingProfile profile)
		{
			return new CustomProductMixingProfileManifestEntryData
			{
				ProductKindId = profile.ProductKind.Id,
				MixerMap = (int)profile.MixerMap,
				OutputFactoryIdentity = profile.OutputFactoryIdentity,
				OutputFactoryVersion = profile.OutputFactoryVersion,
				UsePropertyColorMixing = profile.UsePropertyColorMixing
			};
		}

		internal bool IsValid()
		{
			return CustomProductManifestData.IsBoundedIdentifier(ProductKindId) && Enum.IsDefined(typeof(ProductMixingMap), MixerMap) && CustomProductManifestData.IsBoundedIdentifier(OutputFactoryIdentity) && OutputFactoryVersion >= 0;
		}

		internal static int Compare(CustomProductMixingProfileManifestEntryData left, CustomProductMixingProfileManifestEntryData right)
		{
			return StringComparer.OrdinalIgnoreCase.Compare(left.ProductKindId, right.ProductKindId);
		}

		internal void AppendCanonical(StringBuilder builder)
		{
			builder.Append(ProductKindId.ToUpperInvariant()).Append('|');
			builder.Append(MixerMap.ToString(CultureInfo.InvariantCulture)).Append('|');
			builder.Append(OutputFactoryIdentity.ToUpperInvariant()).Append('|');
			builder.Append(OutputFactoryVersion.ToString(CultureInfo.InvariantCulture)).Append('|');
			builder.Append(UsePropertyColorMixing ? "1|" : "0|");
		}

		internal string? DescribeMismatch(CustomProductMixingProfileManifestEntryData local)
		{
			if (MixerMap != local.MixerMap)
			{
				return "native mixer-map strategy differs";
			}
			if (!string.Equals(OutputFactoryIdentity, local.OutputFactoryIdentity, StringComparison.OrdinalIgnoreCase) || OutputFactoryVersion != local.OutputFactoryVersion)
			{
				return "output-factory compatibility identity or version differs";
			}
			if (UsePropertyColorMixing != local.UsePropertyColorMixing)
			{
				return "property-color mixing strategy differs";
			}
			return null;
		}
	}
	internal sealed class CustomProductPresentationRuntime : ICustomProductPresentationRuntime
	{
		private sealed class GeneratedIconRequest
		{
			internal CustomProductDefinitionRegistration Product { get; }

			internal ProductPresentationProfileRegistration Registration { get; }

			internal CustomProductPresentationState State { get; }

			internal GeneratedIconRequest(CustomProductDefinitionRegistration product, ProductPresentationProfileRegistration registration, CustomProductPresentationState state)
			{
				Product = product;
				Registration = registration;
				State = state;
			}
		}

		internal enum GeneratedIconAttemptResult
		{
			Success,
			Retry,
			Failure
		}

		internal static readonly CustomProductPresentationRuntime Instance = new CustomProductPresentationRuntime();

		private static GameObject? _cacheRoot;

		private static readonly object GeneratedIconQueueGate = new object();

		private static readonly Queue<GeneratedIconRequest> GeneratedIconQueue = new Queue<GeneratedIconRequest>();

		private static bool _isProcessingGeneratedIcons;

		private const string DiscoveryVisualRootName = "S1API_CustomProductDiscoveryVisual";

		internal static bool GeneratedIconWorkComplete
		{
			get
			{
				lock (GeneratedIconQueueGate)
				{
					return !_isProcessingGeneratedIcons && GeneratedIconQueue.Count == 0;
				}
			}
		}

		private CustomProductPresentationRuntime()
		{
		}

		public void Apply(CustomProductDefinitionRegistration product, ProductPresentationProfileRegistration? profile)
		{
			if (product.Metadata == null)
			{
				return;
			}
			if (profile == null)
			{
				if (product.PresentationState != null)
				{
					RestoreBaseline(product);
				}
				return;
			}
			CustomProductPresentationState customProductPresentationState = product.PresentationState ?? (product.PresentationState = new CustomProductPresentationState(product.Definition, product.Metadata));
			if (customProductPresentationState.AppliedRegistration == profile && GeneratedObjectsAreAlive(customProductPresentationState.GeneratedObjects))
			{
				QueuePendingGeneratedIcon(product, profile, customProductPresentationState);
			}
			else
			{
				BuildAndCommit(product, profile);
			}
		}

		internal static void ApplyDiscoveryVisual(MultiTypeVisualsSetter setter, ProductDefinition product, List<Effect> properties)
		{
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			if ((Object)(object)setter == (Object)null)
			{
				return;
			}
			RemoveDiscoveryVisual(((Component)setter).transform);
			if ((Object)(object)product == (Object)null || properties == null || !CustomProductDefinitionRegistry.TryGetMetadata(product, out CustomProductDefinitionMetadata metadata) || metadata == null || !ProductPresentationProfileRegistry.TryResolve(((BaseItemDefinition)product).ID, metadata.ProductKind.Id, out ProductPresentationProfileRegistration registration) || registration == null)
			{
				return;
			}
			ProductPresentationProfile profile = registration.Profile;
			if (!profile.TryGetVisualProvider(ProductPresentationContext.FunctionalProduct, out Func<GameObject> provider) || provider == null)
			{
				return;
			}
			GameObject val;
			try
			{
				val = provider();
			}
			catch (Exception ex)
			{
				MelonLogger.Warning($"[ProductPresentationProfile] Discovery visual provider for '{((BaseItemDefinition)product).ID}' failed: {ex.Message}");
				return;
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject val2 = null;
			try
			{
				val2 = new GameObject("S1API_CustomProductDiscoveryVisual");
				val2.transform.SetParent(((Component)setter).transform, false);
				val2.SetActive(false);
				GameObject val3 = Object.Instantiate<GameObject>(val);
				val3.transform.SetParent(val2.transform, false);
				ApplyVisualTransform(val3.transform, profile, ProductPresentationContext.FunctionalProduct);
				ApplyDiscoveryMixColor(val3, metadata, properties);
				val3.SetActive(true);
				ResetMultiTypeVisuals(setter);
				val2.SetActive(true);
			}
			catch (Exception ex2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
				MelonLogger.Warning("[ProductPresentationProfile] Could not show the discovery visual for '" + ((BaseItemDefinition)product).ID + "'; retaining the native fallback: " + ex2.Message);
			}
		}

		private static void ApplyDiscoveryMixColor(GameObject visual, CustomProductDefinitionMetadata metadata, List<Effect> properties)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			if (!ProductMixingProfiles.TryGet(metadata.ProductKind.Id, out ProductMixingProfile profile) || profile == null || !profile.UsePropertyColorMixing)
			{
				return;
			}
			List<ProductMixingColorSample> list = new List<ProductMixingColorSample>(properties.Count);
			for (int i = 0; i < properties.Count; i++)
			{
				Effect val = properties[i];
				if (!((Object)(object)val == (Object)null))
				{
					Color32 val2 = Color32.op_Implicit(val.ProductColor);
					list.Add(new ProductMixingColorSample(val.Tier, new ProductMixingColorValue(val2.r, val2.g, val2.b, val2.a)));
				}
			}
			Color val3 = Color32.op_Implicit(ProductMixingColorContract.CalculatePrimaryColor(profile.MixerMap, list).ToColor32());
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(visual.GetComponentsInChildren<Renderer>(true));
			MaterialPropertyBlock val4 = new MaterialPropertyBlock();
			foreach (Renderer val5 in array)
			{
				val5.GetPropertyBlock(val4);
				Material[] array2 = Il2CppArrayBase<Material>.op_Implicit((Il2CppArrayBase<Material>)(object)val5.sharedMaterials);
				foreach (Material val6 in array2)
				{
					if (!((Object)(object)val6 == (Object)null))
					{
						if (val6.HasProperty("_BaseColor"))
						{
							val4.SetColor("_BaseColor", val3);
						}
						if (val6.HasProperty("_Color"))
						{
							val4.SetColor("_Color", val3);
						}
					}
				}
				val5.SetPropertyBlock(val4);
				val4.Clear();
			}
		}

		private static void ResetMultiTypeVisuals(MultiTypeVisualsSetter setter)
		{
			WeedVisualsSetter weedVisuals = setter.WeedVisuals;
			if (weedVisuals != null)
			{
				((ProductVisualsSetter)weedVisuals).ResetVisuals();
			}
			MethVisualsSetter methVisuals = setter.MethVisuals;
			if (methVisuals != null)
			{
				((ProductVisualsSetter)methVisuals).ResetVisuals();
			}
			CocaineVisualsSetter cocaineVisuals = setter.CocaineVisuals;
			if (cocaineVisuals != null)
			{
				((ProductVisualsSetter)cocaineVisuals).ResetVisuals();
			}
			ShroomVisualsSetter shroomVisuals = setter.ShroomVisuals;
			if (shroomVisuals != null)
			{
				((ProductVisualsSetter)shroomVisuals).ResetVisuals();
			}
		}

		private static void RemoveDiscoveryVisual(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Transform child = parent.GetChild(num);
				if (string.Equals(((Object)child).name, "S1API_CustomProductDiscoveryVisual", StringComparison.Ordinal))
				{
					((Component)child).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
		}

		private static void BuildAndCommit(CustomProductDefinitionRegistration product, ProductPresentationProfileRegistration registration)
		{
			ProductPresentationProfile profile = registration.Profile;
			CustomProductPresentationState customProductPresentationState = product.PresentationState ?? throw new InvalidOperationException("Presentation state was not initialized.");
			List<Object> list = new List<Object>();
			Dictionary<Func<GameObject>, GameObject> sources = new Dictionary<Func<GameObject>, GameObject>();
			StoredItem baselineStoredItem = customProductPresentationState.BaselineStoredItem;
			Equippable baselineEquippable = customProductPresentationState.BaselineEquippable;
			StationItem baselineStationItem = customProductPresentationState.BaselineStationItem;
			FunctionalProduct baselineFunctionalProduct = customProductPresentationState.BaselineFunctionalProduct;
			Sprite baselineIcon = customProductPresentationState.BaselineIcon;
			ProductConsumeAnimation baselineConsumeAnimation = customProductPresentationState.BaselineConsumeAnimation;
			GameObject registeredAvatarPrefab = null;
			bool generatedIconPending = false;
			try
			{
				baselineStoredItem = BuildStored(product, profile, sources, list, customProductPresentationState.BaselineStoredItem);
				baselineStationItem = BuildStation(product, profile, sources, list, customProductPresentationState.TemplateStationItem ?? customProductPresentationState.BaselineStationItem);
				baselineFunctionalProduct = BuildFunctional(product, profile, sources, list, customProductPresentationState.BaselineFunctionalProduct);
				baselineIcon = BuildIcon(product, profile, sources, list, customProductPresentationState.BaselineIcon, out generatedIconPending);
				baselineConsumeAnimation = BuildConsumption(product, profile, list, customProductPresentationState.BaselineConsumeAnimation);
				baselineEquippable = BuildHeld(product, profile, sources, list, customProductPresentationState.BaselineEquippable, out registeredAvatarPrefab);
			}
			catch
			{
				DestroyAll(list);
				throw;
			}
			ProductDefinition definition = product.Definition;
			((StorableItemDefinition)definition).StoredItem = baselineStoredItem;
			((ItemDefinition)definition).Equippable = baselineEquippable;
			((StorableItemDefinition)definition).StationItem = baselineStationItem;
			definition.FunctionalProduct = baselineFunctionalProduct;
			((BaseItemDefinition)definition).Icon = baselineIcon;
			definition.ConsumeAnimation = baselineConsumeAnimation;
			List<Object> generatedObjects = customProductPresentationState.GeneratedObjects;
			UnregisterHeldAvatar(product, customProductPresentationState);
			customProductPresentationState.GeneratedObjects = list;
			customProductPresentationState.RegisteredAvatarPrefab = registeredAvatarPrefab;
			customProductPresentationState.AppliedRegistration = registration;
			customProductPresentationState.IsGeneratedIconPending = generatedIconPending;
			DestroyAll(generatedObjects);
			QueuePendingGeneratedIcon(product, registration, customProductPresentationState);
		}

		private static StoredItem? BuildStored(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, Dictionary<Func<GameObject?>, GameObject?> sources, List<Object> created, StoredItem? fallback)
		{
			GameObject visualSource = GetVisualSource(product, profile, ProductPresentationContext.Stored, sources);
			if ((Object)(object)visualSource == (Object)null)
			{
				return fallback;
			}
			if ((Object)(object)fallback == (Object)null)
			{
				return MissingScaffold<StoredItem>(product, profile, ProductPresentationContext.Stored, fallback);
			}
			StoredItem val = Object.Instantiate<StoredItem>(fallback, GetCacheRoot().transform);
			PrepareCachedPrefab(((Component)val).gameObject);
			created.Add((Object)(object)((Component)val).gameObject);
			if (!CrossType.Is<Product_Stored>((object)val, out Product_Stored result))
			{
				return InvalidScaffold<StoredItem>(product, profile, ProductPresentationContext.Stored, (Component)(object)val, fallback, created, "Product_Stored");
			}
			result.Visuals = (ProductVisualsSetter)(object)ReplaceVisual(((Component)result).gameObject, result.Visuals, visualSource, profile, ProductPresentationContext.Stored);
			ApplyGeneratedMixColor(((Component)result.Visuals.VisualsContainer).gameObject, product, created);
			return val;
		}

		private static Equippable? BuildHeld(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, Dictionary<Func<GameObject?>, GameObject?> sources, List<Object> created, Equippable? fallback, out GameObject? registeredAvatarPrefab)
		{
			registeredAvatarPrefab = null;
			GameObject visualSource = GetVisualSource(product, profile, ProductPresentationContext.Held, sources);
			if ((Object)(object)visualSource == (Object)null)
			{
				return fallback;
			}
			if ((Object)(object)fallback == (Object)null)
			{
				return MissingScaffold<Equippable>(product, profile, ProductPresentationContext.Held, fallback);
			}
			Equippable val = Object.Instantiate<Equippable>(fallback, GetCacheRoot().transform);
			PrepareCachedPrefab(((Component)val).gameObject);
			created.Add((Object)(object)((Component)val).gameObject);
			if (!CrossType.Is<Product_Equippable>((object)val, out Product_Equippable result))
			{
				return InvalidScaffold<Equippable>(product, profile, ProductPresentationContext.Held, (Component)(object)val, fallback, created, "Product_Equippable");
			}
			result.Visuals = (ProductVisualsSetter)(object)ReplaceVisual(((Component)result).gameObject, result.Visuals, visualSource, profile, ProductPresentationContext.Held);
			ApplyGeneratedMixColor(((Component)result.Visuals.VisualsContainer).gameObject, product, created);
			result.ModelContainer = result.Visuals.VisualsContainer;
			GameObject source = ResolveAvatarHeldSource(product, profile, visualSource, sources);
			((Equippable_Viewmodel)result).AvatarEquippable = BuildAvatarEquippable(product, ((Equippable_Viewmodel)result).AvatarEquippable, source, profile, created);
			registeredAvatarPrefab = ((Component)((Equippable_Viewmodel)result).AvatarEquippable).gameObject;
			return val;
		}

		private static StationItem? BuildStation(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, Dictionary<Func<GameObject?>, GameObject?> sources, List<Object> created, StationItem? fallback)
		{
			GameObject visualSource = GetVisualSource(product, profile, ProductPresentationContext.Station, sources);
			if ((Object)(object)visualSource == (Object)null)
			{
				return product.PresentationState?.BaselineStationItem;
			}
			if ((Object)(object)fallback == (Object)null)
			{
				return MissingScaffold<StationItem>(product, profile, ProductPresentationContext.Station, fallback);
			}
			StationItem val = Object.Instantiate<StationItem>(fallback, GetCacheRoot().transform);
			PrepareCachedPrefab(((Component)val).gameObject);
			created.Add((Object)(object)((Component)val).gameObject);
			if (!CrossType.Is<ProductStationItem>((object)val, out ProductStationItem result))
			{
				return InvalidScaffold<StationItem>(product, profile, ProductPresentationContext.Station, (Component)(object)val, product.PresentationState?.BaselineStationItem, created, "ProductStationItem");
			}
			result.Visuals = ReplaceStationVisual(((Component)result).gameObject, result.Visuals, visualSource, profile);
			ApplyGeneratedMixColor(((Component)result.Visuals.VisualsContainer).gameObject, product, created);
			return val;
		}

		private static FunctionalProduct? BuildFunctional(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, Dictionary<Func<GameObject?>, GameObject?> sources, List<Object> created, FunctionalProduct? fallback)
		{
			GameObject visualSource = GetVisualSource(product, profile, ProductPresentationContext.FunctionalProduct, sources);
			if ((Object)(object)visualSource == (Object)null)
			{
				return fallback;
			}
			if ((Object)(object)fallback == (Object)null)
			{
				return MissingScaffold<FunctionalProduct>(product, profile, ProductPresentationContext.FunctionalProduct, fallback);
			}
			FunctionalProduct val = Object.Instantiate<FunctionalProduct>(fallback, GetCacheRoot().transform);
			PrepareCachedPrefab(((Component)val).gameObject);
			created.Add((Object)(object)((Component)val).gameObject);
			if (!CrossType.Is<FunctionalProduct>((object)val, out FunctionalProduct result))
			{
				return InvalidScaffold<FunctionalProduct>(product, profile, ProductPresentationContext.FunctionalProduct, (Component)(object)val, fallback, created, "FunctionalProduct");
			}
			result.Visuals = (ProductVisualsSetter)(object)ReplaceVisual(((Component)result).gameObject, result.Visuals, visualSource, profile, ProductPresentationContext.FunctionalProduct);
			ApplyGeneratedMixColor(((Component)result.Visuals.VisualsContainer).gameObject, product, created);
			if (profile.UseFunctionalProductConvexMeshColliders)
			{
				ReplaceWithConvexMeshColliders(((Component)result).gameObject, ((Component)result.Visuals.VisualsContainer).gameObject);
			}
			else
			{
				EnsureCollider(((Component)result.Visuals.VisualsContainer).gameObject);
			}
			return val;
		}

		private static Sprite? BuildIcon(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, Dictionary<Func<GameObject?>, GameObject?> sources, List<Object> created, Sprite? fallback, out bool generatedIconPending)
		{
			generatedIconPending = false;
			if (profile.IconProvider != null)
			{
				try
				{
					Sprite val = profile.IconProvider();
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
					return ProviderFailed<Sprite>(product, profile, ProductPresentationContext.Icon, "returned null", fallback);
				}
				catch (Exception ex)
				{
					return ProviderFailed<Sprite>(product, profile, ProductPresentationContext.Icon, ex.Message, fallback);
				}
			}
			if (!profile.GenerateIconFromLooseVisual)
			{
				return MissingProvider<Sprite>(product, profile, ProductPresentationContext.Icon, "no icon provider was configured", fallback);
			}
			generatedIconPending = true;
			return fallback;
		}

		private static void QueuePendingGeneratedIcon(CustomProductDefinitionRegistration product, ProductPresentationProfileRegistration registration, CustomProductPresentationState state)
		{
			if (!state.IsGeneratedIconPending || state.IsGeneratedIconQueued || !registration.Profile.GenerateIconFromLooseVisual)
			{
				return;
			}
			bool flag = false;
			lock (GeneratedIconQueueGate)
			{
				if (state.IsGeneratedIconQueued)
				{
					return;
				}
				state.IsGeneratedIconQueued = true;
				GeneratedIconQueue.Enqueue(new GeneratedIconRequest(product, registration, state));
				if (!_isProcessingGeneratedIcons)
				{
					_isProcessingGeneratedIcons = true;
					flag = true;
				}
			}
			if (flag)
			{
				MelonCoroutines.Start(ProcessGeneratedIconQueue());
			}
		}

		private static IEnumerator ProcessGeneratedIconQueue()
		{
			while (true)
			{
				GeneratedIconRequest request;
				lock (GeneratedIconQueueGate)
				{
					if (GeneratedIconQueue.Count == 0)
					{
						_isProcessingGeneratedIcons = false;
						break;
					}
					request = GeneratedIconQueue.Dequeue();
				}
				CustomProductPresentationState state = request.State;
				ProductIconRenderRigArbiter.CaptureLease renderLease = null;
				try
				{
					if (!state.IsGeneratedIconPending || state.AppliedRegistration != request.Registration)
					{
						continue;
					}
					int readinessFrame = 0;
					while (!IconFactory.IsItemIconGeneratorReady && readinessFrame < 300)
					{
						readinessFrame++;
						yield return null;
					}
					if (!IconFactory.IsItemIconGeneratorReady)
					{
						LogGeneratedIconFailure(request, "the native item-icon rendering rig did not become ready");
						continue;
					}
					renderLease = ProductIconRenderRigArbiter.Enqueue();
					while (!ProductIconRenderRigArbiter.TryAcquire(renderLease))
					{
						if (!state.IsGeneratedIconPending || state.AppliedRegistration != request.Registration)
						{
							ProductIconRenderRigArbiter.Cancel(renderLease);
							renderLease = null;
							break;
						}
						yield return null;
					}
					if (renderLease == null)
					{
						continue;
					}
					string lastError = "the native renderer returned no visible pixels";
					Sprite icon;
					Texture2D texture;
					for (int attempt = 0; attempt <= 30; icon = null, texture = null, attempt++)
					{
						yield return null;
						yield return (object)new WaitForEndOfFrame();
						switch (TryGenerateIcon(request, out icon, out texture, out lastError))
						{
						case GeneratedIconAttemptResult.Success:
							((BaseItemDefinition)request.Product.Definition).Icon = icon;
							state.GeneratedObjects.Add((Object)(object)texture);
							state.GeneratedObjects.Add((Object)(object)icon);
							state.IsGeneratedIconPending = false;
							MelonLogger.Msg($"[ProductPresentationProfile] Generated loose icon for '{request.Product.ProductId}' after {attempt + 1} render attempt(s).");
							break;
						default:
							continue;
						case GeneratedIconAttemptResult.Failure:
							break;
						}
						break;
					}
					if (state.IsGeneratedIconPending)
					{
						LogGeneratedIconFailure(request, lastError);
					}
					yield return null;
					yield return (object)new WaitForEndOfFrame();
					goto IL_0444;
				}
				finally
				{
					if (renderLease != null)
					{
						ProductIconRenderRigArbiter.Release(renderLease);
					}
					state.IsGeneratedIconQueued = false;
					if (state.IsGeneratedIconPending && state.AppliedRegistration != null && state.AppliedRegistration != request.Registration)
					{
						QueuePendingGeneratedIcon(request.Product, state.AppliedRegistration, state);
					}
				}
				IL_0444:
				request = null;
			}
		}

		private static GeneratedIconAttemptResult TryGenerateIcon(GeneratedIconRequest request, out Sprite? icon, out Texture2D? texture, out string error)
		{
			icon = null;
			texture = null;
			ProductPresentationProfile profile = request.Registration.Profile;
			if (!profile.TryGetVisualProvider(ProductPresentationContext.Loose, out Func<GameObject> provider) || provider == null)
			{
				error = "no loose visual provider was configured";
				return GeneratedIconAttemptResult.Failure;
			}
			GameObject val;
			try
			{
				val = provider();
			}
			catch (Exception ex)
			{
				error = "the loose visual provider failed: " + ex.Message;
				return GeneratedIconAttemptResult.Failure;
			}
			if ((Object)(object)val == (Object)null)
			{
				error = "the loose visual provider returned null";
				return GeneratedIconAttemptResult.Failure;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val);
			List<Object> list = new List<Object>();
			try
			{
				ApplyGeneratedMixColor(val2, request.Product, list);
				if (profile.GeneratedIconTransform != null)
				{
					profile.GeneratedIconTransform.ApplyTo(val2.transform);
				}
				else
				{
					ApplyVisualTransform(val2.transform, profile, ProductPresentationContext.Loose);
				}
				Texture2D val3 = IconFactory.GenerateIcon(val2.transform, profile.GeneratedIconSize, bakeSkinnedMeshes: true, profile.FitGeneratedIconToCamera, profile.GeneratedIconCameraFill);
				if ((Object)(object)val3 == (Object)null)
				{
					error = "the native renderer returned no visible pixels";
					return GetGeneratedTextureFailureResult(rendererProducedTexture: false);
				}
				if (!TryCreateUiTexture(val3, request.Product.ProductId, out texture, out error))
				{
					return GetGeneratedTextureFailureResult(rendererProducedTexture: true);
				}
			}
			finally
			{
				Object.Destroy((Object)(object)val2);
				DestroyAll(list);
			}
			icon = global::S1API.Utils.ImageUtils.TextureToSprite(texture);
			if ((Object)(object)icon != (Object)null)
			{
				error = string.Empty;
				return GeneratedIconAttemptResult.Success;
			}
			Object.Destroy((Object)(object)texture);
			texture = null;
			error = "the generated texture could not be converted to a sprite";
			return GeneratedIconAttemptResult.Failure;
		}

		internal static GeneratedIconAttemptResult GetGeneratedTextureFailureResult(bool rendererProducedTexture)
		{
			return (!rendererProducedTexture) ? GeneratedIconAttemptResult.Retry : GeneratedIconAttemptResult.Failure;
		}

		private static bool TryCreateUiTexture(Texture2D renderedTexture, string productId, out Texture2D? uiTexture, out string error)
		{
			//IL_0034: 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_004b: 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_005c: Expected O, but got Unknown
			uiTexture = null;
			try
			{
				byte[] array = Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)ImageConversion.EncodeToPNG(renderedTexture));
				if (array == null || array.Length == 0)
				{
					error = "the generated texture could not be encoded as PNG";
					return false;
				}
				uiTexture = new Texture2D(2, 2, (TextureFormat)4, false)
				{
					name = "S1API_ProductIcon_" + productId,
					filterMode = (FilterMode)1,
					wrapMode = (TextureWrapMode)1
				};
				if (!ImageConversion.LoadImage(uiTexture, Il2CppStructArray<byte>.op_Implicit(array), false))
				{
					Object.Destroy((Object)(object)uiTexture);
					uiTexture = null;
					error = "the generated PNG could not be decoded into a UI texture";
					return false;
				}
				error = string.Empty;
				return true;
			}
			catch (Exception ex)
			{
				if ((Object)(object)uiTexture != (Object)null)
				{
					Object.Destroy((Object)(object)uiTexture);
				}
				uiTexture = null;
				error = "generated icon texture normalization failed: " + ex.Message;
				return false;
			}
			finally
			{
				Object.Destroy((Object)(object)renderedTexture);
			}
		}

		private static void LogGeneratedIconFailure(GeneratedIconRequest request, string reason)
		{
			string text = $"Product presentation context 'Icon' for '{request.Product.ProductId}' could not be applied because {reason}.";
			if (request.Registration.Profile.IsRequired(ProductPresentationContext.Icon))
			{
				MelonLogger.Error("[ProductPresentationProfile] " + text);
			}
			else
			{
				MelonLogger.Warning("[ProductPresentationProfile] " + text + " Preserving the template fallback.");
			}
		}

		private static ProductConsumeAnimation? BuildConsumption(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, List<Object> created, ProductConsumeAnimation? fallback)
		{
			if (profile.ConsumptionPrefabProvider == null)
			{
				return MissingProvider<ProductConsumeAnimation>(product, profile, ProductPresentationContext.Consumption, "no consumption prefab provider was configured", fallback);
			}
			GameObject val;
			try
			{
				val = profile.ConsumptionPrefabProvider();
			}
			catch (Exception ex)
			{
				return ProviderFailed<ProductConsumeAnimation>(product, profile, ProductPresentationContext.Consumption, ex.Message, fallback);
			}
			if ((Object)(object)val == (Object)null)
			{
				return ProviderFailed<ProductConsumeAnimation>(product, profile, ProductPresentationContext.Consumption, "returned null", fallback);
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, GetCacheRoot().transform);
			PrepareCachedPrefab(val2);
			created.Add((Object)(object)val2);
			ProductConsumeAnimation component = val2.GetComponent<ProductConsumeAnimation>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			created.Remove((Object)(object)val2);
			Object.Destroy((Object)(object)val2);
			return RequireOrFallback<ProductConsumeAnimation>(product, profile, ProductPresentationContext.Consumption, "the supplied prefab does not contain ProductConsumeAnimation", fallback);
		}

		private static GameObject? GetVisualSource(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, Dictionary<Func<GameObject?>, GameObject?> sources)
		{
			if (!profile.TryGetVisualProvider(context, out Func<GameObject> provider) || provider == null)
			{
				return MissingProvider<GameObject>(product, profile, context, "no visual provider or loose-visual fallback was configured", null);
			}
			if (sources.TryGetValue(provider, out GameObject value))
			{
				return value ?? ProviderFailed<GameObject>(product, profile, context, "returned null or failed during an earlier context", null);
			}
			try
			{
				GameObject val = provider();
				sources.Add(provider, val);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				return ProviderFailed<GameObject>(product, profile, context, "returned null", null);
			}
			catch (Exception ex)
			{
				sources.Add(provider, null);
				return ProviderFailed<GameObject>(product, profile, context, ex.Message, null);
			}
		}

		private static StaticProductVisualsSetter ReplaceVisual(GameObject scaffold, ProductVisualsSetter? oldSetter, GameObject source, ProductPresentationProfile profile, ProductPresentationContext context)
		{
			Transform parent = (((Object)(object)oldSetter != (Object)null && (Object)(object)oldSetter.VisualsContainer != (Object)null && (Object)(object)oldSetter.VisualsContainer != (Object)(object)scaffold.transform) ? oldSetter.VisualsContainer.parent : scaffold.transform);
			if ((Object)(object)oldSetter != (Object)null && (Object)(object)oldSetter.VisualsContainer != (Object)null && (Object)(object)oldSetter.VisualsContainer != (Object)(object)scaffold.transform)
			{
				((Component)oldSetter.VisualsContainer).gameObject.SetActive(false);
			}
			GameObject val = CreateVisual(source, parent, profile, context);
			StaticProductVisualsSetter staticProductVisualsSetter = scaffold.AddComponent<StaticProductVisualsSetter>();
			((ProductVisualsSetter)staticProductVisualsSetter).VisualsContainer = val.transform;
			return staticProductVisualsSetter;
		}

		private static ProductVisualsSetter ReplaceStationVisual(GameObject scaffold, ProductVisualsSetter? oldSetter, GameObject source, ProductPresentationProfile profile)
		{
			IngredientPiece componentInChildren = scaffold.GetComponentInChildren<IngredientPiece>(true);
			if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.ModelContainer == (Object)null || (Object)(object)oldSetter == (Object)null || (Object)(object)oldSetter.VisualsContainer == (Object)null)
			{
				return (ProductVisualsSetter)(object)ReplaceVisual(scaffold, oldSetter, source, profile, ProductPresentationContext.Station);
			}
			Transform val = (((Object)(object)oldSetter.VisualsContainer != (Object)(object)scaffold.transform) ? oldSetter.VisualsContainer.parent : scaffold.transform);
			GameObject val2 = CreateVisual(source, val ?? scaffold.transform, profile, ProductPresentationContext.Station);
			Transform transform = ((Component)componentInChildren).transform;
			RetireStationModel(componentInChildren.ModelContainer, transform);
			val2.transform.SetParent(transform, true);
			EnsureCollider(val2);
			componentInChildren.ModelContainer = val2.transform;
			StaticStationProductVisualsSetter staticStationProductVisualsSetter = scaffold.AddComponent<StaticStationProductVisualsSetter>();
			((ProductVisualsSetter)staticStationProductVisualsSetter).VisualsContainer = val2.transform;
			((Component)transform).gameObject.SetActive(false);
			return (ProductVisualsSetter)(object)staticStationProductVisualsSetter;
		}

		private static GameObject CreateVisual(GameObject source, Transform parent, ProductPresentationProfile profile, ProductPresentationContext context)
		{
			GameObject val = Object.Instantiate<GameObject>(source);
			val.transform.SetParent(parent, false);
			ApplyVisualTransform(val.transform, profile, context);
			val.SetActive(true);
			return val;
		}

		private static void RetireStationModel(Transform modelContainer, Transform interactionRoot)
		{
			if ((Object)(object)modelContainer != (Object)(object)interactionRoot)
			{
				((Component)modelContainer).gameObject.SetActive(false);
				return;
			}
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(((Component)modelContainer).GetComponentsInChildren<Renderer>(true));
			for (int i = 0; i < array.Length; i++)
			{
				array[i].enabled = false;
			}
			Collider[] array2 = Il2CppArrayBase<Collider>.op_Implicit(((Component)modelContainer).GetComponentsInChildren<Collider>(true));
			for (int j = 0; j < array2.Length; j++)
			{
				array2[j].enabled = false;
			}
		}

		private static AvatarEquippable BuildAvatarEquippable(CustomProductDefinitionRegistration product, AvatarEquippable template, GameObject source, ProductPresentationProfile profile, List<Object> created)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(product.ProductId + " Held Avatar Presentation");
			val.transform.SetParent(GetCacheRoot().transform, false);
			PrepareCachedPrefab(val);
			created.Add((Object)(object)val);
			GameObject val2 = Object.Instantiate<GameObject>(source);
			val2.transform.SetParent(val.transform, false);
			ApplyGeneratedMixColor(val2, product, created);
			if (profile.TryGetAvatarHeldTransform(out ProductPresentationTransform presentationTransform))
			{
				presentationTransform?.ApplyTo(val2.transform);
			}
			AvatarEquippable val3 = val.AddComponent<AvatarEquippable>();
			val3.AlignmentPoint = val.transform;
			if ((Object)(object)template != (Object)null)
			{
				val3.Suspiciousness = template.Suspiciousness;
				val3.Hand = template.Hand;
				val3.TriggerType = template.TriggerType;
				val3.AnimationTrigger = template.AnimationTrigger;
			}
			string text = (val3.AssetPath = "S1API/ProductPresentation/" + product.ProductId + "/Held");
			if (!AvatarEquippableRegistry.RegisterAvatarEquippable(text, val))
			{
				throw new InvalidOperationException("Could not register third-person held presentation path '" + text + "'.");
			}
			return val3;
		}

		private static GameObject ResolveAvatarHeldSource(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, GameObject heldSource, Dictionary<Func<GameObject?>, GameObject?> sources)
		{
			Func<GameObject> avatarHeldVisualProvider = profile.AvatarHeldVisualProvider;
			if (avatarHeldVisualProvider == null)
			{
				return heldSource;
			}
			if (sources.TryGetValue(avatarHeldVisualProvider, out GameObject value))
			{
				return value ?? heldSource;
			}
			GameObject val;
			try
			{
				val = avatarHeldVisualProvider();
			}
			catch (Exception ex)
			{
				sources.Add(avatarHeldVisualProvider, null);
				MelonLogger.Warning("[ProductPresentationProfile] Avatar-held visual provider for '" + product.ProductId + "' failed; using the held visual instead: " + ex.Message);
				return heldSource;
			}
			sources.Add(avatarHeldVisualProvider, val);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			MelonLogger.Warning("[ProductPresentationProfile] Avatar-held visual provider for '" + product.ProductId + "' returned null; using the held visual instead.");
			return heldSource;
		}

		private static void ApplyVisualTransform(Transform target, ProductPresentationProfile profile, ProductPresentationContext context)
		{
			if (profile.TryGetVisualTransform(context, out ProductPresentationTransform presentationTransform))
			{
				presentationTransform?.ApplyTo(target);
			}
		}

		private static void ApplyGeneratedMixColor(GameObject visual, CustomProductDefinitionRegistration product, List<Object> created)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			Color32? val = product.Metadata?.GeneratedMixColor;
			if (!val.HasValue)
			{
				return;
			}
			Color val2 = Color32.op_Implicit(val.Value);
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(visual.GetComponentsInChildren<Renderer>(true));
			foreach (Renderer val3 in array)
			{
				Material[] array2 = Il2CppArrayBase<Material>.op_Implicit((Il2CppArrayBase<Material>)(object)val3.sharedMaterials);
				Material[] array3 = (Material[])(object)new Material[array2.Length];
				for (int j = 0; j < array2.Length; j++)
				{
					Material val4 = array2[j];
					if (!((Object)(object)val4 == (Object)null))
					{
						Material val5 = new Material(val4)
						{
							name = ((Object)val4).name + "_S1API_MixedColor"
						};
						if (val5.HasProperty("_BaseColor"))
						{
							val5.SetColor("_BaseColor", val2);
						}
						if (val5.HasProperty("_Color"))
						{
							val5.SetColor("_Color", val2);
						}
						array3[j] = val5;
						created.Add((Object)(object)val5);
					}
				}
				val3.sharedMaterials = Il2CppReferenceArray<Material>.op_Implicit(array3);
			}
		}

		private static GameObject GetCacheRoot()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_cacheRoot != (Object)null)
			{
				return _cacheRoot;
			}
			GameObject val = new GameObject("S1API_ProductPresentationCache");
			((Object)val).hideFlags = (HideFlags)61;
			val.transform.position = new Vector3(0f, -10000f, 0f);
			Object.DontDestroyOnLoad((Object)(object)val);
			_cacheRoot = val;
			return val;
		}

		private static void PrepareCachedPrefab(GameObject prefab)
		{
			((Object)prefab).hideFlags = (HideFlags)61;
		}

		private static void EnsureCollider(GameObject visual)
		{
			if (!((Object)(object)visual.GetComponentInChildren<Collider>(true) != (Object)null))
			{
				AddBoxCollider(visual);
			}
		}

		private static void AddBoxCollider(GameObject visual)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c3: 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)
			Renderer[] array = Il2CppArrayBase<Renderer>.op_Implicit(visual.GetComponentsInChildren<Renderer>(true));
			if (array.Length == 0)
			{
				return;
			}
			Transform transform = visual.transform;
			Bounds bounds = array[0].bounds;
			Bounds val = default(Bounds);
			((Bounds)(ref val))..ctor(transform.InverseTransformPoint(((Bounds)(ref bounds)).center), Vector3.zero);
			for (int i = 0; i < array.Length; i++)
			{
				Bounds bounds2 = array[i].bounds;
				Vector3 min = ((Bounds)(ref bounds2)).min;
				Vector3 max = ((Bounds)(ref bounds2)).max;
				for (int j = 0; j <= 1; j++)
				{
					for (int k = 0; k <= 1; k++)
					{
						for (int l = 0; l <= 1; l++)
						{
							((Bounds)(ref val)).Encapsulate(visual.transform.InverseTransformPoint(new Vector3((j == 0) ? min.x : max.x, (k == 0) ? min.y : max.y, (l == 0) ? min.z : max.z)));
						}
					}
				}
			}
			BoxCollider val2 = visual.AddComponent<BoxCollider>();
			val2.center = ((Bounds)(ref val)).center;
			val2.size = ((Bounds)(ref val)).size;
		}

		private static void ReplaceWithConvexMeshColliders(GameObject scaffold, GameObject visual)
		{
			Collider[] array = Il2CppArrayBase<Collider>.op_Implicit(scaffold.GetComponentsInChildren<Collider>(true));
			for (int i = 0; i < array.Length; i++)
			{
				array[i].enabled = false;
			}
			MeshFilter[] array2 = Il2CppArrayBase<MeshFilter>.op_Implicit(visual.GetComponentsInChildren<MeshFilter>(true));
			int num = 0;
			foreach (MeshFilter filter in array2)
			{
				if (TryAddConvexMeshCollider(filter))
				{
					num++;
				}
			}
			if (num == 0)
			{
				AddBoxCollider(visual);
			}
		}

		private static bool TryAddConvexMeshCollider(MeshFilter filter)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			Mesh sharedMesh = filter.sharedMesh;
			if (!((Object)(object)sharedMesh == (Object)null))
			{
				Bounds bounds = sharedMesh.bounds;
				Vector3 size = ((Bounds)(ref bounds)).size;
				if (!(((Vector3)(ref size)).sqrMagnitude <= Mathf.Epsilon))
				{
					MeshCollider val = ((Component)filter).gameObject.AddComponent<MeshCollider>();
					try
					{
						val.convex = true;
						val.sharedMesh = sharedMesh;
						if (((Collider)val).enabled && val.convex && (Object)(object)val.sharedMesh != (Object)null)
						{
							if (!((Component)val).gameObject.activeInHierarchy)
							{
								goto IL_00b4;
							}
							bounds = ((Collider)val).bounds;
							size = ((Bounds)(ref bounds)).size;
							if (((Vector3)(ref size)).sqrMagnitude > Mathf.Epsilon)
							{
								goto IL_00b4;
							}
						}
						goto end_IL_004e;
						IL_00b4:
						return true;
						end_IL_004e:;
					}
					catch (Exception ex)
					{
						MelonLogger.Warning($"[ProductPresentationProfile] Could not create a convex mesh collider from '{((Object)sharedMesh).name}': {ex.Message}");
					}
					((Collider)val).enabled = false;
					Object.Destroy((Object)(object)val);
					return false;
				}
			}
			return false;
		}

		private static T MissingScaffold<T>(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, T fallback)
		{
			return RequireOrFallback(product, profile, context, "the representation template does not provide the required native scaffold", fallback);
		}

		private static T InvalidScaffold<T>(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, Component clone, T fallback, List<Object> created, string requiredComponent)
		{
			created.Remove((Object)(object)clone.gameObject);
			Object.Destroy((Object)(object)clone.gameObject);
			return RequireOrFallback(product, profile, context, "the template scaffold does not contain " + requiredComponent, fallback);
		}

		private static T ProviderFailed<T>(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, string reason, T fallback)
		{
			return RequireOrFallback(product, profile, context, "the provider failed: " + reason, fallback);
		}

		private static T MissingProvider<T>(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, string reason, T fallback)
		{
			if (profile.IsRequired(context))
			{
				throw new InvalidOperationException($"Product presentation context '{context}' for '{product.ProductId}' could not be applied because {reason}.");
			}
			return fallback;
		}

		private static T RequireOrFallback<T>(CustomProductDefinitionRegistration product, ProductPresentationProfile profile, ProductPresentationContext context, string reason, T fallback)
		{
			string text = $"Product presentation context '{context}' for '{product.ProductId}' could not be applied because {reason}.";
			if (profile.IsRequired(context))
			{
				throw new InvalidOperationException(text);
			}
			MelonLogger.Warning("[ProductPresentationProfile] " + text + " Preserving the template fallback.");
			return fallback;
		}

		private static void RestoreBaseline(CustomProductDefinitionRegistration product)
		{
			CustomProductPresentationState customProductPresentationState = product.PresentationState ?? throw new InvalidOperationException("Presentation state was not initialized.");
			ProductDefinition definition = product.Definition;
			((BaseItemDefinition)definition).Icon = customProductPresentationState.BaselineIcon;
			((StorableItemDefinition)definition).StoredItem = customProductPresentationState.BaselineStoredItem;
			((ItemDefinition)definition).Equippable = customProductPresentationState.BaselineEquippable;
			((StorableItemDefinition)definition).StationItem = customProductPresentationState.BaselineStationItem;
			definition.FunctionalProduct = customProductPresentationState.BaselineFunctionalProduct;
			definition.ConsumeAnimation = customProductPresentationState.BaselineConsumeAnimation;
			UnregisterHeldAvatar(product, customProductPresentationState);
			DestroyAll(customProductPresentationState.GeneratedObjects);
			customProductPresentationState.GeneratedObjects = new List<Object>();
			customProductPresentationState.RegisteredAvatarPrefab = null;
			customProductPresentationState.AppliedRegistration = null;
			customProductPresentationState.IsGeneratedIconPending = false;
		}

		private static void UnregisterHeldAvatar(CustomProductDefinitionRegistration product, CustomProductPresentationState state)
		{
			if (!((Object)(object)state.RegisteredAvatarPrefab == (Object)null))
			{
				string resourcePath = "S1API/ProductPresentation/" + product.ProductId + "/Held";
				RuntimeResourceRegistry.UnregisterAssetIfMatches(resourcePath, (Object)(object)state.RegisteredAvatarPrefab);
			}
		}

		private static bool GeneratedObjectsAreAlive(IReadOnlyList<Object> objects)
		{
			for (int i = 0; i < objects.Count; i++)
			{
				if (objects[i] == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		private static void DestroyAll(IReadOnlyList<Object> objects)
		{
			for (int i = 0; i < objects.Count; i++)
			{
				if (objects[i] != (Object)null)
				{
					Object.Destroy(objects[i]);
				}
			}
		}
	}
	internal sealed class CustomProductPresentationState
	{
		internal Sprite? BaselineIcon { get; }

		internal StoredItem? BaselineStoredItem { get; }

		internal Equippable? BaselineEquippable { get; }

		internal StationItem? BaselineStationItem { get; }

		internal StationItem? TemplateStationItem { get; }

		internal FunctionalProduct? BaselineFunctionalProduct { get; }

		internal ProductConsumeAnimation? BaselineConsumeAnimation { get; }

		internal ProductPresentationProfileRegistration? AppliedRegistration { get; set; }

		internal bool IsGeneratedIconPending { get; set; }

		internal bool IsGeneratedIconQueued { get; set; }

		internal GameObject? RegisteredAvatarPrefab { get; set; }

		internal List<Object> GeneratedObjects { get; set; } = new List<Object>();

		internal CustomProductPresentationState(ProductDefinition definition, CustomProductDefinitionMetadata? metadata)
		{
			BaselineIcon = ((BaseItemDefinition)definition).Icon;
			BaselineStoredItem = ((StorableItemDefinition)definition).StoredItem;
			BaselineEquippable = ((ItemDefinition)definition).Equippable;
			BaselineStationItem = ((StorableItemDefinition)definition).StationItem;
			BaselineFunctionalProduct = definition.FunctionalProduct;
			BaselineConsumeAnimation = definition.ConsumeAnimation;
			object obj;
			if (metadata == null)
			{
				obj = null;
			}
			else
			{
				ProductDefinition? representationTemplate = metadata.RepresentationTemplate;
				obj = ((representationTemplate != null) ? ((StorableItemDefinition)representationTemplate).StationItem : null);
			}
			TemplateStationItem = (StationItem?)obj;
		}
	}
	[Serializable]
	internal sealed class CustomProductSaveDescriptorData
	{
		public int FormatVersion = 1;

		public string ProductId = string.Empty;

		public string OwnerId = string.Empty;

		public string ProductName = string.Empty;

		public string Description = string.Empty;

		public float InitialPrice;

		public int LegalStatus;

		public float BaseAddictiveness;

		public int DefaultQuality;

		public string ProductKindId = string.Empty;

		public int CompatibilityDrugType;

		public string RepresentationTemplateId = string.Empty;

		public int PlayerEffectDurationSeconds;

		public int NpcEffectDurationSeconds;

		public string[] PropertyIds = Array.Empty<string>();

		public string[] PackagingIds = Array.Empty<string>();

		public string? ProviderId;

		public int ProviderVersion;

		public string ProviderData = string.Empty;

		public bool IsGeneratedMix;

		public bool HasGeneratedMixColor;

		public byte GeneratedMixColorR;

		public byte GeneratedMixColorG;

		public byte GeneratedMixColorB;

		public byte GeneratedMixColorA;
	}
	[Serializable]
	internal sealed class CustomProductSaveFileData
	{
		public int FormatVersion = 1;

		public CustomProductSaveDescriptorData[] Descriptors = Array.Empty<CustomProductSaveDescriptorData>();
	}
	internal static class CustomProductSavePersistence
	{
		internal const string RelativePath = "Modded/CustomProducts.json";

		internal const int CurrentFormatVersion = 1;

		internal const int MaximumDescriptorCount = 256;

		internal const int MaximumStringLength = 4096;

		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ICustomProductSaveProvider> Providers = new Dictionary<string, ICustomProductSaveProvider>(StringComparer.OrdinalIgnoreCase);

		private static string? _restoredSaveFolder;

		internal static ICustomProductSaveProvider RegisterProvider(ICustomProductSaveProvider provider)
		{
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			string text = ProductKindId.Normalize(provider.ProviderId, "ProviderId");
			if (provider.MaximumDescriptorVersion < 1)
			{
				throw new ArgumentOutOfRangeException("MaximumDescriptorVersion");
			}
			lock (Gate)
			{
				if (Providers.TryGetValue(text, out ICustomProductSaveProvider value))
				{
					if (value != provider)
					{
						throw new InvalidOperationException("Custom-product save provider '" + text + "' is already registered.");
					}
					return value;
				}
				Providers.Add(text, provider);
				return provider;
			}
		}

		internal static bool IsProviderAvailable(string? providerId, int descriptorVersion)
		{
			if (string.IsNullOrEmpty(providerId))
			{
				return true;
			}
			lock (Gate)
			{
				ICustomProductSaveProvider value;
				return Providers.TryGetValue(providerId, out value) && descriptorVersion <= value.MaximumDescriptorVersion;
			}
		}

		internal static void Save(string saveFolderPath)
		{
			CustomProductSaveDescriptorData[] saveDescriptors = CustomProductDefinitionRegistry.GetSaveDescriptors();
			string text = Path.Combine(saveFolderPath, "Modded", "CustomProducts.json");
			if (saveDescriptors.Length != 0)
			{
				Directory.CreateDirectory(Path.GetDirectoryName(text));
				string text2 = text + ".tmp";
				File.WriteAllText(text2, JsonConvert.SerializeObject((object)new CustomProductSaveFileData
				{
					Descriptors = saveDescriptors
				}, (Formatting)0));
				if (File.Exists(text))
				{
					File.Replace(text2, text, null);
				}
				else
				{
					File.Move(text2, text);
				}
			}
		}

		internal static void RestoreBeforeBaseLoaders(LoadManager loadManager)
		{
			if ((Object)(object)loadManager == (Object)null || string.IsNullOrEmpty(loadManager.LoadedGameFolderPath))
			{
				return;
			}
			string loadedGameFolderPath = loadManager.LoadedGameFolderPath;
			lock (Gate)
			{
				if (string.Equals(_restoredSaveFolder, loadedGameFolderPath, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
				_restoredSaveFolder = loadedGameFolderPath;
			}
			try
			{
				string path = Path.Combine(loadManager.LoadedGameFolderPath, "Modded", "CustomProducts.json");
				if (!File.Exists(path))
				{
					return;
				}
				CustomProductSaveFileData customProductSaveFileData = JsonConvert.DeserializeObject<CustomProductSaveFileData>(File.ReadAllText(path));
				if (customProductSaveFileData == null || customProductSaveFileData.FormatVersion != 1 || customProductSaveFileData.Descriptors == null || customProductSaveFileData.Descriptors.Length > 256)
				{
					Warn("descriptor file is incompatible or exceeds the supported descriptor count; custom products were skipped");
					return;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				CustomProductSaveDescriptorData[] descriptors = customProductSaveFileData.Descriptors;
				foreach (CustomProductSaveDescriptorData data in descriptors)
				{
					if (!TryValidate(data, out CustomProductSaveDescriptor descriptor) || !hashSet.Add(descriptor.ProductId))
					{
						Warn("ignored an invalid or duplicate custom-product descriptor");
					}
					else
					{
						RestoreOne(descriptor);
					}
				}
			}
			catch (Exception ex)
			{
				Warn("could not read custom-product descriptors; continuing without them: " + ex.Message);
			}
		}

		private static void RestoreOne(CustomProductSaveDescriptor descriptor)
		{
			if (CustomProductDefinitionRegistry.IsRegistered(descriptor.ProductId))
			{
				return;
			}
			if (string.IsNullOrEmpty(descriptor.ProviderId))
			{
				RestoreFallback(descriptor);
				return;
			}
			ICustomProductSaveProvider value;
			lock (Gate)
			{
				Providers.TryGetValue(descriptor.ProviderId, out value);
			}
			if (value == null)
			{
				Warn($"custom product '{descriptor.ProductId}' requires provider '{descriptor.ProviderId}', which is not installed; it was skipped safely");
				RestoreFallback(descriptor);
				return;
			}
			if (descriptor.ProviderVersion > value.MaximumDescriptorVersion)
			{
				Warn($"custom product '{descriptor.ProductId}' needs a newer '{descriptor.ProviderId}' provider; it was skipped safely");
				RestoreFallback(descriptor);
				return;
			}
			try
			{
				CustomProductDefinitionBuilder customProductDefinitionBuilder = value.Restore(descriptor);
				if (customProductDefinitionBuilder != null)
				{
					if (!string.Equals(customProductDefinitionBuilder.ProductId, descriptor.ProductId, StringComparison.OrdinalIgnoreCase))
					{
						throw new InvalidOperationException("provider returned a different product ID; automatic renamed-ID migration is not supported");
					}
					customProductDefinitionBuilder.Build();
				}
				else
				{
					RestoreFallback(descriptor);
				}
			}
			catch (Exception ex)
			{
				Warn($"custom product '{descriptor.ProductId}' could not be reconstructed by '{descriptor.ProviderId}'; it was skipped safely: {ex.Message}");
				RestoreFallback(descriptor);
			}
		}

		private static void RestoreFallback(CustomProductSaveDescriptor descriptor)
		{
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CustomProductSaveDescriptorData customProductSaveDescriptorData = descriptor.Data ?? throw new InvalidOperationException("descriptor has no internal scalar data");
				ItemDefinition item = Registry.GetItem(customProductSaveDescriptorData.RepresentationTemplateId);
				ProductDefinition val = (ProductDefinition)(object)((item is ProductDefinition) ? item : null);
				if ((Object)(object)val == (Object)null)
				{
					throw new InvalidOperationException("the saved vanilla representation template is unavailable");
				}
				ProductKind productKind = ProductKindRegistry.Get(customProductSaveDescriptorData.ProductKindId) ?? ProductKindRegistry.Register(new ProductKind(customProductSaveDescriptorData.ProductKindId, null));
				List<Effect> properties = PropertyResolver.ResolveToGamePropertiesById(customProductSaveDescriptorData.PropertyIds ?? Array.Empty<string>());
				List<PackagingDefinition> list = new List<PackagingDefinition>();
				string[] array = customProductSaveDescriptorData.PackagingIds ?? Array.Empty<string>();
				foreach (string text in array)
				{
					ItemDefinition item2 = Registry.GetItem(text);
					PackagingDefinition val2 = (PackagingDefinition)(object)((item2 is PackagingDefinition) ? item2 : null);
					if ((Object)(object)val2 == (Object)null)
					{
						Warn("saved packaging '" + text + "' is unavailable; restoring the product without that packaging");
					}
					else
					{
						list.Add(val2);
					}
				}
				ProductDefinition definition = CustomProductDefinitionFactory.Create(customProductSaveDescriptorData.ProductId, customProductSaveDescriptorData.ProductName, customProductSaveDescriptorData.Description, customProductSaveDescriptorData.InitialPrice, (LegalStatus)customProductSaveDescriptorData.LegalStatus, customProductSaveDescriptorData.BaseAddictiveness, customProductSaveDescriptorData.PlayerEffectDurationSeconds, customProductSaveDescriptorData.NpcEffectDurationSeconds, (DrugType)customProductSaveDescriptorData.CompatibilityDrugType, properties, list, val);
				List<PackagingDefinition> list2 = new List<PackagingDefinition>();
				foreach (PackagingDefinition item3 in list)
				{
					list2.Add(new PackagingDefinition((ItemDefinition)(object)item3));
				}
				Color32? generatedMixColor = (customProductSaveDescriptorData.HasGeneratedMixColor ? new Color32?(new Color32(customProductSaveDescriptorData.GeneratedMixColorR, customProductSaveDescriptorData.GeneratedMixColorG, customProductSaveDescriptorData.GeneratedMixColorB, customProductSaveDescriptorData.GeneratedMixColorA)) : ((Color32?)null));
				CustomProductDefinitionMetadata metadata = new CustomProductDefinitionMetadata(productKind, (Quality)customProductSaveDescriptorData.DefaultQuality, list2, val, generatedMixColor);
				try
				{
					CustomProductDefinitionRegistry.Register(customProductSaveDescriptorData.OwnerId, customProductSaveDescriptorData.ProductId, customProductSaveDescriptorData.ProductName, customProductSaveDescriptorData.InitialPrice, definition, metadata, customProductSaveDescriptorData);
					Warn($"custom product '{customProductSaveDescriptorData.ProductId}' used S1API's asset-free fallback; reinstall '{descriptor.ProviderId ?? customProductSaveDescriptorData.OwnerId}' to restore provider presentation and content");
				}
				catch
				{
					CustomProductDefinitionFactory.Destroy(definition);
					throw;
				}
			}
			catch (Exception ex)
			{
				Warn("custom product '" + descriptor.ProductId + "' fallback was unavailable; load continues safely: " + ex.Message);
			}
		}

		private static bool TryValidate(CustomProductSaveDescriptorData? data, out CustomProductSaveDescriptor descriptor)
		{
			descriptor = null;
			if (data == null || data.FormatVersion != 1 || data.ProviderVersion < 0 || !IsBounded(data.ProductId) || !IsBounded(data.OwnerId) || !IsBounded(data.ProviderData) || (data.ProviderId != null && !IsBounded(data.ProviderId)))
			{
				return false;
			}
			try
			{
				string productId = ProductKindId.Normalize(data.ProductId, "ProductId");
				string ownerId = data.OwnerId.Trim();
				string providerId = ((data.ProviderId == null) ? null : ProductKindId.Normalize(data.ProviderId, "ProviderId"));
				if (!IsBounded(data.ProductName) || !IsBounded(data.Description) || !IsBounded(data.ProductKindId) || !IsBounded(data.RepresentationTemplateId) || !float.IsFinite(data.InitialPrice) || !float.IsFinite(data.BaseAddictiveness) || data.InitialPrice < 1f || data.BaseAddictiveness < 0f || data.BaseAddictiveness > 1f || data.PlayerEffectDurationSeconds < 0 || data.NpcEffectDurationSeconds < 0 || !Enum.IsDefined(typeof(LegalStatus), data.LegalStatus) || !Enum.IsDefined(typeof(Quality), data.DefaultQuality) || !Enum.IsDefined(typeof(DrugType), data.CompatibilityDrugType) || !IsBoundedCollection(data.PropertyIds) || !IsBoundedCollection(data.PackagingIds))
				{
					return false;
				}
				string productKindId = ProductKindId.Normalize(data.ProductKindId, "ProductKindId");
				if (string.IsNullOrWhiteSpace(data.RepresentationTemplateId))
				{
					return false;
				}
				descriptor = new CustomProductSaveDescriptor(data.FormatVersion, productId, ownerId, data.ProductName, data.Description, data.InitialPrice, productKindId, providerId, data.ProviderVersion, data.ProviderData)
				{
					Data = data
				};
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsBounded(string? value)
		{
			return value != null && value.Length <= 4096;
		}

		private static bool IsBoundedCollection(string[]? values)
		{
			if (values == null || values.Length > 32)
			{
				return false;
			}
			foreach (string value in values)
			{
				if (!IsBounded(value))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool TryRestoreGeneratedDescriptorFromNetwork(CustomProductSaveDescriptorData data)
		{
			if (!data.IsGeneratedMix || !string.IsNullOrEmpty(data.ProviderId) || data.ProviderVersion != 0 || !string.IsNullOrEmpty(data.ProviderData) || !TryValidate(data, out CustomProductSaveDescriptor descriptor))
			{
				return false;
			}
			if (!CustomProductDefinitionRegistry.IsRegistered(descriptor.ProductId))
			{
				RestoreFallback(descriptor);
			}
			return CustomProductDefinitionRegistry.IsRegistered(descriptor.ProductId);
		}

		internal static bool IsNetworkGeneratedDescriptorValid(CustomProductSaveDescriptorData data)
		{
			CustomProductSaveDescriptor descriptor;
			return data != null && data.IsGeneratedMix && string.IsNullOrEmpty(data.ProviderId) && data.ProviderVersion == 0 && string.IsNullOrEmpty(data.ProviderData) && TryValidate(data, out descriptor);
		}

		private static void Warn(string message)
		{
			try
			{
				MelonLogger.Warning("[CustomProductSave] " + message);
			}
			catch
			{
			}
		}
	}
	internal interface ICustomProductPresentationRuntime
	{
		void Apply(CustomProductDefinitionRegistration product, ProductPresentationProfileRegistration? profile);
	}
	internal interface IProductKindMetadataRuntimeAdapter
	{
		void Apply(IReadOnlyList<ProductKindMetadata> metadata);
	}
	internal static class ProductConsumptionProfileDispatcher
	{
		private sealed class ActiveProfile
		{
			internal ProductConsumptionProfile Profile { get; }

			internal ProductConsumptionContext Context { get; }

			internal bool IsPlayer { get; }

			internal bool IsActive { get; set; } = true;

			internal ActiveProfile(ProductConsumptionProfile profile, ProductConsumptionContext context, bool isPlayer)
			{
				Profile = profile;
				Context = context;
				IsPlayer = isPlayer;
			}
		}

		private static readonly Log Logger = new Log("ProductConsumptionProfileDispatcher");

		private static readonly object Gate = new object();

		private static ConditionalWeakTable<object, ActiveProfile> ActiveProfiles = new ConditionalWeakTable<object, ActiveProfile>();

		private static readonly List<WeakReference<ActiveProfile>> ActiveProfileReferences = new List<WeakReference<ActiveProfile>>();

		private static bool _lifecycleHooksRegistered;

		internal static void DispatchPlayer(ProductItemInstance productInstance, object nativePlayer, Player player, bool isClear, ProductConsumptionContext? resolvedContext = null, ProductConsumptionProfileRegistration? resolvedRegistration = null)
		{
			Dispatch(productInstance, nativePlayer, player, null, GetPlayerTargetId(player.S1Player), isClear, resolvedContext, resolvedRegistration);
		}

		internal static void DispatchNpc(ProductItemInstance productInstance, object nativeNpc, NPC? npc, string targetId, bool isClear, ProductConsumptionContext? resolvedContext = null, ProductConsumptionProfileRegistration? resolvedRegistration = null)
		{
			Dispatch(productInstance, nativeNpc, null, npc, targetId, isClear, resolvedContext, resolvedRegistration);
		}

		internal static void ResetForTesting()
		{
			ResetActiveProfiles();
		}

		internal static string GetPlayerTargetIdForTesting(string playerCode)
		{
			return GetPlayerTargetId(playerCode);
		}

		internal static void DispatchForTesting(object nativeTarget, ProductConsumptionProfile profile, ProductConsumptionContext context, bool isPlayer, bool isClear, bool isLocalPlayer = true)
		{
			if (!isPlayer || isLocalPlayer)
			{
				if (isClear)
				{
					Clear(nativeTarget, context, isPlayer);
				}
				else
				{
					ApplyResolved(nativeTarget, profile, context, isPlayer);
				}
			}
		}

		internal static bool TryResolveRegisteredContext(ProductItemInstance productInstance, Player? player, NPC? npc, string targetId, out ProductConsumptionContext? context, out ProductConsumptionProfileRegistration? registration)
		{
			registration = null;
			if (!TryCreateContext(productInstance, player, npc, targetId, out context) || context == null)
			{
				return false;
			}
			return ProductConsumptionProfileRegistrationRegistry.TryResolve(context.ProductId, context.ProductKind.Id, out registration);
		}

		private static void Dispatch(ProductItemInstance productInstance, object nativeTarget, Player? player, NPC? npc, string targetId, bool isClear, ProductConsumptionContext? resolvedContext, ProductConsumptionProfileRegistration? resolvedRegistration)
		{
			if (productInstance == null || nativeTarget == null)
			{
				return;
			}
			ProductConsumptionContext context = resolvedContext;
			if ((context != null || TryCreateContext(productInstance, player, npc, targetId, out context)) && context != null)
			{
				if (isClear)
				{
					Clear(nativeTarget, context, player != null);
				}
				else
				{
					Apply(nativeTarget, context, player != null, resolvedRegistration);
				}
			}
		}

		private static bool TryCreateContext(ProductItemInstance productInstance, Player? player, NPC? npc, string targetId, out ProductConsumptionContext? context)
		{
			context = null;
			try
			{
				ProductInstance productInstance2 = new ProductInstance(productInstance);
				if (!(productInstance2.Definition is CustomProductDefinition definition))
				{
					return false;
				}
				context = new ProductConsumptionContext(productInstance2, definition, player, npc, targetId ?? string.Empty);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Could not resolve a custom product consumption context: " + ex.GetType().Name);
				return false;
			}
		}

		private static void Apply(object nativeTarget, ProductConsumptionContext context, bool isPlayer, ProductConsumptionProfileRegistration? resolvedRegistration)
		{
			ProductConsumptionProfileRegistration registration = resolvedRegistration;
			if ((registration != null || ProductConsumptionProfileRegistrationRegistry.TryResolve(context.ProductId, context.ProductKind.Id, out registration)) && registration != null)
			{
				ApplyResolved(nativeTarget, registration.Profile, context, isPlayer);
			}
		}

		private static void ApplyResolved(object nativeTarget, ProductConsumptionProfile profile, ProductConsumptionContext context, bool isPlayer)
		{
			EnsureLifecycleHooks();
			ActiveProfile activeProfile = new ActiveProfile(profile, context, isPlayer);
			ActiveProfile value;
			lock (Gate)
			{
				if (ActiveProfiles.TryGetValue(nativeTarget, out value) && string.Equals(value.Context.ProductId, context.ProductId, StringComparison.OrdinalIgnoreCase) && value.Profile == profile)
				{
					return;
				}
				if (value != null)
				{
					value.IsActive = false;
					ActiveProfiles.Remove(nativeTarget);
				}
				ActiveProfiles.Add(nativeTarget, activeProfile);
				ActiveProfileReferences.Add(new WeakReference<ActiveProfile>(activeProfile));
			}
			if (value != null)
			{
				InvokeClear(value.Profile, value.Context, value.IsPlayer);
			}
			if (!InvokeApply(profile, context, isPlayer))
			{
				RemoveActiveProfile(nativeTarget, activeProfile);
				InvokeClear(profile, context, isPlayer);
			}
		}

		private static void Clear(object nativeTarget, ProductConsumptionContext context, bool isPlayer)
		{
			ActiveProfile value;
			lock (Gate)
			{
				if (!ActiveProfiles.TryGetValue(nativeTarget, out value) || !string.Equals(value.Context.ProductId, context.ProductId, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
				ActiveProfiles.Remove(nativeTarget);
				value.IsActive = false;
			}
			InvokeClear(value.Profile, value.Context, value.IsPlayer);
		}

		private static bool InvokeApply(ProductConsumptionProfile profile, ProductConsumptionContext context, bool isPlayer)
		{
			Action<ProductConsumptionContext> callback = (isPlayer ? profile.OnPlayerApply : profile.OnNpcApply);
			return Invoke(callback, profile, context, isPlayer ? "player apply" : "NPC apply");
		}

		private static bool InvokeClear(ProductConsumptionProfile profile, ProductConsumptionContext context, bool isPlayer)
		{
			Action<ProductConsumptionContext> callback = (isPlayer ? profile.OnPlayerClear : profile.OnNpcClear);
			return Invoke(callback, profile, context, isPlayer ? "player clear" : "NPC clear");
		}

		private static bool Invoke(Action<ProductConsumptionContext>? callback, ProductConsumptionProfile profile, ProductConsumptionContext context, string lifecycle)
		{
			if (callback == null)
			{
				return true;
			}
			try
			{
				callback(context);
				return true;
			}
			catch (Exception ex)
			{
				try
				{
					Logger.Error("Consumption profile '" + profile.ProviderId + "' " + lifecycle + " callback failed for product '" + context.ProductId + "': " + ex.GetType().Name);
				}
				catch
				{
				}
				return false;
			}
		}

		private static string GetPlayerTargetId(Player player)
		{
			return GetPlayerTargetId((player != null) ? player.PlayerCode : null);
		}

		private static string GetPlayerTargetId(string? playerCode)
		{
			return playerCode ?? string.Empty;
		}

		private static void EnsureLifecycleHooks()
		{
			lock (Gate)
			{
				if (!_lifecycleHooksRegistered)
				{
					GameLifecycle.OnPreLoad += ResetActiveProfiles;
					GameLifecycle.OnPreSceneChange += ResetActiveProfiles;
					Player.PlayerDespawned += OnPlayerDespawned;
					_lifecycleHooksRegistered = true;
				}
			}
		}

		private static void OnPlayerDespawned(Player player)
		{
			if (player != null)
			{
				RemoveActiveProfile(player.S1Player);
			}
		}

		private static void RemoveActiveProfile(object nativeTarget, ActiveProfile expected)
		{
			lock (Gate)
			{
				if (ActiveProfiles.TryGetValue(nativeTarget, out ActiveProfile value) && value == expected)
				{
					value.IsActive = false;
					ActiveProfiles.Remove(nativeTarget);
				}
			}
		}

		private static void RemoveActiveProfile(object nativeTarget)
		{
			ActiveProfile value;
			lock (Gate)
			{
				if (!ActiveProfiles.TryGetValue(nativeTarget, out value))
				{
					return;
				}
				value.IsActive = false;
				ActiveProfiles.Remove(nativeTarget);
			}
			InvokeClear(value.Profile, value.Context, value.IsPlayer);
		}

		private static void ResetActiveProfiles()
		{
			List<ActiveProfile> list = new List<ActiveProfile>();
			lock (Gate)
			{
				for (int num = ActiveProfileReferences.Count - 1; num >= 0; num--)
				{
					if (!ActiveProfileReferences[num].TryGetTarget(out ActiveProfile target))
					{
						ActiveProfileReferences.RemoveAt(num);
					}
					else if (target.IsActive)
					{
						target.IsActive = false;
						list.Add(target);
					}
				}
				ActiveProfiles = new ConditionalWeakTable<object, ActiveProfile>();
				ActiveProfileReferences.Clear();
			}
			foreach (ActiveProfile item in list)
			{
				InvokeClear(item.Profile, item.Context, item.IsPlayer);
			}
		}
	}
	internal sealed class ProductConsumptionProfileRegistration
	{
		internal string Key { get; }

		internal ProductConsumptionProfile Profile { get; }

		internal ProductConsumptionProfileRegistration(string key, ProductConsumptionProfile profile)
		{
			Key = key;
			Profile = profile;
		}
	}
	internal static class ProductConsumptionProfileRegistrationRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ProductConsumptionProfileRegistration> ProductProfiles = new Dictionary<string, ProductConsumptionProfileRegistration>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, ProductConsumptionProfileRegistration> KindProfiles = new Dictionary<string, ProductConsumptionProfileRegistration>(StringComparer.OrdinalIgnoreCase);

		internal static ProductConsumptionProfile RegisterForProduct(string productId, ProductConsumptionProfile profile)
		{
			return Register(ProductProfiles, "product ID", ProductKindId.Normalize(productId, "productId"), profile);
		}

		internal static ProductConsumptionProfile RegisterForProductKind(ProductKind productKind, ProductConsumptionProfile profile)
		{
			if (productKind == null)
			{
				throw new ArgumentNullException("productKind");
			}
			return Register(KindProfiles, "product-kind ID", productKind.Id, profile);
		}

		internal static bool TryResolve(string productId, string productKindId, out ProductConsumptionProfileRegistration? registration)
		{
			lock (Gate)
			{
				if (ProductProfiles.TryGetValue(productId, out registration))
				{
					return true;
				}
				return KindProfiles.TryGetValue(productKindId, out registration);
			}
		}

		internal static bool TryGetManifestIdentity(string productId, string productKindId, out string providerId, out int providerVersion)
		{
			if (TryResolve(productId, productKindId, out ProductConsumptionProfileRegistration registration) && registration != null)
			{
				providerId = registration.Profile.ProviderId;
				providerVersion = registration.Profile.ProviderVersion;
				return true;
			}
			providerId = string.Empty;
			providerVersion = 0;
			return false;
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				ProductProfiles.Clear();
				KindProfiles.Clear();
			}
		}

		private static ProductConsumptionProfile Register(Dictionary<string, ProductConsumptionProfileRegistration> registrations, string keyDescription, string key, ProductConsumptionProfile profile)
		{
			if (profile == null)
			{
				throw new ArgumentNullException("profile");
			}
			ProductConsumptionProfileRegistration productConsumptionProfileRegistration;
			lock (Gate)
			{
				if (registrations.TryGetValue(key, out ProductConsumptionProfileRegistration value))
				{
					if (value.Profile == profile)
					{
						return value.Profile;
					}
					throw new InvalidOperationException("Consumption profile " + keyDescription + " '" + key + "' is already registered by provider '" + value.Profile.ProviderId + "'. Reuse the existing profile or choose another stable key.");
				}
				productConsumptionProfileRegistration = new ProductConsumptionProfileRegistration(key, profile);
				registrations.Add(key, productConsumptionProfileRegistration);
			}
			CustomProductManifestRuntime.RefreshHostManifestIfReady();
			return productConsumptionProfileRegistration.Profile;
		}
	}
	internal static class ProductIconRenderRigArbiter
	{
		internal sealed class CaptureLease
		{
			internal bool Cancelled { get; set; }
		}

		private static readonly object Gate = new object();

		private static readonly Queue<CaptureLease> Pending = new Queue<CaptureLease>();

		private static CaptureLease? _owner;

		internal static CaptureLease Enqueue()
		{
			lock (Gate)
			{
				CaptureLease captureLease = new CaptureLease();
				Pending.Enqueue(captureLease);
				return captureLease;
			}
		}

		internal static bool TryAcquire(CaptureLease lease)
		{
			lock (Gate)
			{
				if (lease.Cancelled)
				{
					return false;
				}
				if (_owner == lease)
				{
					return true;
				}
				if (_owner != null)
				{
					return false;
				}
				RemoveCancelledHead();
				if (Pending.Count == 0 || Pending.Peek() != lease)
				{
					return false;
				}
				_owner = Pending.Dequeue();
				return true;
			}
		}

		internal static void Release(CaptureLease lease)
		{
			lock (Gate)
			{
				if (_owner == lease)
				{
					_owner = null;
				}
				else
				{
					lease.Cancelled = true;
				}
				RemoveCancelledHead();
			}
		}

		internal static void Cancel(CaptureLease lease)
		{
			lock (Gate)
			{
				lease.Cancelled = true;
				if (_owner == lease)
				{
					_owner = null;
				}
				RemoveCancelledHead();
			}
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				Pending.Clear();
				_owner = null;
			}
		}

		private static void RemoveCancelledHead()
		{
			while (Pending.Count != 0 && Pending.Peek().Cancelled)
			{
				Pending.Dequeue();
			}
		}
	}
	internal static class ProductKindIconLifetime
	{
		private static Func<Sprite, bool> _unityNullEvaluator = IsUnityNull;

		internal static bool IsNullOrDestroyed(Sprite? icon)
		{
			if (icon == null)
			{
				return true;
			}
			return _unityNullEvaluator(icon);
		}

		internal static void SetUnityNullEvaluatorForTesting(Func<Sprite, bool>? evaluator)
		{
			_unityNullEvaluator = evaluator ?? new Func<Sprite, bool>(IsUnityNull);
		}

		private static bool IsUnityNull(Sprite icon)
		{
			return (Object)(object)icon == (Object)null;
		}
	}
	internal static class ProductKindId
	{
		internal static string Normalize(string id, string parameterName)
		{
			if (id == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			string text = id.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Product-kind IDs cannot be empty or whitespace.", parameterName);
			}
			int num = text.IndexOf(':');
			if (num <= 0 || num == text.Length - 1 || num != text.LastIndexOf(':'))
			{
				throw new ArgumentException("Product-kind IDs must use '<namespace>:<name>' with exactly one colon and non-empty parts.", parameterName);
			}
			string value = text.Substring(0, num);
			string value2 = text.Substring(num + 1);
			ValidatePart(value, allowSlash: false, "namespace", parameterName);
			ValidatePart(value2, allowSlash: true, "name", parameterName);
			return text;
		}

		private static void ValidatePart(string value, bool allowSlash, string partName, string parameterName)
		{
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsAsciiLetterOrDigit(c))
				{
					flag = true;
				}
				else if (c != '.' && c != '_' && c != '-' && (!allowSlash || c != '/'))
				{
					throw new ArgumentException($"Product-kind ID {partName} contains invalid character '{c}' at position {i}. " + "Use ASCII letters, digits, '.', '_', '-'" + (allowSlash ? ", or '/'." : "."), parameterName);
				}
			}
			if (!flag)
			{
				throw new ArgumentException("Product-kind ID " + partName + " must contain at least one ASCII letter or digit.", parameterName);
			}
		}

		private static bool IsAsciiLetterOrDigit(char character)
		{
			return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9');
		}
	}
	internal static class ProductKindMetadataRegistrationRegistry
	{
		private static readonly object Gate = new object();

		private static readonly object ApplyGate = new object();

		private static readonly Dictionary<string, ProductKindMetadata> Metadata = new Dictionary<string, ProductKindMetadata>(StringComparer.OrdinalIgnoreCase);

		private static IProductKindMetadataRuntimeAdapter _runtimeAdapter = ProductKindMetadataRuntimeAdapter.Instance;

		private static bool _hooked;

		internal static IReadOnlyCollection<ProductKindMetadata> All
		{
			get
			{
				ProductKindMetadata[] array = OrderedSnapshot();
				return Array.AsReadOnly(array);
			}
		}

		internal static bool TryGet(string productKindId, out ProductKindMetadata? metadata)
		{
			string key = ProductKindId.Normalize(productKindId, "productKindId");
			lock (Gate)
			{
				return Metadata.TryGetValue(key, out metadata);
			}
		}

		internal static ProductKindMetadata Register(ProductKindMetadata metadata)
		{
			if (metadata == null)
			{
				throw new ArgumentNullException("metadata");
			}
			ProductKindMetadata result;
			lock (Gate)
			{
				if (Metadata.TryGetValue(metadata.ProductKind.Id, out ProductKindMetadata value))
				{
					if (!value.IsEquivalentTo(metadata))
					{
						throw CreateConflict(value, metadata);
					}
					result = value;
				}
				else
				{
					ValidateNativeMetadataCollision(metadata);
					Metadata.Add(metadata.ProductKind.Id, metadata);
					result = metadata;
				}
				EnsureHooked();
			}
			ApplyAll("registration");
			return result;
		}

		internal static void ApplyAll(string phase)
		{
			lock (ApplyGate)
			{
				try
				{
					_runtimeAdapter.Apply(OrderedSnapshot());
				}
				catch (Exception value)
				{
					try
					{
						MelonLogger.Error("[ProductKindMetadataRegistry] Failed to apply product-kind metadata " + $"during {phase}: {value}");
					}
					catch (Exception)
					{
					}
				}
			}
		}

		internal static void ResetForTesting(IProductKindMetadataRuntimeAdapter runtimeAdapter)
		{
			if (runtimeAdapter == null)
			{
				throw new ArgumentNullException("runtimeAdapter");
			}
			lock (ApplyGate)
			{
				lock (Gate)
				{
					if (_hooked)
					{
						GameLifecycle.OnPreLoad -= OnPreLoad;
						GameLifecycle.OnLoadComplete -= OnLoadComplete;
					}
					Metadata.Clear();
					_runtimeAdapter = runtimeAdapter;
					_hooked = false;
				}
			}
		}

		internal static void RestoreRuntimeAdapterForTesting()
		{
			ResetForTesting(ProductKindMetadataRuntimeAdapter.Instance);
		}

		internal static void InvokePreLoadForTesting()
		{
			OnPreLoad();
		}

		internal static void InvokeLoadCompleteForTesting()
		{
			OnLoadComplete();
		}

		private static ProductKindMetadata[] Snapshot()
		{
			lock (Gate)
			{
				ProductKindMetadata[] array = new ProductKindMetadata[Metadata.Count];
				Metadata.Values.CopyTo(array, 0);
				return array;
			}
		}

		private static ProductKindMetadata[] OrderedSnapshot()
		{
			ProductKindMetadata[] array = Snapshot();
			Array.Sort(array, Compare);
			return array;
		}

		private static void EnsureHooked()
		{
			if (!_hooked)
			{
				GameLifecycle.OnPreLoad += OnPreLoad;
				GameLifecycle.OnLoadComplete += OnLoadComplete;
				_hooked = true;
			}
		}

		private static void OnPreLoad()
		{
			ApplyAll("pre-load");
		}

		private static void OnLoadComplete()
		{
			ApplyAll("load-complete");
		}

		private static int Compare(ProductKindMetadata left, ProductKindMetadata right)
		{
			int num = left.SortOrder.CompareTo(right.SortOrder);
			if (num != 0)
			{
				return num;
			}
			num = StringComparer.OrdinalIgnoreCase.Compare(left.DisplayName, right.DisplayName);
			return (num != 0) ? num : StringComparer.OrdinalIgnoreCase.Compare(left.ProductKind.Id, right.ProductKind.Id);
		}

		private static void ValidateNativeMetadataCollision(ProductKindMetadata candidate)
		{
			DrugType? compatibilityDrugType = candidate.ProductKind.CompatibilityDrugType;
			if (!compatibilityDrugType.HasValue || !ProductKindNativeMetadataTypes.RequiresFallback(compatibilityDrugType.Value))
			{
				return;
			}
			foreach (ProductKindMetadata value in Metadata.Values)
			{
				if (value.ProductKind.CompatibilityDrugType != compatibilityDrugType || (string.Equals(value.DisplayName, candidate.DisplayName, StringComparison.Ordinal) && value.HasSameColor(candidate)))
				{
					continue;
				}
				throw new InvalidOperationException($"Product kind '{candidate.ProductKind.Id}' conflicts with '{value.ProductKind.Id}' for native compatibility drug type '{compatibilityDrugType}'. Shared native types must use the same display " + "name and color so native-facing metadata remains deterministic.");
			}
		}

		private static InvalidOperationException CreateConflict(ProductKindMetadata existing, ProductKindMetadata requested)
		{
			return new InvalidOperationException($"Product-kind metadata for '{requested.ProductKind.Id}' is already registered as '{existing.DisplayName}' with different presentation " + "or Product Manager behavior. Product-kind IDs are case-insensitive.");
		}
	}
	internal sealed class ProductKindMetadataRuntimeAdapter : IProductKindMetadataRuntimeAdapter
	{
		internal static readonly ProductKindMetadataRuntimeAdapter Instance = new ProductKindMetadataRuntimeAdapter();

		private ProductKindMetadataRuntimeAdapter()
		{
		}

		public void Apply(IReadOnlyList<ProductKindMetadata> metadata)
		{
			ProductKindNativeMetadataRuntime.Apply(metadata);
			ProductManagerUiRuntime.ApplyCurrent(metadata);
		}
	}
	internal static class ProductKindNativeMetadataRuntime
	{
		internal static void Apply(IReadOnlyList<ProductKindMetadata> metadata)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			PropertyUtility instance = Singleton<PropertyUtility>.Instance;
			if ((Object)(object)instance == (Object)null || instance.DrugTypeDatas == null)
			{
				return;
			}
			for (int i = 0; i < metadata.Count; i++)
			{
				ProductKindMetadata productKindMetadata = metadata[i];
				if (!productKindMetadata.ProductKind.CompatibilityDrugType.HasValue)
				{
					continue;
				}
				DrugType value = productKindMetadata.ProductKind.CompatibilityDrugType.Value;
				if (ProductKindNativeMetadataTypes.RequiresFallback(value))
				{
					EDrugType drugType = value.ToInternal();
					if (!Contains(instance, drugType))
					{
						instance.DrugTypeDatas.Add(new DrugTypeData
						{
							DrugType = drugType,
							Name = productKindMetadata.DisplayName,
							Color = productKindMetadata.Color
						});
					}
				}
			}
		}

		private static bool Contains(PropertyUtility utility, EDrugType drugType)
		{
			//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)
			for (int i = 0; i < utility.DrugTypeDatas.Count; i++)
			{
				DrugTypeData val = utility.DrugTypeDatas[i];
				if (val != null && val.DrugType == drugType)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class ProductKindNativeMetadataTypes
	{
		internal static bool RequiresFallback(DrugType drugType)
		{
			return drugType == DrugType.MDMA || drugType == DrugType.Heroin;
		}
	}
	internal static class ProductManagerUiRuntime
	{
		internal readonly struct SectionIconState
		{
			internal Sprite? Sprite { get; }

			internal Color Tint { get; }

			internal SectionIconState(Sprite? sprite, Color tint)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				Sprite = sprite;
				Tint = tint;
			}
		}

		private const string ManagedNamePrefix = "S1API_ProductKind_";

		private static readonly Log Logger = new Log("ProductManagerUiRuntime");

		internal static void ApplyCurrent(IReadOnlyList<ProductKindMetadata> metadata)
		{
			ProductManagerApp instance = PlayerSingleton<ProductManagerApp>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				Apply(instance, metadata);
			}
		}

		internal static void Apply(ProductManagerApp app, IReadOnlyList<ProductKindMetadata> metadata)
		{
			if (!((Object)(object)app == (Object)null) && app.ProductTypeContainers != null)
			{
				EnsureContainers(app, metadata);
				ReconcileEntries(app);
			}
		}

		internal static bool BeforeCreateEntry(ProductManagerApp app, ProductDefinition definition)
		{
			if (!TryResolveMetadata(definition, out ProductKindMetadata metadata))
			{
				return true;
			}
			if (!metadata.IsVisibleInProductManager)
			{
				return false;
			}
			bool hasContainer = (Object)(object)FindManagedContainer(app, metadata.ProductKind.Id) != (Object)null;
			if (!RequiresContainerReconciliation(metadata.IsVisibleInProductManager, hasContainer))
			{
				return true;
			}
			EnsureContainers(app, SnapshotMetadata());
			if ((Object)(object)FindManagedContainer(app, metadata.ProductKind.Id) != (Object)null)
			{
				return true;
			}
			Logger.Error($"Skipped Product Manager entry '{((BaseItemDefinition)definition).ID}' because the section for product kind '{metadata.ProductKind.Id}' could not be created.");
			return false;
		}

		internal static void AfterCreateEntry(ProductManagerApp app, ProductDefinition definition)
		{
			if (TryResolveMetadata(definition, out ProductKindMetadata metadata) && metadata.IsVisibleInProductManager)
			{
				RouteEntry(app, definition, metadata);
			}
		}

		internal static bool AllowFavouriteEntry(ProductDefinition definition)
		{
			ProductKindMetadata metadata;
			return !TryResolveMetadata(definition, out metadata) || metadata.IsVisibleInProductManager;
		}

		internal static bool AllowFavouriteRemoval()
		{
			return true;
		}

		internal static bool RequiresContainerReconciliation(bool isVisible, bool hasContainer)
		{
			return isVisible && !hasContainer;
		}

		internal static bool ShouldPurgeFavouriteEntry(bool hasEntry, bool hasDefinition)
		{
			return !hasEntry || !hasDefinition;
		}

		internal static SectionIconState CreateSectionIconState(Sprite? sprite)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Sprite sprite2 = (ProductKindIconLifetime.IsNullOrDestroyed(sprite) ? null : sprite);
			return new SectionIconState(sprite2, new Color
			{
				r = 1f,
				g = 1f,
				b = 1f,
				a = 1f
			});
		}

		private static IReadOnlyList<ProductKindMetadata> SnapshotMetadata()
		{
			List<ProductKindMetadata> list = new List<ProductKindMetadata>(ProductKindMetadataRegistry.All);
			return list.AsReadOnly();
		}

		private static void EnsureContainers(ProductManagerApp app, IReadOnlyList<ProductKindMetadata> metadata)
		{
			List<ProductKindMetadata> list = new List<ProductKindMetadata>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < metadata.Count; i++)
			{
				ProductKindMetadata productKindMetadata = metadata[i];
				if (productKindMetadata.IsVisibleInProductManager && productKindMetadata.ProductKind.CompatibilityDrugType.HasValue)
				{
					list.Add(productKindMetadata);
					hashSet.Add(productKindMetadata.ProductKind.Id);
				}
			}
			list.Sort(CompareMetadata);
			Dictionary<string, ProductTypeContainer> dictionary = new Dictionary<string, ProductTypeContainer>(StringComparer.OrdinalIgnoreCase);
			for (int num = app.ProductTypeContainers.Count - 1; num >= 0; num--)
			{
				ProductTypeContainer val = app.ProductTypeContainers[num];
				if (TryGetManagedId(val, out string productKindId))
				{
					if (!hashSet.Contains(productKindId) || dictionary.ContainsKey(productKindId))
					{
						app.ProductTypeContainers.RemoveAt(num);
						DestroyManagedContainer(app, val);
					}
					else
					{
						dictionary.Add(productKindId, val);
					}
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				ProductKindMetadata productKindMetadata2 = list[j];
				if (!dictionary.TryGetValue(productKindMetadata2.ProductKind.Id, out var value))
				{
					value = CreateContainer(app, productKindMetadata2);
					if ((Object)(object)value == (Object)null)
					{
						continue;
					}
					dictionary.Add(productKindMetadata2.ProductKind.Id, value);
				}
				ConfigureContainer(value, productKindMetadata2);
			}
			for (int num2 = app.ProductTypeContainers.Count - 1; num2 >= 0; num2--)
			{
				if (TryGetManagedId(app.ProductTypeContainers[num2], out string _))
				{
					app.ProductTypeContainers.RemoveAt(num2);
				}
			}
			for (int k = 0; k < list.Count; k++)
			{
				if (dictionary.TryGetValue(list[k].ProductKind.Id, out var value2))
				{
					app.ProductTypeContainers.Add(value2);
					((Component)value2).transform.SetAsLastSibling();
				}
			}
		}

		private static ProductTypeContainer? CreateContainer(ProductManagerApp app, ProductKindMetadata metadata)
		{
			ProductTypeContainer val = null;
			for (int i = 0; i < app.ProductTypeContainers.Count; i++)
			{
				ProductTypeContainer val2 = app.ProductTypeContainers[i];
				if (!TryGetManagedId(val2, out string _))
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				Logger.Error("Could not create Product Manager section '" + metadata.ProductKind.Id + "': no vanilla product-type container is available as a template.");
				return null;
			}
			GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
			val3.SetActive(false);
			((Object)val3).name = "S1API_ProductKind_" + metadata.ProductKind.Id;
			ProductTypeContainer component = val3.GetComponent<ProductTypeContainer>();
			if ((Object)(object)component == (Object)null)
			{
				Object.DestroyImmediate((Object)(object)val3);
				return null;
			}
			ClearChildren((Transform)(object)component.Enteries);
			ConfigureContainer(component, metadata);
			UIScreen screen = GetScreen(app);
			UIPanel component2 = val3.GetComponent<UIPanel>();
			if ((Object)(object)screen == (Object)null || (Object)(object)component2 == (Object)null)
			{
				Logger.Error("Could not create Product Manager section '" + metadata.ProductKind.Id + "': the cloned UI panel or owning screen is unavailable.");
				Object.DestroyImmediate((Object)(object)val3);
				return null;
			}
			screen.AddPanel(component2);
			val3.SetActive(true);
			component.RefreshNoneDisplay();
			return component;
		}

		private static void ConfigureContainer(ProductTypeContainer container, ProductKindMetadata metadata)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if (metadata.ProductKind.CompatibilityDrugType.HasValue)
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(container, "_drugType", metadata.ProductKind.CompatibilityDrugType.Value.ToInternal());
			}
			Text val = FindText(container, "Title");
			if ((Object)(object)val != (Object)null)
			{
				val.text = metadata.DisplayName;
				((Graphic)val).color = metadata.Color;
			}
			Image val2 = FindImage(container, "Arrow");
			if ((Object)(object)val2 != (Object)null)
			{
				((Graphic)val2).color = metadata.Color;
			}
			Image val3 = FindImage(container, "Image");
			if ((Object)(object)val3 != (Object)null)
			{
				SectionIconState sectionIconState = CreateSectionIconState(metadata.Icon);
				val3.sprite = sectionIconState.Sprite;
				((Graphic)val3).color = sectionIconState.Tint;
			}
		}

		private static void ReconcileEntries(ProductManagerApp app)
		{
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "entries") is List<ProductEntry> val)
			{
				List<ProductDefinition> list = new List<ProductDefinition>();
				for (int i = 0; i < val.Count; i++)
				{
					ProductEntry val2 = val[i];
					if ((Object)(object)val2 != (Object)null && (Object)(object)val2.Definition != (Object)null)
					{
						list.Add(val2.Definition);
					}
				}
				for (int j = 0; j < list.Count; j++)
				{
					if (TryResolveMetadata(list[j], out ProductKindMetadata metadata))
					{
						if (metadata.IsVisibleInProductManager)
						{
							RouteEntry(app, list[j], metadata);
						}
						else
						{
							RemoveEntries(val, list[j]);
						}
					}
				}
			}
			if (!(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "favouriteEntries") is List<ProductEntry> val3))
			{
				return;
			}
			for (int num = val3.Count - 1; num >= 0; num--)
			{
				ProductEntry val4 = val3[num];
				bool flag = (Object)(object)val4 != (Object)null;
				bool hasDefinition = flag && (Object)(object)val4.Definition != (Object)null;
				if (ShouldPurgeFavouriteEntry(flag, hasDefinition))
				{
					val3.RemoveAt(num);
					if (flag)
					{
						val4.Destroy();
					}
				}
				else
				{
					ProductDefinition definition = val4.Definition;
					if (TryResolveMetadata(definition, out ProductKindMetadata metadata2))
					{
						if (metadata2.IsVisibleInProductManager)
						{
							RefreshEntryIcon(val4);
						}
						else
						{
							val3.RemoveAt(num);
							val4.Destroy();
						}
					}
				}
			}
			ProductTypeContainer favouritesContainer = app.FavouritesContainer;
			if (favouritesContainer != null)
			{
				favouritesContainer.RefreshNoneDisplay();
			}
		}

		private static void RouteEntry(ProductManagerApp app, ProductDefinition definition, ProductKindMetadata metadata)
		{
			ProductTypeContainer val = FindManagedContainer(app, metadata.ProductKind.Id);
			if ((Object)(object)val == (Object)null || !(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "entries") is List<ProductEntry> val2))
			{
				return;
			}
			ProductEntry val3 = null;
			for (int i = 0; i < val2.Count; i++)
			{
				ProductEntry val4 = val2[i];
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.Definition == (Object)null) && string.Equals(((BaseItemDefinition)val4.Definition).ID, ((BaseItemDefinition)definition).ID, StringComparison.OrdinalIgnoreCase))
				{
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = val4;
						continue;
					}
					val2.RemoveAt(i--);
					val4.Destroy();
				}
			}
			if ((Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).transform.parent != (Object)(object)val.Enteries)
			{
				((Component)val3).transform.SetParent((Transform)(object)val.Enteries, false);
			}
			if ((Object)(object)val3 != (Object)null)
			{
				RefreshEntryIcon(val3);
			}
			RefreshContainers(app);
		}

		private static void RefreshEntryIcon(ProductEntry entry)
		{
			if ((Object)(object)entry.Icon != (Object)null && (Object)(object)entry.Definition != (Object)null && (Object)(object)((BaseItemDefinition)entry.Definition).Icon != (Object)null && entry.Icon.sprite != ((BaseItemDefinition)entry.Definition).Icon)
			{
				entry.Icon.sprite = ((BaseItemDefinition)entry.Definition).Icon;
			}
		}

		private static void RemoveEntries(List<ProductEntry> entries, ProductDefinition definition)
		{
			for (int num = entries.Count - 1; num >= 0; num--)
			{
				ProductEntry val = entries[num];
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Definition == (Object)null) && string.Equals(((BaseItemDefinition)val.Definition).ID, ((BaseItemDefinition)definition).ID, StringComparison.OrdinalIgnoreCase))
				{
					entries.RemoveAt(num);
					val.Destroy();
				}
			}
		}

		private static void RefreshContainers(ProductManagerApp app)
		{
			for (int i = 0; i < app.ProductTypeContainers.Count; i++)
			{
				ProductTypeContainer obj = app.ProductTypeContainers[i];
				if (obj != null)
				{
					obj.RefreshNoneDisplay();
				}
			}
		}

		private static bool TryResolveMetadata(ProductDefinition definition, out ProductKindMetadata metadata)
		{
			metadata = null;
			if (!CustomProductDefinitionRegistry.TryGetMetadata(definition, out CustomProductDefinitionMetadata metadata2) || metadata2 == null || !ProductKindMetadataRegistry.TryGet(metadata2.ProductKind, out ProductKindMetadata metadata3) || metadata3 == null)
			{
				return false;
			}
			metadata = metadata3;
			return true;
		}

		private static ProductTypeContainer? FindManagedContainer(ProductManagerApp app, string productKindId)
		{
			for (int i = 0; i < app.ProductTypeContainers.Count; i++)
			{
				ProductTypeContainer val = app.ProductTypeContainers[i];
				if (TryGetManagedId(val, out string productKindId2) && string.Equals(productKindId2, productKindId, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private static bool TryGetManagedId(ProductTypeContainer? container, out string productKindId)
		{
			productKindId = string.Empty;
			if ((Object)(object)container == (Object)null)
			{
				return false;
			}
			string name = ((Object)((Component)container).gameObject).name;
			if (name == null || !name.StartsWith("S1API_ProductKind_", StringComparison.Ordinal))
			{
				return false;
			}
			productKindId = name.Substring("S1API_ProductKind_".Length);
			return productKindId.Length > 0;
		}

		private static void DestroyManagedContainer(ProductManagerApp app, ProductTypeContainer container)
		{
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "entries") is List<ProductEntry> val)
			{
				for (int num = val.Count - 1; num >= 0; num--)
				{
					ProductEntry val2 = val[num];
					if (!((Object)(object)val2 == (Object)null) && ((Component)val2).transform.IsChildOf(((Component)container).transform))
					{
						val.RemoveAt(num);
						val2.Destroy();
					}
				}
			}
			UIScreen screen = GetScreen(app);
			UIPanel component = ((Component)container).GetComponent<UIPanel>();
			if ((Object)(object)screen != (Object)null && (Object)(object)component != (Object)null)
			{
				screen.RemovePanel(component);
			}
			((Component)container).gameObject.SetActive(false);
			Object.DestroyImmediate((Object)(object)((Component)container).gameObject);
		}

		private static UIScreen? GetScreen(ProductManagerApp app)
		{
			object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "_screen");
			return (UIScreen?)((obj is UIScreen) ? obj : null);
		}

		private static void ClearChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				GameObject gameObject = ((Component)parent.GetChild(num)).gameObject;
				gameObject.SetActive(false);
				Object.DestroyImmediate((Object)(object)gameObject);
			}
		}

		private static Text? FindText(ProductTypeContainer container, string name)
		{
			Il2CppArrayBase<Text> componentsInChildren = ((Component)container).GetComponentsInChildren<Text>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (string.Equals(((Object)((Component)componentsInChildren[i]).gameObject).name, name, StringComparison.Ordinal))
				{
					return componentsInChildren[i];
				}
			}
			return null;
		}

		private static Image? FindImage(ProductTypeContainer container, string name)
		{
			Il2CppArrayBase<Image> componentsInChildren = ((Component)container).GetComponentsInChildren<Image>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (string.Equals(((Object)((Component)componentsInChildren[i]).gameObject).name, name, StringComparison.Ordinal))
				{
					return componentsInChildren[i];
				}
			}
			return null;
		}

		private static int CompareMetadata(ProductKindMetadata left, ProductKindMetadata right)
		{
			int num = left.SortOrder.CompareTo(right.SortOrder);
			if (num != 0)
			{
				return num;
			}
			num = StringComparer.OrdinalIgnoreCase.Compare(left.DisplayName, right.DisplayName);
			return (num != 0) ? num : StringComparer.OrdinalIgnoreCase.Compare(left.ProductKind.Id, right.ProductKind.Id);
		}
	}
	internal readonly struct ProductMixingColorValue : IEquatable<ProductMixingColorValue>
	{
		internal byte Red { get; }

		internal byte Green { get; }

		internal byte Blue { get; }

		internal byte Alpha { get; }

		internal ProductMixingColorValue(byte red, byte green, byte blue, byte alpha)
		{
			Red = red;
			Green = green;
			Blue = blue;
			Alpha = alpha;
		}

		internal Color32 ToColor32()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color32(Red, Green, Blue, Alpha);
		}

		public bool Equals(ProductMixingColorValue other)
		{
			return Red == other.Red && Green == other.Green && Blue == other.Blue && Alpha == other.Alpha;
		}

		public override bool Equals(object? obj)
		{
			return obj is ProductMixingColorValue other && Equals(other);
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(Red, Green, Blue, Alpha);
		}
	}
	internal readonly struct ProductMixingColorSample
	{
		internal int Tier { get; }

		internal ProductMixingColorValue Color { get; }

		internal ProductMixingColorSample(int tier, ProductMixingColorValue color)
		{
			Tier = tier;
			Color = color;
		}
	}
	internal static class ProductMixingColorContract
	{
		internal static ProductMixingColorValue CalculatePrimaryColor(ProductMixingMap mixerMap, IReadOnlyList<ProductMixingColorSample> properties)
		{
			if (properties == null)
			{
				throw new ArgumentNullException("properties");
			}
			ProductMixingColorValue baseColor = GetBaseColor(mixerMap);
			if (properties.Count == 0)
			{
				return baseColor;
			}
			ProductMixingColorSample productMixingColorSample = properties[0];
			for (int i = 1; i < properties.Count; i++)
			{
				if (properties[i].Tier < productMixingColorSample.Tier)
				{
					productMixingColorSample = properties[i];
				}
			}
			if (1 == 0)
			{
			}
			float num = mixerMap switch
			{
				ProductMixingMap.Marijuana => (float)productMixingColorSample.Tier * 0.15f, 
				ProductMixingMap.Methamphetamine => (float)productMixingColorSample.Tier * 0.2f, 
				ProductMixingMap.Cocaine => (float)productMixingColorSample.Tier * 0.13f, 
				ProductMixingMap.Shrooms => (float)productMixingColorSample.Tier / 5f, 
				_ => throw new ArgumentOutOfRangeException("mixerMap"), 
			};
			if (1 == 0)
			{
			}
			float amount = num;
			return Lerp(baseColor, productMixingColorSample.Color, amount);
		}

		private static ProductMixingColorValue GetBaseColor(ProductMixingMap mixerMap)
		{
			if (1 == 0)
			{
			}
			ProductMixingColorValue result = mixerMap switch
			{
				ProductMixingMap.Marijuana => new ProductMixingColorValue(90, 100, 70, byte.MaxValue), 
				ProductMixingMap.Methamphetamine => new ProductMixingColorValue(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 
				ProductMixingMap.Cocaine => new ProductMixingColorValue(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue), 
				ProductMixingMap.Shrooms => new ProductMixingColorValue(168, 125, 43, byte.MaxValue), 
				_ => throw new ArgumentOutOfRangeException("mixerMap"), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static ProductMixingColorValue Lerp(ProductMixingColorValue start, ProductMixingColorValue end, float amount)
		{
			float amount2 = Math.Max(0f, Math.Min(1f, amount));
			return new ProductMixingColorValue(LerpByte(start.Red, end.Red, amount2), LerpByte(start.Green, end.Green, amount2), LerpByte(start.Blue, end.Blue, amount2), LerpByte(start.Alpha, end.Alpha, amount2));
		}

		private static byte LerpByte(byte start, byte end, float amount)
		{
			return (byte)((float)(int)start + (float)(end - start) * amount);
		}
	}
	internal static class ProductMixingMapContract
	{
		internal static DrugType GetNativeDrugType(ProductMixingMap mixerMap)
		{
			return mixerMap switch
			{
				ProductMixingMap.Marijuana => DrugType.Marijuana, 
				ProductMixingMap.Methamphetamine => DrugType.Methamphetamine, 
				ProductMixingMap.Cocaine => DrugType.Cocaine, 
				ProductMixingMap.Shrooms => DrugType.Shrooms, 
				_ => throw new ArgumentOutOfRangeException("mixerMap"), 
			};
		}
	}
	internal static class ProductMixingProfileRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ProductMixingProfile> Profiles = new Dictionary<string, ProductMixingProfile>(StringComparer.OrdinalIgnoreCase);

		internal static ProductMixingProfile Register(ProductMixingProfile profile)
		{
			lock (Gate)
			{
				if (!Profiles.TryGetValue(profile.ProductKind.Id, out ProductMixingProfile value))
				{
					Profiles.Add(profile.ProductKind.Id, profile);
					return profile;
				}
				if (value.MixerMap == profile.MixerMap && (object)value.OutputFactory == profile.OutputFactory && string.Equals(value.OutputFactoryIdentity, profile.OutputFactoryIdentity, StringComparison.OrdinalIgnoreCase) && value.OutputFactoryVersion == profile.OutputFactoryVersion && value.UsePropertyColorMixing == profile.UsePropertyColorMixing)
				{
					return value;
				}
				throw new InvalidOperationException("A conflicting mixing profile is already registered for product kind '" + profile.ProductKind.Id + "'.");
			}
		}

		internal static bool TryGet(string productKindId, out ProductMixingProfile? profile)
		{
			string key = ProductKindId.Normalize(productKindId, "productKindId");
			lock (Gate)
			{
				return Profiles.TryGetValue(key, out profile);
			}
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				Profiles.Clear();
			}
		}

		internal static ProductMixingProfile[] Snapshot()
		{
			lock (Gate)
			{
				ProductMixingProfile[] array = new ProductMixingProfile[Profiles.Count];
				Profiles.Values.CopyTo(array, 0);
				return array;
			}
		}
	}
	internal readonly struct ProductPackagingContentKey : IEquatable<ProductPackagingContentKey>
	{
		internal string ProductId { get; }

		internal string PackagingId { get; }

		internal ProductPackagingContentKey(string productId, string packagingId)
		{
			ProductId = productId;
			PackagingId = packagingId;
		}

		public bool Equals(ProductPackagingContentKey other)
		{
			return string.Equals(ProductId, other.ProductId, StringComparison.OrdinalIgnoreCase) && string.Equals(PackagingId, other.PackagingId, StringComparison.OrdinalIgnoreCase);
		}

		public override bool Equals(object? obj)
		{
			return obj is ProductPackagingContentKey other && Equals(other);
		}

		public override int GetHashCode()
		{
			return (StringComparer.OrdinalIgnoreCase.GetHashCode(ProductId) * 397) ^ StringComparer.OrdinalIgnoreCase.GetHashCode(PackagingId);
		}
	}
	internal sealed class ProductPackagingContentProfileRegistration
	{
		internal string OwnerId { get; }

		internal ProductPackagingContentKey Key { get; }

		internal ProductPackagingContentProfile Profile { get; }

		internal ProductPackagingContentProfileRegistration(string ownerId, ProductPackagingContentKey key, ProductPackagingContentProfile profile)
		{
			OwnerId = ownerId;
			Key = key;
			Profile = profile;
		}
	}
	internal static class ProductPackagingContentRuntime
	{
		private sealed class GeneratedPackagingIcon
		{
			internal Texture2D Texture { get; }

			internal Sprite Icon { get; }

			internal GeneratedPackagingIcon(Texture2D texture, Sprite icon)
			{
				Texture = texture;
				Icon = icon;
			}
		}

		private const string GeneratedRootNamePrefix = "S1API_PackagingContent_";

		private static readonly object IconGate = new object();

		private static readonly object IconQueueGate = new object();

		private static readonly object FailureGate = new object();

		private static readonly Dictionary<ProductPackagingContentKey, GeneratedPackagingIcon> GeneratedIcons = new Dictionary<ProductPackagingContentKey, GeneratedPackagingIcon>();

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

		private static readonly Queue<ProductPackagingContentProfileRegistration> GeneratedIconQueue = new Queue<ProductPackagingContentProfileRegistration>();

		private static readonly HashSet<ProductPackagingContentKey> QueuedGeneratedIcons = new HashSet<ProductPackagingContentKey>();

		private static int _iconGeneratorInstanceId;

		private static int _iconQueueGeneration;

		private static bool _isProcessingGeneratedIcons;

		private static int _nativeIconBatchDepth;

		private static int _nativeIconFallbackDepth;

		internal static bool IsNativeIconFallbackActive => _nativeIconFallbackDepth > 0;

		internal static bool GeneratedIconWorkComplete
		{
			get
			{
				lock (IconQueueGate)
				{
					return !_isProcessingGeneratedIcons && GeneratedIconQueue.Count == 0;
				}
			}
		}

		internal static int CachedIconCountForTesting
		{
			get
			{
				lock (IconGate)
				{
					return GeneratedIcons.Count;
				}
			}
		}

		internal static bool TryApply(MultiTypeVisualsSetter setter, ProductItemInstance product)
		{
			if ((Object)(object)setter == (Object)null)
			{
				return false;
			}
			if (product == null || string.IsNullOrWhiteSpace(product.PackagingID) || !ProductPackagingContentProfileRegistry.TryResolve(((BaseItemInstance)product).ID, product.PackagingID, out ProductPackagingContentProfileRegistration registration) || registration == null)
			{
				RemoveOwnedRoots(((Component)setter).transform, null);
				return false;
			}
			string generatedRootName = GetGeneratedRootName(registration.Key);
			Transform val = FindOwnedRoot(((Component)setter).transform, generatedRootName);
			RemoveOwnedRoots(((Component)setter).transform, val);
			if ((Object)(object)val != (Object)null)
			{
				if (!TryDisableNativeVisuals(setter, registration, "runtime visual"))
				{
					DestroyOwnedRoot(((Component)val).gameObject);
					return false;
				}
				((Component)val).gameObject.SetActive(true);
				return true;
			}
			if (!TryCreateContentRoot(setter, registration, generatedRootName, out GameObject generatedRoot))
			{
				return false;
			}
			if (!TryDisableNativeVisuals(setter, registration, "runtime visual"))
			{
				DestroyOwnedRoot(generatedRoot);
				return false;
			}
			generatedRoot.SetActive(true);
			return true;
		}

		internal static bool TryGeneratePackagingIcon(IconGenerator generator, string packagingId, string productId, out Texture2D? texture)
		{
			texture = null;
			if ((Object)(object)generator == (Object)null || string.IsNullOrWhiteSpace(productId) || string.IsNullOrWhiteSpace(packagingId) || !ProductPackagingContentProfileRegistry.TryResolve(productId, packagingId, out ProductPackagingContentProfileRegistration registration) || registration == null)
			{
				return false;
			}
			lock (IconGate)
			{
				return TryGeneratePackagingIconCore(generator, registration, out texture);
			}
		}

		internal static void BeginNativeIconBatch()
		{
			_nativeIconBatchDepth++;
		}

		internal static void EndNativeIconBatch()
		{
			if (_nativeIconBatchDepth > 0)
			{
				_nativeIconBatchDepth--;
			}
		}

		internal static bool TryDeferNativeBatchPackagingIcon(string packagingId, string productId)
		{
			if (_nativeIconBatchDepth <= 0 || string.IsNullOrWhiteSpace(productId) || string.IsNullOrWhiteSpace(packagingId) || !ProductPackagingContentProfileRegistry.TryResolve(productId, packagingId, out ProductPackagingContentProfileRegistration registration) || registration == null)
			{
				return false;
			}
			QueueGeneratedIcon(registration);
			_nativeIconFallbackDepth++;
			return true;
		}

		internal static void EndNativeIconFallback()
		{
			if (_nativeIconFallbackDepth > 0)
			{
				_nativeIconFallbackDepth--;
			}
		}

		internal static bool TryGetPackagingIcon(string productId, string packagingId, out Sprite? icon)
		{
			icon = null;
			if (string.IsNullOrWhiteSpace(productId) || string.IsNullOrWhiteSpace(packagingId) || !ProductPackagingContentProfileRegistry.TryResolve(productId, packagingId, out ProductPackagingContentProfileRegistration registration) || registration == null)
			{
				return false;
			}
			IconGenerator s1IconGenerator;
			try
			{
				s1IconGenerator = IconFactory.S1IconGenerator;
			}
			catch
			{
				return false;
			}
			if ((Object)(object)s1IconGenerator == (Object)null)
			{
				return false;
			}
			lock (IconGate)
			{
				EnsureIconCacheMatches(s1IconGenerator);
				if (GeneratedIcons.TryGetValue(registration.Key, out GeneratedPackagingIcon value))
				{
					if ((Object)(object)value.Icon != (Object)null && (Object)(object)value.Texture != (Object)null)
					{
						icon = value.Icon;
						return true;
					}
					DestroyGeneratedIcon(value);
					GeneratedIcons.Remove(registration.Key);
				}
			}
			QueueGeneratedIcon(registration);
			return TryGetLooseProductIcon(registration, productId, out icon);
		}

		internal static void QueueRegisteredIconsForLoading()
		{
			ProductPackagingContentProfileRegistration[] array = ProductPackagingContentProfileRegistry.Snapshot();
			for (int i = 0; i < array.Length; i++)
			{
				QueueGeneratedIcon(array[i]);
			}
		}

		internal static void ResetForSceneChange()
		{
			lock (IconGate)
			{
				DestroyGeneratedIcons();
				_iconGeneratorInstanceId = 0;
			}
			lock (IconQueueGate)
			{
				_iconQueueGeneration++;
				GeneratedIconQueue.Clear();
				QueuedGeneratedIcons.Clear();
				_isProcessingGeneratedIcons = false;
			}
			_nativeIconBatchDepth = 0;
			_nativeIconFallbackDepth = 0;
			lock (FailureGate)
			{
				LoggedFailures.Clear();
			}
		}

		internal static string GetGeneratedRootNameForTesting(string productId, string packagingId)
		{
			return GetGeneratedRootName(new ProductPackagingContentKey(productId, packagingId));
		}

		internal static bool MatchesRegistrationForTesting(string? productId, string? packagingId, string registeredProductId, string registeredPackagingId)
		{
			return MatchesRegistration(productId, packagingId, new ProductPackagingContentKey(registeredProductId, registeredPackagingId));
		}

		private static bool TryGeneratePackagingIconCore(IconGenerator generator, ProductPackagingContentProfileRegistration registration, out Texture2D? texture)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			texture = null;
			Transform val = FindPackagingShell(generator, registration.Key.PackagingId);
			if ((Object)(object)val == (Object)null)
			{
				LogFailureOnce(registration, "composite icon", "the active native icon rig has no matching packaging shell");
				return false;
			}
			bool? flag = (((Object)(object)generator.MainContainer != (Object)null) ? new bool?(((Component)generator.MainContainer).gameObject.activeSelf) : ((bool?)null));
			bool? flag2 = (((Object)(object)generator.ItemContainer != (Object)null) ? new bool?(((Component)generator.ItemContainer).gameObject.activeSelf) : ((bool?)null));
			AmbientMode ambientMode = RenderSettings.ambientMode;
			Color ambientLight = RenderSettings.ambientLight;
			Color ambientSkyColor = RenderSettings.ambientSkyColor;
			Color ambientEquatorColor = RenderSettings.ambientEquatorColor;
			Color ambientGroundColor = RenderSettings.ambientGroundColor;
			GameObject val2 = null;
			try
			{
				val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, val.parent, false);
				MultiTypeVisualsSetter componentInChildren = val2.GetComponentInChildren<MultiTypeVisualsSetter>(true);
				if ((Object)(object)componentInChildren == (Object)null)
				{
					LogFailureOnce(registration, "composite icon", "the matching native shell has no content anchor");
					return false;
				}
				if (!TryCreateContentRoot(componentInChildren, registration, GetGeneratedRootName(registration.Key), out GameObject generatedRoot))
				{
					return false;
				}
				if (!TryDisableNativeVisuals(componentInChildren, registration, "composite icon"))
				{
					return false;
				}
				int layer = ((Component)componentInChildren).gameObject.layer;
				LayerUtility.SetLayerRecursively(generatedRoot, layer);
				generatedRoot.SetActive(true);
				val2.SetActive(true);
				texture = generator.GetTexture(((Component)componentInChildren).transform.parent);
				if ((Object)(object)texture == (Object)null)
				{
					LogFailureOnce(registration, "composite icon", "the native icon renderer returned no texture");
					return false;
				}
				if (!IconFactory.HasVisibleContent(texture))
				{
					Object.Destroy((Object)(object)texture);
					texture = null;
					LogFailureOnce(registration, "composite icon", "the native icon renderer returned no visible pixels");
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				if ((Object)(object)texture != (Object)null)
				{
					Object.Destroy((Object)(object)texture);
					texture = null;
				}
				LogFailureOnce(registration, "composite icon", ex.Message);
				return false;
			}
			finally
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(false);
					Object.Destroy((Object)(object)val2);
				}
				if (flag.HasValue && (Object)(object)generator.MainContainer != (Object)null)
				{
					((Component)generator.MainContainer).gameObject.SetActive(flag.Value);
				}
				if (flag2.HasValue && (Object)(object)generator.ItemContainer != (Object)null)
				{
					((Component)generator.ItemContainer).gameObject.SetActive(flag2.Value);
				}
				RenderSettings.ambientMode = ambientMode;
				RenderSettings.ambientLight = ambientLight;
				RenderSettings.ambientSkyColor = ambientSkyColor;
				RenderSettings.ambientEquatorColor = ambientEquatorColor;
				RenderSettings.ambientGroundColor = ambientGroundColor;
			}
		}

		private static void QueueGeneratedIcon(ProductPackagingContentProfileRegistration registration)
		{
			lock (IconGate)
			{
				if (GeneratedIcons.TryGetValue(registration.Key, out GeneratedPackagingIcon value) && (Object)(object)value.Icon != (Object)null && (Object)(object)value.Texture != (Object)null)
				{
					return;
				}
			}
			bool flag = false;
			int iconQueueGeneration;
			lock (IconQueueGate)
			{
				if (!QueuedGeneratedIcons.Add(registration.Key))
				{
					return;
				}
				GeneratedIconQueue.Enqueue(registration);
				iconQueueGeneration = _iconQueueGeneration;
				if (!_isProcessingGeneratedIcons)
				{
					_isProcessingGeneratedIcons = true;
					flag = true;
				}
			}
			if (!flag)
			{
				return;
			}
			try
			{
				MelonCoroutines.Start(ProcessGeneratedIconQueue(iconQueueGeneration));
			}
			catch (Exception ex)
			{
				lock (IconQueueGate)
				{
					if (iconQueueGeneration == _iconQueueGeneration)
					{
						GeneratedIconQueue.Clear();
						QueuedGeneratedIcons.Clear();
						_isProcessingGeneratedIcons = false;
					}
				}
				LogFailureOnce(registration, "composite icon queue", ex.Message);
			}
		}

		private static IEnumerator ProcessGeneratedIconQueue(int generation)
		{
			while (true)
			{
				ProductPackagingContentProfileRegistration registration;
				lock (IconQueueGate)
				{
					if (generation != _iconQueueGeneration)
					{
						break;
					}
					if (GeneratedIconQueue.Count == 0)
					{
						_isProcessingGeneratedIcons = false;
						break;
					}
					registration = GeneratedIconQueue.Dequeue();
				}
				int readinessFrame = 0;
				while (!IconFactory.IsItemIconGeneratorReady && readinessFrame < 300)
				{
					readinessFrame++;
					yield return null;
				}
				if (generation != _iconQueueGeneration)
				{
					break;
				}
				if (!IconFactory.IsItemIconGeneratorReady)
				{
					LogFailureOnce(registration, "composite icon", "the native item-icon rendering rig did not become ready");
					CompleteQueuedIcon(registration.Key, generation);
					continue;
				}
				ProductIconRenderRigArbiter.CaptureLease renderLease = ProductIconRenderRigArbiter.Enqueue();
				try
				{
					while (!ProductIconRenderRigArbiter.TryAcquire(renderLease))
					{
						if (generation != _iconQueueGeneration)
						{
							yield break;
						}
						yield return null;
					}
					yield return null;
					yield return (object)new WaitForEndOfFrame();
					if (generation != _iconQueueGeneration)
					{
						break;
					}
					try
					{
						IconGenerator generator = IconFactory.S1IconGenerator;
						bool iconCached = false;
						lock (IconGate)
						{
							EnsureIconCacheMatches(generator);
							if (!GeneratedIcons.ContainsKey(registration.Key) && TryGeneratePackagingIconCore(generator, registration, out Texture2D texture) && (Object)(object)texture != (Object)null)
							{
								iconCached = TryCacheGeneratedIcon(registration, texture);
							}
							texture = null;
						}
						if (iconCached)
						{
							RefreshMatchingItemUis(registration);
						}
					}
					catch (Exception ex)
					{
						LogFailureOnce(registration, "composite icon", ex.Message);
					}
					yield return null;
					yield return (object)new WaitForEndOfFrame();
				}
				finally
				{
					ProductIconRenderRigArbiter.Release(renderLease);
					CompleteQueuedIcon(registration.Key, generation);
				}
				registration = null;
			}
		}

		private static bool TryGetLooseProductIcon(ProductPackagingContentProfileRegistration registration, string productId, out Sprite? icon)
		{
			icon = null;
			try
			{
				icon = ItemManager.GetDefinition(productId)?.Icon;
				return (Object)(object)icon != (Object)null;
			}
			catch (Exception ex)
			{
				LogFailureOnce(registration, "loose-icon lookup", ex.Message);
				return false;
			}
		}

		private static void RefreshMatchingItemUis(ProductPackagingContentProfileRegistration registration)
		{
			try
			{
				ItemSlotUI[] array = Il2CppArrayBase<ItemSlotUI>.op_Implicit(Object.FindObjectsOfType<ItemSlotUI>(true));
				foreach (ItemSlotUI val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						ItemSlot assignedSlot = val.assignedSlot;
						ItemInstance item = ((assignedSlot != null) ? assignedSlot.ItemInstance : null);
						if (TryGetProductPackaging(item, out string productId, out string packagingId) && MatchesRegistration(productId, packagingId, registration.Key))
						{
							val.UpdateUI();
						}
					}
				}
			}
			catch (Exception ex)
			{
				LogFailureOnce(registration, "bound item UI refresh", ex.Message);
			}
		}

		private static bool TryGetProductPackaging(ItemInstance? item, out string? productId, out string? packagingId)
		{
			productId = null;
			packagingId = null;
			if (item == null)
			{
				return false;
			}
			ProductItemInstance val = ((Il2CppObjectBase)item).TryCast<ProductItemInstance>();
			if (val == null)
			{
				return false;
			}
			productId = ((BaseItemInstance)val).ID;
			packagingId = val.PackagingID;
			return true;
		}

		private static bool MatchesRegistration(string? productId, string? packagingId, ProductPackagingContentKey key)
		{
			return string.Equals(productId, key.ProductId, StringComparison.OrdinalIgnoreCase) && string.Equals(packagingId, key.PackagingId, StringComparison.OrdinalIgnoreCase);
		}

		private static void CompleteQueuedIcon(ProductPackagingContentKey key, int generation)
		{
			lock (IconQueueGate)
			{
				if (generation == _iconQueueGeneration)
				{
					QueuedGeneratedIcons.Remove(key);
				}
			}
		}

		private static bool TryCacheGeneratedIcon(ProductPackagingContentProfileRegistration registration, Texture2D texture)
		{
			//IL_0024: 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)
			Sprite val = null;
			try
			{
				texture.Apply();
				val = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), new Vector2(0.5f, 0.5f));
				if ((Object)(object)val == (Object)null)
				{
					Object.Destroy((Object)(object)texture);
					LogFailureOnce(registration, "composite icon", "the rendered texture could not be converted to a sprite");
					return false;
				}
				((Object)val).name = registration.Key.ProductId + "_" + registration.Key.PackagingId + "_S1API";
				GeneratedIcons.Add(registration.Key, new GeneratedPackagingIcon(texture, val));
				return true;
			}
			catch (Exception ex)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				Object.Destroy((Object)(object)texture);
				LogFailureOnce(registration, "composite icon", ex.Message);
				return false;
			}
		}

		private static Transform? FindPackagingShell(IconGenerator generator, string packagingId)
		{
			if (generator.Visuals == null)
			{
				return null;
			}
			for (int i = 0; i < generator.Visuals.Count; i++)
			{
				PackagingVisuals val = generator.Visuals[i];
				if (val != null && string.Equals(val.PackagingID, packagingId, StringComparison.OrdinalIgnoreCase))
				{
					return val.TopLevelTransform;
				}
			}
			return null;
		}

		private static bool TryCreateContentRoot(MultiTypeVisualsSetter setter, ProductPackagingContentProfileRegistration registration, string rootName, out GameObject? generatedRoot)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Transform transform = ((Component)setter).transform;
			generatedRoot = new GameObject(rootName);
			generatedRoot.transform.SetParent(transform, false);
			generatedRoot.SetActive(false);
			if (registration.Profile.Source == ProductPackagingContentSource.NativeFilledVisualScaffold)
			{
				if (TryCreateNativeScaffold(setter, registration, generatedRoot))
				{
					return true;
				}
				generatedRoot = null;
				return false;
			}
			GameObject val;
			try
			{
				val = registration.Profile.ContentProvider();
			}
			catch (Exception ex)
			{
				LogFailureOnce(registration, "content provider", ex.Message);
				DestroyOwnedRoot(generatedRoot);
				generatedRoot = null;
				return false;
			}
			if ((Object)(object)val == (Object)null)
			{
				LogFailureOnce(registration, "content provider", "the provider returned null");
				DestroyOwnedRoot(generatedRoot);
				generatedRoot = null;
				return false;
			}
			try
			{
				if (registration.Profile.Source == ProductPackagingContentSource.CompleteFilledVisual)
				{
					AddContentClone(val, generatedRoot.transform, registration.Profile.CompleteVisualTransform, null);
					return true;
				}
				if (registration.Profile.Placements.Count == 0)
				{
					AddContentClone(val, generatedRoot.transform, null, null);
					return true;
				}
				for (int i = 0; i < registration.Profile.Placements.Count; i++)
				{
					AddContentClone(val, generatedRoot.transform, registration.Profile.Placements[i], null);
				}
				return true;
			}
			catch (Exception ex2)
			{
				LogFailureOnce(registration, "content composition", ex2.Message);
				DestroyOwnedRoot(generatedRoot);
				generatedRoot = null;
				return false;
			}
		}

		private static bool TryCreateNativeScaffold(MultiTypeVisualsSetter setter, ProductPackagingContentProfileRegistration registration, GameObject generatedRoot)
		{
			GameObject nativeScaffoldSource = GetNativeScaffoldSource(setter, registration.Profile.NativeVisualTemplate.Value);
			if ((Object)(object)nativeScaffoldSource == (Object)null)
			{
				LogFailureOnce(registration, "native visual scaffold", $"the selected template '{registration.Profile.NativeVisualTemplate.Value}' is " + "unavailable in this packaging context");
				DestroyOwnedRoot(generatedRoot);
				return false;
			}
			try
			{
				AddContentClone(nativeScaffoldSource, generatedRoot.transform, registration.Profile.CompleteVisualTransform, registration.Profile.NativeVisualCustomizer);
				return true;
			}
			catch (Exception ex)
			{
				LogFailureOnce(registration, "native visual scaffold", ex.Message);
				DestroyOwnedRoot(generatedRoot);
				return false;
			}
		}

		private static GameObject? GetNativeScaffoldSource(MultiTypeVisualsSetter setter, ProductPackagingVisualTemplate template)
		{
			Transform val;
			switch (template)
			{
			case ProductPackagingVisualTemplate.Marijuana:
			{
				WeedVisualsSetter weedVisuals = setter.WeedVisuals;
				val = ((weedVisuals != null) ? ((ProductVisualsSetter)weedVisuals).VisualsContainer : null);
				break;
			}
			case ProductPackagingVisualTemplate.Methamphetamine:
			{
				MethVisualsSetter methVisuals = setter.MethVisuals;
				val = ((methVisuals != null) ? ((ProductVisualsSetter)methVisuals).VisualsContainer : null);
				break;
			}
			case ProductPackagingVisualTemplate.Cocaine:
			{
				CocaineVisualsSetter cocaineVisuals = setter.CocaineVisuals;
				val = ((cocaineVisuals != null) ? ((ProductVisualsSetter)cocaineVisuals).VisualsContainer : null);
				break;
			}
			case ProductPackagingVisualTemplate.Shrooms:
			{
				ShroomVisualsSetter shroomVisuals = setter.ShroomVisuals;
				val = ((shroomVisuals != null) ? ((ProductVisualsSetter)shroomVisuals).VisualsContainer : null);
				break;
			}
			default:
				return null;
			}
			return (val != null) ? ((Component)val).gameObject : null;
		}

		private static void AddContentClone(GameObject source, Transform parent, ProductPresentationTransform? placement, Action<GameObject>? customize)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = source.transform.localPosition;
			Quaternion localRotation = source.transform.localRotation;
			Vector3 localScale = source.transform.localScale;
			GameObject val = Object.Instantiate<GameObject>(source);
			val.transform.SetParent(parent, false);
			if (placement != null)
			{
				placement.ApplyTo(val.transform);
			}
			else
			{
				val.transform.localPosition = localPosition;
				val.transform.localRotation = localRotation;
				val.transform.localScale = localScale;
			}
			customize?.Invoke(val);
			val.SetActive(true);
		}

		private static bool TryDisableNativeVisuals(MultiTypeVisualsSetter setter, ProductPackagingContentProfileRegistration registration, string operation)
		{
			try
			{
				WeedVisualsSetter weedVisuals = setter.WeedVisuals;
				if (weedVisuals != null)
				{
					((ProductVisualsSetter)weedVisuals).ResetVisuals();
				}
				MethVisualsSetter methVisuals = setter.MethVisuals;
				if (methVisuals != null)
				{
					((ProductVisualsSetter)methVisuals).ResetVisuals();
				}
				CocaineVisualsSetter cocaineVisuals = setter.CocaineVisuals;
				if (cocaineVisuals != null)
				{
					((ProductVisualsSetter)cocaineVisuals).ResetVisuals();
				}
				ShroomVisualsSetter shroomVisuals = setter.ShroomVisuals;
				if (shroomVisuals != null)
				{
					((ProductVisualsSetter)shroomVisuals).ResetVisuals();
				}
				return true;
			}
			catch (Exception ex)
			{
				LogFailureOnce(registration, operation, ex.Message);
				return false;
			}
		}

		private static Transform? FindOwnedRoot(Transform parent, string expectedName)
		{
			for (int i = 0; i < parent.childCount; i++)
			{
				Transform child = parent.GetChild(i);
				if (string.Equals(((Object)child).name, expectedName, StringComparison.Ordinal))
				{
					return child;
				}
			}
			return null;
		}

		private static void RemoveOwnedRoots(Transform parent, Transform? retainedRoot)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Transform child = parent.GetChild(num);
				if (!((Object)(object)child == (Object)(object)retainedRoot) && ((Object)child).name.StartsWith("S1API_PackagingContent_", StringComparison.Ordinal))
				{
					DestroyOwnedRoot(((Component)child).gameObject);
				}
			}
		}

		private static void DestroyOwnedRoot(GameObject root)
		{
			if (!((Object)(object)root == (Object)null))
			{
				root.SetActive(false);
				Object.Destroy((Object)(object)root);
			}
		}

		private static string GetGeneratedRootName(ProductPackagingContentKey key)
		{
			string text = key.ProductId.ToUpperInvariant() + "\0" + key.PackagingId.ToUpperInvariant();
			ulong num = 14695981039346656037uL;
			foreach (char c in text)
			{
				num ^= (byte)c;
				num *= 1099511628211L;
				num ^= (byte)((int)c >> 8);
				num *= 1099511628211L;
			}
			return "S1API_PackagingContent_" + num.ToString("X16");
		}

		private static void EnsureIconCacheMatches(IconGenerator generator)
		{
			int instanceID = ((Object)generator).GetInstanceID();
			if (_iconGeneratorInstanceId != instanceID)
			{
				DestroyGeneratedIcons();
				_iconGeneratorInstanceId = instanceID;
			}
		}

		private static void DestroyGeneratedIcons()
		{
			foreach (GeneratedPackagingIcon value in GeneratedIcons.Values)
			{
				DestroyGeneratedIcon(value);
			}
			GeneratedIcons.Clear();
		}

		private static void DestroyGeneratedIcon(GeneratedPackagingIcon generated)
		{
			if ((Object)(object)generated.Icon != (Object)null)
			{
				Object.Destroy((Object)(object)generated.Icon);
			}
			if ((Object)(object)generated.Texture != (Object)null)
			{
				Object.Destroy((Object)(object)generated.Texture);
			}
		}

		private static void LogFailureOnce(ProductPackagingContentProfileRegistration registration, string operation, string reason)
		{
			string item = registration.Key.ProductId.ToUpperInvariant() + "\0" + registration.Key.PackagingId.ToUpperInvariant() + "\0" + operation;
			lock (FailureGate)
			{
				if (!LoggedFailures.Add(item))
				{
					return;
				}
			}
			MelonLogger.Warning($"[ProductPackagingContentProfile] {operation} for product '{registration.Key.ProductId}' and packaging '{registration.Key.PackagingId}' failed: {reason}. " + "Preserving the native presentation fallback.");
		}
	}
	internal sealed class ProductPresentationProfileRegistration
	{
		internal string OwnerId { get; }

		internal string Key { get; }

		internal ProductPresentationProfile Profile { get; }

		internal ProductPresentationProfileRegistration(string ownerId, string key, ProductPresentationProfile profile)
		{
			OwnerId = ownerId;
			Key = key;
			Profile = profile;
		}
	}
	internal static class ProductPresentationWorkbenchAdapter
	{
		internal static bool TryCreateDefinition(string id, out PresentationWorkbenchDefinition? definition)
		{
			//IL_00f1: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			definition = null;
			if (!ProductPresentationProfileRegistry.TryGetWorkbenchProfile(id, out ProductPresentationProfile profile) || profile == null)
			{
				return false;
			}
			PresentationWorkbenchDefinition.PreviewContext previewContext = null;
			PresentationWorkbenchDefinition.AvatarPreviewContext avatarPreviewContext = null;
			PresentationWorkbenchDefinition.IconPreviewContext iconPreviewContext = null;
			if (profile.TryGetVisualProvider(ProductPresentationContext.Held, out Func<GameObject> provider) && provider != null)
			{
				PresentationWorkbenchTransform initialTransform = ResolveTransform(profile, ProductPresentationContext.Held);
				previewContext = new PresentationWorkbenchDefinition.PreviewContext(provider, initialTransform, PresentationWorkbenchExportKind.ProductTransform);
			}
			if (profile.TryGetAvatarHeldVisualProvider(out Func<GameObject> provider2) && provider2 != null)
			{
				ProductPresentationTransform presentationTransform;
				PresentationWorkbenchTransform initialTransform2 = ((profile.TryGetAvatarHeldTransform(out presentationTransform) && presentationTransform != null) ? Convert(presentationTransform) : null);
				ResolveAvatarMetadata(id, out AvatarHand hand, out string animationTrigger, out bool animationUsesBool);
				avatarPreviewContext = new PresentationWorkbenchDefinition.AvatarPreviewContext(provider2, initialTransform2, hand, animationTrigger, PresentationWorkbenchExportKind.ProductTransform, null, null, alignAvatarEquippable: false, animationUsesBool);
			}
			if (profile.GenerateIconFromLooseVisual && profile.TryGetVisualProvider(ProductPresentationContext.Loose, out Func<GameObject> provider3) && provider3 != null)
			{
				ProductPresentationTransform presentationTransform2 = profile.GeneratedIconTransform;
				if (presentationTransform2 == null)
				{
					profile.TryGetVisualTransform(ProductPresentationContext.Loose, out presentationTransform2);
				}
				iconPreviewContext = new PresentationWorkbenchDefinition.IconPreviewContext(provider3, new PresentationWorkbenchTransform(Vector3.zero, presentationTransform2?.LocalEulerAngles ?? Vector3.zero, presentationTransform2?.LocalScale ?? Vector3.one), profile.GeneratedIconSize, profile.FitGeneratedIconToCamera, profile.GeneratedIconCameraFill);
			}
			if (previewContext == null && avatarPreviewContext == null && iconPreviewContext == null)
			{
				return false;
			}
			definition = new PresentationWorkbenchDefinition(id, "Product presentation: " + id, previewContext, avatarPreviewContext, iconPreviewContext);
			return true;
		}

		private static PresentationWorkbenchTransform? ResolveTransform(ProductPresentationProfile profile, ProductPresentationContext context)
		{
			if (profile.TryGetVisualTransform(context, out ProductPresentationTransform presentationTransform) && presentationTransform != null)
			{
				return Convert(presentationTransform);
			}
			return null;
		}

		private static PresentationWorkbenchTransform Convert(ProductPresentationTransform transform)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			return new PresentationWorkbenchTransform(transform.LocalPosition, transform.LocalEulerAngles, transform.LocalScale);
		}

		private static void ResolveAvatarMetadata(string productId, out AvatarHand hand, out string animationTrigger, out bool animationUsesBool)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			hand = AvatarHand.Right;
			animationTrigger = "RightArm_Hold_ClosedHand";
			animationUsesBool = true;
			ItemDefinition definition = ItemManager.GetDefinition(productId);
			object obj;
			if ((object)definition == null)
			{
				obj = null;
			}
			else
			{
				Equippable equippable = definition.S1ItemDefinition.Equippable;
				obj = ((equippable != null) ? ((Component)equippable).GetComponentInChildren<AvatarEquippable>(true) : null);
			}
			AvatarEquippable val = (AvatarEquippable)obj;
			if (!((Object)(object)val == (Object)null))
			{
				hand = (((int)val.Hand != 0) ? AvatarHand.Right : AvatarHand.Left);
				if (!string.IsNullOrWhiteSpace(val.AnimationTrigger))
				{
					animationTrigger = val.AnimationTrigger;
				}
				animationUsesBool = (int)val.TriggerType == 1;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	internal sealed class StaticProductVisualsSetter : ProductVisualsSetter
	{
		public StaticProductVisualsSetter(IntPtr pointer)
			: base(pointer)
		{
		}

		public StaticProductVisualsSetter()
			: base(ClassInjector.DerivedConstructorPointer<StaticProductVisualsSetter>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public override void ApplyVisuals(ProductDefinition productDefinition)
		{
			if ((Object)(object)((ProductVisualsSetter)this).VisualsContainer != (Object)null)
			{
				((Component)((ProductVisualsSetter)this).VisualsContainer).gameObject.SetActive(true);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	internal sealed class StaticStationProductVisualsSetter : ProductVisualsSetter
	{
		public StaticStationProductVisualsSetter(IntPtr pointer)
			: base(pointer)
		{
		}

		public StaticStationProductVisualsSetter()
			: base(ClassInjector.DerivedConstructorPointer<StaticStationProductVisualsSetter>())
		{
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public override void ApplyVisuals(ProductDefinition productDefinition)
		{
			if (!((Object)(object)((ProductVisualsSetter)this).VisualsContainer == (Object)null))
			{
				if ((Object)(object)((ProductVisualsSetter)this).VisualsContainer.parent != (Object)null)
				{
					((Component)((ProductVisualsSetter)this).VisualsContainer.parent).gameObject.SetActive(true);
				}
				((Component)((ProductVisualsSetter)this).VisualsContainer).gameObject.SetActive(true);
			}
		}
	}
}
namespace S1API.Internal.Phone
{
	[RegisterTypeInIl2Cpp]
	internal sealed class AppIconsRedirect : MonoBehaviour
	{
		internal Transform? _realAppIcons;

		private bool _initialized;

		private int _lastMirroredRealCount = -1;

		private readonly HashSet<int> _stubMirrorIconIds = new HashSet<int>();

		private static readonly Log Logger = new Log("AppIconsRedirect");

		public AppIconsRedirect(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Start()
		{
			InitializeStubIcons();
		}

		private void LateUpdate()
		{
			if ((Object)(object)_realAppIcons == (Object)null)
			{
				return;
			}
			if (!_initialized && _realAppIcons.childCount > 0)
			{
				InitializeStubIcons();
				return;
			}
			bool flag = false;
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Transform child = ((Component)this).transform.GetChild(num);
				if (!_stubMirrorIconIds.Contains(((Object)((Component)child).gameObject).GetInstanceID()))
				{
					child.SetParent(_realAppIcons, true);
					flag = true;
				}
			}
			if (_initialized && (flag || _realAppIcons.childCount != _lastMirroredRealCount))
			{
				RepopulateStub();
			}
		}

		private void InitializeStubIcons()
		{
			if ((Object)(object)_realAppIcons == (Object)null)
			{
				Logger.Warning("[AppIconsRedirect] InitializeStubIcons skipped: _realAppIcons is null.");
			}
			else if (!_initialized)
			{
				_initialized = true;
				RepopulateStub();
			}
		}

		private void RepopulateStub()
		{
			if (!((Object)(object)_realAppIcons == (Object)null))
			{
				DestroyMirrorIconsFromStub();
				_stubMirrorIconIds.Clear();
				int childCount = _realAppIcons.childCount;
				for (int i = 0; i < childCount; i++)
				{
					Transform child = _realAppIcons.GetChild(i);
					GameObject val = Object.Instantiate<GameObject>(((Component)child).gameObject, ((Component)this).transform);
					((Object)val).name = ((Object)child).name;
					_stubMirrorIconIds.Add(((Object)val).GetInstanceID());
				}
				_lastMirroredRealCount = _realAppIcons.childCount;
			}
		}

		private void DestroyMirrorIconsFromStub()
		{
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Transform child = ((Component)this).transform.GetChild(num);
				if (_stubMirrorIconIds.Contains(((Object)((Component)child).gameObject).GetInstanceID()))
				{
					Object.Destroy((Object)(object)((Component)child).gameObject);
				}
			}
		}
	}
}
namespace S1API.Internal.Patches
{
	[HarmonyPatch]
	internal static class AvatarAccessoryPatches
	{
		[HarmonyPatch]
		internal static class AvatarApplyAccessorySettingsPatch
		{
			private static MethodBase? TargetMethod()
			{
				return typeof(Avatar).GetMethod("ApplyAccessorySettings", BindingFlags.Instance | BindingFlags.Public);
			}

			private static void Postfix(Avatar __instance)
			{
				try
				{
					object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "appliedAccessories");
					if (obj == null)
					{
						return;
					}
					Type type = obj.GetType();
					if (!type.IsArray)
					{
						return;
					}
					int length = ((Array)obj).Length;
					for (int i = 0; i < length; i++)
					{
						string text = null;
						try
						{
							object value = ((Array)obj).GetValue(i);
							if (value == null)
							{
								continue;
							}
							text = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(value, "AssetPath") as string;
							if (string.IsNullOrEmpty(text))
							{
								continue;
							}
							Dictionary<string, Texture2D> textureReplacements = AccessoryFactory.GetTextureReplacements(text);
							if (textureReplacements != null && textureReplacements.Count != 0)
							{
								GameObject val = null;
								Component val2 = (Component)((value is Component) ? value : null);
								if (val2 != null)
								{
									val = val2.gameObject;
								}
								if (!((Object)(object)val == (Object)null))
								{
									ApplyTexturesToAccessoryInstance(val, textureReplacements);
								}
							}
						}
						catch (Exception ex)
						{
							Logger.Warning("Error applying custom textures to accessory '" + (text ?? "<unknown>") + "': " + ex.Message);
						}
					}
				}
				catch (Exception ex2)
				{
					Logger.Warning("Error applying custom textures to accessories: " + ex2.Message);
				}
			}

			private static void ApplyTexturesToAccessoryInstance(GameObject accessoryObj, Dictionary<string, Texture2D> textureReplacements)
			{
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Expected O, but got Unknown
				if ((Object)(object)accessoryObj == (Object)null || textureReplacements == null || textureReplacements.Count == 0)
				{
					return;
				}
				Il2CppArrayBase<Renderer> componentsInChildren = accessoryObj.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer item in componentsInChildren)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					Il2CppReferenceArray<Material> materials = item.materials;
					bool flag = false;
					for (int i = 0; i < ((Il2CppArrayBase<Material>)(object)materials).Length; i++)
					{
						if ((Object)(object)((Il2CppArrayBase<Material>)(object)materials)[i] == (Object)null)
						{
							continue;
						}
						Material val = new Material(((Il2CppArrayBase<Material>)(object)materials)[i]);
						foreach (KeyValuePair<string, Texture2D> textureReplacement in textureReplacements)
						{
							if (val.HasProperty(textureReplacement.Key))
							{
								val.SetTexture(textureReplacement.Key, (Texture)(object)textureReplacement.Value);
								flag = true;
							}
						}
						if (flag)
						{
							((Il2CppArrayBase<Material>)(object)materials)[i] = val;
						}
					}
					if (flag)
					{
						item.materials = materials;
					}
				}
			}
		}

		private static readonly Log Logger = new Log("AvatarAccessoryPatches");
	}
	[HarmonyPatch]
	internal static class BuildingPatches
	{
		private static readonly Log Logger = new Log("BuildingPatches");

		[HarmonyPatch(typeof(BuildManager), "CreateGridItem")]
		[HarmonyPostfix]
		private static void CreateGridItem_Postfix(GridItem __result, ItemInstance item)
		{
			if ((Object)(object)__result == (Object)null || (Object)(object)((item != null) ? item.Definition : null) == (Object)null)
			{
				return;
			}
			try
			{
				ItemInstance itemInstance = new ItemInstance(item);
				PlaceableStorageEntity component = ((Component)__result).GetComponent<PlaceableStorageEntity>();
				StorageEntity storageEntity = null;
				if ((Object)(object)((component != null) ? component.StorageEntity : null) != (Object)null)
				{
					storageEntity = new StorageEntity(component.StorageEntity, component);
				}
				if (storageEntity != null)
				{
					BuildEventArgs args = new BuildEventArgs(itemInstance, ((Component)__result).gameObject, storageEntity);
					BuildEvents.RaiseGridItemCreated(args);
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in CreateGridItem_Postfix: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(BuildManager), "CreateSurfaceItem")]
		[HarmonyPostfix]
		private static void CreateSurfaceItem_Postfix(SurfaceItem __result, ItemInstance item)
		{
			if ((Object)(object)__result == (Object)null || (Object)(object)((item != null) ? item.Definition : null) == (Object)null)
			{
				return;
			}
			try
			{
				ItemInstance itemInstance = new ItemInstance(item);
				PlaceableStorageEntity component = ((Component)__result).GetComponent<PlaceableStorageEntity>();
				StorageEntity storageEntity = null;
				if ((Object)(object)((component != null) ? component.StorageEntity : null) != (Object)null)
				{
					storageEntity = new StorageEntity(component.StorageEntity, component);
				}
				if (storageEntity != null)
				{
					BuildEventArgs args = new BuildEventArgs(itemInstance, ((Component)__result).gameObject, storageEntity);
					BuildEvents.RaiseSurfaceItemCreated(args);
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in CreateSurfaceItem_Postfix: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(BuildableItem), "InitializeBuildableItem")]
		[HarmonyPostfix]
		private static void InitializeBuildableItem_Postfix(BuildableItem __instance, ItemInstance instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)((instance != null) ? instance.Definition : null) == (Object)null)
			{
				return;
			}
			try
			{
				ItemInstance itemInstance = new ItemInstance(instance);
				PlaceableStorageEntity component = ((Component)__instance).GetComponent<PlaceableStorageEntity>();
				StorageEntity storageEntity = null;
				if ((Object)(object)((component != null) ? component.StorageEntity : null) != (Object)null)
				{
					storageEntity = new StorageEntity(component.StorageEntity, component);
				}
				if (storageEntity != null)
				{
					BuildEventArgs args = new BuildEventArgs(itemInstance, ((Component)__instance).gameObject, storageEntity);
					BuildEvents.RaiseBuildableItemInitialized(args);
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in InitializeBuildableItem_Postfix: " + ex.Message);
			}
		}
	}
	[HarmonyPatch]
	internal static class CallManagerPatches
	{
		[HarmonyPatch(typeof(CallManager), "QueueCall")]
		[HarmonyPrefix]
		private static bool QueueCall_Prefix(PhoneCallData data)
		{
			if (CallManager.IsDispatchingToGameQueue)
			{
				return true;
			}
			CallManager instance = Singleton<CallManager>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			CallInterface instance2 = Singleton<CallInterface>.Instance;
			bool flag = (Object)(object)instance2 != (Object)null && (Object)(object)instance2.ActiveCallData != (Object)null;
			bool flag2 = CallManager.PendingCount > 0;
			object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(instance, "QueuedCallData");
			PhoneCallData val = (PhoneCallData)((obj is PhoneCallData) ? obj : null);
			bool flag3 = (Object)(object)val != (Object)null;
			if (flag || flag2 || flag3)
			{
				CallManager.QueueCall(data);
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(CallManager), "CallCompleted")]
		[HarmonyPostfix]
		private static void CallCompleted_Postfix()
		{
			CallManager.TryProcessQueue();
		}

		[HarmonyPatch(typeof(CallInterface), "Close")]
		[HarmonyPostfix]
		private static void Close_Postfix()
		{
			CallInterface instance = Singleton<CallInterface>.Instance;
			if (!((Object)(object)instance == (Object)null) && !instance.IsOpen && (Object)(object)instance.ActiveCallData == (Object)null)
			{
				CallManager.TryProcessQueue();
			}
		}

		[HarmonyPatch(typeof(CallInterface), "StartCall")]
		[HarmonyPrefix]
		private static void StartCall_Prefix(ref PhoneCallData data)
		{
			if ((Object)(object)data == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)data.CallerID == (Object)null)
				{
					CallerID val = ScriptableObject.CreateInstance<CallerID>();
					val.Name = "Unknown Caller";
					val.ProfilePicture = null;
					data.CallerID = val;
				}
				if (data.Stages != null && ((Il2CppArrayBase<Stage>)(object)data.Stages).Length != 0)
				{
				}
			}
			catch (Exception ex)
			{
				try
				{
					MelonLogger.Warning("[CallManager] StartCall_Prefix failed: " + ex.Message + "\n" + ex.StackTrace);
				}
				catch
				{
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class ChemistryStationPatches
	{
		private sealed class CanvasInjectionState
		{
			public readonly HashSet<string> LoggedRecipeConflicts = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<string> LoggedEntryConflicts = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

			public readonly HashSet<int> ClickBoundEntryIds = new HashSet<int>();
		}

		private static readonly Log Logger = new Log("ChemistryStationPatches");

		private static readonly ConditionalWeakTable<object, CanvasInjectionState> CanvasStateTable = new ConditionalWeakTable<object, CanvasInjectionState>();

		private static readonly MethodInfo? SetSelectedRecipeMethod = AccessTools.Method(typeof(ChemistryStationInterface), "SetSelectedRecipe", (Type[])null, (Type[])null);

		private static bool _loggedRecipeEntriesMissing;

		private static bool _loggedSetSelectedRecipeMissing;

		private static CanvasInjectionState GetCanvasState(object canvas)
		{
			return CanvasStateTable.GetValue(canvas, (object _) => new CanvasInjectionState());
		}

		private static bool TryGetRecipeEntriesList(ChemistryStationInterface canvas, out List<StationRecipeEntry>? entries)
		{
			entries = null;
			if ((Object)(object)canvas == (Object)null)
			{
				return false;
			}
			try
			{
				entries = canvas.recipeEntries;
			}
			catch
			{
				entries = null;
			}
			return entries != null;
		}

		[HarmonyPatch(typeof(ChemistryStationInterface), "Awake")]
		[HarmonyPrefix]
		private static void ChemistryStationAwakePrefix(ChemistryStationInterface __instance)
		{
			AwakePrefix(__instance);
		}

		[HarmonyPatch(typeof(ChemistryStationInterface), "Open")]
		[HarmonyPrefix]
		private static void ChemistryStationOpenPrefix(ChemistryStationInterface __instance, ChemistryStation __0)
		{
			OpenPrefix(__instance, __0);
		}

		private static void AwakePrefix(ChemistryStationInterface __instance)
		{
			try
			{
				InjectRegisteredRecipes(__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] ChemistryStationCanvas.Awake inject failed: " + ex.Message);
			}
		}

		private static void OpenPrefix(ChemistryStationInterface __instance, ChemistryStation __0)
		{
			try
			{
				InjectRegisteredRecipes(__instance);
				EnsureRecipeEntries(__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] ChemistryStationCanvas.Open sync failed: " + ex.Message);
			}
		}

		private static void InjectRegisteredRecipes(ChemistryStationInterface canvas)
		{
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			IReadOnlyList<StationRecipe> allNative = ChemistryStationRecipes.GetAllNative();
			if (allNative.Count == 0)
			{
				return;
			}
			List<StationRecipe> recipes = canvas.Recipes;
			if (recipes == null)
			{
				return;
			}
			CanvasInjectionState canvasState = GetCanvasState(canvas);
			for (int i = 0; i < allNative.Count; i++)
			{
				StationRecipe val = allNative[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text;
				try
				{
					text = val.RecipeID;
				}
				catch
				{
					text = null;
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				StationRecipe val2 = FindRecipeById(recipes, text);
				if ((Object)(object)val2 != (Object)null)
				{
					if (val2 != val && canvasState.LoggedRecipeConflicts.Add(text))
					{
						Logger.Warning("[S1API] Chemistry Station already has a recipe with ID '" + text + "' (different instance). Skipping S1API injection for this ID.");
					}
				}
				else
				{
					recipes.Add(val);
				}
			}
		}

		private static void EnsureRecipeEntries(ChemistryStationInterface canvas)
		{
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			if (!TryGetRecipeEntriesList(canvas, out List<StationRecipeEntry> entries) || entries == null)
			{
				if (!_loggedRecipeEntriesMissing)
				{
					_loggedRecipeEntriesMissing = true;
					Logger.Warning("[S1API] ChemistryStationCanvas recipeEntries could not be resolved. Late recipe UI sync will be skipped.");
				}
				return;
			}
			IReadOnlyList<StationRecipe> allNative = ChemistryStationRecipes.GetAllNative();
			CanvasInjectionState canvasState = GetCanvasState(canvas);
			for (int i = 0; i < allNative.Count; i++)
			{
				StationRecipe val = allNative[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text;
				try
				{
					text = val.RecipeID;
				}
				catch
				{
					text = null;
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				StationRecipeEntry val2 = FindEntryByRecipeId(entries, text);
				if ((Object)(object)val2 != (Object)null)
				{
					StationRecipe recipe = val2.Recipe;
					if (recipe != val && canvasState.LoggedEntryConflicts.Add(text))
					{
						Logger.Warning("[S1API] Chemistry Station UI already has an entry for recipe ID '" + text + "' (different recipe). Skipping entry injection for this ID.");
					}
					continue;
				}
				try
				{
					StationRecipeEntry recipeEntryPrefab = canvas.RecipeEntryPrefab;
					RectTransform recipeContainer = canvas.RecipeContainer;
					if ((Object)(object)recipeEntryPrefab == (Object)null || (Object)(object)recipeContainer == (Object)null)
					{
						return;
					}
					StationRecipeEntry val3 = Object.Instantiate<StationRecipeEntry>(recipeEntryPrefab, (Transform)(object)recipeContainer);
					if (!((Object)(object)val3 == (Object)null))
					{
						val3.AssignRecipe(val);
						entries.Add(val3);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("[S1API] Failed to create StationRecipeEntry for '" + text + "': " + ex.Message);
				}
			}
			EnsureRecipeEntryClickHandlers(canvas, entries, canvasState);
		}

		private static void EnsureRecipeEntryClickHandlers(object canvas, List<StationRecipeEntry> entries, CanvasInjectionState state)
		{
			if (SetSelectedRecipeMethod == null)
			{
				if (!_loggedSetSelectedRecipeMissing)
				{
					_loggedSetSelectedRecipeMissing = true;
					Logger.Warning("[S1API] Chemistry station selection method could not be resolved. Recipe click binding will be skipped.");
				}
				return;
			}
			for (int i = 0; i < entries.Count; i++)
			{
				StationRecipeEntry entry = entries[i];
				if ((Object)(object)entry == (Object)null || (Object)(object)entry.Button == (Object)null)
				{
					continue;
				}
				int instanceID = ((Object)entry).GetInstanceID();
				if (state.ClickBoundEntryIds.Add(instanceID))
				{
					((UnityEvent)entry.Button.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
					{
						SelectRecipeFromClick(canvas, entry);
					}));
				}
			}
		}

		private static void SelectRecipeFromClick(object canvas, StationRecipeEntry entry)
		{
			try
			{
				SetSelectedRecipeMethod?.Invoke(canvas, new object[1] { entry });
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Chemistry Station recipe click selection failed: " + ex.Message);
			}
		}

		private static StationRecipe? FindRecipeById(List<StationRecipe> recipes, string recipeId)
		{
			if (string.IsNullOrWhiteSpace(recipeId))
			{
				return null;
			}
			for (int i = 0; i < recipes.Count; i++)
			{
				StationRecipe val = recipes[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (string.Equals(val.RecipeID, recipeId, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static StationRecipeEntry? FindEntryByRecipeId(List<StationRecipeEntry> entries, string recipeId)
		{
			if (string.IsNullOrWhiteSpace(recipeId))
			{
				return null;
			}
			for (int i = 0; i < entries.Count; i++)
			{
				StationRecipeEntry val = entries[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					StationRecipe recipe = val.Recipe;
					if ((Object)(object)recipe == (Object)null || !string.Equals(recipe.RecipeID, recipeId, StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					return val;
				}
				catch
				{
				}
			}
			return null;
		}

		[HarmonyPatch(typeof(StationRecipe), "get_RecipeID")]
		[HarmonyPrefix]
		private static bool UseRegisteredRecipeId(StationRecipe __instance, ref string __result)
		{
			if (!ChemistryStationRecipes.TryGetRegisteredId(__instance, out string recipeId))
			{
				return true;
			}
			__result = recipeId;
			return false;
		}

		[HarmonyPatch(typeof(StationRecipe), "CalculateQuality")]
		[HarmonyPrefix]
		private static bool UseCustomCalcMethods(StationRecipe __instance, ref EQuality __result)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			string instanceRecipeId;
			try
			{
				instanceRecipeId = __instance.RecipeID;
			}
			catch
			{
				instanceRecipeId = null;
			}
			if (string.IsNullOrWhiteSpace(instanceRecipeId))
			{
				return true;
			}
			ChemistryStationRecipe chemistryStationRecipe = ChemistryStationRecipes.GetAll().FirstOrDefault(delegate(ChemistryStationRecipe r)
			{
				try
				{
					return string.Equals(r.RecipeID, instanceRecipeId, StringComparison.OrdinalIgnoreCase);
				}
				catch
				{
					return false;
				}
			});
			if (chemistryStationRecipe == null)
			{
				return true;
			}
			if (chemistryStationRecipe.QualityCalculationMethod != QualityCalculationMethod.Absolute)
			{
				return true;
			}
			string itemId = chemistryStationRecipe.Product.ItemId;
			ItemDefinition definition = ItemManager.GetDefinition(itemId);
			if (!(definition is global::S1API.Items.Quality.QualityItemDefinition qualityItemDefinition))
			{
				Logger.Warning($"[S1API] Absolute quality calculation method specified for recipe '{chemistryStationRecipe.RecipeID}' but product '{itemId}' is not a quality item. Falling back to default calculation.");
				return true;
			}
			__result = (EQuality)qualityItemDefinition.DefaultQuality;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class ConsolePatches
	{
		private static readonly Log Logger = new Log("Console");

		private static HashSet<string> _addedCommandsToList = new HashSet<string>();

		[HarmonyPatch(typeof(AddItemToInventoryCommand), "Execute")]
		[HarmonyPrefix]
		private static void ResolveGiveItemAlias(List<string> args)
		{
			if (args != null && args.Count != 0 && args[0] != null)
			{
				args[0] = ConsoleItemAliasRegistry.ResolveItemCodeForGive(args[0], ItemManager.IsItemRegistered);
			}
		}

		[HarmonyPatch(typeof(Console), "Awake")]
		[HarmonyPostfix]
		private static void AddCommands(Console __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			List<Type> derivedClasses = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<BaseConsoleCommand>();
			foreach (Type item in derivedClasses)
			{
				Logger.Debug("Found console command: " + item.FullName);
				if (!(item.GetConstructor(Type.EmptyTypes) == null))
				{
					try
					{
						BaseConsoleCommand baseConsoleCommand = (BaseConsoleCommand)Activator.CreateInstance(item);
						CustomConsoleRegistry.Register(baseConsoleCommand);
						Logger.Msg("Registered custom command '" + baseConsoleCommand.CommandWord + "' into managed registry");
					}
					catch (Exception ex)
					{
						Logger.Warning("[Console] Failed to register " + item.FullName + ": " + ex.Message);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Console), "SubmitCommand", new Type[] { typeof(List<string>) })]
		[HarmonyPrefix]
		private static bool RouteCustomCommandsIl2Cpp(List<string> args)
		{
			try
			{
				if (args == null || args.Count == 0)
				{
					return true;
				}
				string text = args[0];
				if (text == null)
				{
					return true;
				}
				string text2 = text.ToLower();
				Dictionary<string, ConsoleCommand> commands = Console.commands;
				if (commands != null && commands.ContainsKey(text2))
				{
					return true;
				}
				if (CustomConsoleRegistry.TryExecute(args))
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("[Console] Custom command routing failed (Il2Cpp): " + ex.Message);
				return true;
			}
		}

		[HarmonyPatch(typeof(CommandListScreen), "Start")]
		[HarmonyPostfix]
		private static void AddCustomCommandEntries(CommandListScreen __instance)
		{
			try
			{
				if (__instance == null)
				{
					return;
				}
				RectTransform commandEntryPrefab = __instance.CommandEntryPrefab;
				RectTransform commandEntryContainer = __instance.CommandEntryContainer;
				if (commandEntryPrefab == null || commandEntryContainer == null)
				{
					return;
				}
				_addedCommandsToList.Clear();
				List<RectTransform> val = ((__instance != null) ? __instance.commandEntries : null);
				foreach (KeyValuePair<string, BaseConsoleCommand> registeredCommand in CustomConsoleRegistry.RegisteredCommands)
				{
					string key = registeredCommand.Key;
					try
					{
						if (_addedCommandsToList.Contains(key) || IsNativeCommand(key))
						{
							continue;
						}
						RectTransform val2 = Object.Instantiate<RectTransform>(commandEntryPrefab, (Transform)(object)commandEntryContainer);
						if (val2 != null)
						{
							Transform obj = ((Transform)val2).Find("Command");
							TextMeshProUGUI val3 = ((obj != null) ? ((Component)obj).GetComponent<TextMeshProUGUI>() : null);
							Transform obj2 = ((Transform)val2).Find("Description");
							TextMeshProUGUI val4 = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
							Transform obj3 = ((Transform)val2).Find("Example");
							TextMeshProUGUI val5 = ((obj3 != null) ? ((Component)obj3).GetComponent<TextMeshProUGUI>() : null);
							if (!((Object)(object)val3 == (Object)null) && !((Object)(object)val4 == (Object)null) && !((Object)(object)val5 == (Object)null))
							{
								((TMP_Text)val3).text = registeredCommand.Value.CommandWord;
								((TMP_Text)val4).text = registeredCommand.Value.CommandDescription;
								((TMP_Text)val5).text = registeredCommand.Value.ExampleUsage;
								val?.Add(val2);
								_addedCommandsToList.Add(key);
							}
						}
					}
					catch (Exception ex)
					{
						Logger.Warning("[Console] Failed to add command '" + key + "' to command list screen: " + ex.Message);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Warning("[Console] Failed to add custom commands to command list screen: " + ex2.Message);
			}
		}

		private static bool IsNativeCommand(string commandKey)
		{
			if (string.IsNullOrWhiteSpace(commandKey))
			{
				return false;
			}
			return Console.commands?.ContainsKey(commandKey) ?? false;
		}
	}
	[HarmonyPatch]
	internal class ContactsAppPatches
	{
		private static readonly Log Logger = new Log("ContactsAppPatches");

		private static bool _startCalled;

		private static bool? _hasCustomNpcTypesCache;

		private static string? GetAssignedNpcId(RelationCircle circle)
		{
			if ((Object)(object)circle == (Object)null)
			{
				return null;
			}
			object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(circle, "AssignedNPC");
			object? obj2 = ((obj is NPC) ? obj : null);
			return ((obj2 != null) ? ((NPC)obj2).ID : null) ?? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(circle, "AssignedNPC_ID") as string) ?? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(circle, "NPCId") as string);
		}

		private static void SetAssignedNpc(RelationCircle circle, NPC npc)
		{
			if (!((Object)(object)circle == (Object)null) && !((Object)(object)npc == (Object)null))
			{
				BaseNPCDataObject dataObject = NPCDataAccess.GetDataObject(npc);
				if ((Object)(object)dataObject != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(circle, "NPC", dataObject);
				}
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(circle, "AssignedNPC_ID", npc.ID);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(circle, "AssignedNPC", npc);
			}
		}

		internal static void ResetState()
		{
			_startCalled = false;
			_hasCustomNpcTypesCache = null;
		}

		private static bool HasCustomNpcTypes()
		{
			if (_hasCustomNpcTypesCache.HasValue)
			{
				return _hasCustomNpcTypesCache.Value;
			}
			try
			{
				Type typeFromHandle = typeof(NPC);
				Assembly baseAssembly = typeFromHandle.Assembly;
				List<Type> derivedClasses = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<NPC>();
				bool flag = derivedClasses.Any((Type t) => t != null && t.Assembly != baseAssembly && !t.IsAbstract);
				_hasCustomNpcTypesCache = flag;
				return flag;
			}
			catch (Exception value)
			{
				Logger.Error($"Error in HasCustomNpcTypes: {value}");
				_hasCustomNpcTypesCache = false;
				return false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ContactsApp), "Start")]
		private static void ContactsApp_Start_Postfix(ContactsApp __instance)
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			if (!(((Scene)(ref activeScene)).name == "Tutorial") && HasCustomNpcTypes() && !_startCalled)
			{
				_startCalled = true;
				MelonCoroutines.Start(WaitForNPCs(__instance));
			}
		}

		private static IEnumerator WaitForNPCs(ContactsApp contactsApp)
		{
			while (!NPCPatches.CustomNpcsReady)
			{
				yield return null;
			}
			List<NPC> allNPCs = NPC.All.ToList();
			List<NPC> customNPCs = allNPCs.Where((NPC n) => n.IsCustomNPC && n.IsPhysical).ToList();
			if (customNPCs.Count == 0)
			{
				yield break;
			}
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)delegate
			{
				Il2CppArrayBase<NPC> allSceneNPCs = Object.FindObjectsOfType<NPC>(true);
				return customNPCs.All((NPC npc) => ((IEnumerable<NPC>)allSceneNPCs).Any((NPC sn) => sn.ID == npc.ID));
			}));
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)(() => customNPCs.All((NPC npc) => npc.RelationshipDataAppliedFromPrefab))));
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)(() => customNPCs.All((NPC npc) => (Object)(object)npc.S1NPC != (Object)null && npc.S1NPC.RelationData != null))));
			yield return null;
			yield return null;
			yield return (object)new WaitUntil(Func<bool>.op_Implicit((Func<bool>)(() => NPCAppearance.MugshotsProcessingComplete)));
			AddRelationCircles(contactsApp);
		}

		private static void AddRelationCircles(ContactsApp contactsApp)
		{
			//IL_0a43: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a75: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a7c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a83: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a88: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a93: Unknown result type (might be due to invalid IL or missing references)
			//IL_080b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_069f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			List<NPC> list = NPC.All.Where((NPC n) => n.IsCustomNPC && IsContactRole(n.GetType())).ToList();
			Dictionary<EMapRegion, RegionUI> dictionary = ((IEnumerable<RegionUI>)contactsApp.RegionUIs).ToDictionary((RegionUI r) => r.Region, (RegionUI r) => r);
			HashSet<string> createdCircleIds = new HashSet<string>();
			foreach (NPC npc in list)
			{
				if ((Object)(object)npc.S1NPC == (Object)null || npc.S1NPC.RelationData == null)
				{
					Log logger = Logger;
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(37, 3);
					defaultInterpolatedStringHandler.AppendLiteral("Skipping NPC ");
					defaultInterpolatedStringHandler.AppendFormatted(npc.ID);
					defaultInterpolatedStringHandler.AppendLiteral(" - S1NPC=");
					defaultInterpolatedStringHandler.AppendFormatted((Object)(object)npc.S1NPC != (Object)null);
					defaultInterpolatedStringHandler.AppendLiteral(", RelationData=");
					NPC s1NPC = npc.S1NPC;
					defaultInterpolatedStringHandler.AppendFormatted(((s1NPC != null) ? s1NPC.RelationData : null) != null);
					logger.Warning(defaultInterpolatedStringHandler.ToStringAndClear());
					continue;
				}
				if (!dictionary.TryGetValue(npc.S1NPC.Region, out var value) || (Object)(object)((value != null) ? value.Container : null) == (Object)null)
				{
					Logger.Warning($"Skipping NPC {npc.ID} - region {npc.S1NPC.Region} not found in regionUIs");
					continue;
				}
				RelationCircle val = ((IEnumerable<RelationCircle>)((Component)value.Container).GetComponentsInChildren<RelationCircle>(true)).FirstOrDefault((Func<RelationCircle, bool>)((RelationCircle c) => GetAssignedNpcId(c) == npc.S1NPC.ID));
				if ((Object)(object)val != (Object)null)
				{
					continue;
				}
				Il2CppArrayBase<RelationCircle> componentsInChildren = ((Component)value.Container).GetComponentsInChildren<RelationCircle>(true);
				RelationCircle val2 = ((IEnumerable<RelationCircle>)componentsInChildren).FirstOrDefault((Func<RelationCircle, bool>)((RelationCircle c) => !createdCircleIds.Contains(GetAssignedNpcId(c) ?? string.Empty))) ?? ((Component)contactsApp.CirclesContainer).GetComponentInChildren<RelationCircle>(true);
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				GameObject val3 = Object.Instantiate<GameObject>(((Component)val2).gameObject, (Transform)(object)value.Container);
				((Object)val3).name = npc.ID;
				RelationCircle component = val3.GetComponent<RelationCircle>();
				SetAssignedNpc(component, npc.S1NPC);
				component.AssignNPC(npc.S1NPC);
				createdCircleIds.Add(npc.S1NPC.ID);
				MethodInfo zoomMethod = typeof(ContactsApp).GetMethod("ZoomToRect", BindingFlags.Instance | BindingFlags.NonPublic);
				RelationCircle cachedCircle = component;
				NPC cachedNPC = npc.S1NPC;
				component.onClicked = Action.op_Implicit((Action)delegate
				{
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					contactsApp.DetailPanel.Open(cachedNPC);
					if (zoomMethod != null)
					{
						zoomMethod.Invoke(contactsApp, new object[1] { cachedCircle.Rect });
					}
					((Transform)contactsApp.SelectionIndicator).position = ((Transform)cachedCircle.Rect).position;
				});
				ApplyRoleIndicators(component, npc.GetType());
			}
			Dictionary<EMapRegion, List<RelationCircle>> dictionary2 = new Dictionary<EMapRegion, List<RelationCircle>>();
			foreach (RegionUI item3 in (Il2CppArrayBase<RegionUI>)(object)contactsApp.RegionUIs)
			{
				List<RelationCircle> value2 = (((Object)(object)item3.Container == (Object)null) ? new List<RelationCircle>() : ((IEnumerable<RelationCircle>)((Component)item3.Container).GetComponentsInChildren<RelationCircle>(true)).ToList());
				dictionary2[item3.Region] = value2;
			}
			HashSet<string> customNpcIds = new HashSet<string>(from n in list
				where (Object)(object)n.S1NPC != (Object)null
				select n.S1NPC.ID);
			Dictionary<EMapRegion, (float, Vector2, Vector2, Vector2, Vector4)> dictionary3 = new Dictionary<EMapRegion, (float, Vector2, Vector2, Vector2, Vector4)>();
			Vector4 item2 = default(Vector4);
			foreach (KeyValuePair<EMapRegion, List<RelationCircle>> item4 in dictionary2)
			{
				List<Vector2> list2 = (from c in item4.Value.Where(delegate(RelationCircle c)
					{
						string assignedNpcId3 = GetAssignedNpcId(c);
						return !string.IsNullOrEmpty(assignedNpcId3) && !customNpcIds.Contains(assignedNpcId3);
					})
					select ((Component)c).GetComponent<RectTransform>().anchoredPosition).ToList();
				if (list2.Count >= 2)
				{
					float num = EstimateGridSpacing(list2);
					Vector2 item = list2[0];
					float num2 = list2.Min((Vector2 p) => p.x) - num;
					float num3 = list2.Max((Vector2 p) => p.x) + num;
					float num4 = list2.Min((Vector2 p) => p.y) - num;
					float num5 = list2.Max((Vector2 p) => p.y) + num;
					((Vector4)(ref item2))..ctor(num2, num3, num4, num5);
					dictionary3[item4.Key] = (num, item, Vector2.right, Vector2.up, item2);
				}
				else
				{
					dictionary3[item4.Key] = (200f, Vector2.zero, Vector2.right, Vector2.up, new Vector4(-1000f, 1000f, -1000f, 1000f));
				}
			}
			try
			{
				Dictionary<NPC, List<NPC>> graph = BuildGraph(list);
				HashSet<string> hashSet = new HashSet<string>();
				foreach (KeyValuePair<EMapRegion, List<RelationCircle>> item5 in dictionary2)
				{
					foreach (RelationCircle item6 in item5.Value)
					{
						string assignedNpcId = GetAssignedNpcId(item6);
						if (!string.IsNullOrEmpty(assignedNpcId) && !customNpcIds.Contains(assignedNpcId))
						{
							hashSet.Add(assignedNpcId);
						}
					}
				}
				List<NPC> source = ComputeInsertionOrder(list, graph, hashSet);
				foreach (IGrouping<EMapRegion, NPC> item7 in from n in source
					group n by n.S1NPC.Region)
				{
					if (!dictionary.TryGetValue(item7.Key, out var value3) || (Object)(object)((value3 != null) ? value3.Container : null) == (Object)null)
					{
						continue;
					}
					Il2CppArrayBase<RelationCircle> componentsInChildren2 = ((Component)value3.Container).GetComponentsInChildren<RelationCircle>(true);
					Dictionary<string, RelationCircle> circleById = (from c in (IEnumerable<RelationCircle>)componentsInChildren2
						where !string.IsNullOrEmpty(GetAssignedNpcId(c))
						group c by GetAssignedNpcId(c)).ToDictionary((IGrouping<string, RelationCircle> g) => g.Key, (IGrouping<string, RelationCircle> g) => g.First());
					Dictionary<RelationCircle, RectTransform> dictionary4 = new Dictionary<RelationCircle, RectTransform>();
					foreach (RelationCircle item8 in componentsInChildren2)
					{
						if (!dictionary4.ContainsKey(item8))
						{
							dictionary4[item8] = ((Component)item8).GetComponent<RectTransform>();
						}
					}
					HashSet<string> hashSet2 = new HashSet<string>();
					foreach (RelationCircle item9 in componentsInChildren2)
					{
						string assignedNpcId2 = GetAssignedNpcId(item9);
						if (!string.IsNullOrEmpty(assignedNpcId2) && !customNpcIds.Contains(assignedNpcId2))
						{
							hashSet2.Add(assignedNpcId2);
						}
					}
					foreach (NPC item10 in item7)
					{
						try
						{
							NPC s1Npc = item10.S1NPC;
							if (!((Object)(object)s1Npc == (Object)null))
							{
								RelationCircle val4 = ((IEnumerable<RelationCircle>)componentsInChildren2).FirstOrDefault((Func<RelationCircle, bool>)((RelationCircle c) => GetAssignedNpcId(c) == s1Npc.ID));
								if ((Object)(object)val4 == (Object)null)
								{
									Logger.Warning("  No circle found for " + s1Npc.ID);
									continue;
								}
								List<(Vector2, Vector2)> allEdges = GetAllEdges(Il2CppArrayBase<RelationCircle>.op_Implicit(componentsInChildren2), dictionary4);
								(float, Vector2, Vector2, Vector2, Vector4) tuple = dictionary3[item7.Key];
								Vector2 anchoredPosition = ComputePlacement(val4, Il2CppArrayBase<RelationCircle>.op_Implicit(componentsInChildren2), circleById, dictionary4, allEdges, tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4, tuple.Item5, hashSet2);
								dictionary4[val4].anchoredPosition = anchoredPosition;
								hashSet2.Add(s1Npc.ID);
							}
						}
						catch (Exception ex)
						{
							Log logger2 = Logger;
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler2 = new DefaultInterpolatedStringHandler(17, 3);
							defaultInterpolatedStringHandler2.AppendLiteral("Error placing ");
							NPC s1NPC2 = item10.S1NPC;
							defaultInterpolatedStringHandler2.AppendFormatted((s1NPC2 != null) ? s1NPC2.ID : null);
							defaultInterpolatedStringHandler2.AppendLiteral(": ");
							defaultInterpolatedStringHandler2.AppendFormatted(ex.Message);
							defaultInterpolatedStringHandler2.AppendLiteral("\n");
							defaultInterpolatedStringHandler2.AppendFormatted(ex.StackTrace);
							logger2.Error(defaultInterpolatedStringHandler2.ToStringAndClear());
						}
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Error("Error in placement phase: " + ex2.Message + "\n" + ex2.StackTrace);
			}
			CreateConnectionLines(contactsApp, list, dictionary);
		}

		internal static bool IsContactRole(Type npcType)
		{
			return NPC.IsCustomerType(npcType) || NPC.IsDealerType(npcType) || NPC.IsSupplierType(npcType);
		}

		private static void CreateConnectionLines(ContactsApp contactsApp, List<NPC> customNPCs, Dictionary<EMapRegion, RegionUI> regionUIs)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)contactsApp.ConnectionPrefab == (Object)null)
			{
				Logger.Warning("ConnectionPrefab is null, cannot create connection lines");
				return;
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (NPC npc in customNPCs)
			{
				NPC s1NPC = npc.S1NPC;
				object obj;
				if (s1NPC == null)
				{
					obj = null;
				}
				else
				{
					NPCRelationData relationData = s1NPC.RelationData;
					obj = ((relationData != null) ? relationData.Connections : null);
				}
				if (obj == null || !regionUIs.TryGetValue(npc.S1NPC.Region, out RegionUI value) || (Object)(object)((value != null) ? value.Container : null) == (Object)null)
				{
					continue;
				}
				Il2CppArrayBase<RelationCircle> componentsInChildren = ((Component)value.Container).GetComponentsInChildren<RelationCircle>(true);
				RelationCircle val = ((IEnumerable<RelationCircle>)componentsInChildren).FirstOrDefault((Func<RelationCircle, bool>)((RelationCircle c) => GetAssignedNpcId(c) == npc.S1NPC.ID));
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Il2CppArrayBase<NPC> items = npc.S1NPC.RelationData.Connections._items;
				foreach (NPC connectedNPC in items)
				{
					if ((Object)(object)connectedNPC == (Object)null || connectedNPC.Region != npc.S1NPC.Region)
					{
						continue;
					}
					string iD = npc.S1NPC.ID;
					string iD2 = connectedNPC.ID;
					string item = ((string.Compare(iD, iD2, StringComparison.Ordinal) < 0) ? (iD + "->" + iD2) : (iD2 + "->" + iD));
					if (hashSet.Contains(item))
					{
						continue;
					}
					RelationCircle val2 = ((IEnumerable<RelationCircle>)componentsInChildren).FirstOrDefault((Func<RelationCircle, bool>)((RelationCircle c) => GetAssignedNpcId(c) == connectedNPC.ID));
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					hashSet.Add(item);
					RectTransform val3 = value.ConnectionsContainer ?? contactsApp.ConnectionsContainer;
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					GameObject val4 = Object.Instantiate<GameObject>(contactsApp.ConnectionPrefab, (Transform)(object)val3);
					RectTransform component = val4.GetComponent<RectTransform>();
					component.anchoredPosition = (val2.Rect.anchoredPosition + val.Rect.anchoredPosition) / 2f;
					Vector3 val5 = Vector2.op_Implicit(val2.Rect.anchoredPosition - val.Rect.anchoredPosition);
					float num = (0f - Mathf.Atan2(val5.x, val5.y)) * 57.29578f;
					((Transform)component).localRotation = Quaternion.Euler(0f, 0f, num);
					component.sizeDelta = new Vector2(component.sizeDelta.x, Vector3.Distance(Vector2.op_Implicit(val2.Rect.anchoredPosition), Vector2.op_Implicit(val.Rect.anchoredPosition)));
					((Object)val4).name = npc.S1NPC.ID + " -> " + connectedNPC.ID;
					Transform obj2 = ((Transform)component).Find("StartButton");
					Button val6 = ((obj2 != null) ? ((Component)obj2).GetComponent<Button>() : null);
					Transform obj3 = ((Transform)component).Find("EndButton");
					Button val7 = ((obj3 != null) ? ((Component)obj3).GetComponent<Button>() : null);
					MethodInfo zoomMethod = typeof(ContactsApp).GetMethod("ZoomToRect", BindingFlags.Instance | BindingFlags.NonPublic);
					if ((Object)(object)val6 != (Object)null && zoomMethod != null)
					{
						RectTransform cachedOtherRect = val2.Rect;
						((UnityEvent)val6.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							zoomMethod.Invoke(contactsApp, new object[1] { cachedOtherRect });
						}));
					}
					if ((Object)(object)val7 != (Object)null && zoomMethod != null)
					{
						RectTransform cachedNpcRect = val.Rect;
						((UnityEvent)val7.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
						{
							zoomMethod.Invoke(contactsApp, new object[1] { cachedNpcRect });
						}));
					}
				}
			}
		}

		private static Dictionary<NPC, List<NPC>> BuildGraph(List<NPC> customs)
		{
			Dictionary<string, NPC> dictionary = new Dictionary<string, NPC>();
			foreach (NPC custom in customs)
			{
				NPC s1NPC = custom.S1NPC;
				if (((s1NPC != null) ? s1NPC.ID : null) != null)
				{
					if (dictionary.ContainsKey(custom.S1NPC.ID))
					{
						Logger.Warning("Duplicate custom NPC ID '" + custom.S1NPC.ID + "' - each mod should use unique IDs. Skipping duplicate.");
					}
					else
					{
						dictionary[custom.S1NPC.ID] = custom;
					}
				}
			}
			Dictionary<NPC, List<NPC>> dictionary2 = customs.ToDictionary((NPC n) => n, (NPC n) => new List<NPC>());
			foreach (NPC custom2 in customs)
			{
				NPCRelationData relationData = custom2.S1NPC.RelationData;
				List<NPC> val = ((relationData != null) ? relationData.Connections : null);
				if (val == null)
				{
					continue;
				}
				Enumerator<NPC> enumerator3 = val.GetEnumerator();
				while (enumerator3.MoveNext())
				{
					NPC current3 = enumerator3.Current;
					if (!((Object)(object)current3 == (Object)null) && current3.ID != null && dictionary.TryGetValue(current3.ID, out var value))
					{
						if (!dictionary2[custom2].Contains(value))
						{
							dictionary2[custom2].Add(value);
						}
						if (!dictionary2[value].Contains(custom2))
						{
							dictionary2[value].Add(custom2);
						}
					}
				}
			}
			return dictionary2;
		}

		private static List<NPC> ComputeInsertionOrder(List<NPC> customs, Dictionary<NPC, List<NPC>> graph, HashSet<string> nativeIds)
		{
			Dictionary<NPC, int> dist = new Dictionary<NPC, int>();
			Queue<NPC> queue = new Queue<NPC>();
			foreach (NPC custom in customs)
			{
				NPCRelationData relationData = custom.S1NPC.RelationData;
				List<NPC> val = ((relationData != null) ? relationData.Connections : null);
				if (val != null && ((IEnumerable<NPC>)val._items).Any((NPC c) => (Object)(object)c != (Object)null && nativeIds.Contains(c.ID)))
				{
					dist[custom] = 0;
					queue.Enqueue(custom);
				}
			}
			if (queue.Count == 0 && customs.Count > 0)
			{
				dist[customs[0]] = 0;
				queue.Enqueue(customs[0]);
			}
			while (queue.Count > 0)
			{
				NPC key = queue.Dequeue();
				int num = dist[key];
				foreach (NPC item in graph[key])
				{
					if (!dist.ContainsKey(item))
					{
						dist[item] = num + 1;
						queue.Enqueue(item);
					}
				}
			}
			return (from n in customs
				orderby dist.ContainsKey(n) ? dist[n] : int.MaxValue, graph[n].Count descending
				select n).ToList();
		}

		private static Vector2 ComputePlacement(RelationCircle circle, RelationCircle[] regionCircles, Dictionary<string, RelationCircle> circleById, Dictionary<RelationCircle, RectTransform> rectTransforms, List<(Vector2, Vector2)> existingEdges, float spacing, Vector2 gridCenter, Vector2 right, Vector2 up, Vector4 nativeBounds, HashSet<string>? placedIds = null)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> connectionPositions = GetConnectionPositions(circle, circleById, rectTransforms, placedIds);
			List<Vector2> list = regionCircles.Select((RelationCircle c) => rectTransforms[c].anchoredPosition).ToList();
			if (list.Count == 0)
			{
				return Vector2.zero;
			}
			Vector2 normalized = ((Vector2)(ref right)).normalized;
			Vector2 normalized2 = ((Vector2)(ref up)).normalized;
			float minDist = spacing * 0.7f;
			if (connectionPositions.Count > 0)
			{
				Vector2 val = Mean(connectionPositions);
				List<Vector2> list2 = new List<Vector2>();
				Vector2 val2 = val - gridCenter;
				float num = Mathf.Round(Vector2.Dot(val2, normalized) / spacing);
				float num2 = Mathf.Round(Vector2.Dot(val2, normalized2) / spacing);
				HashSet<long> hashSet = new HashSet<long>();
				for (int num3 = -6; num3 <= 6; num3++)
				{
					for (int num4 = -3; num4 <= 3; num4++)
					{
						long num5 = (long)(num + (float)num3);
						long num6 = (long)(num2 + (float)num4);
						long item = num5 * 100000 + num6;
						if (hashSet.Add(item))
						{
							Vector2 val3 = gridCenter + (num + (float)num3) * spacing * normalized + (num2 + (float)num4) * spacing * normalized2;
							if (IsPositionFree(val3, list, minDist))
							{
								list2.Add(val3);
							}
						}
					}
				}
				if (list2.Count > 0)
				{
					return PickBestPosition(list2, connectionPositions, list, existingEdges, spacing, nativeBounds);
				}
				return SnapToLattice(val, gridCenter, spacing, right, up);
			}
			int num7 = Mathf.FloorToInt((nativeBounds.x - gridCenter.x) / spacing);
			int num8 = Mathf.CeilToInt((nativeBounds.y - gridCenter.x) / spacing);
			int num9 = Mathf.FloorToInt((nativeBounds.z - gridCenter.y) / spacing);
			int num10 = Mathf.CeilToInt((nativeBounds.w - gridCenter.y) / spacing);
			Vector2 val4 = Mean(list);
			List<Vector2> list3 = new List<Vector2>();
			for (int num11 = num9 - 2; num11 <= num10 + 2; num11++)
			{
				for (int num12 = num7 - 2; num12 <= num8 + 2; num12++)
				{
					Vector2 val5 = gridCenter + (float)num12 * spacing * normalized + (float)num11 * spacing * normalized2;
					if (IsPositionFree(val5, list, minDist))
					{
						list3.Add(val5);
					}
				}
			}
			if (list3.Count > 0)
			{
				List<(Vector2, float)> list4 = new List<(Vector2, float)>();
				foreach (Vector2 item5 in list3)
				{
					int num13 = 0;
					foreach (Vector2 item6 in list)
					{
						float num14 = Vector2.Distance(item5, item6);
						if (num14 < spacing * 1.2f && num14 > 0.01f)
						{
							num13++;
						}
					}
					if (num13 == 0)
					{
						continue;
					}
					float num15 = ((num13 <= 1) ? 0f : ((float)num13 * 100f));
					float num16 = 0f;
					float num17 = spacing * 0.4f;
					foreach (var existingEdge in existingEdges)
					{
						Vector2 item2 = existingEdge.Item1;
						Vector2 item3 = existingEdge.Item2;
						Vector2 val6 = item3 - item2;
						Vector2 val7 = item5 - item2;
						float num18 = Mathf.Clamp01(Vector2.Dot(val7, val6) / Vector2.Dot(val6, val6));
						Vector2 val8 = item2 + num18 * val6;
						float num19 = Vector2.Distance(item5, val8);
						if (num19 < num17)
						{
							num16 += (num17 - num19) / num17 * 500f;
						}
					}
					float num20 = Vector2.Distance(item5, val4);
					float item4 = num15 + num16 + num20 * 2f;
					list4.Add((item5, item4));
				}
				list4.Sort(((Vector2 pos, float score) a, (Vector2 pos, float score) b) => a.score.CompareTo(b.score));
				float bestScore = list4[0].Item2;
				List<Vector2> list5 = (from s in list4
					where s.score <= bestScore + 50f
					select s.pos).ToList();
				int num21 = GetAssignedNpcId(circle)?.GetHashCode() ?? 0;
				int index = Mathf.Abs(num21) % list5.Count;
				return list5[index];
			}
			return gridCenter;
		}

		private static List<Vector2> GetConnectionPositions(RelationCircle circle, Dictionary<string, RelationCircle> circleById, Dictionary<RelationCircle, RectTransform> rectTransforms, HashSet<string>? placedIds = null)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> list = new List<Vector2>();
			HashSet<string> hashSet = new HashSet<string>();
			string assignedNpcId = GetAssignedNpcId(circle);
			NPC assignedNPC = circle.AssignedNPC;
			object obj;
			if (assignedNPC == null)
			{
				obj = null;
			}
			else
			{
				NPCRelationData relationData = assignedNPC.RelationData;
				obj = ((relationData != null) ? relationData.Connections : null);
			}
			List<NPC> val = (List<NPC>)obj;
			if (val != null)
			{
				Enumerator<NPC> enumerator = val.GetEnumerator();
				while (enumerator.MoveNext())
				{
					NPC current = enumerator.Current;
					if (!((Object)(object)current == (Object)null) && !string.IsNullOrEmpty(current.ID) && (placedIds == null || placedIds.Contains(current.ID)) && circleById.TryGetValue(current.ID, out RelationCircle value) && hashSet.Add(current.ID))
					{
						list.Add(rectTransforms[value].anchoredPosition);
					}
				}
			}
			if (!string.IsNullOrEmpty(assignedNpcId))
			{
				foreach (KeyValuePair<string, RelationCircle> item in circleById)
				{
					if (item.Key == assignedNpcId || hashSet.Contains(item.Key) || (placedIds != null && !placedIds.Contains(item.Key)))
					{
						continue;
					}
					NPC assignedNPC2 = item.Value.AssignedNPC;
					object obj2;
					if (assignedNPC2 == null)
					{
						obj2 = null;
					}
					else
					{
						NPCRelationData relationData2 = assignedNPC2.RelationData;
						obj2 = ((relationData2 != null) ? relationData2.Connections : null);
					}
					List<NPC> val2 = (List<NPC>)obj2;
					if (val2 == null)
					{
						continue;
					}
					Enumerator<NPC> enumerator3 = val2.GetEnumerator();
					while (enumerator3.MoveNext())
					{
						NPC current3 = enumerator3.Current;
						if ((Object)(object)current3 != (Object)null && current3.ID == assignedNpcId && hashSet.Add(item.Key))
						{
							list.Add(rectTransforms[item.Value].anchoredPosition);
							break;
						}
					}
				}
			}
			return list;
		}

		private static bool IsPositionFree(Vector2 pos, List<Vector2> existing, float minDist)
		{
			//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_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)
			foreach (Vector2 item in existing)
			{
				if (Vector2.Distance(item, pos) < minDist)
				{
					return false;
				}
			}
			return true;
		}

		private static Vector2 Mean(IEnumerable<Vector2> pts)
		{
			//IL_0052: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			List<Vector2> source = pts.ToList();
			return new Vector2(source.Average((Vector2 p) => p.x), source.Average((Vector2 p) => p.y));
		}

		private static float EstimateGridSpacing(List<Vector2> pts)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (pts.Count < 2)
			{
				return 200f;
			}
			List<float> list = new List<float>();
			for (int i = 0; i < pts.Count; i++)
			{
				for (int j = i + 1; j < pts.Count; j++)
				{
					float num = Mathf.Abs(pts[i].x - pts[j].x);
					float num2 = Mathf.Abs(pts[i].y - pts[j].y);
					if (num > 50f && num2 < 10f)
					{
						list.Add(num);
					}
					if (num2 > 50f && num < 10f)
					{
						list.Add(num2);
					}
				}
			}
			if (list.Count == 0)
			{
				return 200f;
			}
			list.Sort();
			return Mathf.Clamp(list[0], 100f, 300f);
		}

		private static Vector2 SnapToLattice(Vector2 pos, Vector2 origin, float grid, Vector2 right, Vector2 up)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			Vector2 normalized = ((Vector2)(ref right)).normalized;
			Vector2 normalized2 = ((Vector2)(ref up)).normalized;
			Vector2 val = pos - origin;
			float num = Vector2.Dot(val, normalized);
			float num2 = Vector2.Dot(val, normalized2);
			num = Mathf.Round(num / grid) * grid;
			num2 = Mathf.Round(num2 / grid) * grid;
			return origin + num * normalized + num2 * normalized2;
		}

		private static List<(Vector2 from, Vector2 to)> GetAllEdges(RelationCircle[] regionCircles, Dictionary<RelationCircle, RectTransform> rectTransforms)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			List<(Vector2, Vector2)> list = new List<(Vector2, Vector2)>();
			Dictionary<string, RelationCircle> dictionary = regionCircles.Where((RelationCircle c) => !string.IsNullOrEmpty(GetAssignedNpcId(c))).ToDictionary((RelationCircle c) => GetAssignedNpcId(c), (RelationCircle c) => c);
			foreach (RelationCircle val in regionCircles)
			{
				NPC assignedNPC = val.AssignedNPC;
				object obj;
				if (assignedNPC == null)
				{
					obj = null;
				}
				else
				{
					NPCRelationData relationData = assignedNPC.RelationData;
					obj = ((relationData != null) ? relationData.Connections : null);
				}
				if (obj == null)
				{
					continue;
				}
				Vector2 anchoredPosition = rectTransforms[val].anchoredPosition;
				Enumerator<NPC> enumerator = val.AssignedNPC.RelationData.Connections.GetEnumerator();
				while (enumerator.MoveNext())
				{
					NPC current = enumerator.Current;
					if (!((Object)(object)current == (Object)null) && !string.IsNullOrEmpty(current.ID) && dictionary.TryGetValue(current.ID, out var value))
					{
						Vector2 anchoredPosition2 = rectTransforms[value].anchoredPosition;
						list.Add((anchoredPosition, anchoredPosition2));
					}
				}
			}
			return list;
		}

		private static bool LineSegmentsIntersect(Vector2 a1, Vector2 a2, Vector2 b1, Vector2 b2)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_005f: 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_006d: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			float num = (a2.x - a1.x) * (b2.y - b1.y) - (a2.y - a1.y) * (b2.x - b1.x);
			if (Mathf.Abs(num) < 0.001f)
			{
				return false;
			}
			float num2 = ((b1.x - a1.x) * (b2.y - b1.y) - (b1.y - a1.y) * (b2.x - b1.x)) / num;
			float num3 = ((b1.x - a1.x) * (a2.y - a1.y) - (b1.y - a1.y) * (a2.x - a1.x)) / num;
			return num2 >= 0f && num2 <= 1f && num3 >= 0f && num3 <= 1f;
		}

		private static int CountCrossings(Vector2 newPos, List<Vector2> anchors, List<(Vector2, Vector2)> existingEdges)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_005a: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (Vector2 anchor in anchors)
			{
				foreach (var (val, val2) in existingEdges)
				{
					if (!(Vector2.Distance(val, newPos) < 1f) && !(Vector2.Distance(val2, newPos) < 1f) && !(Vector2.Distance(val, anchor) < 1f) && !(Vector2.Distance(val2, anchor) < 1f) && LineSegmentsIntersect(newPos, anchor, val, val2))
					{
						num++;
					}
				}
			}
			return num;
		}

		private static float CalculateCrowdingPenalty(Vector2 pos, List<Vector2> allPositions, float spacing)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			float num2 = spacing * 1.25f;
			foreach (Vector2 allPosition in allPositions)
			{
				float num3 = Vector2.Distance(pos, allPosition);
				if (num3 < num2 && num3 > 0.01f)
				{
					num += Mathf.Pow((num2 - num3) / num2, 2f) * 100f;
				}
			}
			return num;
		}

		private static Vector2 PickBestPosition(List<Vector2> candidates, List<Vector2> anchors, List<Vector2> allPositions, List<(Vector2, Vector2)> existingEdges, float spacing, Vector4 nativeBounds)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			float num = float.MaxValue;
			Vector2 result = candidates[0];
			foreach (Vector2 candidate in candidates)
			{
				int num2 = CountCrossings(candidate, anchors, existingEdges);
				float num3 = anchors.Average((Vector2 a) => Vector2.Distance(candidate, a));
				float num4 = CalculateCrowdingPenalty(candidate, allPositions, spacing);
				float num5 = CalculateCircleIntersectionPenalty(candidate, anchors, allPositions, spacing);
				float num6 = CalculateOutOfBoundsPenalty(candidate, nativeBounds, spacing);
				float num7 = num3 * 10f + (float)num2 * 200f + num5 * 1f + num4 * 0.5f + num6;
				if (num7 < num)
				{
					num = num7;
					result = candidate;
				}
			}
			return result;
		}

		private static float CalculateOutOfBoundsPenalty(Vector2 pos, Vector4 nativeBounds, float spacing)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (pos.x < nativeBounds.x)
			{
				num += Mathf.Pow((nativeBounds.x - pos.x) / spacing, 2f);
			}
			else if (pos.x > nativeBounds.y)
			{
				num += Mathf.Pow((pos.x - nativeBounds.y) / spacing, 2f);
			}
			if (pos.y < nativeBounds.z)
			{
				num += Mathf.Pow((nativeBounds.z - pos.y) / spacing, 2f) * 2f;
			}
			else if (pos.y > nativeBounds.w)
			{
				num += Mathf.Pow((pos.y - nativeBounds.w) / spacing, 2f);
			}
			return num * 500f;
		}

		private static float CalculateCircleIntersectionPenalty(Vector2 newPos, List<Vector2> anchors, List<Vector2> allPositions, float spacing)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			float num2 = spacing * 0.25f;
			float num3 = num2 * 1.3f;
			foreach (Vector2 anchor in anchors)
			{
				foreach (Vector2 allPosition in allPositions)
				{
					if (!(Vector2.Distance(allPosition, newPos) < 0.8f) && !(Vector2.Distance(allPosition, anchor) < 0.8f))
					{
						float num4 = DistanceFromPointToLineSegment(allPosition, newPos, anchor);
						if (num4 < num3)
						{
							float num5 = (num3 - num4) / num3;
							num += Mathf.Pow(num5, 2f) * 500f;
						}
					}
				}
			}
			return num;
		}

		private static float DistanceFromPointToLineSegment(Vector2 point, Vector2 lineStart, Vector2 lineEnd)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			Vector2 val = lineEnd - lineStart;
			float magnitude = ((Vector2)(ref val)).magnitude;
			if (magnitude < 0.001f)
			{
				return Vector2.Distance(point, lineStart);
			}
			Vector2 val2 = val / magnitude;
			Vector2 val3 = point - lineStart;
			float num = Vector2.Dot(val3, val2);
			num = Mathf.Clamp(num, 0f, magnitude);
			Vector2 val4 = lineStart + val2 * num;
			return Vector2.Distance(point, val4);
		}

		private static void ApplyRoleIndicators(RelationCircle circle, Type npcType)
		{
			if (!((Object)(object)circle == (Object)null) && !(npcType == null))
			{
				ApplyRoleIndicators(npcType, delegate(string indicatorName, bool isActive)
				{
					SetRoleIndicator(circle, indicatorName, isActive);
				});
			}
		}

		internal static void ApplyRoleIndicators(Type npcType, Action<string, bool> setRoleIndicator)
		{
			if (!(npcType == null) && setRoleIndicator != null)
			{
				(bool, bool) roleIndicators = GetRoleIndicators(npcType);
				setRoleIndicator("DealerIndicator", roleIndicators.Item1);
				setRoleIndicator("SupplierIndicator", roleIndicators.Item2);
			}
		}

		internal static (bool IsDealer, bool IsSupplier) GetRoleIndicators(Type npcType)
		{
			if (npcType == null)
			{
				return (IsDealer: false, IsSupplier: false);
			}
			return (IsDealer: NPC.IsDealerType(npcType), IsSupplier: NPC.IsSupplierType(npcType));
		}

		private static void SetRoleIndicator(RelationCircle circle, string indicatorName, bool isActive)
		{
			Transform transform = ((Component)circle).transform;
			Transform val = ((transform != null) ? transform.Find(indicatorName) : null);
			if (!((Object)(object)val == (Object)null))
			{
				((Component)val).gameObject.SetActive(isActive);
			}
		}
	}
	[HarmonyPatch]
	internal static class CustomProductManifestLoadPatches
	{
		[HarmonyPatch(typeof(LoadManager), "StartGame")]
		[HarmonyPrefix]
		private static void StartGamePrefix()
		{
			CustomProductManifestRuntime.BeginHostSession();
		}

		[HarmonyPatch(typeof(LoadManager), "LoadAsClient")]
		[HarmonyPrefix]
		private static void LoadAsClientPrefix()
		{
			CustomProductManifestRuntime.BeginClientSession();
		}

		[HarmonyPatch(typeof(LoadManager), "ExitToMenu")]
		[HarmonyPrefix]
		private static void ExitToMenuPrefix()
		{
			CustomProductManifestRuntime.EndHostSession();
			CustomProductManifestRuntime.EndClientSession();
		}

		[HarmonyPatch(typeof(LoadManager), "Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix()
		{
			CustomProductManifestRuntime.Tick();
		}
	}
	[HarmonyPatch]
	internal static class CustomProductManifestPlayerPatches
	{
		[HarmonyPatch(typeof(Player), "RequestPlayerData")]
		[HarmonyPrefix]
		private static bool RequestPlayerDataPrefix(Player __instance, string playerCode)
		{
			return CustomProductManifestRuntime.AuthorizeClientPlayerDataRequest(delegate
			{
				__instance.RequestPlayerData(playerCode);
			});
		}

		[HarmonyPatch(typeof(Player), "ReceivePlayerData")]
		[HarmonyPrefix]
		private static bool ReceivePlayerDataPrefix(object __instance, object[] __args, MethodBase __originalMethod)
		{
			if (__args.Length != 0)
			{
				object obj = __args[0];
				NetworkConnection val = (NetworkConnection)((obj is NetworkConnection) ? obj : null);
				if (val != null)
				{
					return CustomProductManifestRuntime.AuthorizeHostPlayerData(__instance, val, __args, __originalMethod);
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class CustomProductSavePatches
	{
		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
		[HarmonyPostfix]
		private static void SavePostfix(string saveFolderPath)
		{
			try
			{
				CustomProductSavePersistence.Save(saveFolderPath);
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[CustomProductSave] save failed: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(LoadManager), "QueueLoadRequest")]
		[HarmonyPrefix]
		private static void RestorePrefix()
		{
			CustomProductSavePersistence.RestoreBeforeBaseLoaders(Singleton<LoadManager>.Instance);
			CustomProductManifestRuntime.FinalizeHostManifestAfterDescriptorRestore();
		}
	}
	[HarmonyPatch]
	internal static class DealerManagementAppPatches
	{
		private static readonly Log Logger = new Log("DealerManagementAppPatches");

		private static void RefreshAndSyncDropdown(DealerManagementApp instance)
		{
			Dealer selectedDealer = instance.SelectedDealer;
			typeof(DealerManagementApp).GetMethod("RefreshDropdown", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(instance, null);
			if ((Object)(object)selectedDealer == (Object)null)
			{
				return;
			}
			List<Dealer> dealers = instance.dealers;
			if (dealers == null)
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < dealers.Count; i++)
			{
				if ((Object)(object)dealers[i] == (Object)(object)selectedDealer)
				{
					num = i;
					break;
				}
			}
			if (num >= 0)
			{
				DropdownUI dropdown = instance._dropdown;
				if (dropdown != null)
				{
					((Dropdown)dropdown).SetValueWithoutNotify(num);
				}
			}
		}

		[HarmonyPatch(typeof(DealerManagementApp), "SetOpen")]
		[HarmonyPostfix]
		private static void SetOpen_Postfix(DealerManagementApp __instance, bool open)
		{
			if (!open)
			{
				return;
			}
			try
			{
				RefreshAndSyncDropdown(__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to refresh dealer dropdown on open: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(DealerManagementApp), "Refresh")]
		[HarmonyPostfix]
		private static void Refresh_Postfix(DealerManagementApp __instance)
		{
			try
			{
				RefreshAndSyncDropdown(__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to refresh dealer dropdown on refresh: " + ex.Message);
			}
		}
	}
	[HarmonyPatch]
	internal static class DeliveryPatches
	{
		private readonly struct StatusPatchState
		{
			internal DeliveryStatus PreviousStatus { get; }

			internal bool Deferred { get; }

			internal StatusPatchState(DeliveryStatus previousStatus, bool deferred)
			{
				PreviousStatus = previousStatus;
				Deferred = deferred;
			}
		}

		private static readonly Log Logger = new Log("DeliveryPatches");

		[HarmonyPatch(typeof(DeliveryApp), "SetIsAvailable")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool DeliveryAppSetIsAvailablePrefix(DeliveryApp __instance, ShopInterface matchingShop, bool available)
		{
			if (!SupplierRuntimeCoordinator.IsOwnedShop(matchingShop))
			{
				return true;
			}
			if (!SupplierRuntimeCoordinator.EnsureDeliveryEntry(__instance, matchingShop, available))
			{
				Logger.Warning("Delivery UI could not be provisioned for custom supplier shop '" + ((matchingShop != null) ? matchingShop.ShopName : null) + "'.");
			}
			return false;
		}

		[HarmonyPatch(typeof(DeliveryApp), "CreateDeliveryStatusDisplay")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool DeliveryAppCreateDeliveryStatusDisplayPrefix(DeliveryApp __instance, DeliveryInstance __0)
		{
			return !SupplierRuntimeCoordinator.TryDeferDeliveryStatusDisplay(__instance, __0);
		}

		[HarmonyPatch(typeof(DeliveryInstance), "SetStatus")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool DeliverySetStatusPrefix(DeliveryInstance __instance, EDeliveryStatus status, out StatusPatchState __state)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			DeliveryStatus previousStatus = DeliveryEventBridge.BeforeStatusChange(__instance);
			bool flag = SupplierDeliveryRecovery.TryDeferStatus(__instance, status);
			__state = new StatusPatchState(previousStatus, flag);
			return !flag;
		}

		[HarmonyPatch(typeof(DeliveryInstance), "SetStatus")]
		[HarmonyPostfix]
		private static void DeliverySetStatusPostfix(DeliveryInstance __instance, StatusPatchState __state)
		{
			if (!__state.Deferred)
			{
				DeliveryEventBridge.AfterStatusChange(__instance, __state.PreviousStatus);
			}
		}

		[HarmonyPatch(typeof(VehicleManager), "LoadVehicle")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool VehicleManagerLoadVehiclePrefix(VehicleData data, string path)
		{
			return !SupplierDeliveryRecovery.TryDeferVehicleLoad(data, path);
		}
	}
	[HarmonyPatch]
	internal static class EquippableAvatarPatches
	{
		[HarmonyPatch(typeof(Equippable), "Equip")]
		[HarmonyPostfix]
		private static void Equip_Postfix(Equippable __instance)
		{
			if (TryGetNonViewmodelAvatar(__instance, out AvatarEquippable avatar))
			{
				Player local = Player.Local;
				if (local != null)
				{
					local.SendEquippable_Networked(avatar.AssetPath);
				}
			}
		}

		[HarmonyPatch(typeof(Equippable), "Unequip")]
		[HarmonyPrefix]
		private static void Unequip_Prefix(Equippable __instance)
		{
			if (TryGetNonViewmodelAvatar(__instance, out AvatarEquippable _))
			{
				Player local = Player.Local;
				if (local != null)
				{
					local.SendEquippable_Networked(string.Empty);
				}
			}
		}

		private static bool TryGetNonViewmodelAvatar(Equippable equippable, out AvatarEquippable avatar)
		{
			avatar = null;
			if ((Object)(object)equippable == (Object)null || CrossType.Is<Equippable_Viewmodel>((object)equippable, out Equippable_Viewmodel _))
			{
				return false;
			}
			avatar = ((Component)equippable).GetComponentInChildren<AvatarEquippable>(true);
			return (Object)(object)avatar != (Object)null && !string.IsNullOrWhiteSpace(avatar.AssetPath);
		}
	}
	[HarmonyPatch]
	internal static class GenericSaveablesPatches
	{
		private static bool sameSession;

		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
		[HarmonyPostfix]
		private static void SaveManager_Save_Postfix(string saveFolderPath)
		{
			try
			{
				SaveManager instance = Singleton<SaveManager>.Instance;
				string text = "Modded";
				string text2 = Path.Combine("Modded", "Saveables");
				if (!instance.ApprovedBaseLevelPaths.Contains(text))
				{
					instance.ApprovedBaseLevelPaths.Add(text);
				}
				if (!instance.ApprovedBaseLevelPaths.Contains(text2))
				{
					instance.ApprovedBaseLevelPaths.Add(text2);
				}
				string text3 = Path.Combine(saveFolderPath, "Modded", "Saveables");
				Directory.CreateDirectory(text3);
				foreach (Saveable registeredSaveable in SaveableAutoRegistry.GetRegisteredSaveables())
				{
					List<string> extraSaveables = new List<string>();
					string name = registeredSaveable.GetType().Name;
					string text4 = Path.Combine(text3, name);
					Directory.CreateDirectory(text4);
					registeredSaveable.SaveInternal(text4, ref extraSaveables);
				}
			}
			catch (Exception ex)
			{
				try
				{
					MelonLogger.Warning("[Saveables] SaveManager_Save_Postfix failed: " + ex.Message + "\n" + ex.StackTrace);
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(LoadManager), "QueueLoadRequest")]
		[HarmonyPrefix]
		private static void BeforeBaseLoaders(LoadRequest request)
		{
			try
			{
				LoadManager lm = Singleton<LoadManager>.Instance;
				if ((Object)(object)lm == (Object)null || string.IsNullOrEmpty(lm.LoadedGameFolderPath) || sameSession)
				{
					return;
				}
				string path = Path.Combine(lm.LoadedGameFolderPath, "Modded", "Saveables");
				foreach (Saveable registeredSaveable in SaveableAutoRegistry.GetRegisteredSaveables())
				{
					Saveable saveable = registeredSaveable;
					if (saveable.LoadOrder == SaveableLoadOrder.BeforeBaseGame)
					{
						string name = saveable.GetType().Name;
						string text = Path.Combine(path, name);
						if (Directory.Exists(text))
						{
							saveable.LoadInternal(text);
						}
						else
						{
							global::S1API.Utils.EventHelper.AddListener(InitializeOnLoadComplete, lm.onLoadComplete);
						}
					}
					void InitializeOnLoadComplete()
					{
						try
						{
							global::S1API.Utils.EventHelper.RemoveListener(InitializeOnLoadComplete, lm.onLoadComplete);
							((IRegisterable)saveable).CreateInternal();
						}
						catch (Exception ex2)
						{
							try
							{
								MelonLogger.Warning("[Saveables] InitializeOnLoadComplete (Before) failed: " + ex2.Message + "\n" + ex2.StackTrace);
							}
							catch
							{
							}
						}
					}
				}
				sameSession = true;
				global::S1API.Utils.EventHelper.AddListener(ClearLockOnLoadComplete, lm.onLoadComplete);
				void ClearLockOnLoadComplete()
				{
					try
					{
						global::S1API.Utils.EventHelper.RemoveListener(ClearLockOnLoadComplete, lm.onLoadComplete);
						sameSession = false;
					}
					catch (Exception ex2)
					{
						try
						{
							MelonLogger.Warning("[Saveables] ClearLockOnLoadComplete failed: " + ex2.Message + "\n" + ex2.StackTrace);
						}
						catch
						{
						}
					}
				}
			}
			catch (Exception ex)
			{
				try
				{
					MelonLogger.Warning("[Saveables] BeforeBaseLoaders failed: " + ex.Message + "\n" + ex.StackTrace);
				}
				catch
				{
				}
			}
		}

		[HarmonyPatch(typeof(NPCsLoader), "Load")]
		[HarmonyPostfix]
		private static void AfterBaseLoaders(string mainPath)
		{
			try
			{
				string path = Path.Combine(Singleton<LoadManager>.Instance.LoadedGameFolderPath, "Modded", "Saveables");
				foreach (Saveable registeredSaveable in SaveableAutoRegistry.GetRegisteredSaveables())
				{
					Saveable saveable = registeredSaveable;
					LoadManager lm;
					if (saveable.LoadOrder == SaveableLoadOrder.AfterBaseGame)
					{
						string name = saveable.GetType().Name;
						string text = Path.Combine(path, name);
						if (Directory.Exists(text))
						{
							saveable.LoadInternal(text);
							continue;
						}
						lm = Singleton<LoadManager>.Instance;
						global::S1API.Utils.EventHelper.AddListener(InitializeOnLoadComplete, lm.onLoadComplete);
					}
					void InitializeOnLoadComplete()
					{
						try
						{
							global::S1API.Utils.EventHelper.RemoveListener(InitializeOnLoadComplete, lm.onLoadComplete);
							((IRegisterable)saveable).CreateInternal();
						}
						catch (Exception ex2)
						{
							try
							{
								MelonLogger.Warning("[Saveables] InitializeOnLoadComplete (After) failed: " + ex2.Message + "\n" + ex2.StackTrace);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				try
				{
					MelonLogger.Warning("[Saveables] AfterBaseLoaders failed: " + ex.Message + "\n" + ex.StackTrace);
				}
				catch
				{
				}
			}
		}
	}
	[HarmonyPatch]
	internal class GraffitiPatches
	{
		private static readonly Log Logger = new Log("GraffitiPatches");

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

		[HarmonyPatch(typeof(WorldSpraySurface), "SetFinalized")]
		[HarmonyPostfix]
		private static void WorldSpraySurface_SetFinalized_Postfix(WorldSpraySurface __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)__instance == (Object)null))
				{
					string item = ((object)__instance.GUID/*cast due to .constrained prefix*/).ToString();
					if (!_processedSurfaces.Contains(item) && __instance.HasEverBeenMarkedByPlayer && ((SpraySurface)__instance).DrawingStrokeCount > 0)
					{
						_processedSurfaces.Add(item);
						SpraySurface spraySurface = new SpraySurface(__instance);
						GraffitiEvents.OnGraffitiRewarded(spraySurface);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in SetFinalized patch: " + ex.Message);
				Logger.Error("StackTrace: " + ex.StackTrace);
			}
		}
	}
	[HarmonyPatch]
	internal static class GrowContainerPatches
	{
		private static readonly Log Logger = new Log("GrowContainerPatches");

		[HarmonyPatch(typeof(GrowContainer), "InitializeGridItem", new Type[]
		{
			typeof(ItemInstance),
			typeof(Grid),
			typeof(Vector2),
			typeof(int),
			typeof(string)
		})]
		[HarmonyPrefix]
		private static void GrowContainer_InitializeGridItem_Prefix(GrowContainer __instance)
		{
			try
			{
				ApplyRegisteredAllowedAdditives(__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Failed to apply registered allowed additives: " + ex.Message);
			}
		}

		internal static void ApplyRegisteredAllowedAdditives(GrowContainer container)
		{
			if ((Object)(object)container == (Object)null)
			{
				return;
			}
			IReadOnlyList<string> allowedAdditiveIdsInternal = GrowContainerAdditives.GetAllowedAdditiveIdsInternal();
			if (allowedAdditiveIdsInternal == null || allowedAdditiveIdsInternal.Count == 0)
			{
				return;
			}
			for (int i = 0; i < allowedAdditiveIdsInternal.Count; i++)
			{
				string text = allowedAdditiveIdsInternal[i];
				if (string.IsNullOrWhiteSpace(text))
				{
					continue;
				}
				AdditiveDefinition additive;
				try
				{
					ItemDefinition item = Registry.GetItem(text);
					if ((Object)(object)item == (Object)null || !CrossType.Is<AdditiveDefinition>((object)item, out AdditiveDefinition result))
					{
						GrowContainerAdditives.WarnMissing(text, "[S1API] GrowContainerAdditives: additive '" + text + "' was not found or is not an AdditiveDefinition; skipping.");
						continue;
					}
					additive = result;
				}
				catch (Exception ex)
				{
					GrowContainerAdditives.WarnMissing(text, "[S1API] GrowContainerAdditives: could not resolve additive '" + text + "' (registry unavailable yet?): " + ex.Message);
					continue;
				}
				if (!ContainsAdditive(container, text))
				{
					AppendAdditive(container, additive);
				}
			}
		}

		private static bool ContainsAdditive(GrowContainer container, string additiveId)
		{
			Il2CppReferenceArray<AdditiveDefinition> allowedAdditives = container.AllowedAdditives;
			int num = ((Il2CppArrayBase<AdditiveDefinition>)(object)allowedAdditives)?.Length ?? 0;
			for (int i = 0; i < num; i++)
			{
				AdditiveDefinition val = ((Il2CppArrayBase<AdditiveDefinition>)(object)allowedAdditives)[i];
				if ((Object)(object)val != (Object)null && string.Equals(((BaseItemDefinition)val).ID, additiveId, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static void AppendAdditive(GrowContainer container, AdditiveDefinition additive)
		{
			if (!((Object)(object)additive == (Object)null))
			{
				Il2CppReferenceArray<AdditiveDefinition> allowedAdditives = container.AllowedAdditives;
				int num = ((Il2CppArrayBase<AdditiveDefinition>)(object)allowedAdditives)?.Length ?? 0;
				AdditiveDefinition[] array = (AdditiveDefinition[])(object)new AdditiveDefinition[num + 1];
				for (int i = 0; i < num; i++)
				{
					array[i] = ((Il2CppArrayBase<AdditiveDefinition>)(object)allowedAdditives)[i];
				}
				array[num] = additive;
				container.AllowedAdditives = new Il2CppReferenceArray<AdditiveDefinition>(array);
			}
		}
	}
	[HarmonyPatch(typeof(HomeScreen), "Start")]
	internal static class HomeScreen_Start_Patch
	{
		private static readonly Log Logger = new Log("PhoneApp");

		private static void Postfix(HomeScreen __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (!string.Equals(((Scene)(ref activeScene)).name, "Main", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			List<Type> derivedClasses = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<global::S1API.PhoneApp.PhoneApp>();
			foreach (Type item in derivedClasses)
			{
				Logger.Debug("Found phone app: " + item.FullName);
				if (!(item.GetConstructor(Type.EmptyTypes) == null))
				{
					try
					{
						global::S1API.PhoneApp.PhoneApp phoneApp = (global::S1API.PhoneApp.PhoneApp)Activator.CreateInstance(item);
						((IRegisterable)phoneApp).CreateInternal();
						phoneApp.SpawnUI(__instance);
						phoneApp.SpawnIcon(__instance);
					}
					catch (Exception ex)
					{
						Logger.Warning("[PhoneApp] Failed to register " + item.FullName + ": " + ex.Message);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(HomeScreen), "Start")]
	internal static class HomeScreenScrollPatch
	{
		private static readonly Log Logger = new Log("HomeScreenScroll");

		private static bool _isInitialized = false;

		private static void Postfix(HomeScreen __instance)
		{
			if (_isInitialized || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				SetupScrollableGrid(__instance);
				_isInitialized = true;
			}
			catch (Exception)
			{
			}
		}

		internal static void ResetInitializationState()
		{
			_isInitialized = false;
		}

		private static void SetupScrollableGrid(HomeScreen homeScreen)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0152: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Expected O, but got Unknown
			Transform val = ((Component)homeScreen).transform.Find("AppIcons");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)val).gameObject;
			Transform parent = val.parent;
			if ((Object)(object)parent != (Object)null && ((Object)parent).name == "Viewport")
			{
				return;
			}
			Transform parent2 = val.parent;
			RectTransform component = gameObject.GetComponent<RectTransform>();
			GridLayoutGroup component2 = gameObject.GetComponent<GridLayoutGroup>();
			if (!((Object)(object)component2 == (Object)null))
			{
				GameObject val2 = new GameObject("AppIconsScrollView");
				val2.transform.SetParent(parent2, false);
				val2.transform.SetSiblingIndex(val.GetSiblingIndex());
				val2.AddComponent<RectTransform>();
				RectTransform component3 = val2.GetComponent<RectTransform>();
				component3.anchorMin = new Vector2(0.5f, 0.5f);
				component3.anchorMax = new Vector2(0.5f, 0.5f);
				component3.pivot = new Vector2(0.5f, 0.5f);
				component3.sizeDelta = new Vector2(620f, 1000f);
				GameObject val3 = new GameObject("Viewport");
				val3.transform.SetParent(val2.transform, false);
				val3.AddComponent<RectTransform>();
				RectTransform component4 = val3.GetComponent<RectTransform>();
				component4.anchorMin = Vector2.zero;
				component4.anchorMax = Vector2.one;
				component4.sizeDelta = Vector2.zero;
				component4.offsetMax = new Vector2(-20f, 0f);
				Image val4 = val3.AddComponent<Image>();
				((Graphic)val4).color = new Color(1f, 1f, 1f, 0.01f);
				val3.AddComponent<Mask>();
				val.SetParent(val3.transform, false);
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0.5f, 1f);
				component.anchoredPosition = Vector2.zero;
				component.sizeDelta = Vector2.zero;
				ContentSizeFitter val5 = gameObject.GetComponent<ContentSizeFitter>();
				if ((Object)(object)val5 == (Object)null)
				{
					val5 = gameObject.AddComponent<ContentSizeFitter>();
				}
				val5.verticalFit = (FitMode)2;
				val5.horizontalFit = (FitMode)0;
				component2.cellSize = new Vector2(190f, 190f);
				component2.spacing = new Vector2(15f, 60f);
				((LayoutGroup)component2).padding = new RectOffset(15, 15, 20, 40);
				component2.startCorner = (Corner)0;
				component2.startAxis = (Axis)0;
				((LayoutGroup)component2).childAlignment = (TextAnchor)1;
				component2.constraint = (Constraint)1;
				component2.constraintCount = 3;
				Scrollbar verticalScrollbar = CreateScrollbar(val2.transform);
				ScrollRect val6 = val2.AddComponent<ScrollRect>();
				val6.content = component;
				val6.viewport = component4;
				val6.verticalScrollbar = verticalScrollbar;
				val6.horizontal = false;
				val6.vertical = true;
				val6.movementType = (MovementType)1;
				val6.elasticity = 0.08f;
				val6.inertia = true;
				val6.decelerationRate = 0.06f;
				val6.scrollSensitivity = 24f;
				val6.verticalNormalizedPosition = 1f;
				GameObject val7 = new GameObject("AppIcons");
				val7.transform.SetParent(parent2, false);
				val7.transform.SetSiblingIndex(val2.transform.GetSiblingIndex() + 1);
				val7.AddComponent<RectTransform>();
				ConfigureHiddenStub(val7.GetComponent<RectTransform>());
				AppIconsRedirect appIconsRedirect = val7.AddComponent<AppIconsRedirect>();
				appIconsRedirect._realAppIcons = val;
			}
		}

		private static Scrollbar CreateScrollbar(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0041: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scrollbar");
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			val.AddComponent<Image>();
			val.AddComponent<Scrollbar>();
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 1f);
			component.sizeDelta = new Vector2(12f, 0f);
			component.anchoredPosition = new Vector2(0f, 0f);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = new Color(0.1f, 0.1f, 0.1f, 0.3f);
			((Graphic)component2).raycastTarget = true;
			Scrollbar component3 = val.GetComponent<Scrollbar>();
			component3.direction = (Direction)2;
			GameObject val2 = new GameObject("Sliding Area");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<RectTransform>();
			RectTransform component4 = val2.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = Vector2.one;
			component4.sizeDelta = Vector2.zero;
			component4.anchoredPosition = Vector2.zero;
			GameObject val3 = new GameObject("Handle");
			val3.transform.SetParent(val2.transform, false);
			val3.AddComponent<RectTransform>();
			val3.AddComponent<Image>();
			RectTransform component5 = val3.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.sizeDelta = Vector2.zero;
			component5.pivot = new Vector2(0.5f, 0.5f);
			Image component6 = val3.GetComponent<Image>();
			((Graphic)component6).color = new Color(0.8f, 0.8f, 0.8f, 0.6f);
			((Graphic)component6).raycastTarget = true;
			component3.handleRect = component5;
			((Selectable)component3).targetGraphic = (Graphic)(object)component6;
			component3.size = 0.3f;
			return component3;
		}

		private static void ConfigureHiddenStub(RectTransform stubRect)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)stubRect == (Object)null))
			{
				stubRect.anchorMin = new Vector2(0f, 0f);
				stubRect.anchorMax = new Vector2(0f, 0f);
				stubRect.pivot = new Vector2(0f, 0f);
				stubRect.anchoredPosition = new Vector2(-10000f, -10000f);
				stubRect.sizeDelta = new Vector2(1f, 1f);
				CanvasGroup val = ((Component)stubRect).gameObject.GetComponent<CanvasGroup>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)stubRect).gameObject.AddComponent<CanvasGroup>();
				}
				val.alpha = 0f;
				val.interactable = false;
				val.blocksRaycasts = false;
				val.ignoreParentGroups = false;
			}
		}
	}
	[HarmonyPatch(typeof(LandVehicle))]
	internal class LandVehiclePatches
	{
		[HarmonyPatch("OnDestroy")]
		[HarmonyPostfix]
		public static void OnDestroy(LandVehicle __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)__instance != (Object)null)
				{
					VehicleRegistry.RemoveVehicle(((object)__instance.GUID/*cast due to .constrained prefix*/).ToString());
					DriveToCarParkSpec.VehiclesAtNoSpotLots.Remove(__instance);
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch("SetVisible")]
		[HarmonyPrefix]
		public static bool SetVisible_Prefix(LandVehicle __instance, ref bool vis)
		{
			try
			{
				if (!vis && (Object)(object)__instance != (Object)null && DriveToCarParkSpec.VehiclesAtNoSpotLots.Contains(__instance))
				{
					vis = true;
				}
			}
			catch
			{
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class LoadingScreenPatches
	{
		private static readonly Log Logger = new Log("LoadingScreenPatches");

		private static bool _isWaitingForRenderedIcons;

		private static bool _waitForMugshots;

		private static bool _hasCustomNpcTypes = false;

		private static bool _allowGameClose;

		[HarmonyPatch(typeof(LoadManager), "GetLoadStatusText")]
		[HarmonyPostfix]
		private static void GetLoadStatusText_Postfix(ref string __result)
		{
			if (_isWaitingForRenderedIcons)
			{
				if (HasOutstandingProductIconWork(CustomProductPresentationRuntime.GeneratedIconWorkComplete, ProductPackagingContentRuntime.GeneratedIconWorkComplete))
				{
					__result = "Generating Product Icons...";
				}
				else if (_waitForMugshots && !NPCAppearance.MugshotsProcessingComplete)
				{
					__result = "Generating NPC Mugshots...";
				}
			}
		}

		[HarmonyPatch(typeof(LoadingScreen), "Close")]
		[HarmonyPrefix]
		private static bool Close_Prefix(LoadingScreen __instance)
		{
			if (_allowGameClose)
			{
				return true;
			}
			if (!IsGameLoading())
			{
				return true;
			}
			if (_isWaitingForRenderedIcons)
			{
				return false;
			}
			ProductPackagingContentRuntime.QueueRegisteredIconsForLoading();
			bool flag = ShouldWaitForMugshots() && !NPCAppearance.MugshotsProcessingComplete;
			bool flag2 = HasOutstandingProductIconWork(CustomProductPresentationRuntime.GeneratedIconWorkComplete, ProductPackagingContentRuntime.GeneratedIconWorkComplete);
			if (!flag && !flag2)
			{
				return true;
			}
			_isWaitingForRenderedIcons = true;
			_waitForMugshots = flag;
			MelonCoroutines.Start(WaitForRenderedIconsThenClose(__instance, flag));
			return false;
		}

		private static bool HasCustomNpcInstances()
		{
			return NPC.All.Any((NPC npc) => npc?.IsCustomNPC ?? false);
		}

		private static bool ShouldWaitForMugshots()
		{
			MelonPreferences_Entry<bool>? enableMugshotLoadingScreen = S1APIPreferences.EnableMugshotLoadingScreen;
			if ((enableMugshotLoadingScreen != null && !enableMugshotLoadingScreen.Value) || !_hasCustomNpcTypes)
			{
				return false;
			}
			return HasCustomNpcInstances() || HasOutstandingMugshotWork();
		}

		internal static bool HasOutstandingProductIconWork(bool looseIconWorkComplete, bool packagingIconWorkComplete)
		{
			return !looseIconWorkComplete || !packagingIconWorkComplete;
		}

		private static bool IsGameLoading()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0061: Invalid comparison between Unknown and I4
			try
			{
				LoadManager instance = Singleton<LoadManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				if (!instance.IsLoading)
				{
					return false;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (!string.Equals(name, "Main", StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
				return (int)instance.LoadStatus == 0 || (int)instance.LoadStatus == 3;
			}
			catch
			{
				return false;
			}
		}

		private static bool HasOutstandingMugshotWork()
		{
			try
			{
				bool flag = TryReadStaticBool("_hasQueuedMugshots");
				bool flag2 = TryReadStaticBool("_isProcessingMugshots");
				int mugshotQueueCount = GetMugshotQueueCount();
				if (!flag)
				{
					return false;
				}
				return flag2 || mugshotQueueCount > 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool TryReadStaticBool(string memberName)
		{
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetStaticFieldOrProperty(typeof(NPCAppearance), memberName);
			if (obj is bool result)
			{
				return result;
			}
			bool result2 = default(bool);
			return obj != null && bool.TryParse(obj.ToString(), out result2) && result2;
		}

		private static IEnumerator WaitForRenderedIconsThenClose(LoadingScreen loadingScreen, bool waitForMugshots)
		{
			float startTimer = 0f;
			float timer = 0f;
			while (waitForMugshots && !HasOutstandingMugshotWork() && !NPCAppearance.MugshotsProcessingComplete && startTimer < 5f)
			{
				yield return (object)new WaitForSeconds(0.1f);
				startTimer += 0.1f;
			}
			if (waitForMugshots && !HasOutstandingMugshotWork() && !NPCAppearance.MugshotsProcessingComplete)
			{
				waitForMugshots = false;
				_waitForMugshots = false;
			}
			while ((HasOutstandingProductIconWork(CustomProductPresentationRuntime.GeneratedIconWorkComplete, ProductPackagingContentRuntime.GeneratedIconWorkComplete) || (waitForMugshots && !NPCAppearance.MugshotsProcessingComplete)) && timer < 90f)
			{
				yield return (object)new WaitForSeconds(0.1f);
				timer += 0.1f;
			}
			_isWaitingForRenderedIcons = false;
			_waitForMugshots = false;
			if (timer >= 90f)
			{
				int remaining = GetMugshotQueueCount();
				Logger.Warning($"Rendered icon generation timeout reached after {90f}s. {remaining} NPCs may have incomplete portraits; product icons complete: {!HasOutstandingProductIconWork(CustomProductPresentationRuntime.GeneratedIconWorkComplete, ProductPackagingContentRuntime.GeneratedIconWorkComplete)}.");
			}
			CloseLoadingScreenDirectly(loadingScreen);
		}

		private static int GetMugshotQueueCount()
		{
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetStaticFieldOrProperty(typeof(NPCAppearance), "_mugshotQueue");
			if (obj is IEnumerable enumerable)
			{
				int num = 0;
				foreach (object item in enumerable)
				{
					num++;
				}
				return num;
			}
			return -1;
		}

		private static void CloseLoadingScreenDirectly(LoadingScreen loadingScreen)
		{
			try
			{
				_allowGameClose = true;
				loadingScreen.Close();
			}
			catch (Exception ex)
			{
				Logger.Error("Error closing loading screen: " + ex.Message);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(loadingScreen, "IsOpen", false);
				if ((Object)(object)loadingScreen.Canvas != (Object)null)
				{
					((Behaviour)loadingScreen.Canvas).enabled = false;
				}
			}
			finally
			{
				_allowGameClose = false;
			}
		}

		internal static void ResetState()
		{
			_isWaitingForRenderedIcons = false;
			_waitForMugshots = false;
			_allowGameClose = false;
			_hasCustomNpcTypes = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<NPC>().Any((Type t) => t != null && !t.IsAbstract && t.Assembly != typeof(NPC).Assembly);
		}
	}
	[HarmonyPatch]
	internal class MapPatches
	{
		[HarmonyPatch(typeof(NPCEnterableBuilding), "Awake")]
		[HarmonyPostfix]
		private static void NPCEnterableBuildingAwake(NPCEnterableBuilding __instance)
		{
			global::S1API.Map.Building.Register(__instance);
		}

		[HarmonyPatch(typeof(DeliveryLocation), "Awake")]
		[HarmonyPostfix]
		private static void DeliveryLocationAwake(DeliveryLocation __instance)
		{
			DeliveryLocation.Register(__instance);
		}

		[HarmonyPatch(typeof(ParkingLot), "Awake")]
		[HarmonyPostfix]
		private static void ParkingLotAwake(ParkingLot __instance)
		{
			ParkingLotRegistry.Register(__instance);
		}
	}
	[HarmonyPatch(typeof(EffectMixCalculator), "MixProperties")]
	internal static class MixReactionPatches
	{
		private static readonly Log Logger = new Log("MixReactionPatches");

		private const int MaxProperties = 8;

		[HarmonyPostfix]
		private static void MixProperties_Postfix(ref List<Effect> __result, Effect newProperty, EDrugType drugType)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between I4 and Unknown
			try
			{
				if (__result == null || (Object)(object)newProperty == (Object)null)
				{
					return;
				}
				MixReactions.Rule[] array = MixReactions.Snapshot();
				if (array.Length == 0)
				{
					return;
				}
				string iD = newProperty.ID;
				List<Effect> val = null;
				MixReactions.Rule[] array2 = array;
				foreach (MixReactions.Rule rule in array2)
				{
					if ((rule.Drug.HasValue && rule.Drug.Value != (DrugType)(int)drugType) || !string.Equals(rule.MixerEffectId, iD, StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					List<Effect> list = val ?? __result;
					if (IndexOfId(list, rule.WhenContainsId) < 0)
					{
						continue;
					}
					Effect val2 = MixReactions.ResolveAddResult(rule);
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					if (val == null)
					{
						val = Clone(__result);
					}
					int num = IndexOfId(val, rule.WhenContainsId);
					if (num >= 0)
					{
						if (rule.Replace)
						{
							val[num] = val2;
							RemoveDuplicateIds(val, val2.ID);
						}
						else if (val.Count < 8 && IndexOfId(val, val2.ID) < 0)
						{
							val.Add(val2);
						}
					}
				}
				if (val != null)
				{
					__result = val;
				}
			}
			catch (Exception value)
			{
				Logger.Error($"Mixing reaction postfix failed: {value}");
			}
		}

		private static List<Effect> Clone(List<Effect> source)
		{
			List<Effect> val = new List<Effect>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}

		private static int IndexOfId(List<Effect> list, string id)
		{
			for (int i = 0; i < list.Count; i++)
			{
				Effect val = list[i];
				if ((Object)(object)val != (Object)null && string.Equals(val.ID, id, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			return -1;
		}

		private static void RemoveDuplicateIds(List<Effect> list, string id)
		{
			int num = IndexOfId(list, id);
			if (num < 0)
			{
				return;
			}
			for (int num2 = list.Count - 1; num2 > num; num2--)
			{
				Effect val = list[num2];
				if ((Object)(object)val != (Object)null && string.Equals(val.ID, id, StringComparison.OrdinalIgnoreCase))
				{
					list.RemoveAt(num2);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ProductManager), "RpcLogic___FinishAndNameMix_4237212381")]
	internal static class CustomProductMixingPatches
	{
		private static readonly Log Logger = new Log("CustomProductMixingPatches");

		[HarmonyPrefix]
		private static bool FinishAndNameMix_Prefix(string productID, string ingredientID, string mixName, ref string mixID)
		{
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Invalid comparison between Unknown and I4
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Expected I4, but got Unknown
			//IL_043d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0447: Expected I4, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ItemDefinition item = Registry.GetItem(productID);
				ProductDefinition val = (ProductDefinition)(object)((item is ProductDefinition) ? item : null);
				if ((Object)(object)val == (Object)null || !CustomProductDefinitionRegistry.TryGetMetadata(val, out CustomProductDefinitionMetadata metadata))
				{
					return true;
				}
				if (!ProductMixingProfiles.TryGet(metadata.ProductKind.Id, out ProductMixingProfile profile))
				{
					Logger.Error("Custom product '" + productID + "' has logical kind '" + metadata.ProductKind.Id + "' but no ProductMixingProfile is registered. The mix was rejected before the unsupported native output switch.");
					return false;
				}
				if (!CustomProductMixingIdentity.IsGeneratedIdForSource(productID, mixID))
				{
					mixID = CustomProductMixingIdentity.CreateGeneratedProductId(productID, mixID);
				}
				if (CustomProductDefinitionRegistry.IsRegistered(mixID))
				{
					return false;
				}
				object item2 = Registry.GetItem(ingredientID);
				if (item2 == null || !CrossType.Is<PropertyItemDefinition>(item2, out PropertyItemDefinition result))
				{
					Logger.Error("Custom product mix '" + productID + "' could not resolve ingredient '" + ingredientID + "' as a property item.");
					return false;
				}
				if (result.Properties == null || !CustomProductMixingIngredientContract.HasUsableProperty(result.Properties.Count))
				{
					Logger.Error("Custom product mix '" + productID + "' resolved ingredient '" + ingredientID + "' without any properties.");
					return false;
				}
				List<Effect> val2 = EffectMixCalculator.MixProperties(((PropertyItemDefinition)val).Properties, result.Properties[0], val.DrugType);
				List<Effect> list = new List<Effect>(val2.Count);
				for (int i = 0; i < val2.Count; i++)
				{
					list.Add(val2[i]);
				}
				ProductMixingOutput arg = new ProductMixingOutput(mixID, mixName, productID, metadata.ProductKind, val.BasePrice);
				ProductMixingOutputDefinition productMixingOutputDefinition = profile.OutputFactory(arg) ?? throw new InvalidOperationException("The mixing output factory returned null.");
				DrugType nativeDrugType = ProductMixingMapContract.GetNativeDrugType(profile.MixerMap);
				if ((int)val.DrugType != (int)nativeDrugType)
				{
					throw new InvalidOperationException("Custom product '" + productID + "' uses native drug type '" + ((object)val.DrugType/*cast due to .constrained prefix*/).ToString() + "' but its ProductMixingProfile selects mixer map '" + profile.MixerMap.ToString() + "'. Configure the product's explicit native mixer map to match the profile.");
				}
				List<PackagingDefinition> list2 = new List<PackagingDefinition>();
				for (int j = 0; j < metadata.ValidPackaging.Count; j++)
				{
					list2.Add(metadata.ValidPackaging[j].S1PackagingDefinition);
				}
				ProductDefinition val3 = metadata.RepresentationTemplate ?? val;
				Color32? val4 = null;
				if (profile.UsePropertyColorMixing)
				{
					List<ProductMixingColorSample> list3 = new List<ProductMixingColorSample>(list.Count);
					for (int k = 0; k < list.Count; k++)
					{
						Color32 val5 = Color32.op_Implicit(list[k].ProductColor);
						list3.Add(new ProductMixingColorSample(list[k].Tier, new ProductMixingColorValue(val5.r, val5.g, val5.b, val5.a)));
					}
					val4 = ProductMixingColorContract.CalculatePrimaryColor(profile.MixerMap, list3).ToColor32();
				}
				ProductDefinition val6 = CustomProductDefinitionFactory.Create(mixID, productMixingOutputDefinition.Name, ((BaseItemDefinition)val).Description, productMixingOutputDefinition.Price, (LegalStatus)((BaseItemDefinition)val).legalStatus, val.BaseAddictiveness, val.PlayerEffectDuration, val.NPCEffectDuration, nativeDrugType, list, list2, val3);
				CustomProductDefinitionMetadata metadata2 = new CustomProductDefinitionMetadata(productMixingOutputDefinition.ProductKind, metadata.DefaultQuality, metadata.ValidPackaging, val3, val4);
				CustomProductSaveDescriptorData saveDescriptor = new CustomProductSaveDescriptorData
				{
					ProductId = mixID,
					OwnerId = CustomProductDefinitionBuilderContract.GetOwnerId(mixID),
					ProductName = productMixingOutputDefinition.Name,
					Description = ((BaseItemDefinition)val).Description,
					InitialPrice = productMixingOutputDefinition.Price,
					LegalStatus = (int)((BaseItemDefinition)val).legalStatus,
					BaseAddictiveness = val.BaseAddictiveness,
					DefaultQuality = (int)metadata.DefaultQuality,
					ProductKindId = productMixingOutputDefinition.ProductKind.Id,
					CompatibilityDrugType = (int)nativeDrugType,
					RepresentationTemplateId = ((BaseItemDefinition)val3).ID,
					PlayerEffectDurationSeconds = val.PlayerEffectDuration,
					NpcEffectDurationSeconds = val.NPCEffectDuration,
					PropertyIds = list.ConvertAll((Effect property) => property.ID).ToArray(),
					PackagingIds = metadata.ValidPackaging.Select((PackagingDefinition packagingDefinition) => packagingDefinition.ID).ToArray(),
					IsGeneratedMix = true,
					HasGeneratedMixColor = val4.HasValue,
					GeneratedMixColorR = (val4?.r ?? 0),
					GeneratedMixColorG = (val4?.g ?? 0),
					GeneratedMixColorB = (val4?.b ?? 0),
					GeneratedMixColorA = (val4?.a ?? 0)
				};
				try
				{
					CustomProductDefinitionRegistry.Register(CustomProductDefinitionBuilderContract.GetOwnerId(mixID), mixID, productMixingOutputDefinition.Name, productMixingOutputDefinition.Price, val6, metadata2, saveDescriptor);
					CompleteGeneratedMixCreation(val6);
				}
				catch
				{
					CustomProductDefinitionFactory.Destroy(val6);
					throw;
				}
				return false;
			}
			catch (Exception ex)
			{
				Logger.Error("Custom product mixing output failed for '" + productID + "': " + ex);
				return false;
			}
		}

		private static void CompleteGeneratedMixCreation(ProductDefinition generated)
		{
			ProductManager val = NetworkSingleton<ProductManager>.Instance ?? throw new InvalidOperationException("Cannot complete custom product mixing before ProductManager is available.");
			val.SetProductDiscovered((NetworkConnection)null, ((BaseItemDefinition)generated).ID, false);
			val.onNewProductCreated?.Invoke(generated);
		}
	}
	internal static class CustomProductMixingIngredientContract
	{
		internal static bool HasUsableProperty(int propertyCount)
		{
			return propertyCount > 0;
		}
	}
	[HarmonyPatch(typeof(ProductManager), "FinishAndNameMix", new Type[]
	{
		typeof(string),
		typeof(string),
		typeof(string),
		typeof(string)
	})]
	internal static class CustomProductMixingIdPatches
	{
		[HarmonyPrefix]
		private static void FinishAndNameMix_Prefix(string productID, ref string mixID)
		{
			ItemDefinition item = Registry.GetItem(productID);
			ProductDefinition val = (ProductDefinition)(object)((item is ProductDefinition) ? item : null);
			if (!((Object)(object)val == (Object)null) && CustomProductDefinitionRegistry.TryGetMetadata(val, out CustomProductDefinitionMetadata metadata) && ProductMixingProfiles.TryGet(metadata.ProductKind.Id, out ProductMixingProfile _) && !CustomProductMixingIdentity.IsGeneratedIdForSource(productID, mixID))
			{
				mixID = CustomProductMixingIdentity.CreateGeneratedProductId(productID, mixID);
			}
		}
	}
	[HarmonyPatch(typeof(ProductManager), "SendFinishAndNameMix", new Type[]
	{
		typeof(string),
		typeof(string),
		typeof(string),
		typeof(string)
	})]
	internal static class CustomProductMixingClientRpcPatches
	{
		[HarmonyPrefix]
		private static void SendFinishAndNameMix_Prefix(string productID, ref string mixID)
		{
			ItemDefinition item = Registry.GetItem(productID);
			ProductDefinition val = (ProductDefinition)(object)((item is ProductDefinition) ? item : null);
			if (!((Object)(object)val == (Object)null) && CustomProductDefinitionRegistry.TryGetMetadata(val, out CustomProductDefinitionMetadata metadata) && ProductMixingProfiles.TryGet(metadata.ProductKind.Id, out ProductMixingProfile _) && !CustomProductMixingIdentity.IsGeneratedIdForSource(productID, mixID))
			{
				mixID = CustomProductMixingIdentity.CreateGeneratedProductId(productID, mixID);
			}
		}
	}
	[HarmonyPatch]
	internal class NPCPatches
	{
		[HarmonyPatch]
		private static class NpcBehaviourSummonLogicPatch
		{
			private static MethodBase? TargetMethod()
			{
				return FindSummonLogicMethod(typeof(NPCBehaviour));
			}

			[HarmonyPostfix]
			private static void Postfix(NPCBehaviour __instance)
			{
				NPC npc = ((__instance != null) ? __instance.Npc : null);
				if (!((Object)(object)npc == (Object)null))
				{
					bool isCustomNpc = NPC.All.Any((NPC wrapper) => wrapper != null && wrapper.IsCustomNPC && (Object)(object)wrapper.S1NPC == (Object)(object)npc);
					NPCEnterableBuilding currentBuilding = npc.CurrentBuilding;
					bool isInsideBuilding = (Object)(object)currentBuilding != (Object)null;
					if (ShouldExitCustomNpcAfterSummon(InstanceFinder.IsServer, isCustomNpc, isInsideBuilding))
					{
						Logger.Debug($"[NPCDoorKnock] Exiting summoned custom NPC '{npc.ID}' from '{currentBuilding.BuildingName}' after native summon behaviour activation.");
						npc.ExitBuilding("");
					}
				}
			}
		}

		private static readonly Log Logger = new Log("NPCPatches");

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

		private static readonly FieldInfo? ScheduleActionNpcField = AccessTools.Field(typeof(NPCAction), "npc");

		private static readonly PropertyInfo? ScheduleActionNpcProperty = AccessTools.Property(typeof(NPCAction), "npc");

		private const float DefaultRelationDelta = 2f;

		public static bool CustomNpcsReady = false;

		private static readonly List<Type> _pendingCustomNpcTypes = new List<Type>();

		private static readonly HashSet<string> BaseNpcAdditionalKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Relationship", "Inventory", "CustomerData", "MessageConversation", "Health" };

		private static readonly Dictionary<Customer, float> _savedCurrentAddiction = new Dictionary<Customer, float>();

		private static readonly Dictionary<string, DeserializedItemSet> _pendingInventoryLoads = new Dictionary<string, DeserializedItemSet>();

		private static object? GetInventoryMember(NPCInventory inventory, string memberName)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(inventory, memberName);
		}

		private static bool SetInventoryMember(NPCInventory inventory, string memberName, object? value)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(inventory, memberName, value);
		}

		internal static bool ShouldExitCustomNpcAfterSummon(bool isServer, bool isCustomNpc, bool isInsideBuilding)
		{
			return isServer && isCustomNpc && isInsideBuilding;
		}

		internal static bool ShouldSuppressResidenceReentry(bool isServer, bool isCustomNpc, bool isSummonBehaviourEnabled)
		{
			return isServer && isCustomNpc && isSummonBehaviourEnabled;
		}

		internal static MethodBase? FindSummonLogicMethod(Type behaviourType)
		{
			return behaviourType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).FirstOrDefault(delegate(MethodInfo method)
			{
				if (!method.Name.StartsWith("RpcLogic___Summon_", StringComparison.Ordinal))
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				return method.ReturnType == typeof(void) && parameters.Length == 3 && parameters[0].ParameterType == typeof(string) && parameters[1].ParameterType == typeof(int) && parameters[2].ParameterType == typeof(float);
			});
		}

		internal static NPC? GetScheduleActionNpc(NPCAction action)
		{
			object? obj = ScheduleActionNpcField?.GetValue(action);
			return (NPC?)(((obj is NPC) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
		}

		[HarmonyPatch(typeof(NPCEvent_StayInBuilding), "OnActiveTick")]
		[HarmonyPrefix]
		private static bool StayInBuilding_OnActiveTick_Prefix(NPCEvent_StayInBuilding __instance)
		{
			return !IsCustomNpcSummonedDuringResidence(__instance);
		}

		[HarmonyPatch(typeof(NPCEvent_StayInBuilding), "PlayEnterAnimation")]
		[HarmonyPrefix]
		private static bool StayInBuilding_PlayEnterAnimation_Prefix(NPCEvent_StayInBuilding __instance)
		{
			return !IsCustomNpcSummonedDuringResidence(__instance);
		}

		private static bool IsCustomNpcSummonedDuringResidence(NPCEvent_StayInBuilding action)
		{
			NPC npc = GetScheduleActionNpc((NPCAction)(object)action);
			if ((Object)(object)npc == (Object)null)
			{
				return false;
			}
			NPCBehaviour behaviour = npc.Behaviour;
			int num;
			if (behaviour == null)
			{
				num = 0;
			}
			else
			{
				Behaviour summonBehaviour = behaviour.SummonBehaviour;
				num = ((((summonBehaviour != null) ? new bool?(summonBehaviour.Enabled) : ((bool?)null)) == true) ? 1 : 0);
			}
			bool flag = (byte)num != 0;
			if (!flag)
			{
				return false;
			}
			bool isCustomNpc = NPC.All.Any((NPC wrapper) => wrapper != null && wrapper.IsCustomNPC && (Object)(object)wrapper.S1NPC == (Object)(object)npc);
			return ShouldSuppressResidenceReentry(InstanceFinder.IsServer, isCustomNpc, flag);
		}

		private static bool GetInventoryBool(NPCInventory inventory, string memberName)
		{
			object inventoryMember = GetInventoryMember(inventory, memberName);
			bool flag = default(bool);
			int num;
			if (inventoryMember is bool)
			{
				flag = (bool)inventoryMember;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		private static int GetInventoryInt(NPCInventory inventory, string memberName, int fallback)
		{
			return (GetInventoryMember(inventory, memberName) is int num) ? num : fallback;
		}

		private static int GetArrayLength(object? value)
		{
			if (value == null)
			{
				return 0;
			}
			if (!(value is Array { Length: var length }))
			{
				return (value.GetType().GetProperty("Length", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value) is int num) ? num : 0;
			}
			return length;
		}

		private static void EnsureInventoryArray(NPCInventory inventory, string memberName)
		{
			if ((Object)(object)inventory == (Object)null || GetInventoryMember(inventory, memberName) != null)
			{
				return;
			}
			Type memberType = GetMemberType(((object)inventory).GetType(), memberName);
			if (memberType == null)
			{
				return;
			}
			object obj = null;
			try
			{
				if (memberType.IsArray)
				{
					Type elementType = memberType.GetElementType();
					if (elementType != null)
					{
						obj = Array.CreateInstance(elementType, 0);
					}
				}
				else
				{
					obj = Activator.CreateInstance(memberType, 0);
				}
			}
			catch
			{
				obj = null;
			}
			if (obj != null)
			{
				SetInventoryMember(inventory, memberName, obj);
			}
		}

		private static void ClearInventoryArray(NPCInventory inventory, string memberName)
		{
			if ((Object)(object)inventory == (Object)null)
			{
				return;
			}
			object inventoryMember = GetInventoryMember(inventory, memberName);
			if (GetArrayLength(inventoryMember) == 0)
			{
				return;
			}
			Type memberType = GetMemberType(((object)inventory).GetType(), memberName);
			if (memberType == null)
			{
				return;
			}
			object obj = null;
			try
			{
				if (memberType.IsArray)
				{
					Type elementType = memberType.GetElementType();
					if (elementType != null)
					{
						obj = Array.CreateInstance(elementType, 0);
					}
				}
				else
				{
					obj = Activator.CreateInstance(memberType, 0);
				}
			}
			catch
			{
				obj = null;
			}
			if (obj != null)
			{
				SetInventoryMember(inventory, memberName, obj);
			}
		}

		private static Type? GetMemberType(Type? type, string memberName)
		{
			while (type != null && type != typeof(object))
			{
				FieldInfo field = type.GetField(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field.FieldType;
				}
				PropertyInfo property = type.GetProperty(memberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null)
				{
					return property.PropertyType;
				}
				type = type.BaseType;
			}
			return null;
		}

		internal static void ResetState()
		{
			_savedCurrentAddiction.Clear();
			_loadingDealers.Clear();
			_pendingInventoryLoads.Clear();
		}

		private static void LogCustomNpcInstantiationException(Type? type, string context, Exception? ex)
		{
			if (ex == null)
			{
				Logger.Warning($"[S1API] Failed to instantiate custom NPC type '{type?.FullName ?? "<null>"}' {context}: <null exception>");
				return;
			}
			List<Exception> list = new List<Exception>();
			for (Exception ex2 = ex; ex2 != null; ex2 = ex2.InnerException)
			{
				list.Add(ex2);
			}
			string value = string.Join(" --> ", list.Select((Exception e) => e.GetType().FullName + ": " + e.Message));
			Logger.Warning($"[S1API] Failed to instantiate custom NPC type '{type?.FullName ?? "<null>"}' {context}: {value}");
			for (int num = 0; num < list.Count; num++)
			{
				Exception ex3 = list[num];
				if (!string.IsNullOrWhiteSpace(ex3.StackTrace))
				{
					Logger.Warning($"[S1API] Instantiation exception[{num}] stack trace ({ex3.GetType().FullName}): {ex3.StackTrace}");
				}
			}
		}

		private static int CompareNPCActions(NPCAction a, NPCAction b)
		{
			int num = a.StartTime.CompareTo(b.StartTime);
			if (num != 0)
			{
				return num;
			}
			if (a.IsSignal == b.IsSignal)
			{
				return 0;
			}
			return (!a.IsSignal) ? 1 : (-1);
		}

		private static bool HasConsolidatedSave(string mainPath)
		{
			string path = Directory.GetParent(mainPath)?.FullName ?? mainPath;
			string path2 = Path.Combine(path, "NPCs.json");
			return File.Exists(path2);
		}

		private static void RebuildPendingCustomNpcTypes(bool useConsolidatedFlow)
		{
			_pendingCustomNpcTypes.Clear();
			if (!useConsolidatedFlow)
			{
				return;
			}
			List<Type> derivedClasses = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<NPC>();
			derivedClasses.Sort((Type a, Type b) => string.Compare(a?.Name, b?.Name, StringComparison.Ordinal));
			foreach (Type item in derivedClasses)
			{
				if (!(item == null) && !item.IsAbstract && !(item.Assembly == Assembly.GetExecutingAssembly()))
				{
					_pendingCustomNpcTypes.Add(item);
				}
			}
		}

		private static bool IsLikelyCustomDynamicSaveData(DynamicSaveData saveData)
		{
			if (saveData == null)
			{
				return false;
			}
			try
			{
				List<AdditionalData> additionalDatas = saveData.AdditionalDatas;
				if (additionalDatas == null)
				{
					return false;
				}
				int count = additionalDatas.Count;
				for (int i = 0; i < count; i++)
				{
					AdditionalData val = additionalDatas[i];
					if (val != null)
					{
						string name = val.Name;
						if (!string.IsNullOrEmpty(name) && !BaseNpcAdditionalKeys.Contains(name))
						{
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static void RegisterCustomNpcForNetworking(NPC customNPC)
		{
			if (customNPC == null || (Object)(object)customNPC.gameObject == (Object)null)
			{
				return;
			}
			try
			{
				NetworkObject val = customNPC.gameObject.GetComponent<NetworkObject>();
				if ((Object)(object)val == (Object)null)
				{
					try
					{
						val = customNPC.gameObject.AddComponent<NetworkObject>();
					}
					catch
					{
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					NPCNetworkBootstrap.RegisterPendingNetworkSpawn(customNPC, val, 3f, 6f);
				}
			}
			catch
			{
			}
		}

		private static NPC? TryInstantiateCustomNpcForSaveId(string? npcId, string reasonTag)
		{
			if (_pendingCustomNpcTypes.Count == 0 || string.IsNullOrWhiteSpace(npcId))
			{
				return null;
			}
			NPC val = FindBaseNpcById(npcId);
			if ((Object)(object)val != (Object)null)
			{
				NPC nPC = FindWrapperForS1Npc(val);
				if (nPC != null)
				{
					for (int num = _pendingCustomNpcTypes.Count - 1; num >= 0; num--)
					{
						Type type = _pendingCustomNpcTypes[num];
						if (type != null && nPC.GetType() == type)
						{
							_pendingCustomNpcTypes.RemoveAt(num);
							break;
						}
					}
					return nPC;
				}
				return null;
			}
			for (int i = 0; i < _pendingCustomNpcTypes.Count; i++)
			{
				Type type2 = _pendingCustomNpcTypes[i];
				if (NPC.TryGetConfiguredNpcId(type2, out string id) && id.Equals(npcId, StringComparison.OrdinalIgnoreCase))
				{
					NPC nPC2 = null;
					try
					{
						nPC2 = (NPC)Activator.CreateInstance(type2, nonPublic: true);
					}
					catch (Exception ex)
					{
						LogCustomNpcInstantiationException(type2, "for save ID '" + npcId + "'", ex);
					}
					if (nPC2 != null)
					{
						_pendingCustomNpcTypes.RemoveAt(i);
						RegisterCustomNpcForNetworking(nPC2);
						return nPC2;
					}
				}
			}
			for (int j = 0; j < _pendingCustomNpcTypes.Count; j++)
			{
				Type type3 = _pendingCustomNpcTypes[j];
				if (NPC.TryGetConfiguredNpcId(type3, out string _))
				{
					continue;
				}
				NPC nPC3 = null;
				try
				{
					nPC3 = (NPC)Activator.CreateInstance(type3, nonPublic: true);
				}
				catch (Exception ex2)
				{
					LogCustomNpcInstantiationException(type3, "for save ID '" + npcId + "'", ex2);
				}
				if (nPC3 != null)
				{
					NPC s1NPC = nPC3.S1NPC;
					string text = ((s1NPC != null) ? s1NPC.ID : null);
					if (!string.IsNullOrEmpty(text) && text.Equals(npcId, StringComparison.OrdinalIgnoreCase))
					{
						_pendingCustomNpcTypes.RemoveAt(j);
						RegisterCustomNpcForNetworking(nPC3);
						return nPC3;
					}
					NPC.All.Remove(nPC3);
					Object.DestroyImmediate((Object)(object)nPC3.gameObject);
				}
			}
			return null;
		}

		private static void InstantiateRemainingCustomNpcs(string mainPath)
		{
			if (_pendingCustomNpcTypes.Count == 0)
			{
				return;
			}
			while (_pendingCustomNpcTypes.Count > 0)
			{
				Type type = _pendingCustomNpcTypes[0];
				_pendingCustomNpcTypes.RemoveAt(0);
				NPC nPC = null;
				try
				{
					nPC = (NPC)Activator.CreateInstance(type, nonPublic: true);
				}
				catch (Exception ex)
				{
					LogCustomNpcInstantiationException(type, "with default data", ex);
				}
				if (nPC != null)
				{
					try
					{
						string folderPath = Path.Combine(mainPath, nPC.S1NPC.SaveFolderName);
						nPC.LoadInternal(folderPath);
					}
					catch
					{
					}
					RegisterCustomNpcForNetworking(nPC);
				}
			}
		}

		[HarmonyPatch(typeof(NPCsLoader), "Load")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void NPCsLoadersLoad(NPCsLoader __instance, string mainPath)
		{
			bool useConsolidatedFlow = HasConsolidatedSave(mainPath);
			RebuildPendingCustomNpcTypes(useConsolidatedFlow);
			if (!IsInMainScene() || !InstanceFinder.IsServer)
			{
				return;
			}
			string path = Directory.GetParent(mainPath)?.FullName ?? mainPath;
			string path2 = Path.Combine(path, "NPCs.json");
			if (File.Exists(path2))
			{
				return;
			}
			int num = 0;
			foreach (Type derivedClass in global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<NPC>())
			{
				if (derivedClass.IsAbstract)
				{
					continue;
				}
				NPC nPC = (NPC)Activator.CreateInstance(derivedClass, nonPublic: true);
				if (nPC == null)
				{
					throw new Exception("Unable to create instance of " + derivedClass.FullName + "!");
				}
				if (derivedClass.Assembly == Assembly.GetExecutingAssembly())
				{
					continue;
				}
				NPC val = nPC.S1NPC ?? throw new InvalidOperationException("Custom NPC type '" + derivedClass.FullName + "' did not create its base-game NPC instance.");
				string text = val.ID ?? "<null>";
				string folderPath = Path.Combine(mainPath, val.SaveFolderName);
				nPC.LoadInternal(folderPath);
				try
				{
					NetworkObject val2 = nPC.gameObject.GetComponent<NetworkObject>();
					if ((Object)(object)val2 == (Object)null)
					{
						try
						{
							val2 = nPC.gameObject.AddComponent<NetworkObject>();
						}
						catch
						{
						}
					}
					if ((Object)(object)val2 != (Object)null)
					{
						NPCNetworkBootstrap.RegisterPendingNetworkSpawn(nPC, val2, 3f, 6f);
					}
				}
				catch
				{
				}
				num++;
			}
			_pendingCustomNpcTypes.Clear();
		}

		[HarmonyPatch(typeof(NPCsLoader), "Load")]
		[HarmonyPrefix]
		[HarmonyPriority(400)]
		private static bool NPCsLoader_Load_Prefix(NPCsLoader __instance, string mainPath)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			string path = Directory.GetParent(mainPath)?.FullName ?? mainPath;
			string path2 = Path.Combine(path, "NPCs.json");
			if (File.Exists(path2))
			{
				try
				{
					string text = File.ReadAllText(path2);
					NPCCollectionData val = JsonUtility.FromJson<NPCCollectionData>(text);
					if (val != null)
					{
						NPCLoader val2 = new NPCLoader();
						DynamicSaveData[] array = Il2CppArrayBase<DynamicSaveData>.op_Implicit((Il2CppArrayBase<DynamicSaveData>)(object)val.NPCs);
						if (_pendingCustomNpcTypes.Count == 0)
						{
							RebuildPendingCustomNpcTypes(useConsolidatedFlow: true);
						}
						int num = 0;
						int num2 = 0;
						DynamicSaveData[] array2 = array;
						foreach (DynamicSaveData val3 in array2)
						{
							if (val3 == null)
							{
								continue;
							}
							try
							{
								NPCData val4 = val3.ExtractBaseData<NPCData>();
								NPC val5 = FindBaseNpcById(((val4 != null) ? val4.ID : null) ?? string.Empty);
								if ((Object)(object)val5 == (Object)null && _pendingCustomNpcTypes.Count > 0)
								{
									NPC nPC = TryInstantiateCustomNpcForSaveId((val4 != null) ? val4.ID : null, "no-base-npc");
									if (nPC != null)
									{
										val5 = FindBaseNpcById(((val4 != null) ? val4.ID : null) ?? string.Empty);
									}
								}
								if ((Object)(object)val5 == (Object)null && IsLikelyCustomDynamicSaveData(val3) && _pendingCustomNpcTypes.Count > 0)
								{
									NPC nPC2 = TryInstantiateCustomNpcForSaveId((val4 != null) ? val4.ID : null, "custom-data");
									if (nPC2 != null)
									{
										val5 = FindBaseNpcById(((val4 != null) ? val4.ID : null) ?? string.Empty);
									}
								}
								if ((Object)(object)val5 != (Object)null)
								{
									((DynamicLoader)val2).Load(val3);
									num++;
								}
							}
							catch (Exception ex)
							{
								num2++;
								NPCData val6 = val3.ExtractBaseData<NPCData>();
								string text2 = ((val6 != null) ? val6.ID : null) ?? "<unknown>";
								Logger.Warning("[S1API] NPCsLoader_Load_Prefix: Failed to load NPC '" + text2 + "': " + ex.Message);
							}
						}
						InstantiateRemainingCustomNpcs(mainPath);
						return false;
					}
				}
				catch (Exception ex2)
				{
					Logger.Warning("[S1API] NPCsLoader_Load_Prefix: Error loading NPCs.json from parent directory: " + ex2.Message);
					Logger.Warning("[S1API] NPCsLoader_Load_Prefix: Stack trace: " + ex2.StackTrace);
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(NPCInventory), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void EnsureNPCInventorySafeInit(NPCInventory __instance)
		{
			string text = "<unknown>";
			bool flag = false;
			try
			{
				NPC component = ((Component)__instance).GetComponent<NPC>();
				text = ((component != null) ? component.ID : null) ?? ((Object)__instance).name ?? "<unknown>";
				flag = (((Object)(object)component != (Object)null) ? FindWrapperForS1Npc(component) : null)?.IsCustomNPC ?? false;
			}
			catch
			{
			}
			EnsureInventoryArray(__instance, "TestItems");
			EnsureInventoryArray(__instance, "StartupItems");
			EnsureInventoryArray(__instance, "RandomInventoryItems");
			try
			{
				NPC component2 = ((Component)__instance).GetComponent<NPC>();
				NPC nPC = (((Object)(object)component2 != (Object)null) ? FindWrapperForS1Npc(component2) : null);
				if (nPC == null || !nPC.IsCustomNPC || GetInventoryMember(__instance, "StartupItems") == null || __instance.ItemSlots == null)
				{
					return;
				}
				bool flag2 = false;
				try
				{
					for (int i = 0; i < __instance.ItemSlots.Count; i++)
					{
						ItemSlot val = __instance.ItemSlots[i];
						if (val != null && val.ItemInstance != null && val.Quantity > 0)
						{
							flag2 = true;
							break;
						}
					}
				}
				catch
				{
				}
				if (flag2)
				{
					ClearInventoryArray(__instance, "StartupItems");
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to check for already-inserted startup items: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(NPCInventory), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void NPCInventory_Awake_Postfix(NPCInventory __instance)
		{
			if (!IsInMainScene())
			{
				return;
			}
			try
			{
				NPC component = ((Component)__instance).GetComponent<NPC>();
				NPC nPC = (((Object)(object)component != (Object)null) ? FindWrapperForS1Npc(component) : null);
				if (nPC == null || !nPC.IsCustomNPC)
				{
					return;
				}
				try
				{
					NPCInventory nPCInventory = new NPCInventory(nPC);
					nPCInventory.EnsureInitialized();
					if ((Object)(object)component != (Object)null && _pendingInventoryLoads.TryGetValue(component.ID, out DeserializedItemSet value))
					{
						value.LoadTo(__instance.ItemSlots);
						_pendingInventoryLoads.Remove(component.ID);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to ensure inventory initialized in postfix: " + ex.Message);
				}
				ClearInventoryArray(__instance, "StartupItems");
			}
			catch (Exception ex2)
			{
				MelonLogger.Warning("[S1API] NPCInventory.Awake postfix cleanup failed: " + ex2.Message);
			}
		}

		[HarmonyPatch(typeof(NPC), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool NPC_Awake_Prefix(NPC __instance)
		{
			try
			{
				NPCPrefabIdentity nPCPrefabIdentity = (((Object)(object)__instance != (Object)null) ? ((Component)__instance).GetComponent<NPCPrefabIdentity>() : null);
				if ((Object)(object)nPCPrefabIdentity != (Object)null)
				{
					nPCPrefabIdentity.ApplyCriticalIdentityBeforeAwake(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("NPC_Awake_Prefix: Failed to apply S1API identity before Awake: " + ex.Message);
			}
			return true;
		}

		[HarmonyPatch(typeof(Dealer), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Dealer_Awake_Prefix(Dealer __instance)
		{
			if (IsS1ApiCustomNpcComponent((Component)(object)__instance))
			{
				try
				{
					((Component)__instance).GetComponent<NPCPrefabIdentity>()?.ApplyCriticalIdentityBeforeAwake((NPC)(object)__instance);
				}
				catch (Exception ex)
				{
					Logger.Warning("Dealer_Awake_Prefix: Failed to apply S1API identity before Awake: " + ex.Message);
				}
			}
			return true;
		}

		internal static bool IsS1ApiCustomNpcComponent(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			try
			{
				Transform val = component.transform;
				while ((Object)(object)val != (Object)null)
				{
					if ((Object)(object)((Component)val).gameObject != (Object)null)
					{
						string text = ((Object)((Component)val).gameObject).name ?? string.Empty;
						if (text.StartsWith("S1API_", StringComparison.OrdinalIgnoreCase))
						{
							return true;
						}
						if ((Object)(object)((Component)val).gameObject.GetComponent<NPCPrefabIdentity>() != (Object)null)
						{
							return true;
						}
					}
					val = val.parent;
				}
				if ((Object)(object)component.GetComponent<NPCPrefabIdentity>() != (Object)null)
				{
					return true;
				}
				if ((Object)(object)component.GetComponentInParent<NPCPrefabIdentity>(true) != (Object)null)
				{
					return true;
				}
				NPC val2 = (NPC)(((object)((component is NPC) ? component : null)) ?? ((object)component.GetComponentInParent<NPC>(true)));
				if ((Object)(object)val2 != (Object)null)
				{
					return FindWrapperForS1Npc(val2)?.IsCustomNPC ?? false;
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPatch(typeof(NPC), "Start")]
		[HarmonyPostfix]
		private static void NPCStart(NPC __instance)
		{
			try
			{
				NPCPrefabIdentity component = ((Component)__instance).GetComponent<NPCPrefabIdentity>();
				if ((Object)(object)component != (Object)null)
				{
					component.ApplyTo(__instance);
				}
			}
			catch
			{
			}
			NPC nPC = null;
			for (int i = 0; i < NPC.All.Count; i++)
			{
				NPC nPC2 = NPC.All[i];
				if (nPC2.IsCustomNPC && (Object)(object)nPC2.S1NPC == (Object)(object)__instance)
				{
					nPC = nPC2;
					break;
				}
			}
			if (nPC == null && !InstanceFinder.IsServer)
			{
				nPC = NPC.CreateWrapperForNetworkSpawnedNPC(__instance);
			}
			if (nPC != null && nPC.IsCustomNPC)
			{
				nPC.EnsureMessageConversationReady(resetDefaults: false);
				if (InstanceFinder.IsServer)
				{
					nPC.CreateInternal();
				}
				else
				{
					nPC.CreateFromClientNetworkSpawn();
					NPC.CheckAndSetCustomNpcsReady();
				}
				if (!InstanceFinder.IsServer)
				{
					MelonCoroutines.Start(SetClientVisibilityDelayed(__instance, nPC));
				}
			}
			try
			{
				if (!((Object)(object)__instance != (Object)null) || !((Object)(object)((Component)__instance).gameObject != (Object)null) || ((Object)((Component)__instance).gameObject).name == null)
				{
					return;
				}
				string name = ((Object)((Component)__instance).gameObject).name;
				if ((((Component)__instance).gameObject.activeInHierarchy && ((Behaviour)__instance).enabled) || !name.StartsWith("S1API_", StringComparison.Ordinal))
				{
					return;
				}
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				for (int num = nPCRegistry.Count - 1; num >= 0; num--)
				{
					if ((Object)(object)nPCRegistry[num] == (Object)(object)__instance)
					{
						nPCRegistry.RemoveAt(num);
						break;
					}
				}
			}
			catch
			{
			}
		}

		private static IEnumerator SetClientVisibilityDelayed(NPC npc, NPC apiNpc)
		{
			yield return null;
			yield return (object)new WaitForSeconds(0.1f);
			try
			{
				if ((Object)(object)npc != (Object)null && (Object)(object)((Component)npc).gameObject != (Object)null)
				{
					npc.SetVisible(apiNpc.ShouldBeVisibleAfterSpawn(), false);
				}
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Logger.Warning("Failed to set visibility for NPC '" + ((npc != null) ? npc.ID : null) + "' on client: " + ex2.Message);
			}
		}

		[HarmonyPatch(typeof(NPC), "WriteData")]
		[HarmonyPostfix]
		private static void NPCWriteData(NPC __instance, string parentFolderPath, ref List<string> __result)
		{
			string path = Path.Combine(parentFolderPath, "NPCs.json");
			if (File.Exists(path))
			{
				return;
			}
			for (int i = 0; i < NPC.All.Count; i++)
			{
				NPC nPC = NPC.All[i];
				if (nPC.IsCustomNPC && (Object)(object)nPC.S1NPC == (Object)(object)__instance)
				{
					nPC.SaveInternal(parentFolderPath, ref __result);
					break;
				}
			}
		}

		[HarmonyPatch(typeof(NPC), "GetSaveData")]
		[HarmonyPrefix]
		private static bool NPC_GetSaveData_Prefix(NPC __instance, ref DynamicSaveData? __result)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				__result = null;
				return false;
			}
			if ((Object)(object)((Component)__instance).gameObject == (Object)null)
			{
				Logger.Warning("[S1API] NPC_GetSaveData_Prefix: NPC '" + (((__instance != null) ? __instance.ID : null) ?? "<null>") + "' has null GameObject - skipping save");
				__result = null;
				return false;
			}
			try
			{
				string name = ((Object)((Component)__instance).gameObject).name;
				if (!string.IsNullOrEmpty(name) && name.StartsWith("S1API_", StringComparison.Ordinal))
				{
					__result = null;
					return false;
				}
			}
			catch
			{
				__result = null;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(NPC), "GetSaveData")]
		[HarmonyPostfix]
		private static void NPC_GetSaveData(NPC __instance, ref DynamicSaveData __result)
		{
			if (__result != null && !((Object)(object)__instance == (Object)null) && !((Object)(object)((Component)__instance).gameObject == (Object)null))
			{
				FindWrapperForS1Npc(__instance)?.SaveToDynamic(__result);
			}
		}

		[HarmonyPatch(typeof(NPCLoader), "Load")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool NPCLoader_Load_Prefix(DynamicSaveData saveData)
		{
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInMainScene() && !IsInLoadingScene())
			{
				return true;
			}
			if (saveData == null)
			{
				return true;
			}
			NPCData val = saveData.ExtractBaseData<NPCData>();
			if (val == null || string.IsNullOrEmpty(val.ID))
			{
				return true;
			}
			NPC val2 = FindBaseNpcById(val.ID);
			if ((Object)(object)val2 == (Object)null)
			{
				Logger.Warning("[NPCPatches] NPCLoader_Load_Prefix: Could not find base NPC for '" + val.ID + "'.");
				Logger.Warning("The above warning is normal when removing an S1API mod with custom NPCs, because the NPC is saved but doesn't exist anymore.");
				return true;
			}
			try
			{
				if ((Object)(object)((Component)val2).gameObject == (Object)null)
				{
					return false;
				}
				GameObject gameObject = ((Component)val2).gameObject;
				if ((Object)(object)gameObject != (Object)null && (((Object)gameObject).name == "CivilianNPC" || ((Object)gameObject).name == "BaseNPC" || ((Object)gameObject).name.StartsWith("S1API_")))
				{
					return false;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("NPCLoader_Load_Prefix: Exception in template check for ID '" + val.ID + "': " + ex.Message);
				return false;
			}
			NPC nPC = FindWrapperForS1Npc(val2);
			if (nPC == null || !nPC.IsCustomNPC)
			{
				return true;
			}
			try
			{
				Dealer component = ((Component)val2).GetComponent<Dealer>();
				if ((Object)(object)component != (Object)null)
				{
					EnsureDealerOverflowSlots(component);
				}
				val2.Load(saveData, val);
				RelationshipData val3 = default(RelationshipData);
				if (saveData.TryGetData<RelationshipData>("Relationship", ref val3) && val3 != null && val2.RelationData != null)
				{
					if (!float.IsNaN(val3.RelationDelta) && !float.IsInfinity(val3.RelationDelta))
					{
						val2.RelationData.SetRelationship(val3.RelationDelta, true);
					}
					if (val3.Unlocked)
					{
						val2.RelationData.Unlock(val3.UnlockType, false);
						try
						{
							nPC = FindWrapperForS1Npc(val2);
							if (nPC != null)
							{
								FieldInfo field = typeof(NPC).GetField("_loadedUnlockType", BindingFlags.Instance | BindingFlags.NonPublic);
								if (field != null)
								{
									EUnlockType val4 = (EUnlockType)(((int)val3.UnlockType != 0) ? 1 : 0);
									field.SetValue(nPC, val4);
								}
							}
						}
						catch
						{
						}
					}
				}
				try
				{
					nPC = FindWrapperForS1Npc(val2);
					if (nPC != null)
					{
						typeof(NPC).GetMethod("MarkLoadedFromSave", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(nPC, null);
					}
				}
				catch
				{
				}
				MSGConversationData val5 = default(MSGConversationData);
				if (saveData.TryGetData<MSGConversationData>("MessageConversation", ref val5))
				{
					nPC?.EnsureMessageConversationReady(resetDefaults: false);
					if (val2.MSGConversation == null)
					{
						Logger.Warning("NPCLoader_Load_Prefix: MSGConversation is null for '" + val.ID + "'");
					}
					else
					{
						val2.MSGConversation.Load(val5);
					}
				}
				CustomerData cust = default(CustomerData);
				if (saveData.TryGetData<CustomerData>("CustomerData", ref cust))
				{
					Customer component2 = ((Component)val2).GetComponent<Customer>();
					if ((Object)(object)component2 == (Object)null)
					{
						Logger.Warning("NPCLoader_Load_Prefix: Customer component is null for '" + val.ID + "'");
					}
					else
					{
						try
						{
							nPC?.Customer?.EnsureCustomer();
							Type type = nPC?.GetType();
							if (type != null && NPC.HasCustomerDefaultsForType(type))
							{
								CustomerData val6 = NPC.BuildCustomerDefaultsForType(type);
								if ((Object)(object)val6 != (Object)null && !NPC.TrySetCustomerDataOnComponent(component2, val6))
								{
									try
									{
										component2.customerData = val6;
										component2.currentAffinityData = val6.DefaultAffinityData;
									}
									catch
									{
									}
								}
							}
							((Behaviour)component2).enabled = true;
							ApplyCustomerDataSafely(component2, cust);
						}
						catch (Exception ex2)
						{
							Logger.Warning("NPCLoader_Load_Prefix: Exception loading Customer data for '" + val.ID + "': " + ex2.Message);
							Logger.Warning("NPCLoader_Load_Prefix: Stack trace: " + ex2.StackTrace);
						}
					}
				}
				string text = default(string);
				if (saveData.TryGetData("Inventory", ref text))
				{
					try
					{
						DeserializedItemSet val7 = default(DeserializedItemSet);
						if (ItemSet.TryDeserialize(text, ref val7))
						{
							val7.LoadTo(val2.Inventory.ItemSlots);
						}
						else
						{
							Logger.Warning("Failed to deserialize inventory data for custom NPC '" + val.ID + "'");
						}
					}
					catch (Exception ex3)
					{
						Logger.Warning("NPCLoader_Load_Prefix: Exception loading Inventory data for '" + val.ID + "': " + ex3.Message);
					}
				}
			}
			catch (Exception ex4)
			{
				Logger.Warning("[S1API] NPCLoader.Load guard failed for custom NPC '" + val.ID + "': " + ex4.Message);
				Logger.Warning("Stack trace: " + ex4.StackTrace);
			}
			try
			{
				NPC nPC2 = FindWrapperForS1Npc(val2);
				if (nPC2 != null)
				{
					typeof(NPC).GetMethod("MarkLoadedFromSave", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(nPC2, null);
					Type type2 = nPC2.GetType();
					if (NPC.TypeToRelationshipDefaults.TryGetValue(type2, out Action<NPCRelationshipDataBuilder> value) && value != null)
					{
						NPCRelationshipDataBuilder nPCRelationshipDataBuilder = new NPCRelationshipDataBuilder();
						value(nPCRelationshipDataBuilder);
						NPCRelationData relationData = val2.RelationData;
						if (relationData != null)
						{
							float relationDelta = relationData.RelationDelta;
							bool flag = Math.Abs(relationDelta - 2f) > 0.01f;
							float num = relationDelta;
							bool unlocked = relationData.Unlocked;
							nPCRelationshipDataBuilder.ApplyTo(relationData, val2, preserveUnlockState: true);
							if (flag)
							{
								relationData.SetRelationship(num, true);
							}
							bool unlocked2 = relationData.Unlocked;
							if (unlocked && !unlocked2)
							{
								Logger.Warning("[S1API] NPCLoader_Load_Prefix: WARNING - Unlock state was lost after applying defaults for '" + val.ID + "'!");
							}
						}
						else
						{
							Logger.Warning("[S1API] NPCLoader_Load_Prefix: RelationData is null when trying to apply defaults for '" + val.ID + "'");
						}
					}
					if (NPC.ShouldApplyLoadedVisibilityBeforeSpawn(nPC2.IsSupplier))
					{
						val2.SetVisible(nPC2.ShouldBeVisibleAfterSpawn(), false);
					}
				}
				else
				{
					Logger.Warning("[S1API] NPCLoader_Load_Prefix: Could not find wrapper NPC for '" + val.ID + "'");
				}
			}
			catch (Exception ex5)
			{
				Logger.Warning("[S1API] NPCLoader_Load_Prefix: Exception in post-load processing: " + ex5.Message);
				Logger.Warning("[S1API] Stack trace: " + ex5.StackTrace);
			}
			return false;
		}

		private static void ApplyCustomerDataSafely(Customer customerComponent, CustomerData cust)
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)customerComponent == (Object)null || cust == null)
			{
				return;
			}
			try
			{
				Type type = ((object)customerComponent).GetType();
				try
				{
					FieldInfo field = type.GetField("currentAffinityData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property = type.GetProperty("currentAffinityData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					CustomerAffinityData val = null;
					if (field != null)
					{
						if ((object)field != null)
						{
							FieldInfo fieldInfo = field;
							if (true)
							{
								object? value = fieldInfo.GetValue(customerComponent);
								val = (CustomerAffinityData)((value is CustomerAffinityData) ? value : null);
								goto IL_0097;
							}
						}
						if ((object)property != null)
						{
							PropertyInfo propertyInfo = property;
							if (true)
							{
								object? value2 = propertyInfo.GetValue(customerComponent);
								val = (CustomerAffinityData)((value2 is CustomerAffinityData) ? value2 : null);
							}
						}
					}
					goto IL_0097;
					IL_0097:
					if (val == null)
					{
						val = new CustomerAffinityData();
						PropertyInfo property2 = type.GetProperty("CustomerData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property2 != null)
						{
							object value3 = property2.GetValue(customerComponent);
							if (value3 != null)
							{
								object obj = value3.GetType().GetProperty("DefaultAffinityData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(value3);
								obj?.GetType().GetMethod("CopyTo", BindingFlags.Instance | BindingFlags.Public)?.Invoke(obj, new object[1] { val });
							}
						}
						if ((object)field != null)
						{
							FieldInfo fieldInfo2 = field;
							if (true)
							{
								fieldInfo2.SetValue(customerComponent, val);
								goto IL_018a;
							}
						}
						if ((object)property != null)
						{
							PropertyInfo propertyInfo2 = property;
							if (propertyInfo2.CanWrite)
							{
								propertyInfo2.SetValue(customerComponent, val);
							}
						}
					}
					goto IL_018a;
					IL_018a:
					if (cust.ProductAffinities != null && val != null)
					{
						object obj2 = ((object)val).GetType().GetProperty("ProductAffinities", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(val);
						if (obj2 != null)
						{
							int val2 = ((obj2.GetType().GetProperty("Count", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj2) is int num) ? num : 0);
							int num2 = Math.Min(((Il2CppArrayBase<float>)(object)cust.ProductAffinities).Length, val2);
							for (int i = 0; i < num2; i++)
							{
								if (!float.IsNaN(((Il2CppArrayBase<float>)(object)cust.ProductAffinities)[i]))
								{
									object obj3 = obj2.GetType().GetProperty("Item", BindingFlags.Instance | BindingFlags.Public)?.GetMethod?.Invoke(obj2, new object[1] { i });
									obj3?.GetType().GetProperty("Affinity", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(obj3, ((Il2CppArrayBase<float>)(object)cust.ProductAffinities)[i]);
								}
							}
						}
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("ApplyCustomerDataSafely currentAffinityData: " + ex.Message);
				}
				try
				{
					if (cust.IsContractOffered && cust.OfferedContract != null)
					{
						PropertyInfo property3 = type.GetProperty("OfferedContractInfo", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						PropertyInfo property4 = type.GetProperty("OfferedContractTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if ((object)property3 != null && property3.CanWrite)
						{
							property3.SetValue(customerComponent, cust.OfferedContract);
						}
						if ((object)property4 != null && property4.CanWrite)
						{
							property4.SetValue(customerComponent, cust.OfferedContractTime);
						}
					}
				}
				catch (Exception ex2)
				{
					Logger.Warning("ApplyCustomerDataSafely contract data: " + ex2.Message);
				}
				try
				{
					float num3 = 0f;
					object obj4 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(customerComponent, "CurrentAddiction");
					if (obj4 != null && obj4 is float)
					{
						num3 = (float)obj4;
					}
					float dependence = cust.Dependence;
					float value4 = dependence - num3;
					if (Math.Abs(value4) > 0.0001f)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(customerComponent, "CurrentAddiction", dependence);
					}
				}
				catch (Exception ex3)
				{
					Logger.Warning("ApplyCustomerDataSafely dependence: " + ex3.Message);
				}
				try
				{
					PropertyInfo property5 = type.GetProperty("TimeSinceLastDealCompleted", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property6 = type.GetProperty("TimeSinceLastDealOffered", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property7 = type.GetProperty("OfferedDeals", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property8 = type.GetProperty("CompletedDeliveries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property9 = type.GetProperty("TimeSincePlayerApproached", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					PropertyInfo property10 = type.GetProperty("TimeSinceInstantDealOffered", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if ((object)property5 != null && property5.CanWrite)
					{
						property5.SetValue(customerComponent, cust.TimeSinceLastDealCompleted);
					}
					if ((object)property6 != null && property6.CanWrite)
					{
						property6.SetValue(customerComponent, cust.TimeSinceLastDealOffered);
					}
					if ((object)property7 != null && property7.CanWrite)
					{
						property7.SetValue(customerComponent, cust.OfferedDeals);
					}
					if ((object)property8 != null && property8.CanWrite)
					{
						property8.SetValue(customerComponent, cust.CompletedDeals);
					}
					if ((object)property9 != null && property9.CanWrite)
					{
						property9.SetValue(customerComponent, cust.TimeSincePlayerApproached);
					}
					if ((object)property10 != null && property10.CanWrite)
					{
						property10.SetValue(customerComponent, cust.TimeSinceInstantDealOffered);
					}
				}
				catch (Exception ex4)
				{
					Logger.Warning("ApplyCustomerDataSafely basic counters: " + ex4.Message);
				}
			}
			catch (Exception ex5)
			{
				Logger.Warning("ApplyCustomerDataSafely error: " + ex5.Message);
			}
		}

		[HarmonyPatch(typeof(NPC), "OnDestroy")]
		[HarmonyPostfix]
		private static void NPCOnDestroy(NPC __instance)
		{
			try
			{
				NPCEnterableBuilding componentInParent = ((Component)__instance).GetComponentInParent<NPCEnterableBuilding>(true);
				if ((Object)(object)componentInParent != (Object)null)
				{
					global::S1API.Map.Building.Unregister(componentInParent);
				}
			}
			catch
			{
			}
			for (int i = 0; i < NPC.All.Count; i++)
			{
				NPC nPC = NPC.All[i];
				if ((Object)(object)nPC.S1NPC == (Object)(object)__instance)
				{
					nPC.CleanupRuntimeHooks();
					NPC.All.Remove(nPC);
					break;
				}
			}
		}

		[HarmonyPatch(typeof(NPC), "ShouldSave")]
		[HarmonyPrefix]
		private static bool NPC_ShouldSave_Prefix(NPC __instance, ref bool __result)
		{
			try
			{
				if ((Object)(object)__instance != (Object)null && (Object)(object)((Component)__instance).gameObject != (Object)null)
				{
					string name = ((Object)((Component)__instance).gameObject).name;
					if (!string.IsNullOrEmpty(name) && name.StartsWith("S1API_", StringComparison.Ordinal))
					{
						__result = false;
						return false;
					}
				}
			}
			catch
			{
			}
			return true;
		}

		[HarmonyPatch(typeof(NPCManager), "GetSaveString")]
		[HarmonyPrefix]
		private static bool NPCManager_GetSaveString_Prefix(ref string __result)
		{
			//IL_0187: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				if (nPCRegistry == null)
				{
					__result = ((SaveData)new NPCCollectionData(Il2CppReferenceArray<DynamicSaveData>.op_Implicit((DynamicSaveData[])(object)new DynamicSaveData[0]))).GetJson(true);
					return false;
				}
				List<DynamicSaveData> list = new List<DynamicSaveData>();
				for (int i = 0; i < nPCRegistry.Count; i++)
				{
					NPC val = nPCRegistry[i];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						string text = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : null);
						if ((string.IsNullOrEmpty(text) || !text.StartsWith("S1API_", StringComparison.Ordinal)) && val.ShouldSave())
						{
							DynamicSaveData saveData = val.GetSaveData();
							if (saveData != null)
							{
								list.Add(saveData);
							}
						}
					}
					catch (Exception ex)
					{
						Logger.Warning($"NPCManager_GetSaveString_Prefix: Skipping NPC at index {i} due to exception: {ex.Message}");
					}
				}
				__result = ((SaveData)new NPCCollectionData(Il2CppReferenceArray<DynamicSaveData>.op_Implicit(list.ToArray()))).GetJson(true);
				return false;
			}
			catch (Exception ex2)
			{
				Logger.Warning("NPCManager_GetSaveString_Prefix: Exception building save JSON: " + ex2.Message);
				__result = ((SaveData)new NPCCollectionData(Il2CppReferenceArray<DynamicSaveData>.op_Implicit((DynamicSaveData[])(object)new DynamicSaveData[0]))).GetJson(true);
				return false;
			}
		}

		[HarmonyPatch(typeof(NPCHealth), "Load")]
		[HarmonyPrefix]
		private static bool NPCHealthLoad(NPCHealth __instance, NPCHealthData healthData)
		{
			NPC component = ((Component)__instance).GetComponent<NPC>();
			NPC nPC = FindWrapperForS1Npc(component);
			if (nPC != null && nPC.IsCustomNPC)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(NPCInventory), "OnSleepStart")]
		[HarmonyPrefix]
		private static bool NPCInventory_OnSleepStart_Prefix(NPCInventory __instance)
		{
			if (!IsInMainScene())
			{
				return true;
			}
			NPC component = ((Component)__instance).GetComponent<NPC>();
			NPC nPC = (((Object)(object)component != (Object)null) ? FindWrapperForS1Npc(component) : null);
			if (nPC == null || !nPC.IsCustomNPC)
			{
				return true;
			}
			if (!InstanceFinder.IsServer)
			{
				return false;
			}
			try
			{
				if (GetInventoryBool(__instance, "ClearInventoryEachNight"))
				{
					for (int i = 0; i < __instance.ItemSlots.Count; i++)
					{
						ItemSlot val = __instance.ItemSlots[i];
						if (val != null)
						{
							val.ClearStoredInstance(true);
						}
					}
				}
				int num = 0;
				for (int j = 0; j < __instance.ItemSlots.Count; j++)
				{
					ItemSlot obj = __instance.ItemSlots[j];
					if (((obj != null) ? obj.ItemInstance : null) != null)
					{
						num++;
					}
				}
				if (num >= 3)
				{
					return false;
				}
				if (GetInventoryBool(__instance, "RandomCash"))
				{
					int num2 = Random.Range(GetInventoryInt(__instance, "RandomCashMin", 0), GetInventoryInt(__instance, "RandomCashMax", 0));
					if (num2 > 0)
					{
						CashInstance cashInstance = NetworkSingleton<MoneyManager>.Instance.GetCashInstance((float)num2);
						__instance.InsertItem((ItemInstance)(object)cashInstance, false);
					}
				}
				if (GetInventoryBool(__instance, "RandomItems") && GetArrayLength(GetInventoryMember(__instance, "RandomInventoryItems")) > 0)
				{
					__instance.AddRandomItemsToInventory();
				}
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[S1API] NPCInventory.OnSleepStart guard failed for custom NPC: " + ex.Message);
			}
			return false;
		}

		[HarmonyPatch(typeof(NPCHealth), "Revive")]
		[HarmonyPrefix]
		private static bool NPCHealth_Revive_Prefix(NPCHealth __instance)
		{
			if (!IsInMainScene())
			{
				return true;
			}
			NPC component = ((Component)__instance).GetComponent<NPC>();
			NPC nPC = (((Object)(object)component != (Object)null) ? FindWrapperForS1Npc(component) : null);
			if (nPC == null || !nPC.IsCustomNPC)
			{
				return true;
			}
			try
			{
				bool flag = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "<Health>k__BackingField", __instance.MaxHealth);
				bool flag2 = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "IsDead", false);
				bool flag3 = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "IsKnockedOut", false);
				if (!flag || !flag2 || !flag3)
				{
					MelonLogger.Warning($"[S1API] Revive guard reflection failed for custom NPC '{((component != null) ? component.ID : null) ?? "<unknown>"}' (Health={flag}, IsDead={flag2}, IsKnockedOut={flag3}); falling back to original revive.");
					return true;
				}
				NPCBehaviour behaviour = component.Behaviour;
				if (behaviour != null)
				{
					DeadBehaviour deadBehaviour = behaviour.DeadBehaviour;
					if (deadBehaviour != null)
					{
						((Behaviour)deadBehaviour).Disable();
					}
				}
				NPCBehaviour behaviour2 = component.Behaviour;
				if (behaviour2 != null)
				{
					UnconsciousBehaviour unconsciousBehaviour = behaviour2.UnconsciousBehaviour;
					if (unconsciousBehaviour != null)
					{
						((Behaviour)unconsciousBehaviour).Disable();
					}
				}
				UnityEvent onRevive = __instance.onRevive;
				if (onRevive != null)
				{
					onRevive.Invoke();
				}
				return false;
			}
			catch (Exception ex)
			{
				MelonLogger.Warning($"[S1API] Revive guard failed for custom NPC '{((component != null) ? component.ID : null) ?? "<unknown>"}': {ex.Message}. Falling back to original revive.");
				return true;
			}
		}

		[HarmonyPatch(typeof(NPCLoader), "Load")]
		[HarmonyPostfix]
		private static void NPCLoader_Load_Postfix(DynamicSaveData saveData)
		{
			if (!IsInMainScene() || saveData == null)
			{
				return;
			}
			NPCData val = saveData.ExtractBaseData<NPCData>();
			if (val == null || string.IsNullOrEmpty(val.ID))
			{
				return;
			}
			NPC val2 = FindBaseNpcById(val.ID);
			if ((Object)(object)val2 == (Object)null)
			{
				Logger.Warning("[NPCPatches] NPCLoader_Load_Postfix: No base NPC found for '" + val.ID + "'.");
				return;
			}
			NPC nPC = FindWrapperForS1Npc(val2);
			if (nPC == null)
			{
				return;
			}
			nPC.LoadFromDynamic(saveData);
			try
			{
				typeof(NPC).GetMethod("MarkLoadedFromSave", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(nPC, null);
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] NPCLoader_Load_Postfix: Exception marking NPC '" + val.ID + "' as loaded: " + ex.Message);
			}
		}

		internal static NPC? FindBaseNpcById(string? id)
		{
			try
			{
				List<NPC> nPCRegistry = NPCManager.NPCRegistry;
				if (nPCRegistry != null)
				{
					for (int i = 0; i < nPCRegistry.Count; i++)
					{
						NPC val = nPCRegistry[i];
						if ((Object)(object)val != (Object)null && val.ID == id)
						{
							return val;
						}
					}
				}
				for (int j = 0; j < NPC.All.Count; j++)
				{
					NPC nPC = NPC.All[j];
					if (nPC != null && (Object)(object)nPC.S1NPC != (Object)null && nPC.S1NPC.ID == id)
					{
						if (!NPCManager.NPCRegistry.Contains(nPC.S1NPC))
						{
							NPCManager.NPCRegistry.Add(nPC.S1NPC);
						}
						return nPC.S1NPC;
					}
				}
				return null;
			}
			catch (Exception ex)
			{
				Logger.Warning("FindBaseNpcById: Exception searching for ID '" + id + "': " + ex.Message);
				return null;
			}
		}

		private static void EnsureDealerOverflowSlots(Dealer dealer)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			if ((Object)(object)dealer == (Object)null)
			{
				return;
			}
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(dealer, "overflowSlots");
				bool flag = false;
				int num = 0;
				if (obj == null)
				{
					flag = true;
				}
				else
				{
					PropertyInfo propertyInfo = obj.GetType().GetProperty("Length") ?? obj.GetType().GetProperty("Count");
					if (propertyInfo != null)
					{
						num = ((propertyInfo.GetValue(obj) is int num2) ? num2 : 0);
						flag = num == 0;
					}
					else
					{
						flag = true;
					}
				}
				string text = ((dealer != null) ? ((NPC)dealer).ID : null) ?? ((dealer != null) ? ((Object)dealer).name : null) ?? "<unknown>";
				if (flag)
				{
					Il2CppReferenceArray<ItemSlot> val = new Il2CppReferenceArray<ItemSlot>(10L);
					for (int i = 0; i < 10; i++)
					{
						((Il2CppArrayBase<ItemSlot>)(object)val)[i] = new ItemSlot();
						((Il2CppArrayBase<ItemSlot>)(object)val)[i].SetSlotOwner(((Il2CppObjectBase)dealer).Cast<IItemSlotOwner>());
					}
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealer, "overflowSlots", val);
				}
				else
				{
					if (num <= 0 || !(obj is Il2CppReferenceArray<ItemSlot> val2))
					{
						return;
					}
					for (int j = 0; j < num && j < ((Il2CppArrayBase<ItemSlot>)(object)val2).Length; j++)
					{
						ItemSlot val3 = ((Il2CppArrayBase<ItemSlot>)(object)val2)[j];
						if (val3 != null)
						{
							val3.SetSlotOwner(((Il2CppObjectBase)dealer).Cast<IItemSlotOwner>());
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception ensuring dealer overflow slots: " + ex.Message);
			}
		}

		internal static NPC? FindWrapperForS1Npc(NPC? baseNpc)
		{
			try
			{
				if ((Object)(object)baseNpc == (Object)null)
				{
					return null;
				}
				for (int i = 0; i < NPC.All.Count; i++)
				{
					NPC nPC = NPC.All[i];
					if (nPC != null && (Object)(object)nPC.S1NPC == (Object)(object)baseNpc)
					{
						return nPC;
					}
				}
				return null;
			}
			catch (Exception ex)
			{
				Logger.Warning("FindWrapperForS1Npc: Exception searching for base NPC '" + ((baseNpc != null) ? baseNpc.ID : null) + "': " + ex.Message);
				return null;
			}
		}

		internal static bool IsInMainScene()
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			return string.Equals(name, "Main", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsInLoadingScene()
		{
			//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)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			return string.Equals(name, "Loading", StringComparison.OrdinalIgnoreCase) || string.Equals(name, "Persistence", StringComparison.OrdinalIgnoreCase) || name.Contains("Load", StringComparison.OrdinalIgnoreCase);
		}

		[HarmonyPatch(typeof(NPCManager), "GetNPC")]
		[HarmonyPostfix]
		private static void NPCManager_GetNPC_Postfix(string id, ref NPC __result)
		{
			if ((Object)(object)__result != (Object)null || string.IsNullOrWhiteSpace(id))
			{
				return;
			}
			try
			{
				for (int i = 0; i < NPC.All.Count; i++)
				{
					NPC val = NPC.All[i]?.S1NPC;
					if ((Object)(object)val == (Object)null || string.IsNullOrEmpty(val.ID) || !val.ID.Equals(id, StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					__result = val;
					try
					{
						List<NPC> nPCRegistry = NPCManager.NPCRegistry;
						if (nPCRegistry != null && !nPCRegistry.Contains(val))
						{
							nPCRegistry.Add(val);
						}
						break;
					}
					catch
					{
						break;
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("NPCManager_GetNPC_Postfix: exception while backfilling registry for id '" + id + "': " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(NPCMovement), "SetGravityMultiplier")]
		[HarmonyPrefix]
		private static bool NPCMovement_SetGravityMultiplier_Prefix(NPCMovement __instance, float multiplier)
		{
			return ((IEnumerable<ConstantForce>)__instance.ragdollForceComponents?.ToArray()).All((ConstantForce comp) => (Object)(object)comp != (Object)null) ?? true;
		}

		[HarmonyPatch(typeof(NPCHealth), "Awake")]
		[HarmonyPrefix]
		private static bool NPCHealth_Awake_Prefix(NPCHealth __instance)
		{
			if (NetworkSingleton<TimeManager>.InstanceExists)
			{
				return true;
			}
			__instance.NetworkInitialize___Early();
			NPC component = ((Component)__instance).GetComponent<NPC>();
			__instance.npc = component;
			TimeManagerShim.Instance.onSleepStart = (Action)Delegate.Combine(TimeManagerShim.Instance.onSleepStart, new Action(__instance.SleepStart));
			TimeManagerShim.Instance.onHourPass = (Action)Delegate.Combine(TimeManagerShim.Instance.onHourPass, new Action(__instance.OnHourPass));
			__instance.NetworkInitialize__Late();
			return false;
		}

		[HarmonyPatch(typeof(Customer), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void Customer_Awake_Prefix(Customer __instance)
		{
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "CurrentAddiction");
				if (obj != null && obj is float value)
				{
					if (_savedCurrentAddiction.ContainsKey(__instance))
					{
						_savedCurrentAddiction[__instance] = value;
					}
					else
					{
						_savedCurrentAddiction.Add(__instance, value);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPCPatches] Customer_Awake_Prefix exception: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Customer), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Customer_Awake_Postfix(Customer __instance)
		{
			try
			{
				if (_savedCurrentAddiction.TryGetValue(__instance, out var value))
				{
					if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "CurrentAddiction") is float num && Math.Abs(num - value) > 0.0001f)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "CurrentAddiction", value);
					}
					_savedCurrentAddiction.Remove(__instance);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPCPatches] Customer_Awake_Postfix exception: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Dealer), "Load", new Type[]
		{
			typeof(DynamicSaveData),
			typeof(NPCData)
		})]
		[HarmonyPrefix]
		private static bool Dealer_Load_Prefix(Dealer __instance, DynamicSaveData dynamicData, NPCData npcData)
		{
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Expected O, but got Unknown
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			string iD = ((NPC)__instance).ID;
			if (_loadingDealers.Contains(iD))
			{
				return true;
			}
			bool flag = FindWrapperForS1Npc((NPC?)(object)__instance)?.IsCustomNPC ?? false;
			DealerData val = default(DealerData);
			if (!dynamicData.TryExtractBaseData<DealerData>(ref val))
			{
				Logger.Warning("[NPCPatches] Dealer_Load_Prefix: '" + iD + "' missing DealerData. Falling back to original.");
				return true;
			}
			bool flag2 = false;
			if (val.AssignedCustomerIDs != null && ((Il2CppArrayBase<string>)(object)val.AssignedCustomerIDs).Length > 0)
			{
				foreach (string customerID in (Il2CppArrayBase<string>)(object)val.AssignedCustomerIDs)
				{
					if (string.IsNullOrEmpty(customerID))
					{
						continue;
					}
					bool flag3 = NPC.All.Any(delegate(NPC n)
					{
						NPC s1NPC = n.S1NPC;
						return ((s1NPC != null) ? s1NPC.ID : null) == customerID;
					});
					bool flag4 = false;
					try
					{
						List<NPC> nPCRegistry = NPCManager.NPCRegistry;
						if (nPCRegistry != null)
						{
							for (int num = 0; num < nPCRegistry.Count; num++)
							{
								NPC obj = nPCRegistry[num];
								if (((obj != null) ? obj.ID : null) == customerID)
								{
									flag4 = true;
									break;
								}
							}
						}
					}
					catch
					{
					}
					if (!flag3 && flag4)
					{
						continue;
					}
					flag2 = true;
					break;
				}
			}
			if (!flag && !flag2)
			{
				return true;
			}
			_loadingDealers.Add(iD);
			try
			{
				if (!flag)
				{
					((NPC)__instance).Load(dynamicData, npcData);
				}
				DealerData val2 = default(DealerData);
				if (!dynamicData.TryExtractBaseData<DealerData>(ref val2))
				{
					return false;
				}
				if (val2.Recruited)
				{
					__instance.SetIsRecruited((NetworkConnection)null);
				}
				__instance.SetCash(val2.Cash);
				if (val2.AssignedCustomerIDs != null && ((Il2CppArrayBase<string>)(object)val2.AssignedCustomerIDs).Length > 0)
				{
					MelonCoroutines.Start(DelayedCustomerAssignment(__instance, Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)val2.AssignedCustomerIDs)));
				}
				if (val2.ActiveContractGUIDs != null)
				{
					for (int num2 = 0; num2 < ((Il2CppArrayBase<string>)(object)val2.ActiveContractGUIDs).Length; num2++)
					{
						if (!GUIDManager.IsGUIDValid(((Il2CppArrayBase<string>)(object)val2.ActiveContractGUIDs)[num2]))
						{
							Logger.Warning("Invalid contract GUID: " + ((Il2CppArrayBase<string>)(object)val2.ActiveContractGUIDs)[num2]);
							continue;
						}
						Contract val3 = GUIDManager.GetObject<Contract>(new Guid(((Il2CppArrayBase<string>)(object)val2.ActiveContractGUIDs)[num2]));
						if ((Object)(object)val3 != (Object)null)
						{
							Type typeFromHandle = typeof(Dealer);
							MethodInfo method = typeFromHandle.GetMethod("AddContract", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
							if (method != null)
							{
								method.Invoke(__instance, new object[1] { val3 });
							}
						}
					}
				}
				if (val2.HasBeenRecommended)
				{
					__instance.MarkAsRecommended();
				}
				if (val2.OverflowItems != null)
				{
					try
					{
						EnsureDealerOverflowSlots(__instance);
						object obj3 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "overflowSlots");
						if (obj3 != null)
						{
							int num3 = (((obj3.GetType().GetProperty("Length") ?? obj3.GetType().GetProperty("Count"))?.GetValue(obj3) is int num4) ? num4 : 0);
							if (num3 > 0)
							{
								ItemSlot[] array = (ItemSlot[])(object)new ItemSlot[num3];
								if (obj3 is Il2CppReferenceArray<ItemSlot> val4)
								{
									for (int num5 = 0; num5 < num3 && num5 < ((Il2CppArrayBase<ItemSlot>)(object)val4).Length; num5++)
									{
										ItemSlot val5 = ((Il2CppArrayBase<ItemSlot>)(object)val4)[num5];
										if (val5 == null)
										{
											val5 = new ItemSlot();
											val5.SetSlotOwner(((Il2CppObjectBase)__instance).Cast<IItemSlotOwner>());
										}
										array[num5] = val5;
									}
								}
								if (val2.OverflowItems != null && array != null && array.Length != 0)
								{
									val2.OverflowItems.LoadTo(Il2CppReferenceArray<ItemSlot>.op_Implicit(array));
								}
							}
						}
					}
					catch (Exception ex)
					{
						Logger.Warning("Failed to load overflow items for dealer '" + (((__instance != null) ? ((NPC)__instance).ID : null) ?? "unknown") + "': " + ex.Message);
						Logger.Warning("Stack trace: " + ex.StackTrace);
					}
				}
				string text = default(string);
				if (flag && dynamicData.TryGetData("Inventory", ref text))
				{
					DeserializedItemSet value = default(DeserializedItemSet);
					if (ItemSet.TryDeserialize(text, ref value))
					{
						_pendingInventoryLoads[((NPC)__instance).ID] = value;
					}
					else
					{
						Logger.Warning("Failed to deserialize inventory data for custom NPC dealer " + ((NPC)__instance).ID);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Warning("Dealer_Load_Prefix failed for '" + ((__instance != null) ? ((NPC)__instance).ID : null) + "': " + ex2.Message);
				Logger.Warning("Stack trace: " + ex2.StackTrace);
			}
			finally
			{
				_loadingDealers.Remove(iD);
			}
			return false;
		}

		[HarmonyPatch(typeof(NPCScheduleManager), "GetActionsTotallyOccurringWithinRange")]
		[HarmonyPrefix]
		private static bool NPCScheduleManager_GetActionsTotallyOccurringWithinRange_Prefix(NPCScheduleManager __instance, int min, int max, bool checkShouldStart, ref List<NPCAction> __result)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "ActionList");
				if (obj == null)
				{
					return true;
				}
				int num = 0;
				if (obj is List<NPCAction> val)
				{
					num = val.Count;
					List<NPCAction> val2 = new List<NPCAction>();
					for (int i = 0; i < num; i++)
					{
						NPCAction val3 = null;
						val3 = val[i];
						if (!((Object)(object)val3 == (Object)null) && !((Object)(object)((Component)val3).gameObject == (Object)null) && ((Component)val3).gameObject.activeInHierarchy && (!checkShouldStart || val3.ShouldStart()) && TimeManager.IsGivenTimeWithinRange(val3.StartTime, min, max) && TimeManager.IsGivenTimeWithinRange(val3.GetEndTime(), min, max))
						{
							val2.Add(val3);
						}
					}
					try
					{
						object obj2 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "orderByDescending");
						if (obj2 != null && obj2 is IComparer<NPCAction> val4)
						{
							val2.Sort(val4);
						}
					}
					catch
					{
					}
					__result = val2;
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("NPCScheduleManager_GetActionsTotallyOccurringWithinRange_Prefix failed: " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
				return true;
			}
		}

		[HarmonyPatch(typeof(NPCScheduleManager), "InitializeActions")]
		[HarmonyPrefix]
		private static bool NPCScheduleManager_InitializeActions_Prefix(NPCScheduleManager __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			try
			{
				Il2CppArrayBase<NPCAction> componentsInChildren = ((Component)__instance).gameObject.GetComponentsInChildren<NPCAction>(true);
				List<NPCAction> val = new List<NPCAction>();
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if ((Object)(object)componentsInChildren[i] != (Object)null)
					{
						val.Add(componentsInChildren[i]);
					}
				}
				NPCAction[] array = (NPCAction[])(object)new NPCAction[val.Count];
				for (int j = 0; j < val.Count; j++)
				{
					array[j] = val[j];
				}
				for (int k = 0; k < array.Length - 1; k++)
				{
					for (int l = 0; l < array.Length - k - 1; l++)
					{
						if (CompareNPCActions(array[l], array[l + 1]) > 0)
						{
							NPCAction val2 = array[l];
							array[l] = array[l + 1];
							array[l + 1] = val2;
						}
					}
				}
				val.Clear();
				for (int m = 0; m < array.Length; m++)
				{
					val.Add(array[m]);
				}
				if (!Application.isPlaying)
				{
					for (int n = 0; n < val.Count; n++)
					{
						NPCAction val3 = val[n];
						if ((Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).transform != (Object)null)
						{
							((Object)((Component)val3).transform).name = val3.GetName() + " (" + val3.GetTimeDescription() + ")";
							((Component)val3).transform.SetAsLastSibling();
						}
					}
				}
				if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "ActionList", val))
				{
					Logger.Warning("NPCScheduleManager_InitializeActions_Prefix: Failed to set ActionList on " + (((object)__instance)?.GetType().Name ?? "null"));
					try
					{
						PropertyInfo property = ((object)__instance).GetType().GetProperty("ActionList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						FieldInfo field = ((object)__instance).GetType().GetField("ActionList", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						Type obj = property?.PropertyType ?? field?.FieldType;
						Logger.Warning("ActionList member type: " + (obj?.FullName ?? "null") + ", list type: " + ((object)val).GetType().FullName);
					}
					catch
					{
					}
					return true;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("NPCScheduleManager_InitializeActions_Prefix failed: " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
				return true;
			}
			return false;
		}

		private static IEnumerator DelayedCustomerAssignment(Dealer dealer, string[] customerIDs)
		{
			yield return null;
			yield return null;
			yield return (object)new WaitForSeconds(0.1f);
			if ((Object)(object)dealer == (Object)null || customerIDs == null)
			{
				yield break;
			}
			try
			{
				_ = ((NPC)dealer).ID ?? ((Object)dealer).name ?? "<unknown>";
			}
			catch
			{
			}
			foreach (string customerID in customerIDs)
			{
				if (string.IsNullOrEmpty(customerID))
				{
					continue;
				}
				NPC npc = null;
				for (int retry = 0; retry < 5; retry++)
				{
					if (!((Object)(object)npc == (Object)null))
					{
						break;
					}
					try
					{
						npc = NPCManager.GetNPC(customerID);
					}
					catch (Exception ex)
					{
						Logger.Warning($"Exception finding customer NPC {customerID} (retry {retry}): {ex.Message}");
					}
					if ((Object)(object)npc == (Object)null && retry < 4)
					{
						yield return (object)new WaitForSeconds(0.1f);
					}
				}
				if ((Object)(object)npc == (Object)null)
				{
					Logger.Warning("Failed to find customer NPC with ID " + customerID + " after retries");
					continue;
				}
				Customer customer = null;
				try
				{
					customer = ((Component)npc).GetComponent<Customer>();
				}
				catch (Exception ex2)
				{
					Exception ex3 = ex2;
					Logger.Warning("Exception getting Customer component for " + customerID + ": " + ex3.Message);
				}
				if ((Object)(object)customer == (Object)null)
				{
					string npcName = (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(npc, "fullName") as string) ?? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(npc, "FullName") as string) ?? ((Object)npc).name;
					Logger.Warning($"NPC {npcName} (ID: {customerID}) is not a customer");
				}
				else
				{
					try
					{
						dealer.AddCustomer_Server(customer.NPC.ID);
					}
					catch (Exception ex2)
					{
						Exception ex4 = ex2;
						Logger.Warning("Exception assigning customer " + customerID + " to dealer: " + ex4.Message);
					}
				}
			}
		}
	}
	internal static class PhoneAppRegistry
	{
		public static readonly List<global::S1API.PhoneApp.PhoneApp> RegisteredApps = new List<global::S1API.PhoneApp.PhoneApp>();

		public static void Register(global::S1API.PhoneApp.PhoneApp app)
		{
			RegisteredApps.Add(app);
		}
	}
	[HarmonyPatch]
	internal class PlayerPatches
	{
		private static readonly Log Logger;

		static PlayerPatches()
		{
			Logger = new Log("PlayerPatches");
			try
			{
				Type typeFromHandle = typeof(Player);
				Player.onLocalPlayerSpawned += Action.op_Implicit((Action)HandleLocalPlayerSpawned);
				Player.onPlayerSpawned += Action<Player>.op_Implicit((Action<Player>)HandlePlayerSpawned);
				Player.onPlayerDespawned += Action<Player>.op_Implicit((Action<Player>)HandlePlayerDespawned);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to subscribe to game player events: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		private static void SubscribeToStandardEvent(Type targetType, string eventName, Delegate handler)
		{
			Delegate value = ((global::S1API.Internal.Utils.ReflectionUtils.TryGetStaticFieldOrProperty(targetType, eventName) is Delegate a) ? Delegate.Combine(a, handler) : handler);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetStaticFieldOrProperty(targetType, eventName, value);
		}

		private static void SubscribeToIL2CPPEvent(Type targetType, string eventName, string methodName, Type? parameterType)
		{
			MethodInfo method = typeof(PlayerPatches).GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				Logger.Warning("Could not find player event handler '" + methodName + "'.");
				return;
			}
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetStaticFieldOrProperty(targetType, eventName);
			object obj2;
			if (parameterType == null)
			{
				Action action = (Action)Delegate.CreateDelegate(typeof(Action), method);
				obj2 = DelegateSupport.ConvertDelegate<Action>((Delegate)action);
			}
			else
			{
				Type type = typeof(Action<>).MakeGenericType(parameterType);
				Delegate obj3 = Delegate.CreateDelegate(type, method);
				Type type2 = typeof(Action<>).MakeGenericType(parameterType);
				MethodInfo method2 = typeof(DelegateSupport).GetMethod("ConvertDelegate", BindingFlags.Static | BindingFlags.Public);
				if (method2 == null)
				{
					Logger.Warning("Could not find IL2CPP delegate conversion method.");
					return;
				}
				MethodInfo methodInfo = method2.MakeGenericMethod(type2);
				obj2 = methodInfo.Invoke(null, new object[1] { obj3 });
			}
			if (obj2 == null)
			{
				Logger.Warning("Could not convert player event handler '" + methodName + "' to an IL2CPP delegate.");
			}
			else if (obj != null)
			{
				Delegate value = Delegate.Combine((Delegate)((obj is Delegate) ? obj : null), (Delegate)((obj2 is Delegate) ? obj2 : null));
				global::S1API.Internal.Utils.ReflectionUtils.TrySetStaticFieldOrProperty(targetType, eventName, value);
			}
			else
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetStaticFieldOrProperty(targetType, eventName, obj2);
			}
		}

		private static void HandleLocalPlayerSpawned()
		{
			try
			{
				Player player = Player.All.FirstOrDefault((Player p) => p.IsLocal);
				if (player != null)
				{
					Player.RaiseLocalPlayerSpawned(player);
				}
				else
				{
					Logger.Warning("Game fired onLocalPlayerSpawned but no API Player instance found in Player.All list");
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error handling local player spawned event: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		private static void HandlePlayerSpawned(Player gamePlayer)
		{
			try
			{
				if ((Object)(object)gamePlayer == (Object)null)
				{
					Logger.Warning("Game fired onPlayerSpawned with null player");
					return;
				}
				Player player = Player.All.FirstOrDefault((Player p) => (Object)(object)p.S1Player == (Object)(object)gamePlayer);
				if (player != null)
				{
					Player.RaisePlayerSpawned(player);
					return;
				}
				Logger.Warning($"Game fired onPlayerSpawned for {gamePlayer.PlayerName} but no API Player instance found in Player.All list (count: {Player.All.Count})");
			}
			catch (Exception ex)
			{
				Logger.Error("Error handling player spawned event: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		private static void HandlePlayerDespawned(Player gamePlayer)
		{
			try
			{
				if ((Object)(object)gamePlayer == (Object)null)
				{
					Logger.Warning("Game fired onPlayerDespawned with null player");
					return;
				}
				Player player = Player.All.FirstOrDefault((Player p) => (Object)(object)p.S1Player == (Object)(object)gamePlayer);
				if (player != null)
				{
					Player.RaisePlayerDespawned(player);
				}
				else
				{
					Logger.Warning("Game fired onPlayerDespawned for " + gamePlayer.PlayerName + " but no API Player instance found in Player.All list");
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error handling player despawned event: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		[HarmonyPatch(typeof(Player), "Awake")]
		[HarmonyPostfix]
		private static void PlayerAwake(Player __instance)
		{
			try
			{
				new Player(__instance);
			}
			catch (Exception ex)
			{
				Logger.Error("Error in PlayerAwake: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		[HarmonyPatch(typeof(Player), "OnDestroy")]
		[HarmonyPostfix]
		private static void PlayerOnDestroy(Player __instance)
		{
			try
			{
				Player player = Player.All.FirstOrDefault((Player player2) => (Object)(object)player2.S1Player == (Object)(object)__instance);
				if (player != null)
				{
					Player.All.Remove(player);
				}
				else
				{
					Logger.Warning("OnDestroy called but API Player instance not found in Player.All list");
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in PlayerOnDestroy: " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
		}

		[HarmonyPatch(typeof(PlayerHealth), "TakeDamage")]
		[HarmonyPrefix]
		private static bool PlayerHealth_TakeDamage(PlayerHealth __instance, float damage, bool flinch = true, bool playBloodMist = true)
		{
			Player player = __instance.Player;
			if ((Object)(object)player != (Object)null && Player.IsPlayerInvincible(player))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class ProductEffectPatches
	{
		private static readonly Log Logger = new Log("ProductEffectPatches");

		private static Dictionary<string, Type>? _npcWrapperTypeById;

		private static IEnumerable<MethodBase> TargetMethods()
		{
			Type typeFromHandle = typeof(Player);
			Type typeFromHandle2 = typeof(NPC);
			Type typeFromHandle3 = typeof(ProductItemInstance);
			return new MethodInfo[4]
			{
				typeFromHandle3.GetMethod("ApplyEffectsToPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeFromHandle }, null),
				typeFromHandle3.GetMethod("ApplyEffectsToNPC", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeFromHandle2 }, null),
				typeFromHandle3.GetMethod("ClearEffectsFromPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeFromHandle }, null),
				typeFromHandle3.GetMethod("ClearEffectsFromNPC", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeFromHandle2 }, null)
			}.Where((MethodInfo method) => method != null).Cast<MethodBase>();
		}

		[HarmonyPrefix]
		private static bool ProductEffects_Prefix(ProductItemInstance __instance, object __0, MethodBase __originalMethod)
		{
			bool flag = __originalMethod?.Name == "ClearEffectsFromPlayer" || __originalMethod?.Name == "ClearEffectsFromNPC";
			if (__instance == null || __0 == null)
			{
				return true;
			}
			List<Effect> list = ResolveEffects(__instance);
			Player player = Player.All.FirstOrDefault((Player p) => p.IsLocal);
			Player val = (Player)((__0 is Player) ? __0 : null);
			NPC val2 = (NPC)((__0 is NPC) ? __0 : null);
			if ((Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null)
			{
				return true;
			}
			if ((Object)(object)val != (Object)null && (player == null || (Object)(object)val != (Object)(object)player.S1Player))
			{
				return true;
			}
			NPC nPC = (((Object)(object)val2 != (Object)null) ? ResolveApiNpc(val2) : null);
			ProductConsumptionContext context = null;
			ProductConsumptionProfileRegistration registration = null;
			if (list == null && !ProductConsumptionProfileDispatcher.TryResolveRegisteredContext(__instance, ((Object)(object)val != (Object)null) ? player : null, nPC, ((val2 != null) ? val2.ID : null) ?? string.Empty, out context, out registration))
			{
				return true;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			while (list != null && num < list.Count)
			{
				Effect val3 = list[num];
				if (!((Object)(object)val3 == (Object)null))
				{
					string iD = val3.ID;
					if (!string.IsNullOrWhiteSpace(iD) && hashSet.Add(iD))
					{
						try
						{
							if ((Object)(object)val != (Object)null)
							{
								bool allowDefaultEffect;
								bool flag2 = (flag ? ProductManager.TryInvokeEffectClearCallback(iD, player, out allowDefaultEffect) : ProductManager.TryInvokeEffectCallback(iD, player, out allowDefaultEffect));
								if (!flag2 || allowDefaultEffect)
								{
									if (flag)
									{
										val3.ClearFromPlayer(val);
									}
									else
									{
										val3.ApplyToPlayer(val);
									}
								}
							}
							else
							{
								bool allowDefaultEffect2 = false;
								bool flag3 = nPC != null && (flag ? ProductManager.TryInvokeNpcEffectClearCallback(iD, nPC, out allowDefaultEffect2) : ProductManager.TryInvokeNpcEffectCallback(iD, nPC, out allowDefaultEffect2));
								if (!flag3 || allowDefaultEffect2)
								{
									if (flag)
									{
										val3.ClearFromNPC(val2);
									}
									else
									{
										val3.ApplyToNPC(val2);
									}
								}
							}
						}
						catch (Exception ex)
						{
							string value = (flag ? "clear" : "apply");
							Logger.Error($"Exception while invoking effect {value} callback for '{iD}': {ex.Message}");
							Logger.Error(ex.StackTrace ?? string.Empty);
						}
					}
				}
				num++;
			}
			if ((Object)(object)val != (Object)null)
			{
				ProductConsumptionProfileDispatcher.DispatchPlayer(__instance, val, player, flag, context, registration);
			}
			else if ((Object)(object)val2 != (Object)null)
			{
				ProductConsumptionProfileDispatcher.DispatchNpc(__instance, val2, nPC, val2.ID ?? string.Empty, flag, context, registration);
			}
			return false;
		}

		private static List<Effect>? ResolveEffects(ProductItemInstance productInstance)
		{
			try
			{
				ProductInstance productInstance2 = new ProductInstance(productInstance);
				List<Effect> list = (from property in productInstance2.Properties.OfType<ProductPropertyWrapper>()
					select property.InnerProperty into effect
					where (Object)(object)effect != (Object)null
					select effect).ToList();
				if (list.Count > 0)
				{
					return list;
				}
			}
			catch (Exception ex)
			{
				Logger.Error("ResolveEffects wrapper path failed: " + ex.Message);
			}
			List<Effect> list2 = ExtractEffectsFromObject(TryGetPropertyValue(productInstance, "Properties"));
			if (list2 != null && list2.Count > 0)
			{
				return list2;
			}
			ItemDefinition definition = ((ItemInstance)productInstance).Definition;
			List<Effect> list3 = ExtractEffectsFromObject(TryGetPropertyValue(definition, "Properties"));
			if (list3 != null && list3.Count > 0)
			{
				return list3;
			}
			return null;
		}

		private static object? TryGetPropertyValue(object? instance, string propertyName)
		{
			return instance?.GetType().GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(instance);
		}

		private static List<Effect>? ExtractEffectsFromObject(object? propertiesObject)
		{
			if (propertiesObject == null)
			{
				return null;
			}
			List<Effect> list = new List<Effect>();
			if (propertiesObject is IEnumerable enumerable)
			{
				foreach (object item in enumerable)
				{
					Effect val = (Effect)((item is Effect) ? item : null);
					if (val != null)
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		private static NPC? ResolveApiNpc(NPC? targetNpc)
		{
			if ((Object)(object)targetNpc == (Object)null)
			{
				return null;
			}
			NPC nPC = NPC.All.FirstOrDefault(delegate(NPC npc)
			{
				int result;
				if (!((Object)(object)npc?.S1NPC == (Object)(object)targetNpc))
				{
					object value2;
					if (npc == null)
					{
						value2 = null;
					}
					else
					{
						NPC s1NPC = npc.S1NPC;
						value2 = ((s1NPC != null) ? s1NPC.ID : null);
					}
					result = ((!string.IsNullOrWhiteSpace((string?)value2) && !string.IsNullOrWhiteSpace(targetNpc.ID) && string.Equals(npc.S1NPC.ID, targetNpc.ID, StringComparison.OrdinalIgnoreCase)) ? 1 : 0);
				}
				else
				{
					result = 1;
				}
				return (byte)result != 0;
			});
			if (nPC != null)
			{
				return nPC;
			}
			if (string.IsNullOrWhiteSpace(targetNpc.ID))
			{
				return null;
			}
			try
			{
				Dictionary<string, Type> npcWrapperTypeById = GetNpcWrapperTypeById();
				if (!npcWrapperTypeById.TryGetValue(targetNpc.ID, out var value))
				{
					return null;
				}
				NPC nPC2 = Activator.CreateInstance(value, nonPublic: true) as NPC;
				if ((Object)(object)nPC2?.S1NPC == (Object)(object)targetNpc)
				{
					return nPC2;
				}
				return NPC.All.FirstOrDefault((NPC npc) => (Object)(object)npc?.S1NPC == (Object)(object)targetNpc);
			}
			catch (Exception ex)
			{
				Logger.Error("NPC intercept: wrapper creation failed for '" + targetNpc.ID + "': " + ex.Message);
				return null;
			}
		}

		private static Dictionary<string, Type> GetNpcWrapperTypeById()
		{
			if (_npcWrapperTypeById != null)
			{
				return _npcWrapperTypeById;
			}
			Dictionary<string, Type> dictionary = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase);
			Type typeFromHandle = typeof(NPC);
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				Type[] types;
				try
				{
					types = assembly.GetTypes();
				}
				catch
				{
					continue;
				}
				Type[] array = types;
				foreach (Type type in array)
				{
					if (type == null || type.IsAbstract || !typeFromHandle.IsAssignableFrom(type))
					{
						continue;
					}
					PropertyInfo property = type.GetProperty("NPCId", BindingFlags.Static | BindingFlags.Public);
					if (!(property == null) && !(property.PropertyType != typeof(string)))
					{
						string text = property.GetValue(null) as string;
						if (!string.IsNullOrWhiteSpace(text) && !dictionary.ContainsKey(text))
						{
							dictionary[text] = type;
						}
					}
				}
			}
			_npcWrapperTypeById = dictionary;
			return dictionary;
		}
	}
	[HarmonyPatch]
	internal static class ProductManagerUiPatches
	{
		private static readonly Log Logger = new Log("ProductManagerUiPatches");

		[HarmonyPatch(typeof(PropertyUtility), "Awake")]
		[HarmonyPostfix]
		private static void PropertyUtilityAwakePostfix()
		{
			ProductKindMetadataRegistrationRegistry.ApplyAll("PropertyUtility.Awake");
		}

		[HarmonyPatch(typeof(ProductManagerApp), "Start")]
		[HarmonyPrefix]
		private static void ProductManagerStartPrefix(ProductManagerApp __instance)
		{
			SafeApply(__instance, "ProductManagerApp.Start");
		}

		[HarmonyPatch(typeof(ProductManagerApp), "CreateEntry")]
		[HarmonyPrefix]
		private static bool CreateEntryPrefix(ProductManagerApp __instance, ProductDefinition definition)
		{
			try
			{
				return ProductManagerUiRuntime.BeforeCreateEntry(__instance, definition);
			}
			catch (Exception value)
			{
				Logger.Error($"Product Manager entry preparation failed for '{((definition != null) ? ((BaseItemDefinition)definition).ID : null)}': {value}");
				return true;
			}
		}

		[HarmonyPatch(typeof(ProductManagerApp), "CreateEntry")]
		[HarmonyPostfix]
		private static void CreateEntryPostfix(ProductManagerApp __instance, ProductDefinition definition)
		{
			try
			{
				ProductManagerUiRuntime.AfterCreateEntry(__instance, definition);
			}
			catch (Exception value)
			{
				Logger.Error($"Product Manager entry routing failed for '{((definition != null) ? ((BaseItemDefinition)definition).ID : null)}': {value}");
			}
		}

		[HarmonyPatch(typeof(ProductManagerApp), "CreateFavouriteEntry")]
		[HarmonyPrefix]
		private static bool CreateFavouriteEntryPrefix(ProductDefinition definition)
		{
			try
			{
				return ProductManagerUiRuntime.AllowFavouriteRemoval();
			}
			catch (Exception value)
			{
				Logger.Error($"Product Manager favourite preparation failed for '{((definition != null) ? ((BaseItemDefinition)definition).ID : null)}': {value}");
				return true;
			}
		}

		[HarmonyPatch(typeof(ProductManagerApp), "RemoveFavouriteEntry")]
		[HarmonyPrefix]
		private static bool RemoveFavouriteEntryPrefix(ProductDefinition definition)
		{
			try
			{
				return ProductManagerUiRuntime.AllowFavouriteEntry(definition);
			}
			catch (Exception value)
			{
				Logger.Error($"Product Manager favourite removal failed for '{((definition != null) ? ((BaseItemDefinition)definition).ID : null)}': {value}");
				return true;
			}
		}

		[HarmonyPatch(typeof(ProductManagerApp), "SetOpen")]
		[HarmonyPostfix]
		private static void SetOpenPostfix(ProductManagerApp __instance)
		{
			SafeApply(__instance, "ProductManagerApp.SetOpen");
		}

		private static void SafeApply(ProductManagerApp app, string phase)
		{
			try
			{
				ProductManagerUiRuntime.Apply(app, new List<ProductKindMetadata>(ProductKindMetadataRegistry.All));
			}
			catch (Exception value)
			{
				Logger.Error($"Product Manager metadata reconciliation failed during {phase}: {value}");
			}
		}
	}
	[HarmonyPatch]
	internal static class ProductPackagingContentPatches
	{
		[HarmonyPatch(typeof(MultiTypeVisualsSetter), "ApplyVisuals", new Type[] { typeof(ProductItemInstance) })]
		[HarmonyPrefix]
		private static bool ApplyVisualsPrefix(MultiTypeVisualsSetter __instance, ProductItemInstance itemInstance)
		{
			if (ProductPackagingContentRuntime.IsNativeIconFallbackActive)
			{
				return true;
			}
			return !ProductPackagingContentRuntime.TryApply(__instance, itemInstance);
		}

		[HarmonyPatch(typeof(ProductIconManager), "GenerateIcons")]
		[HarmonyPrefix]
		private static void GenerateIconsPrefix()
		{
			ProductPackagingContentRuntime.BeginNativeIconBatch();
		}

		[HarmonyPatch(typeof(ProductIconManager), "GenerateIcons")]
		[HarmonyFinalizer]
		private static Exception? GenerateIconsFinalizer(Exception? __exception)
		{
			ProductPackagingContentRuntime.EndNativeIconBatch();
			return __exception;
		}

		[HarmonyPatch(typeof(IconGenerator), "GeneratePackagingIcon")]
		[HarmonyPrefix]
		private static bool GeneratePackagingIconPrefix(IconGenerator __instance, string packagingID, string productID, ref Texture2D __result, ref bool __state)
		{
			if (ProductPackagingContentRuntime.TryDeferNativeBatchPackagingIcon(packagingID, productID))
			{
				__state = true;
				return true;
			}
			if (!ProductPackagingContentRuntime.TryGeneratePackagingIcon(__instance, packagingID, productID, out Texture2D texture))
			{
				return true;
			}
			__result = texture;
			return false;
		}

		[HarmonyPatch(typeof(IconGenerator), "GeneratePackagingIcon")]
		[HarmonyFinalizer]
		private static Exception? GeneratePackagingIconFinalizer(bool __state, Exception? __exception)
		{
			if (__state)
			{
				ProductPackagingContentRuntime.EndNativeIconFallback();
			}
			return __exception;
		}

		[HarmonyPatch(typeof(ProductIconManager), "GetIcon", new Type[]
		{
			typeof(string),
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static bool GetIconPrefix(string productID, string packagingID, ref Sprite __result)
		{
			if (!ProductPackagingContentRuntime.TryGetPackagingIcon(productID, packagingID, out Sprite icon))
			{
				return true;
			}
			__result = icon;
			return false;
		}
	}
	[HarmonyPatch(typeof(NewMixDiscoveryBox), "ShowProduct")]
	internal static class ProductPresentationPatches
	{
		[HarmonyPostfix]
		private static void ShowProductPostfix(NewMixDiscoveryBox __instance, ProductDefinition baseDefinition, List<Effect> properties)
		{
			if (!((Object)(object)((__instance != null) ? __instance.Visuals : null) == (Object)null))
			{
				CustomProductPresentationRuntime.ApplyDiscoveryVisual(__instance.Visuals, baseDefinition, properties);
			}
		}
	}
	[HarmonyPatch]
	internal static class PropertyUtilityPatches
	{
		private static readonly Log Logger = new Log("PropertyUtilityPatches");

		private static readonly EDrugType[] MixDrugs;

		private static MethodBase? TargetMethod()
		{
			return typeof(PropertyUtility).GetMethods(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault((MethodInfo method) => method.Name == "GetProperties" && method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType != typeof(int));
		}

		[HarmonyPostfix]
		private static void GetProperties_Postfix(List<string> __0, List<Effect> __result)
		{
			try
			{
				if (__0 == null || __result == null || __result.Count == __0.Count)
				{
					return;
				}
				ProductManager instance = NetworkSingleton<ProductManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				for (int i = 0; i < __0.Count; i++)
				{
					string text = __0[i];
					if (!string.IsNullOrEmpty(text) && !ContainsId(__result, text))
					{
						Effect val = FindInMixMaps(instance, text) ?? FindInIngredients(instance, text);
						if ((Object)(object)val != (Object)null && !ContainsId(__result, text))
						{
							__result.Add(val);
						}
					}
				}
			}
			catch (Exception value)
			{
				Logger.Error($"GetProperties recovery failed: {value}");
			}
		}

		private static bool ContainsId(List<Effect> list, string id)
		{
			for (int i = 0; i < list.Count; i++)
			{
				Effect val = list[i];
				if ((Object)(object)val != (Object)null && string.Equals(val.ID, id, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static Effect? FindInMixMaps(ProductManager productManager, string id)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			EDrugType[] mixDrugs = MixDrugs;
			foreach (EDrugType val in mixDrugs)
			{
				MixerMap mixerMap = productManager.GetMixerMap(val);
				if ((Object)(object)mixerMap == (Object)null || mixerMap.Effects == null)
				{
					continue;
				}
				for (int j = 0; j < mixerMap.Effects.Count; j++)
				{
					MixerMapEffect val2 = mixerMap.Effects[j];
					if ((Object)(object)((val2 != null) ? val2.Property : null) != (Object)null && string.Equals(val2.Property.ID, id, StringComparison.OrdinalIgnoreCase))
					{
						return val2.Property;
					}
				}
			}
			return null;
		}

		private static Effect? FindInIngredients(ProductManager productManager, string id)
		{
			List<PropertyItemDefinition> validMixIngredients = productManager.ValidMixIngredients;
			if (validMixIngredients == null)
			{
				return null;
			}
			for (int i = 0; i < validMixIngredients.Count; i++)
			{
				PropertyItemDefinition obj = validMixIngredients[i];
				List<Effect> val = ((obj != null) ? obj.Properties : null);
				if (val == null)
				{
					continue;
				}
				for (int j = 0; j < val.Count; j++)
				{
					Effect val2 = val[j];
					if ((Object)(object)val2 != (Object)null && string.Equals(val2.ID, id, StringComparison.OrdinalIgnoreCase))
					{
						return val2;
					}
				}
			}
			return null;
		}

		static PropertyUtilityPatches()
		{
			EDrugType[] array = new EDrugType[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			MixDrugs = (EDrugType[])(object)array;
		}
	}
	[HarmonyPatch]
	internal class QuestPatches
	{
		private static readonly Log Logger = new Log("QuestPatches");

		private static readonly Dictionary<string, QuestData> PendingQuestDataByGuid = new Dictionary<string, QuestData>();

		[HarmonyPatch(typeof(SaveManager), "Save", new Type[] { typeof(string) })]
		[HarmonyPostfix]
		private static void SaveManager_Save_Postfix(string saveFolderPath)
		{
			try
			{
				SaveManager instance = Singleton<SaveManager>.Instance;
				string[] array = new string[2]
				{
					"Modded",
					Path.Combine("Modded", "Quests")
				};
				string[] array2 = array;
				foreach (string text in array2)
				{
					if (!instance.ApprovedBaseLevelPaths.Contains(text))
					{
						instance.ApprovedBaseLevelPaths.Add(text);
					}
				}
				string text2 = Path.Combine(saveFolderPath, "Modded", "Quests");
				Directory.CreateDirectory(text2);
				try
				{
					string[] directories = Directory.GetDirectories(text2);
					string[] array3 = directories;
					foreach (string path in array3)
					{
						string fileName = Path.GetFileName(path);
						if (string.IsNullOrEmpty(fileName))
						{
							continue;
						}
						string text3 = ((fileName.StartsWith("Quest_") && fileName.Length > 6) ? fileName.Substring(6) : string.Empty);
						bool flag = false;
						if (!string.IsNullOrEmpty(text3))
						{
							foreach (Quest quest in QuestManager.Quests)
							{
								if (quest == null || (Object)(object)quest.S1Quest == (Object)null || quest.S1Quest.StaticGUID != text3)
								{
									continue;
								}
								flag = true;
								break;
							}
						}
						if (!flag)
						{
							try
							{
								Directory.Delete(path, recursive: true);
							}
							catch
							{
							}
						}
					}
				}
				catch (Exception)
				{
				}
				foreach (Quest quest2 in QuestManager.Quests)
				{
					string text4 = quest2.GetType().Namespace;
					if (text4 != null && !text4.StartsWith("ScheduleOne"))
					{
						List<string> extraSaveables = new List<string>();
						quest2.SaveInternal(text2, ref extraSaveables);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Error("[S1API] ❌ Failed to save modded quests:\n" + ex2);
			}
		}

		[HarmonyPatch(typeof(QuestsLoader), "Load")]
		[HarmonyPrefix]
		private static void QuestsLoaderLoad_Prefix(string mainPath)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!File.Exists(mainPath))
			{
				return;
			}
			string text = File.ReadAllText(mainPath);
			QuestManagerData val = JsonUtility.FromJson<QuestManagerData>(text);
			if (((val != null) ? val.Quests : null) == null)
			{
				return;
			}
			foreach (QuestData item in (Il2CppArrayBase<QuestData>)(object)val.Quests)
			{
				if (item == null || string.IsNullOrEmpty(item.GUID))
				{
					continue;
				}
				try
				{
					Quest val2 = GUIDManager.GetObject<Quest>(new Guid(item.GUID));
					if ((Object)(object)val2 == (Object)null)
					{
						PendingQuestDataByGuid[item.GUID] = item;
					}
				}
				catch
				{
					PendingQuestDataByGuid[item.GUID] = item;
				}
			}
		}

		[HarmonyPatch(typeof(QuestsLoader), "Load")]
		[HarmonyPostfix]
		private static void QuestsLoaderLoad_Postfix(QuestsLoader __instance, string mainPath)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Invalid comparison between Unknown and I4
			string directoryName = Path.GetDirectoryName(mainPath);
			if (directoryName != null)
			{
				string path = Path.Combine(directoryName, "Quests.json");
				if (File.Exists(path))
				{
					try
					{
						string text = File.ReadAllText(path);
						QuestManagerData val = JsonUtility.FromJson<QuestManagerData>(text);
						if (((val != null) ? val.Quests : null) != null)
						{
							foreach (QuestData item in (Il2CppArrayBase<QuestData>)(object)val.Quests)
							{
								if (item == null || string.IsNullOrEmpty(item.GUID))
								{
									continue;
								}
								try
								{
									Quest val2 = GUIDManager.GetObject<Quest>(new Guid(item.GUID));
									if ((Object)(object)val2 == (Object)null)
									{
										PendingQuestDataByGuid[item.GUID] = item;
									}
								}
								catch
								{
									PendingQuestDataByGuid[item.GUID] = item;
								}
							}
						}
					}
					catch (Exception value)
					{
						Logger.Error($"Failed to load quest data from main Quests.json: {value}");
					}
				}
			}
			string text2 = Path.Combine(Singleton<LoadManager>.Instance.LoadedGameFolderPath, "Modded", "Quests");
			if (!Directory.Exists(text2))
			{
				Directory.CreateDirectory(text2);
				return;
			}
			string[] array = (from directory in Directory.GetDirectories(text2).Select(Path.GetFileName).OfType<string>()
				where directory.StartsWith("Quest_")
				select directory).ToArray();
			string[] array2 = array;
			string text6 = default(string);
			foreach (string text3 in array2)
			{
				string text4 = Path.Combine(text2, text3);
				string text5 = Path.Combine(text4, "QuestData");
				if (!((Loader)__instance).TryLoadFile(text5, ref text6, true))
				{
					Logger.Warning("Failed to load QuestData.json from: " + text5);
					continue;
				}
				QuestData questData = JsonConvert.DeserializeObject<QuestData>(text6, ISaveable.SerializerSettings);
				if (questData?.ClassName == null)
				{
					Logger.Warning("QuestData has no ClassName");
					continue;
				}
				Type typeByName = global::S1API.Internal.Utils.ReflectionUtils.GetTypeByName(questData.ClassName);
				if (typeByName == null || !typeof(Quest).IsAssignableFrom(typeByName))
				{
					Logger.Warning("Failed to find quest type: " + questData.ClassName);
					continue;
				}
				string value2 = (text3.StartsWith("Quest_") ? text3.Substring(6) : text3);
				QuestData val3 = null;
				foreach (KeyValuePair<string, QuestData> item2 in PendingQuestDataByGuid)
				{
					if (item2.Key.StartsWith(value2, StringComparison.OrdinalIgnoreCase))
					{
						val3 = item2.Value;
						break;
					}
				}
				if (val3 == null)
				{
					Logger.Warning("No QuestData found for quest directory: " + text3);
				}
				else if ((int)val3.State == 1)
				{
					Quest quest = QuestManager.CreateQuest(typeByName, val3.GUID);
					quest.S1Quest.StaticGUID = val3.GUID;
					quest.LoadInternal(text4);
				}
			}
		}

		[HarmonyPatch(typeof(Quest), "Start")]
		[HarmonyPrefix]
		private static void QuestStart(Quest __instance)
		{
			Quest quest = QuestManager.Quests.FirstOrDefault((Quest q) => (Object)(object)q.S1Quest == (Object)(object)__instance);
			if (quest != null)
			{
				quest.CreateInternal();
				string staticGUID = __instance.StaticGUID;
				if (!string.IsNullOrEmpty(staticGUID) && PendingQuestDataByGuid.TryGetValue(staticGUID, out QuestData value))
				{
					__instance.Load(value);
					PendingQuestDataByGuid.Remove(staticGUID);
				}
			}
		}

		[HarmonyPatch(typeof(QuestEntry), "CreateCompassElement")]
		[HarmonyPrefix]
		private static bool QuestEntry_CreateCompassElement_Prefix(QuestEntry __instance)
		{
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(__instance, "PoILocation");
			return obj != null;
		}
	}
	[HarmonyPatch]
	internal static class StoragePatches
	{
		[Serializable]
		private class StorageSlotMeta : SaveData
		{
			public int SlotCount;

			public int DisplayRowCount;

			public string? ItemId;
		}

		[HarmonyPatch]
		private static class StorageMenuOpenPatch
		{
			private static MethodBase? TargetMethod()
			{
				return AccessTools.GetDeclaredMethods(typeof(StorageMenu)).Find(delegate(MethodInfo method)
				{
					if (method.Name != "Open")
					{
						return false;
					}
					ParameterInfo[] parameters = method.GetParameters();
					return parameters.Length != 0 && parameters[0].ParameterType == typeof(StorageEntity);
				});
			}

			[HarmonyPrefix]
			private static void StorageMenu_Open_Prefix(StorageEntity entity)
			{
				if ((Object)(object)entity == (Object)null)
				{
					return;
				}
				try
				{
					PlaceableStorageEntity componentInParent = ((Component)entity).GetComponentInParent<PlaceableStorageEntity>();
					StorageEntity storage = new StorageEntity(entity, componentInParent);
					StorageEventArgs args = new StorageEventArgs(storage);
					StorageEvents.RaiseStorageOpening(args);
				}
				catch (Exception ex)
				{
					Logger.Error("Error in StorageMenu_Open_Prefix: " + ex.Message);
				}
			}
		}

		private static readonly Log Logger = new Log("StoragePatches");

		private static readonly HashSet<int> _processedStorages = new HashSet<int>();

		private const string ExtraSlotMetaKey = "S1API_Storage_SlotMeta";

		internal static int ResolveRestoreMaxSlots(int configuredMaxSlots, int persistedSlotCount)
		{
			return Math.Max(configuredMaxSlots, persistedSlotCount);
		}

		private static string? ParseConfigurationName(string? json)
		{
			if (string.IsNullOrEmpty(json))
			{
				return null;
			}
			try
			{
				int num = json.IndexOf("\"Value\"");
				if (num < 0)
				{
					return null;
				}
				int num2 = json.IndexOf(':', num + 7);
				if (num2 < 0)
				{
					return null;
				}
				int num3 = json.IndexOf('"', num2 + 1);
				if (num3 < 0)
				{
					return null;
				}
				int num4 = json.IndexOf('"', num3 + 1);
				if (num4 < 0)
				{
					return null;
				}
				return json.Substring(num3 + 1, num4 - num3 - 1);
			}
			catch
			{
				return null;
			}
		}

		private static StorageSlotMeta? ParseStorageSlotMeta(string? json)
		{
			if (string.IsNullOrEmpty(json))
			{
				return null;
			}
			try
			{
				StorageSlotMeta storageSlotMeta = new StorageSlotMeta();
				int num = json.IndexOf("\"SlotCount\":");
				if (num >= 0)
				{
					int num2 = num + 12;
					int num3 = json.IndexOfAny(new char[2] { ',', '}' }, num2);
					if (num3 > num2 && int.TryParse(json.Substring(num2, num3 - num2), out var result))
					{
						storageSlotMeta.SlotCount = result;
					}
				}
				int num4 = json.IndexOf("\"DisplayRowCount\":");
				if (num4 >= 0)
				{
					int num5 = num4 + 18;
					int num6 = json.IndexOfAny(new char[2] { ',', '}' }, num5);
					if (num6 > num5 && int.TryParse(json.Substring(num5, num6 - num5), out var result2))
					{
						storageSlotMeta.DisplayRowCount = result2;
					}
				}
				int num7 = json.IndexOf("\"ItemId\":\"");
				if (num7 >= 0)
				{
					int num8 = num7 + 10;
					int num9 = json.IndexOf("\"", num8);
					if (num9 > num8)
					{
						storageSlotMeta.ItemId = json.Substring(num8, num9 - num8);
					}
				}
				return storageSlotMeta;
			}
			catch
			{
				return null;
			}
		}

		[HarmonyPatch(typeof(PlaceableStorageEntity), "Start")]
		[HarmonyPostfix]
		private static void PlaceableStorageEntity_Start_Postfix(PlaceableStorageEntity __instance)
		{
			try
			{
				object obj;
				if (__instance == null)
				{
					obj = null;
				}
				else
				{
					ItemInstance itemInstance = ((BuildableItem)__instance).ItemInstance;
					obj = ((itemInstance != null) ? itemInstance.Definition : null);
				}
				if ((Object)obj == (Object)null)
				{
					return;
				}
			}
			catch (Exception)
			{
				return;
			}
			if ((Object)(object)__instance.StorageEntity == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)__instance).GetInstanceID();
			if (_processedStorages.Contains(instanceID))
			{
				return;
			}
			_processedStorages.Add(instanceID);
			try
			{
				StorageEntity storage = new StorageEntity(__instance.StorageEntity, __instance);
				StorageEventArgs args = new StorageEventArgs(storage);
				StorageEvents.RaiseStorageCreated(args);
			}
			catch (Exception ex2)
			{
				Logger.Error("Error in PlaceableStorageEntity_Start_Postfix: " + ex2.Message);
			}
		}

		[HarmonyPatch(typeof(PlaceableStorageEntity), "InitializeGridItem")]
		[HarmonyPostfix]
		private static void PlaceableStorageEntity_InitializeGridItem_Postfix(PlaceableStorageEntity __instance)
		{
			object obj;
			if (__instance == null)
			{
				obj = null;
			}
			else
			{
				ItemInstance itemInstance = ((BuildableItem)__instance).ItemInstance;
				obj = ((itemInstance != null) ? itemInstance.Definition : null);
			}
			if ((Object)obj == (Object)null || (Object)(object)__instance.StorageEntity == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)__instance).GetInstanceID();
			if (_processedStorages.Contains(instanceID))
			{
				return;
			}
			_processedStorages.Add(instanceID);
			try
			{
				StorageEntity storage = new StorageEntity(__instance.StorageEntity, __instance);
				StorageEventArgs args = new StorageEventArgs(storage);
				StorageEvents.RaiseStorageCreated(args);
			}
			catch (Exception ex)
			{
				Logger.Error("Error in PlaceableStorageEntity_InitializeGridItem_Postfix: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(ItemSet), "LoadTo", new Type[] { typeof(List<ItemSlot>) })]
		[HarmonyPrefix]
		private static void ItemSet_LoadTo_Prefix(ItemSet __instance, List<ItemSlot> slots)
		{
			if (__instance.Items == null || slots == null || ((Il2CppArrayBase<string>)(object)__instance.Items).Length <= slots.Count || slots.Count == 0)
			{
				return;
			}
			try
			{
				IItemSlotOwner slotOwner = slots[0].SlotOwner;
				if (slotOwner == null)
				{
					return;
				}
				StorageEntity val = null;
				val = ((Il2CppObjectBase)slotOwner).TryCast<StorageEntity>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				PlaceableStorageEntity componentInParent = ((Component)val).GetComponentInParent<PlaceableStorageEntity>();
				StorageEntity storage = new StorageEntity(val, componentInParent);
				StorageLoadingEventArgs args = new StorageLoadingEventArgs(storage, ((Il2CppArrayBase<string>)(object)__instance.Items).Length);
				StorageEvents.RaiseStorageLoading(args);
				int count = val.ItemSlots.Count;
				if (slots.Count < count)
				{
					for (int i = slots.Count; i < count; i++)
					{
						slots.Add(val.ItemSlots[i]);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Error("Error in ItemSet_LoadTo_Prefix: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(BuildableItem), "GetSaveData")]
		[HarmonyPostfix]
		private static void BuildableItem_GetSaveData_Postfix(BuildableItem __instance, ref DynamicSaveData __result)
		{
			PlaceableStorageEntity val = (PlaceableStorageEntity)(object)((__instance is PlaceableStorageEntity) ? __instance : null);
			if (__result == null || (Object)(object)((val != null) ? val.StorageEntity : null) == (Object)null)
			{
				return;
			}
			try
			{
				StorageSlotMeta obj = new StorageSlotMeta
				{
					SlotCount = ((val.StorageEntity.ItemSlots != null) ? val.StorageEntity.ItemSlots.Count : val.StorageEntity.SlotCount),
					DisplayRowCount = val.StorageEntity.DisplayRowCount
				};
				ItemInstance itemInstance = ((BuildableItem)val).ItemInstance;
				object itemId;
				if (itemInstance == null)
				{
					itemId = null;
				}
				else
				{
					ItemDefinition definition = itemInstance.Definition;
					itemId = ((definition != null) ? ((BaseItemDefinition)definition).ID : null);
				}
				obj.ItemId = (string?)itemId;
				StorageSlotMeta storageSlotMeta = obj;
				__result.AddData("S1API_Storage_SlotMeta", (SaveData)(object)storageSlotMeta);
			}
			catch (Exception ex)
			{
				Logger.Error("Error adding storage slot metadata: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(PlaceableStorageEntityLoader), "Load", new Type[] { typeof(DynamicSaveData) })]
		[HarmonyPrefix]
		private static bool PlaceableStorageEntityLoader_Load_Prefix(PlaceableStorageEntityLoader __instance, DynamicSaveData data)
		{
			try
			{
				if (data == null)
				{
					return false;
				}
				GridItemData val = default(GridItemData);
				if (!data.TryExtractBaseData<GridItemData>(ref val) || val == null)
				{
					return false;
				}
				object? obj = AccessTools.Method(((object)__instance).GetType(), "LoadAndCreate", new Type[1] { typeof(GridItemData) }, (Type[])null)?.Invoke(__instance, new object[1] { val });
				GridItem val2 = (GridItem)((obj is GridItem) ? obj : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return false;
				}
				PlaceableStorageEntity val3 = (PlaceableStorageEntity)(object)((val2 is PlaceableStorageEntity) ? val2 : null);
				if ((Object)(object)((val3 != null) ? val3.StorageEntity : null) == (Object)null)
				{
					return false;
				}
				PlaceableStorageData val4 = default(PlaceableStorageData);
				if (!data.TryExtractBaseData<PlaceableStorageData>(ref val4) || val4 == null)
				{
					return false;
				}
				StorageEntity storageEntity = val3.StorageEntity;
				ItemSet contents = val4.Contents;
				if (contents == null)
				{
					return false;
				}
				int num = ((Il2CppArrayBase<string>)(object)contents.Items)?.Length ?? storageEntity.ItemSlots.Count;
				string text = default(string);
				if (data.TryGetData("S1API_Storage_SlotMeta", ref text) && !string.IsNullOrEmpty(text))
				{
					try
					{
						StorageSlotMeta storageSlotMeta = ParseStorageSlotMeta(text);
						if (storageSlotMeta != null)
						{
							num = Math.Max(num, storageSlotMeta.SlotCount);
							if (storageSlotMeta.DisplayRowCount > storageEntity.DisplayRowCount)
							{
								storageEntity.DisplayRowCount = storageSlotMeta.DisplayRowCount;
							}
						}
					}
					catch (Exception ex)
					{
						object obj2;
						if (val3 == null)
						{
							obj2 = null;
						}
						else
						{
							ItemInstance itemInstance = ((BuildableItem)val3).ItemInstance;
							if (itemInstance == null)
							{
								obj2 = null;
							}
							else
							{
								ItemDefinition definition = itemInstance.Definition;
								obj2 = ((definition != null) ? ((BaseItemDefinition)definition).ID : null);
							}
						}
						if (obj2 == null)
						{
							obj2 = "unknown";
						}
						string value = (string)obj2;
						Logger.Warning($"Failed to deserialize storage slot metadata for item '{value}'. This usually happens when a mod that added extra storage rows is no longer loaded. The save file contains expanded storage data, but the mod that created it is missing. Exception: {ex.GetType().Name}: {ex.Message}. ");
					}
				}
				StorageEntity storageEntity2 = new StorageEntity(storageEntity, val3);
				storageEntity2.MaxSlots = ResolveRestoreMaxSlots(storageEntity2.MaxSlots, num);
				if (!storageEntity2.SetSlotCount(num))
				{
					ItemInstance itemInstance2 = ((BuildableItem)val3).ItemInstance;
					object obj3;
					if (itemInstance2 == null)
					{
						obj3 = null;
					}
					else
					{
						ItemDefinition definition2 = itemInstance2.Definition;
						obj3 = ((definition2 != null) ? ((BaseItemDefinition)definition2).ID : null);
					}
					if (obj3 == null)
					{
						obj3 = "unknown";
					}
					string value2 = (string)obj3;
					Logger.Warning($"Failed to restore {num} storage slots for item '{value2}'. " + "Saved contents may not fit in the available slots.");
				}
				contents.LoadTo(storageEntity.ItemSlots);
				string text2 = default(string);
				if (data.TryGetData("Configuration", ref text2) && !string.IsNullOrEmpty(text2))
				{
					try
					{
						string text3 = ParseConfigurationName(text2);
						EntityConfiguration configuration = val3.Configuration;
						StringField val5 = ((configuration != null) ? configuration.Name : null);
						if (!string.IsNullOrEmpty(text3) && val5 != null)
						{
							val5.SetValue(text3, true);
						}
					}
					catch (Exception ex2)
					{
						Logger.Warning("Failed to load storage configuration name: " + ex2.Message);
					}
				}
			}
			catch (Exception ex3)
			{
				Logger.Error("Error in PlaceableStorageEntityLoader_Load_Prefix: " + ex3.Message);
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class SupplierRuntimePatches
	{
		private static readonly Log Logger = new Log("SupplierRuntimePatches");

		[HarmonyPatch(typeof(Supplier), "Awake")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static void SupplierAwakePrefix(Supplier __instance)
		{
			if (!NPCPatches.IsS1ApiCustomNpcComponent((Component)(object)__instance))
			{
				return;
			}
			try
			{
				((Component)__instance).GetComponent<NPCPrefabIdentity>()?.ApplyCriticalIdentityBeforeAwake((NPC)(object)__instance);
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to apply custom supplier identity before Awake: " + ex.Message);
			}
		}

		[HarmonyPatch(typeof(Supplier), "Start")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SupplierStartPrefix(Supplier __instance)
		{
			if (!NPCPatches.IsS1ApiCustomNpcComponent((Component)(object)__instance))
			{
				return true;
			}
			try
			{
				NPC nPC = NPCPatches.FindWrapperForS1Npc((NPC?)(object)__instance);
				SupplierDataBuilder.SupplierConfigData config = ((nPC != null) ? NPC.BuildSupplierDefaultsForType(nPC.GetType()) : null);
				if (SupplierRuntimeCoordinator.EnsureReady(__instance, ((NPC)__instance).ID, config))
				{
					return true;
				}
				Logger.Error("Custom supplier '" + ((NPC)__instance).ID + "' is missing required runtime infrastructure; native Supplier.Start was skipped.");
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to prepare custom supplier infrastructure before Start: " + ex.Message);
			}
			return false;
		}

		[HarmonyPatch(typeof(Supplier), "Load", new Type[]
		{
			typeof(DynamicSaveData),
			typeof(NPCData)
		})]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SupplierLoadPrefix(Supplier __instance, DynamicSaveData dynamicData)
		{
			NPC nPC = NPCPatches.FindWrapperForS1Npc((NPC?)(object)__instance);
			if (nPC == null || !nPC.IsCustomNPC)
			{
				return true;
			}
			SupplierData val = default(SupplierData);
			if (!dynamicData.TryExtractBaseData<SupplierData>(ref val) || val == null)
			{
				Logger.Warning("Custom supplier '" + ((NPC)__instance).ID + "' has no SupplierData in its save entry.");
				return false;
			}
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "_minsSinceMeetingStart", val.timeSinceMeetingStart);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "_minsSinceLastMeetingEnd", val.timeSinceLastMeetingEnd);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "MinsUntilDeaddropReady", val.minsUntilDeadDropReady);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "_repaymentReminderSent", val.debtReminderSent);
			if (val.deaddropItems != null)
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(__instance, "_deaddropItems", val.deaddropItems);
			}
			bool flag = val.minsUntilDeadDropReady > 0;
			if (((NetworkBehaviour)__instance).IsServerInitialized)
			{
				__instance.sync___set_value__debt(val.debt, true);
				__instance.sync___set_value__deadDropPreparing(flag, true);
			}
			else
			{
				__instance._debt = val.debt;
				__instance._deadDropPreparing = flag;
			}
			return false;
		}

		[HarmonyPatch(typeof(SupplierStash), "Start")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SupplierStashStartPrefix(SupplierStash __instance)
		{
			return !SupplierRuntimeCoordinator.TryInitializeGeneratedStash(__instance);
		}

		[HarmonyPatch(typeof(DeadDrop), "GetRandomEmptyDrop")]
		[HarmonyPrefix]
		private static bool ExcludeSupplierStashesFromDeadDropSelection(Vector3 origin, ref DeadDrop __result)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!SupplierStashRuntime.HasReservedDeadDrops)
			{
				return true;
			}
			List<DeadDrop> list = (from drop in (IEnumerable<DeadDrop>)DeadDrop.DeadDrops.ToArray()
				where (Object)(object)drop != (Object)null && ((StorageEntity)drop.Storage).ItemCount == 0 && !SupplierStashRuntime.IsReservedDeadDrop(drop)
				orderby Vector3.Distance(((Component)drop).transform.position, origin)
				select drop).ToList();
			if (list.Count > 1)
			{
				list.RemoveAt(0);
			}
			if (list.Count > 1)
			{
				int num = list.Count / 2;
				list.RemoveRange(num, list.Count - num);
			}
			__result = ((list.Count == 0) ? null : list[Random.Range(0, list.Count)]);
			return false;
		}

		[HarmonyPatch(typeof(NPC), "SetVisible", new Type[]
		{
			typeof(bool),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void NpcSetVisiblePostfix(NPC __instance, bool __0)
		{
			if (NPCPatches.IsS1ApiCustomNpcComponent((Component)(object)__instance) && CrossType.Is<Supplier>((object)__instance, out Supplier result))
			{
				SupplierRuntimeCoordinator.ReconcileMeetingDialogue(result, __0);
			}
		}

		[HarmonyPatch(typeof(NPCLoader), "Load")]
		[HarmonyPostfix]
		private static void NpcLoaderLoadPostfix(DynamicSaveData saveData)
		{
			if (!NPCPatches.IsInMainScene() || saveData == null)
			{
				return;
			}
			NPCData val = saveData.ExtractBaseData<NPCData>();
			if (val != null && !string.IsNullOrEmpty(val.ID))
			{
				NPC val2 = NPCPatches.FindBaseNpcById(val.ID);
				if ((Object)(object)val2 != (Object)null && CrossType.Is<Supplier>((object)val2, out Supplier result))
				{
					SupplierRuntimeCoordinator.ReconcileDeliveryUnlock(result);
				}
			}
		}

		[HarmonyPatch(typeof(NPC), "OnDestroy")]
		[HarmonyPostfix]
		private static void NpcOnDestroyPostfix(NPC __instance)
		{
			if (CrossType.Is<Supplier>((object)__instance, out Supplier result))
			{
				SupplierRuntimeCoordinator.CleanupSupplier(result);
			}
		}
	}
	[HarmonyPatch]
	internal static class SupplierStashPersistencePatches
	{
		[HarmonyPatch(typeof(StorageLoader), "Load")]
		[HarmonyPrefix]
		private static void StorageLoaderLoadPrefix(StorageLoader __instance, string __0)
		{
			SupplierStashPersistenceRuntime.CaptureFromLoader(__instance, __0);
		}

		[HarmonyPatch(typeof(WorldStorageEntity), "Load", new Type[] { typeof(WorldStorageEntityData) })]
		[HarmonyPostfix]
		private static void WorldStorageEntityLoadPostfix(WorldStorageEntityData __0)
		{
			SupplierStashPersistenceRuntime.NotifyLoadSucceeded(__0);
		}
	}
	internal static class TVAppRegistry
	{
		public static readonly List<global::S1API.TVApp.TVApp> RegisteredApps = new List<global::S1API.TVApp.TVApp>();

		public static void Register(global::S1API.TVApp.TVApp app)
		{
			RegisteredApps.Add(app);
		}

		public static void Clear()
		{
			RegisteredApps.Clear();
		}

		public static void CloseAllApps()
		{
			foreach (global::S1API.TVApp.TVApp registeredApp in RegisteredApps)
			{
				if (registeredApp.IsOpen)
				{
					registeredApp.ForceClose();
				}
			}
		}
	}
	[HarmonyPatch(typeof(TVHomeScreen), "Awake")]
	internal static class TVHomeScreen_Awake_Patch
	{
		private static readonly Log Logger = new Log("TVApp");

		private static void Postfix(TVHomeScreen __instance)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (!string.Equals(((Scene)(ref activeScene)).name, "Main", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			SetupScrollRect(__instance);
			TVAppRegistry.Clear();
			List<Type> derivedClasses = global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<global::S1API.TVApp.TVApp>();
			foreach (Type item in derivedClasses)
			{
				if (item.IsAbstract)
				{
					continue;
				}
				if (item.GetConstructor(Type.EmptyTypes) == null)
				{
					Logger.Warning("[TVApp] Skipping " + item.FullName + ": no parameterless constructor");
					continue;
				}
				try
				{
					global::S1API.TVApp.TVApp tVApp = (global::S1API.TVApp.TVApp)Activator.CreateInstance(item);
					((IRegisterable)tVApp).CreateInternal();
					tVApp.SpawnUI(__instance);
					tVApp.SpawnButton(__instance);
				}
				catch (Exception ex)
				{
					Logger.Warning("[TVApp] Failed to register " + item.FullName + ": " + ex.Message);
					Logger.Warning("[TVApp] Stack trace: " + ex.StackTrace);
				}
			}
		}

		private static void SetupScrollRect(TVHomeScreen homeScreen)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: 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_00c7: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			if ((Object)(object)homeScreen.AppButtonContainer == (Object)null)
			{
				Logger.Warning("[TVApp] Cannot setup scroll: AppButtonContainer is null");
			}
			else
			{
				if ((Object)(object)((Component)homeScreen.AppButtonContainer).GetComponentInParent<ScrollRect>() != (Object)null)
				{
					return;
				}
				try
				{
					RectTransform appButtonContainer = homeScreen.AppButtonContainer;
					Transform parent = ((Transform)appButtonContainer).parent;
					int siblingIndex = ((Transform)appButtonContainer).GetSiblingIndex();
					HorizontalLayoutGroup component = ((Component)appButtonContainer).GetComponent<HorizontalLayoutGroup>();
					GridLayoutGroup component2 = ((Component)appButtonContainer).GetComponent<GridLayoutGroup>();
					Vector2 anchorMin = appButtonContainer.anchorMin;
					Vector2 anchorMax = appButtonContainer.anchorMax;
					Vector2 anchoredPosition = appButtonContainer.anchoredPosition;
					Vector2 pivot = appButtonContainer.pivot;
					LayoutRebuilder.ForceRebuildLayoutImmediate(appButtonContainer);
					Rect rect = appButtonContainer.rect;
					RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
					Rect val2 = (Rect)(((Object)(object)val != (Object)null) ? val.rect : new Rect(0f, 0f, 800f, 200f));
					GameObject val3 = new GameObject("AppScrollView");
					val3.transform.SetParent(parent, false);
					val3.transform.SetSiblingIndex(siblingIndex);
					RectTransform val4 = val3.AddComponent<RectTransform>();
					val4.anchorMin = new Vector2(0f, anchorMin.y);
					val4.anchorMax = new Vector2(1f, anchorMax.y);
					val4.anchoredPosition = new Vector2(0f, anchoredPosition.y);
					val4.sizeDelta = new Vector2(0f, (((Rect)(ref rect)).height > 0f) ? ((Rect)(ref rect)).height : 200f);
					val4.pivot = pivot;
					GameObject val5 = new GameObject("Viewport");
					val5.transform.SetParent(val3.transform, false);
					RectTransform val6 = val5.AddComponent<RectTransform>();
					val6.anchorMin = Vector2.zero;
					val6.anchorMax = Vector2.one;
					val6.sizeDelta = Vector2.zero;
					val6.anchoredPosition = Vector2.zero;
					val6.pivot = pivot;
					((Transform)appButtonContainer).SetParent(val5.transform, false);
					appButtonContainer.anchorMin = new Vector2(0f, 0.5f);
					appButtonContainer.anchorMax = new Vector2(0f, 0.5f);
					appButtonContainer.pivot = new Vector2(0f, 0.5f);
					appButtonContainer.anchoredPosition = Vector2.zero;
					if ((Object)(object)component != (Object)null)
					{
						((LayoutGroup)component).padding = new RectOffset(80, 80, 0, 0);
					}
					else if ((Object)(object)component2 == (Object)null)
					{
						HorizontalLayoutGroup val7 = ((Component)appButtonContainer).gameObject.AddComponent<HorizontalLayoutGroup>();
						((LayoutGroup)val7).childAlignment = (TextAnchor)3;
						((HorizontalOrVerticalLayoutGroup)val7).childControlWidth = false;
						((HorizontalOrVerticalLayoutGroup)val7).childControlHeight = false;
						((HorizontalOrVerticalLayoutGroup)val7).childForceExpandWidth = false;
						((HorizontalOrVerticalLayoutGroup)val7).childForceExpandHeight = false;
						((HorizontalOrVerticalLayoutGroup)val7).spacing = 15f;
						((LayoutGroup)val7).padding = new RectOffset(80, 80, 0, 0);
					}
					ContentSizeFitter val8 = ((Component)appButtonContainer).gameObject.GetComponent<ContentSizeFitter>();
					if ((Object)(object)val8 == (Object)null)
					{
						val8 = ((Component)appButtonContainer).gameObject.AddComponent<ContentSizeFitter>();
					}
					val8.horizontalFit = (FitMode)2;
					val8.verticalFit = (FitMode)2;
					ScrollRect val9 = val3.AddComponent<ScrollRect>();
					val9.content = appButtonContainer;
					val9.viewport = val6;
					val9.horizontal = true;
					val9.vertical = false;
					val9.movementType = (MovementType)1;
					val9.elasticity = 0.1f;
					val9.inertia = true;
					val9.decelerationRate = 0.135f;
					LayoutRebuilder.ForceRebuildLayoutImmediate(appButtonContainer);
					LayoutRebuilder.ForceRebuildLayoutImmediate(val4);
					for (int i = 0; i < ((Transform)appButtonContainer).childCount; i++)
					{
						Transform child = ((Transform)appButtonContainer).GetChild(i);
						RectTransform component3 = ((Component)child).GetComponent<RectTransform>();
					}
				}
				catch (Exception ex)
				{
					Logger.Error("[TVApp] Failed to setup scroll rect: " + ex.Message);
					Logger.Error("[TVApp] Stack trace: " + ex.StackTrace);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class TVHomeScreen_Close_Patch
	{
		internal static bool SkipInterfaceClose { get; set; }

		private static MethodBase? TargetMethod()
		{
			return AccessTools.GetDeclaredMethods(typeof(TVHomeScreen)).Find((MethodInfo method) => method.Name == "Close" || method.Name == "OnClose");
		}

		private static void Prefix(TVHomeScreen __instance)
		{
			if (SkipInterfaceClose)
			{
				FieldInfo field = typeof(TVHomeScreen).GetField("skipExit", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					field.SetValue(__instance, true);
					SkipInterfaceClose = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(TVHomeScreen), "Open")]
	internal static class TVHomeScreen_Open_Patch
	{
		private static void Postfix()
		{
			TVAppRegistry.CloseAllApps();
		}
	}
	[HarmonyPatch(typeof(TVInterface), "Close")]
	internal static class TVInterface_Close_Patch
	{
		private static bool Prefix()
		{
			if (!TVHomeScreen_Close_Patch.SkipInterfaceClose)
			{
				return true;
			}
			TVHomeScreen_Close_Patch.SkipInterfaceClose = false;
			return false;
		}
	}
}
namespace S1API.Internal.NPCWorkbench
{
	internal enum NPCWorkbenchSourceKind
	{
		Blank,
		Native,
		S1API
	}
	internal enum NPCWorkbenchDiagnosticSeverity
	{
		Information,
		Warning,
		Error
	}
	internal sealed class NPCWorkbenchDraft
	{
		internal NPCWorkbenchSourceKind SourceKind { get; set; }

		internal string SourceId { get; set; } = string.Empty;

		internal string SourceDisplayName { get; set; } = "Blank appearance";

		internal NPCWorkbenchAppearance Appearance { get; } = new NPCWorkbenchAppearance();

		internal NPCWorkbenchDraft Clone()
		{
			NPCWorkbenchDraft nPCWorkbenchDraft = new NPCWorkbenchDraft
			{
				SourceKind = SourceKind,
				SourceId = SourceId,
				SourceDisplayName = SourceDisplayName
			};
			nPCWorkbenchDraft.Appearance.CopyFrom(Appearance);
			return nPCWorkbenchDraft;
		}

		internal IReadOnlyList<NPCWorkbenchDiagnostic> Validate()
		{
			List<NPCWorkbenchDiagnostic> list = new List<NPCWorkbenchDiagnostic>();
			Appearance.Validate(list);
			return list;
		}
	}
	internal sealed class NPCWorkbenchAppearance
	{
		internal float Gender { get; set; }

		internal float Height { get; set; } = 1f;

		internal float Weight { get; set; } = 0.5f;

		internal NPCWorkbenchColor SkinColor { get; set; } = new NPCWorkbenchColor(150, 120, 95, byte.MaxValue);

		internal NPCWorkbenchColor LeftEyeLidColor { get; set; } = new NPCWorkbenchColor(150, 120, 95, byte.MaxValue);

		internal NPCWorkbenchColor RightEyeLidColor { get; set; } = new NPCWorkbenchColor(150, 120, 95, byte.MaxValue);

		internal NPCWorkbenchColor EyeBallTint { get; set; } = NPCWorkbenchColor.White;

		internal string EyeballMaterialIdentifier { get; set; } = "Default";

		internal float PupilDilation { get; set; } = 1f;

		internal float EyebrowScale { get; set; } = 1f;

		internal float EyebrowThickness { get; set; } = 1f;

		internal float EyebrowRestingHeight { get; set; }

		internal float EyebrowRestingAngle { get; set; }

		internal NPCWorkbenchEyeSettings LeftEye { get; set; } = new NPCWorkbenchEyeSettings(0.5f, 0.5f);

		internal NPCWorkbenchEyeSettings RightEye { get; set; } = new NPCWorkbenchEyeSettings(0.5f, 0.5f);

		internal string HairPath { get; set; } = string.Empty;

		internal NPCWorkbenchColor HairColor { get; set; } = NPCWorkbenchColor.Black;

		internal string? ImpostorId { get; set; }

		internal List<NPCWorkbenchLayer> FaceLayers { get; } = new List<NPCWorkbenchLayer>();

		internal List<NPCWorkbenchLayer> BodyLayers { get; } = new List<NPCWorkbenchLayer>();

		internal List<NPCWorkbenchLayer> Accessories { get; } = new List<NPCWorkbenchLayer>();

		internal void CopyFrom(NPCWorkbenchAppearance source)
		{
			Gender = source.Gender;
			Height = source.Height;
			Weight = source.Weight;
			SkinColor = source.SkinColor;
			LeftEyeLidColor = source.LeftEyeLidColor;
			RightEyeLidColor = source.RightEyeLidColor;
			EyeBallTint = source.EyeBallTint;
			EyeballMaterialIdentifier = source.EyeballMaterialIdentifier;
			PupilDilation = source.PupilDilation;
			EyebrowScale = source.EyebrowScale;
			EyebrowThickness = source.EyebrowThickness;
			EyebrowRestingHeight = source.EyebrowRestingHeight;
			EyebrowRestingAngle = source.EyebrowRestingAngle;
			LeftEye = source.LeftEye;
			RightEye = source.RightEye;
			HairPath = source.HairPath;
			HairColor = source.HairColor;
			ImpostorId = source.ImpostorId;
			CopyLayers(FaceLayers, source.FaceLayers);
			CopyLayers(BodyLayers, source.BodyLayers);
			CopyLayers(Accessories, source.Accessories);
		}

		internal void Validate(List<NPCWorkbenchDiagnostic> diagnostics)
		{
			ValidateRange(diagnostics, Gender, 0f, 1f, "appearance.gender", "Gender");
			ValidateRange(diagnostics, Height, 0.5f, 2f, "appearance.height", "Height");
			ValidateRange(diagnostics, Weight, 0f, 1f, "appearance.weight", "Weight");
			ValidateRange(diagnostics, PupilDilation, 0f, 2f, "appearance.pupil", "Pupil dilation");
			ValidateRange(diagnostics, EyebrowScale, 0f, 2f, "appearance.eyebrow-scale", "Eyebrow scale");
			ValidateRange(diagnostics, EyebrowThickness, 0f, 2f, "appearance.eyebrow-thickness", "Eyebrow thickness");
			ValidateRange(diagnostics, EyebrowRestingHeight, -1f, 1f, "appearance.eyebrow-height", "Eyebrow resting height");
			ValidateRange(diagnostics, EyebrowRestingAngle, -1f, 1f, "appearance.eyebrow-angle", "Eyebrow resting angle");
			ValidateEye(diagnostics, LeftEye, "left");
			ValidateEye(diagnostics, RightEye, "right");
			ValidateLayers(diagnostics, FaceLayers, "face");
			ValidateLayers(diagnostics, BodyLayers, "body");
			ValidateLayers(diagnostics, Accessories, "accessory");
		}

		private static void CopyLayers(List<NPCWorkbenchLayer> target, IEnumerable<NPCWorkbenchLayer> source)
		{
			target.Clear();
			target.AddRange(source.Select((NPCWorkbenchLayer layer) => layer.Clone()));
		}

		private static void ValidateEye(List<NPCWorkbenchDiagnostic> diagnostics, NPCWorkbenchEyeSettings eye, string side)
		{
			ValidateRange(diagnostics, eye.TopLidOpen, 0f, 1f, "appearance." + side + "-eye-top", side + " top eyelid");
			ValidateRange(diagnostics, eye.BottomLidOpen, 0f, 1f, "appearance." + side + "-eye-bottom", side + " bottom eyelid");
		}

		private static void ValidateLayers(List<NPCWorkbenchDiagnostic> diagnostics, IReadOnlyList<NPCWorkbenchLayer> layers, string kind)
		{
			for (int i = 0; i < layers.Count; i++)
			{
				if (string.IsNullOrWhiteSpace(layers[i].Path))
				{
					diagnostics.Add(NPCWorkbenchDiagnostic.Error("appearance." + kind + "-layer.path", $"{kind} layer {i + 1} requires a resource path."));
				}
			}
		}

		private static void ValidateRange(List<NPCWorkbenchDiagnostic> diagnostics, float value, float minimum, float maximum, string code, string label)
		{
			if (float.IsNaN(value) || float.IsInfinity(value) || value < minimum || value > maximum)
			{
				diagnostics.Add(NPCWorkbenchDiagnostic.Error(code, $"{label} must be between {minimum} and {maximum}."));
			}
		}
	}
	internal sealed class NPCWorkbenchLayer
	{
		internal string Path { get; set; } = string.Empty;

		internal NPCWorkbenchColor Color { get; set; } = NPCWorkbenchColor.White;

		internal NPCWorkbenchLayer Clone()
		{
			return new NPCWorkbenchLayer
			{
				Path = Path,
				Color = Color
			};
		}
	}
	internal readonly struct NPCWorkbenchEyeSettings
	{
		internal float TopLidOpen { get; }

		internal float BottomLidOpen { get; }

		internal NPCWorkbenchEyeSettings(float topLidOpen, float bottomLidOpen)
		{
			TopLidOpen = topLidOpen;
			BottomLidOpen = bottomLidOpen;
		}
	}
	internal readonly struct NPCWorkbenchColor
	{
		internal static NPCWorkbenchColor Black => new NPCWorkbenchColor(0, 0, 0, byte.MaxValue);

		internal static NPCWorkbenchColor White => new NPCWorkbenchColor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);

		internal byte Red { get; }

		internal byte Green { get; }

		internal byte Blue { get; }

		internal byte Alpha { get; }

		internal NPCWorkbenchColor(byte red, byte green, byte blue, byte alpha)
		{
			Red = red;
			Green = green;
			Blue = blue;
			Alpha = alpha;
		}

		internal string ToHex()
		{
			return $"{Red:X2}{Green:X2}{Blue:X2}{Alpha:X2}";
		}

		internal static bool TryParse(string? value, out NPCWorkbenchColor color)
		{
			color = default(NPCWorkbenchColor);
			if (string.IsNullOrWhiteSpace(value))
			{
				return false;
			}
			string text = value.Trim().TrimStart('#');
			if (text.Length == 6)
			{
				text += "FF";
			}
			if (text.Length != 8)
			{
				return false;
			}
			if (!byte.TryParse(text.Substring(0, 2), NumberStyles.HexNumber, null, out var result) || !byte.TryParse(text.Substring(2, 2), NumberStyles.HexNumber, null, out var result2) || !byte.TryParse(text.Substring(4, 2), NumberStyles.HexNumber, null, out var result3) || !byte.TryParse(text.Substring(6, 2), NumberStyles.HexNumber, null, out var result4))
			{
				return false;
			}
			color = new NPCWorkbenchColor(result, result2, result3, result4);
			return true;
		}
	}
	internal sealed class NPCWorkbenchDiagnostic
	{
		internal NPCWorkbenchDiagnosticSeverity Severity { get; }

		internal string Code { get; }

		internal string Message { get; }

		private NPCWorkbenchDiagnostic(NPCWorkbenchDiagnosticSeverity severity, string code, string message)
		{
			Severity = severity;
			Code = code;
			Message = message;
		}

		internal static NPCWorkbenchDiagnostic Error(string code, string message)
		{
			return new NPCWorkbenchDiagnostic(NPCWorkbenchDiagnosticSeverity.Error, code, message);
		}
	}
	internal sealed class NPCWorkbenchExportResult
	{
		internal string Code { get; }

		internal IReadOnlyList<NPCWorkbenchDiagnostic> Diagnostics { get; }

		internal bool CanExport => Diagnostics.All((NPCWorkbenchDiagnostic diagnostic) => diagnostic.Severity != NPCWorkbenchDiagnosticSeverity.Error);

		internal NPCWorkbenchExportResult(string code, IReadOnlyList<NPCWorkbenchDiagnostic> diagnostics)
		{
			Code = code;
			Diagnostics = diagnostics;
		}
	}
	internal static class NPCWorkbenchExporter
	{
		internal static NPCWorkbenchExportResult Export(NPCWorkbenchDraft draft)
		{
			if (draft == null)
			{
				throw new ArgumentNullException("draft");
			}
			IReadOnlyList<NPCWorkbenchDiagnostic> readOnlyList = draft.Validate();
			if (readOnlyList.Any((NPCWorkbenchDiagnostic diagnostic) => diagnostic.Severity == NPCWorkbenchDiagnosticSeverity.Error))
			{
				return new NPCWorkbenchExportResult(string.Empty, readOnlyList);
			}
			NPCWorkbenchAppearance appearance = draft.Appearance;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("builder.WithAppearanceDefaults(appearance =>");
			stringBuilder.AppendLine("{");
			stringBuilder.Append("    appearance.Gender = ").Append(Float(appearance.Gender)).AppendLine(";");
			stringBuilder.Append("    appearance.Height = ").Append(Float(appearance.Height)).AppendLine(";");
			stringBuilder.Append("    appearance.Weight = ").Append(Float(appearance.Weight)).AppendLine(";");
			stringBuilder.Append("    appearance.SkinColor = ").Append(Color(appearance.SkinColor)).AppendLine(";");
			stringBuilder.Append("    appearance.LeftEyeLidColor = ").Append(Color(appearance.LeftEyeLidColor)).AppendLine(";");
			stringBuilder.Append("    appearance.RightEyeLidColor = ").Append(Color(appearance.RightEyeLidColor)).AppendLine(";");
			stringBuilder.Append("    appearance.EyeBallTint = ").Append(Color(appearance.EyeBallTint)).AppendLine(";");
			stringBuilder.Append("    appearance.EyeballMaterialIdentifier = ").Append(Quote(appearance.EyeballMaterialIdentifier)).AppendLine(";");
			stringBuilder.Append("    appearance.PupilDilation = ").Append(Float(appearance.PupilDilation)).AppendLine(";");
			stringBuilder.Append("    appearance.EyebrowScale = ").Append(Float(appearance.EyebrowScale)).AppendLine(";");
			stringBuilder.Append("    appearance.EyebrowThickness = ").Append(Float(appearance.EyebrowThickness)).AppendLine(";");
			stringBuilder.Append("    appearance.EyebrowRestingHeight = ").Append(Float(appearance.EyebrowRestingHeight)).AppendLine(";");
			stringBuilder.Append("    appearance.EyebrowRestingAngle = ").Append(Float(appearance.EyebrowRestingAngle)).AppendLine(";");
			stringBuilder.Append("    appearance.LeftEye = (").Append(Float(appearance.LeftEye.TopLidOpen)).Append(", ")
				.Append(Float(appearance.LeftEye.BottomLidOpen))
				.AppendLine(");");
			stringBuilder.Append("    appearance.RightEye = (").Append(Float(appearance.RightEye.TopLidOpen)).Append(", ")
				.Append(Float(appearance.RightEye.BottomLidOpen))
				.AppendLine(");");
			stringBuilder.Append("    appearance.HairPath = ").Append(PathExpression(NPCWorkbenchPathKind.Hair, appearance.HairPath)).AppendLine(";");
			stringBuilder.Append("    appearance.HairColor = ").Append(Color(appearance.HairColor)).AppendLine(";");
			AppendLayers(stringBuilder, NPCWorkbenchPathKind.FaceLayer, "WithFaceLayer", appearance.FaceLayers);
			AppendLayers(stringBuilder, NPCWorkbenchPathKind.BodyLayer, "WithBodyLayer", appearance.BodyLayers);
			AppendLayers(stringBuilder, NPCWorkbenchPathKind.Accessory, "WithAccessoryLayer", appearance.Accessories);
			if (!string.IsNullOrWhiteSpace(appearance.ImpostorId))
			{
				stringBuilder.Append("    appearance.WithImpostor(").Append(Quote(appearance.ImpostorId)).AppendLine(");");
			}
			stringBuilder.AppendLine("});");
			return new NPCWorkbenchExportResult(stringBuilder.ToString(), readOnlyList);
		}

		private static void AppendLayers(StringBuilder code, NPCWorkbenchPathKind kind, string method, IEnumerable<NPCWorkbenchLayer> layers)
		{
			foreach (NPCWorkbenchLayer layer in layers)
			{
				NPCWorkbenchPathEntry nPCWorkbenchPathEntry = NPCWorkbenchPathCatalog.Find(kind, layer.Path);
				code.Append("    appearance.").Append(method);
				if (nPCWorkbenchPathEntry != null)
				{
					code.Append("<").Append(nPCWorkbenchPathEntry.CSharpTypeName).Append(">");
				}
				code.Append("(").Append(nPCWorkbenchPathEntry?.CSharpExpression ?? Quote(layer.Path)).Append(", ")
					.Append(Color(layer.Color))
					.AppendLine(");");
			}
		}

		private static string PathExpression(NPCWorkbenchPathKind kind, string path)
		{
			return NPCWorkbenchPathCatalog.Find(kind, path)?.CSharpExpression ?? Quote(path);
		}

		private static string Quote(string value)
		{
			return "\"" + (value ?? string.Empty).Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r")
				.Replace("\n", "\\n")
				.Replace("\t", "\\t") + "\"";
		}

		private static string Float(float value)
		{
			return value.ToString("0.0#######", CultureInfo.InvariantCulture) + "f";
		}

		private static string Color(NPCWorkbenchColor value)
		{
			return $"new Color32({value.Red}, {value.Green}, {value.Blue}, {value.Alpha})";
		}
	}
	internal enum NPCWorkbenchPathKind
	{
		Hair,
		FaceLayer,
		BodyLayer,
		Accessory
	}
	internal sealed class NPCWorkbenchPathEntry
	{
		internal NPCWorkbenchPathKind Kind { get; }

		internal Type DeclaringType { get; }

		internal string MemberName { get; }

		internal string Path { get; }

		internal string GroupName => DeclaringType.Name;

		internal string DisplayName => GroupName + " / " + MemberName;

		internal string CSharpTypeName => "global::" + DeclaringType.FullName;

		internal string CSharpExpression => CSharpTypeName + "." + MemberName;

		internal NPCWorkbenchPathEntry(NPCWorkbenchPathKind kind, Type declaringType, string memberName, string path)
		{
			Kind = kind;
			DeclaringType = declaringType;
			MemberName = memberName;
			Path = path;
		}
	}
	internal static class NPCWorkbenchPathCatalog
	{
		private static readonly IReadOnlyDictionary<NPCWorkbenchPathKind, IReadOnlyList<NPCWorkbenchPathEntry>> EntriesByKind = Build();

		internal static IReadOnlyList<NPCWorkbenchPathEntry> Get(NPCWorkbenchPathKind kind)
		{
			return EntriesByKind[kind];
		}

		internal static NPCWorkbenchPathEntry? Find(NPCWorkbenchPathKind kind, string path)
		{
			return Get(kind).FirstOrDefault((NPCWorkbenchPathEntry entry) => string.Equals(entry.Path, path, StringComparison.OrdinalIgnoreCase));
		}

		private static IReadOnlyDictionary<NPCWorkbenchPathKind, IReadOnlyList<NPCWorkbenchPathEntry>> Build()
		{
			Dictionary<NPCWorkbenchPathKind, IReadOnlyList<NPCWorkbenchPathEntry>> dictionary = new Dictionary<NPCWorkbenchPathKind, IReadOnlyList<NPCWorkbenchPathEntry>>();
			dictionary[NPCWorkbenchPathKind.Hair] = ReadConstants(NPCWorkbenchPathKind.Hair, new Type[1] { typeof(HairStyle) });
			dictionary[NPCWorkbenchPathKind.FaceLayer] = ReadDerivedConstants<BaseFaceAppearance>(NPCWorkbenchPathKind.FaceLayer);
			dictionary[NPCWorkbenchPathKind.BodyLayer] = ReadDerivedConstants<BaseBodyAppearance>(NPCWorkbenchPathKind.BodyLayer);
			dictionary[NPCWorkbenchPathKind.Accessory] = ReadDerivedConstants<BaseAccessoryAppearance>(NPCWorkbenchPathKind.Accessory);
			return dictionary;
		}

		private static IReadOnlyList<NPCWorkbenchPathEntry> ReadDerivedConstants<TBase>(NPCWorkbenchPathKind kind)
		{
			Type baseType = typeof(TBase);
			IEnumerable<Type> types = from type in baseType.Assembly.GetTypes()
				where type != baseType && baseType.IsAssignableFrom(type)
				select type;
			return ReadConstants(kind, types);
		}

		private static IReadOnlyList<NPCWorkbenchPathEntry> ReadConstants(NPCWorkbenchPathKind kind, IEnumerable<Type> types)
		{
			return (from value in types.OrderBy<Type, string>((Type type) => type.Name, StringComparer.Ordinal).SelectMany((Type type) => from field in (from field in type.GetFields(BindingFlags.Static | BindingFlags.Public)
						where field.IsLiteral && !field.IsInitOnly && field.FieldType == typeof(string)
						select field).OrderBy<FieldInfo, string>((FieldInfo field) => field.Name, StringComparer.Ordinal)
					select new
					{
						Type = type,
						Field = field,
						Path = (field.GetRawConstantValue() as string)
					})
				where !string.IsNullOrWhiteSpace(value.Path)
				select new NPCWorkbenchPathEntry(kind, value.Type, value.Field.Name, value.Path)).ToArray();
		}
	}
	internal sealed class NPCWorkbenchPreview : IDisposable
	{
		private static readonly Log Logger = new Log("NPCWorkbenchPreview");

		private const int TextureWidth = 640;

		private const int TextureHeight = 800;

		private readonly GameObject _root;

		private readonly Avatar _avatar;

		private readonly Camera _camera;

		private readonly RenderTexture _texture;

		private readonly int _renderLayer;

		private AvatarSettings? _template;

		private AvatarSettings? _appliedSettings;

		private NPCWorkbenchDraft? _pendingDraft;

		private int _settleFrames;

		private int _rendererRefreshFrames;

		private float _yaw = 180f;

		private float _pitch;

		private float _distance = 2.8f;

		private bool _disposed;

		internal Texture Texture => (Texture)(object)_texture;

		private NPCWorkbenchPreview(GameObject root, Avatar avatar, Camera camera, RenderTexture texture, int renderLayer)
		{
			_root = root;
			_avatar = avatar;
			_camera = camera;
			_texture = texture;
			_renderLayer = renderLayer;
			_template = (((Object)(object)avatar.CurrentSettings != (Object)null) ? Object.Instantiate<AvatarSettings>(avatar.CurrentSettings) : null);
			UpdateCamera();
		}

		internal static bool TryCreate(out NPCWorkbenchPreview? preview, out string failure)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: 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_016f: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Expected O, but got Unknown
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			preview = null;
			failure = string.Empty;
			MugshotGenerator instance = Singleton<MugshotGenerator>.Instance;
			Avatar val = (((Object)(object)instance != (Object)null) ? instance.MugshotRig : null);
			if ((Object)(object)val == (Object)null)
			{
				failure = "The native avatar preview rig is not ready. Load a save, then reopen the workbench.";
				return false;
			}
			GameObject val2 = null;
			RenderTexture val3 = null;
			try
			{
				int num = LayerMask.NameToLayer("IconGeneration");
				if (num < 0)
				{
					num = 30;
				}
				val2 = new GameObject("S1API NPC Workbench Preview");
				val2.transform.position = new Vector3(0f, -1000f, 0f);
				GameObject val4 = Object.Instantiate<GameObject>(((Component)val).gameObject, val2.transform, false);
				((Object)val4).name = "Detached Avatar";
				val4.SetActive(true);
				SetLayerRecursively(val4, num);
				Avatar component = val4.GetComponent<Avatar>();
				if ((Object)(object)component == (Object)null)
				{
					throw new InvalidOperationException("The cloned native preview rig has no Avatar component.");
				}
				component.SetVisible(true);
				if ((Object)(object)component.Animation != (Object)null)
				{
					component.Animation.AllowCulling = false;
				}
				foreach (SkinnedMeshRenderer componentsInChild in val4.GetComponentsInChildren<SkinnedMeshRenderer>(true))
				{
					componentsInChild.updateWhenOffscreen = true;
				}
				val3 = new RenderTexture(640, 800, 24, (RenderTextureFormat)0)
				{
					name = "S1API NPC Workbench Preview",
					antiAliasing = 2
				};
				val3.Create();
				GameObject val5 = new GameObject("Preview Camera");
				val5.transform.SetParent(val2.transform, false);
				Camera val6 = val5.AddComponent<Camera>();
				val6.clearFlags = (CameraClearFlags)2;
				val6.backgroundColor = new Color(0.035f, 0.045f, 0.06f, 1f);
				val6.cullingMask = 1 << num;
				val6.nearClipPlane = 0.05f;
				val6.farClipPlane = 20f;
				val6.fieldOfView = 34f;
				val6.targetTexture = val3;
				GameObject val7 = new GameObject("Key Light");
				val7.transform.SetParent(val2.transform, false);
				val7.transform.localPosition = new Vector3(-2f, 3f, -3f);
				val7.transform.LookAt(val2.transform.position + Vector3.up);
				Light val8 = val7.AddComponent<Light>();
				val8.type = (LightType)1;
				val8.intensity = 1.25f;
				val8.color = new Color(1f, 0.88f, 0.76f);
				val8.cullingMask = 1 << num;
				GameObject val9 = new GameObject("Fill Light");
				val9.transform.SetParent(val2.transform, false);
				val9.transform.localEulerAngles = new Vector3(30f, 210f, 0f);
				Light val10 = val9.AddComponent<Light>();
				val10.type = (LightType)1;
				val10.intensity = 0.65f;
				val10.color = new Color(0.55f, 0.72f, 1f);
				val10.cullingMask = 1 << num;
				preview = new NPCWorkbenchPreview(val2, component, val6, val3, num);
				return true;
			}
			catch (Exception ex)
			{
				failure = "Could not create the detached avatar preview: " + ex.Message;
				Logger.Error(failure);
				if ((Object)(object)val3 != (Object)null)
				{
					val3.Release();
					Object.Destroy((Object)(object)val3);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
				}
				return false;
			}
		}

		internal void ScheduleApply(NPCWorkbenchDraft draft)
		{
			_pendingDraft = draft.Clone();
			_settleFrames = 1;
		}

		internal void Tick()
		{
			if (_disposed)
			{
				return;
			}
			if (_pendingDraft != null)
			{
				if (_settleFrames-- > 0)
				{
					return;
				}
				NPCWorkbenchDraft pendingDraft = _pendingDraft;
				_pendingDraft = null;
				Apply(pendingDraft);
			}
			if (_rendererRefreshFrames-- > 0)
			{
				RefreshRenderers();
			}
		}

		internal void Orbit(float horizontal, float vertical)
		{
			_yaw += horizontal;
			_pitch = Mathf.Clamp(_pitch - vertical, -25f, 45f);
			UpdateCamera();
		}

		internal void Zoom(float delta)
		{
			_distance = Mathf.Clamp(_distance - delta, 1.45f, 4.5f);
			UpdateCamera();
		}

		internal void SetPose(int pose)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_avatar.Animation == (Object)null))
			{
				_avatar.Animation.SetCrouched(pose == 2);
				_avatar.SetAnimationBool("Sitting", pose == 1);
				_avatar.Animation.SetMotion(Vector3.zero, pose == 2);
			}
		}

		internal void ResetView()
		{
			_yaw = 180f;
			_pitch = 0f;
			_distance = 2.8f;
			SetPose(0);
			UpdateCamera();
		}

		private void Apply(NPCWorkbenchDraft draft)
		{
			AvatarSettings val = NPCWorkbenchRuntimeAdapter.CreateSettings(draft, _template);
			try
			{
				_avatar.LoadAvatarSettings(val);
				_avatar.SetVisible(true);
				_avatar.Impostor.DisableImpostor();
				if ((Object)(object)_avatar.Animation != (Object)null)
				{
					_avatar.Animation.AllowCulling = false;
				}
				RefreshRenderers();
				_rendererRefreshFrames = 2;
				if ((Object)(object)_appliedSettings != (Object)null)
				{
					Object.Destroy((Object)(object)_appliedSettings);
				}
				_appliedSettings = val;
			}
			catch
			{
				Object.Destroy((Object)(object)val);
				throw;
			}
		}

		private void RefreshRenderers()
		{
			SetLayerRecursively(((Component)_avatar).gameObject, _renderLayer);
			foreach (SkinnedMeshRenderer componentsInChild in ((Component)_avatar).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>(true))
			{
				componentsInChild.updateWhenOffscreen = true;
			}
		}

		private void UpdateCamera()
		{
			//IL_000c: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = _root.transform.position + new Vector3(0f, 1.05f, 0f);
			Quaternion val2 = Quaternion.Euler(_pitch, _yaw, 0f);
			((Component)_camera).transform.position = val + val2 * new Vector3(0f, 0f, _distance);
			((Component)_camera).transform.LookAt(val);
		}

		private static void SetLayerRecursively(GameObject root, int layer)
		{
			root.layer = layer;
			for (int i = 0; i < root.transform.childCount; i++)
			{
				SetLayerRecursively(((Component)root.transform.GetChild(i)).gameObject, layer);
			}
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				_pendingDraft = null;
				if ((Object)(object)_camera != (Object)null)
				{
					_camera.targetTexture = null;
				}
				if ((Object)(object)_texture != (Object)null)
				{
					_texture.Release();
					Object.Destroy((Object)(object)_texture);
				}
				if ((Object)(object)_template != (Object)null)
				{
					Object.Destroy((Object)(object)_template);
				}
				if ((Object)(object)_appliedSettings != (Object)null)
				{
					Object.Destroy((Object)(object)_appliedSettings);
				}
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
				}
			}
		}
	}
	internal static class NPCWorkbenchRuntime
	{
		private static readonly Log Logger = new Log("NPCWorkbench");

		private static NPCWorkbenchView? _view;

		internal static bool IsOpen => _view != null;

		internal static void Open()
		{
			if (_view != null)
			{
				return;
			}
			try
			{
				_view = NPCWorkbenchView.Create();
			}
			catch (Exception value)
			{
				Logger.Error($"Unable to open the NPC workbench: {value}");
				_view?.Dispose();
				_view = null;
			}
		}

		internal static void Tick()
		{
			_view?.Tick();
		}

		internal static void Close()
		{
			_view?.Dispose();
			_view = null;
		}

		internal static void NotifyClosed(NPCWorkbenchView view)
		{
			if (_view == view)
			{
				_view = null;
			}
		}
	}
	internal sealed class NPCWorkbenchCommand : BaseConsoleCommand
	{
		public override string CommandWord => "npcworkbench";

		public override string CommandDescription => "Opens the local-only S1API NPC appearance editor and preview.";

		public override string ExampleUsage => "npcworkbench";

		public override void ExecuteCommand(List<string> args)
		{
			NPCWorkbenchRuntime.Open();
		}
	}
	internal sealed class NPCWorkbenchSourceOption
	{
		internal string Id { get; }

		internal string DisplayName { get; }

		internal bool IsCustom { get; }

		internal NPCWorkbenchSourceOption(string id, string displayName, bool isCustom)
		{
			Id = id;
			DisplayName = displayName;
			IsCustom = isCustom;
		}
	}
	internal static class NPCWorkbenchRuntimeAdapter
	{
		private sealed class AvatarSettingsScope : IDisposable
		{
			internal AvatarSettings Value { get; }

			internal AvatarSettingsScope(AvatarSettings value)
			{
				Value = value;
			}

			public void Dispose()
			{
				if ((Object)(object)Value != (Object)null)
				{
					Object.Destroy((Object)(object)Value);
				}
			}
		}

		internal static IReadOnlyList<NPCWorkbenchSourceOption> GetSources(bool custom)
		{
			if (!custom)
			{
				return GetNativeSources();
			}
			return (from npc in NPC.All.Where((NPC npc) => npc?.IsCustomNPC ?? false).OrderBy<NPC, string>((NPC npc) => npc.ID, StringComparer.OrdinalIgnoreCase)
				select new NPCWorkbenchSourceOption(npc.ID, npc.FullName + " (" + npc.ID + ")", isCustom: true)).ToArray();
		}

		internal static NPCWorkbenchDraft Import(string id, bool custom)
		{
			return custom ? ImportCustom(id) : ImportNative(id);
		}

		private static NPCWorkbenchDraft ImportCustom(string id)
		{
			NPC nPC = NPC.All.FirstOrDefault((NPC candidate) => candidate != null && candidate.IsCustomNPC && string.Equals(candidate.ID, id, StringComparison.OrdinalIgnoreCase));
			if (nPC == null)
			{
				throw new InvalidOperationException("S1API NPC '" + id + "' is not available in the current scene.");
			}
			NPCWorkbenchDraft nPCWorkbenchDraft = new NPCWorkbenchDraft
			{
				SourceKind = NPCWorkbenchSourceKind.S1API,
				SourceId = nPC.ID,
				SourceDisplayName = nPC.FullName + " (" + nPC.ID + ")"
			};
			using (AvatarSettingsScope avatarSettingsScope = new AvatarSettingsScope(nPC.Appearance.CreateSettingsSnapshot()))
			{
				CopyAppearance(avatarSettingsScope.Value, nPCWorkbenchDraft.Appearance);
			}
			AvatarImpostorSelection avatarImpostorSelection = (((Component)nPC.S1NPC).gameObject.GetComponent<NPCPrefabIdentity>() ?? ((Component)nPC.S1NPC).gameObject.GetComponentInChildren<NPCPrefabIdentity>(true))?.AppearanceImpostorSelection;
			if (avatarImpostorSelection != null && avatarImpostorSelection.Kind == AvatarImpostorSelectionKind.Name)
			{
				nPCWorkbenchDraft.Appearance.ImpostorId = avatarImpostorSelection.Name;
			}
			else if (avatarImpostorSelection != null && avatarImpostorSelection.Kind == AvatarImpostorSelectionKind.Definition)
			{
				nPCWorkbenchDraft.Appearance.ImpostorId = avatarImpostorSelection.Definition?.Name;
			}
			return nPCWorkbenchDraft;
		}

		private static NPCWorkbenchDraft ImportNative(string id)
		{
			NPC val = ((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).FirstOrDefault((Func<NPC, bool>)((NPC candidate) => (Object)(object)candidate != (Object)null && string.Equals(NPCDataAccess.GetId(candidate), id, StringComparison.OrdinalIgnoreCase) && !IsCustom(candidate)));
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("Native NPC '" + id + "' is not available in the current scene.");
			}
			Avatar val2 = val.Avatar ?? ((Component)val).gameObject.GetComponentInChildren<Avatar>(true);
			AvatarSettings val3 = ((val2 != null) ? val2.CurrentSettings : null);
			if ((Object)(object)val3 == (Object)null && (Object)(object)val2 != (Object)null)
			{
				object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(val2, "InitialAvatarSettings");
				val3 = (AvatarSettings)((obj is AvatarSettings) ? obj : null);
			}
			if ((Object)(object)val3 == (Object)null)
			{
				throw new InvalidOperationException("Native NPC '" + id + "' has no available appearance settings.");
			}
			NPCWorkbenchDraft nPCWorkbenchDraft = new NPCWorkbenchDraft
			{
				SourceKind = NPCWorkbenchSourceKind.Native,
				SourceId = id,
				SourceDisplayName = GetDisplayName(val) + " (" + id + ")"
			};
			using (AvatarSettingsScope avatarSettingsScope = new AvatarSettingsScope(Object.Instantiate<AvatarSettings>(val3)))
			{
				CopyAppearance(avatarSettingsScope.Value, nPCWorkbenchDraft.Appearance);
			}
			return nPCWorkbenchDraft;
		}

		private static IReadOnlyList<NPCWorkbenchSourceOption> GetNativeSources()
		{
			return (from @group in ((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).Where((NPC npc) => (Object)(object)npc != (Object)null && !IsCustom(npc) && !string.IsNullOrWhiteSpace(NPCDataAccess.GetId(npc))).GroupBy<NPC, string>(NPCDataAccess.GetId, StringComparer.OrdinalIgnoreCase)
				select @group.First()).OrderBy<NPC, string>(NPCDataAccess.GetId, StringComparer.OrdinalIgnoreCase).Select(delegate(NPC npc)
			{
				string id = NPCDataAccess.GetId(npc);
				return new NPCWorkbenchSourceOption(id, GetDisplayName(npc) + " (" + id + ")", isCustom: false);
			}).ToArray();
		}

		private static bool IsCustom(NPC npc)
		{
			if ((Object)(object)((Component)npc).gameObject.GetComponent<NPCPrefabIdentity>() != (Object)null)
			{
				return true;
			}
			return NPC.All.Any((NPC wrapper) => wrapper != null && wrapper.IsCustomNPC && (Object)(object)wrapper.S1NPC == (Object)(object)npc);
		}

		private static string GetDisplayName(NPC npc)
		{
			string firstName = NPCDataAccess.GetFirstName(npc);
			string lastName = NPCDataAccess.GetLastName(npc);
			string text = string.Join(" ", new string[2] { firstName, lastName }.Where((string value) => !string.IsNullOrWhiteSpace(value)));
			return string.IsNullOrWhiteSpace(text) ? NPCDataAccess.GetId(npc) : text;
		}

		internal static AvatarSettings CreateSettings(NPCWorkbenchDraft draft, AvatarSettings? template)
		{
			//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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Expected O, but got Unknown
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			AvatarSettings val = (((Object)(object)template != (Object)null) ? Object.Instantiate<AvatarSettings>(template) : ScriptableObject.CreateInstance<AvatarSettings>());
			NPCWorkbenchAppearance appearance = draft.Appearance;
			val.Gender = appearance.Gender;
			val.Height = appearance.Height;
			val.Weight = appearance.Weight;
			val.SkinColor = ToColor(appearance.SkinColor);
			val.LeftEyeLidColor = ToColor(appearance.LeftEyeLidColor);
			val.RightEyeLidColor = ToColor(appearance.RightEyeLidColor);
			val.EyeBallTint = ToColor(appearance.EyeBallTint);
			val.EyeballMaterialIdentifier = appearance.EyeballMaterialIdentifier;
			val.PupilDilation = appearance.PupilDilation;
			val.EyebrowScale = appearance.EyebrowScale;
			val.EyebrowThickness = appearance.EyebrowThickness;
			val.EyebrowRestingHeight = appearance.EyebrowRestingHeight;
			val.EyebrowRestingAngle = appearance.EyebrowRestingAngle;
			val.LeftEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = appearance.LeftEye.TopLidOpen,
				bottomLidOpen = appearance.LeftEye.BottomLidOpen
			};
			val.RightEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = appearance.RightEye.TopLidOpen,
				bottomLidOpen = appearance.RightEye.BottomLidOpen
			};
			val.HairPath = appearance.HairPath;
			val.HairColor = ToColor(appearance.HairColor);
			val.FaceLayerSettings.Clear();
			foreach (NPCWorkbenchLayer faceLayer in appearance.FaceLayers)
			{
				val.FaceLayerSettings.Add(new LayerSetting
				{
					layerPath = faceLayer.Path,
					layerTint = ToColor(faceLayer.Color)
				});
			}
			val.BodyLayerSettings.Clear();
			foreach (NPCWorkbenchLayer bodyLayer in appearance.BodyLayers)
			{
				val.BodyLayerSettings.Add(new LayerSetting
				{
					layerPath = bodyLayer.Path,
					layerTint = ToColor(bodyLayer.Color)
				});
			}
			val.AccessorySettings.Clear();
			foreach (NPCWorkbenchLayer accessory in appearance.Accessories)
			{
				val.AccessorySettings.Add(new AccessorySetting
				{
					path = accessory.Path,
					color = ToColor(accessory.Color)
				});
			}
			return val;
		}

		private static void CopyAppearance(AvatarSettings settings, NPCWorkbenchAppearance appearance)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			appearance.Gender = settings.Gender;
			appearance.Height = settings.Height;
			appearance.Weight = settings.Weight;
			appearance.SkinColor = FromColor(settings.SkinColor);
			appearance.LeftEyeLidColor = FromColor(settings.LeftEyeLidColor);
			appearance.RightEyeLidColor = FromColor(settings.RightEyeLidColor);
			appearance.EyeBallTint = FromColor(settings.EyeBallTint);
			appearance.EyeballMaterialIdentifier = settings.EyeballMaterialIdentifier ?? string.Empty;
			appearance.PupilDilation = settings.PupilDilation;
			appearance.EyebrowScale = settings.EyebrowScale;
			appearance.EyebrowThickness = settings.EyebrowThickness;
			appearance.EyebrowRestingHeight = settings.EyebrowRestingHeight;
			appearance.EyebrowRestingAngle = settings.EyebrowRestingAngle;
			appearance.LeftEye = new NPCWorkbenchEyeSettings(settings.LeftEyeRestingState.topLidOpen, settings.LeftEyeRestingState.bottomLidOpen);
			appearance.RightEye = new NPCWorkbenchEyeSettings(settings.RightEyeRestingState.topLidOpen, settings.RightEyeRestingState.bottomLidOpen);
			appearance.HairPath = settings.HairPath ?? string.Empty;
			appearance.HairColor = FromColor(settings.HairColor);
			appearance.FaceLayers.Clear();
			Enumerator<LayerSetting> enumerator = settings.FaceLayerSettings.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LayerSetting current = enumerator.Current;
				appearance.FaceLayers.Add(new NPCWorkbenchLayer
				{
					Path = (current.layerPath ?? string.Empty),
					Color = FromColor(current.layerTint)
				});
			}
			appearance.BodyLayers.Clear();
			Enumerator<LayerSetting> enumerator2 = settings.BodyLayerSettings.GetEnumerator();
			while (enumerator2.MoveNext())
			{
				LayerSetting current2 = enumerator2.Current;
				appearance.BodyLayers.Add(new NPCWorkbenchLayer
				{
					Path = (current2.layerPath ?? string.Empty),
					Color = FromColor(current2.layerTint)
				});
			}
			appearance.Accessories.Clear();
			Enumerator<AccessorySetting> enumerator3 = settings.AccessorySettings.GetEnumerator();
			while (enumerator3.MoveNext())
			{
				AccessorySetting current3 = enumerator3.Current;
				appearance.Accessories.Add(new NPCWorkbenchLayer
				{
					Path = (current3.path ?? string.Empty),
					Color = FromColor(current3.color)
				});
			}
		}

		private static Color ToColor(NPCWorkbenchColor value)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			return Color32.op_Implicit(new Color32(value.Red, value.Green, value.Blue, value.Alpha));
		}

		private static NPCWorkbenchColor FromColor(Color value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			Color32 val = Color32.op_Implicit(value);
			return new NPCWorkbenchColor(val.r, val.g, val.b, val.a);
		}
	}
	internal sealed class NPCWorkbenchView : IDisposable
	{
		private static readonly Log Logger = new Log("NPCWorkbench");

		private static readonly Color PanelColor = new Color(0.075f, 0.09f, 0.12f, 0.98f);

		private static readonly Color RaisedColor = new Color(0.12f, 0.15f, 0.19f, 1f);

		private static readonly Color AccentColor = new Color(0.18f, 0.55f, 0.84f, 1f);

		private readonly GameObject _root;

		private readonly RectTransform _editorContent;

		private readonly RawImage _previewImage;

		private readonly Text _sourceText;

		private readonly Text _statusText;

		private readonly Text _codeText;

		private readonly NPCWorkbenchPreview? _preview;

		private readonly CursorLockMode _previousCursorLock;

		private readonly bool _previousCursorVisible;

		private readonly bool? _previousCanLook;

		private readonly bool? _previousCanMove;

		private NPCWorkbenchDraft _draft = new NPCWorkbenchDraft();

		private Vector3 _lastMousePosition;

		private bool _inputCaptured;

		private bool _disposed;

		private NPCWorkbenchView(GameObject root, RectTransform editorContent, RawImage previewImage, Text sourceText, Text statusText, Text codeText, NPCWorkbenchPreview? preview, CursorLockMode previousCursorLock, bool previousCursorVisible, bool? previousCanLook, bool? previousCanMove)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			_root = root;
			_editorContent = editorContent;
			_previewImage = previewImage;
			_sourceText = sourceText;
			_statusText = statusText;
			_codeText = codeText;
			_preview = preview;
			_previousCursorLock = previousCursorLock;
			_previousCursorVisible = previousCursorVisible;
			_previousCanLook = previousCanLook;
			_previousCanMove = previousCanMove;
			BuildEditor();
			Refresh();
		}

		internal static NPCWorkbenchView Create()
		{
			//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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Expected O, but got Unknown
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_0536: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0570: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_082b: Unknown result type (might be due to invalid IL or missing references)
			CursorLockMode lockState = Cursor.lockState;
			bool visible = Cursor.visible;
			bool? previousCanLook = null;
			bool? previousCanMove = null;
			if (PlayerSingleton<PlayerCamera>.InstanceExists)
			{
				PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
				previousCanLook = instance.CanLook;
			}
			if (PlayerSingleton<PlayerMovement>.InstanceExists)
			{
				PlayerMovement instance2 = PlayerSingleton<PlayerMovement>.Instance;
				previousCanMove = instance2.CanMove;
			}
			GameObject val = new GameObject("S1API NPC Workbench");
			Object.DontDestroyOnLoad((Object)(object)val);
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)0;
			val2.sortingOrder = 32000;
			CanvasScaler val3 = val.AddComponent<CanvasScaler>();
			val3.uiScaleMode = (ScaleMode)1;
			val3.referenceResolution = new Vector2(1920f, 1080f);
			val3.matchWidthOrHeight = 0.5f;
			val.AddComponent<GraphicRaycaster>();
			GameObject val4 = Panel("Backdrop", val.transform, new Color(0.015f, 0.02f, 0.03f, 0.94f));
			Stretch(val4.GetComponent<RectTransform>());
			GameObject val5 = Panel("Shell", val4.transform, PanelColor);
			RectTransform component = val5.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.03f, 0.04f);
			component.anchorMax = new Vector2(0.97f, 0.96f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			GameObject val6 = Panel("Header", val5.transform, new Color(0.055f, 0.07f, 0.095f, 1f));
			Anchor(val6.GetComponent<RectTransform>(), 0f, 1f, 1f, 1f, 0f, -76f, 0f, 0f);
			Text val7 = Label("Title", val6.transform, "NPC Appearance Workbench", 28, (TextAnchor)3, (FontStyle)1);
			Anchor(((Graphic)val7).rectTransform, 0f, 0f, 0.4f, 1f, 28f, 0f, 0f, 0f);
			Text val8 = Label("Source", val6.transform, "Blank draft", 15, (TextAnchor)4, (FontStyle)0);
			((Graphic)val8).color = new Color(0.62f, 0.72f, 0.82f);
			Anchor(((Graphic)val8).rectTransform, 0.35f, 0f, 0.72f, 1f, 0f, 0f, 0f, 0f);
			GameObject val9 = Button("Close", val6.transform, "Close", new Color(0.5f, 0.16f, 0.17f));
			Anchor(val9.GetComponent<RectTransform>(), 1f, 0.5f, 1f, 0.5f, -132f, -22f, -24f, 22f);
			GameObject val10 = Panel("Editor", val5.transform, new Color(0.055f, 0.067f, 0.085f, 1f));
			Anchor(val10.GetComponent<RectTransform>(), 0f, 0f, 0.34f, 1f, 16f, 16f, -8f, -92f);
			RectTransform content;
			GameObject val11 = Scroll("Editor Scroll", val10.transform, out content);
			GameObject val12 = Panel("Preview", val5.transform, new Color(0.035f, 0.045f, 0.06f, 1f));
			Anchor(val12.GetComponent<RectTransform>(), 0.34f, 0f, 0.69f, 1f, 8f, 16f, -8f, -92f);
			GameObject val13 = new GameObject("Avatar Preview");
			val13.transform.SetParent(val12.transform, false);
			RectTransform rect = val13.AddComponent<RectTransform>();
			Anchor(rect, 0f, 0.12f, 1f, 1f, 12f, 0f, -12f, -12f);
			RawImage val14 = val13.AddComponent<RawImage>();
			((Graphic)val14).color = Color.white;
			Text val15 = Label("Preview Hint", val12.transform, "Drag to orbit  |  Wheel to zoom", 14, (TextAnchor)4, (FontStyle)0);
			((Graphic)val15).color = new Color(0.62f, 0.68f, 0.75f);
			Anchor(((Graphic)val15).rectTransform, 0f, 0.07f, 1f, 0.12f, 8f, 0f, -8f, 0f);
			GameObject val16 = Panel("Pose Row", val12.transform, Color.clear);
			Anchor(val16.GetComponent<RectTransform>(), 0f, 0f, 1f, 0.07f, 12f, 8f, -12f, -4f);
			AddHorizontalLayout(val16, 8f);
			GameObject val17 = Button("Stand", val16.transform, "Stand", RaisedColor);
			GameObject val18 = Button("Sit", val16.transform, "Sit", RaisedColor);
			GameObject val19 = Button("Crouch", val16.transform, "Crouch", RaisedColor);
			GameObject val20 = Button("Reset View", val16.transform, "Reset View", RaisedColor);
			ConfigureFlexibleButton(val17);
			ConfigureFlexibleButton(val18);
			ConfigureFlexibleButton(val19);
			ConfigureFlexibleButton(val20);
			GameObject val21 = Panel("Output", val5.transform, new Color(0.055f, 0.067f, 0.085f, 1f));
			Anchor(val21.GetComponent<RectTransform>(), 0.69f, 0f, 1f, 1f, 8f, 16f, -16f, -92f);
			Text val22 = Label("Output Title", val21.transform, "Appearance C# export", 19, (TextAnchor)3, (FontStyle)1);
			Anchor(((Graphic)val22).rectTransform, 0f, 1f, 1f, 1f, 16f, -54f, -16f, -10f);
			Text val23 = Label("Diagnostics", val21.transform, string.Empty, 14, (TextAnchor)0, (FontStyle)0);
			val23.horizontalOverflow = (HorizontalWrapMode)0;
			val23.verticalOverflow = (VerticalWrapMode)0;
			Anchor(((Graphic)val23).rectTransform, 0f, 0.78f, 1f, 0.95f, 16f, 0f, -16f, 0f);
			RectTransform content2;
			GameObject val24 = Scroll("Code Scroll", val21.transform, out content2);
			Anchor(val24.GetComponent<RectTransform>(), 0f, 0.12f, 1f, 0.78f, 12f, 0f, -12f, 0f);
			Text val25 = Label("Code", (Transform)(object)content2, string.Empty, 12, (TextAnchor)0, (FontStyle)0);
			val25.font = BuiltinFont();
			val25.horizontalOverflow = (HorizontalWrapMode)0;
			val25.verticalOverflow = (VerticalWrapMode)1;
			((Component)val25).gameObject.AddComponent<LayoutElement>().minHeight = 500f;
			GameObject val26 = Panel("Export Row", val21.transform, Color.clear);
			Anchor(val26.GetComponent<RectTransform>(), 0f, 0f, 1f, 0.12f, 12f, 12f, -12f, -8f);
			AddHorizontalLayout(val26, 8f);
			GameObject val27 = Button("Copy", val26.transform, "Copy C#", AccentColor);
			GameObject val28 = Button("Validate", val26.transform, "Validate", RaisedColor);
			ConfigureFlexibleButton(val27);
			ConfigureFlexibleButton(val28);
			NPCWorkbenchPreview.TryCreate(out NPCWorkbenchPreview preview, out string failure);
			if (preview != null)
			{
				val14.texture = preview.Texture;
			}
			else
			{
				val23.text = failure;
			}
			NPCWorkbenchView view = new NPCWorkbenchView(val, content, val14, val8, val23, val25, preview, lockState, visible, previousCanLook, previousCanMove);
			((UnityEvent)val9.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)view.Dispose));
			((UnityEvent)val17.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				view._preview?.SetPose(0);
			}));
			((UnityEvent)val18.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				view._preview?.SetPose(1);
			}));
			((UnityEvent)val19.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				view._preview?.SetPose(2);
			}));
			((UnityEvent)val20.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				view._preview?.ResetView();
			}));
			((UnityEvent)val27.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)view.CopyExport));
			((UnityEvent)val28.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)view.Refresh));
			view.ActivateInputCapture();
			return view;
		}

		private void ActivateInputCapture()
		{
			_inputCaptured = true;
			try
			{
				if (PlayerSingleton<PlayerCamera>.InstanceExists)
				{
					PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
					instance.AddActiveUIElement("S1API NPC Workbench");
					instance.SetCanLook(false);
				}
				if (PlayerSingleton<PlayerMovement>.InstanceExists)
				{
					PlayerSingleton<PlayerMovement>.Instance.CanMove = false;
				}
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		internal void Tick()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			_preview?.Tick();
			if (Input.GetKeyDown((KeyCode)27))
			{
				Dispose();
				return;
			}
			Vector3 mousePosition = Input.mousePosition;
			bool flag = RectTransformUtility.RectangleContainsScreenPoint(((Graphic)_previewImage).rectTransform, Vector2.op_Implicit(mousePosition));
			if (flag && Input.GetMouseButton(0))
			{
				Vector3 val = mousePosition - _lastMousePosition;
				_preview?.Orbit(val.x * 0.35f, val.y * 0.35f);
			}
			if (flag)
			{
				_preview?.Zoom(Input.mouseScrollDelta.y * 0.2f);
			}
			_lastMousePosition = mousePosition;
		}

		private void BuildEditor()
		{
			ClearChildren((Transform)(object)_editorContent);
			Section("Source");
			GameObject row = Row("Source Buttons");
			AddButton(row, "Blank", delegate
			{
				_draft = new NPCWorkbenchDraft();
				BuildEditor();
				Refresh();
			});
			AddButton(row, "Import native", delegate
			{
				ShowSourcePicker(custom: false);
			});
			AddButton(row, "Import S1API", delegate
			{
				ShowSourcePicker(custom: true);
			});
			Section("Body");
			AddFloat("Gender", _draft.Appearance.Gender, delegate(float value)
			{
				_draft.Appearance.Gender = value;
			});
			AddFloat("Height", _draft.Appearance.Height, delegate(float value)
			{
				_draft.Appearance.Height = value;
			});
			AddFloat("Weight", _draft.Appearance.Weight, delegate(float value)
			{
				_draft.Appearance.Weight = value;
			});
			AddColor("Skin color", _draft.Appearance.SkinColor, delegate(NPCWorkbenchColor value)
			{
				_draft.Appearance.SkinColor = value;
			});
			Section("Eyes");
			AddColor("Left eyelid color", _draft.Appearance.LeftEyeLidColor, delegate(NPCWorkbenchColor value)
			{
				_draft.Appearance.LeftEyeLidColor = value;
			});
			AddColor("Right eyelid color", _draft.Appearance.RightEyeLidColor, delegate(NPCWorkbenchColor value)
			{
				_draft.Appearance.RightEyeLidColor = value;
			});
			AddColor("Eyeball tint", _draft.Appearance.EyeBallTint, delegate(NPCWorkbenchColor value)
			{
				_draft.Appearance.EyeBallTint = value;
			});
			AddInput("Eyeball material ID", _draft.Appearance.EyeballMaterialIdentifier, delegate(string value)
			{
				_draft.Appearance.EyeballMaterialIdentifier = value;
			});
			AddFloat("Pupil dilation", _draft.Appearance.PupilDilation, delegate(float value)
			{
				_draft.Appearance.PupilDilation = value;
			});
			AddEyeControls("Left eye", () => _draft.Appearance.LeftEye, delegate(NPCWorkbenchEyeSettings value)
			{
				_draft.Appearance.LeftEye = value;
			});
			AddEyeControls("Right eye", () => _draft.Appearance.RightEye, delegate(NPCWorkbenchEyeSettings value)
			{
				_draft.Appearance.RightEye = value;
			});
			Section("Eyebrows");
			AddFloat("Scale", _draft.Appearance.EyebrowScale, delegate(float value)
			{
				_draft.Appearance.EyebrowScale = value;
			});
			AddFloat("Thickness", _draft.Appearance.EyebrowThickness, delegate(float value)
			{
				_draft.Appearance.EyebrowThickness = value;
			});
			AddFloat("Resting height", _draft.Appearance.EyebrowRestingHeight, delegate(float value)
			{
				_draft.Appearance.EyebrowRestingHeight = value;
			});
			AddFloat("Resting angle", _draft.Appearance.EyebrowRestingAngle, delegate(float value)
			{
				_draft.Appearance.EyebrowRestingAngle = value;
			});
			Section("Hair");
			AddPathSelection("Hair style", NPCWorkbenchPathKind.Hair, _draft.Appearance.HairPath, delegate(string value)
			{
				_draft.Appearance.HairPath = value;
			});
			AddInput("Custom hair path", _draft.Appearance.HairPath, delegate(string value)
			{
				_draft.Appearance.HairPath = value;
			});
			AddColor("Hair color", _draft.Appearance.HairColor, delegate(NPCWorkbenchColor value)
			{
				_draft.Appearance.HairColor = value;
			});
			AddInput("Impostor settings ID", _draft.Appearance.ImpostorId ?? string.Empty, delegate(string value)
			{
				_draft.Appearance.ImpostorId = (string.IsNullOrWhiteSpace(value) ? null : value);
			});
			AddLayerEditor("Face layers", NPCWorkbenchPathKind.FaceLayer, _draft.Appearance.FaceLayers);
			AddLayerEditor("Body layers", NPCWorkbenchPathKind.BodyLayer, _draft.Appearance.BodyLayers);
			AddLayerEditor("Accessories", NPCWorkbenchPathKind.Accessory, _draft.Appearance.Accessories);
		}

		private void ShowSourcePicker(bool custom)
		{
			IReadOnlyList<NPCWorkbenchSourceOption> sources = NPCWorkbenchRuntimeAdapter.GetSources(custom);
			if (sources.Count == 0)
			{
				SetStatus(custom ? "No configured S1API NPCs are available." : "No native NPCs are available.");
				return;
			}
			ClearChildren((Transform)(object)_editorContent);
			Section(custom ? "Import configured S1API NPC" : "Import native NPC");
			AddNotice("Import copies only current appearance settings into a detached draft. The source NPC is never mutated.");
			foreach (NPCWorkbenchSourceOption option in sources)
			{
				GameObject row = Row(option.Id);
				AddButton(row, option.DisplayName, delegate
				{
					try
					{
						_draft = NPCWorkbenchRuntimeAdapter.Import(option.Id, option.IsCustom);
						BuildEditor();
						Refresh();
					}
					catch (Exception ex)
					{
						SetStatus(ex.Message);
					}
				});
			}
			GameObject row2 = Row("Back");
			AddButton(row2, "Back", BuildEditor);
		}

		private void AddColor(string label, NPCWorkbenchColor value, Action<NPCWorkbenchColor> changed)
		{
			AddInput(label + " (RRGGBBAA)", value.ToHex(), delegate(string text)
			{
				if (NPCWorkbenchColor.TryParse(text, out var color))
				{
					changed(color);
				}
			});
		}

		private void AddEyeControls(string label, Func<NPCWorkbenchEyeSettings> getValue, Action<NPCWorkbenchEyeSettings> changed)
		{
			AddFloat(label + " top lid", getValue().TopLidOpen, delegate(float top)
			{
				NPCWorkbenchEyeSettings nPCWorkbenchEyeSettings = getValue();
				changed(new NPCWorkbenchEyeSettings(top, nPCWorkbenchEyeSettings.BottomLidOpen));
			});
			AddFloat(label + " bottom lid", getValue().BottomLidOpen, delegate(float bottom)
			{
				NPCWorkbenchEyeSettings nPCWorkbenchEyeSettings = getValue();
				changed(new NPCWorkbenchEyeSettings(nPCWorkbenchEyeSettings.TopLidOpen, bottom));
			});
		}

		private void AddLayerEditor(string title, NPCWorkbenchPathKind kind, List<NPCWorkbenchLayer> layers)
		{
			Section(title);
			GameObject row = Row(title + " Add");
			AddButton(row, "Add layer", delegate
			{
				layers.Add(new NPCWorkbenchLayer());
				BuildEditor();
				Refresh();
			});
			for (int num = 0; num < layers.Count; num++)
			{
				int capturedIndex = num;
				NPCWorkbenchLayer layer = layers[num];
				AddPathSelection($"{num + 1}. S1API path", kind, layer.Path, delegate(string value)
				{
					layer.Path = value;
				});
				AddInput($"{num + 1}. Custom path", layer.Path, delegate(string value)
				{
					layer.Path = value;
				});
				AddColor($"{num + 1}. Tint", layer.Color, delegate(NPCWorkbenchColor value)
				{
					layer.Color = value;
				});
				GameObject row2 = Row($"{title} {num + 1} Actions");
				AddButton(row2, "Up", delegate
				{
					MoveLayer(layers, capturedIndex, capturedIndex - 1);
				});
				AddButton(row2, "Down", delegate
				{
					MoveLayer(layers, capturedIndex, capturedIndex + 1);
				});
				AddButton(row2, "Remove", delegate
				{
					layers.RemoveAt(capturedIndex);
					BuildEditor();
					Refresh();
				});
			}
		}

		private void AddPathSelection(string label, NPCWorkbenchPathKind kind, string path, Action<string> selected)
		{
			NPCWorkbenchPathEntry nPCWorkbenchPathEntry = NPCWorkbenchPathCatalog.Find(kind, path);
			GameObject val = Row(label);
			Text val2 = Label(label + " Label", val.transform, nPCWorkbenchPathEntry?.DisplayName ?? (string.IsNullOrWhiteSpace(path) ? "None selected" : "Custom path"), 14, (TextAnchor)3, (FontStyle)0);
			((Component)val2).gameObject.AddComponent<LayoutElement>().preferredWidth = 205f;
			AddButton(val, "Choose", delegate
			{
				ShowPathPicker(kind, selected);
			});
			if (kind == NPCWorkbenchPathKind.Hair && !string.IsNullOrEmpty(path))
			{
				AddButton(val, "Clear", delegate
				{
					selected(string.Empty);
					BuildEditor();
					Refresh();
				});
			}
		}

		private void ShowPathPicker(NPCWorkbenchPathKind kind, Action<string> selected)
		{
			ClearChildren((Transform)(object)_editorContent);
			Section(PathPickerTitle(kind));
			AddNotice("Choose a typed S1API appearance path. The raw path field remains available for custom assets.");
			foreach (IGrouping<string, NPCWorkbenchPathEntry> item in from nPCWorkbenchPathEntry in NPCWorkbenchPathCatalog.Get(kind)
				group nPCWorkbenchPathEntry by nPCWorkbenchPathEntry.GroupName)
			{
				Section(item.Key);
				foreach (NPCWorkbenchPathEntry entry in item)
				{
					GameObject row = Row(entry.DisplayName);
					AddButton(row, entry.MemberName, delegate
					{
						selected(entry.Path);
						BuildEditor();
						Refresh();
					});
				}
			}
			GameObject row2 = Row("Back");
			AddButton(row2, "Back without changes", BuildEditor);
		}

		private static string PathPickerTitle(NPCWorkbenchPathKind kind)
		{
			return kind switch
			{
				NPCWorkbenchPathKind.Hair => "Choose hair style", 
				NPCWorkbenchPathKind.FaceLayer => "Choose face layer", 
				NPCWorkbenchPathKind.BodyLayer => "Choose body or clothing layer", 
				NPCWorkbenchPathKind.Accessory => "Choose accessory", 
				_ => throw new ArgumentOutOfRangeException("kind", kind, null), 
			};
		}

		private void MoveLayer(List<NPCWorkbenchLayer> layers, int from, int to)
		{
			if (to >= 0 && to < layers.Count)
			{
				NPCWorkbenchLayer item = layers[from];
				layers.RemoveAt(from);
				layers.Insert(to, item);
				BuildEditor();
				Refresh();
			}
		}

		private void Refresh()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			NPCWorkbenchExportResult nPCWorkbenchExportResult = NPCWorkbenchExporter.Export(_draft);
			_sourceText.text = _draft.SourceDisplayName;
			_codeText.text = (nPCWorkbenchExportResult.CanExport ? nPCWorkbenchExportResult.Code : "Fix validation errors to generate C#.");
			if (nPCWorkbenchExportResult.Diagnostics.Count == 0)
			{
				((Graphic)_statusText).color = new Color(0.48f, 0.86f, 0.62f);
				_statusText.text = "Appearance is ready to export. Preview is local-only and detached.";
			}
			else
			{
				((Graphic)_statusText).color = (nPCWorkbenchExportResult.CanExport ? new Color(0.95f, 0.76f, 0.36f) : new Color(1f, 0.42f, 0.42f));
				_statusText.text = string.Join("\n", from diagnostic in nPCWorkbenchExportResult.Diagnostics.Take(6)
					select $"{diagnostic.Severity}: {diagnostic.Message}");
			}
			_preview?.ScheduleApply(_draft);
		}

		private void CopyExport()
		{
			NPCWorkbenchExportResult nPCWorkbenchExportResult = NPCWorkbenchExporter.Export(_draft);
			if (!nPCWorkbenchExportResult.CanExport)
			{
				Refresh();
				return;
			}
			GUIUtility.systemCopyBuffer = nPCWorkbenchExportResult.Code;
			SetStatus("Appearance C# copied to the clipboard.");
		}

		private void SetStatus(string message)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			((Graphic)_statusText).color = new Color(0.75f, 0.82f, 0.9f);
			_statusText.text = message;
		}

		private void Section(string title)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Text val = Label(title, (Transform)(object)_editorContent, title, 18, (TextAnchor)3, (FontStyle)1);
			((Graphic)val).color = new Color(0.62f, 0.82f, 1f);
			((Component)val).gameObject.AddComponent<LayoutElement>().preferredHeight = 38f;
		}

		private GameObject Row(string name)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(name, (Transform)(object)_editorContent, Color.clear);
			AddHorizontalLayout(val, 8f);
			val.AddComponent<LayoutElement>().preferredHeight = 42f;
			return val;
		}

		private void AddInput(string label, string value, Action<string> changed)
		{
			GameObject val = Row(label);
			Text val2 = Label(label + " Label", val.transform, label, 14, (TextAnchor)3, (FontStyle)0);
			((Component)val2).gameObject.AddComponent<LayoutElement>().preferredWidth = 205f;
			InputField val3 = InputField(label + " Input", val.transform, value);
			((Component)val3).gameObject.AddComponent<LayoutElement>().flexibleWidth = 1f;
			((UnityEvent<string>)(object)val3.onEndEdit).AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate(string text)
			{
				changed(text);
				Refresh();
			}));
		}

		private void AddFloat(string label, float value, Action<float> changed)
		{
			AddInput(label, value.ToString("0.####", CultureInfo.InvariantCulture), delegate(string text)
			{
				if (float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					changed(result);
				}
			});
		}

		private void AddNotice(string text)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Text val = Label("Notice", (Transform)(object)_editorContent, text, 13, (TextAnchor)0, (FontStyle)0);
			((Graphic)val).color = new Color(0.65f, 0.7f, 0.76f);
			val.horizontalOverflow = (HorizontalWrapMode)0;
			val.verticalOverflow = (VerticalWrapMode)1;
			((Component)val).gameObject.AddComponent<LayoutElement>().preferredHeight = 52f;
		}

		private static GameObject AddButton(GameObject row, string text, Action clicked)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Button(text, row.transform, text, RaisedColor);
			ConfigureFlexibleButton(val);
			((UnityEvent)val.GetComponent<Button>().onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				clicked();
			}));
			return val;
		}

		private static void ConfigureFlexibleButton(GameObject button)
		{
			LayoutElement val = button.AddComponent<LayoutElement>();
			val.minWidth = 72f;
			val.preferredWidth = 108f;
			val.flexibleWidth = 1f;
		}

		public void Dispose()
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			try
			{
				_preview?.Dispose();
				if (_inputCaptured && PlayerSingleton<PlayerCamera>.InstanceExists)
				{
					PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
					instance.RemoveActiveUIElement("S1API NPC Workbench");
					if (_previousCanLook.HasValue)
					{
						instance.SetCanLook(_previousCanLook.Value);
					}
				}
				if (_inputCaptured && PlayerSingleton<PlayerMovement>.InstanceExists && _previousCanMove.HasValue)
				{
					PlayerSingleton<PlayerMovement>.Instance.CanMove = _previousCanMove.Value;
				}
				if (_inputCaptured)
				{
					Cursor.lockState = _previousCursorLock;
					Cursor.visible = _previousCursorVisible;
				}
			}
			catch (Exception value)
			{
				Logger.Error($"Error restoring game state: {value}");
			}
			finally
			{
				if ((Object)(object)_root != (Object)null)
				{
					Object.Destroy((Object)(object)_root);
				}
				NPCWorkbenchRuntime.NotifyClosed(this);
			}
		}

		private static GameObject Panel(string name, Transform parent, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = color;
			return val;
		}

		private static Text Label(string name, Transform parent, string text, int size, TextAnchor alignment, FontStyle style = (FontStyle)0)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			val.AddComponent<RectTransform>();
			Text val2 = val.AddComponent<Text>();
			val2.font = BuiltinFont();
			val2.fontSize = size;
			val2.fontStyle = style;
			val2.alignment = alignment;
			((Graphic)val2).color = Color.white;
			val2.text = text;
			return val2;
		}

		private static GameObject Button(string name, Transform parent, string text, Color color)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(name, parent, color);
			Button val2 = val.AddComponent<Button>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			Text val3 = Label("Label", val.transform, text, 14, (TextAnchor)4, (FontStyle)1);
			Stretch(((Graphic)val3).rectTransform);
			return val;
		}

		private static InputField InputField(string name, Transform parent, string value)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Panel(name, parent, new Color(0.035f, 0.045f, 0.06f, 1f));
			InputField val2 = val.AddComponent<InputField>();
			((Selectable)val2).targetGraphic = (Graphic)(object)val.GetComponent<Image>();
			Text val3 = Label("Text", val.transform, value, 14, (TextAnchor)3, (FontStyle)0);
			val3.supportRichText = false;
			Anchor(((Graphic)val3).rectTransform, 0f, 0f, 1f, 1f, 10f, 2f, -10f, -2f);
			val2.textComponent = val3;
			val2.text = value;
			return val2;
		}

		private static GameObject Scroll(string name, Transform parent, out RectTransform content)
		{
			//IL_0017: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			GameObject val = Panel(name, parent, new Color(0.025f, 0.032f, 0.043f, 1f));
			Stretch(val.GetComponent<RectTransform>());
			GameObject val2 = Panel("Viewport", val.transform, Color.clear);
			Stretch(val2.GetComponent<RectTransform>());
			val2.AddComponent<RectMask2D>();
			GameObject val3 = new GameObject("Content");
			val3.transform.SetParent(val2.transform, false);
			content = val3.AddComponent<RectTransform>();
			content.anchorMin = new Vector2(0f, 1f);
			content.anchorMax = new Vector2(1f, 1f);
			content.pivot = new Vector2(0.5f, 1f);
			content.offsetMin = new Vector2(12f, 0f);
			content.offsetMax = new Vector2(-12f, 0f);
			VerticalLayoutGroup val4 = val3.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val4).spacing = 5f;
			((LayoutGroup)val4).padding = new RectOffset(4, 4, 8, 8);
			((HorizontalOrVerticalLayoutGroup)val4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandWidth = true;
			ContentSizeFitter val5 = val3.AddComponent<ContentSizeFitter>();
			val5.verticalFit = (FitMode)2;
			ScrollRect val6 = val.AddComponent<ScrollRect>();
			val6.viewport = val2.GetComponent<RectTransform>();
			val6.content = content;
			val6.horizontal = false;
			val6.vertical = true;
			val6.movementType = (MovementType)2;
			val6.scrollSensitivity = 24f;
			return val;
		}

		private static void AddHorizontalLayout(GameObject root, float spacing)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			HorizontalLayoutGroup val = root.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val).spacing = spacing;
			((LayoutGroup)val).padding = new RectOffset(4, 4, 4, 4);
			((LayoutGroup)val).childAlignment = (TextAnchor)4;
			((HorizontalOrVerticalLayoutGroup)val).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)val).childForceExpandWidth = false;
		}

		private static Font BuiltinFont()
		{
			return Resources.GetBuiltinResource<Font>("Arial.ttf");
		}

		private static void ClearChildren(Transform parent)
		{
			for (int num = parent.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)parent.GetChild(num)).gameObject);
			}
		}

		private static void Stretch(RectTransform rect)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private static void Anchor(RectTransform rect, float minX, float minY, float maxX, float maxY, float left, float bottom, float right, float top)
		{
			//IL_0004: 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_0023: 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)
			rect.anchorMin = new Vector2(minX, minY);
			rect.anchorMax = new Vector2(maxX, maxY);
			rect.offsetMin = new Vector2(left, bottom);
			rect.offsetMax = new Vector2(right, top);
		}
	}
}
namespace S1API.Internal.Map
{
	internal sealed class DeferredLookup
	{
		public Type? IdentifierType { get; private set; }

		public string? IdentifierName { get; private set; }

		public Action<object> Callback { get; }

		public bool IsResolved { get; private set; }

		public DeferredLookup(Type identifierType, Action<object> callback)
		{
			IdentifierType = identifierType ?? throw new ArgumentNullException("identifierType");
			Callback = callback ?? throw new ArgumentNullException("callback");
			IdentifierName = null;
			IsResolved = false;
		}

		public DeferredLookup(string identifierName, Action<object> callback)
		{
			IdentifierName = identifierName ?? throw new ArgumentNullException("identifierName");
			Callback = callback ?? throw new ArgumentNullException("callback");
			IdentifierType = null;
			IsResolved = false;
		}

		internal void MarkResolved()
		{
			IsResolved = true;
		}
	}
	internal static class DeferredMapResolver
	{
		private static readonly Log Logger = new Log("DeferredMapResolver");

		private static readonly List<DeferredLookup> PendingLookups = new List<DeferredLookup>();

		private static bool MainSceneLoaded = false;

		internal static bool IsMainSceneReady => MainSceneLoaded;

		public static void RegisterDeferredLookup(DeferredLookup lookup)
		{
			if (lookup == null)
			{
				return;
			}
			lock (PendingLookups)
			{
				if (MainSceneLoaded && !lookup.IsResolved)
				{
					TryResolveLookup(lookup);
				}
				else if (!PendingLookups.Contains(lookup))
				{
					PendingLookups.Add(lookup);
				}
			}
		}

		public static void ResolveAll()
		{
			if (MainSceneLoaded)
			{
				return;
			}
			MainSceneLoaded = true;
			List<DeferredLookup> list;
			lock (PendingLookups)
			{
				list = new List<DeferredLookup>(PendingLookups);
			}
			int num = 0;
			int num2 = 0;
			foreach (DeferredLookup item in list)
			{
				if (item.IsResolved)
				{
					continue;
				}
				try
				{
					if (TryResolveLookup(item))
					{
						num++;
					}
					else
					{
						num2++;
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to resolve deferred lookup: " + ex.Message);
					num2++;
				}
			}
			lock (PendingLookups)
			{
				PendingLookups.RemoveAll((DeferredLookup l) => l.IsResolved);
			}
		}

		private static bool TryResolveLookup(DeferredLookup lookup)
		{
			object obj = null;
			if (lookup.IdentifierType != null)
			{
				obj = ResolveTypedLookup(lookup.IdentifierType);
			}
			else if (!string.IsNullOrEmpty(lookup.IdentifierName))
			{
				lookup.MarkResolved();
				return false;
			}
			if (obj != null)
			{
				try
				{
					lookup.Callback(obj);
					lookup.MarkResolved();
					return true;
				}
				catch (Exception ex)
				{
					Logger.Warning("Callback failed for deferred lookup: " + ex.Message);
					lookup.MarkResolved();
					return false;
				}
			}
			return false;
		}

		private static object? ResolveTypedLookup(Type identifierType)
		{
			try
			{
				MethodInfo method = typeof(ParkingLotRegistry).GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
				if (method != null)
				{
					MethodInfo methodInfo = method.MakeGenericMethod(identifierType);
					object obj = methodInfo.Invoke(null, null);
					if (obj is ParkingLotWrapper parkingLotWrapper && parkingLotWrapper != null)
					{
						return parkingLotWrapper;
					}
				}
				MethodInfo method2 = typeof(global::S1API.Map.Building).GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
				if (method2 != null)
				{
					MethodInfo methodInfo2 = method2.MakeGenericMethod(identifierType);
					object obj2 = methodInfo2.Invoke(null, null);
					if (obj2 is global::S1API.Map.Building building && building != null)
					{
						return building;
					}
				}
				MethodInfo method3 = typeof(DeliveryLocation).GetMethod("Get", BindingFlags.Static | BindingFlags.Public);
				if (method3 != null)
				{
					MethodInfo methodInfo3 = method3.MakeGenericMethod(identifierType);
					object obj3 = methodInfo3.Invoke(null, null);
					if (obj3 is DeliveryLocation deliveryLocation && deliveryLocation != null)
					{
						return deliveryLocation;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		public static void Clear()
		{
			lock (PendingLookups)
			{
				PendingLookups.Clear();
			}
			MainSceneLoaded = false;
		}

		public static void TryResolve(DeferredLookup lookup)
		{
			if (lookup != null && !lookup.IsResolved)
			{
				TryResolveLookup(lookup);
			}
		}

		public static bool IsMainScene()
		{
			//IL_0002: 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)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				return string.Equals(((Scene)(ref activeScene)).name, "Main", StringComparison.OrdinalIgnoreCase);
			}
			catch
			{
				return false;
			}
		}

		public static bool IsMenuScene()
		{
			//IL_0002: 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)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				return !string.Equals(((Scene)(ref activeScene)).name, "Main", StringComparison.OrdinalIgnoreCase);
			}
			catch
			{
				return true;
			}
		}
	}
	internal sealed class MapPOIRuntime
	{
		private const string CustomIconName = "S1API.CustomIcon";

		private static readonly Log Logger = new Log("S1API.MapPOI");

		private readonly MapPOI _owner;

		private object? _initializationCoroutine;

		private GameObject? _root;

		private POI? _nativePOI;

		private bool _disposed;

		internal bool IsReady => !_disposed && (Object)(object)_root != (Object)null && (Object)(object)_nativePOI != (Object)null;

		internal bool IsUIReady => IsReady && (Object)(object)_nativePOI.UI != (Object)null && _nativePOI.UISetup;

		internal bool CanContinue => !_disposed && (_initializationCoroutine != null || (Object)(object)_root != (Object)null);

		internal RectTransform? UI => IsUIReady ? _nativePOI.UI : null;

		internal MapPOIRuntime(MapPOI owner)
		{
			_owner = owner;
		}

		internal void Start()
		{
			if (!_disposed && _initializationCoroutine == null && !((Object)(object)_root != (Object)null))
			{
				_initializationCoroutine = MelonCoroutines.Start(InitializeWhenReady());
			}
		}

		internal void ApplyLabel()
		{
			if ((Object)(object)_nativePOI != (Object)null)
			{
				_nativePOI.SetMainText(_owner.Label);
			}
		}

		internal void ApplyIcon()
		{
			if (IsUIReady)
			{
				ApplyIconToCurrentUI();
			}
		}

		internal void ApplyLocation()
		{
			//IL_0096: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root == (Object)null))
			{
				Transform target = _owner.Target;
				if ((Object)(object)target != (Object)null)
				{
					_root.transform.SetParent(target, false);
					_root.transform.localPosition = Vector3.zero;
					_root.transform.localRotation = Quaternion.identity;
				}
				else
				{
					_root.transform.SetParent((Transform)null, true);
					_root.transform.position = _owner.Position;
					_root.transform.rotation = Quaternion.identity;
				}
				UpdatePosition();
			}
		}

		internal void ApplyTextVisibility()
		{
			if ((Object)(object)_nativePOI == (Object)null)
			{
				return;
			}
			_nativePOI.MainTextVisibility = (TextShowMode)_owner.TextVisibility;
			if ((Object)(object)_nativePOI.UI != (Object)null)
			{
				Transform val = ((Transform)_nativePOI.UI).Find("MainLabel");
				Text val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Text>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					((Behaviour)val2).enabled = _owner.TextVisibility == MapPOITextVisibility.Always;
				}
			}
		}

		internal void ApplyRotation()
		{
			if (!((Object)(object)_nativePOI == (Object)null))
			{
				_nativePOI.Rotate = _owner.RotateWithTarget;
				UpdatePosition();
			}
		}

		internal void ApplyVisibility()
		{
			if (!((Object)(object)_root == (Object)null))
			{
				_root.SetActive(_owner.IsVisible);
				if (_owner.IsVisible)
				{
					UpdatePosition();
				}
			}
		}

		internal bool Focus(bool openMap)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsUIReady || !PlayerSingleton<MapApp>.InstanceExists)
			{
				return false;
			}
			MapApp instance = PlayerSingleton<MapApp>.Instance;
			UpdatePosition();
			if (openMap)
			{
				bool skipFocusPlayer = instance.SkipFocusPlayer;
				instance.SkipFocusPlayer = true;
				((App<MapApp>)(object)instance).SetOpen(true);
				instance.SkipFocusPlayer = skipFocusPlayer;
			}
			instance.FocusPosition(_nativePOI.UI.anchoredPosition);
			return true;
		}

		internal void Dispose(bool destroyRuntimeObject)
		{
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			if (_initializationCoroutine != null)
			{
				try
				{
					MelonCoroutines.Stop(_initializationCoroutine);
				}
				catch
				{
				}
				_initializationCoroutine = null;
			}
			if (destroyRuntimeObject && (Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_nativePOI = null;
			_root = null;
		}

		private IEnumerator InitializeWhenReady()
		{
			while (!_disposed)
			{
				if (TryGetNativeUIPrefab(out GameObject uiPrefab))
				{
					try
					{
						CreateNativeMarker(uiPrefab);
					}
					catch (Exception ex)
					{
						Exception ex2 = ex;
						Logger.Error($"Failed to create map POI '{_owner.Id}': {ex2}");
					}
					_initializationCoroutine = null;
					yield break;
				}
				yield return null;
				uiPrefab = null;
			}
			_initializationCoroutine = null;
		}

		private void CreateNativeMarker(GameObject uiPrefab)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			_root = new GameObject("S1API.MapPOI." + _owner.Id);
			_root.SetActive(false);
			ApplyLocation();
			_nativePOI = _root.AddComponent<POI>();
			_nativePOI.onUICreated = new UnityEvent();
			_nativePOI.onUICreated.AddListener(UnityAction.op_Implicit((Action)ApplyUIState));
			_nativePOI.AutoUpdatePosition = true;
			_nativePOI.Rotate = _owner.RotateWithTarget;
			_nativePOI.MainTextVisibility = (TextShowMode)_owner.TextVisibility;
			_nativePOI.DefaultMainText = _owner.Label;
			SetNativeUIPrefab(_nativePOI, uiPrefab);
			_nativePOI.SetMainText(_owner.Label);
			_root.SetActive(_owner.IsVisible);
			if (_owner.IsVisible)
			{
				UpdatePosition();
			}
		}

		private void ApplyUIState()
		{
			ApplyLabel();
			ApplyTextVisibility();
			ApplyIconToCurrentUI();
			UpdatePosition();
		}

		private void ApplyIconToCurrentUI()
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			POI? nativePOI = _nativePOI;
			if ((Object)(object)((nativePOI != null) ? nativePOI.IconContainer : null) == (Object)null)
			{
				return;
			}
			RectTransform iconContainer = _nativePOI.IconContainer;
			Transform val = ((Transform)iconContainer).Find("S1API.CustomIcon");
			for (int i = 0; i < ((Transform)iconContainer).childCount; i++)
			{
				Transform child = ((Transform)iconContainer).GetChild(i);
				if (((Object)child).name != "S1API.CustomIcon")
				{
					((Component)child).gameObject.SetActive((Object)(object)_owner.Icon == (Object)null);
				}
			}
			if ((Object)(object)_owner.Icon == (Object)null)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Component)val).gameObject.SetActive(false);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				return;
			}
			Image val4;
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("S1API.CustomIcon");
				RectTransform val3 = val2.AddComponent<RectTransform>();
				((Transform)val3).SetParent((Transform)(object)iconContainer, false);
				val3.anchorMin = new Vector2(0.5f, 0.5f);
				val3.anchorMax = new Vector2(0.5f, 0.5f);
				val3.pivot = new Vector2(0.5f, 0.5f);
				val3.anchoredPosition = Vector2.zero;
				val3.sizeDelta = new Vector2(26f, 26f);
				val4 = val2.AddComponent<Image>();
				val4.preserveAspect = true;
				((Graphic)val4).raycastTarget = false;
			}
			else
			{
				((Component)val).gameObject.SetActive(true);
				val4 = ((Component)val).GetComponent<Image>();
			}
			val4.sprite = _owner.Icon;
			((Graphic)val4).color = Color.white;
		}

		private void UpdatePosition()
		{
			if ((Object)(object)_nativePOI != (Object)null && (Object)(object)_nativePOI.UI != (Object)null)
			{
				_nativePOI.UpdatePosition();
			}
		}

		private static bool TryGetNativeUIPrefab(out GameObject? uiPrefab)
		{
			uiPrefab = null;
			try
			{
				Player local = Player.Local;
				if ((Object)(object)local == (Object)null || (Object)(object)local.PoI == (Object)null)
				{
					return false;
				}
				uiPrefab = local.PoI.UIPrefab;
				return (Object)(object)uiPrefab != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		private static void SetNativeUIPrefab(POI poi, GameObject uiPrefab)
		{
			poi.UIPrefab = uiPrefab;
		}
	}
	internal static class SeatBootstrap
	{
		public static void OnMainSceneInitialized()
		{
			MelonCoroutines.Start(ScanAndRegisterSeats());
		}

		private static IEnumerator ScanAndRegisterSeats()
		{
			yield return (object)new WaitForSeconds(0.25f);
			RegisterAllCurrentSeats();
			yield return (object)new WaitForSeconds(1f);
			RegisterAllCurrentSeats();
		}

		private static void RegisterAllCurrentSeats()
		{
			Il2CppArrayBase<AvatarSeat> val = Object.FindObjectsOfType<AvatarSeat>(true);
			if (val == null)
			{
				return;
			}
			for (int i = 0; i < val.Length; i++)
			{
				AvatarSeat val2 = val[i];
				if ((Object)(object)val2 != (Object)null)
				{
					Seat.Register(val2);
				}
			}
		}
	}
}
namespace S1API.Internal.Diagnostics
{
	internal static class UnityExceptionTraceHook
	{
		private const string KnownBaseGameNullReferenceAdvisory = "[Unity] Note: this NullReferenceException is commonly observed in the native/base game and is usually not caused by a mod. The original stack trace is retained for diagnosis.";

		private static readonly Log Logger = new Log("S1API.UnityExceptionTrace");

		private static readonly object Sync = new object();

		private static readonly Action<string, string, LogType> ManagedCallback = OnUnityLogMessageReceived;

		private static readonly LogCallback Callback = DelegateSupport.ConvertDelegate<LogCallback>((Delegate)ManagedCallback) ?? LogCallback.op_Implicit(ManagedCallback);

		private static string? _lastExceptionSignature;

		private static DateTime _lastExceptionAtUtc;

		private static bool _installed;

		internal static void Install()
		{
			if (!_installed)
			{
				Application.logMessageReceivedThreaded += Callback;
				_installed = true;
			}
		}

		internal static void Remove()
		{
			if (_installed)
			{
				_installed = false;
			}
		}

		private static void OnUnityLogMessageReceived(string condition, string stackTrace, LogType type)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)type != 4 || !LooksLikeNullReference(condition, stackTrace))
			{
				return;
			}
			string signature = (condition ?? string.Empty) + "\n" + (stackTrace ?? string.Empty);
			if (!ShouldSuppressDuplicate(signature))
			{
				Logger.Error("[Unity] " + condition);
				if (GetKnownBaseGameNullReferenceAdvisory(stackTrace) != null)
				{
					Logger.Warning("[Unity] Note: this NullReferenceException is commonly observed in the native/base game and is usually not caused by a mod. The original stack trace is retained for diagnosis.");
				}
				if (!string.IsNullOrWhiteSpace(stackTrace))
				{
					Logger.Error("[Unity] stack trace:\n" + stackTrace);
				}
			}
		}

		private static bool LooksLikeNullReference(string condition, string stackTrace)
		{
			string text = (condition ?? string.Empty) + "\n" + (stackTrace ?? string.Empty);
			return text.Contains("NullReferenceException", StringComparison.Ordinal);
		}

		internal static string? GetKnownBaseGameNullReferenceAdvisory(string? stackTrace)
		{
			if (string.IsNullOrWhiteSpace(stackTrace))
			{
				return null;
			}
			return (stackTrace.Contains("ScheduleOne.Weather.EnvironmentManager.GetWeatherProfileFromPosition", StringComparison.Ordinal) || stackTrace.Contains("ScheduleOne.NPCs.NPCMovement+<FaceDirection_Process>", StringComparison.Ordinal) || stackTrace.Contains("ScheduleOne.Configuration.ConfigurationServiceNetworker.OnDestroy", StringComparison.Ordinal) || stackTrace.Contains("ScheduleOne.UI.PauseMenu.OnDestroy", StringComparison.Ordinal)) ? "[Unity] Note: this NullReferenceException is commonly observed in the native/base game and is usually not caused by a mod. The original stack trace is retained for diagnosis." : null;
		}

		private static bool ShouldSuppressDuplicate(string signature)
		{
			lock (Sync)
			{
				DateTime utcNow = DateTime.UtcNow;
				if (signature == _lastExceptionSignature && (utcNow - _lastExceptionAtUtc).TotalSeconds < 1.0)
				{
					return true;
				}
				_lastExceptionSignature = signature;
				_lastExceptionAtUtc = utcNow;
				return false;
			}
		}
	}
}
namespace S1API.Internal.Lifecycle
{
	internal static class SceneStateCleaner
	{
		private static readonly Log Logger = new Log("Lifecycle");

		private static void TryRun(Action action, string? warningMessage = null)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				if (!string.IsNullOrEmpty(warningMessage))
				{
					Logger.Warning("[S1API] " + warningMessage + ": " + ex.Message);
				}
			}
		}

		private static bool ShouldResetForScene(string sceneName)
		{
			if (string.IsNullOrEmpty(sceneName))
			{
				return false;
			}
			string a = sceneName.Trim();
			return string.Equals(a, "Main", StringComparison.OrdinalIgnoreCase);
		}

		internal static void ResetForSceneChange(string sceneName, bool afterUnload)
		{
			if (!ShouldResetForScene(sceneName))
			{
				return;
			}
			try
			{
				if (afterUnload)
				{
					for (int i = 0; i < NPC.All.Count; i++)
					{
						NPC npc = NPC.All[i];
						if (npc != null && (Object)(object)npc.gameObject != (Object)null)
						{
							TryRun(delegate
							{
								Object.Destroy((Object)(object)npc.gameObject);
							});
						}
					}
					NPC.All.Clear();
					NPC.FinalizedCustomNpcTypes.Clear();
					NPCPatches.CustomNpcsReady = false;
					QuestManager.Quests.Clear();
					global::S1API.Map.Building.All.Clear();
					DeliveryLocation.All.Clear();
					Seat.Clear();
					ParkingLotRegistry.All.Clear();
					ShopManager.InvalidateCache();
					DeferredMapResolver.Clear();
					TimeManager.ResetBindings();
					HomeScreenScrollPatch.ResetInitializationState();
					NPCAppearance.ResetMugshotState();
					LoadingScreenPatches.ResetState();
					DialogueInjector.ResetState();
					DialogueChoiceListener.ResetState();
					ContactsAppPatches.ResetState();
					NPCPatches.ResetState();
					SupplierRuntimeCoordinator.CleanupForSceneChange();
					NPCDealer.ClearStaticDelegates();
					TimeManagerShim.Instance.ResetDelegates();
				}
				else
				{
					LoadingScreenPatches.ResetState();
					NPCNetworkBootstrap.EnsurePrefabsWarmup();
					if (string.Equals(sceneName, "Main", StringComparison.OrdinalIgnoreCase))
					{
						NPCNetworkBootstrap.OnMainSceneInitialized();
						TryRun(SeatBootstrap.OnMainSceneInitialized);
						TryRun(DeferredMapResolver.ResolveAll, "Failed to resolve deferred map lookups");
						TryRun(TimeManagerShim.Instance.AddDelegatesToReal);
					}
					else
					{
						NPCNetworkBootstrap.ResetFlags();
						TryRun(TimeManagerShim.Instance.DeleteDelegatesFromReal);
					}
					TryRun(TimeManager.TryBindToCurrentInstance);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Scene cleanup encountered an error: " + ex.Message);
			}
		}
	}
	internal class TimeManagerShim
	{
		private static TimeManagerShim? _instance;

		internal Action onSleepStart = delegate
		{
		};

		internal Action onHourPass = delegate
		{
		};

		private Action? il2cppOnSleepStart;

		private Action? il2cppOnHourPass;

		private readonly List<Action> _addedSleepStart = new List<Action>();

		private readonly List<Action> _addedHourPass = new List<Action>();

		internal static TimeManagerShim Instance => _instance ?? (_instance = new TimeManagerShim());

		private TimeManagerShim()
		{
		}

		internal void ResetDelegates()
		{
			onSleepStart = delegate
			{
			};
			onHourPass = delegate
			{
			};
			il2cppOnSleepStart = null;
			il2cppOnHourPass = null;
			_addedSleepStart.Clear();
			_addedHourPass.Clear();
		}

		internal void AddDelegatesToReal()
		{
			try
			{
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					Debug.LogWarning(Object.op_Implicit("TimeManagerShim: Real TimeManager instance not available yet; cannot migrate delegates."));
					return;
				}
				Action val = il2cppOnSleepStart ?? (il2cppOnSleepStart = DelegateSupport.ConvertDelegate<Action>((Delegate)onSleepStart));
				Action val2 = il2cppOnHourPass ?? (il2cppOnHourPass = DelegateSupport.ConvertDelegate<Action>((Delegate)onHourPass));
				if (!((Delegate)(object)val == (Delegate)null) && !((Delegate)(object)val2 == (Delegate)null))
				{
					if (!_addedSleepStart.Contains(val))
					{
						instance.onSleepStart = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)instance.onSleepStart, (Delegate)(object)val)).Cast<Action>();
						_addedSleepStart.Add(val);
					}
					if (!_addedHourPass.Contains(val2))
					{
						instance.onHourPass = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)instance.onHourPass, (Delegate)(object)val2)).Cast<Action>();
						_addedHourPass.Add(val2);
					}
				}
			}
			catch
			{
			}
		}

		internal void DeleteDelegatesFromReal()
		{
			try
			{
				TimeManager instance = NetworkSingleton<TimeManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					Debug.LogWarning(Object.op_Implicit("TimeManagerShim: Real TimeManager instance no longer available; cannot delete delegates."));
					return;
				}
				foreach (Action item in _addedSleepStart)
				{
					instance.onSleepStart = RemoveAll(instance.onSleepStart, item);
				}
				_addedSleepStart.Clear();
				foreach (Action item2 in _addedHourPass)
				{
					instance.onHourPass = RemoveAll(instance.onHourPass, item2);
				}
				_addedHourPass.Clear();
			}
			catch
			{
			}
		}

		private static Action? RemoveAll(Action? original, Action toRemove)
		{
			if ((Delegate)(object)original == (Delegate)null)
			{
				return null;
			}
			Il2CppReferenceArray<Delegate> invocationList = ((Delegate)original).GetInvocationList();
			Action val = null;
			foreach (Delegate item in (Il2CppArrayBase<Delegate>)(object)invocationList)
			{
				if (!((Object)item).Equals((Object)(object)toRemove))
				{
					val = (((Delegate)(object)val == (Delegate)null) ? ((Il2CppObjectBase)item).Cast<Action>() : ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)val, item)).Cast<Action>());
				}
			}
			return val;
		}
	}
}
namespace S1API.Internal.Items
{
	internal static class CustomIngredientRegistry
	{
		private static readonly Log Logger = new Log("CustomIngredientRegistry");

		private static readonly object Gate = new object();

		private static readonly Dictionary<string, PropertyItemDefinition> Ingredients = new Dictionary<string, PropertyItemDefinition>(StringComparer.OrdinalIgnoreCase);

		private static bool _hooked;

		internal static void Register(PropertyItemDefinition definition)
		{
			if ((Object)(object)definition == (Object)null)
			{
				return;
			}
			string iD = ((BaseItemDefinition)definition).ID;
			if (string.IsNullOrWhiteSpace(iD))
			{
				Logger.Warning("Ingredient has no ID; it will not be tracked as a mixing ingredient.");
				return;
			}
			lock (Gate)
			{
				Ingredients[iD] = definition;
				EnsureHooked();
			}
			EnsureInMixIngredients(definition);
		}

		internal static bool TryGetExisting(string id, out PropertyItemDefinition? definition)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				definition = null;
				return false;
			}
			lock (Gate)
			{
				return Ingredients.TryGetValue(id, out definition);
			}
		}

		private static void EnsureHooked()
		{
			if (!_hooked)
			{
				GameLifecycle.OnPreLoad += OnPreLoad;
				GameLifecycle.OnLoadComplete += OnLoadComplete;
				_hooked = true;
			}
		}

		private static void OnPreLoad()
		{
			ReapplyRegistry();
		}

		private static void OnLoadComplete()
		{
			ReapplyRegistry();
			ReapplyMixIngredients();
		}

		private static PropertyItemDefinition[] Snapshot()
		{
			lock (Gate)
			{
				PropertyItemDefinition[] array = (PropertyItemDefinition[])(object)new PropertyItemDefinition[Ingredients.Count];
				Ingredients.Values.CopyTo(array, 0);
				return array;
			}
		}

		private static void ReapplyRegistry()
		{
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				return;
			}
			PropertyItemDefinition[] array = Snapshot();
			foreach (PropertyItemDefinition val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					if (!Registry.ItemExists(((BaseItemDefinition)val).ID))
					{
						Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)val);
					}
				}
				catch (Exception value)
				{
					Logger.Error($"Failed to re-register ingredient '{((BaseItemDefinition)val).ID}': {value}");
				}
			}
		}

		private static void ReapplyMixIngredients()
		{
			PropertyItemDefinition[] array = Snapshot();
			foreach (PropertyItemDefinition val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					EnsureInMixIngredients(val);
				}
			}
		}

		private static bool EnsureInMixIngredients(PropertyItemDefinition definition)
		{
			try
			{
				ProductManager instance = NetworkSingleton<ProductManager>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				List<PropertyItemDefinition> validMixIngredients = instance.ValidMixIngredients;
				if (validMixIngredients == null)
				{
					return false;
				}
				if (!validMixIngredients.Contains(definition))
				{
					validMixIngredients.Add(definition);
				}
				return true;
			}
			catch (Exception value)
			{
				Logger.Error($"Failed to add ingredient '{((definition != null) ? ((BaseItemDefinition)definition).ID : null)}' to the mixing-ingredient list: {value}");
				return false;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	internal class EquippableUseCallback : Equippable_Viewmodel
	{
		public UnityEvent OnUse = new UnityEvent();

		private readonly List<Action<ItemInstance>> _callbacks = new List<Action<ItemInstance>>();

		[HideFromIl2Cpp]
		internal void AddCallback(Action<ItemInstance> callback)
		{
			if (callback != null && !_callbacks.Contains(callback))
			{
				_callbacks.Add(callback);
			}
		}

		public EquippableUseCallback(IntPtr ptr)
			: base(ptr)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown


		public EquippableUseCallback()
			: base(ClassInjector.DerivedConstructorPointer<EquippableUseCallback>())
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			ClassInjector.DerivedConstructorBody((Il2CppObjectBase)(object)this);
		}

		public override void Update()
		{
			((Equippable)this).Update();
			if (OnUse == null || !GameInput.GetButtonDown((ButtonCode)0) || GameInput.IsTyping || GetActiveUIElementCount(PlayerSingleton<PlayerCamera>.Instance) != 0 || ((Equippable)this).itemInstance == null)
			{
				return;
			}
			try
			{
				ItemInstance obj = new ItemInstance(((Equippable)this).itemInstance);
				if (_callbacks != null)
				{
					foreach (Action<ItemInstance> callback in _callbacks)
					{
						try
						{
							callback?.Invoke(obj);
						}
						catch (Exception ex)
						{
							MelonLogger.Error("[EquippableUseCallback] Exception in callback: " + ex.Message);
							MelonLogger.Error(ex.StackTrace);
						}
					}
				}
				UnityEvent onUse = OnUse;
				if (onUse != null)
				{
					onUse.Invoke();
				}
			}
			catch (Exception ex2)
			{
				MelonLogger.Error("[EquippableUseCallback] Exception in use callback: " + ex2.Message);
				MelonLogger.Error(ex2.StackTrace);
			}
		}

		private static int GetActiveUIElementCount(PlayerCamera camera)
		{
			if ((Object)(object)camera == (Object)null)
			{
				return 0;
			}
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(camera, "ActiveUIElementCount") is int result)
			{
				return result;
			}
			return 0;
		}
	}
	internal static class ItemIconRuntime
	{
		private static readonly Log Logger = new Log("ItemIconRuntime");

		internal static void SetIcon(ItemDefinition definition, Sprite icon)
		{
			((BaseItemDefinition)definition).Icon = icon;
			RefreshVisibleUis(definition);
		}

		internal static void RefreshVisibleUis(ItemDefinition definition)
		{
			if (!((Object)(object)definition == (Object)null))
			{
				RefreshBoundItemSlots(((BaseItemDefinition)definition).ID);
				RefreshBoundShopListings(((BaseItemDefinition)definition).ID, ((BaseItemDefinition)definition).Icon);
			}
		}

		private static void RefreshBoundItemSlots(string itemId)
		{
			try
			{
				ItemSlotUI[] array = Il2CppArrayBase<ItemSlotUI>.op_Implicit(Object.FindObjectsOfType<ItemSlotUI>(true));
				foreach (ItemSlotUI val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						ItemSlot assignedSlot = val.assignedSlot;
						object candidateItemId;
						if (assignedSlot == null)
						{
							candidateItemId = null;
						}
						else
						{
							ItemInstance itemInstance = assignedSlot.ItemInstance;
							candidateItemId = ((itemInstance != null) ? ((BaseItemInstance)itemInstance).ID : null);
						}
						if (MatchesItemId((string?)candidateItemId, itemId))
						{
							val.UpdateUI();
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning($"Could not refresh bound item slots for '{itemId}': {ex.Message}");
			}
		}

		private static void RefreshBoundShopListings(string itemId, Sprite icon)
		{
			try
			{
				ListingUI[] array = Il2CppArrayBase<ListingUI>.op_Implicit(Object.FindObjectsOfType<ListingUI>(true));
				foreach (ListingUI val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.Icon == (Object)null))
					{
						ShopListing listing = val.Listing;
						object candidateItemId;
						if (listing == null)
						{
							candidateItemId = null;
						}
						else
						{
							StorableItemDefinition item = listing.Item;
							candidateItemId = ((item != null) ? ((BaseItemDefinition)item).ID : null);
						}
						if (MatchesItemId((string?)candidateItemId, itemId))
						{
							val.Icon.sprite = icon;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning($"Could not refresh bound shop listings for '{itemId}': {ex.Message}");
			}
		}

		internal static bool MatchesItemId(string? candidateItemId, string? targetItemId)
		{
			return !string.IsNullOrWhiteSpace(candidateItemId) && !string.IsNullOrWhiteSpace(targetItemId) && string.Equals(candidateItemId, targetItemId, StringComparison.OrdinalIgnoreCase);
		}
	}
	internal interface IRuntimeItemDefinitionRegistryAdapter
	{
		bool IsRegistered(string itemId);

		void Register(ItemDefinition definition);
	}
	internal sealed class RuntimeItemDefinitionRegistryAdapter : IRuntimeItemDefinitionRegistryAdapter
	{
		internal static readonly RuntimeItemDefinitionRegistryAdapter Instance = new RuntimeItemDefinitionRegistryAdapter();

		private RuntimeItemDefinitionRegistryAdapter()
		{
		}

		public bool IsRegistered(string itemId)
		{
			return (Object)(object)Singleton<Registry>.Instance != (Object)null && Registry.ItemExists(itemId);
		}

		public void Register(ItemDefinition definition)
		{
			if ((Object)(object)Singleton<Registry>.Instance == (Object)null)
			{
				throw new InvalidOperationException("ScheduleOne.Registry is unavailable.");
			}
			Singleton<Registry>.Instance.AddToRegistry(definition);
		}
	}
	internal static class RuntimeItemDefinitionRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, ItemDefinition> Definitions = new Dictionary<string, ItemDefinition>(StringComparer.OrdinalIgnoreCase);

		private static IRuntimeItemDefinitionRegistryAdapter _adapter = RuntimeItemDefinitionRegistryAdapter.Instance;

		private static bool _hooked;

		internal static void Retain(string itemId, ItemDefinition definition)
		{
			if (string.IsNullOrWhiteSpace(itemId))
			{
				throw new ArgumentException("Item ID cannot be empty or whitespace.", "itemId");
			}
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			lock (Gate)
			{
				Definitions[itemId] = definition;
				EnsureHooked();
			}
		}

		internal static void Forget(string itemId)
		{
			if (string.IsNullOrWhiteSpace(itemId))
			{
				return;
			}
			lock (Gate)
			{
				Definitions.Remove(itemId);
			}
		}

		private static void EnsureHooked()
		{
			if (!_hooked)
			{
				GameLifecycle.OnPreLoad += ReapplyAll;
				_hooked = true;
			}
		}

		private static void ReapplyAll()
		{
			KeyValuePair<string, ItemDefinition>[] array;
			lock (Gate)
			{
				array = new KeyValuePair<string, ItemDefinition>[Definitions.Count];
				((ICollection<KeyValuePair<string, ItemDefinition>>)Definitions).CopyTo(array, 0);
			}
			KeyValuePair<string, ItemDefinition>[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<string, ItemDefinition> keyValuePair = array2[i];
				try
				{
					if (!_adapter.IsRegistered(keyValuePair.Key))
					{
						_adapter.Register(keyValuePair.Value);
					}
				}
				catch (Exception value)
				{
					MelonLogger.Error($"[RuntimeItemDefinitionRegistry] Failed to restore item '{keyValuePair.Key}' during pre-load: {value}");
				}
			}
		}

		internal static void ResetForTesting(IRuntimeItemDefinitionRegistryAdapter adapter)
		{
			if (adapter == null)
			{
				throw new ArgumentNullException("adapter");
			}
			lock (Gate)
			{
				if (_hooked)
				{
					GameLifecycle.OnPreLoad -= ReapplyAll;
				}
				Definitions.Clear();
				_adapter = adapter;
				_hooked = false;
			}
		}

		internal static void RestoreRuntimeAdapterForTesting()
		{
			ResetForTesting(RuntimeItemDefinitionRegistryAdapter.Instance);
		}

		internal static void InvokePreLoadForTesting()
		{
			ReapplyAll();
		}
	}
}
namespace S1API.Internal.Entities
{
	internal enum AvatarImpostorSelectionKind
	{
		Preserve,
		Definition,
		Name,
		Texture,
		Random
	}
	internal sealed class AvatarImpostorSelection
	{
		public AvatarImpostorSelectionKind Kind { get; }

		public AvatarImpostorDefinition? Definition { get; }

		public string? Name { get; }

		public Texture2D? Texture { get; }

		public IReadOnlyList<string>? Names { get; }

		public int? Seed { get; }

		private AvatarImpostorSelection(AvatarImpostorSelectionKind kind, AvatarImpostorDefinition? definition = null, string? name = null, Texture2D? texture = null, IReadOnlyList<string>? names = null, int? seed = null)
		{
			Kind = kind;
			Definition = definition;
			Name = name;
			Texture = texture;
			Names = names;
			Seed = seed;
		}

		public static AvatarImpostorSelection Preserve()
		{
			return new AvatarImpostorSelection(AvatarImpostorSelectionKind.Preserve);
		}

		public static AvatarImpostorSelection FromDefinition(AvatarImpostorDefinition definition)
		{
			return new AvatarImpostorSelection(AvatarImpostorSelectionKind.Definition, definition);
		}

		public static AvatarImpostorSelection FromName(string name)
		{
			return new AvatarImpostorSelection(AvatarImpostorSelectionKind.Name, null, name);
		}

		public static AvatarImpostorSelection FromTexture(Texture2D texture)
		{
			return new AvatarImpostorSelection(AvatarImpostorSelectionKind.Texture, null, null, texture);
		}

		public static AvatarImpostorSelection Random(IReadOnlyList<string>? names, int? seed)
		{
			return new AvatarImpostorSelection(AvatarImpostorSelectionKind.Random, null, null, null, names, seed);
		}
	}
	internal static class ImpostorTextureResolver
	{
		private const string CharacterSettingsPath = "charactersettings";

		private static readonly Log Logger = new Log("ImpostorTextureResolver");

		private static readonly string[] KnownImpostorNames = new string[111]
		{
			"Albert", "Alison", "Andy", "Anna", "Austin", "Benji", "BenziesGoon1", "BenziesGoon2", "BenziesGoon3", "BenziesGoon4",
			"Beth", "Billy", "Botanist", "Brad", "Carl", "Charles", "Chemist", "Chloe", "Chris", "Cleaner",
			"Dan", "Dean", "Dennis", "Donna", "Doris", "Doug", "Elizabeth", "Eugene", "Fiona", "Fixer",
			"Frank", "Franklin", "Genghis", "George", "Geraldine", "Greg", "Harold", "Herbert", "Igor", "Jack",
			"Jackie", "Jacob", "Jane", "Javier", "Jeff", "Jen", "Jennifer", "Jeremy", "Jerry", "Jessi",
			"Joe", "Joel", "Joyce", "Karen", "Kathy", "Keith", "Kevin", "Kim", "Kyle", "Leo",
			"Lily", "Lisa", "LoanShark1", "LoanShark2", "Louis", "Lucy", "Ludwig", "Mac", "Mario", "Mayor",
			"Meg", "Melissa", "Michael", "Mick", "Molly", "Nelson", "OfficerBailey", "OfficerCooper", "OfficerDavis", "OfficerGreen",
			"OfficerHoward", "OfficerJackson", "OfficerLee", "OfficerLeo", "OfficerLopez", "OfficerMurphy", "OfficerOakley", "OfficerSanchez", "Oscar", "Packager",
			"Pam", "Pearl", "Peggy", "Peter", "Philip", "Randy", "Ray", "Red", "Salvador", "Sam",
			"Shirley", "Shit1", "Stan", "Steve", "Thomas", "Trent", "Tyler", "Walter", "Wei", "Wong",
			"WW"
		};

		public static IReadOnlyList<AvatarImpostorDefinition> GetAllDefinitions()
		{
			List<AvatarImpostorDefinition> list = new List<AvatarImpostorDefinition>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			AddDefinitionsFromNpcRegistry(list, hashSet);
			try
			{
				Il2CppArrayBase<AvatarSettings> val = Resources.LoadAll<AvatarSettings>("charactersettings");
				if (val != null)
				{
					foreach (AvatarSettings item in val)
					{
						TryAddDefinition(list, hashSet, item);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to load avatar impostor catalog: " + ex.Message);
			}
			string[] knownImpostorNames = KnownImpostorNames;
			foreach (string text in knownImpostorNames)
			{
				if (!hashSet.Contains(text))
				{
					Texture2D val2 = LoadTextureFromCharacterSettings(text);
					if ((Object)(object)val2 != (Object)null && hashSet.Add(text))
					{
						list.Add(new AvatarImpostorDefinition(text, "charactersettings/" + text, val2));
					}
				}
			}
			list.Sort((AvatarImpostorDefinition left, AvatarImpostorDefinition right) => string.Compare(left.Name, right.Name, StringComparison.OrdinalIgnoreCase));
			return list;
		}

		public static AvatarImpostorDefinition? FindDefinition(string? nameOrPath)
		{
			string normalized = NormalizeName(nameOrPath);
			if (string.IsNullOrEmpty(normalized))
			{
				return null;
			}
			AvatarImpostorDefinition avatarImpostorDefinition = GetAllDefinitions().FirstOrDefault((AvatarImpostorDefinition definition) => string.Equals(definition.Name, normalized, StringComparison.OrdinalIgnoreCase) || string.Equals(definition.ResourcePath, nameOrPath, StringComparison.OrdinalIgnoreCase));
			if (avatarImpostorDefinition != null)
			{
				return avatarImpostorDefinition;
			}
			Texture2D val = LoadTextureFromCharacterSettings(normalized);
			return ((Object)(object)val == (Object)null) ? null : new AvatarImpostorDefinition(normalized, "charactersettings/" + normalized, val);
		}

		public static bool TryResolve(AvatarImpostorSelection? selection, string deterministicKey, out Texture2D? texture)
		{
			texture = null;
			if (selection == null || selection.Kind == AvatarImpostorSelectionKind.Preserve)
			{
				return false;
			}
			switch (selection.Kind)
			{
			case AvatarImpostorSelectionKind.Texture:
				texture = selection.Texture;
				return (Object)(object)texture != (Object)null;
			case AvatarImpostorSelectionKind.Definition:
				texture = selection.Definition?.Texture;
				return (Object)(object)texture != (Object)null;
			case AvatarImpostorSelectionKind.Name:
				texture = FindDefinition(selection.Name)?.Texture;
				if ((Object)(object)texture == (Object)null)
				{
					Logger.Warning("Could not resolve avatar impostor '" + selection.Name + "'.");
				}
				return (Object)(object)texture != (Object)null;
			case AvatarImpostorSelectionKind.Random:
				texture = ResolveRandom(selection, deterministicKey);
				return (Object)(object)texture != (Object)null;
			default:
				return false;
			}
		}

		private static Texture2D? ResolveRandom(AvatarImpostorSelection selection, string deterministicKey)
		{
			List<AvatarImpostorDefinition> list = ResolveRandomPool(selection.Names);
			if (list.Count == 0)
			{
				Logger.Warning("Could not resolve any avatar impostors for random selection.");
				return null;
			}
			int seed = selection.Seed ?? CreateStableSeed(deterministicKey);
			int index = new Random(seed).Next(list.Count);
			return list[index].Texture;
		}

		private static List<AvatarImpostorDefinition> ResolveRandomPool(IReadOnlyList<string>? names)
		{
			if (names == null || names.Count == 0)
			{
				return GetAllDefinitions().ToList();
			}
			List<AvatarImpostorDefinition> list = new List<AvatarImpostorDefinition>();
			foreach (string name in names)
			{
				AvatarImpostorDefinition avatarImpostorDefinition = FindDefinition(name);
				if (avatarImpostorDefinition != null)
				{
					list.Add(avatarImpostorDefinition);
				}
				else
				{
					Logger.Warning("Could not resolve avatar impostor '" + name + "' for random selection.");
				}
			}
			return list;
		}

		private static void AddDefinitionsFromNpcRegistry(List<AvatarImpostorDefinition> definitions, HashSet<string> seen)
		{
			try
			{
				if (!NetworkSingleton<NPCManager>.InstanceExists || NPCManager.NPCRegistry == null)
				{
					return;
				}
				foreach (NPC item in NPCManager.NPCRegistry.ToArray())
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					Avatar avatar = item.Avatar;
					AvatarSettings val = (AvatarSettings)(((object)((avatar != null) ? avatar.CurrentSettings : null)) ?? ((object)(((Object)(object)item.Avatar != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null)));
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.ImpostorTexture == (Object)null))
					{
						string text = NormalizeName(item.FirstName);
						if (string.IsNullOrWhiteSpace(text))
						{
							text = NormalizeName(((Object)val).name);
						}
						if (!string.IsNullOrWhiteSpace(text) && seen.Add(text))
						{
							definitions.Add(new AvatarImpostorDefinition(text, "charactersettings/" + text, val.ImpostorTexture));
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to scan NPC registry for avatar impostors: " + ex.Message);
			}
		}

		private static void TryAddDefinition(List<AvatarImpostorDefinition> definitions, HashSet<string> seen, AvatarSettings? setting)
		{
			if (!((Object)(object)setting == (Object)null) && !((Object)(object)setting.ImpostorTexture == (Object)null))
			{
				string text = ((Object)setting).name ?? string.Empty;
				if (!string.IsNullOrWhiteSpace(text) && seen.Add(text))
				{
					definitions.Add(new AvatarImpostorDefinition(text, "charactersettings/" + text, setting.ImpostorTexture));
				}
			}
		}

		private static Texture2D? LoadTextureFromCharacterSettings(string name)
		{
			try
			{
				AvatarSettings val = Resources.Load<AvatarSettings>("charactersettings/" + name);
				return (val != null) ? val.ImpostorTexture : null;
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to load avatar impostor '" + name + "': " + ex.Message);
				return null;
			}
		}

		private static string NormalizeName(string? nameOrPath)
		{
			string text = (nameOrPath ?? string.Empty).Trim();
			if (text.StartsWith("charactersettings/", StringComparison.OrdinalIgnoreCase))
			{
				return text.Substring("charactersettings".Length + 1);
			}
			return text;
		}

		private static int CreateStableSeed(string value)
		{
			int num = 17;
			string text = value ?? string.Empty;
			foreach (char c in text)
			{
				num = num * 31 + c;
			}
			return num;
		}
	}
	internal static class NPCDataAccess
	{
		private static readonly Log Logger = new Log("NPCDataAccess");

		internal static void AssignNewData(NPC npc, NpcRootRole rootRole, NPC? sourceNpc = null)
		{
			if ((Object)(object)npc == (Object)null)
			{
				throw new ArgumentNullException("npc");
			}
			if (1 == 0)
			{
			}
			BaseNPCDataObject val = (BaseNPCDataObject)(rootRole switch
			{
				NpcRootRole.Dealer => ScriptableObject.CreateInstance<DealerNPCDataObject>(), 
				NpcRootRole.Supplier => ScriptableObject.CreateInstance<SupplierNPCDataObject>(), 
				_ => ScriptableObject.CreateInstance<NPCDataObject>(), 
			});
			if (1 == 0)
			{
			}
			BaseNPCDataObject val2 = val;
			if ((Object)(object)val2 == (Object)null)
			{
				throw new InvalidOperationException("Failed to create the beta NPC data object.");
			}
			((Object)val2).hideFlags = (HideFlags)32;
			val2.Initialize();
			NPCData originalData = val2.GetOriginalData();
			PrepareData(originalData);
			if (rootRole == NpcRootRole.Supplier)
			{
				originalData.Messaging.ConversationCanBeHidden = false;
			}
			EnsureDialogueDatabase(originalData, sourceNpc);
			if (rootRole == NpcRootRole.Supplier)
			{
				EnsureSupplierDialogueDatabase(originalData, required: false);
			}
			SetDataObject(npc, val2);
			SetCurrentData(npc, originalData);
		}

		internal static void InitializeCurrentDataForConstruction(NPC npc)
		{
			if ((Object)(object)npc == (Object)null)
			{
				throw new ArgumentNullException("npc");
			}
			BaseNPCDataObject val = GetDataObject(npc) ?? throw new InvalidOperationException("The custom NPC prefab has no framework data object.");
			NPCData data = val.GetRuntimeData() ?? throw new InvalidOperationException("The custom NPC data object returned no runtime data.");
			PrepareData(data);
			SetCurrentData(npc, data);
		}

		internal static bool ApplyIdentity(NPC npc, string? id, string? firstName, string? lastName)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				BasicInfo basicInfo = data.BasicInfo;
				if (!string.IsNullOrWhiteSpace(id))
				{
					basicInfo.ID = id;
				}
				if (!string.IsNullOrWhiteSpace(firstName))
				{
					basicInfo.FirstName = firstName;
				}
				basicInfo.HasLastName = !string.IsNullOrWhiteSpace(lastName);
				basicInfo.LastName = (basicInfo.HasLastName ? lastName : string.Empty);
			});
		}

		internal static string GetId(NPC npc)
		{
			NPCData? currentData = GetCurrentData(npc);
			object obj;
			if (currentData == null)
			{
				obj = null;
			}
			else
			{
				BasicInfo basicInfo = currentData.BasicInfo;
				obj = ((basicInfo != null) ? basicInfo.ID : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return (string)obj;
		}

		internal static string GetFirstName(NPC npc)
		{
			NPCData? currentData = GetCurrentData(npc);
			object obj;
			if (currentData == null)
			{
				obj = null;
			}
			else
			{
				BasicInfo basicInfo = currentData.BasicInfo;
				obj = ((basicInfo != null) ? basicInfo.FirstName : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return (string)obj;
		}

		internal static string GetLastName(NPC npc)
		{
			NPCData? currentData = GetCurrentData(npc);
			object obj;
			if (currentData == null)
			{
				obj = null;
			}
			else
			{
				BasicInfo basicInfo = currentData.BasicInfo;
				obj = ((basicInfo != null) ? basicInfo.LastName : null);
			}
			if (obj == null)
			{
				obj = string.Empty;
			}
			return (string)obj;
		}

		internal static bool ApplyFirstName(NPC npc, string firstName)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				data.BasicInfo.FirstName = firstName ?? string.Empty;
			});
		}

		internal static bool ApplyLastName(NPC npc, string lastName)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				data.BasicInfo.HasLastName = !string.IsNullOrWhiteSpace(lastName);
				data.BasicInfo.LastName = (data.BasicInfo.HasLastName ? lastName : string.Empty);
			});
		}

		internal static bool ApplyId(NPC npc, string id)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				data.BasicInfo.ID = id ?? string.Empty;
			});
		}

		internal static bool ApplyIcon(NPC npc, Sprite? icon)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				data.Appearance.Mugshot = icon;
			});
		}

		internal static Sprite? GetIcon(NPC npc)
		{
			NPCData? currentData = GetCurrentData(npc);
			object result;
			if (currentData == null)
			{
				result = null;
			}
			else
			{
				Appearance appearance = currentData.Appearance;
				result = ((appearance != null) ? appearance.Mugshot : null);
			}
			return (Sprite?)result;
		}

		internal static bool ApplyVoice(NPC npc, VODatabase database, float? pitch)
		{
			if ((Object)(object)database == (Object)null)
			{
				throw new ArgumentNullException("database");
			}
			return ApplyToData(npc, delegate(NPCData data)
			{
				if (data.Voice == null)
				{
					throw new InvalidOperationException("The custom NPC data has no voice settings.");
				}
				data.Voice.VoiceDatabase = database;
				if (pitch.HasValue)
				{
					data.Voice.VoicePitch = pitch.Value;
				}
			});
		}

		internal static bool GetConversationCanBeHidden(NPC npc)
		{
			NPCData? currentData = GetCurrentData(npc);
			bool? obj;
			if (currentData == null)
			{
				obj = null;
			}
			else
			{
				Messaging messaging = currentData.Messaging;
				obj = ((messaging != null) ? new bool?(messaging.ConversationCanBeHidden) : ((bool?)null));
			}
			bool? flag = obj;
			return flag == true;
		}

		internal static bool ApplyConversationCanBeHidden(NPC npc, bool value)
		{
			return ApplyToData(npc, delegate(NPCData data)
			{
				data.Messaging.ConversationCanBeHidden = value;
			});
		}

		internal static IReadOnlyList<EConversationCategory> GetConversationCategories(NPC npc)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			NPCData? currentData = GetCurrentData(npc);
			object obj;
			if (currentData == null)
			{
				obj = null;
			}
			else
			{
				Messaging messaging = currentData.Messaging;
				obj = ((messaging != null) ? messaging.ConversationCategories : null);
			}
			Il2CppStructArray<EConversationCategory> val = (Il2CppStructArray<EConversationCategory>)obj;
			if (val == null)
			{
				return Array.Empty<EConversationCategory>();
			}
			List<EConversationCategory> list = new List<EConversationCategory>(((Il2CppArrayBase<EConversationCategory>)(object)val).Length);
			foreach (EConversationCategory item in (Il2CppArrayBase<EConversationCategory>)(object)val)
			{
				list.Add(item);
			}
			return list;
		}

		internal static bool ApplyConversationCategories(NPC npc, IEnumerable<EConversationCategory> categories)
		{
			EConversationCategory[] values = categories?.ToArray() ?? Array.Empty<EConversationCategory>();
			return ApplyToData(npc, delegate(NPCData data)
			{
				Il2CppStructArray<EConversationCategory> val = new Il2CppStructArray<EConversationCategory>((long)values.Length);
				for (int i = 0; i < values.Length; i++)
				{
					((Il2CppArrayBase<EConversationCategory>)(object)val)[i] = values[i];
				}
				data.Messaging.ConversationCategories = val;
			});
		}

		internal static bool ApplyAppearance(NPC npc, AvatarSettings? settings)
		{
			if ((Object)(object)settings == (Object)null)
			{
				return false;
			}
			NPCData? originalData = GetOriginalData(npc);
			Appearance val = ((originalData != null) ? originalData.Appearance : null);
			if (val == null)
			{
				return false;
			}
			val.AvatarSettings = settings;
			return true;
		}

		internal static bool ApplyDealerDefaults(Dealer dealer, DealerDataBuilder.DealerConfigData data)
		{
			if ((Object)(object)dealer == (Object)null || data == null)
			{
				return false;
			}
			NPCData? originalData = GetOriginalData((NPC?)(object)dealer);
			DealerNPCData val = (DealerNPCData)(object)((originalData is DealerNPCData) ? originalData : null);
			if (val == null)
			{
				return false;
			}
			val.SigningFee = data.SigningFee;
			val.SalesCutPercentage = data.Cut;
			val.DealerType = (EDealerType)data.DealerType;
			if (!string.IsNullOrWhiteSpace(data.HomeName))
			{
				val.HomeName = data.HomeName;
			}
			return true;
		}

		internal static bool ApplySupplierDefaults(Supplier supplier, SupplierDataBuilder.SupplierConfigData data)
		{
			if ((Object)(object)supplier == (Object)null || data == null)
			{
				return false;
			}
			NPCData originalData = GetOriginalData((NPC?)(object)supplier);
			if (originalData == null || !CrossType.Is<SupplierNPCData>((object)originalData, out SupplierNPCData result))
			{
				return false;
			}
			ApplySupplierDefaults(result, data);
			NPCData currentData = GetCurrentData((NPC?)(object)supplier);
			if (currentData != null && CrossType.Is<SupplierNPCData>((object)currentData, out SupplierNPCData result2) && result2 != result)
			{
				ApplySupplierDefaults(result2, data);
			}
			return true;
		}

		internal static void PrepareForRuntime(NPC npc)
		{
			NPCData val = GetOriginalData(npc) ?? throw new InvalidOperationException("The beta NPC has no framework data before network spawn.");
			PrepareData(val);
			EnsureDialogueDatabase(val);
			if (CrossType.Is<SupplierNPCData>((object)val, out SupplierNPCData _))
			{
				EnsureSupplierDialogueDatabase(val, required: true);
			}
			DealerNPCData val2 = (DealerNPCData)(object)((val is DealerNPCData) ? val : null);
			if (val2 != null)
			{
				PopulateDealerDialogueDefaults(val2);
			}
		}

		private static void ApplySupplierDefaults(SupplierNPCData supplierData, SupplierDataBuilder.SupplierConfigData data)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			supplierData.MinimumDeaddropOrderLimit = data.MinimumDeaddropOrderLimit;
			supplierData.MaximumDeaddropOrderLimit = data.MaximumDeaddropOrderLimit;
			supplierData.SupplierRecommendMessage = data.SupplierRecommendMessage;
			supplierData.SupplierUnlockHint = data.SupplierUnlockHint;
			IReadOnlyList<StorableItemDefinition> readOnlyList = data.ResolveDeliveryItems();
			Il2CppReferenceArray<Listing> val = new Il2CppReferenceArray<Listing>((long)readOnlyList.Count);
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				((Il2CppArrayBase<Listing>)(object)val)[i] = new Listing(readOnlyList[i]);
			}
			supplierData.DeliveryShopListings = val;
		}

		private static NPCData? GetOriginalData(NPC? npc)
		{
			object result;
			if (!((Object)(object)npc == (Object)null))
			{
				BaseNPCDataObject? dataObject = GetDataObject(npc);
				result = ((dataObject != null) ? dataObject.GetOriginalData() : null);
			}
			else
			{
				result = null;
			}
			return (NPCData?)result;
		}

		private static NPCData? GetCurrentData(NPC? npc)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return null;
			}
			return npc.NPCData ?? GetOriginalData(npc);
		}

		private static bool ApplyToData(NPC? npc, Action<NPCData> apply)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return false;
			}
			NPCData originalData = GetOriginalData(npc);
			NPCData nPCData = npc.NPCData;
			if (originalData == null && nPCData == null)
			{
				return false;
			}
			if (originalData != null)
			{
				apply(originalData);
			}
			if (nPCData != null && nPCData != originalData)
			{
				apply(nPCData);
			}
			return true;
		}

		internal static BaseNPCDataObject? GetDataObject(NPC npc)
		{
			return npc._npcData;
		}

		private static void SetDataObject(NPC npc, BaseNPCDataObject dataObject)
		{
			npc._npcData = dataObject;
		}

		private static void SetCurrentData(NPC npc, NPCData data)
		{
			npc.NPCData = data;
		}

		private static void PrepareData(NPCData data)
		{
			if (data == null)
			{
				throw new InvalidOperationException("The beta NPC data object returned no data.");
			}
			Inventory inventory = data.Inventory;
			if (inventory.RandomInventoryItems == null)
			{
				Il2CppReferenceArray<WeightedItem> val = (inventory.RandomInventoryItems = new Il2CppReferenceArray<WeightedItem>(0L));
			}
			inventory = data.Inventory;
			if (inventory.StartingInventoryItems == null)
			{
				Il2CppReferenceArray<ItemDefinition> val3 = (inventory.StartingInventoryItems = new Il2CppReferenceArray<ItemDefinition>(0L));
			}
			Messaging messaging = data.Messaging;
			if (messaging.ConversationCategories == null)
			{
				Il2CppStructArray<EConversationCategory> val5 = (messaging.ConversationCategories = new Il2CppStructArray<EConversationCategory>(0L));
			}
			if (CrossType.Is<SupplierNPCData>((object)data, out SupplierNPCData result))
			{
				SupplierNPCData val7 = result;
				if (val7.DeliveryShopListings == null)
				{
					Il2CppReferenceArray<Listing> val8 = (val7.DeliveryShopListings = new Il2CppReferenceArray<Listing>(0L));
				}
			}
		}

		private static void EnsureDialogueDatabase(NPCData data, NPC? sourceNpc = null)
		{
			if (data.Dialogue == null)
			{
				throw new InvalidOperationException("The beta NPC data has no dialogue settings.");
			}
			if ((Object)(object)data.Dialogue.DialogueDatabase != (Object)null)
			{
				return;
			}
			NPCData val = GetOriginalData(sourceNpc) ?? GetCurrentData(sourceNpc);
			bool flag = sourceNpc is Employee;
			if (ShouldReuseSourceDialogueDatabase(flag))
			{
				object obj;
				if (val == null)
				{
					obj = null;
				}
				else
				{
					Dialogue dialogue = val.Dialogue;
					obj = ((dialogue != null) ? dialogue.DialogueDatabase : null);
				}
				if ((Object)obj != (Object)null)
				{
					data.Dialogue.DialogueDatabase = val.Dialogue.DialogueDatabase;
				}
			}
			if ((Object)(object)data.Dialogue.DialogueDatabase == (Object)null)
			{
				DialogueManager instance = Singleton<DialogueManager>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					data.Dialogue.DialogueDatabase = instance.DefaultDatabase;
				}
			}
			if ((Object)(object)data.Dialogue.DialogueDatabase == (Object)null)
			{
				DialogueDatabase[] array = Il2CppArrayBase<DialogueDatabase>.op_Implicit(Resources.FindObjectsOfTypeAll<DialogueDatabase>());
				if (array.Length != 0)
				{
					data.Dialogue.DialogueDatabase = array[0];
				}
			}
			if ((Object)(object)data.Dialogue.DialogueDatabase == (Object)null)
			{
				throw new InvalidOperationException("No 0.4.6 dialogue database is loaded for the custom NPC.");
			}
			if (!flag)
			{
				return;
			}
			Log logger = Logger;
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(111, 2);
			defaultInterpolatedStringHandler.AppendLiteral("[S1API][BaseEmployeeFallback][Dialogue] Rebased employee source dialogue ");
			defaultInterpolatedStringHandler.AppendLiteral("'");
			object obj2;
			if (val == null)
			{
				obj2 = null;
			}
			else
			{
				Dialogue dialogue2 = val.Dialogue;
				if (dialogue2 == null)
				{
					obj2 = null;
				}
				else
				{
					DialogueDatabase dialogueDatabase = dialogue2.DialogueDatabase;
					obj2 = ((dialogueDatabase != null) ? ((Object)dialogueDatabase).name : null);
				}
			}
			if (obj2 == null)
			{
				obj2 = "<null>";
			}
			defaultInterpolatedStringHandler.AppendFormatted((string?)obj2);
			defaultInterpolatedStringHandler.AppendLiteral("' to ");
			defaultInterpolatedStringHandler.AppendLiteral("'");
			defaultInterpolatedStringHandler.AppendFormatted(((Object)data.Dialogue.DialogueDatabase).name);
			defaultInterpolatedStringHandler.AppendLiteral("' for the replacement NPC data.");
			logger.Debug(defaultInterpolatedStringHandler.ToStringAndClear());
		}

		internal static bool ShouldReuseSourceDialogueDatabase(bool sourceIsEmployee)
		{
			return !sourceIsEmployee;
		}

		private static void EnsureSupplierDialogueDatabase(NPCData data, bool required)
		{
			Dialogue dialogue = data.Dialogue;
			if (dialogue == null)
			{
				if (required)
				{
					throw new InvalidOperationException("The beta supplier NPC data has no dialogue settings.");
				}
				return;
			}
			DialogueDatabase dialogueDatabase = dialogue.DialogueDatabase;
			if ((Object)(object)dialogueDatabase != (Object)null && ((Object)dialogueDatabase).name.StartsWith("S1API_SupplierDialogue_", StringComparison.Ordinal) && HasRequiredSupplierDialogue(dialogueDatabase))
			{
				return;
			}
			DialogueDatabase val = ((IEnumerable<DialogueDatabase>)Resources.FindObjectsOfTypeAll<DialogueDatabase>()).Where(HasRequiredSupplierDialogue).OrderBy<DialogueDatabase, string>((DialogueDatabase database) => ((Object)database).name, StringComparer.Ordinal).FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				if (required)
				{
					throw new InvalidOperationException("No loaded supplier dialogue database contains the native supplier meeting entries.");
				}
			}
			else
			{
				DialogueDatabase val2 = Object.Instantiate<DialogueDatabase>(val);
				((Object)val2).name = "S1API_SupplierDialogue_" + ((Object)val).name;
				((Object)val2).hideFlags = (HideFlags)32;
				ApplyGenericSupplierDialogue(val2);
				dialogue.DialogueDatabase = val2;
			}
		}

		private static bool HasRequiredSupplierDialogue(DialogueDatabase database)
		{
			if (((database != null) ? database.GenericEntries : null) == null)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal) { "supplier_unlocked", "supplier_meet_confirm", "supplier_meeting_greeting", "meeting_order_complete", "supplier_meetings_unlocked", "supplier_deliveries_unlocked" };
			Enumerator<Entry> enumerator = database.GenericEntries.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entry current = enumerator.Current;
				if (!string.IsNullOrEmpty(current.Key))
				{
					hashSet.Remove(current.Key);
				}
			}
			return hashSet.Count == 0;
		}

		private static void ApplyGenericSupplierDialogue(DialogueDatabase database)
		{
			SetSupplierDialogueLines(database, "supplier_unlocked", "I've heard you're looking for supplies.", "Send me a message when you'd like to place an order. You can pay off the balance later.");
			SetSupplierDialogueLines(database, "supplier_meet_confirm", "Agreed. I'll be <LOCATION> for the next 6 hours.");
			SetSupplierDialogueLines(database, "supplier_meeting_greeting", "Ready to look over the supplies?");
			SetSupplierDialogueLines(database, "meeting_order_complete", "Good doing business with you.");
			SetSupplierDialogueLines(database, "supplier_meetings_unlocked", "You've proven reliable, so we can now arrange in-person meetings for larger orders.", "Send me a message when you'd like to meet.");
			SetSupplierDialogueLines(database, "supplier_deliveries_unlocked", "I can now deliver supplies directly to your properties. Use the deliveries app to place an order.");
		}

		private static void SetSupplierDialogueLines(DialogueDatabase database, string key, params string[] values)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			if (((database != null) ? database.GenericEntries : null) == null)
			{
				return;
			}
			Enumerator<Entry> enumerator = database.GenericEntries.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Entry current = enumerator.Current;
				if (!string.Equals(current.Key, key, StringComparison.Ordinal) || current.Chains == null)
				{
					continue;
				}
				for (int i = 0; i < ((Il2CppArrayBase<DialogueChain>)(object)current.Chains).Length; i++)
				{
					DialogueChain val = ((Il2CppArrayBase<DialogueChain>)(object)current.Chains)[i];
					if (val != null)
					{
						Il2CppStringArray val2 = new Il2CppStringArray((long)values.Length);
						for (int j = 0; j < values.Length; j++)
						{
							((Il2CppArrayBase<string>)(object)val2)[j] = values[j];
						}
						val.Lines = val2;
					}
				}
				break;
			}
		}

		private static void PopulateDealerDialogueDefaults(DealerNPCData dealerData)
		{
			if ((Object)(object)dealerData.RecruitDialogue != (Object)null && (Object)(object)dealerData.CollectCashDialogue != (Object)null && (Object)(object)dealerData.AssignCustomersDialogue != (Object)null)
			{
				return;
			}
			DealerNPCDataObject[] array = Il2CppArrayBase<DealerNPCDataObject>.op_Implicit(Resources.FindObjectsOfTypeAll<DealerNPCDataObject>());
			DealerNPCDataObject[] array2 = array;
			foreach (DealerNPCDataObject val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				NPCData originalData = ((BaseNPCDataObject)val).GetOriginalData();
				DealerNPCData val2 = (DealerNPCData)(object)((originalData is DealerNPCData) ? originalData : null);
				if (val2 != null)
				{
					DealerNPCData val3 = dealerData;
					if (val3.RecruitDialogue == null)
					{
						DialogueContainer val4 = (val3.RecruitDialogue = val2.RecruitDialogue);
					}
					val3 = dealerData;
					if (val3.CollectCashDialogue == null)
					{
						DialogueContainer val4 = (val3.CollectCashDialogue = val2.CollectCashDialogue);
					}
					val3 = dealerData;
					if (val3.AssignCustomersDialogue == null)
					{
						DialogueContainer val4 = (val3.AssignCustomersDialogue = val2.AssignCustomersDialogue);
					}
					if ((Object)(object)dealerData.RecruitDialogue != (Object)null && (Object)(object)dealerData.CollectCashDialogue != (Object)null && (Object)(object)dealerData.AssignCustomersDialogue != (Object)null)
					{
						break;
					}
				}
			}
		}
	}
	internal static class NPCNetworkBootstrap
	{
		private sealed class PendingSpawn
		{
			internal readonly NPC Owner;

			internal readonly NetworkObject NetObject;

			internal readonly float ActivateAt;

			internal readonly float SpawnAt;

			internal bool ActivationApplied;

			internal PendingSpawn(NPC owner, NetworkObject netObject, float activateAt, float spawnAt)
			{
				Owner = owner;
				NetObject = netObject;
				ActivateAt = activateAt;
				SpawnAt = spawnAt;
				ActivationApplied = false;
			}
		}

		private static readonly Log Logger = new Log("NPCNetworkBootstrap");

		private static bool mainSceneInitialized;

		private static bool networkObserved;

		private static bool clientsReady;

		private static bool connectionObjectsReady;

		private static bool prefabsWarmupScheduled;

		private static float mainSceneInitTime;

		private static readonly List<PendingSpawn> PendingSpawns = new List<PendingSpawn>();

		private static bool readinessLogInitialized;

		private static bool lastLogInMain;

		private static bool lastLogServerUp;

		private static bool lastLogClientUp;

		private static bool lastLogRemoteReady;

		private static bool lastLogHasRemote;

		private static bool lastLogClientsReady;

		private static float lastStateLogTime;

		private static bool pendingSpawnBlockedLogged;

		private static bool AllNetworkPrefabsReady => NPC.PrefabsConfiguredForLocalProcess && SupplierRuntimeCoordinator.DeliveryPrefabsReadyForLocalProcess;

		public static bool ClientsReadyToSpawnNpcs => mainSceneInitialized && AllNetworkPrefabsReady && connectionObjectsReady && clientsReady;

		internal static void ResetFlags()
		{
			mainSceneInitialized = false;
			networkObserved = false;
			clientsReady = false;
			connectionObjectsReady = false;
			prefabsWarmupScheduled = false;
			mainSceneInitTime = 0f;
			PendingSpawns.Clear();
			readinessLogInitialized = false;
			pendingSpawnBlockedLogged = false;
		}

		internal static void EnsurePrefabsWarmup()
		{
			if (!AllNetworkPrefabsReady && !prefabsWarmupScheduled)
			{
				prefabsWarmupScheduled = true;
				MelonCoroutines.Start(PrefabWarmupCoroutine());
			}
		}

		internal static void RegisterPendingNetworkSpawn(NPC? owner, NetworkObject netObject, float activationDelay, float spawnDelay)
		{
			if (owner == null || (Object)(object)netObject == (Object)null)
			{
				return;
			}
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if ((Object)(object)networkManager != (Object)null && !networkManager.IsServer)
				{
					return;
				}
				EnsurePrefabsWarmup();
				for (int num = PendingSpawns.Count - 1; num >= 0; num--)
				{
					PendingSpawn pendingSpawn = PendingSpawns[num];
					if (pendingSpawn == null || (Object)(object)pendingSpawn.NetObject == (Object)null || (Object)(object)pendingSpawn.NetObject == (Object)(object)netObject)
					{
						PendingSpawns.RemoveAt(num);
					}
				}
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				float activateAt = realtimeSinceStartup + Math.Max(0f, activationDelay);
				float spawnAt = realtimeSinceStartup + Math.Max(spawnDelay, activationDelay);
				PendingSpawns.Add(new PendingSpawn(owner, netObject, activateAt, spawnAt));
				TryProcessPendingSpawns();
			}
			catch (Exception ex)
			{
				MelonLogger.Warning("[S1API] Failed to register pending NPC spawn: " + ex.Message);
			}
		}

		public static void OnMainSceneInitialized()
		{
			ResetFlags();
			mainSceneInitialized = true;
			mainSceneInitTime = Time.realtimeSinceStartup;
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				PrefabObjects val = ((networkManager != null) ? networkManager.SpawnablePrefabs : null);
				if ((Object)(object)val != (Object)null)
				{
					NPC.PreRegisterAllNpcPrefabs();
					if (!AllNetworkPrefabsReady)
					{
						EnsurePrefabsWarmup();
					}
				}
				else
				{
					EnsurePrefabsWarmup();
				}
			}
			catch
			{
				EnsurePrefabsWarmup();
			}
			MelonCoroutines.Start(ReadinessMonitor());
		}

		private static IEnumerator PrefabWarmupCoroutine()
		{
			float start = Time.realtimeSinceStartup;
			float timeout = 20f;
			while (!AllNetworkPrefabsReady && Time.realtimeSinceStartup - start < timeout)
			{
				PrefabObjects spawnables = null;
				try
				{
					NetworkManager nm = InstanceFinder.NetworkManager;
					spawnables = ((nm != null) ? nm.SpawnablePrefabs : null);
				}
				catch
				{
				}
				if ((Object)(object)spawnables != (Object)null)
				{
					try
					{
						NPC.PreRegisterAllNpcPrefabs();
						if (AllNetworkPrefabsReady)
						{
							break;
						}
					}
					catch (Exception ex)
					{
						Exception ex2 = ex;
						MelonLogger.Warning("[S1API] Prefab warmup failed: " + ex2.Message);
						break;
					}
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			prefabsWarmupScheduled = false;
			TryProcessPendingSpawns();
		}

		private static IEnumerator ReadinessMonitor()
		{
			NetworkManager nm = null;
			float start = Time.realtimeSinceStartup;
			while ((Object)(object)nm == (Object)null)
			{
				nm = InstanceFinder.NetworkManager;
				if ((Object)(object)nm != (Object)null)
				{
					break;
				}
				if (Time.realtimeSinceStartup - start > 10f)
				{
					yield break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			if ((Object)(object)nm != (Object)null && !nm.IsServer)
			{
				yield break;
			}
			if (!networkObserved)
			{
				networkObserved = true;
				try
				{
					MelonCoroutines.Start(PeriodicEvaluate());
				}
				catch
				{
				}
			}
			float maxWait = 12f;
			while (!clientsReady && Time.realtimeSinceStartup - start < maxWait)
			{
				EvaluateReadiness();
				yield return (object)new WaitForSeconds(0.25f);
			}
			EvaluateReadiness();
			TryProcessPendingSpawns();
		}

		private static IEnumerator PeriodicEvaluate()
		{
			while (true)
			{
				EvaluateReadiness();
				TryProcessPendingSpawns();
				yield return (object)new WaitForSeconds(0.25f);
			}
		}

		private static void EvaluateReadiness()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if ((Object)(object)networkManager == (Object)null || !AllNetworkPrefabsReady)
			{
				clientsReady = false;
				connectionObjectsReady = false;
				return;
			}
			bool hasRemoteClients;
			bool flag = (connectionObjectsReady = AreRemoteConnectionsReady(networkManager, out hasRemoteClients));
			bool flag2 = false;
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				flag2 = ((Scene)(ref activeScene)).name == "Main";
			}
			catch
			{
			}
			bool flag3 = networkManager.IsServer && (Object)(object)networkManager.ServerManager != (Object)null && networkManager.ServerManager.Started;
			bool flag4 = !networkManager.IsServer || networkManager.IsClient || hasRemoteClients;
			clientsReady = flag2 && flag3 && flag4 && flag;
			LogReadinessState(flag2, flag3, flag4, flag, hasRemoteClients);
		}

		private static bool HasRemoteClients()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if ((Object)(object)networkManager == (Object)null)
				{
					return false;
				}
				if (!networkManager.IsServer)
				{
					return false;
				}
				ServerManager serverManager = networkManager.ServerManager;
				Dictionary<int, NetworkConnection> val = ((serverManager != null) ? serverManager.Clients : null);
				if (val == null)
				{
					return false;
				}
				int num = 0;
				Enumerator<int, NetworkConnection> enumerator = val.GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<int, NetworkConnection> current = enumerator.Current;
					NetworkConnection value = current.Value;
					if (!(value == (NetworkConnection)null) && !value.IsLocalClient)
					{
						num++;
					}
				}
				return num > 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool AreRemoteConnectionsReady(NetworkManager nm, out bool hasRemoteClients)
		{
			hasRemoteClients = false;
			try
			{
				if ((Object)(object)nm == (Object)null)
				{
					return false;
				}
				ServerManager serverManager = nm.ServerManager;
				if ((Object)(object)serverManager == (Object)null)
				{
					return false;
				}
				Dictionary<int, NetworkConnection> clients = serverManager.Clients;
				if (clients == null)
				{
					return true;
				}
				Enumerator<int, NetworkConnection> enumerator = clients.GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<int, NetworkConnection> current = enumerator.Current;
					NetworkConnection value = current.Value;
					if (!(value == (NetworkConnection)null) && value.IsValid && !value.IsLocalClient)
					{
						hasRemoteClients = true;
						if (!value.Authenticated)
						{
							return false;
						}
						if ((Object)(object)value.FirstObject == (Object)null)
						{
							return false;
						}
					}
				}
				if (!hasRemoteClients)
				{
					return true;
				}
				float num = Time.realtimeSinceStartup - mainSceneInitTime;
				return !(num < 5f);
			}
			catch
			{
				return false;
			}
		}

		private static void TryProcessPendingSpawns()
		{
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			if (PendingSpawns.Count == 0)
			{
				pendingSpawnBlockedLogged = false;
				return;
			}
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if ((Object)(object)networkManager == (Object)null || !networkManager.IsServer)
			{
				return;
			}
			if (!ClientsReadyToSpawnNpcs)
			{
				if (!pendingSpawnBlockedLogged)
				{
					pendingSpawnBlockedLogged = true;
				}
				return;
			}
			pendingSpawnBlockedLogged = false;
			ServerManager serverManager = networkManager.ServerManager;
			if ((Object)(object)serverManager == (Object)null)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			for (int num = PendingSpawns.Count - 1; num >= 0; num--)
			{
				PendingSpawn pendingSpawn = PendingSpawns[num];
				if (pendingSpawn == null)
				{
					PendingSpawns.RemoveAt(num);
					continue;
				}
				NetworkObject netObject = pendingSpawn.NetObject;
				NPC owner = pendingSpawn.Owner;
				object obj = owner?.ID;
				if (obj == null)
				{
					if (owner == null)
					{
						obj = null;
					}
					else
					{
						GameObject gameObject = owner.gameObject;
						obj = ((gameObject != null) ? ((Object)gameObject).name : null);
					}
					if (obj == null)
					{
						obj = "<unknown>";
					}
				}
				string text = (string)obj;
				if ((Object)(object)netObject == (Object)null)
				{
					PendingSpawns.RemoveAt(num);
					continue;
				}
				GameObject gameObject2 = ((Component)netObject).gameObject;
				if ((Object)(object)gameObject2 == (Object)null)
				{
					PendingSpawns.RemoveAt(num);
					continue;
				}
				if (netObject.IsSpawned)
				{
					try
					{
						owner?.FinalizeNetworkSpawn();
					}
					catch (Exception ex)
					{
						Logger.Warning("[NPCNetworkBootstrap] FinalizeNetworkSpawn threw for already-spawned NPC '" + text + "': " + ex.Message);
					}
					PendingSpawns.RemoveAt(num);
					continue;
				}
				if (!pendingSpawn.ActivationApplied && realtimeSinceStartup >= pendingSpawn.ActivateAt)
				{
					pendingSpawn.ActivationApplied = true;
				}
				if (realtimeSinceStartup < pendingSpawn.SpawnAt)
				{
					continue;
				}
				try
				{
					if (owner != null && !owner.PrepareForNetworkSpawn())
					{
						Logger.Warning("[NPCNetworkBootstrap] Dropping invalid pending spawn for '" + text + "'.");
						PendingSpawns.RemoveAt(num);
						continue;
					}
				}
				catch (Exception ex2)
				{
					Logger.Warning("[NPCNetworkBootstrap] PrepareForNetworkSpawn threw for '" + text + "': " + ex2.Message);
					PendingSpawns.RemoveAt(num);
					continue;
				}
				try
				{
					serverManager.Spawn(netObject, (NetworkConnection)null, default(Scene));
				}
				catch (Exception ex3)
				{
					MelonLogger.Warning("[S1API] Failed to spawn pending NPC '" + ((Object)gameObject2).name + "': " + ex3.Message);
					Logger.Warning("[NPCNetworkBootstrap] Spawn exception stack: " + ex3.StackTrace);
					continue;
				}
				try
				{
					owner?.FinalizeNetworkSpawn();
				}
				catch (Exception ex4)
				{
					Logger.Warning("[NPCNetworkBootstrap] FinalizeNetworkSpawn threw for '" + text + "': " + ex4.Message);
				}
				PendingSpawns.RemoveAt(num);
			}
		}

		private static void LogReadinessState(bool inMain, bool serverUp, bool clientUpIfHost, bool remoteConnectionsReady, bool hasRemoteClients)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!readinessLogInitialized || lastLogInMain != inMain || lastLogServerUp != serverUp || lastLogClientUp != clientUpIfHost || lastLogRemoteReady != remoteConnectionsReady || lastLogHasRemote != hasRemoteClients || lastLogClientsReady != clientsReady || (!clientsReady && realtimeSinceStartup - lastStateLogTime >= 5f))
			{
				readinessLogInitialized = true;
				lastLogInMain = inMain;
				lastLogServerUp = serverUp;
				lastLogClientUp = clientUpIfHost;
				lastLogRemoteReady = remoteConnectionsReady;
				lastLogHasRemote = hasRemoteClients;
				lastLogClientsReady = clientsReady;
				lastStateLogTime = realtimeSinceStartup;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	internal sealed class NPCPrefabIdentity : MonoBehaviour
	{
		private struct IdentityData
		{
			internal string? Id;

			internal string? FirstName;

			internal string? LastName;

			internal Sprite? Icon;

			internal AvatarSettingsData? AppearanceDefaults;

			internal AvatarImpostorSelection? AppearanceImpostorSelection;

			internal string? DealerHomeBuildingName;

			internal float? RelationDelta;

			internal bool? Unlocked;

			internal int? UnlockType;

			internal List<string>? ConnectionIDs;

			internal string? PrefabName;

			internal string? VoiceId;

			internal bool HasVoicePitch;

			internal float VoicePitch;
		}

		private sealed class AvatarSettingsData
		{
			internal float Gender;

			internal float Height;

			internal float Weight;

			internal Color32 SkinColor;

			internal Color EyeBallTint;

			internal float PupilDilation;

			internal float EyebrowScale;

			internal float EyebrowThickness;

			internal float EyebrowRestingHeight;

			internal float EyebrowRestingAngle;

			internal string? HairPath;

			internal Color HairColor;

			internal Texture2D? ImpostorTexture;

			internal AvatarImpostorSelection? ImpostorSelection;

			internal Color LeftEyeLidColor;

			internal Color RightEyeLidColor;

			internal string? EyeballMaterialIdentifier;

			internal EyeStateData LeftEye = new EyeStateData();

			internal EyeStateData RightEye = new EyeStateData();

			internal List<LayerSettingData> FaceLayers = new List<LayerSettingData>();

			internal List<LayerSettingData> BodyLayers = new List<LayerSettingData>();

			internal List<AccessorySettingData> Accessories = new List<AccessorySettingData>();
		}

		private sealed class EyeStateData
		{
			internal float TopLidOpen;

			internal float BottomLidOpen;
		}

		private sealed class LayerSettingData
		{
			internal string? Path;

			internal Color Color;
		}

		private sealed class AccessorySettingData
		{
			internal string? Path;

			internal Color Color;
		}

		private static readonly Log Logger = new Log("NPCPrefabIdentity");

		private string? _id;

		private string? _firstName;

		private string? _lastName;

		private Sprite? _icon;

		private AvatarSettings? _appearanceDefaults;

		private AvatarImpostorSelection? _appearanceImpostorSelection;

		private string? _dealerHomeBuildingName;

		private string? _prefabName;

		private List<string>? _connectionIds;

		private string? _voiceId;

		private bool _hasVoicePitch;

		private float _voicePitch;

		private float? _relationDelta;

		private bool? _unlocked;

		private NPCRelationship.UnlockType? _unlockType;

		private static readonly Dictionary<string, IdentityData> _registry = new Dictionary<string, IdentityData>();

		private bool _applied;

		private AvatarSettingsData? _cachedAppearanceDefaults;

		internal string? Id
		{
			get
			{
				return _id;
			}
			set
			{
				_id = value;
			}
		}

		internal string? FirstName
		{
			get
			{
				return _firstName;
			}
			set
			{
				_firstName = value;
			}
		}

		internal string? LastName
		{
			get
			{
				return _lastName;
			}
			set
			{
				_lastName = value;
			}
		}

		internal Sprite? Icon
		{
			get
			{
				return _icon;
			}
			set
			{
				_icon = value;
			}
		}

		internal AvatarSettings? AppearanceDefaults
		{
			get
			{
				return _appearanceDefaults;
			}
			set
			{
				_appearanceDefaults = value;
			}
		}

		internal AvatarImpostorSelection? AppearanceImpostorSelection
		{
			[HideFromIl2Cpp]
			get
			{
				return _appearanceImpostorSelection;
			}
			[HideFromIl2Cpp]
			set
			{
				_appearanceImpostorSelection = value;
			}
		}

		internal string? DealerHomeBuildingName
		{
			get
			{
				return _dealerHomeBuildingName;
			}
			set
			{
				_dealerHomeBuildingName = value;
			}
		}

		internal string? PrefabName
		{
			get
			{
				return _prefabName;
			}
			set
			{
				_prefabName = value;
			}
		}

		internal string? VoiceId
		{
			get
			{
				return _voiceId;
			}
			set
			{
				_voiceId = value;
			}
		}

		internal float? VoicePitch
		{
			get
			{
				return _hasVoicePitch ? new float?(_voicePitch) : ((float?)null);
			}
			set
			{
				_hasVoicePitch = value.HasValue;
				_voicePitch = value.GetValueOrDefault();
			}
		}

		private float? RelationDelta
		{
			get
			{
				return _relationDelta;
			}
			set
			{
				_relationDelta = value;
			}
		}

		private bool? Unlocked
		{
			get
			{
				return _unlocked;
			}
			set
			{
				_unlocked = value;
			}
		}

		private NPCRelationship.UnlockType? UnlockType
		{
			get
			{
				return _unlockType;
			}
			set
			{
				_unlockType = value;
			}
		}

		private void Awake()
		{
			TryRestoreFromRegistry();
		}

		private void Start()
		{
			TryRestoreFromRegistry();
			TryApplyNow();
			if (!_applied)
			{
				MelonCoroutines.Start(DelayedApply());
			}
		}

		[HideFromIl2Cpp]
		internal static void RegisterRelationshipDataToStaticCache(string prefabName, NPCRelationshipDataBuilder builder)
		{
			if (string.IsNullOrEmpty(prefabName) || builder == null)
			{
				return;
			}
			try
			{
				string text = prefabName;
				if (text.EndsWith("(Clone)"))
				{
					text = text.Substring(0, text.Length - 7);
				}
				NPCRelationshipDataBuilder.RelationshipDefaultsData relationshipDefaultsData = builder.CaptureData();
				float? relationDelta = relationshipDefaultsData?.RelationDelta;
				bool? unlocked = relationshipDefaultsData?.Unlocked;
				NPCRelationship.UnlockType? unlockType = relationshipDefaultsData?.UnlockType;
				List<string> list = ((relationshipDefaultsData?.ConnectionIDs != null && relationshipDefaultsData.ConnectionIDs.Count > 0) ? new List<string>(relationshipDefaultsData.ConnectionIDs) : null);
				if (!_registry.TryGetValue(text, out var value))
				{
					value = default(IdentityData);
				}
				IdentityData value2 = value;
				if (relationDelta.HasValue)
				{
					value2.RelationDelta = relationDelta;
				}
				if (unlocked.HasValue)
				{
					value2.Unlocked = unlocked;
				}
				if (unlockType.HasValue)
				{
					value2.UnlockType = (int)unlockType.Value;
				}
				if (list != null && list.Count > 0)
				{
					value2.ConnectionIDs = new List<string>(list);
				}
				_registry[text] = value2;
			}
			catch (Exception ex)
			{
				Logger.Error("[Relationship Data] RegisterRelationshipDataToStaticCache: Exception storing relationship data for prefab '" + prefabName + "': " + ex.Message);
			}
		}

		[HideFromIl2Cpp]
		internal void RegisterToStaticCache(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return;
			}
			string text = prefabName;
			if (text.EndsWith("(Clone)"))
			{
				text = text.Substring(0, text.Length - 7);
			}
			if (((Object)((Component)this).gameObject).name.EndsWith("(Clone)") || !text.StartsWith("S1API_", StringComparison.OrdinalIgnoreCase))
			{
				return;
			}
			AvatarSettingsData avatarSettingsData = CaptureAvatarSettings(AppearanceDefaults);
			if (avatarSettingsData != null)
			{
				avatarSettingsData.ImpostorSelection = AppearanceImpostorSelection;
			}
			_cachedAppearanceDefaults = CloneAvatarSettingsData(avatarSettingsData);
			float? relationDelta = RelationDelta;
			bool? unlocked = Unlocked;
			int? unlockType = (UnlockType.HasValue ? new int?((int)UnlockType.Value) : ((int?)null));
			PrefabName = text;
			List<string> list = null;
			string dealerHomeBuildingName = DealerHomeBuildingName;
			if (_registry.TryGetValue(text, out var value))
			{
				if (!relationDelta.HasValue && value.RelationDelta.HasValue)
				{
					relationDelta = value.RelationDelta;
				}
				if (!unlocked.HasValue && value.Unlocked.HasValue)
				{
					unlocked = value.Unlocked;
				}
				if (!unlockType.HasValue && value.UnlockType.HasValue)
				{
					unlockType = value.UnlockType;
				}
				if (string.IsNullOrEmpty(dealerHomeBuildingName) && !string.IsNullOrEmpty(value.DealerHomeBuildingName))
				{
					dealerHomeBuildingName = value.DealerHomeBuildingName;
				}
				if (value.ConnectionIDs != null && value.ConnectionIDs.Count > 0)
				{
					list = new List<string>(value.ConnectionIDs);
				}
			}
			if ((list == null || list.Count == 0) && _connectionIds != null && _connectionIds.Count > 0)
			{
				list = new List<string>(_connectionIds);
			}
			IdentityData value2 = new IdentityData
			{
				Id = Id,
				FirstName = FirstName,
				LastName = LastName,
				Icon = Icon,
				AppearanceDefaults = CloneAvatarSettingsData(avatarSettingsData),
				AppearanceImpostorSelection = AppearanceImpostorSelection,
				DealerHomeBuildingName = dealerHomeBuildingName,
				RelationDelta = relationDelta,
				Unlocked = unlocked,
				UnlockType = unlockType,
				ConnectionIDs = list,
				PrefabName = text,
				VoiceId = VoiceId,
				HasVoicePitch = VoicePitch.HasValue,
				VoicePitch = VoicePitch.GetValueOrDefault()
			};
			_registry[text] = value2;
			if (value2.AppearanceDefaults != null)
			{
				AppearanceDefaults = CreateAvatarSettings(value2.AppearanceDefaults);
			}
		}

		private void TryRestoreFromRegistry()
		{
			string text = ((Object)((Component)this).gameObject).name;
			if (text.EndsWith("(Clone)"))
			{
				text = text.Substring(0, text.Length - 7);
			}
			if (!string.IsNullOrEmpty(PrefabName))
			{
				text = PrefabName;
			}
			IdentityData? identityData = null;
			if (_registry.TryGetValue(text, out var value))
			{
				identityData = value;
			}
			else
			{
				foreach (KeyValuePair<string, IdentityData> item in _registry)
				{
					IdentityData value2 = item.Value;
					if (!string.IsNullOrEmpty(value2.PrefabName) && string.Equals(value2.PrefabName, text, StringComparison.OrdinalIgnoreCase))
					{
						identityData = value2;
						PrefabName = value2.PrefabName;
						break;
					}
				}
				if (!identityData.HasValue)
				{
					try
					{
						NPC component = ((Component)this).GetComponent<NPC>();
						string text2 = (((Object)(object)component != (Object)null) ? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(component, "ID") as string) : null);
						if (!string.IsNullOrEmpty(text2))
						{
							foreach (KeyValuePair<string, IdentityData> item2 in _registry)
							{
								IdentityData value3 = item2.Value;
								if (!string.IsNullOrEmpty(value3.Id) && string.Equals(value3.Id, text2, StringComparison.OrdinalIgnoreCase))
								{
									identityData = value3;
									PrefabName = value3.PrefabName ?? item2.Key;
									break;
								}
							}
						}
					}
					catch (Exception ex)
					{
						Logger.Warning("[NPCPrefabIdentity] Exception during ID-based registry lookup: " + ex.Message);
					}
				}
				if (!identityData.HasValue && text.StartsWith("S1API_", StringComparison.OrdinalIgnoreCase) && _registry.TryGetValue(text, out var value4))
				{
					identityData = value4;
					PrefabName = text;
				}
			}
			if (!identityData.HasValue)
			{
				return;
			}
			IdentityData value5 = identityData.Value;
			if (string.IsNullOrEmpty(Id) && !string.IsNullOrEmpty(value5.Id))
			{
				Id = value5.Id;
			}
			if (string.IsNullOrEmpty(FirstName) && !string.IsNullOrEmpty(value5.FirstName))
			{
				FirstName = value5.FirstName;
			}
			if (string.IsNullOrEmpty(LastName) && !string.IsNullOrEmpty(value5.LastName))
			{
				LastName = value5.LastName;
			}
			if ((Object)(object)Icon == (Object)null && (Object)(object)value5.Icon != (Object)null)
			{
				Icon = value5.Icon;
			}
			if (string.IsNullOrEmpty(DealerHomeBuildingName) && !string.IsNullOrEmpty(value5.DealerHomeBuildingName))
			{
				DealerHomeBuildingName = value5.DealerHomeBuildingName;
			}
			RelationDelta = value5.RelationDelta;
			Unlocked = value5.Unlocked;
			UnlockType = (value5.UnlockType.HasValue ? new NPCRelationship.UnlockType?((NPCRelationship.UnlockType)value5.UnlockType.Value) : ((NPCRelationship.UnlockType?)null));
			_connectionIds = ((value5.ConnectionIDs != null) ? new List<string>(value5.ConnectionIDs) : null);
			PrefabName = value5.PrefabName ?? PrefabName;
			if (string.IsNullOrEmpty(VoiceId) && !string.IsNullOrEmpty(value5.VoiceId))
			{
				VoiceId = value5.VoiceId;
			}
			if (!VoicePitch.HasValue && value5.HasVoicePitch)
			{
				VoicePitch = value5.VoicePitch;
			}
			if (AppearanceImpostorSelection == null)
			{
				AppearanceImpostorSelection = value5.AppearanceImpostorSelection ?? value5.AppearanceDefaults?.ImpostorSelection;
			}
			if ((Object)(object)AppearanceDefaults == (Object)null)
			{
				_cachedAppearanceDefaults = CloneAvatarSettingsData(value5.AppearanceDefaults);
				if (_cachedAppearanceDefaults != null)
				{
					AppearanceDefaults = CreateAvatarSettings(_cachedAppearanceDefaults);
				}
				else
				{
					AppearanceDefaults = null;
				}
			}
		}

		[HideFromIl2Cpp]
		private IEnumerator DelayedApply()
		{
			float start = Time.realtimeSinceStartup;
			float timeout = 3f;
			while (!_applied && Time.realtimeSinceStartup - start < timeout)
			{
				TryApplyNow();
				if (_applied)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.05f);
			}
		}

		[HideFromIl2Cpp]
		private void EnsureRelationshipDataFromRegistry()
		{
			if (_connectionIds == null || _connectionIds.Count == 0 || !Unlocked.HasValue || !RelationDelta.HasValue || !UnlockType.HasValue)
			{
				TryRestoreFromRegistry();
			}
		}

		[HideFromIl2Cpp]
		private void EnsureDealerHomeBuildingNameFromRegistry()
		{
			if (!string.IsNullOrEmpty(DealerHomeBuildingName))
			{
				return;
			}
			string text = ((Object)((Component)this).gameObject).name;
			if (text.EndsWith("(Clone)"))
			{
				text = text.Substring(0, text.Length - 7);
			}
			if (!string.IsNullOrEmpty(PrefabName))
			{
				text = PrefabName;
			}
			IdentityData? identityData = null;
			if (_registry.TryGetValue(text, out var value))
			{
				identityData = value;
			}
			else
			{
				foreach (KeyValuePair<string, IdentityData> item in _registry)
				{
					IdentityData value2 = item.Value;
					if (!string.IsNullOrEmpty(value2.PrefabName) && string.Equals(value2.PrefabName, text, StringComparison.OrdinalIgnoreCase))
					{
						identityData = value2;
						PrefabName = value2.PrefabName;
						break;
					}
				}
				if (!identityData.HasValue)
				{
					try
					{
						NPC component = ((Component)this).GetComponent<NPC>();
						if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.ID))
						{
							foreach (KeyValuePair<string, IdentityData> item2 in _registry)
							{
								IdentityData value3 = item2.Value;
								if (!string.IsNullOrEmpty(value3.Id) && string.Equals(value3.Id, component.ID, StringComparison.OrdinalIgnoreCase))
								{
									identityData = value3;
									PrefabName = value3.PrefabName ?? item2.Key;
									break;
								}
							}
						}
					}
					catch
					{
					}
				}
			}
			if (identityData.HasValue && !string.IsNullOrEmpty(identityData.Value.DealerHomeBuildingName))
			{
				DealerHomeBuildingName = identityData.Value.DealerHomeBuildingName;
			}
		}

		internal void ApplyRelationshipDataTo(NPC npc, bool preserveUnlockState = false)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return;
			}
			EnsureRelationshipDataFromRegistry();
			NPCRelationData relationData = npc.RelationData;
			if (relationData == null)
			{
				return;
			}
			try
			{
				NPCRelationshipDataBuilder nPCRelationshipDataBuilder = new NPCRelationshipDataBuilder();
				if (RelationDelta.HasValue)
				{
					nPCRelationshipDataBuilder.WithDelta(RelationDelta.Value);
				}
				if (Unlocked.HasValue)
				{
					nPCRelationshipDataBuilder.SetUnlocked(Unlocked.Value);
				}
				if (UnlockType.HasValue)
				{
					nPCRelationshipDataBuilder.SetUnlockType(UnlockType.Value);
				}
				if (_connectionIds != null && _connectionIds.Count > 0)
				{
					nPCRelationshipDataBuilder.WithConnectionsById(_connectionIds);
				}
				nPCRelationshipDataBuilder.ApplyTo(relationData, npc, preserveUnlockState);
			}
			catch (Exception ex)
			{
				Logger.Error("[Relationship Data] ApplyRelationshipDataTo: Exception applying relationship data to NPC '" + (((npc != null) ? npc.ID : null) ?? "<null>") + "': " + ex.Message);
			}
		}

		internal void ApplyTo(NPC npc)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return;
			}
			if (string.IsNullOrEmpty(Id) && string.IsNullOrEmpty(FirstName))
			{
				TryRestoreFromRegistry();
			}
			EnsureRelationshipDataFromRegistry();
			EnsureDealerHomeBuildingNameFromRegistry();
			NPCDataAccess.ApplyIdentity(npc, Id, FirstName, LastName);
			if ((Object)(object)Icon != (Object)null)
			{
				NPCDataAccess.ApplyIcon(npc, Icon);
			}
			ApplyConfiguredVoice(npc, updateEmitter: true);
			try
			{
				Avatar val = npc.Avatar ?? ((Component)npc).GetComponentInChildren<Avatar>(true);
				if ((Object)(object)val != (Object)null && (Object)(object)AppearanceDefaults != (Object)null)
				{
					EnsureAppearanceImpostorTexture(npc.ID ?? PrefabName ?? ((Object)((Component)this).gameObject).name);
					val.LoadAvatarSettings(AppearanceDefaults);
				}
			}
			catch
			{
			}
			try
			{
				string text = DealerHomeBuildingName;
				if (string.IsNullOrEmpty(text))
				{
					string text2 = ((Object)((Component)this).gameObject).name;
					if (text2.EndsWith("(Clone)"))
					{
						text2 = text2.Substring(0, text2.Length - 7);
					}
					if (!string.IsNullOrEmpty(PrefabName))
					{
						text2 = PrefabName;
					}
					IdentityData? identityData = null;
					if (_registry.TryGetValue(text2, out var value))
					{
						identityData = value;
					}
					else
					{
						try
						{
							if ((Object)(object)npc != (Object)null && !string.IsNullOrEmpty(npc.ID))
							{
								foreach (KeyValuePair<string, IdentityData> item in _registry)
								{
									IdentityData value2 = item.Value;
									if (!string.IsNullOrEmpty(value2.Id) && string.Equals(value2.Id, npc.ID, StringComparison.OrdinalIgnoreCase))
									{
										identityData = value2;
										PrefabName = value2.PrefabName ?? item.Key;
										break;
									}
								}
							}
						}
						catch
						{
						}
					}
					if (identityData.HasValue && !string.IsNullOrEmpty(identityData.Value.DealerHomeBuildingName))
					{
						text = (DealerHomeBuildingName = identityData.Value.DealerHomeBuildingName);
					}
				}
				if (!string.IsNullOrEmpty(text))
				{
					ApplyDealerHomeBuilding(npc, text);
				}
			}
			catch
			{
			}
		}

		internal void ApplyCriticalIdentityBeforeAwake(NPC npc)
		{
			if ((Object)(object)npc == (Object)null)
			{
				return;
			}
			if (string.IsNullOrEmpty(Id) && string.IsNullOrEmpty(FirstName))
			{
				TryRestoreFromRegistry();
			}
			try
			{
				if (!string.IsNullOrEmpty(FirstName))
				{
					TrySetNpcMember(npc, "FirstName", FirstName);
				}
			}
			catch
			{
			}
			try
			{
				if (!string.IsNullOrEmpty(LastName))
				{
					TrySetNpcMember(npc, "LastName", LastName);
				}
			}
			catch
			{
			}
			try
			{
				if (!string.IsNullOrEmpty(Id))
				{
					TrySetNpcMember(npc, "ID", Id);
				}
			}
			catch
			{
			}
			EnsureFrameworkNpcDataIdentity(npc);
			ApplyConfiguredVoice(npc, updateEmitter: false);
		}

		[HideFromIl2Cpp]
		private void ApplyDealerHomeBuilding(NPC npc, string? buildingName = null)
		{
			if (string.IsNullOrEmpty(buildingName))
			{
				buildingName = DealerHomeBuildingName;
			}
			if (DeferredMapResolver.IsMenuScene())
			{
				return;
			}
			try
			{
				if (string.IsNullOrEmpty(buildingName))
				{
					Logger.Warning("[Dealer Home] Building name is empty for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>"));
					return;
				}
				Dealer component = ((Component)npc).GetComponent<Dealer>();
				if ((Object)(object)component == (Object)null)
				{
					Logger.Warning("[Dealer Home] Dealer component not found for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>"));
					return;
				}
				global::S1API.Map.Building byName = global::S1API.Map.Building.GetByName(buildingName);
				if (byName == null)
				{
					Logger.Warning("[Dealer Home] Building '" + buildingName + "' not found in registry for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>"));
					return;
				}
				object obj = byName.ResolveGameBuilding();
				if (obj == null)
				{
					Logger.Warning("[Dealer Home] Building '" + buildingName + "' wrapper found but game building is null for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>"));
					return;
				}
				if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(component, "Home", obj))
				{
					Logger.Warning("[Dealer Home] Failed to set Home property on Dealer component for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>"));
					return;
				}
				try
				{
					object obj2 = typeof(Dealer).GetProperty("HomeEvent", BindingFlags.Instance | BindingFlags.Public)?.GetValue(component);
					if (obj2 != null)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(obj2, "Building", obj);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("[Dealer Home] Failed to sync HomeEvent.Building for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>") + ": " + ex.Message);
				}
			}
			catch (Exception ex2)
			{
				Logger.Error("[Dealer Home] Exception applying dealer home building for NPC " + (((npc != null) ? npc.ID : null) ?? "<null>") + ": " + ex2.Message);
				Logger.Error("[Dealer Home] Stack trace: " + ex2.StackTrace);
			}
		}

		private void TryApplyNow()
		{
			try
			{
				NPC component = ((Component)this).GetComponent<NPC>();
				if (!((Object)(object)component == (Object)null))
				{
					EnsureAppearanceDefaults();
					ApplyTo(component);
					Avatar val = component.Avatar ?? ((Component)component).GetComponentInChildren<Avatar>(true);
					_applied = (Object)(object)AppearanceDefaults == (Object)null || (Object)(object)val != (Object)null;
				}
			}
			catch
			{
			}
		}

		private void EnsureAppearanceDefaults()
		{
			if ((Object)(object)AppearanceDefaults != (Object)null)
			{
				return;
			}
			IdentityData data;
			if (_cachedAppearanceDefaults != null)
			{
				AppearanceDefaults = CreateAvatarSettings(_cachedAppearanceDefaults);
				EnsureAppearanceImpostorTexture(PrefabName ?? ((Object)((Component)this).gameObject).name);
			}
			else if (TryGetRegistryData(out data) && data.AppearanceDefaults != null)
			{
				_cachedAppearanceDefaults = CloneAvatarSettingsData(data.AppearanceDefaults);
				if (AppearanceImpostorSelection == null)
				{
					AppearanceImpostorSelection = data.AppearanceImpostorSelection ?? data.AppearanceDefaults?.ImpostorSelection;
				}
				AppearanceDefaults = CreateAvatarSettings(_cachedAppearanceDefaults);
				EnsureAppearanceImpostorTexture(PrefabName ?? ((Object)((Component)this).gameObject).name);
			}
		}

		private static bool TrySetNpcMember(NPC npc, string memberName, object value)
		{
			return global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(npc, memberName, value) || global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(npc, "_" + memberName + "_k__BackingField", value) || global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(npc, "<" + memberName + ">k__BackingField", value);
		}

		private void EnsureFrameworkNpcDataIdentity(NPC npc)
		{
			if ((Object)(object)npc == (Object)null || (string.IsNullOrWhiteSpace(Id) && string.IsNullOrWhiteSpace(FirstName)))
			{
				return;
			}
			try
			{
				NPCDataAccess.ApplyIdentity(npc, Id, FirstName, LastName);
				NPCDataAccess.ApplyIcon(npc, Icon);
				NPCDataAccess.ApplyAppearance(npc, AppearanceDefaults);
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPCPrefabIdentity] Failed to initialize framework NPCData identity before Awake for '" + (Id ?? FirstName ?? "<unknown>") + "': " + ex.Message);
			}
		}

		private void ApplyConfiguredVoice(NPC npc, bool updateEmitter)
		{
			if ((Object)(object)npc == (Object)null || string.IsNullOrWhiteSpace(VoiceId))
			{
				return;
			}
			NPCVoiceDefinition nPCVoiceDefinition = NPCVoiceCatalog.Get(VoiceId);
			VODatabase val = NPCVoiceResolver.Resolve(nPCVoiceDefinition);
			if (!NPCDataAccess.ApplyVoice(npc, val, VoicePitch))
			{
				throw new InvalidOperationException("Could not apply S1API voice '" + nPCVoiceDefinition.Id + "' because the custom NPC has no framework data.");
			}
			if (updateEmitter && !((Object)(object)npc.VoiceOverEmitter == (Object)null))
			{
				npc.VoiceOverEmitter.SetDatabase(val, true);
				if (VoicePitch.HasValue)
				{
					npc.VoiceOverEmitter.SetDefaultPitch(VoicePitch.Value);
				}
			}
		}

		internal void ApplyRelationshipConnectionsTo(NPC npc)
		{
			if (((npc != null) ? npc.RelationData : null) == null)
			{
				return;
			}
			EnsureRelationshipDataFromRegistry();
			if (_connectionIds == null || _connectionIds.Count == 0)
			{
				return;
			}
			try
			{
				NPCRelationshipDataBuilder nPCRelationshipDataBuilder = new NPCRelationshipDataBuilder();
				nPCRelationshipDataBuilder.WithConnectionsById(_connectionIds);
				nPCRelationshipDataBuilder.ApplyTo(npc.RelationData, npc, preserveUnlockState: true);
			}
			catch (Exception ex)
			{
				Logger.Error("[Relationship Data] ApplyRelationshipConnectionsTo: Exception applying connections to NPC '" + (npc.ID ?? "<null>") + "': " + ex.Message);
			}
		}

		internal bool ApplyAppearanceTo(NPC npc, Avatar avatar)
		{
			if ((Object)(object)npc == (Object)null || (Object)(object)avatar == (Object)null)
			{
				return false;
			}
			TryRestoreFromRegistry();
			EnsureAppearanceDefaults();
			if ((Object)(object)AppearanceDefaults == (Object)null)
			{
				return false;
			}
			EnsureAppearanceImpostorTexture(npc.ID ?? PrefabName ?? ((Object)((Component)this).gameObject).name);
			NPCDataAccess.ApplyAppearance(npc, AppearanceDefaults);
			avatar.LoadAvatarSettings(AppearanceDefaults);
			return true;
		}

		[HideFromIl2Cpp]
		private void EnsureAppearanceImpostorTexture(string deterministicKey)
		{
			if ((Object)(object)AppearanceDefaults == (Object)null || (Object)(object)AppearanceDefaults.ImpostorTexture != (Object)null)
			{
				return;
			}
			AvatarImpostorSelection avatarImpostorSelection = _cachedAppearanceDefaults?.ImpostorSelection ?? AppearanceImpostorSelection;
			if (avatarImpostorSelection != null && avatarImpostorSelection.Kind != AvatarImpostorSelectionKind.Preserve && ImpostorTextureResolver.TryResolve(avatarImpostorSelection, deterministicKey, out Texture2D texture) && (Object)(object)texture != (Object)null)
			{
				AppearanceDefaults.ImpostorTexture = texture;
				if (_cachedAppearanceDefaults != null)
				{
					_cachedAppearanceDefaults.ImpostorTexture = texture;
				}
			}
		}

		[HideFromIl2Cpp]
		private bool TryGetRegistryData(out IdentityData data)
		{
			string text = PrefabName;
			if (string.IsNullOrEmpty(text))
			{
				text = ((Object)((Component)this).gameObject).name;
			}
			if (string.IsNullOrEmpty(text))
			{
				data = default(IdentityData);
				return false;
			}
			if (text.EndsWith("(Clone)"))
			{
				text = text.Substring(0, text.Length - 7);
			}
			if (_registry.TryGetValue(text, out data))
			{
				return true;
			}
			try
			{
				NPC component = ((Component)this).GetComponent<NPC>();
				string text2 = (((Object)(object)component != (Object)null) ? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(component, "ID") as string) : null);
				if (!string.IsNullOrEmpty(text2))
				{
					foreach (KeyValuePair<string, IdentityData> item in _registry)
					{
						IdentityData value = item.Value;
						if (!string.IsNullOrEmpty(value.Id) && string.Equals(value.Id, text2, StringComparison.OrdinalIgnoreCase))
						{
							data = value;
							PrefabName = value.PrefabName ?? item.Key;
							return true;
						}
					}
				}
			}
			catch
			{
			}
			data = default(IdentityData);
			return false;
		}

		[HideFromIl2Cpp]
		internal static bool TryGetIdentityFromRegistry(string prefabName, out string? id, out string? firstName, out string? lastName, out Sprite? icon)
		{
			id = null;
			firstName = null;
			lastName = null;
			icon = null;
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (prefabName.EndsWith("(Clone)"))
			{
				prefabName = prefabName.Substring(0, prefabName.Length - 7);
			}
			if (_registry.TryGetValue(prefabName, out var value))
			{
				id = value.Id;
				firstName = value.FirstName;
				lastName = value.LastName;
				icon = value.Icon;
				return true;
			}
			return false;
		}

		[HideFromIl2Cpp]
		internal static bool TryGetRelationshipDataFromRegistry(string prefabName, out float? relationDelta, out bool? unlocked, out NPCRelationship.UnlockType? unlockType, out List<string>? connectionIDs)
		{
			relationDelta = null;
			unlocked = null;
			unlockType = null;
			connectionIDs = null;
			if (string.IsNullOrEmpty(prefabName))
			{
				return false;
			}
			if (prefabName.EndsWith("(Clone)"))
			{
				prefabName = prefabName.Substring(0, prefabName.Length - 7);
			}
			if (_registry.TryGetValue(prefabName, out var value))
			{
				relationDelta = value.RelationDelta;
				unlocked = value.Unlocked;
				unlockType = (value.UnlockType.HasValue ? new NPCRelationship.UnlockType?((NPCRelationship.UnlockType)value.UnlockType.Value) : ((NPCRelationship.UnlockType?)null));
				connectionIDs = ((value.ConnectionIDs != null) ? new List<string>(value.ConnectionIDs) : null);
				return true;
			}
			return false;
		}

		[HideFromIl2Cpp]
		private static AvatarSettingsData? CaptureAvatarSettings(AvatarSettings? settings)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)settings == (Object)null)
			{
				return null;
			}
			AvatarSettingsData avatarSettingsData = new AvatarSettingsData
			{
				Gender = settings.Gender,
				Height = settings.Height,
				Weight = settings.Weight,
				SkinColor = Color32.op_Implicit(settings.SkinColor),
				EyeBallTint = settings.EyeBallTint,
				LeftEyeLidColor = settings.LeftEyeLidColor,
				RightEyeLidColor = settings.RightEyeLidColor,
				EyeballMaterialIdentifier = settings.EyeballMaterialIdentifier,
				PupilDilation = settings.PupilDilation,
				EyebrowScale = settings.EyebrowScale,
				EyebrowThickness = settings.EyebrowThickness,
				EyebrowRestingHeight = settings.EyebrowRestingHeight,
				EyebrowRestingAngle = settings.EyebrowRestingAngle,
				HairPath = settings.HairPath,
				HairColor = settings.HairColor,
				ImpostorTexture = settings.ImpostorTexture,
				LeftEye = new EyeStateData
				{
					TopLidOpen = settings.LeftEyeRestingState.topLidOpen,
					BottomLidOpen = settings.LeftEyeRestingState.bottomLidOpen
				},
				RightEye = new EyeStateData
				{
					TopLidOpen = settings.RightEyeRestingState.topLidOpen,
					BottomLidOpen = settings.RightEyeRestingState.bottomLidOpen
				}
			};
			if (settings.FaceLayerSettings != null)
			{
				for (int i = 0; i < settings.FaceLayerSettings.Count; i++)
				{
					LayerSetting val = settings.FaceLayerSettings[i];
					avatarSettingsData.FaceLayers.Add(new LayerSettingData
					{
						Path = val.layerPath,
						Color = val.layerTint
					});
				}
			}
			if (settings.BodyLayerSettings != null)
			{
				for (int j = 0; j < settings.BodyLayerSettings.Count; j++)
				{
					LayerSetting val2 = settings.BodyLayerSettings[j];
					avatarSettingsData.BodyLayers.Add(new LayerSettingData
					{
						Path = val2.layerPath,
						Color = val2.layerTint
					});
				}
			}
			if (settings.AccessorySettings != null)
			{
				for (int k = 0; k < settings.AccessorySettings.Count; k++)
				{
					AccessorySetting val3 = settings.AccessorySettings[k];
					avatarSettingsData.Accessories.Add(new AccessorySettingData
					{
						Path = val3.path,
						Color = val3.color
					});
				}
			}
			return avatarSettingsData;
		}

		[HideFromIl2Cpp]
		private static AvatarSettingsData? CloneAvatarSettingsData(AvatarSettingsData? source)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				return null;
			}
			AvatarSettingsData avatarSettingsData = new AvatarSettingsData
			{
				Gender = source.Gender,
				Height = source.Height,
				Weight = source.Weight,
				SkinColor = source.SkinColor,
				EyeBallTint = source.EyeBallTint,
				PupilDilation = source.PupilDilation,
				EyebrowScale = source.EyebrowScale,
				EyebrowThickness = source.EyebrowThickness,
				EyebrowRestingHeight = source.EyebrowRestingHeight,
				EyebrowRestingAngle = source.EyebrowRestingAngle,
				HairPath = source.HairPath,
				HairColor = source.HairColor,
				ImpostorTexture = source.ImpostorTexture,
				ImpostorSelection = source.ImpostorSelection,
				LeftEyeLidColor = source.LeftEyeLidColor,
				RightEyeLidColor = source.RightEyeLidColor,
				EyeballMaterialIdentifier = source.EyeballMaterialIdentifier,
				LeftEye = new EyeStateData
				{
					TopLidOpen = source.LeftEye.TopLidOpen,
					BottomLidOpen = source.LeftEye.BottomLidOpen
				},
				RightEye = new EyeStateData
				{
					TopLidOpen = source.RightEye.TopLidOpen,
					BottomLidOpen = source.RightEye.BottomLidOpen
				}
			};
			for (int i = 0; i < source.FaceLayers.Count; i++)
			{
				LayerSettingData layerSettingData = source.FaceLayers[i];
				avatarSettingsData.FaceLayers.Add(new LayerSettingData
				{
					Path = layerSettingData.Path,
					Color = layerSettingData.Color
				});
			}
			for (int j = 0; j < source.BodyLayers.Count; j++)
			{
				LayerSettingData layerSettingData2 = source.BodyLayers[j];
				avatarSettingsData.BodyLayers.Add(new LayerSettingData
				{
					Path = layerSettingData2.Path,
					Color = layerSettingData2.Color
				});
			}
			for (int k = 0; k < source.Accessories.Count; k++)
			{
				AccessorySettingData accessorySettingData = source.Accessories[k];
				avatarSettingsData.Accessories.Add(new AccessorySettingData
				{
					Path = accessorySettingData.Path,
					Color = accessorySettingData.Color
				});
			}
			return avatarSettingsData;
		}

		[HideFromIl2Cpp]
		private static AvatarSettings? CreateAvatarSettings(AvatarSettingsData? data)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			if (data == null)
			{
				return null;
			}
			AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
			((Object)val).hideFlags = (HideFlags)32;
			val.Gender = data.Gender;
			val.Height = data.Height;
			val.Weight = data.Weight;
			val.SkinColor = Color32.op_Implicit(data.SkinColor);
			val.LeftEyeLidColor = data.LeftEyeLidColor;
			val.RightEyeLidColor = data.RightEyeLidColor;
			val.EyeBallTint = data.EyeBallTint;
			val.EyeballMaterialIdentifier = data.EyeballMaterialIdentifier;
			val.PupilDilation = data.PupilDilation;
			val.EyebrowScale = data.EyebrowScale;
			val.EyebrowThickness = data.EyebrowThickness;
			val.EyebrowRestingHeight = data.EyebrowRestingHeight;
			val.EyebrowRestingAngle = data.EyebrowRestingAngle;
			val.HairPath = data.HairPath ?? string.Empty;
			val.HairColor = data.HairColor;
			val.ImpostorTexture = data.ImpostorTexture;
			val.UseCombinedLayer = false;
			val.CombinedLayer = null;
			val.LeftEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = data.LeftEye.TopLidOpen,
				bottomLidOpen = data.LeftEye.BottomLidOpen
			};
			val.RightEyeRestingState = new EyeLidConfiguration
			{
				topLidOpen = data.RightEye.TopLidOpen,
				bottomLidOpen = data.RightEye.BottomLidOpen
			};
			List<LayerSetting> list = new List<LayerSetting>();
			for (int i = 0; i < data.FaceLayers.Count; i++)
			{
				LayerSettingData layerSettingData = data.FaceLayers[i];
				list.Add(new LayerSetting
				{
					layerPath = layerSettingData.Path,
					layerTint = layerSettingData.Color
				});
			}
			List<LayerSetting> list2 = new List<LayerSetting>();
			for (int j = 0; j < data.BodyLayers.Count; j++)
			{
				LayerSettingData layerSettingData2 = data.BodyLayers[j];
				list2.Add(new LayerSetting
				{
					layerPath = layerSettingData2.Path,
					layerTint = layerSettingData2.Color
				});
			}
			List<AccessorySetting> list3 = new List<AccessorySetting>();
			for (int k = 0; k < data.Accessories.Count; k++)
			{
				AccessorySettingData accessorySettingData = data.Accessories[k];
				list3.Add(new AccessorySetting
				{
					path = accessorySettingData.Path,
					color = accessorySettingData.Color
				});
			}
			val.FaceLayerSettings = ToIl2CppList(list);
			val.BodyLayerSettings = ToIl2CppList(list2);
			val.AccessorySettings = ToIl2CppList(list3);
			return val;
		}

		[HideFromIl2Cpp]
		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
	internal enum NpcRootRole
	{
		Plain,
		Dealer,
		Supplier
	}
	internal static class NPCVoiceResolver
	{
		internal static VODatabase Resolve(NPCVoiceDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			VODatabase val = null;
			foreach (VODatabase item in Resources.FindObjectsOfTypeAll<VODatabase>())
			{
				if (!((Object)(object)item == (Object)null) && string.Equals(((Object)item).name, definition.DatabaseName, StringComparison.OrdinalIgnoreCase))
				{
					if ((Object)(object)val != (Object)null && ((Object)val).GetInstanceID() != ((Object)item).GetInstanceID())
					{
						throw new InvalidOperationException($"Multiple loaded voice databases match S1API voice '{definition.Id}' ({definition.DatabaseName}).");
					}
					val = item;
				}
			}
			return val ?? throw new InvalidOperationException($"The voice database for S1API voice '{definition.Id}' ({definition.DatabaseName}) is not loaded.");
		}
	}
	internal static class SupplierRuntimeCoordinator
	{
		private static readonly Log Logger = new Log("SupplierRuntimeCoordinator");

		internal static bool DeliveryPrefabsReadyForLocalProcess => SupplierDeliveryVehicleRuntime.PrefabsReadyForLocalProcess;

		internal static void EnsurePrefabInfrastructure(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				throw new ArgumentNullException("prefabRoot");
			}
			SupplierMeetingRuntime.EnsurePrefab(prefabRoot);
			SupplierStashRuntime.EnsurePrefab(prefabRoot);
		}

		internal static bool FinalizePrefabInfrastructure(GameObject prefabRoot, string? explicitId = null)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return false;
			}
			string text = SupplierRuntimeIds.ResolveStableId(prefabRoot, explicitId);
			SupplierStashRuntime.FinalizePrefab(prefabRoot, text);
			return SupplierDeliveryVehicleRuntime.RegisterSupplier(prefabRoot, text);
		}

		internal static bool EnsureAllDeliveryPrefabsRegistered()
		{
			return SupplierDeliveryVehicleRuntime.EnsureAllPrefabsRegistered();
		}

		internal static void BindPrefabInfrastructure(Supplier supplier)
		{
			if ((Object)(object)supplier == (Object)null)
			{
				throw new ArgumentNullException("supplier");
			}
			SupplierStashRuntime.BindPrefab(supplier);
			SupplierShopRuntime.ClearDonorReference(supplier);
		}

		internal static bool EnsureReady(Supplier supplier, string supplierId, SupplierDataBuilder.SupplierConfigData? config)
		{
			if ((Object)(object)supplier == (Object)null)
			{
				return false;
			}
			try
			{
				string stableId = SupplierRuntimeIds.ResolveStableId(((Component)supplier).gameObject, config?.PersistentId ?? supplierId);
				SupplierStashRuntime.Bind(supplier, stableId, config?.StashDeadDropGuid);
				ShopInterface val = SupplierShopRuntime.Ensure(supplier, stableId, config);
				bool flag = SupplierDeliveryVehicleRuntime.Ensure(supplier, val, stableId);
				bool flag2 = SupplierMeetingRuntime.EnsureSelected(supplier);
				bool flag3 = SupplierMeetingRuntime.PrepareNativeStartDialogue(supplier);
				SupplierStashRuntime.SchedulePlacement(supplier, config?.StashDeadDropGuid);
				int num;
				if ((Object)(object)val != (Object)null && flag)
				{
					SupplierStash stash = supplier.Stash;
					num = (((Object)(object)((stash != null) ? stash.Storage : null) != (Object)null) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag2 ? 1u : 0u) & (flag3 ? 1u : 0u)) != 0;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to prepare supplier '" + (supplierId ?? ((Object)supplier).name) + "': " + ex.Message);
				return false;
			}
		}

		internal static bool IsOwnedShop(ShopInterface? shop)
		{
			return SupplierRuntimeIds.IsOwnedShop(shop);
		}

		internal static bool EnsureDeliveryEntry(DeliveryApp app, ShopInterface shop, bool available)
		{
			return SupplierDeliveryUiBridge.EnsureEntry(app, shop, available);
		}

		internal static bool TryDeferDeliveryStatusDisplay(DeliveryApp app, DeliveryInstance delivery)
		{
			return SupplierDeliveryStatusDisplayRecovery.TryDefer(app, delivery);
		}

		internal static bool TryInitializeGeneratedStash(SupplierStash stash)
		{
			return SupplierStashRuntime.TryInitialize(stash);
		}

		internal static void ReconcileDeliveryUnlock(Supplier supplier)
		{
			if ((Object)(object)supplier == (Object)null || !((NetworkBehaviour)supplier).IsServerInitialized || ((NPC)supplier).RelationData == null || ((NPC)supplier).RelationData.RelationDelta < 5f || supplier.DeliveriesEnabled)
			{
				return;
			}
			try
			{
				global::S1API.Internal.Utils.ReflectionUtils.GetMethod(((object)supplier).GetType(), "RelationshipChange", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(supplier, new object[1] { 0f });
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to restore delivery availability for supplier '" + ((NPC)supplier).ID + "': " + ex.Message);
			}
		}

		internal static void ReconcileMeetingDialogue(Supplier supplier, bool visible)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			if (!((Object)(object)supplier == (Object)null))
			{
				bool flag = SupplierMeetingDialoguePolicy.ShouldActivate(visible, (int)supplier.Status == 2);
				if (!SupplierMeetingRuntime.SetDialogueActive(supplier, flag) && flag)
				{
					Logger.Warning("Supplier '" + ((NPC)supplier).ID + "' entered a meeting without a bound shop dialogue choice.");
				}
			}
		}

		internal static void CleanupSupplier(Supplier supplier)
		{
			if (!((Object)(object)supplier == (Object)null))
			{
				ShopInterface shop = supplier.Shop;
				SupplierDeliveryStatusDisplayRecovery.CleanupShop((shop != null) ? shop.ShopName : null);
				SupplierDeliveryUiBridge.CleanupShop(supplier.Shop);
				SupplierDeliveryVehicleRuntime.CleanupSupplier(supplier);
				SupplierShopRuntime.CleanupSupplier(supplier);
				SupplierStashRuntime.CleanupSupplier(supplier);
			}
		}

		internal static void CleanupForSceneChange()
		{
			SupplierDeliveryRecovery.Reset();
			DeliveryEventBridge.Reset();
			SupplierStashPersistenceRuntime.ClearPending();
			SupplierDeliveryStatusDisplayRecovery.Reset();
			SupplierDeliveryUiBridge.CleanupForSceneChange();
			SupplierDeliveryVehicleRuntime.CleanupForSceneChange();
			SupplierShopRuntime.CleanupForSceneChange();
			SupplierStashRuntime.CleanupForSceneChange();
		}
	}
}
namespace S1API.Internal.Entities.Suppliers
{
	internal static class SupplierMeetingDialoguePolicy
	{
		internal static SupplierMeetingDialogueBindings ForNativeStart(int existingGreetingCount, int existingChoiceCount)
		{
			return new SupplierMeetingDialogueBindings(existingGreetingCount, existingChoiceCount);
		}

		internal static bool ShouldActivate(bool visible, bool isMeeting)
		{
			return visible && isMeeting;
		}
	}
	internal readonly struct SupplierMeetingDialogueBindings
	{
		internal int GreetingOverrideIndex { get; }

		internal int ChoiceIndex { get; }

		internal SupplierMeetingDialogueBindings(int greetingOverrideIndex, int choiceIndex)
		{
			GreetingOverrideIndex = greetingOverrideIndex;
			ChoiceIndex = choiceIndex;
		}
	}
	internal static class SupplierMeetingRuntime
	{
		private const string MeetingActionName = "S1API_SupplierMeetingAction";

		internal static void EnsurePrefab(GameObject prefabRoot)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			NPCScheduleManager val = prefabRoot.GetComponentInChildren<NPCScheduleManager>(true);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("NPCSchedule");
				val2.transform.SetParent(prefabRoot.transform, false);
				val = val2.AddComponent<NPCScheduleManager>();
			}
			NPC component = prefabRoot.GetComponent<NPC>();
			if ((Object)(object)((component != null) ? component.Behaviour : null) != (Object)null)
			{
				component.Behaviour.ScheduleManager = val;
			}
			NPCEvent_LocationDialogue val3 = ((IEnumerable<NPCEvent_LocationDialogue>)((Component)val).GetComponentsInChildren<NPCEvent_LocationDialogue>(true)).FirstOrDefault((Func<NPCEvent_LocationDialogue, bool>)((NPCEvent_LocationDialogue candidate) => (Object)(object)candidate != (Object)null && ((Object)((Component)candidate).gameObject).name == "S1API_SupplierMeetingAction"));
			if ((Object)(object)val3 == (Object)null)
			{
				GameObject val4 = new GameObject("S1API_SupplierMeetingAction");
				val4.transform.SetParent(((Component)val).transform, false);
				val3 = val4.AddComponent<NPCEvent_LocationDialogue>();
			}
			((NPCAction)val3).StartTime = 501;
			((NPCEvent)val3).Duration = 1439;
			((NPCEvent)val3).EndTime = 500;
			val3.Destination = null;
			val3.FaceDestinationDir = true;
			val3.DestinationThreshold = 1f;
			val3.WarpIfSkipped = false;
			val3.GreetingOverrideToEnable = 0;
			val3.ChoiceToEnable = 0;
			val3.DialogueOverride = null;
			((Component)val3).transform.SetSiblingIndex(0);
			((Component)val3).gameObject.SetActive(true);
		}

		internal static bool EnsureSelected(Supplier supplier)
		{
			NPCBehaviour behaviour = ((NPC)supplier).Behaviour;
			NPCScheduleManager val = ((behaviour != null) ? behaviour.ScheduleManager : null);
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)supplier).GetComponentInChildren<NPCScheduleManager>(true);
				if ((Object)(object)val != (Object)null && (Object)(object)((NPC)supplier).Behaviour != (Object)null)
				{
					((NPC)supplier).Behaviour.ScheduleManager = val;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (val.ActionList == null || val.ActionList.Count == 0)
			{
				val.InitializeActions();
			}
			NPCEvent_LocationDialogue val2 = ((IEnumerable<NPCEvent_LocationDialogue>)((Component)val).GetComponentsInChildren<NPCEvent_LocationDialogue>(true)).FirstOrDefault((Func<NPCEvent_LocationDialogue, bool>)((NPCEvent_LocationDialogue action) => (Object)(object)action != (Object)null && ((Object)((Component)action).gameObject).name == "S1API_SupplierMeetingAction"));
			if ((Object)(object)val2 == (Object)null || val.ActionList == null)
			{
				return false;
			}
			int num = val.ActionList.IndexOf((NPCAction)(object)val2);
			if (num < 0)
			{
				val.InitializeActions();
				num = val.ActionList.IndexOf((NPCAction)(object)val2);
			}
			int num2 = -1;
			for (int num3 = 0; num3 < val.ActionList.Count; num3++)
			{
				if (CrossType.Is<NPCEvent_LocationDialogue>((object)val.ActionList[num3], out NPCEvent_LocationDialogue _))
				{
					num2 = num3;
					break;
				}
			}
			if (num >= 0 && num2 >= 0 && num != num2)
			{
				val.ActionList.Remove((NPCAction)(object)val2);
				val.ActionList.Insert(num2, (NPCAction)(object)val2);
			}
			for (int num4 = 0; num4 < val.ActionList.Count; num4++)
			{
				if (CrossType.Is<NPCEvent_LocationDialogue>((object)val.ActionList[num4], out NPCEvent_LocationDialogue result2))
				{
					return (Object)(object)result2 == (Object)(object)val2;
				}
			}
			return false;
		}

		internal static bool PrepareNativeStartDialogue(Supplier supplier)
		{
			NPCEvent_LocationDialogue val = FindReservedAction(supplier);
			DialogueHandler dialogueHandler = ((NPC)supplier).DialogueHandler;
			DialogueController val2 = ((dialogueHandler != null) ? ((Component)dialogueHandler).GetComponent<DialogueController>() : null);
			if ((Object)(object)val == (Object)null || ((val2 != null) ? val2.GreetingOverrides : null) == null || val2.Choices == null)
			{
				return false;
			}
			SupplierMeetingDialogueBindings supplierMeetingDialogueBindings = SupplierMeetingDialoguePolicy.ForNativeStart(val2.GreetingOverrides.Count, val2.Choices.Count);
			for (int i = 0; i < val2.GreetingOverrides.Count; i++)
			{
				val2.GreetingOverrides[i].ShouldShow = false;
			}
			for (int j = 0; j < val2.Choices.Count; j++)
			{
				val2.Choices[j].Enabled = false;
			}
			val.GreetingOverrideToEnable = supplierMeetingDialogueBindings.GreetingOverrideIndex;
			val.ChoiceToEnable = supplierMeetingDialogueBindings.ChoiceIndex;
			return true;
		}

		internal static bool SetDialogueActive(Supplier supplier, bool active)
		{
			NPCEvent_LocationDialogue val = FindReservedAction(supplier);
			DialogueHandler dialogueHandler = ((NPC)supplier).DialogueHandler;
			DialogueController val2 = ((dialogueHandler != null) ? ((Component)dialogueHandler).GetComponent<DialogueController>() : null);
			if ((Object)(object)val == (Object)null || ((val2 != null) ? val2.GreetingOverrides : null) == null || val2.Choices == null || val.GreetingOverrideToEnable < 0 || val.GreetingOverrideToEnable >= val2.GreetingOverrides.Count || val.ChoiceToEnable < 0 || val.ChoiceToEnable >= val2.Choices.Count)
			{
				return false;
			}
			val2.GreetingOverrides[val.GreetingOverrideToEnable].ShouldShow = active;
			val2.Choices[val.ChoiceToEnable].Enabled = active;
			return true;
		}

		private static NPCEvent_LocationDialogue? FindReservedAction(Supplier supplier)
		{
			NPCBehaviour behaviour = ((NPC)supplier).Behaviour;
			NPCScheduleManager val = ((behaviour != null) ? behaviour.ScheduleManager : null) ?? ((Component)supplier).GetComponentInChildren<NPCScheduleManager>(true);
			return (val != null) ? ((IEnumerable<NPCEvent_LocationDialogue>)((Component)val).GetComponentsInChildren<NPCEvent_LocationDialogue>(true)).FirstOrDefault((Func<NPCEvent_LocationDialogue, bool>)((NPCEvent_LocationDialogue action) => (Object)(object)action != (Object)null && ((Object)((Component)action).gameObject).name == "S1API_SupplierMeetingAction")) : null;
		}
	}
	internal static class SupplierRuntimeIds
	{
		internal const string ShopNamePrefix = "s1api_supplier_";

		internal const string DeliveryVehiclePrefabPrefix = "S1API_SupplierDeliveryVehicle_";

		internal static string ResolveStableId(GameObject supplierObject, string? explicitId = null)
		{
			string text = explicitId;
			NPCPrefabIdentity nPCPrefabIdentity = (((Object)(object)supplierObject != (Object)null) ? supplierObject.GetComponent<NPCPrefabIdentity>() : null);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = nPCPrefabIdentity?.Id;
			}
			if (string.IsNullOrWhiteSpace(text) && (Object)(object)supplierObject != (Object)null)
			{
				Supplier component = supplierObject.GetComponent<Supplier>();
				text = ((component != null) ? ((NPC)component).ID : null);
				if (string.IsNullOrWhiteSpace(text))
				{
					NPC component2 = supplierObject.GetComponent<NPC>();
					text = ((component2 != null) ? component2.ID : null);
				}
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				throw new InvalidOperationException("A custom supplier requires an ID configured with NPCPrefabBuilder.WithIdentity().");
			}
			text = text.Trim();
			if (text.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).Trim();
			}
			return text.ToLowerInvariant();
		}

		internal static string GetShopName(string stableId)
		{
			return "s1api_supplier_" + GetStableToken(stableId);
		}

		internal static string GetShopCode(string stableId)
		{
			return GetShopName(stableId);
		}

		internal static string GetDeliveryVehiclePrefabName(string stableId)
		{
			return "S1API_SupplierDeliveryVehicle_" + GetStableToken(stableId);
		}

		internal static Guid GetStashGuid(string stableId)
		{
			return CreateStableGuid("S1API.SupplierStash:v1:" + Normalize(stableId));
		}

		internal static Guid GetDeliveryVehicleGuid(string stableId)
		{
			return CreateStableGuid("S1API.SupplierDeliveryVehicle:v1:" + Normalize(stableId));
		}

		internal static bool IsOwnedShop(ShopInterface? shop)
		{
			return (Object)(object)shop != (Object)null && IsOwnedShopName(shop.ShopName);
		}

		internal static bool IsOwnedShopName(string? shopName)
		{
			return !string.IsNullOrWhiteSpace(shopName) && shopName.StartsWith("s1api_supplier_", StringComparison.OrdinalIgnoreCase);
		}

		internal static string Sanitize(string value)
		{
			char[] value2 = (from character in Normalize(value)
				select char.IsLetterOrDigit(character) ? character : '_').ToArray();
			string text = new string(value2).Trim('_');
			return string.IsNullOrEmpty(text) ? "supplier" : text;
		}

		private static string GetStableToken(string stableId)
		{
			string text = Normalize(stableId);
			string text2 = Sanitize(text);
			if (text2.Length > 48)
			{
				text2 = text2.Substring(0, 48);
			}
			byte[] array;
			using (SHA256 sHA = SHA256.Create())
			{
				array = sHA.ComputeHash(Encoding.UTF8.GetBytes(text));
			}
			StringBuilder stringBuilder = new StringBuilder(8);
			for (int i = 0; i < 4; i++)
			{
				stringBuilder.Append(array[i].ToString("x2"));
			}
			return $"{text2}_{stringBuilder}";
		}

		private static Guid CreateStableGuid(string value)
		{
			byte[] sourceArray;
			using (SHA256 sHA = SHA256.Create())
			{
				sourceArray = sHA.ComputeHash(Encoding.UTF8.GetBytes(value));
			}
			byte[] array = new byte[16];
			Array.Copy(sourceArray, array, array.Length);
			array[6] = (byte)((array[6] & 0xF) | 0x50);
			array[8] = (byte)((array[8] & 0x3F) | 0x80);
			return new Guid(array);
		}

		private static string Normalize(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				throw new ArgumentException("A stable supplier ID is required.", "value");
			}
			return value.Trim().ToLowerInvariant();
		}
	}
	internal static class SupplierShopRuntime
	{
		private static readonly Dictionary<int, GameObject> OwnedShops = new Dictionary<int, GameObject>();

		internal static ShopInterface Ensure(Supplier supplier, string stableId, SupplierDataBuilder.SupplierConfigData? config)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			if (SupplierRuntimeIds.IsOwnedShop(supplier.Shop))
			{
				return supplier.Shop;
			}
			Supplier val = ((IEnumerable<Supplier>)Resources.FindObjectsOfTypeAll<Supplier>()).FirstOrDefault((Func<Supplier, bool>)((Supplier candidate) => (Object)(object)candidate != (Object)null && (Object)(object)candidate != (Object)(object)supplier && (Object)(object)candidate.Shop != (Object)null && !SupplierRuntimeIds.IsOwnedShop(candidate.Shop)));
			if ((Object)(object)((val != null) ? val.Shop : null) == (Object)null)
			{
				throw new InvalidOperationException("No initialized vanilla supplier shop is loaded in the current scene.");
			}
			ShopInterface val2 = InactiveObjectCloner.CloneComponent<ShopInterface>(val.Shop, ((Component)val.Shop).transform.parent);
			string text = (string.IsNullOrWhiteSpace(((NPC)supplier).FullName) ? stableId : ((NPC)supplier).FullName);
			string shopName = SupplierRuntimeIds.GetShopName(stableId);
			((Object)((Component)val2).gameObject).name = "S1API_SupplierShop_" + SupplierRuntimeIds.Sanitize(stableId);
			val2.ShopName = shopName;
			val2.ShopCode = SupplierRuntimeIds.GetShopCode(stableId);
			val2.ShopDescription = "Supplier shop for " + text + ".";
			val2.Listings = BuildListings(supplier, config);
			val2.onOrderCompleted = new UnityEvent();
			val2.onOrderCompletedWithSpend = null;
			val2.LoadingBayDetector = null;
			val2.DeliveryVehicle = null;
			ClearRuntimeUi(val2);
			val2.DeliveryBays = new Il2CppReferenceArray<StorageEntity>(0L);
			OwnedShops[((Object)supplier).GetInstanceID()] = ((Component)val2).gameObject;
			((Component)val2).gameObject.SetActive(true);
			if ((Object)(object)val2.StoreNameLabel != (Object)null)
			{
				((TMP_Text)val2.StoreNameLabel).text = text;
			}
			supplier.Shop = val2;
			ShopManager.InvalidateCache();
			return val2;
		}

		internal static void ClearDonorReference(Supplier supplier)
		{
			if (!SupplierRuntimeIds.IsOwnedShop(supplier.Shop))
			{
				supplier.Shop = null;
			}
		}

		internal static void CleanupSupplier(Supplier supplier)
		{
			if ((Object)(object)supplier == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)supplier).GetInstanceID();
			if (OwnedShops.TryGetValue(instanceID, out GameObject value))
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				OwnedShops.Remove(instanceID);
				ShopManager.InvalidateCache();
			}
		}

		internal static void CleanupForSceneChange()
		{
			GameObject[] array = OwnedShops.Values.ToArray();
			foreach (GameObject val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
			OwnedShops.Clear();
			ShopManager.InvalidateCache();
		}

		private static List<ShopListing> BuildListings(Supplier supplier, SupplierDataBuilder.SupplierConfigData? config)
		{
			List<ShopListing> val = new List<ShopListing>();
			if (config != null)
			{
				IReadOnlyList<StorableItemDefinition> readOnlyList = config.ResolveDeliveryItems();
				for (int i = 0; i < readOnlyList.Count; i++)
				{
					val.Add(CreateListing(readOnlyList[i]));
				}
				return val;
			}
			SupplierNPCData supplierData = supplier.SupplierData;
			if (((supplierData != null) ? supplierData.DeliveryShopListings : null) == null)
			{
				return val;
			}
			for (int j = 0; j < ((Il2CppArrayBase<Listing>)(object)supplierData.DeliveryShopListings).Length; j++)
			{
				Listing obj = ((Il2CppArrayBase<Listing>)(object)supplierData.DeliveryShopListings)[j];
				StorableItemDefinition val2 = ((obj != null) ? obj.Item : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val.Add(CreateListing(val2));
				}
			}
			return val;
		}

		private static ShopListing CreateListing(StorableItemDefinition 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_0053: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			return new ShopListing
			{
				name = $"{((BaseItemDefinition)item).Name} (${item.BasePurchasePrice})",
				Item = item,
				LimitedStock = false,
				DefaultStock = -1,
				CanBeDelivered = true
			};
		}

		private static void ClearRuntimeUi(ShopInterface shop)
		{
			if ((Object)(object)shop.ListingContainer != (Object)null)
			{
				for (int num = ((Transform)shop.ListingContainer).childCount - 1; num >= 0; num--)
				{
					Transform child = ((Transform)shop.ListingContainer).GetChild(num);
					bool isAmountSelector = (Object)(object)shop.AmountSelector != (Object)null && (Object)(object)child == (Object)(object)((Component)shop.AmountSelector).transform;
					bool isListingUi = (Object)(object)((Component)child).GetComponent<ListingUI>() != (Object)null;
					if (ShouldRemoveClonedUiChild(isListingUi, isAmountSelector))
					{
						Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
					}
				}
			}
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "listingUI", new List<ListingUI>());
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(shop, "listingPanel");
			global::S1API.Internal.Utils.ReflectionUtils.GetMethod(obj?.GetType(), "ClearAllSelectables", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj, null);
		}

		internal static bool ShouldRemoveClonedUiChild(bool isListingUi, bool isAmountSelector)
		{
			return isListingUi && !isAmountSelector;
		}
	}
	internal static class SupplierStashPersistenceRuntime
	{
		private static readonly Log Logger = new Log("SupplierStashPersistenceRuntime");

		private static readonly HashSet<string> RegisteredStashGuids = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, WorldStorageEntityData> PendingData = new Dictionary<string, WorldStorageEntityData>(StringComparer.OrdinalIgnoreCase);

		internal static void Register(string stableId)
		{
			RegisteredStashGuids.Add(GetStashGuid(stableId));
		}

		internal static void CaptureFromLoader(StorageLoader loader, string mainPath)
		{
			if (loader == null || string.IsNullOrWhiteSpace(mainPath))
			{
				return;
			}
			try
			{
				if (Directory.Exists(mainPath))
				{
					string[] files = Directory.GetFiles(mainPath);
					string contents = default(string);
					foreach (string text in files)
					{
						if (((Loader)loader).TryLoadFile(text, ref contents, false))
						{
							TryCaptureSingle(contents);
						}
					}
				}
				string text2 = default(string);
				if (!((Loader)loader).TryLoadFile(mainPath, ref text2, true))
				{
					return;
				}
				WorldStorageEntitiesData val = JsonUtility.FromJson<WorldStorageEntitiesData>(text2);
				if (((val != null) ? val.Entities : null) == null)
				{
					return;
				}
				foreach (WorldStorageEntityData item in (Il2CppArrayBase<WorldStorageEntityData>)(object)val.Entities)
				{
					Capture(item);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not inspect supplier stash save data before native storage loading: " + ex.Message);
			}
		}

		internal static bool TryReplay(WorldStorageEntity storage, string stableId)
		{
			if ((Object)(object)storage == (Object)null)
			{
				return false;
			}
			string stashGuid = GetStashGuid(stableId);
			RegisteredStashGuids.Add(stashGuid);
			if (!PendingData.TryGetValue(stashGuid, out WorldStorageEntityData value) || value == null)
			{
				return false;
			}
			try
			{
				storage.Load(value);
				PendingData.Remove(stashGuid);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not restore custom supplier stash '" + stashGuid + "': " + ex.Message);
				return false;
			}
		}

		internal static void NotifyLoadSucceeded(WorldStorageEntityData data)
		{
			if (data != null && TryNormalizeGuid(data.GUID, out string guid))
			{
				PendingData.Remove(guid);
			}
		}

		internal static void ClearPending()
		{
			PendingData.Clear();
		}

		private static void Capture(WorldStorageEntityData? data)
		{
			if (data != null && TryNormalizeGuid(data.GUID, out string guid) && RegisteredStashGuids.Contains(guid))
			{
				if (TryResolveStorage(guid))
				{
					PendingData.Remove(guid);
				}
				else
				{
					PendingData[guid] = data;
				}
			}
		}

		private static void TryCaptureSingle(string contents)
		{
			try
			{
				Capture(JsonUtility.FromJson<WorldStorageEntityData>(contents));
			}
			catch
			{
			}
		}

		private static string GetStashGuid(string stableId)
		{
			return SupplierRuntimeIds.GetStashGuid(stableId).ToString("D");
		}

		private static bool TryNormalizeGuid(string? value, out string guid)
		{
			if (Guid.TryParse(value, out var result))
			{
				guid = result.ToString("D");
				return true;
			}
			guid = string.Empty;
			return false;
		}

		private static bool TryResolveStorage(string guid)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return (Object)(object)GUIDManager.GetObject<WorldStorageEntity>(new Guid(guid)) != (Object)null;
			}
			catch
			{
				return false;
			}
		}
	}
	internal static class SupplierStashRuntime
	{
		internal const string StashObjectName = "S1API_SupplierStash";

		private static readonly Log Logger = new Log("SupplierStashRuntime");

		private static readonly Dictionary<int, GameObject> OwnedStashes = new Dictionary<int, GameObject>();

		private static readonly HashSet<int> InitializedStashes = new HashSet<int>();

		private static readonly HashSet<int> ScheduledPlacements = new HashSet<int>();

		private static readonly HashSet<int> ConfiguredStashes = new HashSet<int>();

		private static readonly Dictionary<int, string> ConfiguredStashGuids = new Dictionary<int, string>();

		internal static bool HasReservedDeadDrops => ConfiguredStashGuids.Count > 0;

		internal static void EnsurePrefab(GameObject prefabRoot)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			SupplierStash val = ((IEnumerable<SupplierStash>)prefabRoot.GetComponentsInChildren<SupplierStash>(true)).FirstOrDefault((Func<SupplierStash, bool>)((SupplierStash candidate) => (Object)(object)candidate != (Object)null && ((Object)((Component)candidate).gameObject).name == "S1API_SupplierStash"));
			if (!((Object)(object)val != (Object)null))
			{
				GameObject val2 = new GameObject("S1API_SupplierStash");
				val2.SetActive(false);
				val2.transform.SetParent(prefabRoot.transform, false);
				val2.transform.localPosition = new Vector3(1.5f, 0.5f, 0f);
				WorldStorageEntity val3 = val2.AddComponent<WorldStorageEntity>();
				((StorageEntity)val3).SlotCount = 5;
				((StorageEntity)val3).DisplayRowCount = 1;
				((StorageEntity)val3).AccessSettings = (EAccessSettings)2;
				((StorageEntity)val3).MaxAccessDistance = 5f;
				BoxCollider val4 = val2.AddComponent<BoxCollider>();
				val4.size = new Vector3(1.1f, 0.8f, 0.8f);
				((Collider)val4).isTrigger = true;
				StorageEntityInteractable val5 = val2.AddComponent<StorageEntityInteractable>();
				((InteractableObject)val5).MaxInteractionRange = ((StorageEntity)val3).MaxAccessDistance;
				GameObject val6 = new GameObject("IndicatorLight");
				val6.transform.SetParent(val2.transform, false);
				Light val7 = val6.AddComponent<Light>();
				val7.range = 2f;
				val7.intensity = 1f;
				OptimizedLight val8 = val6.AddComponent<OptimizedLight>();
				val8.Enabled = false;
				GameObject val9 = GameObject.CreatePrimitive((PrimitiveType)3);
				((Object)val9).name = "StashVisual";
				val9.transform.SetParent(val2.transform, false);
				val9.transform.localScale = new Vector3(1f, 0.7f, 0.7f);
				Collider component = val9.GetComponent<Collider>();
				if ((Object)(object)component != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)component);
				}
				SupplierStash val10 = val2.AddComponent<SupplierStash>();
				val10.locationDescription = "beside the supplier's starting location";
				val10.Storage = (StorageEntity)(object)val3;
				val10.IntObj = (InteractableObject)(object)val5;
				val10.Light = val8;
				val10.StashPoI = null;
				val2.SetActive(true);
			}
		}

		internal static void FinalizePrefab(GameObject prefabRoot, string stableId)
		{
			SupplierStashPersistenceRuntime.Register(stableId);
			SupplierStash val = FindInHierarchy(prefabRoot);
			if ((Object)(object)((val != null) ? val.Storage : null) != (Object)null && CrossType.Is<WorldStorageEntity>((object)val.Storage, out WorldStorageEntity result))
			{
				ConfigureIdentity(result, stableId);
			}
		}

		internal static void Bind(Supplier supplier, string stableId, string? stashDeadDropGuid)
		{
			if (!string.IsNullOrWhiteSpace(stashDeadDropGuid))
			{
				BindDeadDrop(supplier, stashDeadDropGuid);
				return;
			}
			SupplierStash val = BindPrefab(supplier);
			if ((Object)(object)val.Storage != (Object)null && CrossType.Is<WorldStorageEntity>((object)val.Storage, out WorldStorageEntity result))
			{
				ConfigureIdentity(result, stableId);
				SupplierStashPersistenceRuntime.Register(stableId);
			}
		}

		internal static SupplierStash BindPrefab(Supplier supplier)
		{
			SupplierStash val = Find(supplier);
			if ((Object)(object)val == (Object)null && !((NetworkBehaviour)supplier).IsSpawned)
			{
				EnsurePrefab(((Component)supplier).gameObject);
				val = Find(supplier);
			}
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("The generated supplier prefab has no S1API stash.");
			}
			val.Supplier = supplier;
			supplier.Stash = val;
			return val;
		}

		internal static bool TryInitialize(SupplierStash stash)
		{
			if ((Object)(object)stash == (Object)null || (Object)(object)((Component)stash).gameObject == (Object)null)
			{
				return false;
			}
			bool flag = ConfiguredStashes.Contains(((Object)stash).GetInstanceID());
			if (!flag && ((Object)((Component)stash).gameObject).name != "S1API_SupplierStash")
			{
				return false;
			}
			int instanceID = ((Object)stash).GetInstanceID();
			if (!InitializedStashes.Add(instanceID))
			{
				return true;
			}
			if ((Object)(object)stash.Supplier == (Object)null || (Object)(object)stash.Storage == (Object)null || (Object)(object)stash.IntObj == (Object)null)
			{
				Logger.Error("Generated supplier stash is missing Supplier, Storage, or Interactable references.");
				return true;
			}
			if (!flag && CrossType.Is<WorldStorageEntity>((object)stash.Storage, out WorldStorageEntity result))
			{
				string stableId = SupplierRuntimeIds.ResolveStableId(((Component)stash.Supplier).gameObject, ((NPC)stash.Supplier).ID);
				SupplierStashPersistenceRuntime.TryReplay(result, stableId);
			}
			stash.IntObj.SetMessage("View " + ((NPC)stash.Supplier).FullName + "'s stash");
			((Behaviour)stash.IntObj).enabled = ((NPC)stash.Supplier).RelationData.Unlocked;
			stash.IntObj.onInteractStart.AddListener(UnityAction.op_Implicit((Action)delegate
			{
				UpdateSubtitle(stash);
			}));
			stash.Storage.StorageEntityName = ((NPC)stash.Supplier).FullName + "'s Stash";
			if ((Object)(object)stash.StashPoI != (Object)null)
			{
				((Behaviour)stash.StashPoI).enabled = ((NPC)stash.Supplier).RelationData.Unlocked;
				stash.StashPoI.SetMainText(((NPC)stash.Supplier).FullName + "'s Stash");
			}
			Action<EUnlockType, bool> val = DelegateSupport.ConvertDelegate<Action<EUnlockType, bool>>((Delegate)(Action<EUnlockType, bool>)delegate
			{
				EnableUnlockedStash(stash);
			});
			((NPC)stash.Supplier).RelationData.OnUnlocked = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)((NPC)stash.Supplier).RelationData.OnUnlocked, (Delegate)(object)val)).Cast<Action<EUnlockType, bool>>();
			Action val2 = DelegateSupport.ConvertDelegate<Action>((Delegate)(Action)delegate
			{
				Recalculate(stash);
			});
			stash.Storage.onContentsChanged = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)stash.Storage.onContentsChanged, (Delegate)(object)val2)).Cast<Action>();
			Recalculate(stash);
			return true;
		}

		private static void EnableUnlockedStash(SupplierStash stash)
		{
			((Behaviour)stash.IntObj).enabled = true;
			if ((Object)(object)stash.StashPoI != (Object)null)
			{
				((Behaviour)stash.StashPoI).enabled = true;
			}
		}

		internal static void SchedulePlacement(Supplier supplier, string? stashDeadDropGuid)
		{
			if (string.IsNullOrWhiteSpace(stashDeadDropGuid))
			{
				int instanceID = ((Object)supplier).GetInstanceID();
				if (ScheduledPlacements.Add(instanceID))
				{
					MelonCoroutines.Start(PlaceAfterSpawn(supplier, instanceID));
				}
			}
		}

		internal static SupplierStash? Find(Supplier supplier)
		{
			if ((Object)(object)supplier.Stash != (Object)null && (((Object)((Component)supplier.Stash).gameObject).name == "S1API_SupplierStash" || ConfiguredStashes.Contains(((Object)supplier.Stash).GetInstanceID())))
			{
				return supplier.Stash;
			}
			if (OwnedStashes.TryGetValue(((Object)supplier).GetInstanceID(), out GameObject value) && (Object)(object)value != (Object)null)
			{
				return value.GetComponent<SupplierStash>();
			}
			return FindInHierarchy(((Component)supplier).gameObject);
		}

		internal static void CleanupSupplier(Supplier supplier)
		{
			if (!((Object)(object)supplier == (Object)null))
			{
				int instanceID = ((Object)supplier).GetInstanceID();
				if (ConfiguredStashGuids.Remove(instanceID, out string _) && (Object)(object)supplier.Stash != (Object)null)
				{
					ConfiguredStashes.Remove(((Object)supplier.Stash).GetInstanceID());
				}
				if (OwnedStashes.TryGetValue(instanceID, out GameObject value2))
				{
					Destroy(value2);
					OwnedStashes.Remove(instanceID);
				}
				ScheduledPlacements.Remove(instanceID);
			}
		}

		internal static void CleanupForSceneChange()
		{
			GameObject[] array = OwnedStashes.Values.ToArray();
			foreach (GameObject stashObject in array)
			{
				Destroy(stashObject);
			}
			OwnedStashes.Clear();
			InitializedStashes.Clear();
			ScheduledPlacements.Clear();
			ConfiguredStashes.Clear();
			ConfiguredStashGuids.Clear();
		}

		private static IEnumerator PlaceAfterSpawn(Supplier supplier, int supplierKey)
		{
			float deadline = Time.realtimeSinceStartup + 30f;
			while ((Object)(object)supplier != (Object)null && !((NetworkBehaviour)supplier).IsSpawned && Time.realtimeSinceStartup < deadline)
			{
				yield return null;
			}
			yield return null;
			try
			{
				if ((Object)(object)supplier == (Object)null || !((NetworkBehaviour)supplier).IsSpawned)
				{
					Logger.Error("A custom supplier stash could not be placed because its NPC never spawned.");
					yield break;
				}
				SupplierStash stash = Find(supplier);
				if ((Object)(object)stash == (Object)null)
				{
					Logger.Error("Custom supplier '" + ((NPC)supplier).ID + "' lost its generated stash after network spawn.");
					yield break;
				}
				stash.Supplier = supplier;
				supplier.Stash = stash;
				if ((Object)(object)((Component)stash).transform.parent != (Object)null)
				{
					((Component)stash).transform.SetParent((Transform)null, true);
				}
				((Object)((Component)stash).gameObject).name = "S1API_SupplierStash";
				OwnedStashes[supplierKey] = ((Component)stash).gameObject;
				SupplierRuntimeCoordinator.ReconcileDeliveryUnlock(supplier);
			}
			finally
			{
				ScheduledPlacements.Remove(supplierKey);
			}
		}

		private static SupplierStash? FindInHierarchy(GameObject root)
		{
			return ((IEnumerable<SupplierStash>)root.GetComponentsInChildren<SupplierStash>(true)).FirstOrDefault((Func<SupplierStash, bool>)((SupplierStash candidate) => (Object)(object)candidate != (Object)null && ((Object)((Component)candidate).gameObject).name == "S1API_SupplierStash"));
		}

		private static void BindDeadDrop(Supplier supplier, string deadDropGuid)
		{
			DeadDropInstance deadDropInstance = DeadDropManager.GetByGUID(deadDropGuid) ?? throw new InvalidOperationException("Supplier stash dead drop '" + deadDropGuid + "' is not present in the scene.");
			DeadDrop s1DeadDrop = deadDropInstance.S1DeadDrop;
			int instanceID = ((Object)supplier).GetInstanceID();
			foreach (KeyValuePair<int, string> configuredStashGuid in ConfiguredStashGuids)
			{
				if (configuredStashGuid.Key != instanceID && string.Equals(configuredStashGuid.Value, deadDropInstance.GUID, StringComparison.OrdinalIgnoreCase))
				{
					throw new InvalidOperationException("Dead drop '" + deadDropInstance.Name + "' is already assigned to another supplier stash.");
				}
			}
			StorageEntityInteractable intObj = ((Component)s1DeadDrop.Storage).GetComponent<StorageEntityInteractable>() ?? ((Component)s1DeadDrop.Storage).GetComponentInChildren<StorageEntityInteractable>(true) ?? throw new InvalidOperationException("Dead drop '" + deadDropInstance.Name + "' has no storage interaction component.");
			RemoveGeneratedPrefabStash(supplier);
			SupplierStash val = ((Component)s1DeadDrop).GetComponent<SupplierStash>() ?? ((Component)s1DeadDrop).gameObject.AddComponent<SupplierStash>();
			val.Supplier = supplier;
			val.Storage = (StorageEntity)(object)s1DeadDrop.Storage;
			val.IntObj = (InteractableObject)(object)intObj;
			val.Light = s1DeadDrop.Light;
			val.StashPoI = s1DeadDrop.PoI;
			val.locationDescription = s1DeadDrop.DeadDropDescription;
			supplier.Stash = val;
			ConfiguredStashes.Add(((Object)val).GetInstanceID());
			ConfiguredStashGuids[instanceID] = deadDropInstance.GUID;
		}

		private static void RemoveGeneratedPrefabStash(Supplier supplier)
		{
			int instanceID = ((Object)supplier).GetInstanceID();
			GameObject val = null;
			if (OwnedStashes.TryGetValue(instanceID, out GameObject value))
			{
				val = value;
				OwnedStashes.Remove(instanceID);
			}
			SupplierStash val2 = ((val != null) ? val.GetComponent<SupplierStash>() : null) ?? FindInHierarchy(((Component)supplier).gameObject);
			if (val == null)
			{
				val = ((val2 != null) ? ((Component)val2).gameObject : null);
			}
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)((val2 != null) ? val2.IntObj : null) != (Object)null)
				{
					((Behaviour)val2.IntObj).enabled = false;
				}
				val.SetActive(false);
				Destroy(val);
			}
		}

		internal static bool IsReservedDeadDrop(DeadDrop deadDrop)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)deadDrop == (Object)null)
			{
				return false;
			}
			Guid gUID = deadDrop.GUID;
			string guid = ((Guid)(ref gUID)).ToString("D");
			return ConfiguredStashGuids.Values.Any((string value) => string.Equals(value, guid, StringComparison.OrdinalIgnoreCase));
		}

		private static void ConfigureIdentity(WorldStorageEntity storage, string stableId)
		{
			string value = SupplierRuntimeIds.GetStashGuid(stableId).ToString();
			if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(storage, "BakedGUID", value))
			{
				throw new InvalidOperationException("Could not assign a persistent GUID to supplier stash '" + stableId + "'.");
			}
		}

		private static void Destroy(GameObject stashObject)
		{
			if ((Object)(object)stashObject == (Object)null)
			{
				return;
			}
			SupplierStash component = stashObject.GetComponent<SupplierStash>();
			if ((Object)(object)component != (Object)null)
			{
				InitializedStashes.Remove(((Object)component).GetInstanceID());
			}
			WorldStorageEntity component2 = stashObject.GetComponent<WorldStorageEntity>();
			if ((Object)(object)component2 != (Object)null)
			{
				try
				{
					if (CrossType.Is<IGUIDRegisterable>((object)component2, out IGUIDRegisterable result))
					{
						GUIDManager.DeregisterObject(result);
					}
				}
				catch
				{
				}
			}
			Object.Destroy((Object)(object)stashObject);
		}

		private static void UpdateSubtitle(SupplierStash stash)
		{
			stash.Storage.StorageEntitySubtitle = $"You owe {((NPC)stash.Supplier).FullName} ${stash.Supplier.Debt:0.00}. Insert cash and exit the stash to repay the debt.";
		}

		private static void Recalculate(SupplierStash stash)
		{
			float num = 0f;
			for (int i = 0; i < stash.Storage.ItemSlots.Count; i++)
			{
				ItemSlot obj = stash.Storage.ItemSlots[i];
				ItemInstance val = ((obj != null) ? obj.ItemInstance : null);
				if (val != null && CrossType.Is<CashInstance>((object)val, out CashInstance result))
				{
					num += result.Balance;
				}
			}
			stash._CashAmount_k__BackingField = num;
			if ((Object)(object)stash.Light != (Object)null)
			{
				stash.Light.Enabled = stash.Storage.ItemCount > 0;
			}
			UpdateSubtitle(stash);
		}
	}
}
namespace S1API.Internal.Deliveries
{
	internal static class DeliveryEventBridge
	{
		private static readonly HashSet<string> SeenDeliveryIds = new HashSet<string>(StringComparer.Ordinal);

		internal static DeliveryStatus BeforeStatusChange(DeliveryInstance delivery)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return (delivery != null) ? ((DeliveryStatus)delivery.Status) : DeliveryStatus.InTransit;
		}

		internal static void AfterStatusChange(DeliveryInstance delivery, DeliveryStatus previousStatus)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			if (delivery != null)
			{
				string text = delivery.DeliveryID ?? string.Empty;
				if (!string.IsNullOrEmpty(text) && SeenDeliveryIds.Add(text))
				{
					DeliveryRegistry.NotifyCreated(delivery);
				}
				DeliveryStatus deliveryStatus = (DeliveryStatus)delivery.Status;
				DeliveryRegistry.NotifyStatusChanged(delivery, previousStatus, deliveryStatus);
				if (deliveryStatus == DeliveryStatus.Completed)
				{
					DeliveryRegistry.NotifyCompleted(delivery);
				}
			}
		}

		internal static void Reset()
		{
			SeenDeliveryIds.Clear();
		}
	}
	internal static class SupplierDeliveryRecovery
	{
		private sealed class PendingVehicleLoad
		{
			internal VehicleData Data { get; }

			internal string Path { get; }

			internal PendingVehicleLoad(VehicleData data, string path)
			{
				Data = data;
				Path = path;
			}
		}

		private static readonly Log Logger = new Log("SupplierDeliveryRecovery");

		private static readonly Dictionary<DeliveryInstance, int> PendingArrivals = new Dictionary<DeliveryInstance, int>();

		private static readonly Dictionary<string, PendingVehicleLoad> PendingVehicleLoads = new Dictionary<string, PendingVehicleLoad>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<DeliveryInstance> ReplayingArrivals = new HashSet<DeliveryInstance>();

		internal static bool TryDeferStatus(DeliveryInstance delivery, EDeliveryStatus status)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			if (delivery == null || !SupplierRuntimeIds.IsOwnedShopName(delivery.StoreName))
			{
				return false;
			}
			if ((int)status != 2)
			{
				PendingArrivals.Remove(delivery);
				return false;
			}
			if (ReplayingArrivals.Contains(delivery))
			{
				return false;
			}
			ShopInterface val = FindShop(delivery.StoreName);
			if ((Object)(object)((val != null) ? val.DeliveryVehicle : null) != (Object)null)
			{
				return false;
			}
			if (!PendingArrivals.ContainsKey(delivery))
			{
				PendingArrivals[delivery] = delivery.TimeUntilArrival;
			}
			delivery.Status = (EDeliveryStatus)1;
			delivery.TimeUntilArrival = int.MaxValue;
			return true;
		}

		internal static bool TryDeferVehicleLoad(VehicleData data, string path)
		{
			if (data == null || !SupplierDeliveryVehicleRuntime.IsKnownGuid(data.GUID))
			{
				return false;
			}
			DeliveryVehicle val = SupplierDeliveryVehicleRuntime.FindByGuid(data.GUID);
			if ((Object)(object)((val != null) ? val.Vehicle : null) != (Object)null)
			{
				return false;
			}
			PendingVehicleLoads[data.GUID] = new PendingVehicleLoad(data, path ?? string.Empty);
			return true;
		}

		internal static void OnVehicleBound(ShopInterface shop, DeliveryVehicle deliveryVehicle)
		{
			if (!((Object)(object)shop == (Object)null) && !((Object)(object)deliveryVehicle == (Object)null))
			{
				ApplyPendingVehicleLoad(deliveryVehicle);
				ReplayArrivals(shop.ShopName);
			}
		}

		internal static void Reset()
		{
			PendingArrivals.Clear();
			PendingVehicleLoads.Clear();
			ReplayingArrivals.Clear();
		}

		private static void ApplyPendingVehicleLoad(DeliveryVehicle deliveryVehicle)
		{
			if (string.IsNullOrWhiteSpace(deliveryVehicle.GUID) || !PendingVehicleLoads.TryGetValue(deliveryVehicle.GUID, out PendingVehicleLoad value))
			{
				return;
			}
			try
			{
				deliveryVehicle.Vehicle.Load(value.Data, value.Path);
				PendingVehicleLoads.Remove(deliveryVehicle.GUID);
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to restore custom supplier delivery vehicle '" + deliveryVehicle.GUID + "': " + ex.Message);
			}
		}

		private static void ReplayArrivals(string shopName)
		{
			KeyValuePair<DeliveryInstance, int>[] array = PendingArrivals.Where<KeyValuePair<DeliveryInstance, int>>(delegate(KeyValuePair<DeliveryInstance, int> entry)
			{
				DeliveryInstance key2 = entry.Key;
				return string.Equals((key2 != null) ? key2.StoreName : null, shopName, StringComparison.Ordinal);
			}).ToArray();
			KeyValuePair<DeliveryInstance, int>[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				KeyValuePair<DeliveryInstance, int> keyValuePair = array2[num];
				DeliveryInstance key = keyValuePair.Key;
				PendingArrivals.Remove(key);
				if (key == null)
				{
					continue;
				}
				try
				{
					key.TimeUntilArrival = keyValuePair.Value;
					ReplayingArrivals.Add(key);
					key.SetStatus((EDeliveryStatus)2);
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to replay arrived delivery '" + key.DeliveryID + "' after vehicle binding: " + ex.Message);
				}
				finally
				{
					ReplayingArrivals.Remove(key);
				}
			}
		}

		private static ShopInterface? FindShop(string shopName)
		{
			if (ShopInterface.AllShops == null)
			{
				return null;
			}
			Enumerator<ShopInterface> enumerator = ShopInterface.AllShops.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ShopInterface current = enumerator.Current;
				if ((Object)(object)current != (Object)null && string.Equals(current.ShopName, shopName, StringComparison.Ordinal))
				{
					return current;
				}
			}
			return null;
		}
	}
	internal static class SupplierDeliveryStatusDisplayRecovery
	{
		private sealed class PendingStatusDisplay
		{
			internal DeliveryApp App { get; }

			internal DeliveryInstance Delivery { get; }

			internal PendingStatusDisplay(DeliveryApp app, DeliveryInstance delivery)
			{
				App = app;
				Delivery = delivery;
			}
		}

		private static readonly Log Logger = new Log("SupplierDeliveryStatusDisplayRecovery");

		private static readonly Dictionary<int, Dictionary<string, PendingStatusDisplay>> Pending = new Dictionary<int, Dictionary<string, PendingStatusDisplay>>();

		internal static bool TryDefer(DeliveryApp app, DeliveryInstance delivery)
		{
			if ((Object)(object)app == (Object)null || delivery == null || !SupplierRuntimeIds.IsOwnedShopName(delivery.StoreName))
			{
				return false;
			}
			string deliveryKey = GetDeliveryKey(delivery);
			if (HasReadyShop(app, delivery.StoreName))
			{
				Remove(((Object)app).GetInstanceID(), deliveryKey);
				return false;
			}
			int instanceID = ((Object)app).GetInstanceID();
			if (!Pending.TryGetValue(instanceID, out Dictionary<string, PendingStatusDisplay> value) || value == null)
			{
				value = new Dictionary<string, PendingStatusDisplay>(StringComparer.Ordinal);
				Pending.Add(instanceID, value);
			}
			value[deliveryKey] = new PendingStatusDisplay(app, delivery);
			return true;
		}

		internal static void OnShopReady(DeliveryApp app, string shopName)
		{
			Replay(app, shopName);
			RefreshPastDeliveries(app);
		}

		internal static void CleanupShop(string? shopName)
		{
			if (string.IsNullOrEmpty(shopName))
			{
				return;
			}
			int[] array = Pending.Keys.ToArray();
			foreach (int key in array)
			{
				Dictionary<string, PendingStatusDisplay> dictionary = Pending[key];
				string[] array2 = (from pair in dictionary
					where string.Equals(pair.Value.Delivery.StoreName, shopName, StringComparison.Ordinal)
					select pair.Key).ToArray();
				foreach (string key2 in array2)
				{
					dictionary.Remove(key2);
				}
				if (dictionary.Count == 0)
				{
					Pending.Remove(key);
				}
			}
		}

		internal static void Reset()
		{
			Pending.Clear();
		}

		private static bool HasReadyShop(DeliveryApp app, string shopName)
		{
			if (!(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "deliveryShops") is List<DeliveryShop> val))
			{
				return false;
			}
			for (int i = 0; i < val.Count; i++)
			{
				DeliveryShop val2 = val[i];
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2.MatchingShop != (Object)null && string.Equals(val2.MatchingShopInterfaceName, shopName, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static void Replay(DeliveryApp app, string shopName)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Invalid comparison between Unknown and I4
			if (!HasReadyShop(app, shopName) || !Pending.TryGetValue(((Object)app).GetInstanceID(), out Dictionary<string, PendingStatusDisplay> value) || value == null)
			{
				return;
			}
			PendingStatusDisplay[] array = value.Values.Where((PendingStatusDisplay pending) => string.Equals(pending.Delivery.StoreName, shopName, StringComparison.Ordinal)).ToArray();
			if (array.Length == 0)
			{
				return;
			}
			MethodInfo method = global::S1API.Internal.Utils.ReflectionUtils.GetMethod(typeof(DeliveryApp), "CreateDeliveryStatusDisplay", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null)
			{
				Logger.Warning("Could not find DeliveryApp.CreateDeliveryStatusDisplay to replay saved deliveries.");
				return;
			}
			PendingStatusDisplay[] array2 = array;
			foreach (PendingStatusDisplay pendingStatusDisplay in array2)
			{
				Remove(((Object)app).GetInstanceID(), GetDeliveryKey(pendingStatusDisplay.Delivery));
				if ((int)pendingStatusDisplay.Delivery.Status != 3)
				{
					try
					{
						method.Invoke(pendingStatusDisplay.App, new object[1] { pendingStatusDisplay.Delivery });
					}
					catch (Exception ex)
					{
						Logger.Warning("Could not replay delivery status display '" + pendingStatusDisplay.Delivery.DeliveryID + "': " + ex.Message);
					}
				}
			}
		}

		private static void RefreshPastDeliveries(DeliveryApp app)
		{
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "_pastDeliveries") == null)
			{
				return;
			}
			try
			{
				global::S1API.Internal.Utils.ReflectionUtils.GetMethod(typeof(DeliveryApp), "UpdatePastDeliveries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(app, null);
			}
			catch (Exception ex)
			{
				Logger.Warning("Could not refresh delivery history after registering a supplier shop: " + ex.Message);
			}
		}

		private static void Remove(int appKey, string deliveryKey)
		{
			if (Pending.TryGetValue(appKey, out Dictionary<string, PendingStatusDisplay> value) && value != null)
			{
				value.Remove(deliveryKey);
				if (value.Count == 0)
				{
					Pending.Remove(appKey);
				}
			}
		}

		private static string GetDeliveryKey(DeliveryInstance delivery)
		{
			return string.IsNullOrEmpty(delivery.DeliveryID) ? $"{delivery.StoreName}:{((Object)delivery).GetHashCode()}" : delivery.DeliveryID;
		}
	}
	internal static class SupplierDeliveryUiBridge
	{
		private sealed class DeliveryRegistration
		{
			internal DeliveryApp App { get; }

			internal DeliveryShopElement Element { get; }

			internal DeliveryRegistration(DeliveryApp app, DeliveryShopElement element)
			{
				App = app;
				Element = element;
			}
		}

		private sealed class PendingAvailability
		{
			internal DeliveryApp App { get; }

			internal ShopInterface Shop { get; }

			internal bool Available { get; }

			internal PendingAvailability(DeliveryApp app, ShopInterface shop, bool available)
			{
				App = app;
				Shop = shop;
				Available = available;
			}
		}

		private static readonly Log Logger = new Log("SupplierDeliveryUiBridge");

		private static readonly Dictionary<int, DeliveryRegistration> Registrations = new Dictionary<int, DeliveryRegistration>();

		private static readonly Dictionary<int, PendingAvailability> Pending = new Dictionary<int, PendingAvailability>();

		internal static bool EnsureEntry(DeliveryApp app, ShopInterface shop, bool available)
		{
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Expected O, but got Unknown
			if ((Object)(object)app == (Object)null || (Object)(object)shop == (Object)null || !SupplierRuntimeIds.IsOwnedShop(shop))
			{
				return false;
			}
			int instanceID = ((Object)shop).GetInstanceID();
			if ((Object)(object)shop.DeliveryVehicle == (Object)null)
			{
				Pending[instanceID] = new PendingAvailability(app, shop, available);
				if (Registrations.TryGetValue(instanceID, out DeliveryRegistration value))
				{
					Button button = value.Element.Button;
					if (button != null)
					{
						((Component)button).gameObject.SetActive(false);
					}
				}
				return true;
			}
			Pending.Remove(instanceID);
			if (!(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "_shopElements") is List<DeliveryShopElement> val))
			{
				return false;
			}
			for (int i = 0; i < val.Count; i++)
			{
				DeliveryShopElement val2 = val[i];
				if (!((Object)(object)((val2 != null) ? val2.Shop : null) == (Object)null) && ((Object)(object)val2.Shop.MatchingShop == (Object)(object)shop || string.Equals(val2.Shop.MatchingShopInterfaceName, shop.ShopName, StringComparison.Ordinal)))
				{
					val2.Shop.AvailableByDefault = available;
					Button button2 = val2.Button;
					if (button2 != null)
					{
						((Component)button2).gameObject.SetActive(available);
					}
					Registrations[instanceID] = new DeliveryRegistration(app, val2);
					SupplierDeliveryStatusDisplayRecovery.OnShopReady(app, shop.ShopName);
					return true;
				}
			}
			DeliveryShopElement val3 = FindDonor(val);
			if ((Object)(object)((val3 != null) ? val3.Shop : null) == (Object)null || (Object)(object)val3.Button == (Object)null)
			{
				Logger.Warning("No delivery UI donor was available for custom supplier shop '" + shop.ShopName + "'.");
				return false;
			}
			DeliveryShop val4 = InactiveObjectCloner.CloneComponent<DeliveryShop>(val3.Shop, ((Component)val3.Shop).transform.parent);
			Button val5 = InactiveObjectCloner.CloneComponent<Button>(val3.Button, ((Component)val3.Button).transform.parent);
			ResetShopState(val4);
			((UnityEventBase)val5.onClick).RemoveAllListeners();
			((Object)((Component)val4).gameObject).name = "S1API_" + SupplierRuntimeIds.Sanitize(shop.ShopName) + "_DeliveryShop";
			val4.MatchingShopInterfaceName = shop.ShopName;
			val4.AvailableByDefault = available;
			((Object)((Component)val5).gameObject).name = "S1API_" + SupplierRuntimeIds.Sanitize(shop.ShopName) + "_DeliveryButton";
			Text componentInChildren = ((Component)val5).GetComponentInChildren<Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = (((Object)(object)shop.StoreNameLabel != (Object)null) ? ((TMP_Text)shop.StoreNameLabel).text : shop.ShopName);
			}
			DeliveryShopElement val6 = new DeliveryShopElement
			{
				Shop = val4,
				Button = val5
			};
			val.Add(val6);
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "deliveryShops") is List<DeliveryShop> val7)
			{
				val7.Add(val4);
			}
			Registrations[instanceID] = new DeliveryRegistration(app, val6);
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "started");
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = 1;
			}
			else
			{
				num = 0;
			}
			if (((uint)num & (flag ? 1u : 0u)) != 0)
			{
				InitializeElement(app, val6);
			}
			((Component)val5).gameObject.SetActive(available);
			SupplierDeliveryStatusDisplayRecovery.OnShopReady(app, shop.ShopName);
			return true;
		}

		internal static void OnVehicleBound(ShopInterface shop)
		{
			if ((Object)(object)shop == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)shop).GetInstanceID();
			if (Pending.TryGetValue(instanceID, out PendingAvailability value))
			{
				Pending.Remove(instanceID);
				if (!EnsureEntry(value.App, value.Shop, value.Available))
				{
					Logger.Warning("Delivery UI could not be provisioned for custom supplier shop '" + shop.ShopName + "'.");
				}
			}
		}

		internal static void CleanupShop(ShopInterface? shop)
		{
			if (!((Object)(object)shop == (Object)null))
			{
				int instanceID = ((Object)shop).GetInstanceID();
				Pending.Remove(instanceID);
				if (Registrations.TryGetValue(instanceID, out DeliveryRegistration value))
				{
					DestroyRegistration(value, removeFromApp: true);
					Registrations.Remove(instanceID);
				}
			}
		}

		internal static void CleanupForSceneChange()
		{
			DeliveryRegistration[] array = Registrations.Values.ToArray();
			foreach (DeliveryRegistration registration in array)
			{
				DestroyRegistration(registration, removeFromApp: false);
			}
			Registrations.Clear();
			Pending.Clear();
		}

		private static DeliveryShopElement? FindDonor(List<DeliveryShopElement> elements)
		{
			for (int i = 0; i < elements.Count; i++)
			{
				DeliveryShopElement val = elements[i];
				if ((Object)(object)((val != null) ? val.Shop : null) != (Object)null && (Object)(object)val.Button != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static void InitializeElement(DeliveryApp app, DeliveryShopElement element)
		{
			((UnityEvent)element.Button.onClick).AddListener(UnityAction.op_Implicit((Action)delegate
			{
				app.OpenShop(element.Shop);
			}));
			Action<DeliveryShop> val = DelegateSupport.ConvertDelegate<Action<DeliveryShop>>((Delegate)new Action<DeliveryShop>(app.CloseShop));
			element.Shop.OnSelect = ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)element.Shop.OnSelect, (Delegate)(object)val)).Cast<Action<DeliveryShop>>();
			element.Shop.Initialize();
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(app, "_deliveryScreen");
			if (obj == null)
			{
				return;
			}
			MethodInfo method = global::S1API.Internal.Utils.ReflectionUtils.GetMethod(obj.GetType(), "AddPanel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(method == null))
			{
				Enumerator<UIPanel> enumerator = element.Shop.Panels.GetEnumerator();
				while (enumerator.MoveNext())
				{
					UIPanel current = enumerator.Current;
					method.Invoke(obj, new object[1] { current });
				}
			}
		}

		private static void ResetShopState(DeliveryShop shop)
		{
			if ((Object)(object)shop.ListingContainer != (Object)null)
			{
				for (int num = ((Transform)shop.ListingContainer).childCount - 1; num >= 0; num--)
				{
					Transform child = ((Transform)shop.ListingContainer).GetChild(num);
					if (!((Object)(object)shop.ListingEntryPrefab != (Object)null) || !((Object)(object)((Component)child).gameObject == (Object)(object)((Component)shop.ListingEntryPrefab).gameObject))
					{
						Object.DestroyImmediate((Object)(object)((Component)child).gameObject);
					}
				}
			}
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "listingEntries", new List<ListingEntry>());
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "MatchingShop", null);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "IsOpen", false);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "destinationProperty", null);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(shop, "loadingDockIndex", 0);
			shop.OnSelect = null;
			Button backButton = shop.BackButton;
			if (backButton != null)
			{
				((UnityEventBase)backButton.onClick).RemoveAllListeners();
			}
			Button orderButton = shop.OrderButton;
			if (orderButton != null)
			{
				((UnityEventBase)orderButton.onClick).RemoveAllListeners();
			}
			Dropdown destinationDropdown = shop.DestinationDropdown;
			if (destinationDropdown != null)
			{
				((UnityEventBase)destinationDropdown.onValueChanged).RemoveAllListeners();
			}
			Dropdown loadingDockDropdown = shop.LoadingDockDropdown;
			if (loadingDockDropdown != null)
			{
				((UnityEventBase)loadingDockDropdown.onValueChanged).RemoveAllListeners();
			}
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(shop, "_entriesPanel");
			global::S1API.Internal.Utils.ReflectionUtils.GetMethod(obj?.GetType(), "ClearAllSelectables", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.Invoke(obj, null);
		}

		private static void DestroyRegistration(DeliveryRegistration registration, bool removeFromApp)
		{
			if (removeFromApp && (Object)(object)registration.App != (Object)null)
			{
				if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(registration.App, "_shopElements") is List<DeliveryShopElement> val)
				{
					val.Remove(registration.Element);
				}
				List<DeliveryShop> val2 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(registration.App, "deliveryShops") as List<DeliveryShop>;
				DeliveryShopElement element = registration.Element;
				if ((Object)(object)((element != null) ? element.Shop : null) != (Object)null)
				{
					val2?.Remove(registration.Element.Shop);
				}
			}
			DeliveryShopElement element2 = registration.Element;
			if ((Object)(object)((element2 != null) ? element2.Button : null) != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)registration.Element.Button).gameObject);
			}
			DeliveryShopElement element3 = registration.Element;
			if ((Object)(object)((element3 != null) ? element3.Shop : null) != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)registration.Element.Shop).gameObject);
			}
		}
	}
	internal static class SupplierDeliveryVehicleRuntime
	{
		private const string VehicleCode = "veeper";

		private static readonly Log Logger = new Log("SupplierDeliveryVehicleRuntime");

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

		private static readonly Dictionary<string, NetworkObject> Prefabs = new Dictionary<string, NetworkObject>(StringComparer.Ordinal);

		private static readonly Dictionary<int, GameObject> OwnedVehicles = new Dictionary<int, GameObject>();

		private static readonly HashSet<int> ScheduledBindings = new HashSet<int>();

		internal static bool PrefabsReadyForLocalProcess
		{
			get
			{
				if (RegisteredSupplierIds.Count == 0)
				{
					return true;
				}
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				PrefabObjects val = ((networkManager != null) ? networkManager.SpawnablePrefabs : null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				foreach (string registeredSupplierId in RegisteredSupplierIds)
				{
					if (!Prefabs.TryGetValue(registeredSupplierId, out NetworkObject value) || (Object)(object)value == (Object)null || !IsRegistered(value))
					{
						return false;
					}
				}
				return true;
			}
		}

		internal static bool RegisterSupplier(GameObject prefabRoot, string? explicitId = null)
		{
			string text = SupplierRuntimeIds.ResolveStableId(prefabRoot, explicitId);
			RegisteredSupplierIds.Add(text);
			return EnsurePrefab(text);
		}

		internal static bool EnsureAllPrefabsRegistered()
		{
			bool flag = true;
			foreach (string item in RegisteredSupplierIds.OrderBy<string, string>((string value) => value, StringComparer.Ordinal))
			{
				flag &= EnsurePrefab(item);
			}
			return flag;
		}

		internal static bool Ensure(Supplier supplier, ShopInterface shop, string stableId)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			RegisteredSupplierIds.Add(stableId);
			if (TryBind(supplier, shop, stableId))
			{
				return true;
			}
			shop.DeliveryVehicle = null;
			if (!EnsurePrefab(stableId))
			{
				Logger.Error("Custom supplier '" + ((NPC)supplier).ID + "' cannot start because its delivery vehicle prefab is unavailable.");
				return false;
			}
			if (!InstanceFinder.IsServer)
			{
				ScheduleBinding(supplier, shop, stableId);
				return true;
			}
			try
			{
				NetworkObject val = Prefabs[stableId];
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject);
				((Object)val2).name = ((Object)((Component)val).gameObject).name + "_Runtime";
				val2.transform.SetParent((Transform)null, false);
				val2.transform.position = new Vector3(0f, -100f, 0f);
				val2.transform.rotation = Quaternion.identity;
				val2.SetActive(true);
				NetworkObject val3 = val2.GetComponent<NetworkObject>() ?? throw new InvalidOperationException("Spawned delivery vehicle has no NetworkObject.");
				DeliveryVehicle deliveryVehicle = val2.GetComponent<DeliveryVehicle>() ?? throw new InvalidOperationException("Spawned delivery vehicle has no DeliveryVehicle component.");
				InstanceFinder.ServerManager.Spawn(val3, (NetworkConnection)null, default(Scene));
				Bind(supplier, shop, deliveryVehicle);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to spawn the delivery vehicle for supplier '" + ((NPC)supplier).ID + "': " + ex.Message);
				return false;
			}
		}

		internal static bool IsKnownGuid(string? guid)
		{
			if (string.IsNullOrWhiteSpace(guid))
			{
				return false;
			}
			foreach (string registeredSupplierId in RegisteredSupplierIds)
			{
				if (string.Equals(SupplierRuntimeIds.GetDeliveryVehicleGuid(registeredSupplierId).ToString(), guid, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static DeliveryVehicle? FindByGuid(string guid)
		{
			return ((IEnumerable<DeliveryVehicle>)Resources.FindObjectsOfTypeAll<DeliveryVehicle>()).FirstOrDefault((Func<DeliveryVehicle, bool>)((DeliveryVehicle candidate) => (Object)(object)candidate != (Object)null && string.Equals(candidate.GUID, guid, StringComparison.OrdinalIgnoreCase)));
		}

		internal static void CleanupSupplier(Supplier supplier)
		{
			if (!((Object)(object)supplier == (Object)null))
			{
				int instanceID = ((Object)supplier).GetInstanceID();
				ScheduledBindings.Remove(instanceID);
				if (OwnedVehicles.TryGetValue(instanceID, out GameObject value))
				{
					DestroyVehicle(value);
					OwnedVehicles.Remove(instanceID);
				}
			}
		}

		internal static void CleanupForSceneChange()
		{
			GameObject[] array = OwnedVehicles.Values.ToArray();
			foreach (GameObject vehicleObject in array)
			{
				DestroyVehicle(vehicleObject);
			}
			OwnedVehicles.Clear();
			ScheduledBindings.Clear();
		}

		private static bool EnsurePrefab(string stableId)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (Prefabs.TryGetValue(stableId, out NetworkObject value) && (Object)(object)value != (Object)null)
			{
				return EnsureRegistered(value);
			}
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			if ((Object)(object)((networkManager != null) ? networkManager.SpawnablePrefabs : null) == (Object)null)
			{
				return false;
			}
			VehicleManager val = null;
			try
			{
				val = NetworkSingleton<VehicleManager>.Instance;
			}
			catch
			{
			}
			LandVehicle val2 = ((val != null) ? val.GetVehiclePrefab("veeper") : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).gameObject == (Object)null)
			{
				return false;
			}
			GameObject val3 = null;
			try
			{
				val3 = InactiveObjectCloner.CloneGameObject(((Component)val2).gameObject);
				((Object)val3).name = SupplierRuntimeIds.GetDeliveryVehiclePrefabName(stableId);
				val3.transform.position = new Vector3(0f, -100f, 0f);
				val3.transform.rotation = Quaternion.identity;
				DeliveryVehicle val4 = val3.GetComponent<DeliveryVehicle>() ?? val3.AddComponent<DeliveryVehicle>();
				val4.GUID = SupplierRuntimeIds.GetDeliveryVehicleGuid(stableId).ToString();
				NetworkObject val5 = val3.GetComponent<NetworkObject>() ?? throw new InvalidOperationException("Vehicle prefab '" + val2.VehicleCode + "' has no FishNet NetworkObject.");
				NPCPrefabContainer.OrganizePrefab(val3, SupplierRuntimeIds.Sanitize(stableId) + "_SupplierDeliveryVehicle");
				if (!EnsureRegistered(val5))
				{
					throw new InvalidOperationException("FishNet rejected the custom delivery vehicle prefab.");
				}
				Prefabs[stableId] = val5;
				return true;
			}
			catch (Exception ex)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)val3);
				}
				Logger.Warning("Could not prepare the delivery vehicle prefab for supplier '" + stableId + "': " + ex.Message);
				return false;
			}
		}

		private static bool EnsureRegistered(NetworkObject networkObject)
		{
			if ((Object)(object)networkObject == (Object)null || (Object)(object)((Component)networkObject).gameObject == (Object)null)
			{
				return false;
			}
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			PrefabObjects val = ((networkManager != null) ? networkManager.SpawnablePrefabs : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			if (IsRegistered(networkObject))
			{
				return true;
			}
			val.AddObject(networkObject, false);
			return true;
		}

		private static bool IsRegistered(NetworkObject networkObject)
		{
			NetworkManager networkManager = InstanceFinder.NetworkManager;
			PrefabObjects val = ((networkManager != null) ? networkManager.SpawnablePrefabs : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			int objectCount = val.GetObjectCount();
			for (int i = 0; i < objectCount; i++)
			{
				NetworkObject val2 = val.GetObject(true, i);
				if ((Object)(object)val2 == (Object)(object)networkObject || ((Object)(object)((val2 != null) ? ((Component)val2).gameObject : null) != (Object)null && string.Equals(((Object)((Component)val2).gameObject).name, ((Object)((Component)networkObject).gameObject).name, StringComparison.Ordinal)))
				{
					return true;
				}
			}
			return false;
		}

		private static bool TryBind(Supplier supplier, ShopInterface shop, string stableId)
		{
			string expectedGuid = SupplierRuntimeIds.GetDeliveryVehicleGuid(stableId).ToString();
			if ((Object)(object)shop.DeliveryVehicle != (Object)null && IsSpawnedMatch(shop.DeliveryVehicle, expectedGuid))
			{
				Bind(supplier, shop, shop.DeliveryVehicle);
				return true;
			}
			DeliveryVehicle val = ((IEnumerable<DeliveryVehicle>)Resources.FindObjectsOfTypeAll<DeliveryVehicle>()).FirstOrDefault((Func<DeliveryVehicle, bool>)((DeliveryVehicle candidate) => IsSpawnedMatch(candidate, expectedGuid)));
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			Bind(supplier, shop, val);
			return true;
		}

		private static bool IsSpawnedMatch(DeliveryVehicle? deliveryVehicle, string expectedGuid)
		{
			if ((Object)(object)deliveryVehicle == (Object)null || !string.Equals(deliveryVehicle.GUID, expectedGuid, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			NetworkObject component = ((Component)deliveryVehicle).GetComponent<NetworkObject>();
			return (Object)(object)component != (Object)null && component.IsSpawned;
		}

		private static void Bind(Supplier supplier, ShopInterface shop, DeliveryVehicle deliveryVehicle)
		{
			shop.DeliveryVehicle = deliveryVehicle;
			OwnedVehicles[((Object)supplier).GetInstanceID()] = ((Component)deliveryVehicle).gameObject;
			SupplierDeliveryRecovery.OnVehicleBound(shop, deliveryVehicle);
			SupplierDeliveryUiBridge.OnVehicleBound(shop);
		}

		private static void ScheduleBinding(Supplier supplier, ShopInterface shop, string stableId)
		{
			int instanceID = ((Object)supplier).GetInstanceID();
			if (ScheduledBindings.Add(instanceID))
			{
				MelonCoroutines.Start(BindWhenSpawned(supplier, shop, stableId, instanceID));
			}
		}

		private static IEnumerator BindWhenSpawned(Supplier supplier, ShopInterface shop, string stableId, int supplierKey)
		{
			float deadline = Time.realtimeSinceStartup + 30f;
			try
			{
				while (true)
				{
					if ((Object)(object)supplier != (Object)null && (Object)(object)shop != (Object)null && Time.realtimeSinceStartup < deadline)
					{
						if (!TryBind(supplier, shop, stableId))
						{
							yield return null;
							continue;
						}
						break;
					}
					if ((Object)(object)supplier != (Object)null)
					{
						Logger.Error("Timed out waiting for the delivery vehicle for supplier '" + ((NPC)supplier).ID + "'.");
					}
					break;
				}
			}
			finally
			{
				ScheduledBindings.Remove(supplierKey);
			}
		}

		private static void DestroyVehicle(GameObject vehicleObject)
		{
			if ((Object)(object)vehicleObject == (Object)null)
			{
				return;
			}
			NetworkObject component = vehicleObject.GetComponent<NetworkObject>();
			if ((Object)(object)component != (Object)null && component.IsSpawned && !InstanceFinder.IsServer)
			{
				return;
			}
			DeliveryVehicle component2 = vehicleObject.GetComponent<DeliveryVehicle>();
			try
			{
				if (component2 != null)
				{
					component2.Deactivate();
				}
			}
			catch
			{
			}
			LandVehicle val = ((component2 != null) ? component2.Vehicle : null) ?? vehicleObject.GetComponent<LandVehicle>();
			if ((Object)(object)val != (Object)null)
			{
				try
				{
					if (CrossType.Is<IGUIDRegisterable>((object)val, out IGUIDRegisterable result))
					{
						GUIDManager.DeregisterObject(result);
					}
				}
				catch
				{
				}
			}
			if ((Object)(object)component != (Object)null && component.IsSpawned)
			{
				try
				{
					ServerManager serverManager = InstanceFinder.ServerManager;
					if (serverManager != null && serverManager.Started)
					{
						component.Despawn((Nullable<DespawnType>)null);
						return;
					}
				}
				catch
				{
				}
			}
			Object.Destroy((Object)(object)vehicleObject);
		}
	}
}
namespace S1API.Internal.Cutscenes
{
	internal sealed class CutsceneConfiguration
	{
		internal string Id { get; }

		internal string Name { get; }

		internal float Duration { get; }

		internal float? Fov { get; }

		internal Vector3 InitialPosition { get; }

		internal Quaternion InitialRotation { get; }

		internal Action<CutsceneFrame>? CameraUpdate { get; }

		internal Action? Started { get; }

		internal Action<CutsceneEndReason>? Ended { get; }

		internal float FadeInDuration { get; }

		internal float FadeInDelay { get; }

		internal float FadeOutDuration { get; }

		internal float HoldToSkipDuration { get; }

		internal string? TitleCardText { get; }

		internal float TitleCardDuration { get; }

		internal CutsceneConfiguration(string id, string name, float duration, float? fov, Vector3 initialPosition, Quaternion initialRotation, Action<CutsceneFrame>? cameraUpdate, Action? started, Action<CutsceneEndReason>? ended, float fadeInDuration, float fadeInDelay, float fadeOutDuration, float holdToSkipDuration, string? titleCardText, float titleCardDuration)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Id = id;
			Name = name;
			Duration = duration;
			Fov = fov;
			InitialPosition = initialPosition;
			InitialRotation = initialRotation;
			CameraUpdate = cameraUpdate;
			Started = started;
			Ended = ended;
			FadeInDuration = fadeInDuration;
			FadeInDelay = fadeInDelay;
			FadeOutDuration = fadeOutDuration;
			HoldToSkipDuration = holdToSkipDuration;
			TitleCardText = titleCardText;
			TitleCardDuration = titleCardDuration;
		}
	}
	internal sealed class CutscenePresentationRuntime
	{
		private readonly CutsceneConfiguration _configuration;

		private float _holdElapsed;

		private float _titleAlpha;

		private bool _fadeInStarted;

		private bool _fadeOutStarted;

		private bool _ownsBlackOverlay;

		private GUIStyle? _titleStyle;

		private GUIStyle? _skipStyle;

		internal CutscenePresentationRuntime(CutsceneConfiguration configuration)
		{
			_configuration = configuration;
		}

		internal void Begin()
		{
			if (_configuration.FadeInDuration > 0f && TryOpenBlackOverlay(0f) && _configuration.FadeInDelay <= 0f)
			{
				_fadeInStarted = true;
				CloseOwnedBlackOverlay(_configuration.FadeInDuration);
			}
		}

		internal bool Tick(float deltaTime, float elapsed)
		{
			UpdateFadeIn(elapsed);
			UpdateTitle(elapsed);
			UpdateFadeOut(elapsed);
			if (_configuration.HoldToSkipDuration <= 0f)
			{
				return false;
			}
			if (!IsSkipHeld())
			{
				_holdElapsed = 0f;
				return false;
			}
			_holdElapsed = Math.Min(_configuration.HoldToSkipDuration, _holdElapsed + Math.Max(0f, deltaTime));
			return _holdElapsed >= _configuration.HoldToSkipDuration;
		}

		internal void Draw()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			if (!(_titleAlpha <= 0f) || !(_configuration.HoldToSkipDuration <= 0f))
			{
				EnsureStyles();
				Color color = GUI.color;
				float num = Screen.width;
				float num2 = Screen.height;
				if (_titleAlpha > 0f && _configuration.TitleCardText != null)
				{
					GUI.color = new Color(1f, 1f, 1f, _titleAlpha);
					GUI.Label(new Rect(0f, num2 * 0.44f, num, 64f), _configuration.TitleCardText, _titleStyle);
				}
				if (_configuration.HoldToSkipDuration > 0f)
				{
					float num3 = Math.Min(1f, _holdElapsed / _configuration.HoldToSkipDuration);
					Rect val = default(Rect);
					((Rect)(ref val))..ctor(num - 310f, num2 - 82f, 270f, 28f);
					GUI.color = Color.white;
					GUI.Label(val, "HOLD PRIMARY CLICK TO SKIP", _skipStyle);
					int num4 = (int)Math.Round(num3 * 24f);
					string text = "[" + new string('#', num4) + new string('-', 24 - num4) + "]";
					GUI.Label(new Rect(((Rect)(ref val)).x, ((Rect)(ref val)).yMax + 2f, ((Rect)(ref val)).width, 20f), text, _skipStyle);
				}
				GUI.color = color;
			}
		}

		internal void End(CutsceneEndReason reason)
		{
			float duration = ((reason == CutsceneEndReason.Completed) ? _configuration.FadeOutDuration : 0f);
			CloseOwnedBlackOverlay(duration);
			_holdElapsed = 0f;
			_titleAlpha = 0f;
		}

		private void UpdateTitle(float elapsed)
		{
			if (_configuration.TitleCardText == null || elapsed >= _configuration.TitleCardDuration)
			{
				_titleAlpha = 0f;
				return;
			}
			float num = Math.Min(0.35f, _configuration.TitleCardDuration / 3f);
			float val = Math.Min(1f, elapsed / num);
			float val2 = Math.Min(1f, (_configuration.TitleCardDuration - elapsed) / num);
			_titleAlpha = Math.Min(val, val2);
		}

		private void UpdateFadeIn(float elapsed)
		{
			if (!_fadeInStarted && !(_configuration.FadeInDuration <= 0f) && !(elapsed < _configuration.FadeInDelay))
			{
				_fadeInStarted = true;
				CloseOwnedBlackOverlay(_configuration.FadeInDuration);
			}
		}

		private void UpdateFadeOut(float elapsed)
		{
			if (!_fadeOutStarted && !(_configuration.FadeOutDuration <= 0f) && !(elapsed < _configuration.Duration - _configuration.FadeOutDuration))
			{
				_fadeOutStarted = true;
				TryOpenBlackOverlay(_configuration.FadeOutDuration);
			}
		}

		private bool TryOpenBlackOverlay(float duration)
		{
			try
			{
				if (!Singleton<BlackOverlay>.InstanceExists)
				{
					return false;
				}
				BlackOverlay instance = Singleton<BlackOverlay>.Instance;
				if (instance.isShown)
				{
					return false;
				}
				_ownsBlackOverlay = true;
				instance.Open(duration);
				return true;
			}
			catch
			{
				_ownsBlackOverlay = false;
				return false;
			}
		}

		private void CloseOwnedBlackOverlay(float duration)
		{
			if (!_ownsBlackOverlay)
			{
				return;
			}
			try
			{
				if (Singleton<BlackOverlay>.InstanceExists)
				{
					Singleton<BlackOverlay>.Instance.Close(duration);
				}
			}
			catch
			{
			}
			finally
			{
				_ownsBlackOverlay = false;
			}
		}

		private static bool IsSkipHeld()
		{
			try
			{
				return GameInput.GetButton((ButtonCode)0);
			}
			catch
			{
				return false;
			}
		}

		private void EnsureStyles()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_0042: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (_titleStyle == null)
			{
				_titleStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)4,
					fontSize = 32,
					fontStyle = (FontStyle)1
				};
				_titleStyle.normal.textColor = Color.white;
				_skipStyle = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)5,
					fontSize = 14,
					fontStyle = (FontStyle)1
				};
				_skipStyle.normal.textColor = Color.white;
			}
		}
	}
	internal sealed class NativeCutsceneAdapter
	{
		private static readonly Log Logger = new Log("Cutscenes");

		private GameObject? _host;

		private GameObject? _cameraControlObject;

		private Cutscene? _cutscene;

		private string? _nativeStateName;

		internal bool TryBegin(string id, string name, Vector3 initialPosition, Quaternion initialRotation, float? fov, out CutsceneCamera? camera)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0047: 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)
			camera = null;
			try
			{
				_host = new GameObject("S1API_Cutscene_" + SanitizeName(id));
				_cameraControlObject = new GameObject("S1API_CutsceneCamera_" + SanitizeName(id));
				_cameraControlObject.transform.SetPositionAndRotation(initialPosition, initialRotation);
				_cutscene = _host.AddComponent<Cutscene>();
				_cutscene.Name = name;
				_cutscene.CameraControl = _cameraControlObject.transform;
				_cutscene.OverrideFOV = fov.HasValue;
				if (fov.HasValue)
				{
					_cutscene.CameraFOV = fov.Value;
				}
				_nativeStateName = "Cutscene (" + name + ")";
				_cutscene.Play();
				if (!_cutscene.IsPlaying)
				{
					throw new InvalidOperationException("The native cutscene did not enter its playing state.");
				}
				camera = new CutsceneCamera(_cameraControlObject.transform);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning($"Could not start cutscene '{id}': {ex.GetType().Name}: {ex.Message}");
				TryEnd(out Exception _);
				return false;
			}
		}

		internal bool TryEnd(out Exception? exception)
		{
			exception = null;
			try
			{
				if ((Object)(object)_cutscene != (Object)null && _cutscene.IsPlaying)
				{
					_cutscene.InvokeEnd();
				}
			}
			catch (Exception ex)
			{
				exception = ex;
				TryForceCameraRestore();
			}
			finally
			{
				if ((Object)(object)_host != (Object)null)
				{
					Object.Destroy((Object)(object)_host);
				}
				if ((Object)(object)_cameraControlObject != (Object)null)
				{
					Object.Destroy((Object)(object)_cameraControlObject);
				}
				_cutscene = null;
				_host = null;
				_cameraControlObject = null;
				_nativeStateName = null;
			}
			return exception == null;
		}

		private void TryForceCameraRestore()
		{
			try
			{
				if (PlayerSingleton<PlayerCamera>.InstanceExists)
				{
					PlayerCamera instance = PlayerSingleton<PlayerCamera>.Instance;
					if (!string.IsNullOrEmpty(_nativeStateName))
					{
						instance.RemoveActiveUIElement(_nativeStateName);
					}
					instance.StopTransformOverride(0f, true, false);
					instance.StopFOVOverride(0f);
				}
			}
			catch
			{
			}
		}

		private static string SanitizeName(string value)
		{
			char[] array = value.ToCharArray();
			for (int i = 0; i < array.Length; i++)
			{
				if (!char.IsLetterOrDigit(array[i]) && array[i] != '_' && array[i] != '-')
				{
					array[i] = '_';
				}
			}
			return new string(array);
		}
	}
}
namespace S1API.Internal.Console
{
	internal static class ConsoleItemAliasRegistry
	{
		private static readonly object Gate = new object();

		private static readonly Dictionary<string, string> Aliases = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		internal static void Register(string alias, string canonicalItemId, Func<string, bool> itemExists)
		{
			if (itemExists == null)
			{
				throw new ArgumentNullException("itemExists");
			}
			string text = NormalizeAlias(alias);
			string text2 = NormalizeCanonicalItemId(canonicalItemId);
			lock (Gate)
			{
				if (IsIdempotentOrThrow(text, text2))
				{
					return;
				}
			}
			if (!itemExists(text2))
			{
				throw new ArgumentException("Canonical item ID '" + text2 + "' is not registered. Register the item before its console alias.", "canonicalItemId");
			}
			if (itemExists(text))
			{
				throw new InvalidOperationException("Console item alias '" + text + "' is already a native or canonical item ID and cannot be shadowed.");
			}
			lock (Gate)
			{
				if (!IsIdempotentOrThrow(text, text2))
				{
					Aliases.Add(text, text2);
				}
			}
		}

		internal static bool TryResolveForGive(string itemCode, Func<string, bool> itemExists, out string canonicalItemId)
		{
			canonicalItemId = string.Empty;
			if (string.IsNullOrWhiteSpace(itemCode) || itemExists == null)
			{
				return false;
			}
			string text = itemCode.Trim();
			if (itemExists(text))
			{
				return false;
			}
			string value;
			lock (Gate)
			{
				if (!Aliases.TryGetValue(text, out value))
				{
					return false;
				}
			}
			if (value == null || !itemExists(value))
			{
				return false;
			}
			canonicalItemId = value;
			return true;
		}

		internal static string ResolveItemCodeForGive(string itemCode, Func<string, bool> itemExists)
		{
			string canonicalItemId;
			return TryResolveForGive(itemCode, itemExists, out canonicalItemId) ? canonicalItemId : itemCode;
		}

		internal static void ResetForTesting()
		{
			lock (Gate)
			{
				Aliases.Clear();
			}
		}

		private static string NormalizeAlias(string alias)
		{
			if (alias == null)
			{
				throw new ArgumentNullException("alias");
			}
			string text = alias.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Console item aliases cannot be empty or whitespace.", "alias");
			}
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				if (!IsAsciiLetterOrDigit(c) && c != '.' && c != '_' && c != '-')
				{
					throw new ArgumentException($"Console item alias contains invalid character '{c}' at position {i}. Use ASCII letters, " + "digits, '.', '_', or '-'; aliases do not include a namespace.", "alias");
				}
			}
			return text;
		}

		private static bool IsIdempotentOrThrow(string alias, string canonicalItemId)
		{
			if (!Aliases.TryGetValue(alias, out string value))
			{
				return false;
			}
			if (string.Equals(value, canonicalItemId, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			throw new InvalidOperationException($"Console item alias '{alias}' is already registered for '{value}' and cannot also target '{canonicalItemId}'.");
		}

		private static string NormalizeCanonicalItemId(string canonicalItemId)
		{
			if (canonicalItemId == null)
			{
				throw new ArgumentNullException("canonicalItemId");
			}
			string text = canonicalItemId.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Canonical item IDs cannot be empty or whitespace.", "canonicalItemId");
			}
			return text;
		}

		private static bool IsAsciiLetterOrDigit(char character)
		{
			return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9');
		}
	}
	internal sealed class PresentationWorkbenchCommand : BaseConsoleCommand
	{
		private static readonly Log Logger = new Log("PresentationWorkbench");

		public override string CommandWord => "presentationworkbench";

		public override string CommandDescription => "Open the local icon and equippable presentation authoring workbench.";

		public override string ExampleUsage => "presentationworkbench [product|item] <id> | close";

		public override void ExecuteCommand(List<string> args)
		{
			if (args == null || args.Count == 0)
			{
				Logger.Msg("Usage: " + ExampleUsage);
				return;
			}
			string text = args[0]?.Trim() ?? string.Empty;
			if (text.Equals("close", StringComparison.OrdinalIgnoreCase))
			{
				PresentationWorkbenchRuntime.Close();
				Logger.Msg("Presentation workbench closed.");
				return;
			}
			string targetKind = null;
			string text2 = text;
			if (PresentationWorkbenchResolver.IsTargetKind(text))
			{
				if (args.Count != 2 || string.IsNullOrWhiteSpace(args[1]))
				{
					Logger.Msg("Usage: " + ExampleUsage);
					return;
				}
				targetKind = text;
				text2 = args[1].Trim();
			}
			else if (args.Count != 1)
			{
				Logger.Msg("Usage: " + ExampleUsage);
				return;
			}
			if (!PresentationWorkbenchRuntime.Open(text2, targetKind))
			{
				Logger.Warning("Could not open presentation workbench target '" + text2 + "'.");
			}
		}
	}
}
namespace S1API.Internal.Abstraction
{
	[Obsolete("Use S1API.Utils.EventHelper instead. This compatibility type will be hidden from public usage in a future update.")]
	public static class EventHelper
	{
		private static readonly Dictionary<Action, Delegate> SubscribedActions = new Dictionary<Action, Delegate>();

		private static readonly Dictionary<Delegate, Delegate> SubscribedGenericActions = new Dictionary<Delegate, Delegate>();

		internal static void AddListener(Action listener, Action<Action> subscribe)
		{
			if (!SubscribedActions.ContainsKey(listener))
			{
				subscribe(listener);
				SubscribedActions.Add(listener, listener);
			}
		}

		internal static void RemoveListener(Action listener, Action<Action> unsubscribe)
		{
			if (SubscribedActions.ContainsKey(listener))
			{
				unsubscribe(listener);
				SubscribedActions.Remove(listener);
			}
		}

		public static void AddListener(Action listener, UnityEvent unityEvent)
		{
			if (listener != null && unityEvent != null && !SubscribedActions.ContainsKey(listener))
			{
				Action action = listener.Invoke;
				unityEvent.AddListener(UnityAction.op_Implicit(action));
				SubscribedActions.Add(listener, action);
			}
		}

		public static void RemoveListener(Action listener, UnityEvent unityEvent)
		{
			if (listener != null && unityEvent != null)
			{
				SubscribedActions.TryGetValue(listener, out Delegate value);
				SubscribedActions.Remove(listener);
				if ((object)value != null && value is Action action)
				{
					unityEvent.RemoveListener(UnityAction.op_Implicit(action));
				}
			}
		}

		public static void AddListener<T>(Action<T> listener, UnityEvent<T> unityEvent)
		{
			if (listener != null && unityEvent != null && !SubscribedGenericActions.ContainsKey(listener))
			{
				Action<T> action = listener.Invoke;
				unityEvent.AddListener(UnityAction<T>.op_Implicit(action));
				SubscribedGenericActions.Add(listener, action);
			}
		}

		public static void RemoveListener<T>(Action<T> listener, UnityEvent<T> unityEvent)
		{
			if (listener != null && unityEvent != null && SubscribedGenericActions.TryGetValue(listener, out Delegate value) && (object)value != null)
			{
				if (value is Action<T> action)
				{
					unityEvent.RemoveListener(UnityAction<T>.op_Implicit(action));
				}
				SubscribedGenericActions.Remove(listener);
			}
		}

		public static void AddEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action listener)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)trigger == (Object)null) && listener != null)
			{
				AddEventTrigger(trigger, eventType, (Action<BaseEventData>)delegate
				{
					listener();
				});
			}
		}

		public static void AddEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action<BaseEventData> listener)
		{
			//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_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			if (!((Object)(object)trigger == (Object)null) && listener != null)
			{
				Entry val = new Entry
				{
					eventID = eventType
				};
				AddListener(listener, (UnityEvent<BaseEventData>)(object)val.callback);
				trigger.triggers.Add(val);
			}
		}

		public static void RemoveEventTrigger(EventTrigger trigger, EventTriggerType eventType, Action<BaseEventData> listener)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)trigger == (Object)null) && listener != null && SubscribedGenericActions.ContainsKey(listener))
			{
				Entry val = ((IEnumerable<Entry>)trigger.triggers._items).FirstOrDefault((Func<Entry, bool>)((Entry candidate) => candidate.eventID == eventType));
				if (val != null)
				{
					RemoveListener(listener, (UnityEvent<BaseEventData>)(object)val.callback);
					trigger.triggers.Remove(val);
				}
			}
		}
	}
	internal class GUIDReferenceConverter : JsonConverter
	{
		public override bool CanRead => true;

		public override bool CanConvert(Type objectType)
		{
			return typeof(IGUIDReference).IsAssignableFrom(objectType);
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (value is IGUIDReference iGUIDReference)
			{
				writer.WriteValue(iGUIDReference.GUID);
			}
			else
			{
				writer.WriteNull();
			}
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			string text = reader.Value?.ToString();
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			MethodInfo method = global::S1API.Internal.Utils.ReflectionUtils.GetMethod(objectType, "GetFromGUID", BindingFlags.Static | BindingFlags.NonPublic);
			if (method == null)
			{
				throw new Exception("The type " + objectType.Name + " does not have a valid implementation of the GetFromGUID(string guid) method!");
			}
			return method.Invoke(null, new object[1] { text });
		}
	}
	internal interface IGUIDReference
	{
		string GUID { get; }
	}
	internal interface IRegisterable
	{
		void CreateInternal();

		void DestroyInternal();

		void OnCreated();

		void OnDestroyed();
	}
	internal interface ISaveable : IRegisterable
	{
		internal static JsonSerializerSettings SerializerSettings => new JsonSerializerSettings
		{
			ReferenceLoopHandling = (ReferenceLoopHandling)1,
			Converters = new List<JsonConverter> { (JsonConverter)(object)new GUIDReferenceConverter() }
		};

		void SaveInternal(string path, ref List<string> extraSaveables);

		void LoadInternal(string folderPath);

		void OnSaved();

		void OnLoaded();
	}
	public abstract class Registerable : IRegisterable
	{
		void IRegisterable.CreateInternal()
		{
			CreateInternal();
		}

		internal virtual void CreateInternal()
		{
			OnCreated();
		}

		void IRegisterable.DestroyInternal()
		{
			DestroyInternal();
		}

		internal virtual void DestroyInternal()
		{
			OnDestroyed();
		}

		void IRegisterable.OnCreated()
		{
			OnCreated();
		}

		protected virtual void OnCreated()
		{
		}

		void IRegisterable.OnDestroyed()
		{
			OnDestroyed();
		}

		protected virtual void OnDestroyed()
		{
		}
	}
	public abstract class Saveable : Registerable, ISaveable, IRegisterable
	{
		public virtual SaveableLoadOrder LoadOrder => SaveableLoadOrder.AfterBaseGame;

		public static bool RequestGameSave(bool immediate)
		{
			return RequestGameSave();
		}

		public static bool RequestGameSave()
		{
			try
			{
				LoadManager instance = Singleton<LoadManager>.Instance;
				if ((Object)(object)instance == (Object)null || !instance.IsGameLoaded)
				{
					return false;
				}
				SaveManager instance2 = Singleton<SaveManager>.Instance;
				if ((Object)(object)instance2 == (Object)null)
				{
					return false;
				}
				instance2.Save();
				return true;
			}
			catch
			{
				return false;
			}
		}

		void ISaveable.LoadInternal(string folderPath)
		{
			LoadInternal(folderPath);
		}

		internal virtual void LoadInternal(string folderPath)
		{
			FieldInfo[] fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = fields;
			foreach (FieldInfo fieldInfo in array)
			{
				SaveableField customAttribute = fieldInfo.GetCustomAttribute<SaveableField>();
				if (customAttribute != null)
				{
					string path = (customAttribute.SaveName.EndsWith(".json") ? customAttribute.SaveName : (customAttribute.SaveName + ".json"));
					string path2 = Path.Combine(folderPath, path);
					if (File.Exists(path2))
					{
						string text = File.ReadAllText(path2);
						Type fieldType = fieldInfo.FieldType;
						object value = JsonConvert.DeserializeObject(text, fieldType, ISaveable.SerializerSettings);
						fieldInfo.SetValue(this, value);
					}
				}
			}
			OnLoaded();
		}

		void ISaveable.SaveInternal(string folderPath, ref List<string> extraSaveables)
		{
			SaveInternal(folderPath, ref extraSaveables);
		}

		internal virtual void SaveInternal(string folderPath, ref List<string> extraSaveables)
		{
			FieldInfo[] allFields = global::S1API.Internal.Utils.ReflectionUtils.GetAllFields(GetType(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = allFields;
			foreach (FieldInfo fieldInfo in array)
			{
				SaveableField customAttribute = fieldInfo.GetCustomAttribute<SaveableField>();
				if (customAttribute != null)
				{
					string text = (customAttribute.SaveName.EndsWith(".json") ? customAttribute.SaveName : (customAttribute.SaveName + ".json"));
					string path = Path.Combine(folderPath, text);
					object value = fieldInfo.GetValue(this);
					if (value == null)
					{
						File.Delete(path);
						continue;
					}
					extraSaveables.Add(text);
					string contents = JsonConvert.SerializeObject(value, (Formatting)1, ISaveable.SerializerSettings);
					File.WriteAllText(path, contents);
				}
			}
			OnSaved();
		}

		internal void SaveToDynamic(DynamicSaveData dynamicSaveData)
		{
			if (dynamicSaveData == null)
			{
				return;
			}
			FieldInfo[] allFields = global::S1API.Internal.Utils.ReflectionUtils.GetAllFields(GetType(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = allFields;
			foreach (FieldInfo fieldInfo in array)
			{
				SaveableField customAttribute = fieldInfo.GetCustomAttribute<SaveableField>();
				if (customAttribute != null)
				{
					object value = fieldInfo.GetValue(this);
					if (value != null)
					{
						string text = JsonConvert.SerializeObject(value, (Formatting)0, ISaveable.SerializerSettings);
						dynamicSaveData.AddData(customAttribute.SaveName, text);
					}
				}
			}
			OnSaved();
		}

		internal void LoadFromDynamic(DynamicSaveData dynamicSaveData)
		{
			if (dynamicSaveData == null)
			{
				return;
			}
			FieldInfo[] allFields = global::S1API.Internal.Utils.ReflectionUtils.GetAllFields(GetType(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			FieldInfo[] array = allFields;
			string text = default(string);
			foreach (FieldInfo fieldInfo in array)
			{
				SaveableField customAttribute = fieldInfo.GetCustomAttribute<SaveableField>();
				if (customAttribute != null && dynamicSaveData.TryGetData(customAttribute.SaveName, ref text) && !string.IsNullOrEmpty(text))
				{
					Type fieldType = fieldInfo.FieldType;
					object value = JsonConvert.DeserializeObject(text, fieldType, ISaveable.SerializerSettings);
					fieldInfo.SetValue(this, value);
				}
			}
			OnLoaded();
		}

		void ISaveable.OnLoaded()
		{
			OnLoaded();
		}

		protected virtual void OnLoaded()
		{
		}

		void ISaveable.OnSaved()
		{
			OnSaved();
		}

		protected virtual void OnSaved()
		{
		}
	}
}
namespace S1API.Input
{
	public enum ButtonCode
	{
		PrimaryClick,
		SecondaryClick,
		TertiaryClick,
		Forward,
		Backward,
		Left,
		Right,
		Jump,
		Crouch,
		Sprint,
		Escape,
		Back,
		Interact,
		Submit,
		TogglePhone,
		VehicleToggleLights,
		VehicleHandbrake,
		RotateLeft,
		RotateRight,
		ManagementMode,
		OpenMap,
		OpenJournal,
		OpenTexts,
		QuickMove,
		ToggleFlashlight,
		ViewAvatar,
		Reload,
		InventoryLeft,
		InventoryRight,
		Holster,
		VehicleResetCamera,
		SkateboardDismount,
		SkateboardMount,
		TogglePauseMenu
	}
	public enum InputDeviceType
	{
		KeyboardMouse,
		Gamepad
	}
	internal static class ControlsState
	{
		internal static InputDeviceType LastKnownDevice = InputDeviceType.KeyboardMouse;

		internal static readonly Dictionary<Action<InputDeviceType>, Action<InputDeviceType>> TrackedListeners = new Dictionary<Action<InputDeviceType>, Action<InputDeviceType>>();
	}
	public static class Controls
	{
		public static bool IsTyping
		{
			get
			{
				return GameInput.IsTyping;
			}
			set
			{
				GameInput.IsTyping = value;
			}
		}

		public static Vector2 MotionAxis => GameInput.MotionAxis;

		public static Vector2 CameraAxis => GameInput.CameraAxis;

		public static Vector2 MouseDelta => GameInput.MouseDelta;

		public static Vector3 MousePosition => GameInput.MousePosition;

		public static float MouseScrollDelta => GameInput.MouseScrollDelta;

		public static InputDeviceType CurrentInputDevice => (InputDeviceType)GameInput.CurrentInputDevice;

		public static bool ControllerComboActive => GameInput.ControllerComboActive;

		public static float VehicleDriveAxis => GameInput.VehicleDriveAxis;

		public static Vector2 UINavigationDirection => GameInput.UINavigationDirection;

		public static Vector2 UICyclePanelDirection => GameInput.UICyclePanelDirection;

		public static float UITabNavigationPrimaryAxis => GameInput.UITabNavigationPrimaryAxis;

		public static float UITabNavigationSecondaryAxis => GameInput.UITabNavigationSecondaryAxis;

		public static float UIScrollbarAxis => GameInput.UIScrollbarAxis;

		public static Vector2 UIMapNavigationDirection => GameInput.UIMapNavigationDirection;

		public static float UIMapZoomAxis => GameInput.UIMapZoomAxis;

		public static float UIModifyAmountIncrementTierOneAxis => GameInput.UIModifyAmountIncrementTierOneAxis;

		public static float UIModifyAmountIncrementTierTwoAxis => GameInput.UIModifyAmountIncrementTierTwoAxis;

		public static float UIModifyAmountIncrementTierThreeAxis => GameInput.UIModifyAmountIncrementTierThreeAxis;

		public static void RegisterDeviceChangedListener(Action<InputDeviceType> callback)
		{
			if (callback != null && !ControlsState.TrackedListeners.ContainsKey(callback))
			{
				Action<InputDeviceType> action = delegate(InputDeviceType device)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Expected I4, but got Unknown
					callback((InputDeviceType)device);
				};
				ControlsState.TrackedListeners[callback] = action;
				GameInput.OnInputDeviceChanged += Action<InputDeviceType>.op_Implicit(action);
			}
		}

		public static void UnregisterDeviceChangedListener(Action<InputDeviceType> callback)
		{
			if (callback != null && ControlsState.TrackedListeners.TryGetValue(callback, out Action<InputDeviceType> value))
			{
				GameInput.OnInputDeviceChanged -= Action<InputDeviceType>.op_Implicit(value);
				ControlsState.TrackedListeners.Remove(callback);
			}
		}

		public static bool GetButton(ButtonCode button)
		{
			return GameInput.GetButton((ButtonCode)button);
		}

		public static bool GetButtonDown(ButtonCode button)
		{
			return GameInput.GetButtonDown((ButtonCode)button);
		}

		public static bool GetButtonUp(ButtonCode button)
		{
			return GameInput.GetButtonUp((ButtonCode)button);
		}

		public static bool GetCurrentInputDeviceIsKeyboardMouse()
		{
			return GameInput.GetCurrentInputDeviceIsKeyboardMouse();
		}

		public static bool GetCurrentInputDeviceIsGamepad()
		{
			return GameInput.GetCurrentInputDeviceIsGamepad();
		}
	}
}
namespace S1API.Growing
{
	public static class GrowContainerAdditives
	{
		private static readonly Log Logger = new Log("GrowContainerAdditives");

		private static readonly object Gate = new object();

		private static readonly HashSet<string> AllowedIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> WarnedMissingIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static void AllowAdditive(string additiveItemId)
		{
			string text = (additiveItemId ?? string.Empty).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				throw new ArgumentException("Additive item ID is required.", "additiveItemId");
			}
			lock (Gate)
			{
				AllowedIds.Add(text);
			}
		}

		public static IReadOnlyList<string> GetAllowedAdditiveIds()
		{
			lock (Gate)
			{
				string[] array = new string[AllowedIds.Count];
				AllowedIds.CopyTo(array);
				return array;
			}
		}

		internal static IReadOnlyList<string> GetAllowedAdditiveIdsInternal()
		{
			return GetAllowedAdditiveIds();
		}

		internal static void WarnMissing(string additiveItemId, string message)
		{
			if (string.IsNullOrWhiteSpace(additiveItemId))
			{
				return;
			}
			lock (Gate)
			{
				if (WarnedMissingIds.Add(additiveItemId))
				{
					Logger.Warning(message);
				}
			}
		}
	}
	public sealed class MushroomBedInstance
	{
		internal readonly MushroomBed S1MushroomBed;

		public ShroomColonyInstance? CurrentColony
		{
			get
			{
				ShroomColony currentColony = S1MushroomBed.CurrentColony;
				return ((Object)(object)currentColony != (Object)null) ? new ShroomColonyInstance(currentColony) : null;
			}
		}

		public GameObject GameObject => ((Component)S1MushroomBed).gameObject;

		public Transform Transform => ((Component)S1MushroomBed).transform;

		internal MushroomBedInstance(MushroomBed mushroomBed)
		{
			S1MushroomBed = mushroomBed;
		}

		public bool ContainsGrowable()
		{
			return ((GrowContainer)S1MushroomBed).ContainsGrowable();
		}

		public float GetGrowthProgressNormalized()
		{
			return ((GrowContainer)S1MushroomBed).GetGrowthProgressNormalized();
		}

		public float GetAverageTileTemperature()
		{
			return ((GridItem)S1MushroomBed).GetAverageTileTemperature();
		}

		public bool IsReadyForHarvest(out string reason)
		{
			return S1MushroomBed.IsReadyForHarvest(ref reason);
		}

		public float GetGrowSurfaceSideLength()
		{
			return ((GrowContainer)S1MushroomBed).GetGrowSurfaceSideLength();
		}
	}
	public class PlantInstance
	{
		internal readonly Plant S1Plant;

		public float NormalizedGrowth => S1Plant.NormalizedGrowthProgress;

		public bool IsFullyGrown => S1Plant.IsFullyGrown;

		public SeedDefinition SeedDefinition => new SeedDefinition(S1Plant.SeedDefinition);

		public float Quality => S1Plant.QualityLevel;

		public float YieldMultiplier => S1Plant.YieldMultiplier;

		private GameObject GameObject => ((Component)S1Plant).gameObject;

		internal PlantInstance(Plant plant)
		{
			S1Plant = plant;
		}

		public void Destroy(bool dropScraps = false)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (dropScraps && (Object)(object)S1Plant.PlantScrapPrefab != (Object)null)
			{
				try
				{
					TrashManager instance = NetworkSingleton<TrashManager>.Instance;
					if ((Object)(object)instance != (Object)null)
					{
						Vector3 position = ((Component)S1Plant).transform.position;
						Quaternion identity = Quaternion.identity;
						instance.CreateTrashItem(S1Plant.PlantScrapPrefab.ID, position, identity, default(Vector3), "", false);
					}
				}
				catch
				{
				}
			}
			Object.Destroy((Object)(object)((Component)S1Plant).gameObject);
		}
	}
	public static class SeedCreator
	{
		public static SeedDefinition CreateSeed(string id, string name, string description, int stackLimit = 10, GameObject? functionSeedPrefab = null, GameObject? plantPrefab = null, Sprite? icon = null)
		{
			SeedDefinition val = ScriptableObject.CreateInstance<SeedDefinition>();
			((BaseItemDefinition)val).ID = id;
			((BaseItemDefinition)val).Name = name;
			((BaseItemDefinition)val).Description = description;
			((BaseItemDefinition)val).StackLimit = stackLimit;
			((BaseItemDefinition)val).Category = (EItemCategory)2;
			if ((Object)(object)functionSeedPrefab != (Object)null)
			{
				val.FunctionSeedPrefab = functionSeedPrefab.GetComponent<FunctionalSeed>();
			}
			if ((Object)(object)plantPrefab != (Object)null)
			{
				val.PlantPrefab = plantPrefab.GetComponent<Plant>();
			}
			Singleton<Registry>.Instance.AddToRegistry((ItemDefinition)(object)val);
			return new SeedDefinition(val);
		}
	}
	public class SeedDefinition : ItemDefinition
	{
		internal SeedDefinition S1SeedDefinition => CrossType.As<SeedDefinition>((object)base.S1ItemDefinition);

		public GameObject? FunctionalSeedPrefab
		{
			get
			{
				FunctionalSeed functionSeedPrefab = S1SeedDefinition.FunctionSeedPrefab;
				return (functionSeedPrefab != null) ? ((Component)functionSeedPrefab).gameObject : null;
			}
		}

		public GameObject? PlantPrefab
		{
			get
			{
				Plant plantPrefab = S1SeedDefinition.PlantPrefab;
				return (plantPrefab != null) ? ((Component)plantPrefab).gameObject : null;
			}
		}

		internal SeedDefinition(SeedDefinition definition)
			: base((ItemDefinition)(object)definition)
		{
		}

		public GameObject CreateSeedInstance()
		{
			if ((Object)(object)S1SeedDefinition.FunctionSeedPrefab != (Object)null)
			{
				return ((Component)Object.Instantiate<FunctionalSeed>(S1SeedDefinition.FunctionSeedPrefab)).gameObject;
			}
			throw new NullReferenceException("No FunctionalSeedPrefab assigned to this SeedDefinition!");
		}
	}
	public class SeedInstance
	{
		internal readonly FunctionalSeed S1FunctionalSeed;

		private GameObject GameObject => ((Component)S1FunctionalSeed).gameObject;

		public bool HasExitedVial { get; private set; } = false;

		internal SeedInstance(FunctionalSeed functionalSeed)
		{
			S1FunctionalSeed = functionalSeed;
		}

		public void ForceExitVial()
		{
			if ((Object)(object)S1FunctionalSeed.Vial != (Object)null)
			{
				S1FunctionalSeed.TriggerExit(((Component)S1FunctionalSeed.Vial).GetComponent<Collider>());
				HasExitedVial = true;
			}
		}
	}
	public sealed class ShroomColonyInstance
	{
		public const float MaxTemperatureForGrowth = 15f;

		internal readonly ShroomColony S1ShroomColony;

		public int BaseShroomYield => S1ShroomColony.BaseShroomYield;

		public float GrowthProgress => S1ShroomColony.GrowthProgress;

		public bool IsFullyGrown => S1ShroomColony.IsFullyGrown;

		public bool IsTooHotToGrow => S1ShroomColony.IsTooHotToGrow;

		public int GrownMushroomCount => S1ShroomColony.GrownMushroomCount;

		public float NormalizedQuality => S1ShroomColony.NormalizedQuality;

		public GameObject GameObject => ((Component)S1ShroomColony).gameObject;

		internal ShroomColonyInstance(ShroomColony colony)
		{
			S1ShroomColony = colony;
		}

		public void Destroy()
		{
			Object.Destroy((Object)(object)((Component)S1ShroomColony).gameObject);
		}
	}
}
namespace S1API.Graffiti
{
	public static class GraffitiEvents
	{
		public static event Action<SpraySurface>? GraffitiCompleted;

		internal static void OnGraffitiRewarded(SpraySurface spraySurface)
		{
			try
			{
				GraffitiEvents.GraffitiCompleted?.Invoke(spraySurface);
			}
			catch (Exception ex)
			{
				MelonLogger.Error("[S1API.GraffitiEvents] Error in OnGraffitiRewarded: " + ex.Message);
				MelonLogger.Error("[S1API.GraffitiEvents] StackTrace: " + ex.StackTrace);
			}
		}
	}
	public static class GraffitiManager
	{
		private static GraffitiManager? Instance => NetworkSingleton<GraffitiManager>.Instance;

		public static List<SpraySurface> UntaggedSpraySurfaces => (from surface in GetAllSpraySurfaces()
			where surface.StrokeCount == 0 && !surface.HasDrawingBeenFinalized
			select surface).ToList();

		public static List<SpraySurface> GetAllSpraySurfaces()
		{
			GraffitiManager instance = Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return new List<SpraySurface>();
			}
			List<SpraySurface> list = new List<SpraySurface>();
			if (instance.WorldSpraySurfaces == null)
			{
				return list;
			}
			for (int i = 0; i < instance.WorldSpraySurfaces.Count; i++)
			{
				WorldSpraySurface val = instance.WorldSpraySurfaces[i];
				if ((Object)(object)val != (Object)null)
				{
					list.Add(new SpraySurface(val));
				}
			}
			return list;
		}

		public static List<SpraySurface> GetUntaggedSpraySurfaces()
		{
			return UntaggedSpraySurfaces;
		}

		public static SpraySurface? FindNearestUntaggedSurface(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return FindNearestUntaggedSurface(position, null);
		}

		public static SpraySurface? FindNearestUntaggedSurface(Vector3 position, Func<SpraySurface, bool>? include)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			List<SpraySurface> untaggedSpraySurfaces = GetUntaggedSpraySurfaces();
			if (untaggedSpraySurfaces.Count == 0)
			{
				return null;
			}
			SpraySurface result = null;
			float num = float.MaxValue;
			foreach (SpraySurface item in untaggedSpraySurfaces)
			{
				if (include == null || include(item))
				{
					float num2 = Vector3.Distance(position, item.Position);
					if (num2 < num)
					{
						num = num2;
						result = item;
					}
				}
			}
			return result;
		}

		internal static WorldSpraySurface? FindSurfaceByGuid(Guid guid)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GraffitiManager instance = Instance;
			if (((instance != null) ? instance.WorldSpraySurfaces : null) == null)
			{
				return null;
			}
			for (int i = 0; i < instance.WorldSpraySurfaces.Count; i++)
			{
				WorldSpraySurface val = instance.WorldSpraySurfaces[i];
				if ((Object)(object)val != (Object)null && ((object)val.GUID/*cast due to .constrained prefix*/).ToString() == guid.ToString())
				{
					return val;
				}
			}
			return null;
		}

		internal static List<WorldSpraySurface> FindAvailableForNPCInRegion(Region region)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			GraffitiManager instance = Instance;
			List<WorldSpraySurface> list = new List<WorldSpraySurface>();
			if (((instance != null) ? instance.WorldSpraySurfaces : null) == null)
			{
				return list;
			}
			EMapRegion val = (EMapRegion)region;
			for (int i = 0; i < instance.WorldSpraySurfaces.Count; i++)
			{
				WorldSpraySurface val2 = instance.WorldSpraySurfaces[i];
				if ((Object)(object)val2 != (Object)null && val2.Region == val && val2.CanBeSprayedByNPCs && ((SpraySurface)val2).CanBeEdited(true))
				{
					list.Add(val2);
				}
			}
			return list;
		}

		internal static WorldSpraySurface? FindNearestAvailableForNPC(Vector3 position)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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)
			GraffitiManager instance = Instance;
			if (((instance != null) ? instance.WorldSpraySurfaces : null) == null)
			{
				return null;
			}
			WorldSpraySurface result = null;
			float num = float.MaxValue;
			for (int i = 0; i < instance.WorldSpraySurfaces.Count; i++)
			{
				WorldSpraySurface val = instance.WorldSpraySurfaces[i];
				if (!((Object)(object)val == (Object)null) && val.CanBeSprayedByNPCs && ((SpraySurface)val).CanBeEdited(true))
				{
					Vector3 centerPoint = ((SpraySurface)val).CenterPoint;
					float num2 = Vector3.Distance(position, centerPoint);
					if (num2 < num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}
	}
	public sealed class SpraySurface
	{
		internal readonly WorldSpraySurface S1SpraySurface;

		public Guid GUID => new Guid(((object)S1SpraySurface.GUID/*cast due to .constrained prefix*/).ToString());

		public Vector3 Position
		{
			get
			{
				//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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(S1SpraySurface, "BottomLeftPoint");
				Transform val = (Transform)((obj is Transform) ? obj : null);
				if (val != null && (Object)(object)val != (Object)null)
				{
					return val.position;
				}
				return Vector3.zero;
			}
		}

		public int StrokeCount => ((SpraySurface)S1SpraySurface).DrawingStrokeCount;

		public int PaintedPixelCount => ((SpraySurface)S1SpraySurface).DrawingPaintedPixelCount;

		public bool HasDrawingBeenFinalized => S1SpraySurface.HasEverBeenMarkedByPlayer;

		public Texture DrawingOutputTexture => ((SpraySurface)S1SpraySurface).DrawingOutputTexture;

		public event Action OnDrawingChanged
		{
			add
			{
				WorldSpraySurface s1SpraySurface = S1SpraySurface;
				((SpraySurface)s1SpraySurface).onDrawingChanged = ((SpraySurface)s1SpraySurface).onDrawingChanged + Action.op_Implicit(value);
			}
			remove
			{
				WorldSpraySurface s1SpraySurface = S1SpraySurface;
				((SpraySurface)s1SpraySurface).onDrawingChanged = ((SpraySurface)s1SpraySurface).onDrawingChanged - Action.op_Implicit(value);
			}
		}

		internal SpraySurface(WorldSpraySurface spraySurface)
		{
			S1SpraySurface = spraySurface;
		}
	}
}
namespace S1API.GameTime
{
	public enum Day
	{
		Monday,
		Tuesday,
		Wednesday,
		Thursday,
		Friday,
		Saturday,
		Sunday
	}
	public struct GameDateTime
	{
		public int ElapsedDays;

		public int Time;

		public GameDateTime(int elapsedDays, int time)
		{
			ElapsedDays = elapsedDays;
			Time = time;
		}

		public GameDateTime(int minSum)
		{
			ElapsedDays = minSum / 1440;
			int num = minSum % 1440;
			if (minSum < 0)
			{
				num = -minSum % 1440;
			}
			Time = TimeManager.Get24HourTimeFromMinSum(num);
		}

		public GameDateTime(GameDateTimeData data)
		{
			ElapsedDays = data.ElapsedDays;
			Time = data.Time;
		}

		public GameDateTime(GameDateTime gameDateTime)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ElapsedDays = gameDateTime.elapsedDays;
			Time = gameDateTime.time;
		}

		public int GetMinSum()
		{
			return ElapsedDays * 1440 + TimeManager.GetMinSumFrom24HourTime(Time);
		}

		public GameDateTime AddMinutes(int minutes)
		{
			return new GameDateTime(GetMinSum() + minutes);
		}

		public GameDateTime ToS1()
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			return new GameDateTime(ElapsedDays, Time);
		}

		public string GetFormattedTime()
		{
			return TimeManager.Get12HourTime((float)Time, true);
		}

		public bool IsNightTime()
		{
			return Time < 600 || Time >= 1800;
		}

		public bool IsSameDay(GameDateTime other)
		{
			return ElapsedDays == other.ElapsedDays;
		}

		public bool IsSameTime(GameDateTime other)
		{
			return ElapsedDays == other.ElapsedDays && Time == other.Time;
		}

		public override string ToString()
		{
			return $"Day {ElapsedDays}, {GetFormattedTime()}";
		}

		public static GameDateTime operator +(GameDateTime a, GameDateTime b)
		{
			return new GameDateTime(a.GetMinSum() + b.GetMinSum());
		}

		public static GameDateTime operator -(GameDateTime a, GameDateTime b)
		{
			return new GameDateTime(a.GetMinSum() - b.GetMinSum());
		}

		public static bool operator >(GameDateTime a, GameDateTime b)
		{
			return a.GetMinSum() > b.GetMinSum();
		}

		public static bool operator <(GameDateTime a, GameDateTime b)
		{
			return a.GetMinSum() < b.GetMinSum();
		}
	}
	public static class TimeManager
	{
		public static Action OnHourPass;

		public static Action OnDayPass;

		public static Action OnWeekPass;

		public static Action OnSleepStart;

		public static Action<int> OnSleepEnd;

		public static Action OnTick;

		private static int _lastSleepSkippedMinutes;

		private static TimeManager? _boundInstance;

		private static readonly Action HourPassHandler;

		private static readonly Action DayPassHandler;

		private static readonly Action WeekPassHandler;

		private static readonly Action TickHandler;

		private static readonly Action SleepStartHandler;

		private static readonly Action<int> TimeSkipHandler;

		private static readonly Action SleepEndHandler;

		public static Day CurrentDay => (Day)NetworkSingleton<TimeManager>.Instance.CurrentDay;

		public static int ElapsedDays => NetworkSingleton<TimeManager>.Instance.ElapsedDays;

		public static int CurrentTime => NetworkSingleton<TimeManager>.Instance.CurrentTime;

		public static bool IsNight => NetworkSingleton<TimeManager>.Instance.IsNight;

		public static bool IsEndOfDay => NetworkSingleton<TimeManager>.Instance.IsEndOfDay;

		public static bool SleepInProgress => NetworkSingleton<TimeManager>.Instance.IsSleepInProgress;

		public static float NormalizedTime => NetworkSingleton<TimeManager>.Instance.NormalizedTimeOfDay;

		public static float Playtime => NetworkSingleton<TimeManager>.Instance.Playtime;

		static TimeManager()
		{
			OnHourPass = delegate
			{
			};
			OnDayPass = delegate
			{
			};
			OnWeekPass = delegate
			{
			};
			OnSleepStart = delegate
			{
			};
			OnSleepEnd = delegate
			{
			};
			OnTick = delegate
			{
			};
			HourPassHandler = delegate
			{
				OnHourPass();
			};
			DayPassHandler = delegate
			{
				OnDayPass();
			};
			WeekPassHandler = delegate
			{
				OnWeekPass();
			};
			TickHandler = delegate
			{
				OnTick();
			};
			SleepStartHandler = delegate
			{
				OnSleepStart();
			};
			TimeSkipHandler = delegate(int minutes)
			{
				_lastSleepSkippedMinutes = minutes;
			};
			SleepEndHandler = delegate
			{
				OnSleepEnd(_lastSleepSkippedMinutes);
			};
			TryBindToCurrentInstance();
		}

		internal static void TryBindToCurrentInstance()
		{
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			if (!((Object)(object)instance == (Object)null) && instance != _boundInstance)
			{
				UnbindFromInstance(_boundInstance);
				_boundInstance = instance;
				instance.onHourPass += Action.op_Implicit(HourPassHandler);
				instance.onDayPass += Action.op_Implicit(DayPassHandler);
				instance.onWeekPass += Action.op_Implicit(WeekPassHandler);
				AddToActionList(instance.onTick, TickHandler);
				instance.onSleepStart += Action.op_Implicit(SleepStartHandler);
				instance.onTimeSkip += Action<int>.op_Implicit(TimeSkipHandler);
				instance.onSleepEnd += Action.op_Implicit(SleepEndHandler);
			}
		}

		internal static void ResetBindings()
		{
			UnbindFromInstance(_boundInstance);
			_boundInstance = null;
			_lastSleepSkippedMinutes = 0;
		}

		private static void UnbindFromInstance(TimeManager? instance)
		{
			if (!((Object)(object)instance == (Object)null))
			{
				instance.onHourPass -= Action.op_Implicit(HourPassHandler);
				instance.onDayPass -= Action.op_Implicit(DayPassHandler);
				instance.onWeekPass -= Action.op_Implicit(WeekPassHandler);
				RemoveFromActionList(instance.onTick, TickHandler);
				instance.onSleepStart -= Action.op_Implicit(SleepStartHandler);
				instance.onTimeSkip -= Action<int>.op_Implicit(TimeSkipHandler);
				instance.onSleepEnd -= Action.op_Implicit(SleepEndHandler);
			}
		}

		private static void AddToActionList(object? actionList, Action handler)
		{
			if (actionList == null)
			{
				return;
			}
			MethodInfo method = actionList.GetType().GetMethod("Add", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(method == null))
			{
				object obj = handler;
				ParameterInfo[] parameters = method.GetParameters();
				if (parameters.Length != 0 && parameters[0].ParameterType == typeof(Action))
				{
					obj = DelegateSupport.ConvertDelegate<Action>((Delegate)handler) ?? Action.op_Implicit(handler);
				}
				method.Invoke(actionList, new object[1] { obj });
			}
		}

		private static void RemoveFromActionList(object? actionList, Action handler)
		{
			if (actionList == null)
			{
				return;
			}
			MethodInfo method = actionList.GetType().GetMethod("Remove", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(method == null))
			{
				object obj = handler;
				ParameterInfo[] parameters = method.GetParameters();
				if (parameters.Length != 0 && parameters[0].ParameterType == typeof(Action))
				{
					obj = DelegateSupport.ConvertDelegate<Action>((Delegate)handler) ?? Action.op_Implicit(handler);
				}
				method.Invoke(actionList, new object[1] { obj });
			}
		}

		public static void SetTime(int time24h)
		{
			NetworkSingleton<TimeManager>.Instance.SetTimeAndSync(time24h);
		}

		public static string GetFormatted12HourTime()
		{
			return TimeManager.Get12HourTime((float)CurrentTime, true);
		}

		public static bool IsCurrentTimeWithinRange(int startTime24h, int endTime24h)
		{
			return NetworkSingleton<TimeManager>.Instance.IsCurrentTimeWithinRange(startTime24h, endTime24h);
		}

		public static int GetMinutesFrom24HourTime(int time24h)
		{
			return TimeManager.GetMinSumFrom24HourTime(time24h);
		}

		public static int Get24HourTimeFromMinutes(int minutes)
		{
			return TimeManager.Get24HourTimeFromMinSum(minutes);
		}
	}
}
namespace S1API.Entities
{
	public abstract class NPC : Saveable, IEntity, IHealth
	{
		private sealed class DealerRecommendationSubscription
		{
			internal NPC Customer { get; }

			internal DealerRecommendationBuilder.Trigger RecommendationTrigger { get; }

			internal Action Handler { get; }

			internal DealerRecommendationSubscription(NPC customer, DealerRecommendationBuilder.Trigger recommendationTrigger, Action handler)
			{
				Customer = customer;
				RecommendationTrigger = recommendationTrigger;
				Handler = handler;
			}
		}

		private static readonly Log Logger = new Log("NPC");

		private static readonly Dictionary<Type, GameObject> TypeToPrefab = new Dictionary<Type, GameObject>();

		private static readonly object TemplateLoadLock = new object();

		private static readonly Dictionary<Type, List<IScheduleActionSpec>> TypeToSchedulePlan = new Dictionary<Type, List<IScheduleActionSpec>>();

		private static readonly Dictionary<Type, Action<CustomerDataBuilder>> TypeToCustomerDefaults = new Dictionary<Type, Action<CustomerDataBuilder>>();

		internal static readonly Dictionary<Type, Action<NPCRelationshipDataBuilder>> TypeToRelationshipDefaults = new Dictionary<Type, Action<NPCRelationshipDataBuilder>>();

		private static readonly Dictionary<Type, Action<RandomInventoryItemsBuilder>> TypeToRandomInventoryDefaults = new Dictionary<Type, Action<RandomInventoryItemsBuilder>>();

		private static readonly Dictionary<Type, Action<DealerDataBuilder>> TypeToDealerDefaults = new Dictionary<Type, Action<DealerDataBuilder>>();

		private static readonly Dictionary<Type, DealerDataBuilder.DealerConfigData> TypeToBuiltDealerDefaults = new Dictionary<Type, DealerDataBuilder.DealerConfigData>();

		private static readonly Dictionary<Type, Action<SupplierDataBuilder>> TypeToSupplierDefaults = new Dictionary<Type, Action<SupplierDataBuilder>>();

		private static readonly Dictionary<Type, SupplierDataBuilder.SupplierConfigData> TypeToBuiltSupplierDefaults = new Dictionary<Type, SupplierDataBuilder.SupplierConfigData>();

		internal static readonly HashSet<Type> FinalizedCustomNpcTypes = new HashSet<Type>();

		private static readonly Dictionary<Type, (Vector3 position, Quaternion rotation)> TypeToSpawnPosition = new Dictionary<Type, (Vector3, Quaternion)>();

		private static readonly HashSet<Type> CustomerTypes = new HashSet<Type>();

		private static readonly HashSet<Type> DealerTypes = new HashSet<Type>();

		private static readonly HashSet<Type> SupplierTypes = new HashSet<Type>();

		private const float DefaultRelationDelta = 2f;

		private const string DealerPrefabName = "Dealer";

		private const string CivilianNpcPrefabName = "CivilianNPC";

		private const string BaseNpcPrefabName = "BaseNPC";

		private const string BaseEmployeePrefabName = "BaseEmployee";

		private static readonly bool LogBetaNpcPrefabDiagnostics = false;

		private static readonly string[] BaseNpcMembersToCopy = new string[20]
		{
			"NPCData", "Scale", "Region", "BakedGUID", "GUID", "AggressionController", "Movement", "DialogueHandler", "Avatar", "Awareness",
			"Responses", "Actions", "Behaviour", "Inventory", "VoiceOverEmitter", "Health", "Visibility", "CurrentVehicle", "RelationData", "MSGConversation"
		};

		private static readonly string[] ChildNpcReferenceMemberNames = new string[8] { "Npc", "NPC", "npc", "nPC", "baseNpc", "BaseNpc", "baseNPC", "BaseNPC" };

		private static volatile bool _prefabsConfiguredForLocalProcess;

		private static bool _loggedBaseEmployeeNormalization;

		private static int _clientNetworkSpawnHydrationDepth;

		private Avatar? _runtimeAvatar;

		private bool _hasExplicitIcon;

		protected readonly List<Response> Responses = new List<Response>();

		public static readonly List<NPC> All = new List<NPC>();

		internal readonly NPC S1NPC;

		internal readonly bool IsCustomNPC;

		private const bool DefaultRequiresRegionUnlocked = true;

		private readonly MethodInfo _unsettleMethod = AccessTools.Method(typeof(NPC), "SetUnsettled", (Type[])null, (Type[])null);

		private readonly MethodInfo _removePanicMethod = AccessTools.Method(typeof(NPC), "RemovePanicked", (Type[])null, (Type[])null);

		private NPCDialogue? _dialogue;

		private NPCSchedule? _schedule;

		private NPCInventory? _inventory;

		private NPCCustomer? _customer;

		private NPCDealer? _dealer;

		private NPCSupplier? _supplier;

		private NPCRelationship? _relationship;

		private NPCMessaging? _messaging;

		private NPCSmoking? _smoking;

		private NPCSprayPainting? _sprayPainting;

		private NPCDrinking? _drinking;

		private NPCItemHolding? _itemHolding;

		private bool _relationshipDataAppliedFromPrefab;

		private readonly List<DealerRecommendationSubscription> _recommendationSubscriptions = new List<DealerRecommendationSubscription>();

		internal static bool PrefabsConfiguredForLocalProcess => _prefabsConfiguredForLocalProcess;

		internal bool HasExplicitIcon => _hasExplicitIcon;

		public GameObject gameObject { get; }

		public Vector3 Position
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return gameObject.transform.position;
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				S1NPC.Movement.Warp(value);
			}
		}

		public Transform Transform => gameObject.transform;

		public static bool CustomNpcsReady
		{
			get
			{
				return NPCPatches.CustomNpcsReady;
			}
			internal set
			{
				NPCPatches.CustomNpcsReady = value;
			}
		}

		public string FirstName
		{
			get
			{
				return NPCDataAccess.GetFirstName(S1NPC);
			}
			set
			{
				NPCDataAccess.ApplyFirstName(S1NPC, value);
			}
		}

		public string LastName
		{
			get
			{
				return NPCDataAccess.GetLastName(S1NPC);
			}
			set
			{
				NPCDataAccess.ApplyLastName(S1NPC, value);
			}
		}

		public string FullName => GetNpcFullName();

		public string ID
		{
			get
			{
				return NPCDataAccess.GetId(S1NPC);
			}
			protected set
			{
				NPCDataAccess.ApplyId(S1NPC, value);
			}
		}

		public static string? NPCId => null;

		public Sprite? Icon
		{
			get
			{
				return NPCDataAccess.GetIcon(S1NPC);
			}
			set
			{
				_hasExplicitIcon = (Object)(object)value != (Object)null;
				NPCDataAccess.ApplyIcon(S1NPC, value);
				RefreshMessagingIcons();
			}
		}

		public bool IsConscious => S1NPC.IsConscious;

		public bool IsInBuilding => S1NPC.isInBuilding;

		public bool IsInVehicle => S1NPC.IsInVehicle;

		public bool IsPanicking => S1NPC.IsPanicked;

		public bool IsUnsettled => S1NPC.isUnsettled;

		public bool IsVisible => S1NPC.isVisible;

		public virtual bool IsPhysical => false;

		public virtual bool IsDealer => false;

		public virtual bool IsSupplier => false;

		public float Aggressiveness
		{
			get
			{
				return S1NPC.Aggression;
			}
			set
			{
				SetNpcMember("Aggression", value);
			}
		}

		public Region Region
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (Region)S1NPC.Region;
			}
			set
			{
				try
				{
					S1NPC.Region = (EMapRegion)value;
				}
				catch
				{
				}
			}
		}

		public float Scale
		{
			get
			{
				return S1NPC.Scale;
			}
			set
			{
				S1NPC.SetScale(value);
			}
		}

		public bool IsKnockedOut => S1NPC.Health.IsKnockedOut;

		public bool RequiresRegionUnlocked
		{
			get
			{
				return true;
			}
			set
			{
			}
		}

		public LandVehicle? CurrentVehicle => ((Object)(object)S1NPC.CurrentVehicle != (Object)null) ? new LandVehicle(S1NPC.CurrentVehicle) : null;

		public float CurrentHealth => S1NPC.Health.Health;

		public float MaxHealth
		{
			get
			{
				return S1NPC.Health.MaxHealth;
			}
			set
			{
				SetGameMember(S1NPC.Health, "MaxHealth", value);
			}
		}

		public bool IsDead => S1NPC.Health.IsDead;

		public bool IsInvincible
		{
			get
			{
				return GetGameMember<bool>(S1NPC.Health, "Invincible");
			}
			set
			{
				SetGameMember(S1NPC.Health, "Invincible", value);
			}
		}

		public NPCAppearance Appearance { get; private set; }

		public NPCMovement Movement => new NPCMovement(this);

		public CombatBehaviour CombatBehaviour => new CombatBehaviour(this);

		public NPCSmoking Smoking => _smoking ?? (_smoking = new NPCSmoking(this));

		public NPCSprayPainting SprayPainting => _sprayPainting ?? (_sprayPainting = new NPCSprayPainting(this));

		public NPCDrinking Drinking => _drinking ?? (_drinking = new NPCDrinking(this));

		public NPCItemHolding ItemHolding => _itemHolding ?? (_itemHolding = new NPCItemHolding(this));

		public NPCDialogue Dialogue => _dialogue ?? (_dialogue = new NPCDialogue(this));

		public NPCSchedule Schedule => _schedule ?? (_schedule = new NPCSchedule(this));

		public NPCInventory Inventory => _inventory ?? (_inventory = new NPCInventory(this));

		public NPCCustomer Customer => _customer ?? (_customer = new NPCCustomer(this));

		public NPCDealer Dealer => _dealer ?? (_dealer = new NPCDealer(this));

		public NPCSupplier Supplier => _supplier ?? (_supplier = new NPCSupplier(this));

		public NPCRelationship Relationship => _relationship ?? (_relationship = new NPCRelationship(this));

		public NPCMessaging Messaging => _messaging ?? (_messaging = new NPCMessaging(this));

		public bool ConversationCanBeHidden
		{
			get
			{
				return NPCDataAccess.GetConversationCanBeHidden(S1NPC);
			}
			set
			{
				NPCDataAccess.ApplyConversationCanBeHidden(S1NPC, value);
			}
		}

		internal bool RelationshipDataAppliedFromPrefab => _relationshipDataAppliedFromPrefab;

		public event Action OnDeath
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1NPC.Health.onDie);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1NPC.Health.onDie);
			}
		}

		public event Action OnInventoryChanged
		{
			add
			{
				UnityEvent inventoryContentsChanged = GetInventoryContentsChanged(S1NPC.Inventory);
				if (inventoryContentsChanged != null)
				{
					global::S1API.Utils.EventHelper.AddListener(value, inventoryContentsChanged);
				}
			}
			remove
			{
				UnityEvent inventoryContentsChanged = GetInventoryContentsChanged(S1NPC.Inventory);
				if (inventoryContentsChanged != null)
				{
					global::S1API.Utils.EventHelper.RemoveListener(value, inventoryContentsChanged);
				}
			}
		}

		private static GameObject InstantiateTemplateInstance(Type npcType, NPC owner)
		{
			GameObject orCreatePerNpcPrefab = GetOrCreatePerNpcPrefab(npcType, owner);
			NetworkObject val = orCreatePerNpcPrefab.GetComponent<NetworkObject>() ?? orCreatePerNpcPrefab.AddComponent<NetworkObject>();
			NetworkObject val2 = null;
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if ((Object)(object)networkManager != (Object)null)
				{
					PrefabObjects spawnablePrefabs = networkManager.SpawnablePrefabs;
					if ((Object)(object)spawnablePrefabs != (Object)null)
					{
						int objectCount = spawnablePrefabs.GetObjectCount();
						for (int i = 0; i < objectCount; i++)
						{
							NetworkObject val3 = spawnablePrefabs.GetObject(true, i);
							if ((Object)(object)val3 != (Object)null && (Object)(object)((Component)val3).gameObject != (Object)null && ((Object)((Component)val3).gameObject).name == ((Object)orCreatePerNpcPrefab).name)
							{
								val2 = val3;
								break;
							}
						}
					}
				}
			}
			catch
			{
			}
			GameObject val4 = ((val2 != null) ? ((Component)val2).gameObject : null) ?? orCreatePerNpcPrefab;
			GameObject val5 = Object.Instantiate<GameObject>(val4);
			try
			{
				NetworkManager networkManager2 = InstanceFinder.NetworkManager;
				bool flag = (Object)(object)networkManager2 != (Object)null && networkManager2.IsServer;
				NetworkObject component = val5.GetComponent<NetworkObject>();
				if (flag)
				{
					if ((Object)(object)component == (Object)null)
					{
						component = val5.AddComponent<NetworkObject>();
					}
				}
				else if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
			}
			catch
			{
			}
			if (NetworkSingleton<NPCManager>.InstanceExists && (Object)(object)NetworkSingleton<NPCManager>.Instance.NPCContainer != (Object)null)
			{
				Transform nPCContainer = NetworkSingleton<NPCManager>.Instance.NPCContainer;
				if ((Object)(object)nPCContainer != (Object)null && (Object)(object)((Component)nPCContainer).gameObject != (Object)null && ((Component)nPCContainer).gameObject.activeInHierarchy)
				{
					val5.transform.SetParent(nPCContainer, false);
				}
			}
			((Object)val5).name = ((Object)orCreatePerNpcPrefab).name;
			NPC preferredNpcComponent = GetPreferredNpcComponent(val5);
			if ((Object)(object)preferredNpcComponent != (Object)null)
			{
				RepairNpcPrefabReferences(val5, preferredNpcComponent);
			}
			return val5;
		}

		private static NetworkObject? FindSpawnablePrefabByName(PrefabObjects spawnablePrefabs, int count, params string[] prefabNames)
		{
			for (int i = 0; i < count; i++)
			{
				NetworkObject val = spawnablePrefabs.GetObject(true, i);
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
				{
					continue;
				}
				for (int j = 0; j < prefabNames.Length; j++)
				{
					if (((Object)((Component)val).gameObject).name == prefabNames[j])
					{
						return val;
					}
				}
			}
			return null;
		}

		private static NetworkObject? FindSpawnablePrefabWithComponent<T>(PrefabObjects spawnablePrefabs, int count) where T : Component
		{
			for (int i = 0; i < count; i++)
			{
				NetworkObject val = spawnablePrefabs.GetObject(true, i);
				if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null && (Object)(object)((Component)val).gameObject.GetComponent<T>() != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static NetworkObject? FindSpawnablePrefabWithPlainNpcComponent(PrefabObjects spawnablePrefabs, int count)
		{
			for (int i = 0; i < count; i++)
			{
				NetworkObject val = spawnablePrefabs.GetObject(true, i);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && !IsGeneratedS1ApiPrefab(((Component)val).gameObject) && (Object)(object)FindPlainNpcComponent(((Component)val).gameObject) != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsGeneratedS1ApiPrefab(GameObject prefabRoot)
		{
			return (Object)(object)prefabRoot != (Object)null && !string.IsNullOrEmpty(((Object)prefabRoot).name) && ((Object)prefabRoot).name.StartsWith("S1API_", StringComparison.OrdinalIgnoreCase);
		}

		private static NetworkObject? ResolveNpcSpawnablePrefab(PrefabObjects spawnablePrefabs, int count, NpcRootRole rootRole)
		{
			if (rootRole == NpcRootRole.Dealer)
			{
				NetworkObject val = FindSpawnablePrefabByName(spawnablePrefabs, count, "Dealer") ?? FindSpawnablePrefabWithComponent<Dealer>(spawnablePrefabs, count);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			if (rootRole == NpcRootRole.Supplier)
			{
				NetworkObject val2 = FindSpawnablePrefabWithComponent<Supplier>(spawnablePrefabs, count);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return FindSpawnablePrefabByName(spawnablePrefabs, count, "CivilianNPC", "BaseNPC") ?? FindSpawnablePrefabWithPlainNpcComponent(spawnablePrefabs, count) ?? FindSpawnablePrefabByName(spawnablePrefabs, count, "BaseEmployee") ?? FindSpawnablePrefabWithComponent<NPC>(spawnablePrefabs, count);
		}

		private static NPC? FindPlainNpcComponent(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return null;
			}
			try
			{
				HashSet<int> employeeComponentInstanceIds = GetEmployeeComponentInstanceIds(prefabRoot);
				Il2CppArrayBase<NPC> components = prefabRoot.GetComponents<NPC>();
				foreach (NPC item in components)
				{
					if (IsPlainNpcComponent(item, employeeComponentInstanceIds))
					{
						return item;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static NPC? FindEmployeeNpcComponent(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return null;
			}
			Employee component = prefabRoot.GetComponent<Employee>();
			if ((Object)(object)component != (Object)null)
			{
				return (NPC?)(object)component;
			}
			try
			{
				Il2CppArrayBase<NPC> components = prefabRoot.GetComponents<NPC>();
				foreach (NPC item in components)
				{
					if (IsEmployeeNpcComponent(item))
					{
						return item;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static HashSet<int> GetEmployeeComponentInstanceIds(GameObject prefabRoot)
		{
			HashSet<int> hashSet = new HashSet<int>();
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return hashSet;
			}
			try
			{
				Il2CppArrayBase<Employee> components = prefabRoot.GetComponents<Employee>();
				foreach (Employee item in components)
				{
					if ((Object)(object)item != (Object)null)
					{
						hashSet.Add(((Object)item).GetInstanceID());
					}
				}
			}
			catch
			{
			}
			return hashSet;
		}

		private static bool IsPlainNpcComponent(NPC? component)
		{
			return IsPlainNpcComponent(component, null);
		}

		private static bool IsPlainNpcComponent(NPC? component, ISet<int>? employeeInstanceIds)
		{
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (employeeInstanceIds != null && employeeInstanceIds.Contains(((Object)component).GetInstanceID()))
			{
				return false;
			}
			return ((object)component).GetType().FullName == typeof(NPC).FullName;
		}

		private static bool IsEmployeeNpcComponent(NPC? component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (component is Employee)
			{
				return true;
			}
			string fullName = ((object)component).GetType().FullName;
			return fullName == "ScheduleOne.Employees.Employee" || fullName == "Il2CppScheduleOne.Employees.Employee";
		}

		private static NPC? GetPreferredNpcComponent(GameObject prefabRoot)
		{
			return (NPC?)(prefabRoot.GetComponent<Supplier>() ?? ((object)prefabRoot.GetComponent<Dealer>()) ?? ((object)(FindPlainNpcComponent(prefabRoot) ?? prefabRoot.GetComponent<NPC>())));
		}

		private static void NormalizeBaseEmployeePrefab(GameObject prefabRoot, string sourcePrefabName, NpcRootRole rootRole)
		{
			if ((Object)(object)prefabRoot == (Object)null || sourcePrefabName != "BaseEmployee")
			{
				return;
			}
			Dealer component = prefabRoot.GetComponent<Dealer>();
			NPC val = FindPlainNpcComponent(prefabRoot);
			NPC val2 = FindEmployeeNpcComponent(prefabRoot);
			if ((Object)(object)val2 == (Object)null && (Object)(object)val != (Object)null)
			{
				RepairNpcPrefabReferences(prefabRoot, val);
				switch (rootRole)
				{
				case NpcRootRole.Dealer:
					EnsureDealerComponentOnPrefab(prefabRoot);
					break;
				case NpcRootRole.Supplier:
					EnsureSupplierComponentOnPrefab(prefabRoot);
					break;
				}
				return;
			}
			if ((Object)(object)val2 == (Object)null && rootRole == NpcRootRole.Dealer && (Object)(object)component != (Object)null)
			{
				NPC val3 = (NPC)(((object)val) ?? ((object)component));
				RewireChildNpcReferences(prefabRoot, val3);
				RepairNpcPrefabReferences(prefabRoot, val3);
				LogBaseEmployeeNormalization();
				return;
			}
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = prefabRoot.GetComponent<NPC>();
			}
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			try
			{
				LogBaseEmployeeComponentState("before plain NPC AddComponent", prefabRoot);
				if (1 == 0)
				{
				}
				NPC val4 = (NPC)(rootRole switch
				{
					NpcRootRole.Dealer => prefabRoot.GetComponent<Dealer>(), 
					NpcRootRole.Supplier => prefabRoot.GetComponent<Supplier>(), 
					_ => val, 
				});
				if (1 == 0)
				{
				}
				NPC val5 = val4;
				if ((Object)(object)val5 == (Object)null)
				{
					if (1 == 0)
					{
					}
					Type type = rootRole switch
					{
						NpcRootRole.Dealer => typeof(Dealer), 
						NpcRootRole.Supplier => typeof(Supplier), 
						_ => typeof(NPC), 
					};
					if (1 == 0)
					{
					}
					Type type2 = type;
					LogBetaNpcPrefabDiagnostic($"[S1API][BaseEmployeeFallback] Adding {type2.FullName} to cloned prefab '{((Object)prefabRoot).name}'. Source={DescribeComponent((Component?)(object)val2)}");
					if (1 == 0)
					{
					}
					val4 = (NPC)(rootRole switch
					{
						NpcRootRole.Dealer => prefabRoot.AddComponent<Dealer>(), 
						NpcRootRole.Supplier => prefabRoot.AddComponent<Supplier>(), 
						_ => prefabRoot.AddComponent<NPC>(), 
					});
					if (1 == 0)
					{
					}
					val5 = val4;
					LogBetaNpcPrefabDiagnostic($"[S1API][BaseEmployeeFallback] AddComponent returned {DescribeComponent((Component?)(object)val5)}. IsPlain={IsPlainNpcComponent(val5)}, IsEmployee={IsEmployeeNpcComponent(val5)}");
					LogBetaNpcPrefabDiagnostic("[S1API][BaseEmployeeFallback] Immediate FindPlainNpcComponent returned " + DescribeComponent((Component?)(object)FindPlainNpcComponent(prefabRoot)));
					LogBaseEmployeeComponentState("after plain NPC AddComponent", prefabRoot);
				}
				if ((Object)(object)val2 != (Object)(object)val5)
				{
					CopyBaseNpcState(val2, val5);
					NPCDataAccess.AssignNewData(val5, rootRole, val2);
					LogBetaNpcPrefabDiagnostic($"[S1API][BaseEmployeeFallback] Copied base NPC state from {DescribeComponent((Component?)(object)val2)} to {DescribeComponent((Component?)(object)val5)}.");
					RemoveComponentImmediate((Component)(object)val2);
					LogBetaNpcPrefabDiagnostic("[S1API][BaseEmployeeFallback] Removed source NPC component " + DescribeComponent((Component?)(object)val2) + ".");
					LogBaseEmployeeComponentState("after source NPC removal", prefabRoot);
				}
				RemoveEmployeeComponentsFromBaseEmployeeFallback(prefabRoot);
				NormalizeBaseEmployeeDialogueComponents(prefabRoot, rootRole);
				LogBaseEmployeeComponentState("after employee cleanup", prefabRoot);
				RewireChildNpcReferences(prefabRoot, val5);
				RepairNpcPrefabReferences(prefabRoot, val5);
				LogBaseEmployeeNormalization();
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Failed to normalize BaseEmployee source prefab; using inherited NPC component fallback: " + ex.Message);
			}
		}

		private static void LogBaseEmployeeNormalization()
		{
			if (!_loggedBaseEmployeeNormalization)
			{
				_loggedBaseEmployeeNormalization = true;
				Logger.Debug("[S1API] Normalized BaseEmployee source prefab for beta NPC fallback.");
			}
		}

		private static void LogBetaNpcPrefabDiagnostic(string message)
		{
			if (LogBetaNpcPrefabDiagnostics)
			{
				Logger.Msg(message);
			}
		}

		private static void CopyBaseNpcState(NPC sourceNpc, NPC replacementNpc)
		{
			string[] baseNpcMembersToCopy = BaseNpcMembersToCopy;
			foreach (string memberName in baseNpcMembersToCopy)
			{
				object gameMember = GetGameMember(sourceNpc, memberName);
				if (gameMember != null)
				{
					SetGameMember(replacementNpc, memberName, gameMember);
				}
			}
		}

		private static void RewireChildNpcReferences(GameObject prefabRoot, NPC replacementNpc)
		{
			Component[] array = Il2CppArrayBase<Component>.op_Implicit(prefabRoot.GetComponentsInChildren<Component>(true));
			Component[] array2 = array;
			foreach (Component val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)replacementNpc))
				{
					string[] childNpcReferenceMemberNames = ChildNpcReferenceMemberNames;
					foreach (string memberName in childNpcReferenceMemberNames)
					{
						SetGameMember(val, memberName, replacementNpc);
					}
				}
			}
		}

		private static void RepairNpcPrefabReferences(GameObject prefabRoot, NPC npc)
		{
			if ((Object)(object)prefabRoot == (Object)null || (Object)(object)npc == (Object)null)
			{
				return;
			}
			NPCMovement val = prefabRoot.GetComponent<NPCMovement>() ?? prefabRoot.GetComponentInChildren<NPCMovement>(true);
			if ((Object)(object)val != (Object)null)
			{
				SetGameMember(npc, "Movement", val);
				SetGameMember(val, "npc", npc);
				val.Agent = EnsureRootNavMeshAgent(prefabRoot);
				NPCSpeedController val2 = prefabRoot.GetComponent<NPCSpeedController>() ?? prefabRoot.GetComponentInChildren<NPCSpeedController>(true);
				if ((Object)(object)val2 != (Object)null)
				{
					val.SpeedController = val2;
					SetGameMember(val2, "Movement", val);
				}
			}
		}

		private static NavMeshAgent EnsureRootNavMeshAgent(GameObject prefabRoot)
		{
			return prefabRoot.GetComponent<NavMeshAgent>() ?? prefabRoot.AddComponent<NavMeshAgent>();
		}

		private static Dealer? EnsureDealerComponentOnPrefab(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return null;
			}
			Dealer component = prefabRoot.GetComponent<Dealer>();
			if ((Object)(object)component != (Object)null)
			{
				RepairDealerPrefabReferences(prefabRoot, component);
				RepairNpcPrefabReferences(prefabRoot, (NPC)(object)component);
				return component;
			}
			NPC preferredNpcComponent = GetPreferredNpcComponent(prefabRoot);
			if ((Object)(object)preferredNpcComponent == (Object)null)
			{
				return null;
			}
			Dealer val = prefabRoot.AddComponent<Dealer>();
			CopyBaseNpcState(preferredNpcComponent, (NPC)(object)val);
			NPCDataAccess.AssignNewData((NPC)(object)val, NpcRootRole.Dealer, preferredNpcComponent);
			RewireChildNpcReferences(prefabRoot, (NPC)(object)val);
			RepairDealerPrefabReferences(prefabRoot, val);
			RepairNpcPrefabReferences(prefabRoot, (NPC)(object)val);
			return val;
		}

		private static Supplier? EnsureSupplierComponentOnPrefab(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return null;
			}
			SupplierRuntimeCoordinator.EnsurePrefabInfrastructure(prefabRoot);
			Supplier component = prefabRoot.GetComponent<Supplier>();
			if ((Object)(object)component != (Object)null)
			{
				NPCDataAccess.AssignNewData((NPC)(object)component, NpcRootRole.Supplier, (NPC?)(object)component);
				SupplierRuntimeCoordinator.BindPrefabInfrastructure(component);
				RepairNpcPrefabReferences(prefabRoot, (NPC)(object)component);
				return component;
			}
			NPC preferredNpcComponent = GetPreferredNpcComponent(prefabRoot);
			if ((Object)(object)preferredNpcComponent == (Object)null)
			{
				return null;
			}
			Supplier val = prefabRoot.AddComponent<Supplier>();
			CopyBaseNpcState(preferredNpcComponent, (NPC)(object)val);
			NPCDataAccess.AssignNewData((NPC)(object)val, NpcRootRole.Supplier, preferredNpcComponent);
			RewireChildNpcReferences(prefabRoot, (NPC)(object)val);
			SupplierRuntimeCoordinator.BindPrefabInfrastructure(val);
			RepairNpcPrefabReferences(prefabRoot, (NPC)(object)val);
			if ((Object)(object)preferredNpcComponent != (Object)(object)val)
			{
				RemoveComponentImmediate((Component)(object)preferredNpcComponent);
			}
			return val;
		}

		private static void RepairDealerPrefabReferences(GameObject prefabRoot, Dealer dealer)
		{
			if (dealer.HomeEvent == null)
			{
				NPCEvent_StayInBuilding val = (dealer.HomeEvent = prefabRoot.GetComponentInChildren<NPCEvent_StayInBuilding>(true));
			}
			DialogueController_Dealer val2 = prefabRoot.GetComponentInChildren<DialogueController_Dealer>(true);
			if ((Object)(object)val2 == (Object)null)
			{
				DialogueController componentInChildren2 = prefabRoot.GetComponentInChildren<DialogueController>(true);
				GameObject val3 = (((Object)(object)componentInChildren2 != (Object)null) ? ((Component)componentInChildren2).gameObject : ((Component)((NPC)dealer).DialogueHandler).gameObject);
				val2 = val3.AddComponent<DialogueController_Dealer>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					((DialogueController)val2).IntObj = componentInChildren2.IntObj;
					((DialogueController)val2).GenericDialogue = componentInChildren2.GenericDialogue;
					((DialogueController)val2).DialogueEnabled = componentInChildren2.DialogueEnabled;
					((DialogueController)val2).UseDialogueBehaviour = componentInChildren2.UseDialogueBehaviour;
					((DialogueController)val2).Choices = componentInChildren2.Choices;
					((DialogueController)val2).GreetingOverrides = componentInChildren2.GreetingOverrides;
					((DialogueController)val2).OverrideContainer = componentInChildren2.OverrideContainer;
					RemoveComponentImmediate((Component)(object)componentInChildren2);
				}
			}
			dealer.DialogueController = val2;
		}

		private static string DescribeComponent(Component? component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return "<null>";
			}
			try
			{
				Type type = ((object)component).GetType();
				return $"{type.FullName ?? type.Name}#{((Object)component).GetInstanceID()}";
			}
			catch (Exception ex)
			{
				return "<component describe failed: " + ex.Message + ">";
			}
		}

		private static void LogBaseEmployeeComponentState(string stage, GameObject prefabRoot)
		{
			if (!LogBetaNpcPrefabDiagnostics)
			{
				return;
			}
			if ((Object)(object)prefabRoot == (Object)null)
			{
				Logger.Msg("[S1API][BaseEmployeeFallback] " + stage + ": prefabRoot=<null>");
				return;
			}
			try
			{
				StringBuilder stringBuilder = new StringBuilder();
				StringBuilder stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder3 = stringBuilder2;
				StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(72, 4, stringBuilder2);
				handler.AppendLiteral("[S1API][BaseEmployeeFallback] ");
				handler.AppendFormatted(stage);
				handler.AppendLiteral(": root='");
				handler.AppendFormatted(((Object)prefabRoot).name);
				handler.AppendLiteral("', activeSelf=");
				handler.AppendFormatted(prefabRoot.activeSelf);
				handler.AppendLiteral(", activeInHierarchy=");
				handler.AppendFormatted(prefabRoot.activeInHierarchy);
				stringBuilder3.Append(ref handler);
				HashSet<int> employeeComponentInstanceIds = GetEmployeeComponentInstanceIds(prefabRoot);
				Il2CppArrayBase<NPC> components = prefabRoot.GetComponents<NPC>();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder4 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(17, 1, stringBuilder2);
				handler.AppendLiteral(", npcComponents=");
				handler.AppendFormatted(components.Length);
				handler.AppendLiteral("[");
				stringBuilder4.Append(ref handler);
				for (int i = 0; i < components.Length; i++)
				{
					if (i > 0)
					{
						stringBuilder.Append("; ");
					}
					NPC val = components[i];
					stringBuilder.Append(DescribeComponent((Component?)(object)val));
					stringBuilder2 = stringBuilder;
					StringBuilder stringBuilder5 = stringBuilder2;
					handler = new StringBuilder.AppendInterpolatedStringHandler(28, 3, stringBuilder2);
					handler.AppendLiteral(", plain=");
					handler.AppendFormatted(IsPlainNpcComponent(val, employeeComponentInstanceIds));
					handler.AppendLiteral(", employee=");
					handler.AppendFormatted(employeeComponentInstanceIds.Contains(((Object)val).GetInstanceID()) || IsEmployeeNpcComponent(val));
					handler.AppendLiteral(", dealer=");
					handler.AppendFormatted(val is Dealer);
					stringBuilder5.Append(ref handler);
				}
				stringBuilder.Append(']');
				Il2CppArrayBase<Employee> components2 = prefabRoot.GetComponents<Employee>();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder6 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(22, 1, stringBuilder2);
				handler.AppendLiteral(", employeeComponents=");
				handler.AppendFormatted(components2.Length);
				handler.AppendLiteral("[");
				stringBuilder6.Append(ref handler);
				for (int j = 0; j < components2.Length; j++)
				{
					if (j > 0)
					{
						stringBuilder.Append("; ");
					}
					stringBuilder.Append(DescribeComponent((Component?)(object)components2[j]));
				}
				stringBuilder.Append(']');
				Il2CppArrayBase<Dealer> components3 = prefabRoot.GetComponents<Dealer>();
				stringBuilder2 = stringBuilder;
				StringBuilder stringBuilder7 = stringBuilder2;
				handler = new StringBuilder.AppendInterpolatedStringHandler(20, 1, stringBuilder2);
				handler.AppendLiteral(", dealerComponents=");
				handler.AppendFormatted(components3.Length);
				handler.AppendLiteral("[");
				stringBuilder7.Append(ref handler);
				for (int k = 0; k < components3.Length; k++)
				{
					if (k > 0)
					{
						stringBuilder.Append("; ");
					}
					stringBuilder.Append(DescribeComponent((Component?)(object)components3[k]));
				}
				stringBuilder.Append(']');
				Logger.Msg(stringBuilder.ToString());
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API][BaseEmployeeFallback] Failed to log component state at '" + stage + "': " + ex.Message);
			}
		}

		private static void RemoveEmployeeComponentsFromBaseEmployeeFallback(GameObject prefabRoot)
		{
			if ((Object)(object)prefabRoot == (Object)null || (Object)(object)FindPlainNpcComponent(prefabRoot) == (Object)null)
			{
				return;
			}
			try
			{
				int num = 0;
				Il2CppArrayBase<Employee> components = prefabRoot.GetComponents<Employee>();
				foreach (Employee item in components)
				{
					if (!((Object)(object)item == (Object)null))
					{
						RemoveComponentImmediate((Component)(object)item);
						num++;
					}
				}
				Il2CppArrayBase<NPC> components2 = prefabRoot.GetComponents<NPC>();
				foreach (NPC item2 in components2)
				{
					if (!((Object)(object)item2 == (Object)null) && IsEmployeeNpcComponent(item2))
					{
						RemoveComponentImmediate((Component)(object)item2);
						num++;
					}
				}
				if (num > 0)
				{
					Logger.Debug($"[S1API] Removed {num} Employee component(s) from {"BaseEmployee"} NPC fallback prefab.");
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Failed to remove Employee component(s) from BaseEmployee fallback prefab: " + ex.Message);
			}
		}

		private static void NormalizeBaseEmployeeDialogueComponents(GameObject prefabRoot, NpcRootRole rootRole)
		{
			if ((Object)(object)prefabRoot == (Object)null || rootRole != NpcRootRole.Plain)
			{
				return;
			}
			try
			{
				Il2CppArrayBase<DialogueController_Employee> componentsInChildren = prefabRoot.GetComponentsInChildren<DialogueController_Employee>(true);
				foreach (DialogueController_Employee item in componentsInChildren)
				{
					if (!((Object)(object)item == (Object)null))
					{
						GameObject val = ((Component)item).gameObject;
						DialogueController component = val.GetComponent<DialogueController>();
						if ((Object)(object)component == (Object)null || (Object)(object)component == (Object)(object)item)
						{
							component = val.AddComponent<DialogueController>();
							component.IntObj = ((DialogueController)item).IntObj;
							component.GenericDialogue = ((DialogueController)item).GenericDialogue;
							component.DialogueEnabled = ((DialogueController)item).DialogueEnabled;
							component.UseDialogueBehaviour = ((DialogueController)item).UseDialogueBehaviour;
							component.Choices = new List<DialogueChoice>();
							component.GreetingOverrides = new List<GreetingOverride>();
							component.OverrideContainer = null;
						}
						RemoveComponentImmediate((Component)(object)item);
						Logger.Debug("[S1API][BaseEmployeeFallback][Dialogue] Replaced employee dialogue controller on '" + ((Object)val).name + "' with the base civilian controller.");
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API][BaseEmployeeFallback][Dialogue] Failed to normalize employee dialogue components: " + ex.Message);
			}
		}

		private static void RemoveComponentImmediate(Component component)
		{
			try
			{
				Object.DestroyImmediate((Object)(object)component);
			}
			catch
			{
				Object.Destroy((Object)(object)component);
			}
		}

		private static GameObject GetOrCreatePerNpcPrefab(Type npcType, NPC? owner)
		{
			if (npcType == null)
			{
				throw new Exception("NPC type is null for prefab resolution.");
			}
			if (TypeToPrefab.TryGetValue(npcType, out GameObject value) && (Object)(object)value != (Object)null)
			{
				FinalizeSupplierPrefabIfNeeded(npcType, value);
				MarkPrefabsConfigured();
				return value;
			}
			lock (TemplateLoadLock)
			{
				if (TypeToPrefab.TryGetValue(npcType, out value) && (Object)(object)value != (Object)null)
				{
					FinalizeSupplierPrefabIfNeeded(npcType, value);
					MarkPrefabsConfigured();
					return value;
				}
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if ((Object)(object)networkManager == (Object)null)
				{
					throw new Exception("NetworkManager not found when resolving NPC prefab.");
				}
				PrefabObjects spawnablePrefabs = networkManager.SpawnablePrefabs;
				if ((Object)(object)spawnablePrefabs == (Object)null)
				{
					throw new Exception("SpawnablePrefabs not available on NetworkManager.");
				}
				NetworkObject val = null;
				int objectCount = spawnablePrefabs.GetObjectCount();
				NpcRootRole declaredRootRole = GetDeclaredRootRole(npcType);
				val = ResolveNpcSpawnablePrefab(spawnablePrefabs, objectCount, declaredRootRole);
				if ((Object)(object)val == (Object)null)
				{
					throw new Exception("Failed to locate a suitable NPC spawnable prefab (Dealer, CivilianNPC, BaseNPC, BaseEmployee, or any with NPC component).");
				}
				string text = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : string.Empty);
				LogBetaNpcPrefabDiagnostic($"[S1API][NPCPrefabSelection] Type={npcType.FullName}, RootRole={declaredRootRole}, SourcePrefab='{text}', Source={DescribeComponent((Component?)(object)val)}");
				if ((Object)(object)((Component)val).gameObject != (Object)null)
				{
					LogBaseEmployeeComponentState("selected source prefab before clone", ((Component)val).gameObject);
				}
				string prefabNameForType = GetPrefabNameForType(npcType);
				bool flag = false;
				bool flag2 = false;
				if (text == "BaseEmployee" && (Object)(object)((Component)val).gameObject != (Object)null)
				{
					flag2 = ((Component)val).gameObject.activeSelf;
					flag = flag2;
					if (flag2)
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
				NetworkObject val2;
				try
				{
					val2 = Object.Instantiate<NetworkObject>(val);
					GameObject obj = ((Component)val2).gameObject;
					if (obj != null)
					{
						obj.SetActive(false);
					}
					DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(63, 3);
					defaultInterpolatedStringHandler.AppendLiteral("[S1API][NPCPrefabSelection] Cloned source '");
					defaultInterpolatedStringHandler.AppendFormatted(text);
					defaultInterpolatedStringHandler.AppendLiteral("' into '");
					GameObject obj2 = ((Component)val2).gameObject;
					defaultInterpolatedStringHandler.AppendFormatted(((obj2 != null) ? ((Object)obj2).name : null) ?? "<null>");
					defaultInterpolatedStringHandler.AppendLiteral("' for type ");
					defaultInterpolatedStringHandler.AppendFormatted(npcType.FullName);
					defaultInterpolatedStringHandler.AppendLiteral(".");
					LogBetaNpcPrefabDiagnostic(defaultInterpolatedStringHandler.ToStringAndClear());
					if ((Object)(object)((Component)val2).gameObject != (Object)null)
					{
						LogBaseEmployeeComponentState("cloned prefab before normalization", ((Component)val2).gameObject);
					}
				}
				finally
				{
					if (flag && (Object)(object)((Component)val).gameObject != (Object)null)
					{
						((Component)val).gameObject.SetActive(flag2);
					}
				}
				NormalizeBaseEmployeePrefab(((Component)val2).gameObject, text, declaredRootRole);
				((Object)((Component)val2).gameObject).name = prefabNameForType;
				try
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null)
					{
						((Component)val2).gameObject.SetActive(false);
						Dealer component = ((Component)val2).gameObject.GetComponent<Dealer>();
						NPC val3 = (NPC)(((Object)(object)component != (Object)null) ? ((object)component) : ((object)((Component)val2).gameObject.GetComponent<NPC>()));
						if ((Object)(object)val3 != (Object)null)
						{
							List<NPC> nPCRegistry = NPCManager.NPCRegistry;
							if (nPCRegistry != null && nPCRegistry.Count > 0)
							{
								for (int num = nPCRegistry.Count - 1; num >= 0; num--)
								{
									if ((Object)(object)nPCRegistry[num] == (Object)(object)val3)
									{
										nPCRegistry.RemoveAt(num);
										break;
									}
								}
							}
						}
					}
				}
				catch
				{
				}
				if (val2 == null)
				{
					throw new InvalidOperationException("NPC prefab is missing its NetworkObject.");
				}
				GameObject prefabRoot = ((Component)val2).gameObject ?? throw new InvalidOperationException("NPC prefab is missing its GameObject.");
				NPCPrefabBuilder builder = new NPCPrefabBuilder(prefabRoot, npcType);
				if (owner != null)
				{
					owner.ConfigurePrefab(builder);
				}
				else
				{
					InvokeConfigurePrefabWithoutInstance(npcType, builder);
				}
				switch (GetDeclaredRootRole(npcType))
				{
				case NpcRootRole.Dealer:
				{
					Dealer val5 = EnsureDealerComponentOnPrefab(((Component)val2).gameObject);
					DealerDataBuilder.DealerConfigData dealerConfigData = BuildDealerDefaultsForType(npcType);
					if ((Object)(object)val5 != (Object)null && dealerConfigData != null)
					{
						TryApplyDealerDefaults(val5, dealerConfigData);
					}
					break;
				}
				case NpcRootRole.Supplier:
				{
					Supplier val4 = EnsureSupplierComponentOnPrefab(((Component)val2).gameObject);
					SupplierDataBuilder.SupplierConfigData supplierConfigData = BuildSupplierDefaultsForType(npcType);
					if ((Object)(object)val4 != (Object)null && supplierConfigData != null)
					{
						TryApplySupplierDefaults(val4, supplierConfigData);
					}
					SupplierRuntimeCoordinator.FinalizePrefabInfrastructure(((Component)val2).gameObject, supplierConfigData?.PersistentId);
					break;
				}
				}
				try
				{
					EnsureScheduleActionsOnPrefab(((Component)val2).gameObject);
				}
				catch
				{
				}
				if (text == "BaseEmployee")
				{
					RemoveEmployeeComponentsFromBaseEmployeeFallback(((Component)val2).gameObject);
				}
				if (owner == null)
				{
					try
					{
						if (IsCustomerType(npcType))
						{
							Customer val6 = ((Component)val2).gameObject.GetComponent<Customer>();
							if ((Object)(object)val6 == (Object)null)
							{
								val6 = ((Component)val2).gameObject.AddComponent<Customer>();
							}
							Action<CustomerDataBuilder> customerDefaultsForType = GetCustomerDefaultsForType(npcType);
							if (customerDefaultsForType != null && (Object)(object)val6 != (Object)null)
							{
								CustomerData val7 = BuildCustomerDefaultsForType(npcType);
								if ((Object)(object)val7 != (Object)null)
								{
									TrySetCustomerDataOnComponent(val6, val7);
								}
							}
						}
					}
					catch
					{
					}
				}
				RepairBehaviourOwnership(prefabRoot, GetPreferredNpcComponent(prefabRoot));
				try
				{
					if ((Object)(object)spawnablePrefabs != (Object)null)
					{
						bool flag3 = false;
						int objectCount2 = spawnablePrefabs.GetObjectCount();
						for (int i = 0; i < objectCount2; i++)
						{
							NetworkObject val8 = spawnablePrefabs.GetObject(true, i);
							if ((Object)(object)val8 != (Object)null && (Object)(object)((Component)val8).gameObject != (Object)null && ((Object)((Component)val8).gameObject).name == prefabNameForType)
							{
								flag3 = true;
								break;
							}
						}
						if (!flag3)
						{
							spawnablePrefabs.AddObject(val2, false);
						}
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("[S1API] Failed to register " + prefabNameForType + " in SpawnablePrefabs: " + ex.Message);
				}
				NPCPrefabContainer.OrganizePrefab(((Component)val2).gameObject, npcType.Name);
				TypeToPrefab[npcType] = ((Component)val2).gameObject;
				MarkPrefabsConfigured();
				return ((Component)val2).gameObject;
			}
		}

		private static void FinalizeSupplierPrefabIfNeeded(Type npcType, GameObject prefabRoot)
		{
			if (!((Object)(object)prefabRoot == (Object)null) && GetDeclaredRootRole(npcType) == NpcRootRole.Supplier)
			{
				SupplierRuntimeCoordinator.FinalizePrefabInfrastructure(prefabRoot, BuildSupplierDefaultsForType(npcType)?.PersistentId);
			}
		}

		private static NpcRootRole GetDeclaredRootRole(Type npcType)
		{
			bool flag = IsDealerType(npcType);
			bool flag2 = IsSupplierType(npcType);
			bool flag3 = false;
			try
			{
				NPC nPC = (NPC)FormatterServices.GetUninitializedObject(npcType);
				flag |= nPC.IsDealer;
				flag2 |= nPC.IsSupplier;
				flag3 = nPC.IsPhysical;
			}
			catch
			{
			}
			if (flag && flag2)
			{
				throw new InvalidOperationException("Custom NPC type '" + npcType.FullName + "' cannot be both a dealer and a supplier root.");
			}
			if (flag2)
			{
				if (!flag3)
				{
					throw new InvalidOperationException("Custom supplier type '" + npcType.FullName + "' must override IsPhysical to return true.");
				}
				RegisterSupplierType(npcType);
				return NpcRootRole.Supplier;
			}
			if (flag)
			{
				RegisterDealerType(npcType);
				return NpcRootRole.Dealer;
			}
			return NpcRootRole.Plain;
		}

		private static void InvokeConfigurePrefabWithoutInstance(Type npcType, NPCPrefabBuilder builder)
		{
			if (npcType == null || builder == null)
			{
				return;
			}
			MethodInfo method = npcType.GetMethod("ConfigurePrefab", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (method == null || method.DeclaringType == typeof(NPC))
			{
				return;
			}
			NPC nPC = null;
			try
			{
				nPC = (NPC)FormatterServices.GetUninitializedObject(npcType);
				method.Invoke(nPC, new object[1] { builder });
			}
			finally
			{
				nPC = null;
			}
		}

		private static string GetPrefabNameForType(Type npcType)
		{
			string text = ((npcType != null) ? npcType.Name : "UnknownNPC");
			return "S1API_" + text;
		}

		internal static bool TryGetConfiguredNpcId(Type npcType, out string id)
		{
			id = string.Empty;
			if (npcType == null)
			{
				return false;
			}
			if (TypeToPrefab.TryGetValue(npcType, out GameObject value) && (Object)(object)value != (Object)null)
			{
				NPCPrefabIdentity component = value.GetComponent<NPCPrefabIdentity>();
				if (!string.IsNullOrWhiteSpace(component?.Id))
				{
					id = component.Id;
					return true;
				}
			}
			if (!NPCPrefabIdentity.TryGetIdentityFromRegistry(GetPrefabNameForType(npcType), out string id2, out string _, out string _, out Sprite _) || string.IsNullOrWhiteSpace(id2))
			{
				return false;
			}
			id = id2;
			return true;
		}

		internal static NPC? CreateWrapperForNetworkSpawnedNPC(NPC baseNpc)
		{
			if ((Object)(object)baseNpc == (Object)null)
			{
				return null;
			}
			try
			{
				NPCPrefabIdentity component = ((Component)baseNpc).GetComponent<NPCPrefabIdentity>();
				string text = ((Object)((Component)baseNpc).gameObject).name;
				if (text.EndsWith("(Clone)"))
				{
					text = text.Substring(0, text.Length - 7);
				}
				if (!text.StartsWith("S1API_", StringComparison.Ordinal) && (Object)(object)component == (Object)null)
				{
					return null;
				}
				string text2 = (text.StartsWith("S1API_", StringComparison.Ordinal) ? text.Substring(6) : null);
				if (string.IsNullOrEmpty(text2))
				{
					return null;
				}
				Type type = null;
				Type typeFromHandle = typeof(NPC);
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length && type == null; i++)
				{
					Assembly assembly = assemblies[i];
					if (assembly == typeFromHandle.Assembly)
					{
						continue;
					}
					Type[] types;
					try
					{
						types = assembly.GetTypes();
					}
					catch
					{
						continue;
					}
					foreach (Type type2 in types)
					{
						if (!(type2 == null) && !type2.IsAbstract && typeFromHandle.IsAssignableFrom(type2) && type2.Name == text2)
						{
							type = type2;
							break;
						}
					}
				}
				if (type == null)
				{
					return null;
				}
				for (int k = 0; k < All.Count; k++)
				{
					NPC nPC = All[k];
					if (nPC != null && (Object)(object)nPC.S1NPC == (Object)(object)baseNpc)
					{
						return nPC;
					}
				}
				NPC nPC2 = (NPC)FormatterServices.GetUninitializedObject(type);
				bool flag = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(nPC2, "S1NPC", baseNpc);
				bool flag2 = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(nPC2, "IsCustomNPC", true);
				bool flag3 = false;
				FieldInfo[] allFields = global::S1API.Internal.Utils.ReflectionUtils.GetAllFields(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in allFields)
				{
					if ((fieldInfo.Name == "<gameObject>k__BackingField" || fieldInfo.Name == "gameObject") && fieldInfo.FieldType == typeof(GameObject))
					{
						try
						{
							fieldInfo.SetValue(nPC2, ((Component)baseNpc).gameObject);
							flag3 = true;
						}
						catch (Exception ex)
						{
							Logger.Warning("CreateWrapperForNetworkSpawnedNPC: Exception setting gameObject backing field '" + fieldInfo.Name + "': " + ex.Message);
							continue;
						}
						break;
					}
				}
				if (!flag3)
				{
					flag3 = global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(nPC2, "gameObject", ((Component)baseNpc).gameObject);
				}
				if (!flag)
				{
					Logger.Warning("CreateWrapperForNetworkSpawnedNPC: Could not set S1NPC field/property for '" + baseNpc.ID + "'.");
					return null;
				}
				if (!flag3)
				{
					Logger.Warning("CreateWrapperForNetworkSpawnedNPC: Could not set gameObject field/property for '" + baseNpc.ID + "'. Tried backing field and property setter.");
					return null;
				}
				if ((Object)(object)nPC2.S1NPC != (Object)(object)baseNpc)
				{
					Logger.Warning("CreateWrapperForNetworkSpawnedNPC: S1NPC field not set correctly for '" + baseNpc.ID + "'.");
					return null;
				}
				if ((Object)(object)nPC2.gameObject != (Object)(object)((Component)baseNpc).gameObject)
				{
					Logger.Warning("CreateWrapperForNetworkSpawnedNPC: gameObject field not set correctly for '" + baseNpc.ID + "'.");
					return null;
				}
				InitializeWrapperStateFromNetworkSpawn(nPC2, baseNpc);
				All.Add(nPC2);
				return nPC2;
			}
			catch (Exception ex2)
			{
				Logger.Warning("CreateWrapperForNetworkSpawnedNPC: Exception creating wrapper for '" + (((baseNpc != null) ? baseNpc.ID : null) ?? "<null>") + "': " + ex2.Message);
				Logger.Warning("Stack trace: " + ex2.StackTrace);
				return null;
			}
		}

		private static void InitializeWrapperStateFromNetworkSpawn(NPC wrapper, NPC baseNpc)
		{
			if (wrapper == null || (Object)(object)baseNpc == (Object)null)
			{
				return;
			}
			try
			{
				object obj = baseNpc.Avatar;
				if (obj == null)
				{
					GameObject obj2 = ((Component)baseNpc).gameObject;
					obj = ((obj2 != null) ? obj2.GetComponentInChildren<Avatar>(true) : null);
				}
				wrapper.Appearance = new NPCAppearance(wrapper, wrapper._runtimeAvatar = (Avatar?)obj);
				wrapper.RestoreRuntimeAvatarAppearance();
				GameObject obj3 = ((Component)baseNpc).gameObject;
				NPCPrefabIdentity nPCPrefabIdentity = ((obj3 != null) ? obj3.GetComponent<NPCPrefabIdentity>() : null);
				if ((Object)(object)nPCPrefabIdentity != (Object)null)
				{
					nPCPrefabIdentity.ApplyRelationshipConnectionsTo(baseNpc);
					wrapper._hasExplicitIcon = (Object)(object)nPCPrefabIdentity.Icon != (Object)null;
				}
				wrapper.RefreshMessagingIcons();
				wrapper._relationshipDataAppliedFromPrefab = (Object)(object)nPCPrefabIdentity != (Object)null && baseNpc.RelationData != null;
				try
				{
					List<NPC> nPCRegistry = NPCManager.NPCRegistry;
					if (nPCRegistry != null && !nPCRegistry.Contains(baseNpc))
					{
						nPCRegistry.Add(baseNpc);
					}
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("InitializeWrapperStateFromNetworkSpawn: Failed for '" + (((baseNpc != null) ? baseNpc.ID : null) ?? "<null>") + "': " + ex.Message);
			}
		}

		public void RefreshMessagingIcons()
		{
			try
			{
				Sprite icon = Icon;
				if (!((Object)(object)icon == (Object)null))
				{
					NPC s1NPC = S1NPC;
					MSGConversation val = ((s1NPC != null) ? s1NPC.MSGConversation : null);
					if (val != null)
					{
						RectTransform rect = val.entry ?? ResolveConversationRect(val, "entry");
						RectTransform rect2 = ResolveConversationRect(val, "container");
						TryApplyIconToRect(rect, icon);
						TryApplyIconToRect(rect2, icon);
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("RefreshMessagingIcons failed for '" + GetSafeNpcId() + "': " + ex.Message);
			}
		}

		private void TryApplyIconToRect(RectTransform? rect, Sprite sprite)
		{
			if (!((Object)(object)rect == (Object)null) && !((Object)(object)sprite == (Object)null))
			{
				ApplyIconToPath(rect, null, sprite);
				ApplyIconToPath(rect, "Icon", sprite);
				ApplyIconToPath(rect, "IconMask/Icon", sprite);
			}
		}

		private static void ApplyIconToPath(RectTransform root, string? childPath, Sprite sprite)
		{
			if ((Object)(object)root == (Object)null || (Object)(object)sprite == (Object)null)
			{
				return;
			}
			Transform val = (Transform)(string.IsNullOrEmpty(childPath) ? ((object)root) : ((object)((Transform)root).Find(childPath)));
			if (!((Object)(object)val == (Object)null))
			{
				Image component = ((Component)val).GetComponent<Image>();
				if (!((Object)(object)component == (Object)null))
				{
					component.sprite = sprite;
					((Behaviour)component).enabled = true;
				}
			}
		}

		private static RectTransform? ResolveConversationRect(MSGConversation convo, string memberName)
		{
			if (convo == null || string.IsNullOrEmpty(memberName))
			{
				return null;
			}
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(convo, memberName);
			return (RectTransform?)((obj is RectTransform) ? obj : null);
		}

		internal static void RegisterSchedulePlanForType(Type npcType, List<IScheduleActionSpec> specs)
		{
			if (!(npcType == null) && specs != null)
			{
				TypeToSchedulePlan[npcType] = specs;
			}
		}

		public static void PreRegisterPrefabForType(Type npcType)
		{
			try
			{
				GetOrCreatePerNpcPrefab(npcType, null);
			}
			catch (Exception ex)
			{
				Exception ex2 = ((ex is TargetInvocationException ex3) ? ex3.InnerException : ex);
				string text = ex2?.Message ?? ex.Message;
				string text2 = ex2?.StackTrace ?? ex.StackTrace;
				Logger.Warning("[S1API] Failed to pre-register NPC prefab for " + npcType?.Name + ": " + text);
				if (!string.IsNullOrEmpty(text2))
				{
					Logger.Warning("[S1API] Stack trace: " + text2);
				}
			}
		}

		public static void PreRegisterAllNpcPrefabs()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				PrefabObjects val = ((networkManager != null) ? networkManager.SpawnablePrefabs : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Type typeFromHandle = typeof(NPC);
				Assembly assembly = typeFromHandle.Assembly;
				List<Type> list = new List<Type>();
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				foreach (Assembly assembly2 in assemblies)
				{
					Type[] types;
					try
					{
						types = assembly2.GetTypes();
					}
					catch
					{
						continue;
					}
					foreach (Type type in types)
					{
						if (!(type == null) && !type.IsAbstract && typeFromHandle.IsAssignableFrom(type) && !(type.Assembly == assembly))
						{
							list.Add(type);
						}
					}
				}
				foreach (Type item in list.OrderBy<Type, string>((Type candidate) => candidate.FullName, StringComparer.Ordinal))
				{
					PreRegisterPrefabForType(item);
				}
				SupplierRuntimeCoordinator.EnsureAllDeliveryPrefabsRegistered();
				MarkPrefabsConfigured();
			}
			catch (Exception ex)
			{
				Logger.Error("[S1API] PreRegisterAllNpcPrefabs failed: " + ex.Message);
				Logger.Error("[S1API] Stack Trace: " + ex.StackTrace);
			}
		}

		internal static void RegisterCustomerDefaultsForType(Type npcType, Action<CustomerDataBuilder> configure)
		{
			if (!(npcType == null) && configure != null)
			{
				TypeToCustomerDefaults[npcType] = configure;
			}
		}

		internal static void RegisterCustomerType(Type npcType)
		{
			if (!(npcType == null))
			{
				CustomerTypes.Add(npcType);
			}
		}

		internal static bool IsCustomerType(Type npcType)
		{
			if (npcType == null)
			{
				return false;
			}
			return CustomerTypes.Contains(npcType);
		}

		internal static bool HasCustomerDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return false;
			}
			Action<CustomerDataBuilder> value;
			return TypeToCustomerDefaults.TryGetValue(npcType, out value) && value != null;
		}

		internal static Action<CustomerDataBuilder>? GetCustomerDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			TypeToCustomerDefaults.TryGetValue(npcType, out Action<CustomerDataBuilder> value);
			return value;
		}

		internal static CustomerData? BuildCustomerDefaultsForType(Type npcType)
		{
			Action<CustomerDataBuilder> customerDefaultsForType = GetCustomerDefaultsForType(npcType);
			if (customerDefaultsForType == null)
			{
				return null;
			}
			CustomerDataBuilder customerDataBuilder = new CustomerDataBuilder();
			customerDefaultsForType(customerDataBuilder);
			return customerDataBuilder.BuildInternal();
		}

		internal static bool TrySetCustomerDataOnComponent(Customer customerComponent, CustomerData data)
		{
			if ((Object)(object)customerComponent == (Object)null || (Object)(object)data == (Object)null)
			{
				return false;
			}
			try
			{
				customerComponent.customerData = data;
				customerComponent.currentAffinityData = data.DefaultAffinityData;
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static bool TryApplyDealerDefaults(Dealer? dealerComponent, DealerDataBuilder.DealerConfigData data)
		{
			if (dealerComponent == null || data == null)
			{
				return false;
			}
			try
			{
				NPCDataAccess.ApplyDealerDefaults(dealerComponent, data);
				string empty = string.Empty;
				try
				{
					empty = ((NPC)dealerComponent).ID ?? ((dealerComponent != null) ? ((Object)dealerComponent).name : null) ?? "<unknown-dealer>";
				}
				catch
				{
					empty = "<unknown-dealer>";
				}
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealerComponent, "SigningFee", data.SigningFee);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealerComponent, "Cut", data.Cut);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealerComponent, "DealerType", (object)(EDealerType)data.DealerType);
				string text = null;
				if (data.Home != null)
				{
					text = data.Home.Name;
				}
				else if (!string.IsNullOrEmpty(data.HomeName))
				{
					text = data.HomeName;
				}
				if (!string.IsNullOrEmpty(text))
				{
					GameObject val = ((dealerComponent != null) ? ((Component)dealerComponent).gameObject : null);
					if (val == null)
					{
						Logger.Warning($"[NPC] TryApplyDealerDefaults: Dealer {empty} has no GameObject. Building name '{text}' will not be stored.");
						return false;
					}
					NPCPrefabIdentity component = val.GetComponent<NPCPrefabIdentity>();
					if ((Object)(object)component != (Object)null)
					{
						component.DealerHomeBuildingName = text;
						string text2 = ((Object)val).name;
						if (text2.EndsWith("(Clone)"))
						{
							text2 = text2.Substring(0, text2.Length - 7);
						}
						component.RegisterToStaticCache(text2);
					}
					else
					{
						Logger.Warning($"[NPC] TryApplyDealerDefaults: NPCPrefabIdentity component not found on {((Object)val).name} for dealer {empty}. Building name '{text}' will not be stored.");
					}
				}
				else
				{
					Logger.Warning($"[NPC] TryApplyDealerDefaults: No building name to store for dealer {empty}. Home={data.Home != null}, HomeName={data.HomeName ?? "null"}");
				}
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("[NPC] TryApplyDealerDefaults: Exception applying dealer defaults: " + ex.Message);
				Logger.Error("[NPC] Stack trace: " + ex.StackTrace);
				return false;
			}
		}

		internal static void RegisterRelationshipDefaultsForType(Type npcType, Action<NPCRelationshipDataBuilder> configure)
		{
			if (!(npcType == null) && configure != null)
			{
				TypeToRelationshipDefaults[npcType] = configure;
			}
		}

		internal static void RegisterDealerDefaultsForType(Type npcType, Action<DealerDataBuilder> configure)
		{
			if (npcType == null || configure == null)
			{
				return;
			}
			TypeToDealerDefaults[npcType] = configure;
			try
			{
				DealerDataBuilder dealerDataBuilder = new DealerDataBuilder();
				configure(dealerDataBuilder);
				TypeToBuiltDealerDefaults[npcType] = dealerDataBuilder.BuildInternal();
			}
			catch (Exception ex)
			{
				TypeToBuiltDealerDefaults.Remove(npcType);
				Logger.Warning("[S1API] Failed to cache dealer defaults for '" + npcType.Name + "': " + ex.Message);
			}
		}

		internal static void RegisterDealerType(Type npcType)
		{
			if (!(npcType == null))
			{
				if (SupplierTypes.Contains(npcType))
				{
					throw new InvalidOperationException("Custom NPC type '" + npcType.FullName + "' cannot be both a dealer and a supplier root.");
				}
				DealerTypes.Add(npcType);
			}
		}

		internal static bool IsDealerType(Type npcType)
		{
			if (npcType == null)
			{
				return false;
			}
			return DealerTypes.Contains(npcType);
		}

		internal static bool HasDealerDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return false;
			}
			Action<DealerDataBuilder> value;
			return TypeToDealerDefaults.TryGetValue(npcType, out value) && value != null;
		}

		internal static Action<DealerDataBuilder>? GetDealerDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			TypeToDealerDefaults.TryGetValue(npcType, out Action<DealerDataBuilder> value);
			return value;
		}

		internal static DealerDataBuilder.DealerConfigData? GetBuiltDealerDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			TypeToBuiltDealerDefaults.TryGetValue(npcType, out DealerDataBuilder.DealerConfigData value);
			return value;
		}

		internal static DealerDataBuilder.DealerConfigData? BuildDealerDefaultsForType(Type npcType)
		{
			DealerDataBuilder.DealerConfigData builtDealerDefaultsForType = GetBuiltDealerDefaultsForType(npcType);
			if (builtDealerDefaultsForType != null)
			{
				return builtDealerDefaultsForType;
			}
			Action<DealerDataBuilder> dealerDefaultsForType = GetDealerDefaultsForType(npcType);
			if (dealerDefaultsForType == null)
			{
				return null;
			}
			DealerDataBuilder dealerDataBuilder = new DealerDataBuilder();
			dealerDefaultsForType(dealerDataBuilder);
			DealerDataBuilder.DealerConfigData dealerConfigData = dealerDataBuilder.BuildInternal();
			if (npcType != null)
			{
				TypeToBuiltDealerDefaults[npcType] = dealerConfigData;
			}
			return dealerConfigData;
		}

		internal static void RegisterSupplierDefaultsForType(Type npcType, Action<SupplierDataBuilder> configure)
		{
			if (!(npcType == null) && configure != null)
			{
				SupplierDataBuilder supplierDataBuilder = new SupplierDataBuilder();
				configure(supplierDataBuilder);
				SupplierDataBuilder.SupplierConfigData value = supplierDataBuilder.BuildInternal();
				TypeToSupplierDefaults[npcType] = configure;
				TypeToBuiltSupplierDefaults[npcType] = value;
			}
		}

		internal static void RegisterSupplierType(Type npcType)
		{
			if (!(npcType == null))
			{
				if (DealerTypes.Contains(npcType))
				{
					throw new InvalidOperationException("Custom NPC type '" + npcType.FullName + "' cannot be both a dealer and a supplier root.");
				}
				SupplierTypes.Add(npcType);
			}
		}

		internal static bool IsSupplierType(Type npcType)
		{
			return npcType != null && SupplierTypes.Contains(npcType);
		}

		internal static SupplierDataBuilder.SupplierConfigData? BuildSupplierDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			if (TypeToBuiltSupplierDefaults.TryGetValue(npcType, out SupplierDataBuilder.SupplierConfigData value) && value != null)
			{
				return value;
			}
			if (!TypeToSupplierDefaults.TryGetValue(npcType, out Action<SupplierDataBuilder> value2) || value2 == null)
			{
				return null;
			}
			SupplierDataBuilder supplierDataBuilder = new SupplierDataBuilder();
			value2(supplierDataBuilder);
			SupplierDataBuilder.SupplierConfigData supplierConfigData = supplierDataBuilder.BuildInternal();
			TypeToBuiltSupplierDefaults[npcType] = supplierConfigData;
			return supplierConfigData;
		}

		internal static bool TryApplySupplierDefaults(Supplier supplierComponent, SupplierDataBuilder.SupplierConfigData data)
		{
			try
			{
				return NPCDataAccess.ApplySupplierDefaults(supplierComponent, data);
			}
			catch (Exception ex)
			{
				Logger.Error("[NPC] Failed to apply supplier defaults: " + ex.Message);
				return false;
			}
		}

		internal static void RegisterRandomInventoryDefaultsForType(Type npcType, Action<RandomInventoryItemsBuilder> configure)
		{
			if (!(npcType == null) && configure != null)
			{
				TypeToRandomInventoryDefaults[npcType] = configure;
			}
		}

		internal static bool HasRandomInventoryDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return false;
			}
			Action<RandomInventoryItemsBuilder> value;
			return TypeToRandomInventoryDefaults.TryGetValue(npcType, out value) && value != null;
		}

		internal static Action<RandomInventoryItemsBuilder>? GetRandomInventoryDefaultsForType(Type npcType)
		{
			if (npcType == null)
			{
				return null;
			}
			TypeToRandomInventoryDefaults.TryGetValue(npcType, out Action<RandomInventoryItemsBuilder> value);
			return value;
		}

		internal static RandomInventoryItemsBuilder.InventoryDefaultsData? BuildRandomInventoryDefaultsForType(Type npcType)
		{
			Action<RandomInventoryItemsBuilder> randomInventoryDefaultsForType = GetRandomInventoryDefaultsForType(npcType);
			if (randomInventoryDefaultsForType == null)
			{
				return null;
			}
			RandomInventoryItemsBuilder randomInventoryItemsBuilder = new RandomInventoryItemsBuilder();
			randomInventoryDefaultsForType(randomInventoryItemsBuilder);
			return randomInventoryItemsBuilder.BuildInternal();
		}

		internal static void RegisterSpawnPositionForType(Type npcType, Vector3 position, Quaternion rotation)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!(npcType == null))
			{
				TypeToSpawnPosition[npcType] = (position, rotation);
			}
		}

		private static void MarkPrefabsConfigured()
		{
			_prefabsConfiguredForLocalProcess = true;
		}

		protected NPC()
		{
			IsCustomNPC = true;
			gameObject = InstantiateTemplateInstance(GetType(), this);
			gameObject.SetActive(false);
			NPC preferredNpcComponent = GetPreferredNpcComponent(gameObject);
			if ((Object)(object)preferredNpcComponent == (Object)null)
			{
				throw new Exception("NPC template is missing the core ScheduleOne.NPCs.NPC component.");
			}
			NPCDataAccess.InitializeCurrentDataForConstruction(preferredNpcComponent);
			S1NPC = preferredNpcComponent;
			Avatar runtimeAvatar = S1NPC.Avatar ?? gameObject.GetComponentInChildren<Avatar>(true);
			_runtimeAvatar = runtimeAvatar;
			NPCPrefabIdentity component = gameObject.GetComponent<NPCPrefabIdentity>();
			string text = null;
			string firstName = null;
			string lastName = null;
			Sprite val = null;
			if ((Object)(object)component != (Object)null)
			{
				string text2 = ((Object)gameObject).name;
				if (text2.EndsWith("(Clone)"))
				{
					text2 = text2.Substring(0, text2.Length - 7);
				}
				component.PrefabName = text2;
				if (NPCPrefabIdentity.TryGetIdentityFromRegistry(text2, out string id, out string firstName2, out string lastName2, out Sprite icon))
				{
					text = id;
					firstName = firstName2;
					lastName = lastName2;
					val = icon;
				}
				else
				{
					text = component.Id;
					firstName = component.FirstName;
					lastName = component.LastName;
					val = component.Icon;
				}
			}
			NPCDataAccess.ApplyIdentity(S1NPC, text, firstName, lastName);
			if ((Object)(object)val != (Object)null)
			{
				NPCDataAccess.ApplyIcon(S1NPC, val);
				_hasExplicitIcon = true;
			}
			if ((Object)(object)Icon == (Object)null)
			{
				NPCDataAccess.ApplyIcon(S1NPC, ((App<ContactsApp>)(object)PlayerSingleton<ContactsApp>.Instance).AppIcon);
			}
			S1NPC.BakedGUID = Guid.NewGuid().ToString();
			if (IsPhysical)
			{
				ResetConversationCategoriesToDefaults();
			}
			else
			{
				EnsureMessageConversationReady(resetDefaults: true);
			}
			InitializeHealthComponent();
			InitializeAwarenessComponent();
			InitializeBehaviourComponents();
			InitializeVisionComponents();
			InitializeInteractables();
			InitializeInventoryComponent();
			InitializeRelationshipData();
			InitializeNetworkBehaviours();
			component?.ApplyAppearanceTo(S1NPC, _runtimeAvatar);
			Appearance = new NPCAppearance(this, _runtimeAvatar);
			RestoreRuntimeAvatarAppearance();
			string text3 = FirstName;
			if (string.IsNullOrWhiteSpace(text3))
			{
				text3 = ((!string.IsNullOrWhiteSpace(text)) ? text : GetPrefabNameForType(GetType()));
			}
			((Object)gameObject).name = text3;
			if (!NPCManager.NPCRegistry.Contains(S1NPC))
			{
				NPCManager.NPCRegistry.Add(S1NPC);
			}
			All.Add(this);
		}

		[Obsolete("Use the parameterless constructor and configure identity via ConfigurePrefab with NPCPrefabBuilder.WithIdentity. This constructor is provided for backwards compatibility with non-physical NPCs.")]
		protected NPC(string id, string? firstName, string? lastName, Sprite? icon = null)
			: this()
		{
			bool flag = !string.IsNullOrEmpty(id);
			bool flag2 = !string.IsNullOrEmpty(firstName);
			bool flag3 = !string.IsNullOrEmpty(lastName);
			NPCDataAccess.ApplyIdentity(S1NPC, id, firstName, lastName);
			if ((Object)(object)icon != (Object)null)
			{
				NPCDataAccess.ApplyIcon(S1NPC, icon);
				_hasExplicitIcon = true;
			}
			NPCPrefabIdentity component = gameObject.GetComponent<NPCPrefabIdentity>();
			if ((Object)(object)component != (Object)null)
			{
				if (flag)
				{
					component.Id = id;
				}
				if (flag2)
				{
					component.FirstName = firstName;
				}
				if (flag3)
				{
					component.LastName = lastName;
				}
				if ((Object)(object)icon != (Object)null)
				{
					component.Icon = icon;
				}
				component.RegisterToStaticCache(((Object)gameObject).name);
			}
			if ((Object)(object)Icon == (Object)null)
			{
				NPCDataAccess.ApplyIcon(S1NPC, ((App<ContactsApp>)(object)PlayerSingleton<ContactsApp>.Instance).AppIcon);
			}
			string text = FirstName;
			if (string.IsNullOrEmpty(text))
			{
				text = (flag ? id : "UnknownNPC");
			}
			((Object)gameObject).name = text;
			if (S1NPC.MSGConversation == null)
			{
				return;
			}
			try
			{
				string value = GetNpcFullName();
				if (string.IsNullOrEmpty(value))
				{
					value = (flag2 ? firstName : (flag ? id : "Unknown"));
				}
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(S1NPC.MSGConversation, "contactName", value);
				RefreshMessagingIcons();
				MethodInfo method = typeof(MSGConversation).GetMethod("SetIsKnown", BindingFlags.Instance | BindingFlags.Public);
				if (method != null)
				{
					bool flag4 = !(global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(S1NPC.MSGConversation, "IsSenderKnown") is bool flag5) || flag5;
					method.Invoke(S1NPC.MSGConversation, new object[1] { flag4 });
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to update MSGConversation contactName for '" + GetSafeNpcId() + "': " + ex.Message);
			}
		}

		protected virtual void ConfigurePrefab(NPCPrefabBuilder builder)
		{
		}

		protected virtual void OnResponseLoaded(Response response)
		{
		}

		protected override void OnCreated()
		{
			if (_hasExplicitIcon)
			{
				RefreshMessagingIcons();
			}
			else
			{
				Appearance.GenerateMugshot();
			}
			RestoreRuntimeAvatarAppearance();
			RepairNpcPrefabReferences(gameObject, S1NPC);
			if ((Object)(object)S1NPC.Movement == (Object)null)
			{
				SetGameMember(S1NPC, "Movement", gameObject.GetComponent<NPCMovement>());
			}
			if ((Object)(object)S1NPC.Movement != (Object)null)
			{
				((Behaviour)S1NPC.Movement).enabled = true;
			}
		}

		internal void ApplyGeneratedIcon(Sprite icon)
		{
			if (!_hasExplicitIcon)
			{
				NPCDataAccess.ApplyIcon(S1NPC, icon);
				RefreshMessagingIcons();
			}
		}

		internal void EnsureMessageConversationReady(bool resetDefaults)
		{
			try
			{
				List<EConversationCategory> categories = (resetDefaults ? ResetConversationCategoriesToDefaults() : EnsureConversationCategoriesInitialized());
				EnsureMessageConversationInstance(categories);
			}
			catch (Exception ex)
			{
				if (!IsCustomNPC || (!(ex is ArgumentNullException) && !ex.Message.Contains("ArgumentNullException")))
				{
					Logger.Warning("EnsureMessageConversationReady exception for '" + GetSafeNpcId() + "': " + ex.Message);
				}
			}
		}

		private List<EConversationCategory> EnsureConversationCategoriesInitialized()
		{
			List<EConversationCategory> conversationCategories = GetConversationCategories();
			if (conversationCategories.Count == 0)
			{
				ResetConversationCategoriesToDefaults(conversationCategories);
			}
			return conversationCategories;
		}

		private List<EConversationCategory> ResetConversationCategoriesToDefaults()
		{
			List<EConversationCategory> conversationCategories = GetConversationCategories();
			conversationCategories.Clear();
			ResetConversationCategoriesToDefaults(conversationCategories);
			return conversationCategories;
		}

		private void ResetConversationCategoriesToDefaults(List<EConversationCategory> categories)
		{
			if (categories != null)
			{
				if (ShouldUseSupplierCategory())
				{
					categories.Add((EConversationCategory)1);
				}
				else if (ShouldUseDealerCategory())
				{
					categories.Add((EConversationCategory)2);
				}
				else
				{
					categories.Add((EConversationCategory)0);
				}
				SetConversationCategories(categories);
			}
		}

		internal void SetConversationCategory(EConversationCategory category, bool ensureUi = true)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			List<EConversationCategory> val = new List<EConversationCategory>();
			val.Add(category);
			SetConversationCategories(val);
			if (S1NPC.MSGConversation != null)
			{
				S1NPC.MSGConversation.SetCategories(val);
				if (ensureUi)
				{
					S1NPC.MSGConversation.EnsureUIExists();
				}
			}
		}

		private bool ShouldUseDealerCategory()
		{
			bool flag = false;
			try
			{
				flag = IsDealer;
			}
			catch
			{
			}
			if (!flag)
			{
				try
				{
					flag = IsDealerType(GetType());
				}
				catch
				{
				}
			}
			return flag;
		}

		private bool ShouldUseSupplierCategory()
		{
			bool flag = false;
			try
			{
				flag = IsSupplier;
			}
			catch
			{
			}
			if (!flag)
			{
				try
				{
					flag = IsSupplierType(GetType());
				}
				catch
				{
				}
			}
			return flag;
		}

		private void EnsureMessageConversationInstance(List<EConversationCategory> categories)
		{
			if ((Object)(object)S1NPC == (Object)null)
			{
				return;
			}
			if (S1NPC.MSGConversation == null)
			{
				S1NPC.CreateMessageConversation();
				if (S1NPC.MSGConversation == null)
				{
					Logger.Warning("EnsureMessageConversationInstance: creation failed for '" + GetSafeNpcId() + "'.");
				}
			}
			MSGConversation mSGConversation = S1NPC.MSGConversation;
			if (mSGConversation == null)
			{
				Logger.Warning("EnsureMessageConversationInstance: conversation still null for '" + GetSafeNpcId() + "'.");
				return;
			}
			if (categories == null)
			{
				Logger.Warning("EnsureMessageConversationInstance: categories null for '" + GetSafeNpcId() + "'.");
				return;
			}
			try
			{
				mSGConversation.SetCategories(categories);
				_messaging?.EnsureConversationHook();
			}
			catch (Exception ex)
			{
				Logger.Warning("EnsureMessageConversationInstance: failed to apply categories for '" + GetSafeNpcId() + "': " + ex.Message);
			}
		}

		private static bool SafeIsServer()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				return (Object)(object)networkManager != (Object)null && networkManager.IsServer;
			}
			catch
			{
				return false;
			}
		}

		private static object? GetGameMember(object? target, string memberName)
		{
			return (target == null) ? null : global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(target, memberName);
		}

		private static T? GetGameMember<T>(object? target, string memberName)
		{
			return (GetGameMember(target, memberName) is T val) ? val : default(T);
		}

		private static bool SetGameMember(object? target, string memberName, object? value)
		{
			if (target == null)
			{
				return false;
			}
			return global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(target, memberName, value) || global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(target, "<" + memberName + ">k__BackingField", value) || global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(target, "_" + memberName + "_k__BackingField", value);
		}

		private string GetNpcString(string memberName)
		{
			return GetGameMember<string>(S1NPC, memberName) ?? string.Empty;
		}

		private string GetSafeNpcId()
		{
			try
			{
				string id = NPCDataAccess.GetId(S1NPC);
				if (!string.IsNullOrEmpty(id))
				{
					return id;
				}
			}
			catch
			{
			}
			try
			{
				NPCPrefabIdentity nPCPrefabIdentity = (((Object)(object)gameObject != (Object)null) ? gameObject.GetComponent<NPCPrefabIdentity>() : null);
				if (!string.IsNullOrEmpty(nPCPrefabIdentity?.Id))
				{
					return nPCPrefabIdentity.Id;
				}
			}
			catch
			{
			}
			return "<null>";
		}

		private void SetNpcMember(string memberName, object? value)
		{
			SetGameMember(S1NPC, memberName, value);
		}

		private string GetNpcFullName()
		{
			string gameMember = GetGameMember<string>(S1NPC, "fullName");
			if (!string.IsNullOrWhiteSpace(gameMember))
			{
				return gameMember;
			}
			string firstName = FirstName;
			string lastName = LastName;
			return string.IsNullOrWhiteSpace(lastName) ? firstName : (firstName + " " + lastName).Trim();
		}

		private List<EConversationCategory> GetConversationCategories()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			List<EConversationCategory> val = new List<EConversationCategory>();
			foreach (EConversationCategory conversationCategory in NPCDataAccess.GetConversationCategories(S1NPC))
			{
				val.Add(conversationCategory);
			}
			return val;
		}

		private void SetConversationCategories(List<EConversationCategory> categories)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			List<EConversationCategory> list = new List<EConversationCategory>(categories.Count);
			for (int i = 0; i < categories.Count; i++)
			{
				list.Add(categories[i]);
			}
			NPCDataAccess.ApplyConversationCategories(S1NPC, list);
		}

		private static UnityEvent? GetInventoryContentsChanged(NPCInventory? inventory)
		{
			object? gameMember = GetGameMember(inventory, "onContentsChanged");
			return (UnityEvent?)((gameMember is UnityEvent) ? gameMember : null);
		}

		private static InteractableObject? GetInventoryPickpocketInteractable(NPCInventory? inventory)
		{
			object? gameMember = GetGameMember(inventory, "PickpocketIntObj");
			return (InteractableObject?)((gameMember is InteractableObject) ? gameMember : null);
		}

		private static void SetInventoryPickpocketInteractable(NPCInventory? inventory, InteractableObject interactable)
		{
			SetGameMember(inventory, "PickpocketIntObj", interactable);
		}

		private static void SetInventoryMember(NPCInventory? inventory, string memberName, object? value)
		{
			SetGameMember(inventory, memberName, value);
		}

		private static object? GetInventoryMember(NPCInventory? inventory, string memberName)
		{
			return GetGameMember(inventory, memberName);
		}

		public void Revive()
		{
			S1NPC.Health.Revive();
		}

		public void Damage(int amount)
		{
			if (amount > 0)
			{
				S1NPC.Health.TakeDamage((float)amount, true);
			}
		}

		public void Heal(int amount)
		{
			if (amount > 0)
			{
				float num = Mathf.Min((float)amount, S1NPC.Health.MaxHealth - S1NPC.Health.Health);
				S1NPC.Health.TakeDamage(0f - num, false);
			}
		}

		public void Kill()
		{
			S1NPC.Health.TakeDamage(S1NPC.Health.MaxHealth, true);
		}

		public void Unsettle(float duration)
		{
			_unsettleMethod.Invoke(S1NPC, new object[1] { duration });
		}

		public void LerpScale(float scale, float lerpTime)
		{
			S1NPC.SetScale(scale, lerpTime);
		}

		public void Panic()
		{
			if (SafeIsServer())
			{
				S1NPC.SetPanicked_Server();
			}
		}

		public void StopPanicking()
		{
			_removePanicMethod.Invoke(S1NPC, new object[0]);
		}

		public void KnockOut()
		{
			S1NPC.Health.KnockOut();
		}

		public void Goto(Vector3 position)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			S1NPC.Movement.SetDestination(position);
		}

		public void ClearConversationCategories()
		{
			try
			{
				List<EConversationCategory> val = new List<EConversationCategory>();
				SetConversationCategories(val);
				MSGConversation mSGConversation = S1NPC.MSGConversation;
				if (mSGConversation != null)
				{
					mSGConversation.SetCategories(val);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to clear conversation categories for " + ID + ": " + ex.Message);
			}
		}

		public void SendTextMessage(string message, Response[]? responses = null, float responseDelay = 1f, bool network = true)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			bool flag = network && _clientNetworkSpawnHydrationDepth == 0;
			if (S1NPC.MSGConversation == null)
			{
				Logger.Warning("SendTextMessage: MSGConversation null before send for '" + GetSafeNpcId() + "'. Trying to ensure.");
				EnsureMessageConversationReady(resetDefaults: false);
			}
			if (S1NPC.MSGConversation == null)
			{
				Logger.Warning("SendTextMessage: Conversation is unavailable for '" + GetSafeNpcId() + "'.");
				return;
			}
			S1NPC.MSGConversation.SendMessage(new Message(message, (ESenderType)1, true, Random.Range(int.MinValue, int.MaxValue)), true, flag);
			if (responses == null || responses.Length == 0)
			{
				if (S1NPC.MSGConversation == null)
				{
					Logger.Warning("SendTextMessage: Conversation still null after send for '" + GetSafeNpcId() + "'.");
				}
				return;
			}
			if (S1NPC.MSGConversation == null)
			{
				Logger.Warning("SendTextMessage: Unable to show responses because MSGConversation is null for '" + GetSafeNpcId() + "'.");
				return;
			}
			S1NPC.MSGConversation.ClearResponses(false);
			Responses.Clear();
			List<Response> val = new List<Response>();
			foreach (Response response in responses)
			{
				Responses.Add(response);
				val.Add(response.S1Response);
			}
			S1NPC.MSGConversation.ShowResponses(val, responseDelay, flag);
		}

		public void SetEquippable(string assetPath)
		{
			S1NPC.SetEquippable_Return(assetPath);
		}

		public void SetEquippable(EquippablePath equippablePath)
		{
			SetEquippable(equippablePath.ResourcePath);
		}

		public static NPC? Get<T>() where T : NPC
		{
			return All.FirstOrDefault((NPC npc) => npc.GetType() == typeof(T)) ?? TryCreateBuiltInWrapper(typeof(T));
		}

		public static NPC? Get(string npcId)
		{
			if (string.IsNullOrWhiteSpace(npcId))
			{
				return null;
			}
			NPC nPC = All.FirstOrDefault((NPC npc) => string.Equals(npc.ID, npcId, StringComparison.OrdinalIgnoreCase));
			if (nPC != null)
			{
				return nPC;
			}
			Type type = NPCTypeUtils.TryResolveBuiltInNPCType(npcId);
			return (type == null) ? null : TryCreateBuiltInWrapper(type);
		}

		private static NPC? TryCreateBuiltInWrapper(Type npcType)
		{
			if (npcType == null || npcType.Assembly != typeof(NPC).Assembly || npcType.IsAbstract)
			{
				return null;
			}
			try
			{
				return (NPC)Activator.CreateInstance(npcType, nonPublic: true);
			}
			catch
			{
			}
			return null;
		}

		internal NPC(NPC npc)
		{
			S1NPC = npc;
			gameObject = ((Component)npc).gameObject;
			_runtimeAvatar = npc.Avatar ?? gameObject.GetComponentInChildren<Avatar>(true);
			Appearance = new NPCAppearance(this, _runtimeAvatar);
			IsCustomNPC = false;
			All.Add(this);
		}

		internal override void CreateInternal()
		{
			NPC s1NPC = S1NPC;
			if (((s1NPC != null) ? s1NPC.MSGConversation : null) != null && S1NPC.MSGConversation.currentResponses != null)
			{
				Enumerator<Response> enumerator = S1NPC.MSGConversation.currentResponses.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Response current = enumerator.Current;
					Response response = new Response(current)
					{
						Label = current.label,
						Text = current.text
					};
					Responses.Add(response);
					OnResponseLoaded(response);
				}
			}
			try
			{
				Inventory.EnsureInitialized();
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPC] CreateInternal: Failed to ensure inventory initialized for '" + GetSafeNpcId() + "': " + ex.Message);
			}
			try
			{
				ApplyRandomInventoryDefaults();
			}
			catch (Exception ex2)
			{
				Logger.Warning("[NPC] CreateInternal: Failed to apply inventory defaults for '" + GetSafeNpcId() + "': " + ex2.Message);
			}
			base.CreateInternal();
		}

		internal void CreateFromClientNetworkSpawn()
		{
			_clientNetworkSpawnHydrationDepth++;
			try
			{
				CreateInternal();
			}
			finally
			{
				_clientNetworkSpawnHydrationDepth--;
			}
		}

		internal override void SaveInternal(string folderPath, ref List<string> extraSaveables)
		{
			string path = GetGameMember<string>(S1NPC, "SaveFolderName")?.Trim() ?? "UnknownNPC";
			string folderPath2 = Path.Combine(folderPath, path);
			base.SaveInternal(folderPath2, ref extraSaveables);
		}

		private void InitializeHealthComponent()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			if ((Object)(object)S1NPC.Health == (Object)null)
			{
				SetGameMember(S1NPC, "Health", gameObject.GetComponent<NPCHealth>());
			}
			if ((Object)(object)S1NPC.Health == (Object)null)
			{
				SetGameMember(S1NPC, "Health", gameObject.AddComponent<NPCHealth>());
			}
			NPCHealth health = S1NPC.Health;
			if (!((Object)(object)health == (Object)null))
			{
				if (health.onDie == null)
				{
					health.onDie = new UnityEvent();
				}
				if (health.onKnockedOut == null)
				{
					health.onKnockedOut = new UnityEvent();
				}
				SetGameMember(health, "MaxHealth", 100f);
			}
		}

		private void InitializeAwarenessComponent()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			if ((Object)(object)S1NPC.Awareness == (Object)null)
			{
				SetGameMember(S1NPC, "Awareness", gameObject.GetComponentInChildren<NPCAwareness>(true));
				if ((Object)(object)S1NPC.Awareness == (Object)null)
				{
					GameObject val = new GameObject("NPCAwareness");
					val.transform.SetParent(gameObject.transform, false);
					SetGameMember(S1NPC, "Awareness", val.AddComponent<NPCAwareness>());
				}
			}
			NPCAwareness awareness = S1NPC.Awareness;
			if ((Object)(object)awareness == (Object)null)
			{
				return;
			}
			if (awareness.onExplosionHeard == null)
			{
				awareness.onExplosionHeard = new UnityEvent<NoiseEvent>();
			}
			if (awareness.onGunshotHeard == null)
			{
				awareness.onGunshotHeard = new UnityEvent<NoiseEvent>();
			}
			if (awareness.onHitByCar == null)
			{
				awareness.onHitByCar = new UnityEvent<LandVehicle>();
			}
			if (awareness.onNoticedDrugDealing == null)
			{
				awareness.onNoticedDrugDealing = new UnityEvent<Player>();
			}
			if (awareness.onNoticedGeneralCrime == null)
			{
				awareness.onNoticedGeneralCrime = new UnityEvent<Player>();
			}
			if (awareness.onNoticedPettyCrime == null)
			{
				awareness.onNoticedPettyCrime = new UnityEvent<Player>();
			}
			if (awareness.onNoticedPlayerViolatingCurfew == null)
			{
				awareness.onNoticedPlayerViolatingCurfew = new UnityEvent<Player>();
			}
			if (awareness.onNoticedSuspiciousPlayer == null)
			{
				awareness.onNoticedSuspiciousPlayer = new UnityEvent<Player>();
			}
			if ((Object)(object)awareness.Listener == (Object)null)
			{
				awareness.Listener = gameObject.GetComponent<Listener>() ?? gameObject.AddComponent<Listener>();
			}
			if ((Object)(object)S1NPC.Responses == (Object)null)
			{
				SetGameMember(S1NPC, "Responses", gameObject.GetComponentInChildren<NPCResponses>(true));
				if ((Object)(object)S1NPC.Responses == (Object)null)
				{
					GameObject val2 = new GameObject("NPCResponses");
					val2.transform.SetParent(gameObject.transform, false);
					SetGameMember(S1NPC, "Responses", val2.AddComponent<NPCResponses_Civilian>());
				}
			}
			if (!(S1NPC.Responses is NPCResponses_Civilian))
			{
				try
				{
					GameObject val3 = (GameObject)(((Object)(object)S1NPC.Responses != (Object)null) ? ((object)((Component)S1NPC.Responses).gameObject) : ((object)gameObject));
					if ((Object)(object)S1NPC.Responses != (Object)null)
					{
						Object.Destroy((Object)(object)S1NPC.Responses);
					}
					NPCResponses_Civilian value = val3.AddComponent<NPCResponses_Civilian>();
					SetGameMember(S1NPC, "Responses", value);
				}
				catch
				{
				}
			}
			NPCResponses responses = S1NPC.Responses;
			NPCResponses_Civilian val4 = (NPCResponses_Civilian)(object)((responses is NPCResponses_Civilian) ? responses : null);
			if (val4 != null)
			{
				awareness.Responses = (NPCResponses)(object)val4;
			}
		}

		private void InitializeBehaviourComponents()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Expected O, but got Unknown
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Expected O, but got Unknown
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Expected O, but got Unknown
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Expected O, but got Unknown
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Expected O, but got Unknown
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f4: Expected O, but got Unknown
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Expected O, but got Unknown
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Expected O, but got Unknown
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Expected O, but got Unknown
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_0607: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_060f: Expected O, but got Unknown
			//IL_061f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0624: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Expected O, but got Unknown
			//IL_062c: Expected O, but got Unknown
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Expected O, but got Unknown
			//IL_0649: Expected O, but got Unknown
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Expected O, but got Unknown
			//IL_0666: Expected O, but got Unknown
			if ((Object)(object)S1NPC.Behaviour == (Object)null)
			{
				NPCBehaviour val = gameObject.GetComponentInChildren<NPCBehaviour>(true);
				if ((Object)(object)val == (Object)null)
				{
					GameObject val2 = new GameObject("NPCBehaviour");
					val2.transform.SetParent(gameObject.transform, false);
					val = val2.AddComponent<NPCBehaviour>();
				}
				SetGameMember(S1NPC, "Behaviour", val);
			}
			if ((Object)(object)S1NPC.Actions == (Object)null)
			{
				NPCActions val3 = ((Component)S1NPC).GetComponentInChildren<NPCActions>(true);
				if ((Object)(object)val3 == (Object)null)
				{
					GameObject val4 = new GameObject("NPCActions");
					val4.transform.SetParent(gameObject.transform, false);
					val3 = val4.AddComponent<NPCActions>();
				}
				SetGameMember(S1NPC, "Actions", val3);
			}
			NPCBehaviour behaviour = S1NPC.Behaviour;
			if ((Object)(object)behaviour == (Object)null)
			{
				return;
			}
			if ((Object)(object)behaviour.CoweringBehaviour == (Object)null)
			{
				CoweringBehaviour val5 = ((Component)behaviour).GetComponentInChildren<CoweringBehaviour>(true);
				if ((Object)(object)val5 == (Object)null)
				{
					GameObject val6 = new GameObject("CowingBehaviour");
					val6.transform.SetParent(((Component)behaviour).transform, false);
					val5 = val6.AddComponent<CoweringBehaviour>();
				}
				behaviour.CoweringBehaviour = val5;
			}
			behaviour.HeavyFlinchBehaviour = ((Component)behaviour).GetComponentInChildren<HeavyFlinchBehaviour>(true);
			if ((Object)(object)behaviour.FleeBehaviour == (Object)null)
			{
				FleeBehaviour val7 = ((Component)behaviour).GetComponentInChildren<FleeBehaviour>(true);
				if ((Object)(object)val7 == (Object)null)
				{
					GameObject val8 = new GameObject("FleeBehaviour");
					val8.transform.SetParent(((Component)behaviour).transform, false);
					val7 = val8.AddComponent<FleeBehaviour>();
				}
				behaviour.FleeBehaviour = val7;
			}
			if ((Object)(object)behaviour.GenericDialogueBehaviour == (Object)null)
			{
				GenericDialogueBehaviour val9 = ((Component)behaviour).GetComponentInChildren<GenericDialogueBehaviour>(true);
				if ((Object)(object)val9 == (Object)null)
				{
					GameObject val10 = new GameObject("GenericDialogueBehaviour");
					val10.transform.SetParent(((Component)behaviour).transform, false);
					val9 = val10.AddComponent<GenericDialogueBehaviour>();
				}
				behaviour.GenericDialogueBehaviour = val9;
			}
			if ((Object)(object)behaviour.RequestProductBehaviour == (Object)null)
			{
				RequestProductBehaviour val11 = ((Component)behaviour).GetComponentInChildren<RequestProductBehaviour>(true);
				if ((Object)(object)val11 == (Object)null)
				{
					GameObject val12 = new GameObject("RequestProductBehaviour");
					val12.transform.SetParent(((Component)behaviour).transform, false);
					val11 = val12.AddComponent<RequestProductBehaviour>();
				}
				behaviour.RequestProductBehaviour = val11;
			}
			if ((Object)(object)behaviour.CallPoliceBehaviour == (Object)null)
			{
				CallPoliceBehaviour val13 = ((Component)behaviour).GetComponentInChildren<CallPoliceBehaviour>(true);
				if ((Object)(object)val13 == (Object)null)
				{
					GameObject val14 = new GameObject("CallPoliceBehaviour");
					val14.transform.SetParent(((Component)behaviour).transform, false);
					val13 = val14.AddComponent<CallPoliceBehaviour>();
				}
				behaviour.CallPoliceBehaviour = val13;
			}
			if ((Object)(object)behaviour.CombatBehaviour == (Object)null)
			{
				CombatBehaviour val15 = ((Component)behaviour).GetComponentInChildren<CombatBehaviour>(true);
				if ((Object)(object)val15 == (Object)null)
				{
					GameObject val16 = new GameObject("CombatBehaviour");
					val16.transform.SetParent(((Component)behaviour).transform, false);
					val15 = val16.AddComponent<CombatBehaviour>();
				}
				behaviour.CombatBehaviour = val15;
			}
			if ((Object)(object)behaviour.CombatBehaviour != (Object)null)
			{
				CombatBehaviour combatBehaviour = behaviour.CombatBehaviour;
				if (combatBehaviour.TargetVelocityTracker == null)
				{
					SmoothedVelocityCalculator val17 = (combatBehaviour.TargetVelocityTracker = gameObject.GetComponentInChildren<SmoothedVelocityCalculator>(true));
				}
				combatBehaviour = behaviour.CombatBehaviour;
				if (combatBehaviour.VirtualPunchWeapon == null)
				{
					AvatarMeleeWeapon val18 = (combatBehaviour.VirtualPunchWeapon = gameObject.GetComponentInChildren<AvatarMeleeWeapon>(true));
				}
			}
			if ((Object)(object)behaviour.StationaryBehaviour == (Object)null)
			{
				StationaryBehaviour val19 = ((Component)behaviour).GetComponentInChildren<StationaryBehaviour>(true);
				if ((Object)(object)val19 == (Object)null)
				{
					GameObject val20 = new GameObject("StationaryBehaviour");
					val20.transform.SetParent(((Component)behaviour).transform, false);
					val19 = val20.AddComponent<StationaryBehaviour>();
				}
				behaviour.StationaryBehaviour = val19;
			}
			if ((Object)(object)behaviour.FaceTargetBehaviour == (Object)null)
			{
				FaceTargetBehaviour val21 = ((Component)behaviour).GetComponentInChildren<FaceTargetBehaviour>(true);
				if ((Object)(object)val21 == (Object)null)
				{
					GameObject val22 = new GameObject("FaceTargetBehaviour");
					val22.transform.SetParent(((Component)behaviour).transform, false);
					val21 = val22.AddComponent<FaceTargetBehaviour>();
				}
				behaviour.FaceTargetBehaviour = val21;
			}
			if ((Object)(object)behaviour.ConsumeProductBehaviour == (Object)null)
			{
				ConsumeProductBehaviour val23 = ((Component)behaviour).GetComponentInChildren<ConsumeProductBehaviour>(true);
				if ((Object)(object)val23 == (Object)null)
				{
					GameObject val24 = new GameObject("ConsumeProductBehaviour");
					val24.transform.SetParent(((Component)behaviour).transform, false);
					val23 = val24.AddComponent<ConsumeProductBehaviour>();
				}
				behaviour.ConsumeProductBehaviour = val23;
			}
			if (behaviour.ConsumeProductBehaviour.onConsumeDone == null)
			{
				behaviour.ConsumeProductBehaviour.onConsumeDone = new UnityEvent();
			}
			if ((Object)(object)behaviour.UnconsciousBehaviour == (Object)null)
			{
				UnconsciousBehaviour val25 = ((Component)behaviour).GetComponentInChildren<UnconsciousBehaviour>(true);
				if ((Object)(object)val25 == (Object)null)
				{
					GameObject val26 = new GameObject("UnconsciousBehaviour");
					val26.transform.SetParent(((Component)behaviour).transform, false);
					val25 = val26.AddComponent<UnconsciousBehaviour>();
				}
				behaviour.UnconsciousBehaviour = val25;
			}
			if ((Object)(object)behaviour.DeadBehaviour == (Object)null)
			{
				DeadBehaviour val27 = ((Component)behaviour).GetComponentInChildren<DeadBehaviour>(true);
				if ((Object)(object)val27 == (Object)null)
				{
					GameObject val28 = new GameObject("DeadBehaviour");
					val28.transform.SetParent(((Component)behaviour).transform, false);
					val27 = val28.AddComponent<DeadBehaviour>();
				}
				behaviour.DeadBehaviour = val27;
			}
			RepairBehaviourOwnership(gameObject, S1NPC);
			foreach (Behaviour componentsInChild in ((Component)behaviour).GetComponentsInChildren<Behaviour>(true))
			{
				if (!((Object)(object)componentsInChild == (Object)null))
				{
					Behaviour val29 = componentsInChild;
					if (val29.onEnable == null)
					{
						Behaviour obj = val29;
						UnityEvent val30 = new UnityEvent();
						UnityEvent val31 = val30;
						obj.onEnable = val30;
					}
					val29 = componentsInChild;
					if (val29.onDisable == null)
					{
						Behaviour obj2 = val29;
						UnityEvent val32 = new UnityEvent();
						UnityEvent val31 = val32;
						obj2.onDisable = val32;
					}
					val29 = componentsInChild;
					if (val29.onBegin == null)
					{
						Behaviour obj3 = val29;
						UnityEvent val33 = new UnityEvent();
						UnityEvent val31 = val33;
						obj3.onBegin = val33;
					}
					val29 = componentsInChild;
					if (val29.onEnd == null)
					{
						Behaviour obj4 = val29;
						UnityEvent val34 = new UnityEvent();
						UnityEvent val31 = val34;
						obj4.onEnd = val34;
					}
				}
			}
			RefreshBehaviourStack();
		}

		private static void RepairBehaviourOwnership(GameObject prefabRoot, NPC? npc)
		{
			if ((Object)(object)prefabRoot == (Object)null || (Object)(object)npc == (Object)null)
			{
				return;
			}
			NPCBehaviour componentInChildren = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			SetGameMember(npc, "Behaviour", componentInChildren);
			componentInChildren.Npc = npc;
			foreach (Behaviour componentsInChild in ((Component)componentInChildren).GetComponentsInChildren<Behaviour>(true))
			{
				if (!((Object)(object)componentsInChild == (Object)null))
				{
					componentsInChild.beh = componentInChildren;
				}
			}
		}

		private void RefreshBehaviourStack()
		{
			Il2CppArrayBase<Behaviour> componentsInChildren = ((Component)S1NPC.Behaviour).GetComponentsInChildren<Behaviour>(true);
			List<Behaviour> list = new List<Behaviour>();
			foreach (Behaviour item in componentsInChildren)
			{
				if ((Object)(object)item != (Object)null)
				{
					list.Add(item);
				}
			}
			list.Sort((Behaviour left, Behaviour right) => right.Priority.CompareTo(left.Priority));
			List<Behaviour> val = new List<Behaviour>();
			foreach (Behaviour item2 in list)
			{
				val.Add(item2);
			}
			S1NPC.Behaviour.behaviourStack = val;
		}

		private void InitializeVisionComponents()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			if ((Object)(object)S1NPC.Awareness == (Object)null)
			{
				return;
			}
			if ((Object)(object)S1NPC.Awareness.VisionCone == (Object)null)
			{
				VisionCone val = gameObject.GetComponentInChildren<VisionCone>(true);
				if ((Object)(object)val == (Object)null)
				{
					GameObject val2 = new GameObject("VisionCone");
					val2.transform.SetParent(gameObject.transform, false);
					val = val2.AddComponent<VisionCone>();
				}
				S1NPC.Awareness.VisionCone = val;
			}
			List<StateContainer> val3 = S1NPC.Awareness.VisionCone.DefaultStatesOfInterest;
			if (val3 == null)
			{
				val3 = new List<StateContainer>();
				S1NPC.Awareness.VisionCone.DefaultStatesOfInterest = val3;
			}
			if (val3.Count == 0)
			{
				EVisualState[] array = new EVisualState[9];
				RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
				EVisualState[] array2 = (EVisualState[])(object)array;
				for (int i = 0; i < array2.Length; i++)
				{
					val3.Add(new StateContainer
					{
						state = array2[i]
					});
				}
			}
			if ((Object)(object)S1NPC.Awareness.VisionCone.QuestionMarkPopup == (Object)null)
			{
				WorldspacePopup questionMarkPopup = gameObject.GetComponent<WorldspacePopup>() ?? gameObject.AddComponent<WorldspacePopup>();
				S1NPC.Awareness.VisionCone.QuestionMarkPopup = questionMarkPopup;
			}
		}

		private void InitializeInteractables()
		{
			if ((Object)(object)gameObject.GetComponentInChildren<InteractableObject>(true) == (Object)null)
			{
				gameObject.AddComponent<InteractableObject>();
			}
		}

		private void InitializeInventoryComponent()
		{
			if ((Object)(object)S1NPC.Inventory == (Object)null)
			{
				SetGameMember(S1NPC, "Inventory", gameObject.GetComponentInChildren<NPCInventory>(true) ?? gameObject.AddComponent<NPCInventory>());
			}
			if ((Object)(object)GetInventoryPickpocketInteractable(S1NPC.Inventory) == (Object)null)
			{
				InteractableObject talkInteractable = GetPrimaryInteractable();
				InteractableObject[] source = Il2CppArrayBase<InteractableObject>.op_Implicit(gameObject.GetComponentsInChildren<InteractableObject>(true));
				InteractableObject val = ((IEnumerable<InteractableObject>)source).FirstOrDefault((Func<InteractableObject, bool>)((InteractableObject io) => (Object)(object)io != (Object)null && (Object)(object)io != (Object)(object)talkInteractable));
				if ((Object)(object)val == (Object)null)
				{
					val = gameObject.AddComponent<InteractableObject>();
				}
				SetInventoryPickpocketInteractable(S1NPC.Inventory, val);
			}
		}

		private void InitializeRelationshipData()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			string safeNpcId = GetSafeNpcId();
			bool flag = S1NPC.RelationData != null;
			if (S1NPC.RelationData == null)
			{
				S1NPC.RelationData = new NPCRelationData();
			}
			try
			{
				if (S1NPC.RelationData != null)
				{
					S1NPC.RelationData.Init(S1NPC);
				}
				else
				{
					Logger.Warning("[NPC] InitializeRelationshipData: RelationData is still null after creation attempt for NPC '" + safeNpcId + "'");
				}
			}
			catch (Exception ex)
			{
				Logger.Error("[NPC] InitializeRelationshipData: Exception during Init() for NPC '" + safeNpcId + "': " + ex.Message);
				Logger.Error("[NPC] InitializeRelationshipData: Stack trace: " + ex.StackTrace);
			}
			_relationship?.EnsureUnlockedHook();
		}

		private void ApplyRandomInventoryDefaults()
		{
			if (!HasRandomInventoryDefaultsForType(GetType()))
			{
				return;
			}
			try
			{
				string safeNpcId = GetSafeNpcId();
				RandomInventoryItemsBuilder.InventoryDefaultsData inventoryDefaultsData = BuildRandomInventoryDefaultsForType(GetType());
				if (inventoryDefaultsData == null)
				{
					return;
				}
				NPCInventory inventory = S1NPC.Inventory;
				if ((Object)(object)inventory == (Object)null)
				{
					return;
				}
				if (inventoryDefaultsData.RandomCashMin.HasValue || inventoryDefaultsData.RandomCashMax.HasValue)
				{
					SetInventoryMember(inventory, "RandomCash", true);
					if (inventoryDefaultsData.RandomCashMin.HasValue)
					{
						SetInventoryMember(inventory, "RandomCashMin", inventoryDefaultsData.RandomCashMin.Value);
					}
					if (inventoryDefaultsData.RandomCashMax.HasValue)
					{
						SetInventoryMember(inventory, "RandomCashMax", inventoryDefaultsData.RandomCashMax.Value);
					}
					if (inventory.ItemSlots != null && inventory.ItemSlots.Count > 0)
					{
						int num = 0;
						try
						{
							if (inventory.ItemSlots != null)
							{
								for (int i = 0; i < inventory.ItemSlots.Count; i++)
								{
									ItemSlot val = inventory.ItemSlots[i];
									if (((val != null) ? val.ItemInstance : null) == null)
									{
										continue;
									}
									ItemDefinition definition = val.ItemInstance.Definition;
									if (!((Object)(object)definition != (Object)null) || !(((BaseItemDefinition)definition).ID == "cash"))
									{
										continue;
									}
									PropertyInfo property = ((object)val.ItemInstance).GetType().GetProperty("Value");
									if (property != null)
									{
										object value = property.GetValue(val.ItemInstance);
										if (value is int num2)
										{
											num += num2;
										}
										else if (value is float num3)
										{
											num += (int)num3;
										}
									}
								}
							}
						}
						catch (Exception ex)
						{
							Logger.Warning("[NPC] ApplyRandomInventoryDefaults: '" + safeNpcId + "' failed to check existing cash: " + ex.Message);
						}
						if (num == 0)
						{
							int valueOrDefault = inventoryDefaultsData.RandomCashMin.GetValueOrDefault();
							int num4 = inventoryDefaultsData.RandomCashMax ?? 100;
							if (num4 > 0)
							{
								int num5 = Random.Range(valueOrDefault, num4 + 1);
								if (num5 > 0)
								{
									try
									{
										MethodInfo method = ((object)inventory).GetType().GetMethod("AddCash", BindingFlags.Instance | BindingFlags.Public);
										if (method != null)
										{
											method.Invoke(inventory, new object[1] { (float)num5 });
										}
										else
										{
											MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
											if ((Object)(object)instance != (Object)null)
											{
												CashInstance cashInstance = instance.GetCashInstance((float)num5);
												if (cashInstance != null)
												{
													inventory.InsertItem((ItemInstance)(object)cashInstance, true);
												}
												else
												{
													Logger.Warning($"[NPC] ApplyRandomInventoryDefaults: '{safeNpcId}' MoneyManager.GetCashInstance returned null for amount {num5}");
												}
											}
											else
											{
												Logger.Warning("[NPC] ApplyRandomInventoryDefaults: '" + safeNpcId + "' MoneyManager not available to create cash");
											}
										}
									}
									catch (Exception ex2)
									{
										Logger.Warning("[NPC] ApplyRandomInventoryDefaults: '" + safeNpcId + "' failed to add cash: " + ex2.Message);
									}
								}
							}
						}
					}
				}
				if (inventoryDefaultsData.ClearInventoryEachNight.HasValue)
				{
					SetInventoryMember(inventory, "ClearInventoryEachNight", inventoryDefaultsData.ClearInventoryEachNight.Value);
				}
				if (inventoryDefaultsData.StartupItems == null || inventoryDefaultsData.StartupItems.Count <= 0)
				{
					return;
				}
				List<ItemDefinition> val2 = new List<ItemDefinition>();
				foreach (string startupItem in inventoryDefaultsData.StartupItems)
				{
					ItemDefinition item = Registry.GetItem(startupItem);
					if ((Object)(object)item != (Object)null)
					{
						val2.Add(item);
					}
				}
				if (val2.Count > 0)
				{
					if (inventory.ItemSlots != null && inventory.ItemSlots.Count > 0)
					{
						int num6 = 0;
						Enumerator<ItemDefinition> enumerator2 = val2.GetEnumerator();
						while (enumerator2.MoveNext())
						{
							ItemDefinition current2 = enumerator2.Current;
							try
							{
								ItemInstance defaultInstance = current2.GetDefaultInstance(1);
								if (defaultInstance != null)
								{
									inventory.InsertItem(defaultInstance, false);
									num6++;
								}
							}
							catch (Exception ex3)
							{
								Logger.Warning($"[NPC] ApplyRandomInventoryDefaults: '{safeNpcId}' failed to insert startup item {((BaseItemDefinition)current2).ID}: {ex3.Message}");
							}
						}
						SetInventoryMember(inventory, "StartupItems", new Il2CppReferenceArray<ItemDefinition>(0L));
						return;
					}
					bool flag = false;
					try
					{
						object inventoryMember = GetInventoryMember(inventory, "StartupItems");
						if (inventoryMember != null)
						{
							flag = inventoryMember is Il2CppReferenceArray<ItemDefinition> val3 && ((Il2CppArrayBase<ItemDefinition>)(object)val3).Length > 0;
						}
					}
					catch
					{
						flag = false;
					}
					if (!flag)
					{
						SetInventoryMember(inventory, "StartupItems", new Il2CppReferenceArray<ItemDefinition>(Il2CppArrayBase<ItemDefinition>.op_Implicit(val2.ToArray())));
					}
				}
				else
				{
					Logger.Warning("[NPC] ApplyRandomInventoryDefaults: '" + safeNpcId + "' had StartupItems definitions but none resolved from registry.");
				}
			}
			catch (Exception ex4)
			{
				Logger.Warning("[NPC] ApplyRandomInventoryDefaults: '" + GetSafeNpcId() + "' failed with exception: " + ex4.Message);
				Logger.Warning("[NPC] ApplyRandomInventoryDefaults: Stack trace: " + ex4.StackTrace);
			}
		}

		private InteractableObject? GetPrimaryInteractable()
		{
			return gameObject.GetComponentInChildren<InteractableObject>(true);
		}

		private void InitializeNetworkBehaviours()
		{
			NetworkBehaviour[] array = Il2CppArrayBase<NetworkBehaviour>.op_Implicit(gameObject.GetComponentsInChildren<NetworkBehaviour>(true));
			NetworkBehaviour[] array2 = array;
			foreach (NetworkBehaviour val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					try
					{
					}
					catch (Exception ex)
					{
						Logger.Warning("[S1API] Failed to initialize network behaviour " + ((object)val).GetType().Name + ": " + ex.Message);
					}
				}
			}
		}

		private void RestoreRuntimeAvatarAppearance()
		{
			if (!((Object)(object)_runtimeAvatar == (Object)null))
			{
				SetGameMember(S1NPC, "Avatar", _runtimeAvatar);
				Appearance.ApplyToAvatar(_runtimeAvatar);
			}
		}

		private void TrySpawnNetworkInstance()
		{
			try
			{
				NetworkManager networkManager = InstanceFinder.NetworkManager;
				if (!((Object)(object)networkManager != (Object)null) || networkManager.IsServer)
				{
					NetworkObject netObject = gameObject.GetComponent<NetworkObject>() ?? gameObject.AddComponent<NetworkObject>();
					NPCNetworkBootstrap.RegisterPendingNetworkSpawn(this, netObject, 0.3f, 0.6f);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Failed to queue NPC network spawn: " + ex.Message);
			}
		}

		internal bool PrepareForNetworkSpawn()
		{
			try
			{
				if (!TryValidateNativeAwakeReferences(out string diagnostic))
				{
					Logger.Error("[NPC] Refusing to spawn custom NPC '" + GetSafeNpcId() + "' because its native Awake reference graph is invalid: " + diagnostic);
					return false;
				}
				NPCDataAccess.PrepareForRuntime(S1NPC);
				Customer component = gameObject.GetComponent<Customer>();
				if ((Object)(object)component != (Object)null)
				{
					Customer.EnsureCustomer();
				}
				Supplier component2 = gameObject.GetComponent<Supplier>();
				if ((Object)(object)component2 != (Object)null && IsSupplierType(GetType()))
				{
					SupplierDataBuilder.SupplierConfigData supplierConfigData = BuildSupplierDefaultsForType(GetType());
					if (supplierConfigData != null)
					{
						TryApplySupplierDefaults(component2, supplierConfigData);
					}
					SupplierRuntimeCoordinator.EnsureReady(component2, ID, supplierConfigData);
				}
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("[S1API] Failed to prepare NPC runtime data before spawn: " + ex.Message);
				return false;
			}
		}

		private bool TryValidateNativeAwakeReferences(out string diagnostic)
		{
			List<string> list = new List<string>();
			if ((Object)(object)gameObject.GetComponent<NPCInventory>() == (Object)null)
			{
				list.Add("NPCInventory");
			}
			if ((Object)(object)gameObject.GetComponent<NPCHealth>() == (Object)null)
			{
				list.Add("NPCHealth");
			}
			if ((Object)(object)gameObject.GetComponent<EntityVisibility>() == (Object)null)
			{
				list.Add("EntityVisibility");
			}
			if ((Object)(object)gameObject.GetComponent<NPCMovement>() == (Object)null)
			{
				list.Add("NPCMovement");
			}
			if ((Object)(object)gameObject.GetComponent<NetworkedEquipper>() == (Object)null)
			{
				list.Add("NetworkedEquipper");
			}
			Avatar componentInChildren = gameObject.GetComponentInChildren<Avatar>();
			Avatar componentInChildren2 = gameObject.GetComponentInChildren<Avatar>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				list.Add(((Object)(object)componentInChildren2 == (Object)null) ? "Avatar" : "Avatar(active)");
			}
			else if ((Object)(object)componentInChildren.HeadBone == (Object)null)
			{
				list.Add("Avatar.HeadBone");
			}
			else if ((Object)(object)((Component)componentInChildren.HeadBone).GetComponentInChildren<VOEmitter>() == (Object)null)
			{
				list.Add("VOEmitter");
			}
			if ((Object)(object)gameObject.GetComponentInChildren<DialogueHandler>() == (Object)null)
			{
				list.Add("DialogueHandler");
			}
			if ((Object)(object)gameObject.GetComponentInChildren<NPCAwareness>() == (Object)null)
			{
				list.Add("NPCAwareness");
			}
			if ((Object)(object)gameObject.GetComponentInChildren<NPCResponses>() == (Object)null)
			{
				list.Add("NPCResponses");
			}
			if ((Object)(object)gameObject.GetComponentInChildren<NPCActions>() == (Object)null)
			{
				list.Add("NPCActions");
			}
			if ((Object)(object)gameObject.GetComponentInChildren<NPCBehaviour>() == (Object)null)
			{
				list.Add("NPCBehaviour");
			}
			diagnostic = ((list.Count == 0) ? string.Empty : string.Join(", ", list));
			return list.Count == 0;
		}

		internal void FinalizeNetworkSpawn()
		{
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)S1NPC.Awareness != (Object)null)
				{
					NPCResponses responses = S1NPC.Responses;
					NPCResponses_Civilian val = (NPCResponses_Civilian)(object)((responses is NPCResponses_Civilian) ? responses : null);
					if (val != null)
					{
						S1NPC.Awareness.Responses = (NPCResponses)(object)val;
					}
				}
				S1NPC.SetVisible(ShouldBeVisibleAfterSpawn(), false);
				EnsureMessageConversationReady(resetDefaults: false);
				if (InstanceFinder.IsServer)
				{
					MelonCoroutines.Start(DelayedVisibilityRPC());
				}
				try
				{
					if (IsCustomNPC && !((Object)(object)gameObject.GetComponent<Customer>() != (Object)null))
					{
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("[S1API] Failed to ensure Customer on NPC: " + ex.Message);
				}
				try
				{
					if (IsCustomNPC && IsDealerType(GetType()))
					{
						Dealer.EnsureDealer();
					}
				}
				catch (Exception ex2)
				{
					Logger.Warning("[S1API] Failed to ensure Dealer on NPC: " + ex2.Message);
				}
				try
				{
					if (IsCustomNPC && IsSupplierType(GetType()))
					{
						Supplier.EnsureSupplier();
					}
				}
				catch (Exception ex3)
				{
					Logger.Warning("[S1API] Failed to ensure Supplier on NPC: " + ex3.Message);
				}
				try
				{
					Type type = GetType();
					if (TypeToSchedulePlan.TryGetValue(type, out List<IScheduleActionSpec> value) && value != null && value.Count > 0)
					{
						for (int i = 0; i < value.Count; i++)
						{
							IScheduleActionSpec scheduleActionSpec = value[i];
							if (scheduleActionSpec != null)
							{
								try
								{
									scheduleActionSpec.ApplyTo(Schedule);
								}
								catch (Exception ex4)
								{
									Logger.Error($"Failed to apply schedule spec {i} ({scheduleActionSpec.GetType().Name}) for NPC type {type.Name}: {ex4.Message}");
									Logger.Error("Stack trace: " + ex4.StackTrace);
								}
							}
						}
						Schedule.InitializeActions();
						Schedule.EnforceState();
					}
				}
				catch (Exception ex5)
				{
					Logger.Error("Failed to apply planned schedule for NPC type " + GetType().Name + ": " + ex5.Message);
					Logger.Error("Stack trace: " + ex5.StackTrace);
				}
				NPCRelationData relationData = S1NPC.RelationData;
				bool flag = false;
				if (relationData != null)
				{
					bool unlocked = relationData.Unlocked;
					float relationDelta = relationData.RelationDelta;
					flag = unlocked || Math.Abs(relationDelta - 2f) > 0.01f;
				}
				if (!flag)
				{
					try
					{
						NPCPrefabIdentity component = gameObject.GetComponent<NPCPrefabIdentity>();
						bool flag2 = false;
						if ((Object)(object)component != (Object)null)
						{
							NPCRelationData relationData2 = S1NPC.RelationData;
							if (relationData2 != null)
							{
								bool unlocked2 = relationData2.Unlocked;
								component.ApplyRelationshipDataTo(S1NPC, unlocked2);
								flag2 = true;
								_relationshipDataAppliedFromPrefab = true;
								if (unlocked2 && !relationData2.Unlocked)
								{
									Logger.Warning("[NPC] FinalizeNetworkSpawn: WARNING - Unlock state was lost for NPC '" + GetSafeNpcId() + "' after applying prefab defaults. Restoring...");
									relationData2.Unlock((EUnlockType)1, false);
								}
							}
							else
							{
								Logger.Warning("[Relationship Data] FinalizeNetworkSpawn: RelationData is null for NPC '" + GetSafeNpcId() + "'");
							}
						}
						if (!flag2)
						{
							Type type2 = GetType();
							if (TypeToRelationshipDefaults.TryGetValue(type2, out Action<NPCRelationshipDataBuilder> value2) && value2 != null)
							{
								NPCRelationshipDataBuilder nPCRelationshipDataBuilder = new NPCRelationshipDataBuilder();
								value2(nPCRelationshipDataBuilder);
								NPCRelationData relationData3 = S1NPC.RelationData;
								if (relationData3 != null)
								{
									bool unlocked3 = relationData3.Unlocked;
									nPCRelationshipDataBuilder.ApplyTo(relationData3, S1NPC, unlocked3);
									_relationshipDataAppliedFromPrefab = true;
									if (unlocked3 && !relationData3.Unlocked)
									{
										Logger.Warning("[NPC] FinalizeNetworkSpawn: WARNING - Unlock state was lost for NPC '" + GetSafeNpcId() + "' after applying defaults. Restoring...");
										relationData3.Unlock((EUnlockType)1, false);
									}
								}
								else
								{
									Logger.Warning("[NPC] FinalizeNetworkSpawn: RelationData is null for NPC '" + GetSafeNpcId() + "' - cannot apply defaults!");
								}
							}
							else
							{
								_relationshipDataAppliedFromPrefab = true;
							}
						}
					}
					catch (Exception ex6)
					{
						Logger.Error("[NPC] FinalizeNetworkSpawn: Failed to apply relationship defaults for NPC '" + GetSafeNpcId() + "': " + ex6.Message);
						Logger.Error("[NPC] FinalizeNetworkSpawn: Stack trace: " + ex6.StackTrace);
					}
				}
				else
				{
					_relationshipDataAppliedFromPrefab = true;
				}
				_relationship?.EnsureUnlockedHook();
				try
				{
					ApplyDealerRecommendationDefaults();
				}
				catch (Exception ex7)
				{
					Logger.Warning("[S1API] Failed to apply dealer recommendation defaults for '" + GetSafeNpcId() + "': " + ex7.Message);
				}
				try
				{
					Type type3 = GetType();
					if (TypeToSpawnPosition.TryGetValue(type3, out (Vector3, Quaternion) value3))
					{
						(Position, _) = value3;
						Transform.rotation = value3.Item2;
					}
				}
				catch (Exception ex8)
				{
					Logger.Warning("[S1API] Failed to apply spawn position: " + ex8.Message);
				}
				try
				{
					if (CrossType.Is<Supplier>((object)S1NPC, out Supplier result))
					{
						SupplierRuntimeCoordinator.ReconcileDeliveryUnlock(result);
					}
				}
				catch (Exception ex9)
				{
					Logger.Warning("[S1API] Failed to restore supplier delivery state: " + ex9.Message);
				}
				FinalizedCustomNpcTypes.Add(GetType());
				CheckAndSetCustomNpcsReady();
			}
			catch (Exception ex10)
			{
				Logger.Warning("[S1API] Failed to finalize NPC after spawn: " + ex10.Message);
			}
		}

		internal static void CheckAndSetCustomNpcsReady()
		{
			if (CustomNpcsReady)
			{
				return;
			}
			try
			{
				List<Type> list = (from t in global::S1API.Internal.Utils.ReflectionUtils.GetDerivedClasses<NPC>()
					where t != null && !t.IsAbstract && t.Assembly != typeof(NPC).Assembly
					select t).ToList();
				if (list.Count != 0 && list.All((Type type) => FinalizedCustomNpcTypes.Contains(type)))
				{
					CustomNpcsReady = true;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPC] Failed to check CustomNpcsReady status: " + ex.Message);
			}
		}

		private void ApplyDealerRecommendationDefaults()
		{
			Type type = GetType();
			if (!IsDealerType(type))
			{
				ClearDealerRecommendationHooks();
				return;
			}
			DealerDataBuilder.DealerConfigData builtDealerDefaultsForType = GetBuiltDealerDefaultsForType(type);
			if (builtDealerDefaultsForType == null || builtDealerDefaultsForType.Recommendations.Count == 0)
			{
				ClearDealerRecommendationHooks();
				return;
			}
			ClearDealerRecommendationHooks();
			for (int i = 0; i < builtDealerDefaultsForType.Recommendations.Count; i++)
			{
				DealerRecommendationBuilder.RecommendationConfigData recommendationConfigData = builtDealerDefaultsForType.Recommendations[i];
				if (recommendationConfigData == null || string.IsNullOrWhiteSpace(recommendationConfigData.CustomerId) || !recommendationConfigData.RecommendationTrigger.HasValue)
				{
					continue;
				}
				NPC customerNpc = Get(recommendationConfigData.CustomerId);
				if (customerNpc == null)
				{
					Logger.Warning($"[S1API] Could not resolve recommending customer '{recommendationConfigData.CustomerId}' for dealer '{GetSafeNpcId()}'.");
				}
				else
				{
					if (recommendationConfigData.RecommendationTrigger.Value != DealerRecommendationBuilder.Trigger.DealCompleted)
					{
						continue;
					}
					Action action = delegate
					{
						try
						{
							if (!Dealer.HasBeenRecommended())
							{
								customerNpc.Customer.RecommendDealer(Dealer);
							}
						}
						catch (Exception ex)
						{
							Logger.Warning($"[S1API] Failed to auto-recommend dealer '{GetSafeNpcId()}' from customer '{customerNpc.ID}': {ex.Message}");
						}
					};
					customerNpc.Customer.OnDealCompleted += action;
					_recommendationSubscriptions.Add(new DealerRecommendationSubscription(customerNpc, recommendationConfigData.RecommendationTrigger.Value, action));
				}
			}
		}

		private void ClearDealerRecommendationHooks()
		{
			if (_recommendationSubscriptions == null)
			{
				return;
			}
			for (int i = 0; i < _recommendationSubscriptions.Count; i++)
			{
				DealerRecommendationSubscription dealerRecommendationSubscription = _recommendationSubscriptions[i];
				if (dealerRecommendationSubscription.RecommendationTrigger == DealerRecommendationBuilder.Trigger.DealCompleted)
				{
					dealerRecommendationSubscription.Customer.Customer.OnDealCompleted -= dealerRecommendationSubscription.Handler;
				}
			}
			_recommendationSubscriptions.Clear();
		}

		internal void CleanupRuntimeHooks()
		{
			ClearDealerRecommendationHooks();
			_messaging?.Cleanup();
		}

		internal bool ShouldBeVisibleAfterSpawn()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			bool flag = IsCustomNPC && IsSupplierType(GetType());
			bool isSupplierMeeting = false;
			if (flag)
			{
				Supplier component = gameObject.GetComponent<Supplier>();
				isSupplierMeeting = component != null && (int)component.Status == 2;
			}
			return ResolveSpawnVisibility(IsPhysical, flag, isSupplierMeeting);
		}

		internal static bool ResolveSpawnVisibility(bool isPhysical, bool isSupplier, bool isSupplierMeeting)
		{
			return isPhysical && (!isSupplier || isSupplierMeeting);
		}

		internal static bool ShouldApplyLoadedVisibilityBeforeSpawn(bool isSupplier)
		{
			return !isSupplier;
		}

		private IEnumerator DelayedVisibilityRPC()
		{
			yield return null;
			yield return (object)new WaitForSeconds(0.1f);
			try
			{
				if ((Object)(object)S1NPC != (Object)null && (Object)(object)((Component)S1NPC).gameObject != (Object)null)
				{
					S1NPC.SetVisible(ShouldBeVisibleAfterSpawn(), true);
				}
			}
			catch (Exception ex)
			{
				Exception ex2 = ex;
				Logger.Warning("[S1API] Failed to send visibility RPC for NPC '" + GetSafeNpcId() + "': " + ex2.Message);
			}
		}

		private static void EnsureScheduleActionsOnPrefab(GameObject prefabRoot)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return;
			}
			NPCScheduleManager val = prefabRoot.GetComponentInChildren<NPCScheduleManager>(true);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("NPCSchedule");
				val2.transform.SetParent(prefabRoot.transform, false);
				val = val2.AddComponent<NPCScheduleManager>();
			}
			List<Type> list = new List<Type>();
			Type val3 = Il2CppType.Of<NPCAction>();
			try
			{
				Assembly assembly = val3.Assembly;
				if (assembly != (Assembly)null)
				{
					Il2CppReferenceArray<Type> types = assembly.GetTypes();
					for (int i = 0; i < ((Il2CppArrayBase<Type>)(object)types).Length; i++)
					{
						Type val4 = ((Il2CppArrayBase<Type>)(object)types)[i];
						if (!(val4 == (Type)null) && !val4.IsAbstract && val3.IsAssignableFrom(val4))
						{
							list.Add(val4);
						}
					}
				}
			}
			catch
			{
				string text = val3.Namespace;
				string[] array = new string[9] { "NPCSignal_WalkToLocation", "NPCSignal_UseVendingMachine", "NPCSignal_UseATM", "NPCSignal_DriveToCarPark", "NPCEvent_StayInBuilding", "NPCEvent_Sit", "NPCEvent_LocationDialogue", "NPCEvent_LocationBasedAction", "NPCEvent_Conversate" };
				for (int j = 0; j < array.Length; j++)
				{
					string text2 = (string.IsNullOrEmpty(text) ? array[j] : (text + "." + array[j]));
					Type type = Type.GetType(text2);
					if (type != (Type)null && !type.IsAbstract && val3.IsAssignableFrom(type))
					{
						list.Add(type);
					}
				}
			}
			for (int k = 0; k < list.Count; k++)
			{
				Type val5 = list[k];
				if (val5 == (Type)null)
				{
					continue;
				}
				Component componentInChildren = ((Component)val).GetComponentInChildren(val5, true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					continue;
				}
				GameObject val6 = new GameObject(((MemberInfo)val5).Name);
				val6.transform.SetParent(((Component)val).transform, false);
				Component val7 = val6.AddComponent(val5);
				try
				{
					FieldInfo field = val5.GetField("npc", (BindingFlags)52);
					FieldInfo field2 = val5.GetField("schedule", (BindingFlags)52);
					NPC component = prefabRoot.GetComponent<NPC>();
					if (field != null)
					{
						field.SetValue((Object)(object)val7, (Object)(object)component);
					}
					if (field2 != null)
					{
						field2.SetValue((Object)(object)val7, (Object)(object)val);
					}
				}
				catch
				{
				}
				val6.SetActive(false);
			}
		}
	}
	public class NPCAppearance
	{
		private static readonly Log _logger = new Log("NPCAppearance");

		internal readonly NPC NPC;

		private Avatar? _runtimeAvatar;

		private AvatarSettings _customAvatarSettings;

		private static readonly Dictionary<Type, Action<NPCAppearance, object>> _setters = new Dictionary<Type, Action<NPCAppearance, object>>
		{
			[typeof(HairStyle)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.HairPath = (value as string) ?? string.Empty;
			},
			[typeof(HairColor)] = delegate(NPCAppearance self, object value)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings customAvatarSettings = self._customAvatarSettings;
				if (1 == 0)
				{
				}
				Color hairColor = ((value is uint hexColor) ? hexColor.ToColor() : ((!(value is Color val)) ? self._customAvatarSettings.HairColor : val));
				if (1 == 0)
				{
				}
				customAvatarSettings.HairColor = hairColor;
			},
			[typeof(SkinColor)] = delegate(NPCAppearance self, object value)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings customAvatarSettings = self._customAvatarSettings;
				if (1 == 0)
				{
				}
				Color skinColor = ((value is uint hexColor) ? hexColor.ToColor() : ((!(value is Color val)) ? self._customAvatarSettings.SkinColor : val));
				if (1 == 0)
				{
				}
				customAvatarSettings.SkinColor = skinColor;
			},
			[typeof(EyeBallTint)] = delegate(NPCAppearance self, object value)
			{
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings customAvatarSettings = self._customAvatarSettings;
				if (1 == 0)
				{
				}
				Color eyeBallTint = ((value is uint hexColor) ? hexColor.ToColor() : ((!(value is Color val)) ? self._customAvatarSettings.EyeBallTint : val));
				if (1 == 0)
				{
				}
				customAvatarSettings.EyeBallTint = eyeBallTint;
			},
			[typeof(Gender)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.Gender = Convert.ToSingle(value);
			},
			[typeof(Height)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.Height = Convert.ToSingle(value);
			},
			[typeof(Weight)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.Weight = Convert.ToSingle(value);
			},
			[typeof(PupilDilation)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.PupilDilation = Convert.ToSingle(value);
			},
			[typeof(EyebrowRestingAngle)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.EyebrowRestingAngle = Convert.ToSingle(value);
			},
			[typeof(EyebrowRestingHeight)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.EyebrowRestingHeight = Convert.ToSingle(value);
			},
			[typeof(EyebrowScale)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.EyebrowScale = Convert.ToSingle(value);
			},
			[typeof(EyebrowThickness)] = delegate(NPCAppearance self, object value)
			{
				self._customAvatarSettings.EyebrowThickness = Convert.ToSingle(value);
			},
			[typeof(EyeLidRestingStateLeft)] = delegate(NPCAppearance self, object value)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				object[] valueTupleItems = global::S1API.Utils.ReflectionUtils.GetValueTupleItems(value);
				self._customAvatarSettings.LeftEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = Convert.ToSingle(valueTupleItems[0]),
					bottomLidOpen = Convert.ToSingle(valueTupleItems[1])
				};
			},
			[typeof(EyeLidRestingStateRight)] = delegate(NPCAppearance self, object value)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				object[] valueTupleItems = global::S1API.Utils.ReflectionUtils.GetValueTupleItems(value);
				self._customAvatarSettings.RightEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = Convert.ToSingle(valueTupleItems[0]),
					bottomLidOpen = Convert.ToSingle(valueTupleItems[1])
				};
			}
		};

		private const int MaxFaceLayers = 6;

		private const int MaxBodyLayers = 6;

		private const int MaxAccessoryLayers = 9;

		private static readonly object _mugshotQueueLock = new object();

		private static readonly Queue<NPCAppearance> _mugshotQueue = new Queue<NPCAppearance>();

		private static bool _isProcessingMugshots = false;

		private static bool _hasQueuedMugshots = false;

		internal static bool MugshotsProcessingComplete
		{
			get
			{
				lock (_mugshotQueueLock)
				{
					if (!_hasQueuedMugshots)
					{
						return false;
					}
					return !_isProcessingMugshots && _mugshotQueue.Count == 0;
				}
			}
		}

		internal NPCAppearance(NPC npc, Avatar? runtimeAvatar)
		{
			NPC = npc;
			_runtimeAvatar = runtimeAvatar;
			AvatarSettings val = null;
			if ((Object)(object)_runtimeAvatar != (Object)null)
			{
				val = (AvatarSettings)((!((Object)(object)_runtimeAvatar.CurrentSettings != (Object)null)) ? ((object)/*isinst with value type is only supported in some contexts*/) : ((object)_runtimeAvatar.CurrentSettings));
			}
			if ((Object)(object)val != (Object)null)
			{
				_customAvatarSettings = Object.Instantiate<AvatarSettings>(val);
			}
			else
			{
				_customAvatarSettings = ScriptableObject.CreateInstance<AvatarSettings>();
				ApplyDefaultSettings(_customAvatarSettings);
			}
			AvatarSettings val2 = Resources.Load<AvatarSettings>("charactersettings/" + NPC.FirstName);
			if ((Object)(object)val2 != (Object)null)
			{
				_customAvatarSettings = Object.Instantiate<AvatarSettings>(val2);
			}
			ApplyToAvatar(_runtimeAvatar);
		}

		internal void GenerateMugshot()
		{
			if (NPC.HasExplicitIcon)
			{
				return;
			}
			MugshotGenerator instance = Singleton<MugshotGenerator>.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.MugshotRig == (Object)null)
			{
				return;
			}
			lock (_mugshotQueueLock)
			{
				_mugshotQueue.Enqueue(this);
				_hasQueuedMugshots = true;
				if (!_isProcessingMugshots)
				{
					_isProcessingMugshots = true;
					MelonCoroutines.Start(ProcessMugshotQueue());
				}
			}
		}

		private static IEnumerator ProcessMugshotQueue()
		{
			MugshotGenerator generator = Singleton<MugshotGenerator>.Instance;
			Avatar mugshotRig = (((Object)(object)generator != (Object)null) ? generator.MugshotRig : null);
			if ((Object)(object)generator != (Object)null)
			{
				_ = generator.Generator;
			}
			AvatarSettings defaultSettings = (((Object)(object)generator != (Object)null) ? generator.DefaultSettings : null);
			if ((Object)(object)mugshotRig != (Object)null && (Object)(object)defaultSettings != (Object)null)
			{
				int iconLayer = LayerMask.NameToLayer("IconGeneration");
				for (int warmup = 0; warmup < 5; warmup++)
				{
					Transform warmupParent = ((Component)mugshotRig).transform.parent;
					if ((Object)(object)warmupParent != (Object)null)
					{
						((Component)warmupParent).gameObject.SetActive(true);
					}
					((Component)mugshotRig).gameObject.SetActive(true);
					mugshotRig.LoadAvatarSettings(defaultSettings);
					SetLayerRecursively(((Component)mugshotRig).gameObject, iconLayer);
					Il2CppArrayBase<SkinnedMeshRenderer> warmupSMRs = ((Component)mugshotRig).GetComponentsInChildren<SkinnedMeshRenderer>();
					foreach (SkinnedMeshRenderer smr in warmupSMRs)
					{
						smr.updateWhenOffscreen = true;
					}
					yield return (object)new WaitForEndOfFrame();
					mugshotRig.LoadAvatarSettings(defaultSettings);
					((Component)mugshotRig).gameObject.SetActive(false);
				}
			}
			while (true)
			{
				NPCAppearance next = null;
				lock (_mugshotQueueLock)
				{
					if (_mugshotQueue.Count <= 0)
					{
						_isProcessingMugshots = false;
						break;
					}
					next = _mugshotQueue.Dequeue();
				}
				if (next == null)
				{
					yield return null;
				}
				else
				{
					if (next.NPC.HasExplicitIcon)
					{
						continue;
					}
					generator = Singleton<MugshotGenerator>.Instance;
					mugshotRig = (((Object)(object)generator != (Object)null) ? generator.MugshotRig : null);
					IconGenerator iconGenerator = (((Object)(object)generator != (Object)null) ? generator.Generator : null);
					defaultSettings = (((Object)(object)generator != (Object)null) ? generator.DefaultSettings : null);
					if ((Object)(object)mugshotRig == (Object)null || (Object)(object)iconGenerator == (Object)null)
					{
						lock (_mugshotQueueLock)
						{
							_mugshotQueue.Enqueue(next);
						}
						yield return null;
						continue;
					}
					Avatar previousAvatar = next.NPC.S1NPC.Avatar;
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(next.NPC.S1NPC, "Avatar", mugshotRig);
					AvatarSettings mugshotSettings = Object.Instantiate<AvatarSettings>(next._customAvatarSettings);
					mugshotSettings.Height = 1f;
					Texture2D generatedMugshot = null;
					for (int attempt = 0; attempt <= 30; attempt++)
					{
						Transform mugshotParent = ((Component)mugshotRig).transform.parent;
						if ((Object)(object)mugshotParent != (Object)null)
						{
							((Component)mugshotParent).gameObject.SetActive(true);
						}
						((Component)mugshotRig).gameObject.SetActive(true);
						bool previousAllowCulling = (Object)(object)mugshotRig.Animation != (Object)null && mugshotRig.Animation.AllowCulling;
						if ((Object)(object)mugshotRig.Animation != (Object)null)
						{
							mugshotRig.Animation.AllowCulling = false;
						}
						mugshotRig.SetVisible(true);
						mugshotRig.Impostor.DisableImpostor();
						mugshotRig.LoadAvatarSettings(mugshotSettings);
						SetLayerRecursively(((Component)mugshotRig).gameObject, LayerMask.NameToLayer("IconGeneration"));
						Il2CppArrayBase<SkinnedMeshRenderer> skinnedMeshRenderers = ((Component)mugshotRig).GetComponentsInChildren<SkinnedMeshRenderer>();
						foreach (SkinnedMeshRenderer smr2 in skinnedMeshRenderers)
						{
							smr2.updateWhenOffscreen = true;
						}
						yield return null;
						yield return (object)new WaitForEndOfFrame();
						generatedMugshot = null;
						try
						{
							generatedMugshot = iconGenerator.GetTexture(((Component)mugshotRig).transform);
						}
						catch (Exception ex)
						{
							_logger.Error("Direct GetTexture failed: " + ex.Message);
						}
						bool hasContent = false;
						if ((Object)(object)generatedMugshot != (Object)null && ((Texture)generatedMugshot).width > 0 && ((Texture)generatedMugshot).height > 0)
						{
							int cx = ((Texture)generatedMugshot).width / 2;
							int cy = ((Texture)generatedMugshot).height / 2;
							Color centerPx = generatedMugshot.GetPixel(cx, cy);
							Color topPx = generatedMugshot.GetPixel(cx, (int)((float)((Texture)generatedMugshot).height * 0.85f));
							Color botPx = generatedMugshot.GetPixel(cx, (int)((float)((Texture)generatedMugshot).height * 0.15f));
							Color leftPx = generatedMugshot.GetPixel((int)((float)((Texture)generatedMugshot).width * 0.25f), cy);
							Color rightPx = generatedMugshot.GetPixel((int)((float)((Texture)generatedMugshot).width * 0.75f), cy);
							float maxBrightness = 0f;
							Color[] samples = (Color[])(object)new Color[5] { centerPx, topPx, botPx, leftPx, rightPx };
							Color[] array = samples;
							for (int i = 0; i < array.Length; i++)
							{
								Color s = array[i];
								float b = s.r + s.g + s.b;
								if (b > maxBrightness)
								{
									maxBrightness = b;
								}
							}
							hasContent = maxBrightness > 0.01f;
						}
						if (hasContent)
						{
							break;
						}
						if ((Object)(object)defaultSettings != (Object)null)
						{
							mugshotRig.LoadAvatarSettings(defaultSettings);
						}
						if ((Object)(object)mugshotRig.Animation != (Object)null)
						{
							mugshotRig.Animation.AllowCulling = previousAllowCulling;
						}
						((Component)mugshotRig).gameObject.SetActive(false);
						if (attempt == 30)
						{
							_logger.Warning($"[Mugshot] {next.NPC.FirstName}: no content after {31} attempts, using last capture");
						}
					}
					if ((Object)(object)generatedMugshot != (Object)null)
					{
						try
						{
							generatedMugshot.Apply();
							Rect cropRect = new Rect(0f, 0f, (float)((Texture)generatedMugshot).width, (float)((Texture)generatedMugshot).height);
							Sprite iconSprite = Sprite.Create(generatedMugshot, cropRect, Vector2.zero);
							next.NPC.ApplyGeneratedIcon(iconSprite);
							UpdatePoiIcons(next.NPC.S1NPC, iconSprite);
						}
						catch (Exception ex2)
						{
							Exception ex3 = ex2;
							_logger.Error("Failed to finalize mugshot: " + ex3.Message);
						}
					}
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(next.NPC.S1NPC, "Avatar", previousAvatar ?? next._runtimeAvatar);
					next.ApplyToAvatar(next._runtimeAvatar);
					bool finalAllowCulling = (Object)(object)mugshotRig.Animation != (Object)null && mugshotRig.Animation.AllowCulling;
					if ((Object)(object)defaultSettings != (Object)null)
					{
						mugshotRig.LoadAvatarSettings(defaultSettings);
					}
					if ((Object)(object)mugshotRig.Animation != (Object)null)
					{
						mugshotRig.Animation.AllowCulling = finalAllowCulling;
					}
					((Component)mugshotRig).gameObject.SetActive(false);
					yield return (object)new WaitForSeconds(0.1f);
				}
			}
		}

		internal void ApplyToAvatar(Avatar? avatar)
		{
			if (!((Object)(object)avatar == (Object)null))
			{
				avatar.LoadAvatarSettings(_customAvatarSettings);
			}
		}

		public NPCAppearance Set<T>(object appearanceValue) where T : BaseAppearance
		{
			InvalidateCombinedLayer();
			if (_setters.TryGetValue(typeof(T), out Action<NPCAppearance, object> value))
			{
				try
				{
					value(this, appearanceValue);
				}
				catch (Exception ex)
				{
					_logger.Error("Failed to set " + typeof(T).Name + ": " + ex.Message);
				}
			}
			else
			{
				_logger.Error("No setter registered for appearance type " + typeof(T).Name);
			}
			return this;
		}

		public NPCAppearance WithFaceLayer<T>(string path, uint hexColor) where T : BaseFaceAppearance
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return WithFaceLayer<T>(path, hexColor.ToColor());
		}

		public NPCAppearance WithFaceLayer<T>(string path, Color color) where T : BaseFaceAppearance
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (_customAvatarSettings.FaceLayerSettings.Count > 6)
			{
				return this;
			}
			InvalidateCombinedLayer();
			_customAvatarSettings.FaceLayerSettings.Add(new LayerSetting
			{
				layerPath = path,
				layerTint = color
			});
			return this;
		}

		public NPCAppearance WithBodyLayer<T>(string path, uint hexColor) where T : BaseBodyAppearance
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return WithBodyLayer<T>(path, hexColor.ToColor());
		}

		public NPCAppearance WithBodyLayer<T>(string path, Color color) where T : BaseBodyAppearance
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (_customAvatarSettings.BodyLayerSettings.Count > 6)
			{
				return this;
			}
			InvalidateCombinedLayer();
			_customAvatarSettings.BodyLayerSettings.Add(new LayerSetting
			{
				layerPath = path,
				layerTint = color
			});
			return this;
		}

		public NPCAppearance WithAccessoryLayer<T>(string path, uint hexColor) where T : BaseAccessoryAppearance
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return WithAccessoryLayer<T>(path, hexColor.ToColor());
		}

		public NPCAppearance WithAccessoryLayer<T>(string path, Color color) where T : BaseAccessoryAppearance
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			if (_customAvatarSettings.AccessorySettings.Count > 9)
			{
				return this;
			}
			InvalidateCombinedLayer();
			_customAvatarSettings.AccessorySettings.Add(new AccessorySetting
			{
				path = path,
				color = color
			});
			return this;
		}

		public NPCAppearance Build()
		{
			GenerateMugshot();
			return this;
		}

		public void GenerateRandomAppearance()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			Set<EyeBallTint>(RandomColor());
			Set<EyebrowRestingAngle>(RandomRange(0f, 1f));
			Set<EyebrowRestingHeight>(RandomRange(0f, 1f));
			Set<EyebrowScale>(RandomRange(0f, 1f));
			Set<EyebrowThickness>(RandomRange(0f, 1f));
			float item = RandomRange(0f, 1f);
			float item2 = RandomRange(0f, 1f);
			Set<EyeLidRestingStateLeft>((item, item2));
			Set<EyeLidRestingStateRight>((item, item2));
			Color val = RandomColor();
			Set<HairColor>(val);
			List<string> constPaths = BaseAppearance.GetConstPaths<HairStyle>();
			if (constPaths.Count > 0)
			{
				Set<HairStyle>(RandomFromList(constPaths));
			}
			Set<Gender>(RandomRange(0f, 1f));
			Set<Height>(RandomRange(0.8f, 1.2f));
			Set<PupilDilation>(RandomRange(0f, 1f));
			Set<SkinColor>(RandomColor());
			Set<Weight>(RandomRange(0f, 1f));
			Color color = RandomColor();
			List<string> constPaths2 = BaseFaceAppearance.GetConstPaths<Eyes>();
			if (constPaths2.Count > 0)
			{
				WithFaceLayer<Eyes>(RandomFromList(constPaths2), color);
			}
			List<string> constPaths3 = BaseFaceAppearance.GetConstPaths<Face>();
			if (constPaths3.Count > 0)
			{
				WithFaceLayer<Face>(RandomFromList(constPaths3), color);
			}
			if (Random.value < 0.5f)
			{
				List<string> constPaths4 = BaseFaceAppearance.GetConstPaths<FacialHair>();
				if (constPaths4.Count > 0)
				{
					WithFaceLayer<FacialHair>(RandomFromList(constPaths4), val);
				}
			}
			(Type, Action<string, Color>)[] source = new(Type, Action<string, Color>)[2]
			{
				(typeof(Shirts), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithBodyLayer<Shirts>(path, color2);
				}),
				(typeof(Pants), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithBodyLayer<Pants>(path, color2);
				})
			};
			foreach (var item7 in source.OrderBy(((Type type, Action<string, Color> apply) _) => Guid.NewGuid()).Take(Random.Range(1, 3)))
			{
				Type item3 = item7.type;
				Action<string, Color> item4 = item7.apply;
				MethodInfo methodInfo = AccessTools.Method(typeof(BaseBodyAppearance), "GetConstPaths", (Type[])null, (Type[])null).MakeGenericMethod(item3);
				List<string> list = (List<string>)methodInfo.Invoke(null, null);
				if (list != null && list.Count > 0)
				{
					item4(RandomFromList(list), RandomColor());
				}
			}
			(Type, Action<string, Color>)[] source2 = new(Type, Action<string, Color>)[7]
			{
				(typeof(Bottom), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Bottom>(path, color2);
				}),
				(typeof(Chest), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Chest>(path, color2);
				}),
				(typeof(Feet), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Feet>(path, color2);
				}),
				(typeof(Hands), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Hands>(path, color2);
				}),
				(typeof(Head), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Head>(path, color2);
				}),
				(typeof(Neck), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Neck>(path, color2);
				}),
				(typeof(Waist), delegate(string path, Color color2)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					WithAccessoryLayer<Waist>(path, color2);
				})
			};
			foreach (var item8 in source2.OrderBy(((Type type, Action<string, Color> apply) _) => Guid.NewGuid()).Take(Random.Range(2, 6)))
			{
				Type item5 = item8.type;
				Action<string, Color> item6 = item8.apply;
				MethodInfo methodInfo2 = AccessTools.Method(typeof(BaseAccessoryAppearance), "GetConstPaths", (Type[])null, (Type[])null).MakeGenericMethod(item5);
				List<string> list2 = (List<string>)methodInfo2.Invoke(null, null);
				if (list2 != null && list2.Count > 0)
				{
					item6(RandomFromList(list2), RandomColor());
				}
			}
			static Color RandomColor()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				return new Color(Random.value, Random.value, Random.value);
			}
			static string RandomFromList(List<string> list3)
			{
				return list3[Random.Range(0, list3.Count)];
			}
			static float RandomRange(float min, float max)
			{
				return Random.Range(min, max);
			}
		}

		private static void ApplyDefaultSettings(AvatarSettings avatarSettings)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			avatarSettings.SkinColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			avatarSettings.Height = 0.98f;
			avatarSettings.Gender = 0f;
			avatarSettings.Weight = 0.4f;
			avatarSettings.EyebrowScale = 1f;
			avatarSettings.EyebrowThickness = 1f;
			avatarSettings.EyebrowRestingHeight = 0f;
			avatarSettings.EyebrowRestingAngle = 0f;
			avatarSettings.LeftEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			avatarSettings.RightEyeLidColor = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));
			avatarSettings.LeftEyeRestingState = new EyeLidConfiguration
			{
				bottomLidOpen = 0.5f,
				topLidOpen = 0.5f
			};
			avatarSettings.RightEyeRestingState = new EyeLidConfiguration
			{
				bottomLidOpen = 0.5f,
				topLidOpen = 0.5f
			};
			avatarSettings.EyeballMaterialIdentifier = "Default";
			avatarSettings.EyeBallTint = Color.white;
			avatarSettings.PupilDilation = 1f;
			avatarSettings.HairPath = string.Empty;
			avatarSettings.HairColor = Color.black;
			avatarSettings.UseCombinedLayer = false;
			avatarSettings.CombinedLayer = null;
		}

		internal AvatarSettings CreateSettingsSnapshot()
		{
			return Object.Instantiate<AvatarSettings>(_customAvatarSettings);
		}

		private void InvalidateCombinedLayer()
		{
			_customAvatarSettings.UseCombinedLayer = false;
			_customAvatarSettings.CombinedLayer = null;
		}

		internal static void ResetMugshotState()
		{
			lock (_mugshotQueueLock)
			{
				_mugshotQueue.Clear();
				_isProcessingMugshots = false;
				_hasQueuedMugshots = false;
			}
		}

		private static void SetLayerRecursively(GameObject obj, int layer)
		{
			if (!((Object)(object)obj == (Object)null))
			{
				obj.layer = layer;
				for (int i = 0; i < obj.transform.childCount; i++)
				{
					SetLayerRecursively(((Component)obj.transform.GetChild(i)).gameObject, layer);
				}
			}
		}

		private static void UpdatePoiIcons(NPC npc, Sprite iconSprite)
		{
			if ((Object)(object)npc == (Object)null || (Object)(object)iconSprite == (Object)null)
			{
				return;
			}
			try
			{
				Il2CppArrayBase<NPCPoI> val = Object.FindObjectsOfType<NPCPoI>();
				foreach (NPCPoI item in val)
				{
					if (!((Object)(object)item.NPC == (Object)(object)npc) || !((Object)(object)((POI)item).IconContainer != (Object)null))
					{
						continue;
					}
					Transform val2 = ((Transform)((POI)item).IconContainer).Find("Outline/Icon");
					if ((Object)(object)val2 != (Object)null)
					{
						Image component = ((Component)val2).GetComponent<Image>();
						if ((Object)(object)component != (Object)null)
						{
							component.sprite = iconSprite;
						}
					}
				}
			}
			catch (Exception ex)
			{
				_logger.Error("Failed to update POI icons: " + ex.Message);
			}
		}
	}
	public sealed class NPCCustomer
	{
		internal readonly NPC NPC;

		private static readonly Log Logger = new Log("NPCCustomer");

		private Action<float, int, int, int>? _onContractAssigned;

		private Delegate? _contractAssignedBridge;

		private object? _contractAssignedUnityEvent;

		private MethodInfo? setupDialogueMethod = typeof(Customer).GetMethod("SetUpDialogue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public bool IsCustomer => (Object)(object)Component != (Object)null;

		internal Customer Component => NPC.gameObject.GetComponent<Customer>();

		public event Action OnUnlocked
		{
			add
			{
				EnsureCustomer();
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent customerUnityEvent = GetCustomerUnityEvent("onUnlocked", createIfMissing: true);
					if (customerUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.AddListener(value, customerUnityEvent);
					}
				}
				catch (Exception)
				{
				}
			}
			remove
			{
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent customerUnityEvent = GetCustomerUnityEvent("onUnlocked", createIfMissing: false);
					if (customerUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.RemoveListener(value, customerUnityEvent);
					}
				}
				catch (Exception)
				{
				}
			}
		}

		public event Action OnDealCompleted
		{
			add
			{
				EnsureCustomer();
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent customerUnityEvent = GetCustomerUnityEvent("onDealCompleted", createIfMissing: true);
					if (customerUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.AddListener(value, customerUnityEvent);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception in OnDealCompleted for " + NPC.ID + ": " + ex.Message);
					Logger.Warning("Stack trace: " + ex.StackTrace);
				}
			}
			remove
			{
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent customerUnityEvent = GetCustomerUnityEvent("onDealCompleted", createIfMissing: false);
					if (customerUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.RemoveListener(value, customerUnityEvent);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception while removing OnDealCompleted listener for " + NPC.ID + ": " + ex.Message);
				}
			}
		}

		public event Action<float, int, int, int> OnContractAssigned
		{
			add
			{
				EnsureCustomer();
				if (!((Object)(object)Component == (Object)null) && value != null && EnsureContractAssignedHook())
				{
					_onContractAssigned = (Action<float, int, int, int>)Delegate.Combine(_onContractAssigned, value);
				}
			}
			remove
			{
				if (value != null)
				{
					_onContractAssigned = (Action<float, int, int, int>)Delegate.Remove(_onContractAssigned, value);
					if (_onContractAssigned == null)
					{
						TryUnhookContractAssignedEvent();
					}
				}
			}
		}

		internal NPCCustomer(NPC npc)
		{
			NPC = npc;
		}

		public void EnsureCustomer()
		{
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Customer component not present on NPC prefab for " + NPC.ID + ". Add it via NPC.ConfigurePrefab(builder.EnsureCustomer()).");
				return;
			}
			try
			{
				EnsureCustomerData(Component);
				WireCoreReferences(Component);
				InitializeRuntimeState(Component);
				EnsureUnityEvents(Component);
				TryNetworkInitialize(Component);
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in EnsureCustomer for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		public void Unlock()
		{
			EnsureCustomer();
			if (!((Object)(object)Component == (Object)null))
			{
				NPCRelationData relationData = NPC.S1NPC.RelationData;
				if (relationData != null && !relationData.Unlocked)
				{
					relationData.Unlock((EUnlockType)1, true);
				}
			}
		}

		public bool ForceDealOffer()
		{
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Cannot force deal offer for " + NPC.ID + ": Customer component is null");
				return false;
			}
			EnsureCurrentAffinityDataInitialized(Component);
			try
			{
				ContractInfo offeredContractInfo = Component.OfferedContractInfo;
				Component.ForceDealOffer();
				ContractInfo offeredContractInfo2 = Component.OfferedContractInfo;
				bool flag = offeredContractInfo2 != null && offeredContractInfo2 != offeredContractInfo;
				if (!flag)
				{
					Logger.Warning("Failed to generate contract for " + NPC.ID + ". Check if products are listed for sale and NPC meets order conditions.");
				}
				return flag;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in ForceDealOffer for " + NPC.ID + ": " + ex.Message);
				return false;
			}
		}

		public bool OfferContract(ContractInfo info)
		{
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Cannot offer contract to " + NPC.ID + ": Customer component is null");
				return false;
			}
			if (info == null)
			{
				Logger.Warning("Cannot offer contract to " + NPC.ID + ": ContractInfo is null");
				return false;
			}
			EnsureCurrentAffinityDataInitialized(Component);
			ContractInfo val = info.ToInternal();
			try
			{
				Component.OfferContract(val);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("OfferContract failed for " + NPC.ID + ": " + ex.Message);
				return false;
			}
		}

		public void RequestProduct(Player? player = null)
		{
			if (!((Object)(object)Component == (Object)null))
			{
				EnsureCurrentAffinityDataInitialized(Component);
				if (player == null)
				{
					Component.RequestProduct(Player.Local);
				}
				else
				{
					Component.RequestProduct(player.S1Player);
				}
			}
		}

		public void SetAwaitingDelivery(bool awaiting)
		{
			if (!((Object)(object)Component == (Object)null))
			{
				Component.SetIsAwaitingDelivery(awaiting);
			}
		}

		public void SetupDialog()
		{
			setupDialogueMethod?.Invoke(Component, null);
		}

		private void TryNetworkInitialize(Customer customer)
		{
			if ((Object)(object)customer == (Object)null)
			{
				return;
			}
			try
			{
				TransportManager transportManager = InstanceFinder.TransportManager;
				NetworkObject component = NPC.gameObject.GetComponent<NetworkObject>();
				if (!((Object)(object)transportManager == (Object)null) && !((Object)(object)component == (Object)null))
				{
					SetNonPublicInstanceField(customer, "_transportManagerCache", transportManager);
					SetNonPublicInstanceField(customer, "_networkObjectCache", component);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in TryNetworkInitialize for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void WireCoreReferences(Customer customer)
		{
			try
			{
				MethodInfo methodInfo = typeof(Customer).GetProperty("NPC", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetSetMethod(nonPublic: true);
				if (methodInfo != null)
				{
					methodInfo.Invoke(customer, new object[1] { NPC.S1NPC });
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in WireCoreReferences for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void EnsureCustomerData(Customer customer)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			try
			{
				CustomerData customerData = customer.CustomerData;
				CustomerData val = null;
				val = customer.CustomerData;
				if ((Object)(object)val == (Object)null && (Object)(object)customerData != (Object)null)
				{
					val = customerData;
				}
				if (!((Object)(object)val == (Object)null))
				{
					return;
				}
				val = ScriptableObject.CreateInstance<CustomerData>();
				val.DefaultAffinityData = new CustomerAffinityData();
				Array values = Enum.GetValues(typeof(EDrugType));
				foreach (object item in values)
				{
					val.DefaultAffinityData.ProductAffinities.Add(new ProductTypeAffinity
					{
						DrugType = (EDrugType)item,
						Affinity = 0f
					});
				}
				val.MinWeeklySpend = 100f;
				val.MaxWeeklySpend = 400f;
				val.MinOrdersPerWeek = 1;
				val.MaxOrdersPerWeek = 3;
				val.OrderTime = 1200;
				val.CanBeDirectlyApproached = true;
				val.DependenceMultiplier = 1f;
				val.BaseAddiction = 0f;
				customer.customerData = val;
				CustomerAffinityData val2 = new CustomerAffinityData();
				if (val.DefaultAffinityData != null)
				{
					val.DefaultAffinityData.CopyTo(val2);
				}
				if (val2.ProductAffinities == null || val2.ProductAffinities.Count == 0)
				{
					CustomerAffinityData val3 = val2;
					if (val3.ProductAffinities == null)
					{
						List<ProductTypeAffinity> val4 = (val3.ProductAffinities = new List<ProductTypeAffinity>());
					}
					Array values2 = Enum.GetValues(typeof(EDrugType));
					foreach (object item2 in values2)
					{
						val2.ProductAffinities.Add(new ProductTypeAffinity
						{
							DrugType = (EDrugType)item2,
							Affinity = 0f
						});
					}
				}
				customer.currentAffinityData = val2;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in EnsureCustomerData for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void InitializeRuntimeState(Customer customer)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CustomerData customerData = customer.CustomerData;
				if ((Object)(object)customerData == (Object)null)
				{
					EnsureCustomerData(customer);
					customerData = customer.CustomerData;
				}
				try
				{
					if ((Object)(object)customer.NPC == (Object)null && (Object)(object)NPC?.S1NPC != (Object)null)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(customer, "NPC", NPC.S1NPC);
					}
				}
				catch
				{
				}
				try
				{
					if (Customer.UnlockedCustomers == null)
					{
						Customer.UnlockedCustomers = new List<Customer>();
					}
					if (Customer.LockedCustomers == null)
					{
						Customer.LockedCustomers = new List<Customer>();
					}
				}
				catch
				{
				}
				CustomerAffinityData currentAffinityData = customer.currentAffinityData;
				if (currentAffinityData == null)
				{
					currentAffinityData = new CustomerAffinityData();
					if ((Object)(object)customerData != (Object)null && customerData.DefaultAffinityData != null)
					{
						customerData.DefaultAffinityData.CopyTo(currentAffinityData);
					}
					if (currentAffinityData.ProductAffinities == null || currentAffinityData.ProductAffinities.Count == 0)
					{
						CustomerAffinityData val = currentAffinityData;
						if (val.ProductAffinities == null)
						{
							List<ProductTypeAffinity> val2 = (val.ProductAffinities = new List<ProductTypeAffinity>());
						}
						Array values = Enum.GetValues(typeof(EDrugType));
						foreach (object item in values)
						{
							currentAffinityData.ProductAffinities.Add(new ProductTypeAffinity
							{
								DrugType = (EDrugType)item,
								Affinity = 0f
							});
						}
					}
					customer.currentAffinityData = currentAffinityData;
				}
				float num = ((customerData != null) ? customerData.BaseAddiction : 0f);
				float currentAddiction = customer.CurrentAddiction;
				if (currentAddiction == 0f && num != 0f)
				{
					customer.CurrentAddiction = num;
				}
				try
				{
					if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(customer, "DefaultDeliveryLocation") == null)
					{
						Map instance = Singleton<Map>.Instance;
						NPC val4 = NPC?.S1NPC;
						if (instance != null && val4 != null)
						{
							MapRegionData regionData = instance.GetRegionData(val4.Region);
							DeliveryLocation val5 = ((regionData != null) ? regionData.GetRandomUnscheduledDeliveryLocation() : null);
							if ((Object)(object)val5 != (Object)null)
							{
								global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(customer, "DefaultDeliveryLocation", val5);
							}
						}
					}
				}
				catch
				{
				}
				try
				{
					EnsureDealAttendanceSupport(NPC?.gameObject, NPC?.GetType());
				}
				catch
				{
				}
			}
			catch (Exception)
			{
			}
		}

		internal static bool EnsureDealAttendanceSupport(GameObject? prefabRoot, Type? ownerType = null)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			if ((Object)(object)prefabRoot == (Object)null)
			{
				return false;
			}
			NPCBehaviour componentInChildren = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Logger.Warning("Cannot add CustomerAttendDealBehaviour for NPC type " + (ownerType?.Name ?? "Unknown") + ": NPCBehaviour is missing.");
				return false;
			}
			CustomerAttendDealBehaviour val = prefabRoot.GetComponentInChildren<CustomerAttendDealBehaviour>(true);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("Customer attend deal");
				val2.transform.SetParent(((Component)componentInChildren).transform, false);
				val = val2.AddComponent<CustomerAttendDealBehaviour>();
			}
			((Behaviour)val).EnabledOnAwake = false;
			((Behaviour)val).Name = "Customer attend deal";
			((Behaviour)val).Priority = 4;
			((Behaviour)val).SetCanUseUmbrellaDuringBehaviour(true);
			return true;
		}

		private void EnsureUnityEvents(Customer customer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			try
			{
				if (global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(customer, "onUnlocked") == null)
				{
					global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(customer, "onUnlocked", (object?)new UnityEvent());
				}
				if (global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(customer, "onDealCompleted") == null)
				{
					global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(customer, "onDealCompleted", (object?)new UnityEvent());
				}
				if (global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(customer, "onContractAssigned") == null)
				{
					Type type = typeof(UnityEvent<>).MakeGenericType(typeof(Contract));
					object value = Activator.CreateInstance(type);
					global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(customer, "onContractAssigned", value);
				}
			}
			catch (Exception)
			{
			}
		}

		private UnityEvent? GetCustomerUnityEvent(string memberName, bool createIfMissing)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if ((Object)(object)Component == (Object)null)
			{
				return null;
			}
			object? obj = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(Component, memberName);
			UnityEvent val = (UnityEvent)((obj is UnityEvent) ? obj : null);
			if (val == null && createIfMissing)
			{
				val = new UnityEvent();
				global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(Component, memberName, val);
			}
			return val;
		}

		private bool EnsureContractAssignedHook()
		{
			if ((object)_contractAssignedBridge != null || (Object)(object)Component == (Object)null)
			{
				return (object)_contractAssignedBridge != null;
			}
			try
			{
				object obj = typeof(Customer).GetField("onContractAssigned", BindingFlags.Instance | BindingFlags.Public)?.GetValue(Component);
				if (obj == null)
				{
					return false;
				}
				Type typeFromHandle = typeof(Contract);
				Type type = typeof(UnityAction<>).MakeGenericType(typeFromHandle);
				MethodInfo method = GetType().GetMethod("HandleContractAssigned", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method == null)
				{
					return false;
				}
				Delegate obj2 = Delegate.CreateDelegate(type, this, method);
				obj.GetType().GetMethod("AddListener", new Type[1] { type })?.Invoke(obj, new object[1] { obj2 });
				_contractAssignedBridge = obj2;
				_contractAssignedUnityEvent = obj;
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception wiring OnContractAssigned for " + NPC.ID + ": " + ex.Message);
				return false;
			}
		}

		private void TryUnhookContractAssignedEvent()
		{
			if ((object)_contractAssignedBridge == null || _contractAssignedUnityEvent == null)
			{
				return;
			}
			try
			{
				Type type = _contractAssignedBridge.GetType();
				_contractAssignedUnityEvent.GetType().GetMethod("RemoveListener", new Type[1] { type })?.Invoke(_contractAssignedUnityEvent, new object[1] { _contractAssignedBridge });
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception removing OnContractAssigned for " + NPC.ID + ": " + ex.Message);
			}
			finally
			{
				_contractAssignedBridge = null;
				_contractAssignedUnityEvent = null;
			}
		}

		private void HandleContractAssigned(object contract)
		{
			try
			{
				Action<float, int, int, int> onContractAssigned = _onContractAssigned;
				if (onContractAssigned == null || contract == null)
				{
					return;
				}
				float arg = 0f;
				int num = 0;
				int arg2 = 0;
				int arg3 = 0;
				Type type = contract.GetType();
				PropertyInfo property = type.GetProperty("Payment", BindingFlags.Instance | BindingFlags.Public);
				if (property != null)
				{
					arg = Convert.ToSingle(property.GetValue(contract));
				}
				object obj = type.GetProperty("ProductList", BindingFlags.Instance | BindingFlags.Public)?.GetValue(contract);
				if (obj != null && obj.GetType().GetField("entries", BindingFlags.Instance | BindingFlags.Public)?.GetValue(obj) is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						FieldInfo field = item.GetType().GetField("Quantity", BindingFlags.Instance | BindingFlags.Public);
						if (field != null)
						{
							num += Convert.ToInt32(field.GetValue(item));
						}
					}
				}
				object obj2 = type.GetProperty("DeliveryWindow", BindingFlags.Instance | BindingFlags.Public)?.GetValue(contract);
				if (obj2 != null)
				{
					FieldInfo field2 = obj2.GetType().GetField("WindowStartTime", BindingFlags.Instance | BindingFlags.Public);
					FieldInfo field3 = obj2.GetType().GetField("WindowEndTime", BindingFlags.Instance | BindingFlags.Public);
					if (field2 != null)
					{
						arg2 = Convert.ToInt32(field2.GetValue(obj2));
					}
					if (field3 != null)
					{
						arg3 = Convert.ToInt32(field3.GetValue(obj2));
					}
				}
				Delegate[] invocationList = onContractAssigned.GetInvocationList();
				for (int i = 0; i < invocationList.Length; i++)
				{
					Action<float, int, int, int> action = (Action<float, int, int, int>)invocationList[i];
					try
					{
						action(arg, num, arg2, arg3);
					}
					catch (Exception ex)
					{
						Logger.Warning("Exception in OnContractAssigned handler for " + NPC.ID + ": " + ex.Message);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Warning("Exception while processing OnContractAssigned for " + NPC.ID + ": " + ex2.Message);
			}
		}

		private void EnsureCurrentAffinityDataInitialized(Customer customer)
		{
			//IL_0075: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			if ((Object)(object)customer == (Object)null)
			{
				return;
			}
			try
			{
				if (customer.currentAffinityData == null)
				{
					InitializeRuntimeState(customer);
				}
				if (customer.currentAffinityData == null || customer.currentAffinityData.ProductAffinities == null)
				{
					return;
				}
				Array values = Enum.GetValues(typeof(EDrugType));
				foreach (object item in values)
				{
					EDrugType val = (EDrugType)item;
					ProductTypeAffinity val2 = null;
					Enumerator<ProductTypeAffinity> enumerator2 = customer.currentAffinityData.ProductAffinities.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						ProductTypeAffinity current2 = enumerator2.Current;
						if (current2 != null && current2.DrugType == val)
						{
							val2 = current2;
							break;
						}
					}
					if (val2 == null)
					{
						customer.currentAffinityData.ProductAffinities.Add(new ProductTypeAffinity
						{
							DrugType = val,
							Affinity = 0f
						});
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception ensuring currentAffinityData initialized for " + NPC.ID + ": " + ex.Message);
			}
		}

		public void RecommendDealer(NPCDealer dealer)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			if (dealer == null)
			{
				Logger.Warning("Cannot recommend dealer: dealer is null");
				return;
			}
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Cannot recommend dealer for " + NPC.ID + ": Customer component is null");
				return;
			}
			EnsureCurrentAffinityDataInitialized(Component);
			try
			{
				dealer.MarkAsRecommended();
				HintDisplay instance = Singleton<HintDisplay>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.ShowHint_20s("You can now hire <h1>" + dealer.NPC.FullName + "</h> as a dealer.", (string)null);
				}
				float distance;
				Player closestPlayer = GetClosestPlayer(NPC.gameObject.transform.position, out distance);
				if (!((Object)(object)closestPlayer == (Object)(object)Player.Local) || !(distance < 6f))
				{
					return;
				}
				NPC s1NPC = NPC.S1NPC;
				DialogueHandler val = ((s1NPC != null) ? s1NPC.DialogueHandler : null);
				if (!((Object)(object)val != (Object)null) || !((Object)(object)val.Database != (Object)null))
				{
					return;
				}
				string line = val.Database.GetLine((EDialogueModule)3, "post_deal_recommend_dealer");
				if (string.IsNullOrEmpty(line))
				{
					return;
				}
				line = line.Replace("<NAME>", dealer.NPC.FullName);
				DialogueContainer val2 = ScriptableObject.CreateInstance<DialogueContainer>();
				DialogueNodeData val3 = new DialogueNodeData();
				val3.DialogueText = line;
				val3.choices = Il2CppReferenceArray<DialogueChoiceData>.op_Implicit((DialogueChoiceData[])(object)new DialogueChoiceData[0]);
				val3.DialogueNodeLabel = "ENTRY";
				val3.VoiceLine = (EVOLineType)3;
				DialogueNodeData item = val3;
				List<DialogueNodeData> list = new List<DialogueNodeData> { item };
				List<DialogueNodeData> val4 = new List<DialogueNodeData>();
				foreach (DialogueNodeData item2 in list)
				{
					val4.Add(item2);
				}
				val2.DialogueNodeData = val4;
				MelonCoroutines.Start(WaitAndShowDialogue(val2, val));
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in RecommendDealer for " + NPC.ID + ": " + ex.Message);
			}
		}

		private IEnumerator WaitAndShowDialogue(DialogueContainer container, DialogueHandler handler)
		{
			yield return (object)new WaitForSeconds(0.1f);
			if ((Object)(object)handler != (Object)null && (Object)(object)container != (Object)null)
			{
				handler.StartDialogue(container);
			}
		}

		private static Player? GetClosestPlayer(Vector3 position, out float distance)
		{
			//IL_0041: 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)
			Player result = null;
			distance = float.MaxValue;
			List<Player> playerList = Player.PlayerList;
			if (playerList == null)
			{
				return null;
			}
			Enumerator<Player> enumerator = playerList.GetEnumerator();
			while (enumerator.MoveNext())
			{
				Player current = enumerator.Current;
				if (!((Object)(object)current == (Object)null))
				{
					float num = Vector3.Distance(position, ((Component)current).transform.position);
					if (num < distance)
					{
						result = current;
						distance = num;
					}
				}
			}
			return result;
		}

		private static void SetNonPublicInstanceField(object target, string fieldName, object? value)
		{
			try
			{
				if (target != null && !string.IsNullOrEmpty(fieldName))
				{
					Type type = target.GetType();
					FieldInfo fieldInfo = null;
					while (type != null && fieldInfo == null)
					{
						fieldInfo = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						type = type.BaseType;
					}
					fieldInfo?.SetValue(target, value);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public sealed class NPCDealer
	{
		internal readonly NPC NPC;

		private static readonly Log Logger = new Log("NPCDealer");

		private static readonly FieldInfo? DealerRecruitedField = typeof(Dealer).GetField("onDealerRecruited", BindingFlags.Static | BindingFlags.Public);

		private readonly Dictionary<Action, Action<Dealer>> _dealerRecruitedHandlers = new Dictionary<Action, Action<Dealer>>();

		private Action? _contractAcceptedHandlers;

		private bool _contractAcceptedHooked;

		public bool IsDealer => (Object)(object)Component != (Object)null;

		public global::S1API.Map.Building? Home
		{
			get
			{
				EnsureDealer();
				if ((Object)(object)Component == (Object)null)
				{
					return null;
				}
				try
				{
					object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Component, "Home");
					if (obj == null)
					{
						return null;
					}
					string text = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(obj, "BuildingName") as string;
					if (string.IsNullOrEmpty(text))
					{
						return null;
					}
					return global::S1API.Map.Building.GetByName(text);
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception in Home getter for " + NPC.ID + ": " + ex.Message);
					return null;
				}
			}
			set
			{
				EnsureDealer();
				if ((Object)(object)Component == (Object)null)
				{
					Logger.Warning("Cannot set Home for " + NPC.ID + ": Dealer component not available.");
					return;
				}
				try
				{
					object obj = null;
					if (value != null)
					{
						obj = value.ResolveGameBuilding();
						if (obj == null)
						{
							Logger.Warning($"Cannot set Home for {NPC.ID}: Building '{value.Name}' could not be resolved.");
							return;
						}
					}
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(Component, "Home", obj);
					try
					{
						object obj2 = typeof(Dealer).GetProperty("HomeEvent", BindingFlags.Instance | BindingFlags.Public)?.GetValue(Component);
						if (obj2 != null)
						{
							global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(obj2, "Building", obj);
						}
					}
					catch
					{
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception in Home setter for " + NPC.ID + ": " + ex.Message);
				}
			}
		}

		internal Dealer? Component
		{
			get
			{
				NPC s1NPC = NPC.S1NPC;
				Dealer val = (Dealer)(object)((s1NPC is Dealer) ? s1NPC : null);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				return NPC.gameObject.GetComponent<Dealer>();
			}
		}

		public event Action OnRecruited
		{
			add
			{
				EnsureDealer();
				if ((Object)(object)Component == (Object)null || value == null || DealerRecruitedField == null || _dealerRecruitedHandlers.ContainsKey(value))
				{
					return;
				}
				try
				{
					Action<Dealer> action = delegate(Dealer dealer)
					{
						if ((Object)(object)dealer != (Object)(object)Component)
						{
							return;
						}
						try
						{
							value();
						}
						catch (Exception ex2)
						{
							Logger.Warning("Exception in OnRecruited handler for " + NPC.ID + ": " + ex2.Message);
						}
					};
					Action<Dealer> value2 = ((DealerRecruitedField.GetValue(null) is Action<Dealer> a) ? ((Action<Dealer>)Delegate.Combine(a, action)) : action);
					DealerRecruitedField.SetValue(null, value2);
					_dealerRecruitedHandlers[value] = action;
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception wiring OnRecruited for " + NPC.ID + ": " + ex.Message);
				}
			}
			remove
			{
				if (value == null || DealerRecruitedField == null || !_dealerRecruitedHandlers.TryGetValue(value, out Action<Dealer> value2))
				{
					return;
				}
				_dealerRecruitedHandlers.Remove(value);
				try
				{
					if (DealerRecruitedField.GetValue(null) is Action<Dealer> source)
					{
						Action<Dealer> value3 = (Action<Dealer>)Delegate.Remove(source, value2);
						DealerRecruitedField.SetValue(null, value3);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception removing OnRecruited handler for " + NPC.ID + ": " + ex.Message);
				}
			}
		}

		public event Action OnContractAccepted
		{
			add
			{
				EnsureDealer();
				if (!((Object)(object)Component == (Object)null) && value != null)
				{
					EnsureContractAcceptedHook();
					_contractAcceptedHandlers = (Action)Delegate.Combine(_contractAcceptedHandlers, value);
				}
			}
			remove
			{
				if (value != null)
				{
					_contractAcceptedHandlers = (Action)Delegate.Remove(_contractAcceptedHandlers, value);
				}
			}
		}

		public event Action OnRecommended
		{
			add
			{
				EnsureDealer();
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent recommendedUnityEvent = GetRecommendedUnityEvent(createIfMissing: true);
					if (recommendedUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.AddListener(value, recommendedUnityEvent);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception in OnRecommended for " + NPC.ID + ": " + ex.Message);
				}
			}
			remove
			{
				if ((Object)(object)Component == (Object)null || value == null)
				{
					return;
				}
				try
				{
					UnityEvent recommendedUnityEvent = GetRecommendedUnityEvent(createIfMissing: false);
					if (recommendedUnityEvent != null)
					{
						global::S1API.Utils.EventHelper.RemoveListener(value, recommendedUnityEvent);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception while removing OnRecommended handler for " + NPC.ID + ": " + ex.Message);
				}
			}
		}

		internal NPCDealer(NPC npc)
		{
			NPC = npc;
		}

		internal static void ClearStaticDelegates()
		{
			try
			{
				if (DealerRecruitedField != null)
				{
					DealerRecruitedField.SetValue(null, null);
				}
			}
			catch
			{
			}
		}

		public void EnsureDealer()
		{
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Dealer component not present on NPC prefab for " + NPC.ID + ". Add it via NPC.ConfigurePrefab(builder.EnsureDealer()).");
				return;
			}
			try
			{
				EnsureDealerCategory();
				WireCoreReferences(Component);
				InitializeRuntimeState(Component);
				EnsureUnityEvents(Component);
				TryNetworkInitialize(Component);
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in EnsureDealer for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void EnsureDealerCategory()
		{
			try
			{
				NPC.SetConversationCategory((EConversationCategory)2);
				if (NPC.S1NPC.MSGConversation != null)
				{
					TryHookConversationUIRefresh(NPC.S1NPC.MSGConversation);
					RefreshDealerCategoryBadge();
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in EnsureDealerCategory for " + NPC.ID + ": " + ex.Message);
			}
		}

		private void TryHookConversationUIRefresh(object convoObj)
		{
			try
			{
				MSGConversation val = (MSGConversation)((convoObj is MSGConversation) ? convoObj : null);
				if (val == null)
				{
					return;
				}
				FieldInfo field = typeof(MSGConversation).GetField("uiCreated", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null)
				{
					object value = field.GetValue(val);
					bool flag = default(bool);
					int num;
					if (value != null)
					{
						if (value is bool)
						{
							flag = (bool)value;
							num = 1;
						}
						else
						{
							num = 0;
						}
					}
					else
					{
						num = 0;
					}
					if (((uint)num & (flag ? 1u : 0u)) != 0)
					{
						RefreshDealerCategoryBadge();
					}
				}
				Action prevLoaded = val.onLoaded;
				val.onLoaded = Action.op_Implicit((Action)delegate
				{
					try
					{
						Action obj = prevLoaded;
						if (obj != null)
						{
							obj.Invoke();
						}
					}
					catch
					{
					}
					RefreshDealerCategoryBadge();
				});
				Action prevOpened = val.onConversationOpened;
				val.onConversationOpened = Action.op_Implicit((Action)delegate
				{
					try
					{
						Action obj = prevOpened;
						if (obj != null)
						{
							obj.Invoke();
						}
					}
					catch
					{
					}
					RefreshDealerCategoryBadge();
				});
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in TryHookConversationUIRefresh: " + ex.Message);
			}
		}

		private void RefreshDealerCategoryBadge()
		{
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MSGConversation mSGConversation = NPC.S1NPC.MSGConversation;
				if (mSGConversation == null)
				{
					return;
				}
				object? obj = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(mSGConversation, "entry");
				RectTransform val = (RectTransform)((obj is RectTransform) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				MessagesApp instance = PlayerSingleton<MessagesApp>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				CategoryInfo categoryInfo = instance.GetCategoryInfo((EConversationCategory)2);
				if (categoryInfo == null)
				{
					return;
				}
				Transform obj2 = ((Transform)val).Find("Category");
				RectTransform val2 = (RectTransform)(object)((obj2 is RectTransform) ? obj2 : null);
				if ((Object)(object)val2 == (Object)null)
				{
					try
					{
						for (int i = 0; i < ((Transform)val).childCount; i++)
						{
							Transform child = ((Transform)val).GetChild(i);
							if (((Object)child).name != null && ((Object)child).name.Contains("Category"))
							{
								val2 = (RectTransform)(object)((child is RectTransform) ? child : null);
							}
						}
					}
					catch
					{
					}
					if ((Object)(object)val2 == (Object)null)
					{
						return;
					}
				}
				Transform obj4 = ((Transform)val2).Find("Label");
				Text val3 = ((obj4 != null) ? ((Component)obj4).GetComponent<Text>() : null);
				Image component = ((Component)val2).GetComponent<Image>();
				Transform obj5 = ((Transform)val).Find("Name");
				Text val4 = ((obj5 != null) ? ((Component)obj5).GetComponent<Text>() : null);
				if (!((Object)(object)val3 == (Object)null) && !((Object)(object)component == (Object)null) && !((Object)(object)val4 == (Object)null))
				{
					val3.text = ((categoryInfo.Name != null && categoryInfo.Name.Length > 0) ? categoryInfo.Name[0].ToString() : "D");
					LayoutRebuilder.ForceRebuildLayoutImmediate(((Graphic)val3).rectTransform);
					((Graphic)component).color = categoryInfo.Color;
					val2.anchoredPosition = new Vector2(225f + val4.preferredWidth, val2.anchoredPosition.y);
					((Component)val2).gameObject.SetActive(true);
				}
			}
			catch
			{
			}
		}

		public void RecruitDealer()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return;
			}
			try
			{
				Component.InitialRecruitment();
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in RecruitDealer for " + NPC.ID + ": " + ex.Message);
			}
		}

		public void MarkAsRecommended()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return;
			}
			try
			{
				Component.MarkAsRecommended();
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in MarkAsRecommended for " + NPC.ID + ": " + ex.Message);
			}
		}

		public void AssignCustomer(NPC customer)
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null || customer == null)
			{
				return;
			}
			try
			{
				Component.AddCustomer_Server(customer.ID);
				try
				{
					Customer component = customer.gameObject.GetComponent<Customer>();
					if ((Object)(object)component != (Object)null && (Object)(object)component.AssignedDealer == (Object)null)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(component, "AssignedDealer", Component);
					}
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in AssignCustomer for " + NPC.ID + ": " + ex.Message);
			}
		}

		public void RemoveCustomer(NPC customer)
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null || customer == null)
			{
				return;
			}
			try
			{
				Component.SendRemoveCustomer(customer.ID);
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in RemoveCustomer for " + NPC.ID + ": " + ex.Message);
			}
		}

		public float GetCash()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return 0f;
			}
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Component, "Cash");
				if (obj != null && obj is float result)
				{
					return result;
				}
				return 0f;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in GetCash for " + NPC.ID + ": " + ex.Message);
				return 0f;
			}
		}

		public void ChangeCash(float amount)
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return;
			}
			try
			{
				Component.ChangeCash(amount);
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in ChangeCash for " + NPC.ID + ": " + ex.Message);
			}
		}

		public void CollectCash()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return;
			}
			try
			{
				MethodInfo method = typeof(Dealer).GetMethod("CollectCash", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method != null)
				{
					method.Invoke(Component, null);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in CollectCash for " + NPC.ID + ": " + ex.Message);
			}
		}

		public bool IsRecruited()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return false;
			}
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Component, "IsRecruited");
				if (obj != null && obj is bool result)
				{
					return result;
				}
				return false;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in IsRecruited for " + NPC.ID + ": " + ex.Message);
				return false;
			}
		}

		public bool HasBeenRecommended()
		{
			EnsureDealer();
			if ((Object)(object)Component == (Object)null)
			{
				return false;
			}
			try
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Component, "HasBeenRecommended");
				if (obj != null && obj is bool result)
				{
					return result;
				}
				return false;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in HasBeenRecommended for " + NPC.ID + ": " + ex.Message);
				return false;
			}
		}

		public List<NPC> GetAssignedCustomers()
		{
			EnsureDealer();
			List<NPC> list = new List<NPC>();
			if ((Object)(object)Component == (Object)null)
			{
				return list;
			}
			try
			{
				Enumerator<Customer> enumerator = Component.AssignedCustomers.GetEnumerator();
				while (enumerator.MoveNext())
				{
					Customer customer = enumerator.Current;
					Customer obj = customer;
					if ((Object)(object)((obj != null) ? obj.NPC : null) != (Object)null)
					{
						NPC nPC = global::S1API.Entities.NPC.All.FirstOrDefault((NPC n) => (Object)(object)n.S1NPC == (Object)(object)customer.NPC);
						if (nPC != null)
						{
							list.Add(nPC);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in GetAssignedCustomers for " + NPC.ID + ": " + ex.Message);
			}
			return list;
		}

		private void TryNetworkInitialize(Dealer dealer)
		{
			if ((Object)(object)dealer == (Object)null)
			{
				return;
			}
			try
			{
				TransportManager transportManager = InstanceFinder.TransportManager;
				NetworkObject component = NPC.gameObject.GetComponent<NetworkObject>();
				if (!((Object)(object)transportManager == (Object)null) && !((Object)(object)component == (Object)null))
				{
					SetNonPublicInstanceField(dealer, "_transportManagerCache", transportManager);
					SetNonPublicInstanceField(dealer, "_networkObjectCache", component);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in TryNetworkInitialize for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void WireCoreReferences(Dealer dealer)
		{
			try
			{
				if ((Object)(object)dealer != (Object)null && !((Object)(object)dealer != (Object)/*isinst with value type is only supported in some contexts*/))
				{
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception in WireCoreReferences for " + NPC.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
			}
		}

		private void InitializeRuntimeState(Dealer dealer)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			try
			{
				try
				{
					object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(dealer, "AssignedCustomers");
					if (obj == null)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealer, "AssignedCustomers", new List<Customer>());
					}
					object obj2 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(dealer, "ActiveContracts");
					if (obj2 == null)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(dealer, "ActiveContracts", new List<Contract>());
					}
				}
				catch
				{
				}
				FieldInfo field = typeof(Dealer).GetField("overflowSlots", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null && (!(field.GetValue(dealer) is ItemSlot[] array) || array.Length == 0))
				{
					ItemSlot[] array2 = (ItemSlot[])(object)new ItemSlot[10];
					for (int i = 0; i < 10; i++)
					{
						array2[i] = new ItemSlot();
						array2[i].SetSlotOwner(((Il2CppObjectBase)dealer).Cast<IItemSlotOwner>());
					}
					field.SetValue(dealer, array2);
				}
				try
				{
					FieldInfo field2 = typeof(Dealer).GetField("_attendDealBehaviour", BindingFlags.Instance | BindingFlags.NonPublic);
					object? obj4 = field2?.GetValue(dealer);
					DealerAttendDealBehaviour val = (DealerAttendDealBehaviour)((obj4 is DealerAttendDealBehaviour) ? obj4 : null);
					if ((Object)(object)val == (Object)null)
					{
						NPCBehaviour val2 = NPC.gameObject.GetComponentInChildren<NPCBehaviour>(true);
						if ((Object)(object)val2 == (Object)null)
						{
							GameObject val3 = new GameObject("NPCBehaviour");
							val3.transform.SetParent(NPC.gameObject.transform, false);
							val2 = val3.AddComponent<NPCBehaviour>();
						}
						DealerAttendDealBehaviour val4 = NPC.gameObject.GetComponentInChildren<DealerAttendDealBehaviour>(true);
						if ((Object)(object)val4 == (Object)null)
						{
							GameObject val5 = new GameObject("DealerAttendDealBehaviour");
							val5.transform.SetParent(((Component)val2).transform, false);
							val4 = val5.AddComponent<DealerAttendDealBehaviour>();
							val5.SetActive(false);
						}
						field2?.SetValue(dealer, val4);
					}
				}
				catch
				{
				}
				try
				{
					PropertyInfo property = typeof(Dealer).GetProperty("HomeEvent", BindingFlags.Instance | BindingFlags.Public);
					object? obj6 = property?.GetValue(dealer);
					NPCEvent_StayInBuilding val6 = (NPCEvent_StayInBuilding)((obj6 is NPCEvent_StayInBuilding) ? obj6 : null);
					if (!((Object)(object)val6 == (Object)null))
					{
						return;
					}
					NPCScheduleManager componentInChildren = NPC.gameObject.GetComponentInChildren<NPCScheduleManager>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						val6 = NPC.gameObject.GetComponentInChildren<NPCEvent_StayInBuilding>(true);
						if ((Object)(object)val6 == (Object)null)
						{
							GameObject val7 = new GameObject("HomeEvent");
							val7.transform.SetParent(((Component)componentInChildren).transform, false);
							val6 = val7.AddComponent<NPCEvent_StayInBuilding>();
							val7.SetActive(false);
						}
						property?.SetValue(dealer, val6);
					}
				}
				catch
				{
				}
			}
			catch (Exception)
			{
			}
		}

		private void EnsureUnityEvents(Dealer dealer)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			try
			{
				PropertyInfo property = typeof(Dealer).GetProperty("onRecommended", BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo property2 = typeof(Dealer).GetProperty("onContractAccepted", BindingFlags.Instance | BindingFlags.Public);
				if (property != null && property.GetValue(dealer) == null)
				{
					property.SetValue(dealer, (object?)new UnityEvent());
				}
				if (property2 != null && property2.GetValue(dealer) == null)
				{
					property2.SetValue(dealer, (Action)delegate
					{
					});
				}
			}
			catch (Exception)
			{
			}
		}

		private void EnsureContractAcceptedHook()
		{
			if (_contractAcceptedHooked || (Object)(object)Component == (Object)null)
			{
				return;
			}
			try
			{
				Action existing = Component.onContractAccepted;
				Action dispatch = DispatchContractAccepted;
				Component.onContractAccepted = Action.op_Implicit(((Delegate)(object)existing != (Delegate)null) ? ((Action)delegate
				{
					Action obj = existing;
					if (obj != null)
					{
						obj.Invoke();
					}
					dispatch();
				}) : dispatch);
				_contractAcceptedHooked = true;
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception wiring OnContractAccepted for " + NPC.ID + ": " + ex.Message);
			}
		}

		private void DispatchContractAccepted()
		{
			Action contractAcceptedHandlers = _contractAcceptedHandlers;
			if (contractAcceptedHandlers == null)
			{
				return;
			}
			Delegate[] invocationList = contractAcceptedHandlers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception ex)
				{
					Logger.Warning("Exception in OnContractAccepted handler for " + NPC.ID + ": " + ex.Message);
				}
			}
		}

		private UnityEvent? GetRecommendedUnityEvent(bool createIfMissing)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			if ((Object)(object)Component == (Object)null)
			{
				return null;
			}
			PropertyInfo property = typeof(Dealer).GetProperty("onRecommended", BindingFlags.Instance | BindingFlags.Public);
			if (property != null)
			{
				object? value = property.GetValue(Component);
				UnityEvent val = (UnityEvent)((value is UnityEvent) ? value : null);
				if (val == null && createIfMissing)
				{
					val = new UnityEvent();
					property.SetValue(Component, val);
				}
				return val;
			}
			FieldInfo field = typeof(Dealer).GetField("onRecommended", BindingFlags.Instance | BindingFlags.Public);
			if (field == null)
			{
				return null;
			}
			object? value2 = field.GetValue(Component);
			UnityEvent val2 = (UnityEvent)((value2 is UnityEvent) ? value2 : null);
			if (val2 == null && createIfMissing)
			{
				val2 = new UnityEvent();
				field.SetValue(Component, val2);
			}
			return val2;
		}

		private static void SetNonPublicInstanceField(object target, string fieldName, object value)
		{
			try
			{
				if (target != null && !string.IsNullOrEmpty(fieldName))
				{
					Type type = target.GetType();
					FieldInfo fieldInfo = null;
					while (type != null && fieldInfo == null)
					{
						fieldInfo = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						type = type.BaseType;
					}
					fieldInfo?.SetValue(target, value);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	public sealed class NPCDialogue
	{
		internal readonly NPC NPC;

		private readonly Dictionary<string, List<Action>> _choiceCallbacks = new Dictionary<string, List<Action>>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, List<Action>> _nodeCallbacks = new Dictionary<string, List<Action>>(StringComparer.OrdinalIgnoreCase);

		private readonly List<Action> _conversationStartCallbacks = new List<Action>();

		private bool _eventsHooked;

		public bool IsDialogueInProgress => (Object)(object)Handler != (Object)null && Handler.IsDialogueInProgress;

		internal DialogueHandler Handler => NPC.gameObject.GetComponentInChildren<DialogueHandler>(true);

		internal NPCDialogue(NPC npc)
		{
			NPC = npc;
		}

		public NPCDialogue OnChoiceSelected(string choiceLabel, Action callback)
		{
			if (string.IsNullOrEmpty(choiceLabel) || callback == null)
			{
				return this;
			}
			EnsureHandler();
			EnsureEventHooks();
			if (!_choiceCallbacks.TryGetValue(choiceLabel, out List<Action> value))
			{
				value = new List<Action>();
				_choiceCallbacks[choiceLabel] = value;
			}
			value.Add(callback);
			return this;
		}

		public NPCDialogue OnNodeDisplayed(string nodeLabel, Action callback)
		{
			if (string.IsNullOrEmpty(nodeLabel) || callback == null)
			{
				return this;
			}
			EnsureHandler();
			EnsureEventHooks();
			if (!_nodeCallbacks.TryGetValue(nodeLabel, out List<Action> value))
			{
				value = new List<Action>();
				_nodeCallbacks[nodeLabel] = value;
			}
			value.Add(callback);
			return this;
		}

		public NPCDialogue OnConversationStart(Action callback)
		{
			if (callback == null)
			{
				return this;
			}
			EnsureHandler();
			EnsureEventHooks();
			_conversationStartCallbacks.Add(callback);
			return this;
		}

		public void ClearCallbacks()
		{
			_choiceCallbacks.Clear();
			_nodeCallbacks.Clear();
			_conversationStartCallbacks.Clear();
		}

		public void Start(string containerName, bool enableBehaviour = true, string entryNodeLabel = "ENTRY")
		{
			if (!string.IsNullOrEmpty(containerName))
			{
				EnsureHandler();
				StartDialogueCompat(containerName, enableBehaviour, entryNodeLabel);
			}
		}

		public void End()
		{
			DialogueHandler handler = Handler;
			if (handler != null)
			{
				handler.EndDialogue();
			}
		}

		public void ShowWorldText(string text, float durationSeconds)
		{
			if (!string.IsNullOrEmpty(text))
			{
				EnsureHandler();
				DialogueHandler handler = Handler;
				if (handler != null)
				{
					handler.ShowWorldspaceDialogue(text, durationSeconds);
				}
			}
		}

		public void PlayReaction(string key, float durationSeconds = -1f, bool network = false)
		{
			if (string.IsNullOrEmpty(key))
			{
				DialogueHandler handler = Handler;
				if (handler != null)
				{
					handler.HideWorldspaceDialogue();
				}
				return;
			}
			EnsureHandler();
			DialogueHandler handler2 = Handler;
			if (handler2 != null)
			{
				handler2.PlayReaction(key, durationSeconds, network);
			}
		}

		public void OverrideText(string text)
		{
			EnsureHandler();
			DialogueHandler handler = Handler;
			if (handler != null)
			{
				handler.OverrideShownDialogue(text);
			}
		}

		public void StopOverride()
		{
			DialogueHandler handler = Handler;
			if (handler != null)
			{
				handler.StopOverride();
			}
			DialogueHandler handler2 = Handler;
			if (handler2 != null)
			{
				((Component)handler2).GetComponent<DialogueController>().ClearOverrideContainer();
			}
		}

		internal void EnsureHandler()
		{
			if ((Object)(object)Handler == (Object)null)
			{
				NPC.gameObject.AddComponent<DialogueHandler>();
			}
		}

		private void EnsureEventHooks()
		{
			if (!((Object)(object)Handler == (Object)null) && !_eventsHooked)
			{
				_eventsHooked = true;
				global::S1API.Utils.EventHelper.AddListener<string>(Internal_OnChoice, Handler.onDialogueChoiceChosen);
				global::S1API.Utils.EventHelper.AddListener<string>(Internal_OnNode, Handler.onDialogueNodeDisplayed);
				global::S1API.Utils.EventHelper.AddListener(Internal_OnConversationStart, Handler.onConversationStart);
			}
		}

		internal void RebuildRuntimeModules(DialogueDatabase db)
		{
			if ((Object)(object)Handler == (Object)null || (Object)(object)db == (Object)null)
			{
				return;
			}
			try
			{
				db.Initialize(Handler);
			}
			catch
			{
			}
			EnsureRuntimeModulesList();
			List<DialogueModule> runtimeModules = GetRuntimeModules();
			try
			{
				runtimeModules?.Clear();
			}
			catch
			{
			}
			Il2CppArrayBase<DialogueModule> components = ((Component)Handler).gameObject.GetComponents<DialogueModule>();
			for (int i = 0; i < components.Length; i++)
			{
				Object.Destroy((Object)(object)components[i]);
			}
			DialogueModule val = ((Component)Handler).gameObject.AddComponent<DialogueModule>();
			val.ModuleType = (EDialogueModule)0;
			val.Entries = db.GenericEntries;
			runtimeModules?.Add(val);
			if (db.Modules == null)
			{
				return;
			}
			for (int j = 0; j < db.Modules.Count; j++)
			{
				try
				{
					runtimeModules?.Add(db.Modules[j]);
				}
				catch
				{
				}
			}
		}

		public void BuildAndSetDatabase(Action<DialogueDatabaseBuilder> configure)
		{
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			if (configure == null)
			{
				return;
			}
			DialogueDatabaseBuilder dialogueDatabaseBuilder = new DialogueDatabaseBuilder();
			configure(dialogueDatabaseBuilder);
			DialogueDatabaseBuilder.BuildResult buildResult = dialogueDatabaseBuilder.BuildInternal();
			EnsureHandler();
			if ((Object)(object)Handler == (Object)null)
			{
				return;
			}
			if ((Object)(object)Handler.Database != (Object)null)
			{
				AppendIntoExistingDatabase(Handler.Database, buildResult.Database);
				AppendRuntimeModulesFromDatabase(buildResult.Database);
			}
			else
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(Handler, "Database", buildResult.Database);
				RebuildRuntimeModules(buildResult.Database);
			}
			if (buildResult.ModuleSpecs != null)
			{
				foreach (DialogueDatabaseBuilder.ModuleSpec moduleSpec in buildResult.ModuleSpecs)
				{
					DialogueModule val = ((Component)Handler).gameObject.AddComponent<DialogueModule>();
					if (Enum.TryParse<EDialogueModule>(moduleSpec.ModuleName, ignoreCase: true, out EDialogueModule result))
					{
						val.ModuleType = result;
					}
					val.Entries = ToIl2CppEntryList(moduleSpec.Entries);
					EnsureRuntimeModulesList();
					try
					{
						GetRuntimeModules()?.Add(val);
					}
					catch
					{
					}
				}
			}
			try
			{
				DialogueDatabase obj2 = Handler.Database ?? buildResult.Database;
				if (obj2 != null)
				{
					obj2.Initialize(Handler);
				}
			}
			catch
			{
			}
		}

		private void EnsureRuntimeModulesList()
		{
			try
			{
				if (GetRuntimeModules() == null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(Handler, "RuntimeModules", new List<DialogueModule>());
				}
			}
			catch
			{
			}
		}

		private void AppendIntoExistingDatabase(DialogueDatabase target, DialogueDatabase source)
		{
			if ((Object)(object)target == (Object)null || (Object)(object)source == (Object)null)
			{
				return;
			}
			try
			{
				if (source.GenericEntries != null)
				{
					for (int i = 0; i < source.GenericEntries.Count; i++)
					{
						target.GenericEntries.Add(source.GenericEntries[i]);
					}
				}
			}
			catch
			{
			}
			try
			{
				if (source.Modules != null)
				{
					if (target.Modules == null)
					{
						target.Modules = new List<DialogueModule>();
					}
					for (int j = 0; j < source.Modules.Count; j++)
					{
						target.Modules.Add(source.Modules[j]);
					}
				}
			}
			catch
			{
			}
			try
			{
				target.Initialize(Handler);
			}
			catch
			{
			}
		}

		private void AppendRuntimeModulesFromDatabase(DialogueDatabase db)
		{
			if ((Object)(object)Handler == (Object)null || (Object)(object)db == (Object)null)
			{
				return;
			}
			EnsureRuntimeModulesList();
			List<DialogueModule> runtimeModules = GetRuntimeModules();
			try
			{
				if (db.GenericEntries != null && db.GenericEntries.Count > 0)
				{
					DialogueModule val = ((Component)Handler).gameObject.AddComponent<DialogueModule>();
					val.ModuleType = (EDialogueModule)0;
					val.Entries = db.GenericEntries;
					runtimeModules?.Add(val);
				}
			}
			catch
			{
			}
			if (db.Modules == null)
			{
				return;
			}
			for (int i = 0; i < db.Modules.Count; i++)
			{
				try
				{
					runtimeModules?.Add(db.Modules[i]);
				}
				catch
				{
				}
			}
		}

		public void BuildAndRegisterContainer(string containerName, Action<DialogueContainerBuilder> configure)
		{
			if (string.IsNullOrEmpty(containerName) || configure == null)
			{
				return;
			}
			EnsureHandler();
			if ((Object)(object)Handler == (Object)null)
			{
				return;
			}
			DialogueContainerBuilder dialogueContainerBuilder = new DialogueContainerBuilder();
			configure(dialogueContainerBuilder);
			DialogueContainer val = dialogueContainerBuilder.Build(containerName);
			List<DialogueContainer> dialogueContainers = Handler.dialogueContainers;
			if (dialogueContainers == null)
			{
				return;
			}
			int num = -1;
			for (int i = 0; i < dialogueContainers.Count; i++)
			{
				DialogueContainer val2 = dialogueContainers[i];
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == containerName)
				{
					num = i;
					break;
				}
			}
			if (num >= 0)
			{
				dialogueContainers[num] = val;
			}
			else
			{
				dialogueContainers.Add(val);
			}
		}

		public bool UseContainerOnInteract(string containerName)
		{
			if (string.IsNullOrEmpty(containerName))
			{
				return false;
			}
			EnsureHandler();
			if ((Object)(object)Handler == (Object)null)
			{
				return false;
			}
			List<DialogueContainer> dialogueContainers = Handler.dialogueContainers;
			if (dialogueContainers == null)
			{
				return false;
			}
			DialogueContainer val = null;
			for (int i = 0; i < dialogueContainers.Count; i++)
			{
				DialogueContainer val2 = dialogueContainers[i];
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == containerName)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			DialogueController component = ((Component)Handler).GetComponent<DialogueController>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			component.SetOverrideContainer(val);
			return true;
		}

		public bool UseContainerOnInteractOnce(string containerName)
		{
			if (string.IsNullOrEmpty(containerName))
			{
				return false;
			}
			EnsureHandler();
			if ((Object)(object)Handler == (Object)null)
			{
				return false;
			}
			List<DialogueContainer> dialogueContainers = Handler.dialogueContainers;
			if (dialogueContainers == null)
			{
				return false;
			}
			DialogueContainer val = null;
			for (int i = 0; i < dialogueContainers.Count; i++)
			{
				DialogueContainer val2 = dialogueContainers[i];
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == containerName)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			DialogueController controller = ((Component)Handler).GetComponent<DialogueController>();
			if ((Object)(object)controller == (Object)null)
			{
				return false;
			}
			controller.SetOverrideContainer(val);
			try
			{
				global::S1API.Utils.EventHelper.AddListener(ClearOnce, Handler.onConversationStart);
			}
			catch
			{
			}
			return true;
			void ClearOnce()
			{
				try
				{
					controller.ClearOverrideContainer();
				}
				catch
				{
				}
				try
				{
					global::S1API.Utils.EventHelper.RemoveListener(ClearOnce, Handler.onConversationStart);
				}
				catch
				{
				}
			}
		}

		public bool JumpTo(string containerName, string entryNodeLabel, bool enableBehaviour = false)
		{
			if (string.IsNullOrEmpty(containerName) || string.IsNullOrEmpty(entryNodeLabel))
			{
				return false;
			}
			EnsureHandler();
			if ((Object)(object)Handler == (Object)null)
			{
				return false;
			}
			List<DialogueContainer> dialogueContainers = Handler.dialogueContainers;
			if (dialogueContainers == null)
			{
				return false;
			}
			DialogueContainer val = null;
			for (int i = 0; i < dialogueContainers.Count; i++)
			{
				DialogueContainer val2 = dialogueContainers[i];
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == containerName)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return StartDialogueCompat(val, enableBehaviour, entryNodeLabel);
		}

		private void Internal_OnChoice(string choiceLabel)
		{
			if (string.IsNullOrEmpty(choiceLabel) || !_choiceCallbacks.TryGetValue(choiceLabel, out List<Action> value))
			{
				return;
			}
			for (int i = 0; i < value.Count; i++)
			{
				try
				{
					value[i]?.Invoke();
				}
				catch
				{
				}
			}
		}

		private void Internal_OnNode(string nodeLabel)
		{
			if (string.IsNullOrEmpty(nodeLabel) || !_nodeCallbacks.TryGetValue(nodeLabel, out List<Action> value))
			{
				return;
			}
			for (int i = 0; i < value.Count; i++)
			{
				try
				{
					value[i]?.Invoke();
				}
				catch
				{
				}
			}
		}

		private void Internal_OnConversationStart()
		{
			for (int i = 0; i < _conversationStartCallbacks.Count; i++)
			{
				try
				{
					_conversationStartCallbacks[i]?.Invoke();
				}
				catch
				{
				}
			}
		}

		private List<DialogueModule>? GetRuntimeModules()
		{
			return (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Handler, "RuntimeModules") as List<DialogueModule>) ?? (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(Handler, "runtimeModules") as List<DialogueModule>);
		}

		private bool StartDialogueCompat(string containerName, bool enableBehaviour = true, string entryNodeLabel = "ENTRY")
		{
			if ((Object)(object)Handler == (Object)null || string.IsNullOrEmpty(containerName))
			{
				return false;
			}
			Handler.StartDialogue(containerName, enableBehaviour, entryNodeLabel);
			return true;
		}

		private bool StartDialogueCompat(DialogueContainer container, bool enableBehaviour = true, string entryNodeLabel = "ENTRY")
		{
			if ((Object)(object)Handler == (Object)null || (Object)(object)container == (Object)null)
			{
				return false;
			}
			Handler.StartDialogue(container, enableBehaviour, entryNodeLabel);
			return true;
		}

		private static List<Entry> ToIl2CppEntryList(List<Entry> source)
		{
			List<Entry> val = new List<Entry>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
	public sealed class NPCInventory
	{
		private static readonly Log Logger = new Log("NPCInventory");

		private readonly NPC NPC;

		private NPCInventory Component => NPC.gameObject.GetComponent<NPCInventory>();

		internal NPCInventory(NPC npc)
		{
			NPC = npc;
		}

		public bool CanItemFit(string itemId, int quantity = 1)
		{
			if (string.IsNullOrEmpty(itemId) || quantity <= 0)
			{
				return false;
			}
			ItemInstance val = BuildTempItem(itemId, quantity);
			if (val == null)
			{
				return false;
			}
			return CanItemFitInternal(val);
		}

		public int GetCapacityForItem(string itemId, int quantity = 1)
		{
			if (string.IsNullOrEmpty(itemId) || quantity <= 0)
			{
				return 0;
			}
			ItemInstance val = BuildTempItem(itemId, quantity);
			if (val == null)
			{
				return 0;
			}
			return GetCapacityForItemInternal(val);
		}

		public bool TryInsert(string itemId, int quantity = 1, bool network = true)
		{
			if (string.IsNullOrEmpty(itemId) || quantity <= 0)
			{
				return false;
			}
			ItemInstance val = BuildTempItem(itemId, quantity);
			if (val == null)
			{
				return false;
			}
			if (!CanItemFitInternal(val))
			{
				return false;
			}
			InsertItemInternal(val, network);
			return true;
		}

		public void EnsureInitialized()
		{
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			string text = NPC?.ID ?? "<null>";
			NPCInventory inv = Component;
			if ((Object)(object)inv == (Object)null && NPC != null)
			{
				NPCInventory val = NPC.gameObject.GetComponent<NPCInventory>() ?? NPC.gameObject.AddComponent<NPCInventory>();
				inv = val;
			}
			if ((Object)(object)inv == (Object)null)
			{
				return;
			}
			if (inv.ItemSlots == null)
			{
				inv.ItemSlots = new List<ItemSlot>();
			}
			int count = inv.ItemSlots.Count;
			int slotCount = GetSlotCount(inv, count);
			if (count > slotCount)
			{
				for (int num = count - 1; num >= slotCount; num--)
				{
					ItemSlot val2 = inv.ItemSlots[num];
					if (val2 != null)
					{
						try
						{
							val2.ClearStoredInstance(true);
						}
						catch
						{
						}
					}
					inv.ItemSlots.RemoveAt(num);
				}
				count = inv.ItemSlots.Count;
			}
			Enumerator<ItemSlot> enumerator = inv.ItemSlots.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ItemSlot current = enumerator.Current;
				if (current != null)
				{
					try
					{
						global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(current, "ActiveLock", null);
					}
					catch
					{
					}
					try
					{
						global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(current, "IsAddLocked", false);
					}
					catch
					{
					}
				}
			}
			if (count < slotCount)
			{
				int num2 = slotCount - count;
				for (int i = 0; i < num2; i++)
				{
					ItemSlot val3 = new ItemSlot();
					Action action = delegate
					{
						try
						{
							TryInvokeContentsChanged(inv);
						}
						catch
						{
						}
					};
					val3.onItemDataChanged = (Action)Delegate.Combine((Delegate)(object)val3.onItemDataChanged, (Delegate)(object)Action.op_Implicit(action));
					val3.SetSlotOwner(((Il2CppObjectBase)inv).Cast<IItemSlotOwner>());
					try
					{
						global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(val3, "ActiveLock", null);
					}
					catch
					{
					}
					try
					{
						global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(val3, "IsAddLocked", false);
					}
					catch
					{
					}
				}
			}
			if ((Object)(object)GetPickpocketInteractable(inv) == (Object)null && NPC != null)
			{
				object? obj6 = NPC.GetType().GetMethod("GetPrimaryInteractable", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(NPC, null);
				InteractableObject val4 = (InteractableObject)((obj6 is InteractableObject) ? obj6 : null);
				Il2CppArrayBase<InteractableObject> componentsInChildren = NPC.gameObject.GetComponentsInChildren<InteractableObject>(true);
				InteractableObject val5 = null;
				for (int num3 = 0; num3 < componentsInChildren.Length; num3++)
				{
					if ((Object)(object)componentsInChildren[num3] != (Object)null && (Object)(object)componentsInChildren[num3] != (Object)(object)val4)
					{
						val5 = componentsInChildren[num3];
						break;
					}
				}
				if ((Object)(object)val5 == (Object)null)
				{
					val5 = NPC.gameObject.AddComponent<InteractableObject>();
				}
				SetPickpocketInteractable(inv, val5);
			}
			try
			{
				global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(inv, "npc", NPC?.S1NPC);
			}
			catch
			{
			}
			try
			{
				object? obj8 = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(inv, "onContentsChanged");
				UnityEvent val6 = (UnityEvent)((obj8 is UnityEvent) ? obj8 : null);
				if (val6 == null)
				{
					global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(inv, "onContentsChanged", (object?)new UnityEvent());
				}
			}
			catch
			{
			}
			try
			{
				((NetworkBehaviour)inv).NetworkInitializeIfDisabled();
			}
			catch (Exception ex)
			{
				Logger.Warning("[NPCInventory] EnsureInitialized: NetworkInitializeIfDisabled threw for '" + text + "': " + ex.Message);
			}
		}

		private static int GetSlotCount(NPCInventory inv, int fallback)
		{
			return (global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(inv, "SlotCount") is int num && num >= 0) ? num : fallback;
		}

		private static void TryInvokeContentsChanged(NPCInventory inv)
		{
			object? obj = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(inv, "onContentsChanged");
			UnityEvent val = (UnityEvent)((obj is UnityEvent) ? obj : null);
			if (val != null)
			{
				val.Invoke();
			}
		}

		private static InteractableObject? GetPickpocketInteractable(NPCInventory inv)
		{
			object? obj = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(inv, "PickpocketIntObj");
			return (InteractableObject?)((obj is InteractableObject) ? obj : null);
		}

		private static void SetPickpocketInteractable(NPCInventory inv, InteractableObject interactable)
		{
			global::S1API.Utils.ReflectionUtils.TrySetFieldOrProperty(inv, "PickpocketIntObj", interactable);
		}

		private ItemInstance? BuildTempItem(string itemId, int quantity)
		{
			try
			{
				ItemDefinition item = Registry.GetItem(itemId);
				if ((Object)(object)item == (Object)null)
				{
					return null;
				}
				ItemInstance defaultInstance = item.GetDefaultInstance(1);
				ItemInstance copy = defaultInstance.GetCopy(quantity);
				return copy ?? defaultInstance;
			}
			catch
			{
				return null;
			}
		}

		private bool CanItemFitInternal(ItemInstance item)
		{
			EnsureInitialized();
			NPCInventory component = Component;
			return (Object)(object)component != (Object)null && component.CanItemFit(item);
		}

		private int GetCapacityForItemInternal(ItemInstance item)
		{
			EnsureInitialized();
			NPCInventory component = Component;
			return ((Object)(object)component != (Object)null) ? component.GetCapacityForItem(item) : 0;
		}

		private void InsertItemInternal(ItemInstance item, bool network = true)
		{
			EnsureInitialized();
			NPCInventory component = Component;
			if (component != null)
			{
				component.InsertItem(item, network);
			}
		}
	}
	public sealed class NPCMessaging
	{
		private static readonly Log Logger = new Log("NPCMessaging");

		private readonly NPC _npc;

		private Action? _conversationOpenedHandlers;

		private MSGConversation? _subscribedConversation;

		private Action? _nativeConversationOpenedDispatcher;

		public bool IsRead
		{
			get
			{
				NPC s1NPC = _npc.S1NPC;
				bool? obj;
				if (s1NPC == null)
				{
					obj = null;
				}
				else
				{
					MSGConversation mSGConversation = s1NPC.MSGConversation;
					obj = ((mSGConversation != null) ? new bool?(mSGConversation.Read) : ((bool?)null));
				}
				return obj ?? true;
			}
		}

		public bool HasUnreadMessages => !IsRead;

		public bool IsOpen
		{
			get
			{
				NPC s1NPC = _npc.S1NPC;
				bool? obj;
				if (s1NPC == null)
				{
					obj = null;
				}
				else
				{
					MSGConversation mSGConversation = s1NPC.MSGConversation;
					obj = ((mSGConversation != null) ? new bool?(mSGConversation.isOpen) : ((bool?)null));
				}
				bool? flag = obj;
				return flag == true;
			}
		}

		public event Action OnConversationOpened
		{
			add
			{
				if (value != null)
				{
					_conversationOpenedHandlers = (Action)Delegate.Combine(_conversationOpenedHandlers, value);
					EnsureConversationHook();
				}
			}
			remove
			{
				if (value != null)
				{
					_conversationOpenedHandlers = (Action)Delegate.Remove(_conversationOpenedHandlers, value);
					if (_conversationOpenedHandlers == null)
					{
						RemoveConversationHook();
					}
				}
			}
		}

		internal NPCMessaging(NPC npc)
		{
			_npc = npc;
		}

		public void SendTextMessage(string message, Response[]? responses = null, float responseDelay = 1f, bool network = true)
		{
			_npc.SendTextMessage(message, responses, responseDelay, network);
		}

		internal void EnsureConversationHook()
		{
			if (_conversationOpenedHandlers != null)
			{
				NPC s1NPC = _npc.S1NPC;
				MSGConversation val = ((s1NPC != null) ? s1NPC.MSGConversation : null);
				if (val != null && val != _subscribedConversation)
				{
					RemoveConversationHook();
					Action orCreateNativeDispatcher = GetOrCreateNativeDispatcher();
					val.onConversationOpened = (((Delegate)(object)val.onConversationOpened == (Delegate)null) ? orCreateNativeDispatcher : ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)val.onConversationOpened, (Delegate)(object)orCreateNativeDispatcher)).Cast<Action>());
					_subscribedConversation = val;
				}
			}
		}

		internal void Cleanup()
		{
			RemoveConversationHook();
			_conversationOpenedHandlers = null;
			_nativeConversationOpenedDispatcher = null;
		}

		private Action GetOrCreateNativeDispatcher()
		{
			if ((Delegate)(object)_nativeConversationOpenedDispatcher != (Delegate)null)
			{
				return _nativeConversationOpenedDispatcher;
			}
			_nativeConversationOpenedDispatcher = DelegateSupport.ConvertDelegate<Action>((Delegate)new Action(DispatchConversationOpened)) ?? throw new InvalidOperationException("Could not create the native conversation-opened dispatcher.");
			return _nativeConversationOpenedDispatcher;
		}

		private void RemoveConversationHook()
		{
			if (_subscribedConversation == null || (Delegate)(object)_nativeConversationOpenedDispatcher == (Delegate)null)
			{
				_subscribedConversation = null;
				return;
			}
			Delegate val = Delegate.Remove((Delegate)(object)_subscribedConversation.onConversationOpened, (Delegate)(object)_nativeConversationOpenedDispatcher);
			_subscribedConversation.onConversationOpened = ((val != null) ? ((Il2CppObjectBase)val).Cast<Action>() : null);
			_subscribedConversation = null;
		}

		private void DispatchConversationOpened()
		{
			Action conversationOpenedHandlers = _conversationOpenedHandlers;
			if (conversationOpenedHandlers == null)
			{
				return;
			}
			Delegate[] invocationList = conversationOpenedHandlers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action = (Action)invocationList[i];
				try
				{
					action();
				}
				catch (Exception ex)
				{
					Logger.Warning("An NPCMessaging.OnConversationOpened subscriber failed: " + ex.Message);
				}
			}
		}
	}
	public class NPCMovement
	{
		private readonly NPC NPC;

		public Vector3 FootPosition => ((Object)(object)NPC.S1NPC.Movement != (Object)null) ? NPC.S1NPC.Movement.FootPosition : NPC.gameObject.transform.position;

		public Vector3 CurrentDestination => ((Object)(object)NPC.S1NPC.Movement != (Object)null) ? NPC.S1NPC.Movement.CurrentDestination : NPC.gameObject.transform.position;

		public bool IsMoving => (Object)(object)NPC.S1NPC.Movement != (Object)null && NPC.S1NPC.Movement.IsMoving;

		public float SpeedMultiplier
		{
			get
			{
				NPCSpeedController? speedController = SpeedController;
				return (speedController != null) ? speedController.SpeedMultiplier : 1f;
			}
			set
			{
				if ((Object)(object)SpeedController != (Object)null)
				{
					SpeedController.SpeedMultiplier = value;
				}
			}
		}

		public float DefaultWalkSpeed => ((Object)(object)SpeedController != (Object)null && global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(SpeedController, "DefaultWalkSpeed") is float num) ? num : 0.08f;

		private NPCSpeedController? SpeedController
		{
			get
			{
				NPCMovement movement = NPC.S1NPC.Movement;
				return (movement != null) ? movement.SpeedController : null;
			}
		}

		internal NPCMovement(NPC npc)
		{
			NPC = npc;
			((Behaviour)NPC.S1NPC.Movement).enabled = true;
		}

		public void SetDestination(Vector3 position)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NPC.S1NPC.Movement != (Object)null)
			{
				NPC.S1NPC.Movement.SetDestination(position);
			}
		}

		public void Warp(Vector3 position)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NPC.S1NPC.Movement != (Object)null)
			{
				NPC.S1NPC.Movement.Warp(position);
			}
			else
			{
				NPC.gameObject.transform.position = position;
			}
		}

		public void Stop()
		{
			if ((Object)(object)NPC.S1NPC.Movement != (Object)null)
			{
				NPC.S1NPC.Movement.Stop();
			}
		}

		public bool CanGetTo(Vector3 position)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return (Object)(object)NPC.S1NPC.Movement != (Object)null && NPC.S1NPC.Movement.CanGetTo(position, 1f);
		}

		public bool CanGetTo(Vector3 position, float within)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return (Object)(object)NPC.S1NPC.Movement != (Object)null && NPC.S1NPC.Movement.CanGetTo(position, within);
		}

		public void FaceDirection(Vector3 forward)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NPC.S1NPC.Movement != (Object)null)
			{
				NPC.S1NPC.Movement.FaceDirection(forward, 0.5f);
			}
		}

		public void FacePoint(Vector3 position)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)NPC.S1NPC.Movement != (Object)null)
			{
				NPC.S1NPC.Movement.FacePoint(position, 0.5f);
			}
		}

		public void AddSpeedControl(string id, int priority, float speed)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!((Object)(object)SpeedController == (Object)null))
			{
				SpeedControl val = new SpeedControl(id, priority, speed);
				SpeedController.AddSpeedControl(val);
			}
		}

		public void RemoveSpeedControl(string id)
		{
			NPCSpeedController? speedController = SpeedController;
			if (speedController != null)
			{
				speedController.RemoveSpeedControl(id);
			}
		}

		public bool DoesSpeedControlExist(string id)
		{
			NPCSpeedController? speedController = SpeedController;
			return speedController != null && speedController.DoesSpeedControlExist(id);
		}
	}
	public sealed class NPCPrefabBuilder
	{
		public sealed class AvatarDefaultsBuilder
		{
			internal readonly List<(string path, Color color)> FaceLayers = new List<(string, Color)>();

			internal readonly List<(string path, Color color)> BodyLayers = new List<(string, Color)>();

			internal readonly List<(string path, Color color)> AccessoryLayers = new List<(string, Color)>();

			public float Gender { get; set; } = 0f;

			public float Height { get; set; } = 1f;

			public float Weight { get; set; } = 0.5f;

			public Color32 SkinColor { get; set; } = new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue);

			public Color LeftEyeLidColor { get; set; } = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));

			public Color RightEyeLidColor { get; set; } = Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue));

			public Color EyeBallTint { get; set; } = Color.white;

			public string EyeballMaterialIdentifier { get; set; } = "Default";

			public float PupilDilation { get; set; } = 1f;

			public float EyebrowScale { get; set; } = 1f;

			public float EyebrowThickness { get; set; } = 1f;

			public float EyebrowRestingHeight { get; set; } = 0f;

			public float EyebrowRestingAngle { get; set; } = 0f;

			public (float topLidOpen, float bottomLidOpen) LeftEye { get; set; } = (topLidOpen: 0.5f, bottomLidOpen: 0.5f);

			public (float topLidOpen, float bottomLidOpen) RightEye { get; set; } = (topLidOpen: 0.5f, bottomLidOpen: 0.5f);

			public string HairPath { get; set; } = string.Empty;

			public Color HairColor { get; set; } = Color.black;

			internal AvatarImpostorSelection ImpostorSelection { get; private set; } = AvatarImpostorSelection.Preserve();

			public AvatarDefaultsBuilder WithFaceLayer(string path, Color color)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (!string.IsNullOrEmpty(path))
				{
					FaceLayers.Add((path, color));
				}
				return this;
			}

			public AvatarDefaultsBuilder WithFaceLayer<T>(string path, Color color) where T : BaseFaceAppearance
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return WithFaceLayer(path, color);
			}

			public AvatarDefaultsBuilder WithBodyLayer(string path, Color color)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (!string.IsNullOrEmpty(path))
				{
					BodyLayers.Add((path, color));
				}
				return this;
			}

			public AvatarDefaultsBuilder WithBodyLayer<T>(string path, Color color) where T : BaseBodyAppearance
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return WithBodyLayer(path, color);
			}

			public AvatarDefaultsBuilder WithAccessoryLayer(string path, Color color)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (!string.IsNullOrEmpty(path))
				{
					AccessoryLayers.Add((path, color));
				}
				return this;
			}

			public AvatarDefaultsBuilder WithAccessoryLayer<T>(string path, Color color) where T : BaseAccessoryAppearance
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				return WithAccessoryLayer(path, color);
			}

			public AvatarDefaultsBuilder WithImpostor(string name)
			{
				if (!string.IsNullOrWhiteSpace(name))
				{
					ImpostorSelection = AvatarImpostorSelection.FromName(name);
				}
				return this;
			}

			public AvatarDefaultsBuilder WithImpostor(AvatarImpostorDefinition impostor)
			{
				if (impostor != null)
				{
					ImpostorSelection = AvatarImpostorSelection.FromDefinition(impostor);
				}
				return this;
			}

			public AvatarDefaultsBuilder WithImpostorTexture(Texture2D texture)
			{
				if ((Object)(object)texture != (Object)null)
				{
					ImpostorSelection = AvatarImpostorSelection.FromTexture(texture);
				}
				return this;
			}

			public AvatarDefaultsBuilder WithRandomImpostor()
			{
				ImpostorSelection = AvatarImpostorSelection.Random(null, null);
				return this;
			}

			public AvatarDefaultsBuilder WithRandomImpostor(params string[] names)
			{
				ImpostorSelection = AvatarImpostorSelection.Random(CopyNames(names), null);
				return this;
			}

			public AvatarDefaultsBuilder WithRandomImpostor(int seed, params string[] names)
			{
				ImpostorSelection = AvatarImpostorSelection.Random(CopyNames(names), seed);
				return this;
			}

			private static IReadOnlyList<string>? CopyNames(IEnumerable<string>? names)
			{
				if (names == null)
				{
					return null;
				}
				List<string> list = new List<string>();
				foreach (string name in names)
				{
					if (!string.IsNullOrWhiteSpace(name))
					{
						list.Add(name);
					}
				}
				return (list.Count == 0) ? null : list;
			}
		}

		private static readonly Log Logger = new Log("NPCPrefabBuilder");

		private readonly GameObject prefabRoot;

		private readonly Type ownerType;

		internal NPCPrefabBuilder(GameObject prefabRoot, Type ownerType)
		{
			this.prefabRoot = prefabRoot;
			this.ownerType = ownerType;
		}

		private NPCScheduleManager EnsureScheduleManager()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			NPCScheduleManager componentInChildren = prefabRoot.GetComponentInChildren<NPCScheduleManager>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return componentInChildren;
			}
			GameObject val = new GameObject("NPCSchedule");
			val.transform.SetParent(prefabRoot.transform, false);
			return val.AddComponent<NPCScheduleManager>();
		}

		public NPCPrefabBuilder EnsureCustomer()
		{
			Customer component = prefabRoot.GetComponent<Customer>();
			if ((Object)(object)component == (Object)null)
			{
				component = prefabRoot.AddComponent<Customer>();
				((Behaviour)component).enabled = true;
			}
			NPC.RegisterCustomerType(ownerType);
			return this;
		}

		public NPCPrefabBuilder WithIdentity(string id, string firstName, string lastName)
		{
			try
			{
				NPCPrefabIdentity nPCPrefabIdentity = EnsureIdentityComponent();
				nPCPrefabIdentity.Id = id;
				nPCPrefabIdentity.FirstName = firstName;
				nPCPrefabIdentity.LastName = lastName;
				NPCDataAccess.ApplyIdentity(prefabRoot.GetComponent<NPC>(), id, firstName, lastName);
				nPCPrefabIdentity.RegisterToStaticCache(((Object)prefabRoot).name);
			}
			catch
			{
			}
			return this;
		}

		public NPCPrefabBuilder WithIcon(Sprite icon)
		{
			try
			{
				NPCPrefabIdentity nPCPrefabIdentity = EnsureIdentityComponent();
				nPCPrefabIdentity.Icon = icon;
				NPCDataAccess.ApplyIcon(prefabRoot.GetComponent<NPC>(), icon);
				nPCPrefabIdentity.RegisterToStaticCache(((Object)prefabRoot).name);
			}
			catch
			{
			}
			return this;
		}

		public NPCPrefabBuilder WithAppearanceDefaults(Action<AvatarDefaultsBuilder> configure)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Expected O, but got Unknown
			try
			{
				AvatarDefaultsBuilder avatarDefaultsBuilder = new AvatarDefaultsBuilder();
				configure(avatarDefaultsBuilder);
				AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
				((Object)val).hideFlags = (HideFlags)32;
				val.Gender = avatarDefaultsBuilder.Gender;
				val.Height = avatarDefaultsBuilder.Height;
				val.Weight = avatarDefaultsBuilder.Weight;
				val.SkinColor = Color32.op_Implicit(avatarDefaultsBuilder.SkinColor);
				val.LeftEyeLidColor = avatarDefaultsBuilder.LeftEyeLidColor;
				val.RightEyeLidColor = avatarDefaultsBuilder.RightEyeLidColor;
				val.EyeBallTint = avatarDefaultsBuilder.EyeBallTint;
				val.EyeballMaterialIdentifier = avatarDefaultsBuilder.EyeballMaterialIdentifier ?? string.Empty;
				val.PupilDilation = avatarDefaultsBuilder.PupilDilation;
				val.EyebrowScale = avatarDefaultsBuilder.EyebrowScale;
				val.EyebrowThickness = avatarDefaultsBuilder.EyebrowThickness;
				val.EyebrowRestingHeight = avatarDefaultsBuilder.EyebrowRestingHeight;
				val.EyebrowRestingAngle = avatarDefaultsBuilder.EyebrowRestingAngle;
				val.HairPath = avatarDefaultsBuilder.HairPath ?? string.Empty;
				val.HairColor = avatarDefaultsBuilder.HairColor;
				val.UseCombinedLayer = false;
				val.CombinedLayer = null;
				if ((avatarDefaultsBuilder.ImpostorSelection.Kind == AvatarImpostorSelectionKind.Texture || avatarDefaultsBuilder.ImpostorSelection.Kind == AvatarImpostorSelectionKind.Definition) && ImpostorTextureResolver.TryResolve(avatarDefaultsBuilder.ImpostorSelection, ownerType?.FullName ?? ((Object)prefabRoot).name, out Texture2D texture))
				{
					val.ImpostorTexture = texture;
				}
				val.LeftEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = avatarDefaultsBuilder.LeftEye.topLidOpen,
					bottomLidOpen = avatarDefaultsBuilder.LeftEye.bottomLidOpen
				};
				val.RightEyeRestingState = new EyeLidConfiguration
				{
					topLidOpen = avatarDefaultsBuilder.RightEye.topLidOpen,
					bottomLidOpen = avatarDefaultsBuilder.RightEye.bottomLidOpen
				};
				List<LayerSetting> source = new List<LayerSetting>();
				List<LayerSetting> source2 = new List<LayerSetting>();
				List<AccessorySetting> source3 = new List<AccessorySetting>();
				AvatarSettings val2 = val;
				if (val2.FaceLayerSettings == null)
				{
					List<LayerSetting> val3 = (val2.FaceLayerSettings = ToIl2CppList(source));
				}
				val2 = val;
				if (val2.BodyLayerSettings == null)
				{
					List<LayerSetting> val3 = (val2.BodyLayerSettings = ToIl2CppList(source2));
				}
				val2 = val;
				if (val2.AccessorySettings == null)
				{
					List<AccessorySetting> val6 = (val2.AccessorySettings = ToIl2CppList(source3));
				}
				foreach (var faceLayer in avatarDefaultsBuilder.FaceLayers)
				{
					List<LayerSetting> faceLayerSettings = val.FaceLayerSettings;
					LayerSetting val8 = new LayerSetting();
					(val8.layerPath, val8.layerTint) = faceLayer;
					faceLayerSettings.Add(val8);
				}
				foreach (var bodyLayer in avatarDefaultsBuilder.BodyLayers)
				{
					List<LayerSetting> bodyLayerSettings = val.BodyLayerSettings;
					LayerSetting val9 = new LayerSetting();
					(val9.layerPath, val9.layerTint) = bodyLayer;
					bodyLayerSettings.Add(val9);
				}
				foreach (var accessoryLayer in avatarDefaultsBuilder.AccessoryLayers)
				{
					List<AccessorySetting> accessorySettings = val.AccessorySettings;
					AccessorySetting val10 = new AccessorySetting();
					(val10.path, val10.color) = accessoryLayer;
					accessorySettings.Add(val10);
				}
				NPCPrefabIdentity nPCPrefabIdentity = EnsureIdentityComponent();
				nPCPrefabIdentity.AppearanceDefaults = val;
				nPCPrefabIdentity.AppearanceImpostorSelection = avatarDefaultsBuilder.ImpostorSelection;
				NPCDataAccess.ApplyAppearance(prefabRoot.GetComponent<NPC>(), val);
				nPCPrefabIdentity.RegisterToStaticCache(((Object)prefabRoot).name);
				ApplyAvatarSettingsToPrefab(val);
			}
			catch
			{
			}
			return this;
		}

		public NPCPrefabBuilder WithSchedule(Action<PrefabScheduleBuilder> configure)
		{
			try
			{
				PrefabScheduleBuilder prefabScheduleBuilder = new PrefabScheduleBuilder();
				configure(prefabScheduleBuilder);
				List<IScheduleActionSpec> specs = prefabScheduleBuilder.Build();
				return WithSchedule(specs);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to build schedule for NPC type " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
				return this;
			}
		}

		public NPCPrefabBuilder WithSchedule(IEnumerable<IScheduleActionSpec> specs)
		{
			try
			{
				List<IScheduleActionSpec> list = (specs as List<IScheduleActionSpec>) ?? new List<IScheduleActionSpec>(specs);
				if (list.Count == 0)
				{
					return this;
				}
				NPC.RegisterSchedulePlanForType(ownerType, list);
				PrecreateActionsForSpecs(list);
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to register schedule plan for NPC type " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
				Logger.Error("Stack trace: " + ex.StackTrace);
			}
			return this;
		}

		public NPCPrefabBuilder WithSchedule(params IScheduleActionSpec[] specs)
		{
			if (specs.Length == 0)
			{
				return this;
			}
			return WithSchedule((IEnumerable<IScheduleActionSpec>)specs);
		}

		public NPCPrefabBuilder EnsureDealer()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			NPC.RegisterDealerType(ownerType);
			NPCScheduleManager val = EnsureScheduleManager();
			NPCBehaviour val2 = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)val2 == (Object)null)
			{
				GameObject val3 = new GameObject("NPCBehaviour");
				val3.transform.SetParent(((Component)val).transform, false);
				val2 = val3.AddComponent<NPCBehaviour>();
			}
			DealerAttendDealBehaviour val4 = prefabRoot.GetComponentInChildren<DealerAttendDealBehaviour>(true);
			if ((Object)(object)val4 == (Object)null)
			{
				GameObject val5 = new GameObject("DealerAttendDealBehaviour");
				val5.transform.SetParent(((Component)val2).transform, false);
				val4 = val5.AddComponent<DealerAttendDealBehaviour>();
				val5.SetActive(false);
			}
			NPC component = prefabRoot.GetComponent<NPC>();
			SetBehaviourRefs((Behaviour)(object)val4, val2, component);
			NPCEvent_StayInBuilding componentInChildren = prefabRoot.GetComponentInChildren<NPCEvent_StayInBuilding>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				return this;
			}
			GameObject val6 = new GameObject("StayInBuilding");
			val6.transform.SetParent(((Component)val).transform, false);
			componentInChildren = val6.AddComponent<NPCEvent_StayInBuilding>();
			val6.SetActive(false);
			return this;
		}

		public NPCPrefabBuilder WithVoice(NPCVoiceDefinition voice)
		{
			return WithVoiceInternal(voice, null);
		}

		public NPCPrefabBuilder WithVoice(NPCVoiceDefinition voice, float pitch)
		{
			return WithVoiceInternal(voice, pitch);
		}

		public NPCPrefabBuilder WithVoice(string identifier)
		{
			return WithVoice(NPCVoiceCatalog.Get(identifier));
		}

		public NPCPrefabBuilder WithVoice(string identifier, float pitch)
		{
			return WithVoice(NPCVoiceCatalog.Get(identifier), pitch);
		}

		private NPCPrefabBuilder WithVoiceInternal(NPCVoiceDefinition voice, float? pitch)
		{
			if (voice == null)
			{
				throw new ArgumentNullException("voice");
			}
			if (pitch.HasValue && (float.IsNaN(pitch.Value) || float.IsInfinity(pitch.Value) || pitch.Value < 0.1f || pitch.Value > 4f))
			{
				throw new ArgumentOutOfRangeException("pitch", pitch, "NPC voice pitch must be between 0.1 and 4.0.");
			}
			NPC npc = prefabRoot.GetComponent<NPC>() ?? throw new InvalidOperationException("The custom NPC prefab has no NPC component.");
			VODatabase database = NPCVoiceResolver.Resolve(voice);
			if (!NPCDataAccess.ApplyVoice(npc, database, pitch))
			{
				throw new InvalidOperationException("Could not apply S1API voice '" + voice.Id + "' because the custom NPC has no framework data.");
			}
			NPCPrefabIdentity nPCPrefabIdentity = EnsureIdentityComponent();
			nPCPrefabIdentity.VoiceId = voice.Id;
			nPCPrefabIdentity.VoicePitch = pitch;
			nPCPrefabIdentity.RegisterToStaticCache(((Object)prefabRoot).name);
			return this;
		}

		public NPCPrefabBuilder EnsureSupplier()
		{
			NPC.RegisterSupplierType(ownerType);
			SupplierRuntimeCoordinator.EnsurePrefabInfrastructure(prefabRoot);
			return this;
		}

		public NPCPrefabBuilder WithCustomerDefaults(Action<CustomerDataBuilder> configure)
		{
			EnsureCustomer();
			Customer component = prefabRoot.GetComponent<Customer>();
			if ((Object)(object)component != (Object)null)
			{
				try
				{
					CustomerDataBuilder customerDataBuilder = new CustomerDataBuilder();
					configure(customerDataBuilder);
					CustomerData customerData = customerDataBuilder.BuildInternal();
					component.customerData = customerData;
				}
				catch
				{
				}
			}
			NPC.RegisterCustomerDefaultsForType(ownerType, configure);
			return this;
		}

		public NPCPrefabBuilder WithRelationshipDefaults(Action<NPCRelationshipDataBuilder> configure)
		{
			NPC.RegisterRelationshipDefaultsForType(ownerType, configure);
			try
			{
				NPCRelationshipDataBuilder nPCRelationshipDataBuilder = new NPCRelationshipDataBuilder();
				configure(nPCRelationshipDataBuilder);
				NPCPrefabIdentity.RegisterRelationshipDataToStaticCache(((Object)prefabRoot).name, nPCRelationshipDataBuilder);
			}
			catch (Exception ex)
			{
				Logger.Error("[Relationship Data] WithRelationshipDefaults: Exception registering relationship data for prefab '" + ((Object)prefabRoot).name + "': " + ex.Message);
			}
			return this;
		}

		public NPCPrefabBuilder WithSpawnPosition(Vector3 position, Quaternion rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			NPC.RegisterSpawnPositionForType(ownerType, position, rotation);
			return this;
		}

		public NPCPrefabBuilder WithSpawnPosition(Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return WithSpawnPosition(position, Quaternion.identity);
		}

		public NPCPrefabBuilder WithDealerDefaults(Action<DealerDataBuilder> configure)
		{
			EnsureDealer();
			NPC.RegisterDealerDefaultsForType(ownerType, configure);
			return this;
		}

		public NPCPrefabBuilder WithRegion(Region region)
		{
			try
			{
				NPC component = prefabRoot.GetComponent<NPC>();
				if ((Object)(object)component != (Object)null)
				{
					component.Region = (EMapRegion)region;
				}
			}
			catch
			{
			}
			return this;
		}

		public NPCPrefabBuilder WithSupplierDefaults(Action<SupplierDataBuilder> configure)
		{
			if (configure == null)
			{
				throw new ArgumentNullException("configure");
			}
			EnsureSupplier();
			NPC.RegisterSupplierDefaultsForType(ownerType, configure);
			return this;
		}

		public NPCPrefabBuilder EnsureSmokeBreak(string? cigarettePrefabPath = null, bool? debugMode = null)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EquippableData val = ResolveSmokeCigaretteData(cigarettePrefabPath);
				GameObject val2 = (((Object)(object)val == (Object)null) ? ResolveLegacySmokeCigarettePrefab(cigarettePrefabPath) : null);
				if ((Object)(object)val == (Object)null && (Object)(object)val2 == (Object)null)
				{
					Logger.Warning("EnsureSmokeBreak: Could not load cigarette equippable data or legacy prefab. Pass a Resources path to an EquippableData asset or TPEquippedItem prefab in your mod (for example EnsureSmokeBreak(\"equippables/cigarette/Cigarette\")).");
				}
				NPCScheduleManager val3 = EnsureScheduleManager();
				NPCBehaviour val4 = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
				if ((Object)(object)val4 == (Object)null)
				{
					GameObject val5 = new GameObject("NPCBehaviour");
					val5.transform.SetParent(((Component)val3).transform, false);
					val4 = val5.AddComponent<NPCBehaviour>();
				}
				SmokeBreakBehaviour val6 = ((Component)val4).GetComponentInChildren<SmokeBreakBehaviour>(true);
				if ((Object)(object)val6 == (Object)null)
				{
					GameObject val7 = new GameObject("SmokeBreakBehaviour");
					val7.transform.SetParent(((Component)val4).gameObject.transform, false);
					val6 = val7.AddComponent<SmokeBreakBehaviour>();
					val7.SetActive(false);
				}
				((Behaviour)val6).Name = "SmokeBreakBehaviour";
				SmokeCigarette val8 = ((Component)val6).GetComponentInChildren<SmokeCigarette>(true);
				if ((Object)(object)val8 == (Object)null)
				{
					GameObject val9 = new GameObject("SmokeCigarette");
					val9.transform.SetParent(((Component)val6).transform, false);
					val8 = val9.AddComponent<SmokeCigarette>();
				}
				NPC component = prefabRoot.GetComponent<NPC>();
				AvatarAnimation componentInChildren = prefabRoot.GetComponentInChildren<AvatarAnimation>(true);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "Npc", component);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "_npc", component);
				if ((Object)(object)val != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "_cigarette", val);
				}
				else if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "CigarettePrefab", val2);
				}
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "Anim", componentInChildren);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val6, "SmokeCigarette", val8);
				if (debugMode.HasValue)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val6, "_debugMode", debugMode.Value);
				}
				val6.MinMaxSmokeBreak = new Vector2Int(1, 2);
				if (val6.SmokeBreakLocations == null)
				{
					val6.SmokeBreakLocations = new List<Transform>();
				}
				if (val6.SmokeBreakLocations.Count == 0)
				{
					GameObject val10 = new GameObject("SmokeLocation_Default");
					val10.transform.SetParent(((Component)val6).transform, false);
					GameObject val11 = new GameObject("LookAtPoint");
					val11.transform.SetParent(val10.transform, false);
					val11.transform.localPosition = Vector3.forward;
					val6.SmokeBreakLocations.Add(val10.transform);
				}
				SetBehaviourRefs((Behaviour)(object)val6, val4, component);
			}
			catch (Exception ex)
			{
				Logger.Error("EnsureSmokeBreak failed for " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
			}
			return this;
		}

		private static EquippableData? ResolveSmokeCigaretteData(string? resourcePath)
		{
			if (!string.IsNullOrWhiteSpace(resourcePath))
			{
				EquippableData val = Resources.Load<EquippableData>(resourcePath);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
				TPEquippedItem val2 = Resources.Load<TPEquippedItem>(resourcePath);
				if ((Object)(object)val2 != (Object)null)
				{
					return CreateSmokeCigaretteData(val2);
				}
			}
			EquippableData val3 = Resources.Load<EquippableData>("equippables/cigarette/Cigarette");
			if ((Object)(object)val3 != (Object)null)
			{
				return val3;
			}
			TPEquippedItem val4 = Resources.Load<TPEquippedItem>("equippables/cigarette/cigarette_tp");
			if ((Object)(object)val4 != (Object)null)
			{
				return CreateSmokeCigaretteData(val4);
			}
			try
			{
				Il2CppArrayBase<SmokeCigarette> val5 = Object.FindObjectsOfType<SmokeCigarette>(true);
				if (val5 != null)
				{
					foreach (SmokeCigarette item in val5)
					{
						object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(item, "_cigarette");
						EquippableData val6 = (EquippableData)((obj is EquippableData) ? obj : null);
						if ((Object)(object)val6 != (Object)null)
						{
							return val6;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static EquippableData CreateSmokeCigaretteData(TPEquippedItem thirdPersonPrefab)
		{
			EquippableData val = ScriptableObject.CreateInstance<EquippableData>();
			((Object)val).name = "S1API_Cigarette";
			val.ThirdPersonEquippedItemPrefab = thirdPersonPrefab;
			return val;
		}

		private static GameObject? ResolveLegacySmokeCigarettePrefab(string? resourcePath)
		{
			GameObject val = null;
			if (!string.IsNullOrWhiteSpace(resourcePath))
			{
				val = Resources.Load<GameObject>(resourcePath);
			}
			if ((Object)(object)val == (Object)null)
			{
				val = Resources.Load<GameObject>("GameObject/Cigarette_Lit");
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			try
			{
				Il2CppArrayBase<SmokeCigarette> val2 = Object.FindObjectsOfType<SmokeCigarette>(true);
				if (val2 != null)
				{
					foreach (SmokeCigarette item in val2)
					{
						object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(item, "CigarettePrefab");
						GameObject val3 = (GameObject)((obj is GameObject) ? obj : null);
						if ((Object)(object)val3 != (Object)null)
						{
							return val3;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		public NPCPrefabBuilder EnsureGraffiti(string? sprayPaintEquippablePath = null)
		{
			return EnsureGraffitiInternal(sprayPaintEquippablePath);
		}

		public NPCPrefabBuilder EnsureGraffiti(EquippablePath sprayPaintEquippablePath)
		{
			return EnsureGraffitiInternal(string.IsNullOrEmpty(sprayPaintEquippablePath.ResourcePath) ? null : sprayPaintEquippablePath.ResourcePath);
		}

		private NPCPrefabBuilder EnsureGraffitiInternal(string? sprayPaintEquippablePath)
		{
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Expected O, but got Unknown
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				string text = sprayPaintEquippablePath ?? "Weapons/SprayPaint/SprayPaint_AvatarEquippable";
				GameObject val = Resources.Load<GameObject>(text);
				AvatarEquippable val2 = null;
				if ((Object)(object)val != (Object)null)
				{
					val2 = val.GetComponent<AvatarEquippable>() ?? val.GetComponentInChildren<AvatarEquippable>(true);
				}
				if ((Object)(object)val2 == (Object)null && !string.IsNullOrEmpty(sprayPaintEquippablePath))
				{
					val = Resources.Load<GameObject>(sprayPaintEquippablePath);
					if ((Object)(object)val != (Object)null)
					{
						val2 = val.GetComponent<AvatarEquippable>() ?? val.GetComponentInChildren<AvatarEquippable>(true);
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					try
					{
						Il2CppArrayBase<SprayPaint> val3 = Object.FindObjectsOfType<SprayPaint>(true);
						if (val3 != null)
						{
							foreach (SprayPaint item in val3)
							{
								object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(item, "_sprayPaintPrefab");
								if (obj == null || !CrossType.Is<AvatarEquippable>(obj, out AvatarEquippable result) || (Object)(object)result == (Object)null)
								{
									continue;
								}
								val2 = result;
								break;
							}
						}
					}
					catch
					{
					}
				}
				NPCBehaviour val4 = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
				if ((Object)(object)val4 == (Object)null)
				{
					GameObject val5 = new GameObject("NPCBehaviour");
					val5.transform.SetParent(((Component)EnsureScheduleManager()).transform, false);
					val4 = val5.AddComponent<NPCBehaviour>();
				}
				GraffitiBehaviour val6 = ((Component)val4).GetComponentInChildren<GraffitiBehaviour>(true);
				if ((Object)(object)val6 == (Object)null)
				{
					GameObject val7 = new GameObject("GraffitiBehaviour");
					val7.transform.SetParent(((Component)val4).gameObject.transform, false);
					val6 = val7.AddComponent<GraffitiBehaviour>();
					val7.SetActive(false);
				}
				((Behaviour)val6).Name = "GraffitiBehaviour";
				SprayPaint val8 = ((Component)val6).GetComponentInChildren<SprayPaint>(true);
				if ((Object)(object)val8 == (Object)null)
				{
					GameObject val9 = new GameObject("SprayPaint");
					val9.transform.SetParent(((Component)val6).transform, false);
					val8 = val9.AddComponent<SprayPaint>();
				}
				if ((Object)(object)val2 == (Object)null)
				{
					object obj3 = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(val8, "_sprayPaintPrefab");
					if (obj3 != null && CrossType.Is<AvatarEquippable>(obj3, out AvatarEquippable result2) && (Object)(object)result2 != (Object)null)
					{
						val2 = result2;
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Logger.Warning("EnsureGraffiti: Could not load spray paint equippable at '" + text + "'. Spray painting may not work. Supply a valid path or register via AvatarEquippableRegistry.");
				}
				NPC component = prefabRoot.GetComponent<NPC>();
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val6, "_sprayPaint", val8);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "_npc", component);
				if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val8, "_sprayPaintPrefab", val2);
				}
				SetBehaviourRefs((Behaviour)(object)val6, val4, component);
				Gradient val10 = new Gradient();
				val10.SetKeys(Il2CppStructArray<GradientColorKey>.op_Implicit((GradientColorKey[])(object)new GradientColorKey[3]
				{
					new GradientColorKey(Color.red, 0f),
					new GradientColorKey(Color.blue, 0.5f),
					new GradientColorKey(Color.green, 1f)
				}), Il2CppStructArray<GradientAlphaKey>.op_Implicit((GradientAlphaKey[])(object)new GradientAlphaKey[2]
				{
					new GradientAlphaKey(1f, 0f),
					new GradientAlphaKey(1f, 1f)
				}));
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val6, "_effectColorGradient", val10);
			}
			catch (Exception ex)
			{
				Logger.Error("EnsureGraffiti failed for " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
			}
			return this;
		}

		public NPCPrefabBuilder EnsureDrinking(string? drinkEquippablePath = null)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			try
			{
				string text = drinkEquippablePath ?? "Avatar/Equippables/Beer";
				GameObject val = Resources.Load<GameObject>(text);
				AvatarEquippable val2 = null;
				if ((Object)(object)val != (Object)null)
				{
					val2 = val.GetComponent<AvatarEquippable>() ?? val.GetComponentInChildren<AvatarEquippable>(true);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Logger.Warning("EnsureDrinking: Could not load drink equippable at '" + text + "'.");
				}
				NPCBehaviour val3 = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
				if ((Object)(object)val3 == (Object)null)
				{
					GameObject val4 = new GameObject("NPCBehaviour");
					val4.transform.SetParent(((Component)EnsureScheduleManager()).transform, false);
					val3 = val4.AddComponent<NPCBehaviour>();
				}
				DrinkItem val5 = ((Component)val3).GetComponentInChildren<DrinkItem>(true);
				if ((Object)(object)val5 == (Object)null)
				{
					GameObject val6 = new GameObject("DrinkItem");
					val6.transform.SetParent(((Component)val3).transform, false);
					val5 = val6.AddComponent<DrinkItem>();
				}
				NPC component = prefabRoot.GetComponent<NPC>();
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val5, "Npc", component);
				if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val5, "DrinkPrefab", val2);
				}
			}
			catch (Exception ex)
			{
				Logger.Error("EnsureDrinking failed for " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
			}
			return this;
		}

		public NPCPrefabBuilder EnsureDrinking(EquippablePath drinkEquippablePath)
		{
			return EnsureDrinking(string.IsNullOrEmpty(drinkEquippablePath.ResourcePath) ? null : drinkEquippablePath.ResourcePath);
		}

		public NPCPrefabBuilder EnsureItemHolding(string? equippablePath = null)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			try
			{
				string text = equippablePath ?? "Avatar/Equippables/Phone_Lowered";
				GameObject val = Resources.Load<GameObject>(text);
				AvatarEquippable val2 = null;
				if ((Object)(object)val != (Object)null)
				{
					val2 = val.GetComponent<AvatarEquippable>() ?? val.GetComponentInChildren<AvatarEquippable>(true);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Logger.Warning("EnsureItemHolding: Could not load equippable at '" + text + "'.");
				}
				NPCBehaviour val3 = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
				if ((Object)(object)val3 == (Object)null)
				{
					GameObject val4 = new GameObject("NPCBehaviour");
					val4.transform.SetParent(((Component)EnsureScheduleManager()).transform, false);
					val3 = val4.AddComponent<NPCBehaviour>();
				}
				HoldItem val5 = ((Component)val3).GetComponentInChildren<HoldItem>(true);
				if ((Object)(object)val5 == (Object)null)
				{
					GameObject val6 = new GameObject("HoldItem");
					val6.transform.SetParent(((Component)val3).transform, false);
					val5 = val6.AddComponent<HoldItem>();
				}
				NPC component = prefabRoot.GetComponent<NPC>();
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val5, "Npc", component);
				if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val5, "Equippable", val2);
				}
			}
			catch (Exception ex)
			{
				Logger.Error("EnsureItemHolding failed for " + (ownerType?.Name ?? "Unknown") + ": " + ex.Message);
			}
			return this;
		}

		public NPCPrefabBuilder EnsureItemHolding(EquippablePath equippablePath)
		{
			return EnsureItemHolding(string.IsNullOrEmpty(equippablePath.ResourcePath) ? null : equippablePath.ResourcePath);
		}

		public NPCPrefabBuilder WithInventoryDefaults(Action<RandomInventoryItemsBuilder> configure)
		{
			try
			{
				NPC.RegisterRandomInventoryDefaultsForType(ownerType, configure);
				NPCInventory component = prefabRoot.GetComponent<NPCInventory>();
				if ((Object)(object)component != (Object)null)
				{
					RandomInventoryItemsBuilder randomInventoryItemsBuilder = new RandomInventoryItemsBuilder();
					configure(randomInventoryItemsBuilder);
					RandomInventoryItemsBuilder.InventoryDefaultsData data = randomInventoryItemsBuilder.BuildInternal();
					ApplyInventoryDefaultsToComponent(component, data);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning(Object.op_Implicit("[S1API] Failed to register inventory defaults for " + ownerType.Name + ": " + ex.Message));
			}
			return this;
		}

		private void ApplyInventoryDefaultsToComponent(NPCInventory inventory, RandomInventoryItemsBuilder.InventoryDefaultsData data)
		{
			if ((Object)(object)inventory == (Object)null)
			{
				return;
			}
			try
			{
				if (data.RandomCashMin.HasValue || data.RandomCashMax.HasValue)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(inventory, "RandomCash", true);
					if (data.RandomCashMin.HasValue)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(inventory, "RandomCashMin", data.RandomCashMin.Value);
					}
					if (data.RandomCashMax.HasValue)
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(inventory, "RandomCashMax", data.RandomCashMax.Value);
					}
				}
				if (data.ClearInventoryEachNight.HasValue)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(inventory, "ClearInventoryEachNight", data.ClearInventoryEachNight.Value);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning(Object.op_Implicit("[S1API] Failed to apply inventory defaults to prefab: " + ex.Message));
			}
		}

		private void PrecreateActionsForSpecs(List<IScheduleActionSpec> specs)
		{
			if (specs.Count == 0)
			{
				return;
			}
			EnsureScheduleManager();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			bool flag4 = false;
			foreach (IScheduleActionSpec spec in specs)
			{
				IScheduleActionSpec scheduleActionSpec = spec;
				IScheduleActionSpec scheduleActionSpec2 = scheduleActionSpec;
				if (!(scheduleActionSpec2 is WalkToSpec))
				{
					if (!(scheduleActionSpec2 is StayInBuildingSpec))
					{
						if (!(scheduleActionSpec2 is LocationDialogueSpec))
						{
							if (!(scheduleActionSpec2 is LocationBasedActionSpec locationBasedActionSpec))
							{
								if (!(scheduleActionSpec2 is UseVendingMachineSpec))
								{
									if (!(scheduleActionSpec2 is DriveToCarParkSpec))
									{
										if (!(scheduleActionSpec2 is EnsureDealSignalSpec))
										{
											if (!(scheduleActionSpec2 is UseATMSpec))
											{
												if (scheduleActionSpec2 is SitSpec)
												{
													num9++;
												}
											}
											else
											{
												num8++;
											}
										}
										else
										{
											num7 = Math.Max(num7, 1);
										}
									}
									else
									{
										num6++;
									}
								}
								else
								{
									num5++;
								}
								continue;
							}
							num4++;
							switch (locationBasedActionSpec.ArriveBehaviour)
							{
							case LocationArriveBehaviour.SmokeBreak:
								flag = true;
								break;
							case LocationArriveBehaviour.Graffiti:
								flag2 = true;
								break;
							case LocationArriveBehaviour.Drinking:
								flag3 = true;
								break;
							case LocationArriveBehaviour.HoldItem:
								flag4 = true;
								break;
							}
						}
						else
						{
							num3++;
						}
					}
					else
					{
						num2++;
					}
				}
				else
				{
					num++;
				}
			}
			if (flag)
			{
				EnsureSmokeBreak();
			}
			if (flag2)
			{
				EnsureGraffiti();
			}
			if (flag3)
			{
				EnsureDrinking();
			}
			if (flag4)
			{
				EnsureItemHolding();
			}
			if (num7 > 0)
			{
				EnsureIl2CppCustomerAttendDealBehaviour();
			}
			EnsurePrefabAction<NPCSignal_WalkToLocation>(num, "WalkTo");
			EnsurePrefabAction<NPCEvent_StayInBuilding>(num2, "StayInBuilding");
			EnsurePrefabAction<NPCEvent_LocationDialogue>(num3, "LocationDialogue");
			EnsurePrefabAction<NPCEvent_LocationBasedAction>(num4, "LocationBasedAction");
			EnsurePrefabAction<NPCSignal_UseVendingMachine>(num5, "UseVending");
			EnsurePrefabAction<NPCSignal_DriveToCarPark>(num6, "DriveToCarPark");
			EnsurePrefabAction<NPCSignal_UseATM>(num8, "UseATM");
			EnsurePrefabAction<NPCEvent_Sit>(num9, "Sit");
		}

		private void EnsurePrefabAction<T>(int count, string namePrefix) where T : NPCAction
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			if (count <= 0)
			{
				return;
			}
			NPCScheduleManager val = EnsureScheduleManager();
			for (int i = 0; i < count; i++)
			{
				GameObject val2 = new GameObject(string.IsNullOrEmpty(namePrefix) ? typeof(T).Name : $"{namePrefix}_{i + 1}");
				val2.transform.SetParent(((Component)val).transform, false);
				T val3 = val2.AddComponent<T>();
				try
				{
					NPC component = prefabRoot.GetComponent<NPC>();
					typeof(T).GetField("npc", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val3, component);
					typeof(T).GetField("schedule", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val3, val);
				}
				catch (Exception ex)
				{
					Logger.Warning($"Failed to set npc/schedule fields on prefab action {typeof(T).Name} for NPC type {ownerType?.Name ?? "Unknown"}: {ex.Message}");
				}
				val2.SetActive(false);
				((Behaviour)(object)val3).enabled = false;
			}
		}

		private void EnsureIl2CppCustomerAttendDealBehaviour()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			NPCBehaviour componentInChildren = prefabRoot.GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Logger.Warning("Cannot add CustomerAttendDealBehaviour for NPC type " + (ownerType?.Name ?? "Unknown") + ": NPCBehaviour is missing.");
				return;
			}
			CustomerAttendDealBehaviour val = prefabRoot.GetComponentInChildren<CustomerAttendDealBehaviour>(true);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("Customer attend deal");
				val2.transform.SetParent(((Component)componentInChildren).transform, false);
				val = val2.AddComponent<CustomerAttendDealBehaviour>();
			}
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "EnabledOnAwake", false);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "Name", "Customer attend deal");
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "Priority", 4);
			((Behaviour)val).SetCanUseUmbrellaDuringBehaviour(true);
		}

		private void SetBehaviourRefs(Behaviour behaviour, NPCBehaviour npcBehaviour, NPC baseNpc)
		{
			if (!((Object)(object)behaviour == (Object)null) && !((Object)(object)npcBehaviour == (Object)null))
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(behaviour, "beh", npcBehaviour);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(npcBehaviour, "Npc", baseNpc);
			}
		}

		private NPCPrefabIdentity EnsureIdentityComponent()
		{
			NPCPrefabIdentity nPCPrefabIdentity = prefabRoot.GetComponent<NPCPrefabIdentity>();
			if ((Object)(object)nPCPrefabIdentity == (Object)null)
			{
				nPCPrefabIdentity = prefabRoot.AddComponent<NPCPrefabIdentity>();
			}
			return nPCPrefabIdentity;
		}

		private void ApplyAvatarSettingsToPrefab(AvatarSettings settings)
		{
			if ((Object)(object)settings == (Object)null)
			{
				return;
			}
			try
			{
				Avatar val = prefabRoot.GetComponent<Avatar>() ?? prefabRoot.GetComponentInChildren<Avatar>(true);
				if (!((Object)(object)val == (Object)null))
				{
					((Object)settings).hideFlags = (HideFlags)32;
					if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "InitialAvatarSettings", settings) && !global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "SettingsToLoad", settings))
					{
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "CurrentSettings", settings);
					}
				}
			}
			catch
			{
			}
		}

		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			foreach (T item in source)
			{
				val.Add(item);
			}
			return val;
		}
	}
	internal static class NPCPrefabContainer
	{
		private const string RootName = "@S1API_PersistentPrefabs";

		private static GameObject? _persistentRoot;

		public static GameObject GetOrCreatePrefabsContainer()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if ((Object)(object)_persistentRoot != (Object)null)
			{
				return _persistentRoot;
			}
			GameObject val = GameObject.Find("@S1API_PersistentPrefabs");
			if ((Object)(object)val != (Object)null)
			{
				_persistentRoot = val;
			}
			else
			{
				_persistentRoot = new GameObject("@S1API_PersistentPrefabs");
			}
			Object.DontDestroyOnLoad((Object)(object)_persistentRoot);
			return _persistentRoot;
		}

		public static GameObject? GetOrCreateNPCPrefabContainer(string npcTypeName)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			if (string.IsNullOrEmpty(npcTypeName))
			{
				return null;
			}
			GameObject orCreatePrefabsContainer = GetOrCreatePrefabsContainer();
			if ((Object)(object)orCreatePrefabsContainer == (Object)null)
			{
				return null;
			}
			Transform val = orCreatePrefabsContainer.transform.Find(npcTypeName);
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject(npcTypeName);
				val2.transform.SetParent(orCreatePrefabsContainer.transform, false);
				return val2;
			}
			return ((Component)val).gameObject;
		}

		public static GameObject? OrganizePrefab(GameObject prefab, string npcTypeName)
		{
			if ((Object)(object)prefab == (Object)null || string.IsNullOrEmpty(npcTypeName))
			{
				return null;
			}
			GameObject orCreateNPCPrefabContainer = GetOrCreateNPCPrefabContainer(npcTypeName);
			if ((Object)(object)orCreateNPCPrefabContainer != (Object)null)
			{
				prefab.transform.SetParent(orCreateNPCPrefabContainer.transform, false);
				prefab.SetActive(false);
			}
			return orCreateNPCPrefabContainer;
		}
	}
	public sealed class NPCRelationship
	{
		public enum UnlockType
		{
			Recommendation,
			DirectApproach
		}

		private static readonly Log Logger = new Log("NPCRelationship");

		internal readonly NPC NPC;

		private readonly Dictionary<Action<float>, Delegate> _relationshipChangedHandlers = new Dictionary<Action<float>, Delegate>();

		private Action<UnlockType, bool>? _relationshipUnlockedHandlers;

		private NPCRelationData? _subscribedRelationship;

		private Action<EUnlockType, bool>? _nativeRelationshipUnlockedDispatcher;

		private static readonly MemberInfo? RelationshipChangedMember = ResolveNativeEventMember("OnRelationshipChange", "onRelationshipChange");

		public float Delta
		{
			get
			{
				return (Component != null) ? Component.RelationDelta : 0f;
			}
			set
			{
				NPCRelationData? component = Component;
				if (component != null)
				{
					component.SetRelationship(value, true);
				}
			}
		}

		public float Normalized => (Component != null) ? Component.NormalizedRelationDelta : 0f;

		public bool IsUnlocked => Component != null && Component.Unlocked;

		public UnlockType Type
		{
			get
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				return (Component == null) ? UnlockType.DirectApproach : FromS1(Component.UnlockType);
			}
			set
			{
				SetUnlockType(value);
			}
		}

		public bool IsKnown => Component != null && Component.IsKnown();

		public bool IsMutuallyKnown => Component != null && Component.IsMutuallyKnown();

		public List<string> ConnectionIDs
		{
			get
			{
				List<string> list = new List<string>();
				NPCRelationData component = Component;
				if (component == null || component.Connections == null)
				{
					return list;
				}
				try
				{
					object connections = component.Connections;
					int listCount = GetListCount(connections);
					for (int i = 0; i < listCount; i++)
					{
						NPC listItem = GetListItem(connections, i);
						if ((Object)(object)listItem != (Object)null && listItem.ID != null)
						{
							list.Add(listItem.ID);
						}
					}
				}
				catch
				{
				}
				return list;
			}
		}

		internal NPCRelationData? Component
		{
			get
			{
				NPC nPC = NPC;
				object result;
				if (nPC == null)
				{
					result = null;
				}
				else
				{
					NPC s1NPC = nPC.S1NPC;
					result = ((s1NPC != null) ? s1NPC.RelationData : null);
				}
				return (NPCRelationData?)result;
			}
		}

		public event Action<float> OnChanged
		{
			add
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				if (value == null || Component == null || _relationshipChangedHandlers.ContainsKey(value))
				{
					return;
				}
				try
				{
					MemberInfo relationshipChangedMember = RelationshipChangedMember;
					if (relationshipChangedMember == null)
					{
						return;
					}
					object nativeEventValue = GetNativeEventValue(relationshipChangedMember, Component);
					Action<float> action = delegate(float d)
					{
						try
						{
							value(d);
						}
						catch
						{
						}
					};
					Delegate value2 = Delegate.Combine((Delegate)((nativeEventValue is Delegate) ? nativeEventValue : null), (Delegate)action);
					SetNativeEventValue(relationshipChangedMember, Component, value2);
					_relationshipChangedHandlers[value] = action;
				}
				catch
				{
				}
			}
			remove
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				if (value == null || Component == null || !_relationshipChangedHandlers.TryGetValue(value, out Delegate value2))
				{
					return;
				}
				_relationshipChangedHandlers.Remove(value);
				try
				{
					MemberInfo relationshipChangedMember = RelationshipChangedMember;
					if (!(relationshipChangedMember == null))
					{
						object nativeEventValue = GetNativeEventValue(relationshipChangedMember, Component);
						Delegate value3 = ((nativeEventValue != null) ? Delegate.Remove((Delegate)((nativeEventValue is Delegate) ? nativeEventValue : null), (Delegate)value2) : null);
						SetNativeEventValue(relationshipChangedMember, Component, value3);
					}
				}
				catch
				{
				}
			}
		}

		public event Action<UnlockType, bool> OnUnlocked
		{
			add
			{
				if (value != null && (_relationshipUnlockedHandlers == null || Array.IndexOf(_relationshipUnlockedHandlers.GetInvocationList(), value) < 0))
				{
					_relationshipUnlockedHandlers = (Action<UnlockType, bool>)Delegate.Combine(_relationshipUnlockedHandlers, value);
					EnsureUnlockedHook();
				}
			}
			remove
			{
				if (value != null)
				{
					_relationshipUnlockedHandlers = (Action<UnlockType, bool>)Delegate.Remove(_relationshipUnlockedHandlers, value);
					if (_relationshipUnlockedHandlers == null)
					{
						RemoveUnlockedHook();
					}
				}
			}
		}

		internal NPCRelationship(NPC npc)
		{
			NPC = npc;
		}

		public void Add(float delta, bool network = true)
		{
			NPCRelationData? component = Component;
			if (component != null)
			{
				component.ChangeRelationship(delta, network);
			}
		}

		public void Unlock(UnlockType type = UnlockType.DirectApproach, bool notify = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			NPCRelationData? component = Component;
			if (component != null)
			{
				component.Unlock(ToS1(type), notify);
			}
		}

		public void SetUnlockType(UnlockType type)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (Component == null)
			{
				return;
			}
			try
			{
				(typeof(NPCRelationData).GetProperty("UnlockType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetSetMethod(nonPublic: true))?.Invoke(Component, new object[1] { ToS1(type) });
			}
			catch
			{
			}
		}

		public void UnlockConnections()
		{
			NPCRelationData? component = Component;
			if (component != null)
			{
				component.UnlockConnections();
			}
		}

		internal void EnsureUnlockedHook()
		{
			if (_relationshipUnlockedHandlers == null)
			{
				return;
			}
			NPCRelationData component = Component;
			if (component == null || component == _subscribedRelationship)
			{
				return;
			}
			try
			{
				RemoveUnlockedHook();
				Action<EUnlockType, bool> orCreateNativeUnlockedDispatcher = GetOrCreateNativeUnlockedDispatcher();
				component.OnUnlocked = (((Delegate)(object)component.OnUnlocked == (Delegate)null) ? orCreateNativeUnlockedDispatcher : ((Il2CppObjectBase)Delegate.Combine((Delegate)(object)component.OnUnlocked, (Delegate)(object)orCreateNativeUnlockedDispatcher)).Cast<Action<EUnlockType, bool>>());
				_subscribedRelationship = component;
			}
			catch (Exception value)
			{
				Logger.Warning($"Could not attach the native relationship-unlocked hook: {value}");
			}
		}

		private Action<EUnlockType, bool> GetOrCreateNativeUnlockedDispatcher()
		{
			if ((Delegate)(object)_nativeRelationshipUnlockedDispatcher != (Delegate)null)
			{
				return _nativeRelationshipUnlockedDispatcher;
			}
			_nativeRelationshipUnlockedDispatcher = DelegateSupport.ConvertDelegate<Action<EUnlockType, bool>>((Delegate)new Action<EUnlockType, bool>(DispatchUnlocked)) ?? throw new InvalidOperationException("Could not create the native relationship-unlocked dispatcher.");
			return _nativeRelationshipUnlockedDispatcher;
		}

		private void RemoveUnlockedHook()
		{
			if (_subscribedRelationship == null || (Delegate)(object)_nativeRelationshipUnlockedDispatcher == (Delegate)null)
			{
				_subscribedRelationship = null;
				return;
			}
			try
			{
				Delegate val = Delegate.Remove((Delegate)(object)_subscribedRelationship.OnUnlocked, (Delegate)(object)_nativeRelationshipUnlockedDispatcher);
				_subscribedRelationship.OnUnlocked = ((val != null) ? ((Il2CppObjectBase)val).Cast<Action<EUnlockType, bool>>() : null);
			}
			catch (Exception value)
			{
				Logger.Warning($"Could not remove the native relationship-unlocked hook: {value}");
			}
			finally
			{
				_subscribedRelationship = null;
			}
		}

		private void DispatchUnlocked(EUnlockType type, bool notify)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Action<UnlockType, bool> relationshipUnlockedHandlers = _relationshipUnlockedHandlers;
			if (relationshipUnlockedHandlers == null)
			{
				return;
			}
			Delegate[] invocationList = relationshipUnlockedHandlers.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<UnlockType, bool> action = (Action<UnlockType, bool>)invocationList[i];
				try
				{
					action(FromS1(type), notify);
				}
				catch (Exception value)
				{
					Logger.Warning($"NPCRelationship.OnUnlocked subscriber '{action.Method.DeclaringType?.FullName}.{action.Method.Name}' failed: {value}");
				}
			}
		}

		internal static MemberInfo? ResolveNativeEventMember(string canonicalName, string legacyName)
		{
			return ResolveNativeEventMember(typeof(NPCRelationData), canonicalName, legacyName);
		}

		internal static MemberInfo? ResolveNativeEventMember(Type relationType, string canonicalName, string legacyName)
		{
			return (MemberInfo?)(relationType.GetField(canonicalName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? relationType.GetProperty(canonicalName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) ?? ((object)relationType.GetField(legacyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) ?? ((object)relationType.GetProperty(legacyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)));
		}

		private static object? GetNativeEventValue(MemberInfo member, object target)
		{
			return (member is FieldInfo fieldInfo) ? fieldInfo.GetValue(target) : ((PropertyInfo)member).GetValue(target);
		}

		private static void SetNativeEventValue(MemberInfo member, object target, object? value)
		{
			if (member is FieldInfo fieldInfo)
			{
				fieldInfo.SetValue(target, value);
			}
			else
			{
				((PropertyInfo)member).SetValue(target, value);
			}
		}

		private static UnlockType FromS1(EUnlockType t)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ((int)t != 0) ? UnlockType.DirectApproach : UnlockType.Recommendation;
		}

		private static EUnlockType ToS1(UnlockType t)
		{
			return (EUnlockType)((t != UnlockType.Recommendation) ? 1 : 0);
		}

		private static int GetListCount(object listObj)
		{
			if (listObj == null)
			{
				return 0;
			}
			PropertyInfo property = listObj.GetType().GetProperty("Count", BindingFlags.Instance | BindingFlags.Public);
			return (property != null) ? Convert.ToInt32(property.GetValue(listObj)) : 0;
		}

		private static NPC? GetListItem(object? listObj, int index)
		{
			if (listObj == null)
			{
				return null;
			}
			object? obj = listObj.GetType().GetProperty("Item", BindingFlags.Instance | BindingFlags.Public)?.GetValue(listObj, new object[1] { index });
			return (NPC?)((obj is NPC) ? obj : null);
		}
	}
	public sealed class NPCSchedule
	{
		internal readonly NPC NPC;

		private static bool _loggedRemovedDealSignal;

		public bool IsEnabled => (Object)(object)Manager != (Object)null && Manager.ScheduleEnabled;

		public bool CurfewModeEnabled => (Object)(object)Manager != (Object)null && Manager.CurfewModeEnabled;

		internal NPCScheduleManager? Manager => NPC.gameObject.GetComponentInChildren<NPCScheduleManager>(true);

		internal NPC Owner => NPC;

		internal NPCSchedule(NPC npc)
		{
			NPC = npc;
		}

		public void Enable()
		{
			EnsureManager();
			NPCScheduleManager? manager = Manager;
			if (manager != null)
			{
				manager.EnableSchedule();
			}
		}

		public void Disable()
		{
			NPCScheduleManager? manager = Manager;
			if (manager != null)
			{
				manager.DisableSchedule();
			}
		}

		internal void InitializeActions()
		{
			EnsureManager();
			NPCScheduleManager? manager = Manager;
			if (manager != null)
			{
				manager.InitializeActions();
			}
		}

		public void EnforceState()
		{
			NPCScheduleManager? manager = Manager;
			if (manager != null)
			{
				manager.EnforceState();
			}
		}

		public void SetCurfewMode(bool enabled)
		{
			if (!((Object)(object)Manager == (Object)null))
			{
				Manager.SetCurfewModeEnabled(enabled);
			}
		}

		public string GetActiveActionName()
		{
			return ((Object)(object)Manager != (Object)null && (Object)(object)Manager.ActiveAction != (Object)null) ? ((Object)Manager.ActiveAction).name : string.Empty;
		}

		internal T? AddActionInternal<T>(int startTime, string? name = null) where T : NPCAction
		{
			EnsureManager();
			if ((Object)(object)Manager == (Object)null)
			{
				return default(T);
			}
			Il2CppArrayBase<T> componentsInChildren = ((Component)Manager).GetComponentsInChildren<T>(true);
			T val = default(T);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				T val2 = componentsInChildren[i];
				if (!((Object)(object)val2 == (Object)null) && !((Component)(object)val2).gameObject.activeSelf)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				if (componentsInChildren.Length <= 0)
				{
					Debug.LogWarning(Object.op_Implicit("[S1API] No available pre-created actions of type " + typeof(T).Name + ". Add more via NPC.ConfigurePrefab."));
					return default(T);
				}
				val = componentsInChildren[0];
			}
			if ((Object)(object)val == (Object)null)
			{
				return default(T);
			}
			if (!string.IsNullOrEmpty(name))
			{
				((Object)((Component)(object)val).gameObject).name = name;
			}
			((NPCAction)val).SetStartTime(startTime);
			if (!((Component)(object)val).gameObject.activeSelf)
			{
				((Component)(object)val).gameObject.SetActive(true);
			}
			((Behaviour)(object)val).enabled = true;
			return val;
		}

		internal void AddActionFromSpec(IScheduleActionSpec spec)
		{
			spec?.ApplyTo(this);
		}

		[Obsolete("NPCSignal_WaitForDelivery was removed in game version 0.4.6. Customer deal attendance is configured automatically by EnsureCustomer().")]
		public void EnsureDealSignal()
		{
			if (!_loggedRemovedDealSignal)
			{
				_loggedRemovedDealSignal = true;
				Debug.LogWarning(Object.op_Implicit("[S1API] EnsureDealSignal is obsolete in Schedule I 0.4.6. Customer deal attendance is configured automatically; this call is now a compatibility no-op."));
			}
		}

		public void ClearActions(bool includeSignals = true, bool includeEvents = true)
		{
			if ((Object)(object)Manager == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<NPCAction> componentsInChildren = ((Component)Manager).GetComponentsInChildren<NPCAction>(true);
			foreach (NPCAction item in componentsInChildren)
			{
				bool flag = item is NPCSignal;
				bool flag2 = item is NPCEvent;
				if (((flag && includeSignals) || (flag2 && includeEvents)) && (Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null)
				{
					((Component)item).gameObject.SetActive(false);
					((Behaviour)item).enabled = false;
					try
					{
						item.SetStartTime(0);
					}
					catch
					{
					}
				}
			}
			Manager.InitializeActions();
		}

		public IReadOnlyList<string> GetActionNames()
		{
			if ((Object)(object)Manager == (Object)null)
			{
				return Array.Empty<string>();
			}
			Il2CppArrayBase<NPCAction> componentsInChildren = ((Component)Manager).GetComponentsInChildren<NPCAction>(true);
			List<string> list = new List<string>(componentsInChildren.Length);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				list.Add(((Object)(object)componentsInChildren[i] != (Object)null) ? ((Object)componentsInChildren[i]).name : string.Empty);
			}
			return list;
		}

		internal void EnsureManager()
		{
			NPCScheduleManager componentInChildren = NPC.gameObject.GetComponentInChildren<NPCScheduleManager>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Debug.LogWarning(Object.op_Implicit("[S1API] NPCScheduleManager is missing. Ensure it is added in NPC.ConfigurePrefab."));
			}
		}
	}
	public enum SupplierStatus
	{
		Idle,
		PreparingDeadDrop,
		Meeting
	}
	public sealed class NPCSupplier
	{
		private static readonly Log Logger = new Log("NPCSupplier");

		private readonly NPC npc;

		private Action? deadDropReadyHandlers;

		private Supplier? subscribedSupplier;

		private Action? nativeDeadDropReadyDispatcher;

		internal Supplier? Component
		{
			get
			{
				if (CrossType.Is<Supplier>((object)npc.S1NPC, out Supplier result))
				{
					return result;
				}
				return ((Object)(object)npc.gameObject != (Object)null) ? npc.gameObject.GetComponent<Supplier>() : null;
			}
		}

		public bool IsSupplier => (Object)(object)Component != (Object)null;

		public SupplierStatus Status => (!((Object)(object)Component == (Object)null)) ? ((SupplierStatus)Component.Status) : SupplierStatus.Idle;

		public bool DeliveriesEnabled
		{
			get
			{
				Supplier? component = Component;
				return component != null && component.DeliveriesEnabled;
			}
		}

		public float Debt
		{
			get
			{
				Supplier? component = Component;
				return (component != null) ? component.Debt : 0f;
			}
		}

		public int MinutesUntilDeadDropReady
		{
			get
			{
				Supplier? component = Component;
				return (component != null) ? component.MinsUntilDeaddropReady : (-1);
			}
		}

		public float DeadDropLimit
		{
			get
			{
				Supplier? component = Component;
				return (component != null) ? component.GetDeadDropLimit() : 0f;
			}
		}

		public Shop? Shop
		{
			get
			{
				Supplier component = Component;
				return ((Object)(object)((component != null) ? component.Shop : null) == (Object)null) ? null : new Shop(component.Shop);
			}
		}

		public StorageInstance? Stash
		{
			get
			{
				Supplier component = Component;
				object obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					SupplierStash stash = component.Stash;
					obj = ((stash != null) ? stash.Storage : null);
				}
				return ((Object)obj == (Object)null) ? null : new StorageInstance(component.Stash.Storage);
			}
		}

		public IReadOnlyList<Delivery> ActiveDeliveries
		{
			get
			{
				Shop shop = Shop;
				IReadOnlyList<Delivery> result;
				if (shop != null)
				{
					result = DeliveryRegistry.GetForShop(shop);
				}
				else
				{
					IReadOnlyList<Delivery> readOnlyList = Array.Empty<Delivery>();
					result = readOnlyList;
				}
				return result;
			}
		}

		public event Action OnDeadDropReady
		{
			add
			{
				if (value != null)
				{
					deadDropReadyHandlers = (Action)Delegate.Combine(deadDropReadyHandlers, value);
					EnsureDeadDropReadyDispatcher();
				}
			}
			remove
			{
				deadDropReadyHandlers = (Action)Delegate.Remove(deadDropReadyHandlers, value);
				if (deadDropReadyHandlers == null && (Object)(object)subscribedSupplier != (Object)null)
				{
					if ((Delegate)(object)nativeDeadDropReadyDispatcher != (Delegate)null)
					{
						Supplier? obj = subscribedSupplier;
						obj.OnDeaddropReady -= nativeDeadDropReadyDispatcher;
					}
					subscribedSupplier = null;
				}
			}
		}

		internal NPCSupplier(NPC npc)
		{
			this.npc = npc ?? throw new ArgumentNullException("npc");
		}

		internal void EnsureSupplier()
		{
			if ((Object)(object)Component == (Object)null)
			{
				Logger.Warning("Supplier root not present for NPC '" + npc.ID + "'. Configure it with NPCPrefabBuilder.EnsureSupplier().");
				return;
			}
			npc.SetConversationCategory((EConversationCategory)1, ensureUi: false);
			npc.EnsureMessageConversationReady(resetDefaults: false);
			EnsureDeadDropReadyDispatcher();
		}

		public void Unlock()
		{
			Supplier component = Component;
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException("The wrapped NPC is not a supplier.");
			}
			component.SendUnlocked();
		}

		public void EndMeeting()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			Supplier component = Component;
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException("The wrapped NPC is not a supplier.");
			}
			if (!((NetworkBehaviour)component).IsServerInitialized)
			{
				throw new InvalidOperationException("Supplier meetings can only be ended by the server or host.");
			}
			if ((int)component.Status == 2)
			{
				component.EndMeeting();
			}
		}

		private void EnsureDeadDropReadyDispatcher()
		{
			Supplier component = Component;
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component == (Object)(object)subscribedSupplier))
			{
				Action orCreateNativeDeadDropReadyDispatcher = GetOrCreateNativeDeadDropReadyDispatcher();
				if ((Object)(object)subscribedSupplier != (Object)null)
				{
					Supplier? obj = subscribedSupplier;
					obj.OnDeaddropReady -= orCreateNativeDeadDropReadyDispatcher;
				}
				subscribedSupplier = component;
				Supplier? obj2 = subscribedSupplier;
				obj2.OnDeaddropReady += orCreateNativeDeadDropReadyDispatcher;
			}
		}

		private Action GetOrCreateNativeDeadDropReadyDispatcher()
		{
			if ((Delegate)(object)nativeDeadDropReadyDispatcher != (Delegate)null)
			{
				return nativeDeadDropReadyDispatcher;
			}
			return nativeDeadDropReadyDispatcher = DelegateSupport.ConvertDelegate<Action>((Delegate)new Action(DispatchDeadDropReady)) ?? throw new InvalidOperationException("Could not create the native dead-drop event dispatcher.");
		}

		private void DispatchDeadDropReady()
		{
			Action action = deadDropReadyHandlers;
			if (action == null)
			{
				return;
			}
			Delegate[] invocationList = action.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action action2 = (Action)invocationList[i];
				try
				{
					action2();
				}
				catch (Exception ex)
				{
					Logger.Warning("An NPCSupplier.OnDeadDropReady subscriber failed: " + ex.Message);
				}
			}
		}
	}
	public class Player : IEntity, IHealth
	{
		private const float InvincibleHealth = 1E+09f;

		private const float MortalHealth = 100f;

		public static readonly List<Player> All = new List<Player>();

		internal Player S1Player;

		private static readonly HashSet<Player> InvinciblePlayers = new HashSet<Player>();

		public static Player Local => All.FirstOrDefault((Player player) => player.IsLocal);

		public bool IsLocal => S1Player.IsLocalPlayer;

		public string Name => S1Player.PlayerName;

		GameObject IEntity.gameObject => ((Component)S1Player).gameObject;

		public Vector3 Position
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return ((IEntity)this).gameObject.transform.position;
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((IEntity)this).gameObject.transform.position = value;
			}
		}

		public Transform Transform => ((IEntity)this).gameObject.transform;

		public float Scale
		{
			get
			{
				return S1Player.Scale;
			}
			set
			{
				S1Player.SetScale(value);
			}
		}

		public PlayerCrimeData CrimeData => new PlayerCrimeData(S1Player.CrimeData);

		public float CurrentHealth => S1Player.Health.CurrentHealth;

		public float MaxHealth
		{
			get
			{
				return 100f;
			}
			set
			{
				S1Player.Health.SetHealth(value);
			}
		}

		public bool IsDead => !S1Player.Health.IsAlive;

		public bool IsInvincible
		{
			get
			{
				return InvinciblePlayers.Contains(S1Player);
			}
			set
			{
				if (value)
				{
					InvinciblePlayers.Add(S1Player);
				}
				else
				{
					InvinciblePlayers.Remove(S1Player);
				}
			}
		}

		public LandVehicle? LastDrivenVehicle
		{
			get
			{
				if ((Object)(object)S1Player.LastDrivenVehicle == (Object)null)
				{
					return null;
				}
				LandVehicle[] all = VehicleRegistry.GetAll();
				foreach (LandVehicle landVehicle in all)
				{
					if ((Object)(object)landVehicle.S1LandVehicle == (Object)(object)S1Player.LastDrivenVehicle)
					{
						return landVehicle;
					}
				}
				return null;
			}
		}

		public bool IsInVehicle => S1Player.IsInVehicle;

		public float TimeSinceVehicleExit => S1Player.TimeSinceVehicleExit;

		public bool Crouched => S1Player.Crouched;

		public bool IsReadyToSleep => S1Player.IsReadyToSleep;

		public bool IsSkating => S1Player.IsSkating;

		public bool IsSleeping => S1Player.IsSleeping;

		public bool IsRagdolled => S1Player.IsRagdolled;

		public bool IsArrested => S1Player.IsArrested;

		public bool IsTased => S1Player.IsTased;

		public bool IsUnconscious => S1Player.IsUnconscious;

		public PropertyWrapper? CurrentProperty
		{
			get
			{
				if ((Object)(object)S1Player.CurrentProperty == (Object)null)
				{
					return null;
				}
				foreach (PropertyWrapper allProperty in PropertyManager.GetAllProperties())
				{
					if ((Object)(object)allProperty.InnerProperty == (Object)(object)S1Player.CurrentProperty)
					{
						return allProperty;
					}
				}
				return null;
			}
		}

		public PropertyWrapper? LastVisitedProperty
		{
			get
			{
				Property lastVisitedProperty = S1Player.LastVisitedProperty;
				if ((Object)(object)lastVisitedProperty == (Object)null)
				{
					return null;
				}
				foreach (PropertyWrapper allProperty in PropertyManager.GetAllProperties())
				{
					if ((Object)(object)allProperty.InnerProperty == (Object)(object)lastVisitedProperty)
					{
						return allProperty;
					}
				}
				return null;
			}
		}

		public Region CurrentRegion => (Region)S1Player.CurrentRegion;

		[Obsolete("Use GetCurrentBasicAvatarSettings(). This compatibility property may be removed in a future S1API version.")]
		public object CurrentAvatarSettings => S1Player.CurrentBasicAppearance;

		public static event Action<Player>? PlayerSpawned;

		public static event Action<Player>? LocalPlayerSpawned;

		public static event Action<Player>? PlayerDespawned;

		public event Action OnDeath
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1Player.Health.onDie);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1Player.Health.onDie);
			}
		}

		public event Action OnRevive
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1Player.Health.onRevive);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1Player.Health.onRevive);
			}
		}

		internal Player(Player player)
		{
			S1Player = player;
			All.Add(this);
		}

		public BasicAvatarSettings? GetCurrentBasicAvatarSettings()
		{
			BasicAvatarSettings currentBasicAppearance = S1Player.CurrentBasicAppearance;
			return ((Object)(object)currentBasicAppearance == (Object)null) ? null : new BasicAvatarSettings(currentBasicAppearance);
		}

		public void InsertClothing(global::S1API.Items.ClothingItemInstance clothing)
		{
			if (clothing == null)
			{
				throw new ArgumentNullException("clothing");
			}
			S1Player.Clothing.InsertClothing(clothing.S1ClothingInstance);
		}

		public global::S1API.Items.ClothingItemInstance EquipClothing(global::S1API.Items.ClothingItemDefinition definition)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			global::S1API.Items.ClothingItemInstance clothingItemInstance = definition.CreateInstance(definition.DefaultColor);
			InsertClothing(clothingItemInstance);
			return clothingItemInstance;
		}

		public void RefreshClothingAppearance()
		{
			S1Player.Clothing.RefreshAppearance();
		}

		public void SendAppearance(BasicAvatarSettings settings)
		{
			if (settings == null)
			{
				throw new ArgumentNullException("settings");
			}
			S1Player.SetAppearance_Server(settings.S1BasicAvatarSettings);
		}

		public void Revive()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			S1Player.Health.Revive(Position, Quaternion.identity);
		}

		public void Damage(int amount)
		{
			if (amount > 0)
			{
				S1Player.Health.TakeDamage((float)amount, true, true);
			}
		}

		public void Heal(int amount)
		{
			if (amount > 0)
			{
				S1Player.Health.SetHealth(CurrentHealth + (float)amount);
			}
		}

		public void Kill()
		{
			S1Player.Health.SetHealth(0f);
		}

		internal static bool IsPlayerInvincible(Player player)
		{
			return InvinciblePlayers.Contains(player);
		}

		internal static void RaisePlayerSpawned(Player player)
		{
			Player.PlayerSpawned?.Invoke(player);
		}

		internal static void RaiseLocalPlayerSpawned(Player player)
		{
			Player.LocalPlayerSpawned?.Invoke(player);
		}

		internal static void RaisePlayerDespawned(Player player)
		{
			Player.PlayerDespawned?.Invoke(player);
		}
	}
	public sealed class RandomInventoryItemsBuilder
	{
		internal sealed class InventoryDefaultsData
		{
			public List<string> StartupItems { get; set; } = new List<string>();

			public int? RandomCashMin { get; set; }

			public int? RandomCashMax { get; set; }

			public bool? ClearInventoryEachNight { get; set; }
		}

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

		private int? _randomCashMin;

		private int? _randomCashMax;

		private bool? _clearInventoryEachNight;

		internal RandomInventoryItemsBuilder()
		{
		}

		public RandomInventoryItemsBuilder WithRandomCash(int min, int max)
		{
			_randomCashMin = Mathf.Max(0, Mathf.Min(min, max));
			_randomCashMax = Mathf.Max(0, Mathf.Max(min, max));
			return this;
		}

		public RandomInventoryItemsBuilder WithStartupItem(string itemId)
		{
			if (!string.IsNullOrEmpty(itemId))
			{
				_startupItems.Add(itemId);
			}
			return this;
		}

		public RandomInventoryItemsBuilder WithStartupItems(params string[] itemIds)
		{
			if (itemIds == null)
			{
				return this;
			}
			foreach (string text in itemIds)
			{
				if (!string.IsNullOrEmpty(text))
				{
					_startupItems.Add(text);
				}
			}
			return this;
		}

		public RandomInventoryItemsBuilder WithClearInventoryEachNight(bool clearEachNight)
		{
			_clearInventoryEachNight = clearEachNight;
			return this;
		}

		internal InventoryDefaultsData BuildInternal()
		{
			bool? clearInventoryEachNight = _clearInventoryEachNight;
			if (!clearInventoryEachNight.HasValue && _startupItems.Count > 0)
			{
				clearInventoryEachNight = false;
			}
			return new InventoryDefaultsData
			{
				StartupItems = new List<string>(_startupItems),
				RandomCashMin = _randomCashMin,
				RandomCashMax = _randomCashMax,
				ClearInventoryEachNight = clearInventoryEachNight
			};
		}
	}
}
namespace S1API.Entities.Voices
{
	public static class NPCVoiceCatalog
	{
		private static readonly IReadOnlyList<NPCVoiceDefinition> Definitions = Array.AsReadOnly(new NPCVoiceDefinition[11]
		{
			Cold, Crackhead, Female1, Female2, Goblin, Hippie, Joel, Monotone, Redneck, Timid,
			Tyler
		});

		private static readonly Dictionary<string, NPCVoiceDefinition> DefinitionsById = Definitions.ToDictionary<NPCVoiceDefinition, string>((NPCVoiceDefinition definition) => definition.Id, StringComparer.OrdinalIgnoreCase);

		public static NPCVoiceDefinition Cold { get; } = new NPCVoiceDefinition("cold", "Cold", "Cold VO");

		public static NPCVoiceDefinition Crackhead { get; } = new NPCVoiceDefinition("crackhead", "Crackhead", "Crackhead VO");

		public static NPCVoiceDefinition Female1 { get; } = new NPCVoiceDefinition("female-1", "Female 1", "Female1 VO");

		public static NPCVoiceDefinition Female2 { get; } = new NPCVoiceDefinition("female-2", "Female 2", "Female2 VO");

		public static NPCVoiceDefinition Goblin { get; } = new NPCVoiceDefinition("goblin", "Goblin", "Goblin VO");

		public static NPCVoiceDefinition Hippie { get; } = new NPCVoiceDefinition("hippie", "Hippie", "Hippie VO");

		public static NPCVoiceDefinition Joel { get; } = new NPCVoiceDefinition("joel", "Joel", "Joel VO");

		public static NPCVoiceDefinition Monotone { get; } = new NPCVoiceDefinition("monotone", "Monotone", "Monotone VO");

		public static NPCVoiceDefinition Redneck { get; } = new NPCVoiceDefinition("redneck", "Redneck", "Redneck VO");

		public static NPCVoiceDefinition Timid { get; } = new NPCVoiceDefinition("timid", "Timid", "Timid VO");

		public static NPCVoiceDefinition Tyler { get; } = new NPCVoiceDefinition("tyler", "Tyler", "Tyler VO");

		public static IReadOnlyList<NPCVoiceDefinition> All => Definitions;

		public static NPCVoiceDefinition Get(string identifier)
		{
			if (string.IsNullOrWhiteSpace(identifier))
			{
				throw new ArgumentException("An NPC voice identifier is required.", "identifier");
			}
			string key = identifier.Trim();
			if (DefinitionsById.TryGetValue(key, out NPCVoiceDefinition value) && value != null)
			{
				return value;
			}
			throw new ArgumentException($"Unsupported NPC voice identifier '{identifier}'. Supported identifiers: {string.Join(", ", Definitions.Select((NPCVoiceDefinition definition) => definition.Id))}.", "identifier");
		}

		public static bool TryGet(string identifier, out NPCVoiceDefinition? definition)
		{
			definition = null;
			return !string.IsNullOrWhiteSpace(identifier) && DefinitionsById.TryGetValue(identifier.Trim(), out definition);
		}
	}
	public sealed class NPCVoiceDefinition
	{
		public string Id { get; }

		public string DisplayName { get; }

		internal string DatabaseName { get; }

		internal NPCVoiceDefinition(string id, string displayName, string databaseName)
		{
			Id = id;
			DisplayName = displayName;
			DatabaseName = databaseName;
		}

		public override string ToString()
		{
			return Id;
		}
	}
}
namespace S1API.Entities.Supplier
{
	public sealed class SupplierDataBuilder
	{
		internal sealed class SupplierConfigData
		{
			public float MinimumDeaddropOrderLimit { get; set; } = 100f;

			public float MaximumDeaddropOrderLimit { get; set; } = 500f;

			public List<StorableItemDefinition> DeliveryItems { get; } = new List<StorableItemDefinition>();

			public List<string> DeliveryItemIds { get; } = new List<string>();

			public string SupplierRecommendMessage { get; set; } = "My friend <NAME> can hook you up with <PRODUCT>. I've passed your number on to them.";

			public string SupplierUnlockHint { get; set; } = "You can now order <PRODUCT> from <NAME>. <PRODUCT> can be used to <PURPOSE>.";

			public string? StashDeadDropGuid { get; set; }

			public string? PersistentId { get; set; }

			internal IReadOnlyList<StorableItemDefinition> ResolveDeliveryItems()
			{
				for (int i = 0; i < DeliveryItemIds.Count; i++)
				{
					ItemDefinition definition = ItemManager.GetDefinition(DeliveryItemIds[i]);
					if (definition == null || !CrossType.Is<StorableItemDefinition>((object)definition.S1ItemDefinition, out StorableItemDefinition result))
					{
						continue;
					}
					bool flag = false;
					for (int j = 0; j < DeliveryItems.Count; j++)
					{
						StorableItemDefinition obj = DeliveryItems[j];
						if (string.Equals((obj != null) ? ((BaseItemDefinition)obj).ID : null, ((BaseItemDefinition)result).ID, StringComparison.OrdinalIgnoreCase))
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						DeliveryItems.Add(result);
					}
				}
				return DeliveryItems;
			}
		}

		private readonly SupplierConfigData data = new SupplierConfigData();

		internal SupplierDataBuilder()
		{
		}

		public SupplierDataBuilder WithOrderLimits(float minimum, float maximum)
		{
			if (float.IsNaN(minimum) || float.IsInfinity(minimum))
			{
				throw new ArgumentOutOfRangeException("minimum", "The minimum order limit must be finite.");
			}
			if (float.IsNaN(maximum) || float.IsInfinity(maximum))
			{
				throw new ArgumentOutOfRangeException("maximum", "The maximum order limit must be finite.");
			}
			if (minimum < 0f)
			{
				throw new ArgumentOutOfRangeException("minimum", "The minimum order limit cannot be negative.");
			}
			if (maximum <= 0f)
			{
				throw new ArgumentOutOfRangeException("maximum", "The maximum order limit must be greater than zero.");
			}
			if (maximum < minimum)
			{
				throw new ArgumentOutOfRangeException("maximum", "The maximum order limit cannot be below the minimum.");
			}
			data.MinimumDeaddropOrderLimit = minimum;
			data.MaximumDeaddropOrderLimit = maximum;
			return this;
		}

		public SupplierDataBuilder WithPersistentId(string persistentId)
		{
			if (string.IsNullOrWhiteSpace(persistentId))
			{
				throw new ArgumentException("The persistent supplier ID cannot be empty.", "persistentId");
			}
			data.PersistentId = persistentId.Trim();
			return this;
		}

		public SupplierDataBuilder WithDeliveryItem(ItemDefinition item)
		{
			if (item == null)
			{
				throw new ArgumentNullException("item");
			}
			if (!CrossType.Is<StorableItemDefinition>((object)item.S1ItemDefinition, out StorableItemDefinition result))
			{
				throw new ArgumentException("Item '" + item.ID + "' is not storable and cannot be sold by a supplier.", "item");
			}
			for (int i = 0; i < data.DeliveryItems.Count; i++)
			{
				StorableItemDefinition obj = data.DeliveryItems[i];
				if (string.Equals((obj != null) ? ((BaseItemDefinition)obj).ID : null, ((BaseItemDefinition)result).ID, StringComparison.OrdinalIgnoreCase))
				{
					return this;
				}
			}
			data.DeliveryItems.Add(result);
			AddDeliveryItemId(((BaseItemDefinition)result).ID);
			return this;
		}

		public SupplierDataBuilder WithDeliveryItem(global::S1API.Items.Storable.StorableItemDefinition item)
		{
			return WithDeliveryItem((ItemDefinition)item);
		}

		public SupplierDataBuilder WithDeliveryItem(string itemId)
		{
			if (string.IsNullOrWhiteSpace(itemId))
			{
				throw new ArgumentException("The item ID cannot be empty.", "itemId");
			}
			AddDeliveryItemId(itemId.Trim());
			return this;
		}

		public SupplierDataBuilder WithDeliveryItems(IEnumerable<ItemDefinition> items)
		{
			if (items == null)
			{
				throw new ArgumentNullException("items");
			}
			foreach (ItemDefinition item in items)
			{
				WithDeliveryItem(item);
			}
			return this;
		}

		public SupplierDataBuilder WithRecommendationMessage(string? message)
		{
			data.SupplierRecommendMessage = message ?? string.Empty;
			return this;
		}

		public SupplierDataBuilder WithUnlockHint(string? hint)
		{
			data.SupplierUnlockHint = hint ?? string.Empty;
			return this;
		}

		public SupplierDataBuilder WithStashDeadDrop(DeadDropInstance deadDrop)
		{
			if (deadDrop == null)
			{
				throw new ArgumentNullException("deadDrop");
			}
			return WithStashDeadDrop(deadDrop.GUID);
		}

		public SupplierDataBuilder WithStashDeadDrop<T>() where T : IDeadDropIdentifier
		{
			return WithStashDeadDrop(DeadDropManager.GetGuid<T>());
		}

		public SupplierDataBuilder WithStashDeadDrop(string deadDropGuid)
		{
			if (!Guid.TryParse(deadDropGuid, out var result))
			{
				throw new ArgumentException("The stash dead-drop GUID must be a valid GUID.", "deadDropGuid");
			}
			data.StashDeadDropGuid = result.ToString("D");
			return this;
		}

		internal SupplierConfigData BuildInternal()
		{
			return data;
		}

		private void AddDeliveryItemId(string itemId)
		{
			for (int i = 0; i < data.DeliveryItemIds.Count; i++)
			{
				if (string.Equals(data.DeliveryItemIds[i], itemId, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
			}
			data.DeliveryItemIds.Add(itemId);
		}
	}
}
namespace S1API.Entities.Schedule
{
	public sealed class DriveToCarParkSpec : IScheduleActionSpec
	{
		private static readonly Log Logger = new Log("DriveToCarParkSpec");

		internal static readonly HashSet<LandVehicle> VehiclesAtNoSpotLots = new HashSet<LandVehicle>();

		public int StartTime { get; set; }

		public string? ParkingLotGUID { get; set; }

		public string? VehicleGUID { get; set; }

		public bool? OverrideParkingType { get; set; }

		public int? ParkingType { get; set; }

		public ParkingAlignment? Alignment { get; set; }

		public string? Name { get; set; }

		public ParkingLotWrapper? ParkingLot { get; set; }

		public LandVehicle? Vehicle { get; set; }

		public string? ParkingLotName { get; set; }

		public string? VehicleName { get; set; }

		public string? VehicleCode { get; set; }

		public Vector3 VehicleSpawnPosition { get; set; }

		public Quaternion? VehicleSpawnRotation { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			NPCSignal_DriveToCarPark val = schedule.AddActionInternal<NPCSignal_DriveToCarPark>(StartTime, string.IsNullOrEmpty(Name) ? "DriveToCarPark" : Name);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				object obj = null;
				ParkingLot val2 = null;
				if (ParkingLot != null)
				{
					val2 = ParkingLot.ResolveGameLot();
					obj = val2;
				}
				else if (!string.IsNullOrEmpty(ParkingLotName))
				{
					val2 = ParkingLotRegistry.GetByName(ParkingLotName)?.ResolveGameLot();
					obj = val2;
				}
				else if (!string.IsNullOrEmpty(ParkingLotGUID))
				{
					val2 = ParkingLotRegistry.GetByGUID(ParkingLotGUID)?.ResolveGameLot();
					obj = val2;
				}
				if (obj == null)
				{
					Logger.Warning($"DriveToCarPark: Parking lot could not be resolved (Name='{ParkingLotName}', GUID='{ParkingLotGUID}'). Action will not function correctly.");
				}
				else
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "ParkingLot", obj);
					if ((Object)(object)val2 != (Object)null && (val2.ParkingSpots == null || val2.ParkingSpots.Count == 0))
					{
						Logger.Warning("DriveToCarPark: Parking lot '" + ((Object)((Component)val2).gameObject).name + "' has no parking spots. The game will hide (SetVisible=false) any vehicle parked here. Choose a lot with ParkingSpot children.");
					}
				}
				object obj2 = null;
				if (Vehicle != null && (Object)(object)Vehicle.S1LandVehicle != (Object)null)
				{
					obj2 = Vehicle.S1LandVehicle;
				}
				else if (!string.IsNullOrEmpty(VehicleName))
				{
					obj2 = VehicleRegistry.GetByName(VehicleName)?.S1LandVehicle;
				}
				else if (!string.IsNullOrEmpty(VehicleGUID))
				{
					obj2 = VehicleRegistry.GetByGUID(VehicleGUID)?.S1LandVehicle;
				}
				else if (!string.IsNullOrEmpty(VehicleCode))
				{
					LandVehicle landVehicle = VehicleRegistry.CreateVehicle(VehicleCode);
					if (landVehicle == null)
					{
						Logger.Error("DriveToCarPark: Failed to create vehicle with code '" + VehicleCode + "'. Verify the code is valid.");
					}
					else
					{
						obj2 = landVehicle.S1LandVehicle;
					}
					if (obj2 != null)
					{
						LandVehicle landVehicle2 = landVehicle;
						if (landVehicle2 != null && (Object)(object)landVehicle2.S1LandVehicle != (Object)null)
						{
							try
							{
								NetworkManager networkManager = InstanceFinder.NetworkManager;
								if ((Object)(object)networkManager != (Object)null && networkManager.IsServer)
								{
									Quaternion rotation = (Quaternion)(((??)VehicleSpawnRotation) ?? Quaternion.identity);
									landVehicle2.Spawn(VehicleSpawnPosition, rotation);
								}
							}
							catch (Exception ex)
							{
								Logger.Error("DriveToCarPark: Failed to spawn created vehicle '" + VehicleCode + "': " + ex.Message);
								Logger.Error("DriveToCarPark: Stack trace: " + ex.StackTrace);
							}
						}
					}
				}
				if (obj2 == null)
				{
					Logger.Warning("DriveToCarPark: Vehicle could not be resolved. The NPC will not be able to drive.");
				}
				else
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "Vehicle", obj2);
					if ((Object)(object)val2 != (Object)null && (val2.ParkingSpots == null || val2.ParkingSpots.Count == 0))
					{
						LandVehicle val3 = (LandVehicle)((obj2 is LandVehicle) ? obj2 : null);
						if ((Object)(object)val3 != (Object)null)
						{
							VehiclesAtNoSpotLots.Add(val3);
						}
					}
				}
				if (OverrideParkingType.HasValue)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "OverrideParkingType", OverrideParkingType.Value);
				}
				if (Alignment.HasValue)
				{
					EParkingAlignment val4 = (EParkingAlignment)Alignment.Value;
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "ParkingType", val4);
				}
				else if (ParkingType.HasValue)
				{
					EParkingAlignment val5 = (EParkingAlignment)ParkingType.Value;
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "ParkingType", val5);
				}
			}
			catch (Exception ex2)
			{
				Logger.Error("DriveToCarPark: Unexpected error during ApplyTo: " + ex2.Message);
				Logger.Error("DriveToCarPark: Stack trace: " + ex2.StackTrace);
			}
		}
	}
	[Obsolete("NPCSignal_WaitForDelivery was removed in game version 0.4.6. Customer deal attendance is configured automatically.")]
	public sealed class EnsureDealSignalSpec : IScheduleActionSpec
	{
		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			schedule.EnsureDealSignal();
		}
	}
	[Obsolete("HandleDealSpec is no longer needed as of game version 0.4.2f4. Deal handling is now automatic through DealerAttendDealBehaviour.")]
	public sealed class HandleDealSpec : IScheduleActionSpec
	{
		public int StartTime { get; set; }

		public string? Name { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
		}
	}
	public interface IScheduleActionSpec
	{
		void ApplyTo(NPCSchedule schedule);
	}
	public enum LocationArriveBehaviour
	{
		None,
		SmokeBreak,
		Graffiti,
		Drinking,
		HoldItem
	}
	public sealed class LocationBasedActionSpec : IScheduleActionSpec
	{
		private static readonly Log Logger = new Log("LocationBasedActionSpec");

		public Vector3 Destination { get; set; }

		public int StartTime { get; set; }

		public int DurationMinutes { get; set; } = 60;

		public bool FaceDestinationDirection { get; set; } = true;

		public float Within { get; set; } = 1f;

		public bool WarpIfSkipped { get; set; } = false;

		public LocationArriveBehaviour ArriveBehaviour { get; set; } = LocationArriveBehaviour.None;

		public string? Name { get; set; }

		public Region? GraffitiRegion { get; set; }

		public Guid? GraffitiSurfaceGuid { get; set; }

		public string? EquippableAssetPath { get; set; }

		public string? DrinkEquippablePath { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			NPCEvent_LocationBasedAction val = schedule.AddActionInternal<NPCEvent_LocationBasedAction>(StartTime, string.IsNullOrEmpty(Name) ? "LocationBasedAction" : Name);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Vector3 destination = Destination;
			NavMeshHit val2 = default(NavMeshHit);
			if (NavMesh.SamplePosition(Destination, ref val2, 5f, -1))
			{
				((Vector3)(ref destination))..ctor(Destination.x, ((NavMeshHit)(ref val2)).position.y, Destination.z);
			}
			Transform val3 = NPCDestinationContainer.CreateDestinationMarker(((Object)schedule.NPC.gameObject).name, "Marker", destination);
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			val.Destination = val3;
			val.FaceDestinationDir = FaceDestinationDirection;
			val.DestinationThreshold = Mathf.Max(0.01f, Within);
			val.WarpIfSkipped = WarpIfSkipped;
			((NPCEvent)val).Duration = Mathf.Max(1, DurationMinutes);
			if (val.onStartAction == null)
			{
				val.onStartAction = new UnityEvent();
			}
			if (val.onEndAction == null)
			{
				val.onEndAction = new UnityEvent();
			}
			switch (ArriveBehaviour)
			{
			case LocationArriveBehaviour.SmokeBreak:
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleSmoking(schedule, enabled: true);
				}, val.onStartAction);
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleSmoking(schedule, enabled: false);
				}, val.onEndAction);
				break;
			case LocationArriveBehaviour.Graffiti:
			{
				Vector3 destPos = (((Object)(object)val3 != (Object)null) ? val3.position : Destination);
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					//IL_0017: Unknown result type (might be due to invalid IL or missing references)
					ToggleGraffiti(this, schedule, destPos, enabled: true);
				}, val.onStartAction);
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					//IL_000e: 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)
					ToggleGraffiti(this, schedule, default(Vector3), enabled: false);
				}, val.onEndAction);
				break;
			}
			case LocationArriveBehaviour.Drinking:
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleDrinking(this, schedule, enabled: true);
				}, val.onStartAction);
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleDrinking(this, schedule, enabled: false);
				}, val.onEndAction);
				break;
			case LocationArriveBehaviour.HoldItem:
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleItemHolding(this, schedule, enabled: true);
				}, val.onStartAction);
				global::S1API.Utils.EventHelper.AddListener(delegate
				{
					ToggleItemHolding(this, schedule, enabled: false);
				}, val.onEndAction);
				break;
			case LocationArriveBehaviour.None:
				break;
			}
		}

		private static bool IsServer()
		{
			try
			{
				return InstanceFinder.IsServer;
			}
			catch
			{
				return false;
			}
		}

		private static bool ToggleBehaviourByName(NPCSchedule schedule, string behaviourName, bool enabled)
		{
			if (!IsServer() || (Object)(object)schedule?.NPC?.S1NPC == (Object)null || string.IsNullOrEmpty(behaviourName))
			{
				return false;
			}
			NPC s1NPC = schedule.NPC.S1NPC;
			NPCBehaviour componentInChildren = ((Component)s1NPC).GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return false;
			}
			Behaviour behaviour = componentInChildren.GetBehaviour(behaviourName);
			if ((Object)(object)behaviour == (Object)null)
			{
				return false;
			}
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(componentInChildren, "Npc", s1NPC);
			if (global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(behaviour, "beh") == null)
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(behaviour, "beh", componentInChildren);
			}
			object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(behaviour, "BehaviourIndex");
			int result;
			int num = ((obj is int num2) ? num2 : ((obj != null && int.TryParse(obj.ToString(), out result)) ? result : (-1)));
			if (enabled)
			{
				if ((Object)(object)((Component)behaviour).gameObject != (Object)null && !((Component)behaviour).gameObject.activeSelf)
				{
					((Component)behaviour).gameObject.SetActive(true);
				}
				behaviour.Enable_Networked();
				if (num >= 0)
				{
					componentInChildren.ActivateBehaviour_Server(num);
				}
			}
			else
			{
				behaviour.Disable_Networked((NetworkConnection)null);
			}
			return true;
		}

		private static void ToggleSmoking(NPCSchedule schedule, bool enabled)
		{
			if (!IsServer() || (Object)(object)schedule?.NPC?.S1NPC == (Object)null)
			{
				return;
			}
			NPCSmoking smoking = schedule.NPC.Smoking;
			if (smoking != null)
			{
				if (enabled)
				{
					smoking.Begin();
				}
				else
				{
					smoking.End();
				}
			}
		}

		private static void ToggleGraffiti(LocationBasedActionSpec spec, NPCSchedule schedule, Vector3 destinationPosition, bool enabled)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (!IsServer() || (Object)(object)schedule?.NPC?.S1NPC == (Object)null)
			{
				return;
			}
			if (!enabled)
			{
				ToggleBehaviourByName(schedule, "GraffitiBehaviour", enabled: false);
				return;
			}
			WorldSpraySurface val = null;
			if (spec.GraffitiSurfaceGuid.HasValue)
			{
				val = GraffitiManager.FindSurfaceByGuid(spec.GraffitiSurfaceGuid.Value);
			}
			if ((Object)(object)val == (Object)null && spec.GraffitiRegion.HasValue)
			{
				List<WorldSpraySurface> list = GraffitiManager.FindAvailableForNPCInRegion(spec.GraffitiRegion.Value);
				if (list.Count > 0)
				{
					val = list[Random.Range(0, list.Count)];
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				val = GraffitiManager.FindNearestAvailableForNPC(destinationPosition);
			}
			if ((Object)(object)val == (Object)null)
			{
				Logger.Warning("[LocationBasedActionSpec] Graffiti: No spray surface found (guid/region/nearest).");
				return;
			}
			if ((Object)(object)((NetworkBehaviour)val).NetworkObject == (Object)null)
			{
				Logger.Warning("[LocationBasedActionSpec] Graffiti: Spray surface has no NetworkObject, cannot assign behaviour.");
				return;
			}
			NPC s1NPC = schedule.NPC.S1NPC;
			NPCBehaviour componentInChildren = ((Component)s1NPC).GetComponentInChildren<NPCBehaviour>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Logger.Warning("[LocationBasedActionSpec] Graffiti: NPCBehaviour component not found.");
				return;
			}
			Behaviour behaviour = componentInChildren.GetBehaviour("GraffitiBehaviour");
			if ((Object)(object)behaviour == (Object)null)
			{
				Logger.Warning("[LocationBasedActionSpec] Graffiti: GraffitiBehaviour not found.");
				return;
			}
			if (!CrossType.Is<GraffitiBehaviour>((object)behaviour, out GraffitiBehaviour result) || (Object)(object)result == (Object)null)
			{
				result = ((Component)componentInChildren).GetComponentInChildren<GraffitiBehaviour>(true);
			}
			if ((Object)(object)result == (Object)null)
			{
				Logger.Warning("[LocationBasedActionSpec] Graffiti: GraffitiBehaviour could not be resolved as the concrete type.");
				return;
			}
			result.SetSpraySurface_Client((NetworkConnection)null, ((NetworkBehaviour)val).NetworkObject);
			ToggleBehaviourByName(schedule, "GraffitiBehaviour", enabled: true);
		}

		private static void ToggleDrinking(LocationBasedActionSpec spec, NPCSchedule schedule, bool enabled)
		{
			if (!IsServer() || (Object)(object)schedule?.NPC?.S1NPC == (Object)null)
			{
				return;
			}
			DrinkItem componentInChildren = ((Component)schedule.NPC.S1NPC).GetComponentInChildren<DrinkItem>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			if (enabled && !string.IsNullOrEmpty(spec.DrinkEquippablePath))
			{
				GameObject val = Resources.Load<GameObject>(spec.DrinkEquippablePath);
				AvatarEquippable val2 = ((val != null) ? val.GetComponent<AvatarEquippable>() : null) ?? ((val != null) ? val.GetComponentInChildren<AvatarEquippable>(true) : null);
				if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(componentInChildren, "DrinkPrefab", val2);
				}
			}
			if (enabled)
			{
				componentInChildren.Begin();
			}
			else
			{
				componentInChildren.End();
			}
		}

		private static void ToggleItemHolding(LocationBasedActionSpec spec, NPCSchedule schedule, bool enabled)
		{
			if (!IsServer() || (Object)(object)schedule?.NPC?.S1NPC == (Object)null)
			{
				return;
			}
			HoldItem componentInChildren = ((Component)schedule.NPC.S1NPC).GetComponentInChildren<HoldItem>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			if (enabled && !string.IsNullOrEmpty(spec.EquippableAssetPath))
			{
				GameObject val = Resources.Load<GameObject>(spec.EquippableAssetPath);
				AvatarEquippable val2 = ((val != null) ? val.GetComponent<AvatarEquippable>() : null) ?? ((val != null) ? val.GetComponentInChildren<AvatarEquippable>(true) : null);
				if ((Object)(object)val2 != (Object)null)
				{
					global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(componentInChildren, "Equippable", val2);
				}
			}
			if (enabled)
			{
				componentInChildren.Begin();
			}
			else
			{
				componentInChildren.End();
			}
		}
	}
	public sealed class LocationDialogueSpec : IScheduleActionSpec
	{
		public Vector3 Destination { get; set; }

		public Vector3? Forward { get; set; }

		public int StartTime { get; set; }

		public bool FaceDestinationDirection { get; set; } = true;

		public float Within { get; set; } = 1f;

		public bool WarpIfSkipped { get; set; } = false;

		public int GreetingOverrideToEnable { get; set; } = -1;

		public int ChoiceToEnable { get; set; } = -1;

		public string? Name { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			NPCEvent_LocationDialogue val = schedule.AddActionInternal<NPCEvent_LocationDialogue>(StartTime, string.IsNullOrEmpty(Name) ? "LocationDialogue" : Name);
			if (!((Object)(object)val == (Object)null))
			{
				Vector3 destination = Destination;
				NavMeshHit val2 = default(NavMeshHit);
				if (NavMesh.SamplePosition(Destination, ref val2, 5f, -1))
				{
					((Vector3)(ref destination))..ctor(Destination.x, ((NavMeshHit)(ref val2)).position.y, Destination.z);
				}
				Transform val3 = NPCDestinationContainer.CreateDestinationMarker(((Object)schedule.NPC.gameObject).name, "Marker", destination, Forward);
				if ((Object)(object)val3 != (Object)null)
				{
					val.Destination = val3;
					val.FaceDestinationDir = FaceDestinationDirection;
					val.DestinationThreshold = Mathf.Max(0.01f, Within);
					val.WarpIfSkipped = WarpIfSkipped;
					val.GreetingOverrideToEnable = GreetingOverrideToEnable;
					val.ChoiceToEnable = ChoiceToEnable;
				}
			}
		}
	}
	public sealed class SitSpec : IScheduleActionSpec
	{
		public int StartTime { get; set; }

		public int DurationMinutes { get; set; }

		public string? Name { get; set; }

		public bool WarpIfSkipped { get; set; }

		public Object? SeatSetReference { get; set; }

		public string? SeatSetPath { get; set; }

		public string? SeatSetName { get; set; }

		public bool IncludeInactiveSearch { get; set; } = true;

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			if (schedule == null)
			{
				return;
			}
			NPCEvent_Sit val = schedule.AddActionInternal<NPCEvent_Sit>(StartTime, string.IsNullOrEmpty(Name) ? "Sit" : Name);
			if (!((Object)(object)val == (Object)null))
			{
				try
				{
					((NetworkBehaviour)val).NetworkInitializeIfDisabled();
				}
				catch
				{
				}
				AvatarSeatSet val2 = ResolveSeatSet(schedule);
				if ((Object)(object)val2 != (Object)null)
				{
					val.SeatSet = val2;
					val.WarpIfSkipped = WarpIfSkipped;
					((NPCEvent)val).Duration = ((DurationMinutes > 0) ? DurationMinutes : 60);
					return;
				}
				string value = (((Object)(object)schedule.NPC?.gameObject != (Object)null) ? ((Object)schedule.NPC.gameObject).name : "Unknown");
				Debug.LogWarning(Object.op_Implicit($"[S1API] SitSpec could not resolve a seat set (Name={SeatSetName}, Path={SeatSetPath}) for NPC '{value}'. Disabling action to prevent crash."));
				((Behaviour)val).enabled = false;
				((Component)val).gameObject.SetActive(false);
			}
		}

		private AvatarSeatSet? ResolveSeatSet(NPCSchedule? schedule)
		{
			AvatarSeatSet val = TryGetFromObject(SeatSetReference);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			AvatarSeatSet[] cache = null;
			if (!string.IsNullOrEmpty(SeatSetPath))
			{
				AvatarSeatSet val2 = TryResolveFromPath(SeatSetPath, ref cache);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			if (!string.IsNullOrEmpty(SeatSetName))
			{
				AvatarSeatSet val3 = TryResolveFromName(SeatSetName, ref cache);
				if ((Object)(object)val3 != (Object)null)
				{
					return val3;
				}
			}
			if ((Object)(object)schedule?.NPC?.gameObject != (Object)null)
			{
				Transform transform = schedule.NPC.gameObject.transform;
				if ((Object)(object)transform != (Object)null)
				{
					AvatarSeatSet componentInChildren = ((Component)transform).GetComponentInChildren<AvatarSeatSet>(IncludeInactiveSearch);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						return componentInChildren;
					}
				}
			}
			return null;
		}

		private AvatarSeatSet? TryResolveFromPath(string? path, ref AvatarSeatSet[]? cache)
		{
			if (string.IsNullOrEmpty(path))
			{
				return null;
			}
			try
			{
				GameObject obj = GameObject.Find(path);
				AvatarSeatSet val = TryGetFromObject((Object?)(object)obj);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			catch
			{
			}
			AvatarSeatSet[] array = cache ?? (cache = FindAllSeatSets());
			if (array == null || array.Length == 0)
			{
				return null;
			}
			foreach (AvatarSeatSet val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Transform transform = ((Component)val2).transform;
					if (!((Object)(object)transform == (Object)null) && MatchesPath(transform, path))
					{
						return val2;
					}
				}
			}
			return null;
		}

		private AvatarSeatSet? TryResolveFromName(string? name, ref AvatarSeatSet[]? cache)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			AvatarSeatSet[] array = cache ?? (cache = FindAllSeatSets());
			if (array == null || array.Length == 0)
			{
				return null;
			}
			foreach (AvatarSeatSet val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					GameObject gameObject = ((Component)val).gameObject;
					if (!((Object)(object)gameObject == (Object)null) && string.Equals(((Object)gameObject).name, name, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			return null;
		}

		private AvatarSeatSet[] FindAllSeatSets()
		{
			try
			{
				return Il2CppArrayBase<AvatarSeatSet>.op_Implicit(Object.FindObjectsOfType<AvatarSeatSet>(IncludeInactiveSearch));
			}
			catch
			{
				return Array.Empty<AvatarSeatSet>();
			}
		}

		private static bool MatchesPath(Transform transform, string expectedPath)
		{
			if ((Object)(object)transform == (Object)null || string.IsNullOrEmpty(expectedPath))
			{
				return false;
			}
			string text = expectedPath.Replace('\\', '/');
			if (text.Length == 0)
			{
				return false;
			}
			string text2 = BuildHierarchyPath(transform);
			if (string.Equals(text2, text, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return text2.EndsWith(text, StringComparison.OrdinalIgnoreCase);
		}

		private static string BuildHierarchyPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(128);
			BuildPathRecursive(transform, stringBuilder);
			return stringBuilder.ToString();
		}

		private static void BuildPathRecursive(Transform node, StringBuilder builder)
		{
			if ((Object)(object)node == (Object)null)
			{
				return;
			}
			if ((Object)(object)node.parent != (Object)null)
			{
				BuildPathRecursive(node.parent, builder);
				if (builder.Length > 0)
				{
					builder.Append('/');
				}
			}
			builder.Append(((Object)node).name);
		}

		private static AvatarSeatSet? TryGetFromObject(Object? obj)
		{
			if (obj == (Object)null)
			{
				return null;
			}
			AvatarSeatSet val = (AvatarSeatSet)(object)((obj is AvatarSeatSet) ? obj : null);
			if (val != null)
			{
				return val;
			}
			GameObject val2 = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (val2 != null)
			{
				return val2.GetComponent<AvatarSeatSet>();
			}
			Component val3 = (Component)(object)((obj is Component) ? obj : null);
			if (val3 != null)
			{
				return val3.GetComponent<AvatarSeatSet>();
			}
			return null;
		}
	}
	public sealed class StayInBuildingSpec : IScheduleActionSpec
	{
		private sealed class PendingAction
		{
			public NPCEvent_StayInBuilding? Action;

			public NPCSchedule? Schedule;

			public string? BuildingName;

			public int StartTime;

			public int? DoorIndex;
		}

		private static readonly Log Logger = new Log("StayInBuildingSpec");

		private static readonly List<PendingAction> PendingActions = new List<PendingAction>();

		public string? BuildingGUID { get; set; }

		public string? BuildingName { get; set; }

		internal Type? BuildingIdentifierType { get; set; }

		public int StartTime { get; set; }

		public int DurationMinutes { get; set; } = 60;

		public int? DoorIndex { get; set; }

		public string? Name { get; set; }

		public void ApplyTo(NPCSchedule schedule)
		{
			NPCEvent_StayInBuilding val = schedule.AddActionInternal<NPCEvent_StayInBuilding>(StartTime, string.IsNullOrEmpty(Name) ? "StayInBuilding" : Name);
			if ((Object)(object)val == (Object)null)
			{
				Logger.Warning($"Failed to create StayInBuilding action at time {StartTime} - AddActionInternal returned null");
				return;
			}
			((NPCEvent)val).Duration = Mathf.Max(1, DurationMinutes);
			int num = TimeManager.AddMinutesTo24HourTime(StartTime, ((NPCEvent)val).Duration);
			global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "EndTime", num);
			object obj = null;
			global::S1API.Map.Building building = null;
			if (!string.IsNullOrEmpty(BuildingName))
			{
				building = global::S1API.Map.Building.GetByName(BuildingName);
				if (building == null)
				{
					Logger.Warning($"Building '{BuildingName}' not found in registry for StayInBuilding action at time {StartTime}. Will register deferred lookup.");
					if (!DeferredMapResolver.IsMenuScene())
					{
						obj = TryFindBuildingInScene(BuildingName);
						if (obj != null)
						{
							ApplyBuildingToAction(val, obj);
							return;
						}
					}
					RegisterDeferredBuildingResolution(val, schedule);
					return;
				}
				obj = building.ResolveGameBuilding();
				if (obj == null)
				{
					if (building.IsDeferred)
					{
						RegisterDeferredBuildingResolution(val, schedule, building);
						return;
					}
					Logger.Warning("Building wrapper for '" + BuildingName + "' exists but ResolveGameBuilding returned null. Trying direct scene lookup.");
					obj = TryFindBuildingInScene(BuildingName);
					if (obj == null)
					{
						Logger.Error($"Failed to resolve game building for '{BuildingName}' (wrapper exists but ResolveGameBuilding returned null) at time {StartTime}");
					}
				}
			}
			else if (!string.IsNullOrEmpty(BuildingGUID))
			{
				Logger.Warning($"StayInBuildingSpec at time {StartTime} has BuildingGUID set but BuildingName is empty. GUID-based lookup is not yet implemented.");
			}
			else
			{
				Logger.Error($"StayInBuildingSpec at time {StartTime} has neither BuildingName nor BuildingGUID set. Action will be created without a building reference.");
			}
			if (obj != null)
			{
				ApplyBuildingToAction(val, obj);
				return;
			}
			Logger.Warning($"StayInBuilding action at time {StartTime} was created but Building field is null. Will retry when building is registered.");
			lock (PendingActions)
			{
				PendingActions.Add(new PendingAction
				{
					Action = val,
					Schedule = schedule,
					BuildingName = BuildingName,
					StartTime = StartTime,
					DoorIndex = DoorIndex
				});
			}
			TryResolvePendingActions();
		}

		internal static void TryResolvePendingActions()
		{
			lock (PendingActions)
			{
				if (PendingActions.Count == 0)
				{
					return;
				}
				List<PendingAction> list = new List<PendingAction>();
				for (int num = PendingActions.Count - 1; num >= 0; num--)
				{
					PendingAction pendingAction = PendingActions[num];
					if ((Object)(object)pendingAction.Action == (Object)null || pendingAction.Schedule == null || string.IsNullOrEmpty(pendingAction.BuildingName))
					{
						list.Add(pendingAction);
					}
					else
					{
						global::S1API.Map.Building byName = global::S1API.Map.Building.GetByName(pendingAction.BuildingName);
						if (byName != null)
						{
							object obj = byName.ResolveGameBuilding();
							if (obj != null)
							{
								StayInBuildingSpec stayInBuildingSpec = new StayInBuildingSpec
								{
									BuildingName = pendingAction.BuildingName,
									StartTime = pendingAction.StartTime,
									DoorIndex = pendingAction.DoorIndex
								};
								stayInBuildingSpec.ApplyBuildingToAction(pendingAction.Action, obj);
								try
								{
									pendingAction.Schedule.InitializeActions();
								}
								catch (Exception ex)
								{
									Logger.Warning("Failed to re-initialize schedule after resolving pending building '" + pendingAction.BuildingName + "': " + ex.Message);
								}
								list.Add(pendingAction);
							}
						}
					}
				}
				foreach (PendingAction item in list)
				{
					PendingActions.Remove(item);
				}
			}
		}

		private void ApplyBuildingToAction(NPCEvent_StayInBuilding? action, object? gameBuilding)
		{
			if ((Object)(object)action == (Object)null)
			{
				Logger.Error($"Cannot apply building to null action for '{BuildingName}' at time {StartTime}");
				return;
			}
			if (gameBuilding == null)
			{
				Logger.Error($"Cannot apply null gameBuilding to action for '{BuildingName}' at time {StartTime}");
				return;
			}
			if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(action, "Building", gameBuilding))
			{
				Logger.Error($"Failed to set Building field on StayInBuilding action for '{BuildingName}' at time {StartTime}. Field may not exist or be inaccessible.");
			}
			else
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(action, "Building");
				if (obj == null)
				{
					Logger.Warning($"Building field appears to be null after setting for '{BuildingName}' at time {StartTime}");
				}
			}
			if (!DoorIndex.HasValue)
			{
				return;
			}
			Type type = gameBuilding.GetType();
			IList list = null;
			FieldInfo field = type.GetField("Doors", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				list = field.GetValue(gameBuilding) as IList;
			}
			if (list == null)
			{
				PropertyInfo property = type.GetProperty("Doors", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null)
				{
					list = property.GetValue(gameBuilding) as IList;
				}
			}
			if (list != null && DoorIndex.Value >= 0 && DoorIndex.Value < list.Count)
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(action, "Door", list[DoorIndex.Value]);
			}
			else if (DoorIndex.HasValue)
			{
				Logger.Warning($"DoorIndex {DoorIndex.Value} is out of range for building '{BuildingName}' (has {list?.Count ?? 0} doors)");
			}
		}

		private void RegisterDeferredBuildingResolution(NPCEvent_StayInBuilding action, NPCSchedule schedule, global::S1API.Map.Building? existingWrapper = null)
		{
			if (BuildingIdentifierType != null)
			{
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(BuildingIdentifierType, delegate(object resolved)
				{
					if (resolved is global::S1API.Map.Building building && building != null)
					{
						object obj = building.ResolveGameBuilding();
						if (obj != null && (Object)(object)action != (Object)null)
						{
							ApplyBuildingToAction(action, obj);
							try
							{
								schedule.InitializeActions();
							}
							catch (Exception ex)
							{
								Logger.Warning("Failed to re-initialize schedule after building resolution: " + ex.Message);
							}
						}
					}
				}));
			}
			else if (existingWrapper != null && existingWrapper.DeferredIdentifierType != null)
			{
				DeferredMapResolver.RegisterDeferredLookup(new DeferredLookup(existingWrapper.DeferredIdentifierType, delegate(object resolved)
				{
					if (resolved is global::S1API.Map.Building building && building != null)
					{
						object obj = building.ResolveGameBuilding();
						if (obj != null && (Object)(object)action != (Object)null)
						{
							ApplyBuildingToAction(action, obj);
							try
							{
								schedule.InitializeActions();
							}
							catch (Exception ex)
							{
								Logger.Warning("Failed to re-initialize schedule after building resolution: " + ex.Message);
							}
						}
					}
				}));
			}
			else if (string.IsNullOrEmpty(BuildingName))
			{
			}
		}

		private object? TryFindBuildingInScene(string? buildingName)
		{
			try
			{
				Il2CppArrayBase<NPCEnterableBuilding> val = Object.FindObjectsOfType<NPCEnterableBuilding>(true);
				for (int i = 0; i < val.Length; i++)
				{
					NPCEnterableBuilding val2 = val[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						Type type = ((object)val2).GetType();
						string text = type.GetField("BuildingName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(val2) as string;
						if (string.IsNullOrEmpty(text))
						{
							text = type.GetProperty("BuildingName", BindingFlags.Instance | BindingFlags.Public)?.GetValue(val2) as string;
						}
						if (!string.IsNullOrEmpty(text) && string.Equals(text, buildingName, StringComparison.OrdinalIgnoreCase))
						{
							return val2;
						}
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Exception during direct building lookup for '" + buildingName + "': " + ex.Message);
			}
			return null;
		}
	}
	public sealed class UseATMSpec : IScheduleActionSpec
	{
		public int StartTime { get; set; }

		public string? ATMGUID { get; set; }

		public string? Name { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			NPCSignal_UseATM val = schedule.AddActionInternal<NPCSignal_UseATM>(StartTime, string.IsNullOrEmpty(Name) ? "UseATM" : Name);
			if ((Object)(object)val == (Object)null || string.IsNullOrEmpty(ATMGUID))
			{
				return;
			}
			try
			{
				Guid val2 = default(Guid);
				((Guid)(ref val2))..ctor(ATMGUID);
				ATM value = GUIDManager.GetObject<ATM>(val2);
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "ATM", value);
			}
			catch
			{
			}
		}
	}
	public sealed class UseSlotMachineSpec : IScheduleActionSpec
	{
		private static readonly Log Logger = new Log("UseSlotMachineSpec");

		public int StartTime { get; set; }

		public Vector3 MachinePosition { get; set; }

		public int BetAmount { get; set; } = 10;

		public GamblingSessionMode SessionMode { get; set; } = GamblingSessionMode.SingleSpin;

		public int SpinCount { get; set; } = 1;

		public int EndTime { get; set; }

		public float TimeBetweenSpins { get; set; } = 10f;

		public float MaxSearchDistance { get; set; } = 5f;

		public string? Name { get; set; }

		public global::S1API.Map.Building? Building { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			NPC nPC = schedule.NPC;
			if (nPC == null)
			{
				Logger.Warning("ApplyTo called with null NPC");
				return;
			}
			TimeManager instance = NetworkSingleton<TimeManager>.Instance;
			int num = (((Object)(object)instance != (Object)null) ? instance.CurrentTime : (-1));
			bool flag = num >= 0 && num >= StartTime;
			bool flag2 = false;
			if (flag && (Object)(object)instance != (Object)null)
			{
				flag2 = (SessionMode != GamblingSessionMode.UntilTime && SessionMode != GamblingSessionMode.UntilTimeOrBroke) || ((EndTime <= StartTime) ? (num < EndTime || num >= StartTime) : (num < EndTime));
				if (!flag2)
				{
					return;
				}
			}
			int num2 = ((flag && flag2) ? Mathf.Max(1, num) : StartTime);
			if (Building != null)
			{
				int num3 = Mathf.Max(1, num2 - 5);
				NPCEvent_StayInBuilding val = schedule.AddActionInternal<NPCEvent_StayInBuilding>(num3, string.IsNullOrEmpty(Name) ? "EnterBuildingForSlotMachine" : (Name + "_EnterBuilding"));
				if ((Object)(object)val != (Object)null)
				{
					object obj = Building.ResolveGameBuilding();
					if (obj != null)
					{
						int num4 = 60;
						num4 = ((SessionMode != GamblingSessionMode.UntilTime && SessionMode != GamblingSessionMode.UntilTimeOrBroke) ? 60 : ((EndTime > StartTime) ? (EndTime - num3) : (1440 - num3 + EndTime)));
						((NPCEvent)val).Duration = Mathf.Max(1, num4);
						int num5 = TimeManager.AddMinutesTo24HourTime(num3, ((NPCEvent)val).Duration);
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "EndTime", num5);
						global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(val, "Building", obj);
					}
					else
					{
						Logger.Warning("[" + nPC.ID + "] Failed to resolve game building: " + Building.Name);
					}
				}
				else
				{
					Logger.Warning("[" + nPC.ID + "] Failed to create StayInBuilding action");
				}
			}
			Vector3 val2 = MachinePosition;
			if (!nPC.Movement.CanGetTo(val2))
			{
				Logger.Warning("[" + nPC.ID + "] Initial position not reachable, searching for nearest slot machine");
				SlotMachine val3 = SlotMachineHelper.FindNearestSlotMachine(val2, MaxSearchDistance * 2f);
				if (!((Object)(object)val3 != (Object)null))
				{
					Logger.Error("[" + nPC.ID + "] No slot machine found near position, aborting");
					return;
				}
				if (!nPC.Movement.CanGetTo(((Component)val3).transform.position))
				{
					Logger.Error("[" + nPC.ID + "] Found slot machine but it's not reachable, aborting");
					return;
				}
				val2 = ((Component)val3).transform.position;
			}
			Transform val4 = NPCDestinationContainer.CreateDestinationMarker(((Object)nPC.gameObject).name, "SlotMachineDestination", val2);
			if ((Object)(object)val4 == (Object)null)
			{
				Logger.Error("[" + nPC.ID + "] Failed to create destination marker, aborting");
				return;
			}
			NPCSignal_WalkToLocation val5 = schedule.AddActionInternal<NPCSignal_WalkToLocation>(num2, string.IsNullOrEmpty(Name) ? "WalkToSlotMachine" : (Name + "_Walk"));
			if ((Object)(object)val5 == (Object)null)
			{
				Logger.Error("[" + nPC.ID + "] Failed to create WalkTo action, aborting");
				return;
			}
			val5.Destination = val4;
			val5.FaceDestinationDir = true;
			val5.DestinationThreshold = 2f;
			val5.WarpIfSkipped = flag && flag2;
			MelonCoroutines.Start(WaitForArrivalThenGamble(nPC, val2, BetAmount, MaxSearchDistance, SessionMode, SpinCount, EndTime, TimeBetweenSpins, num2));
		}

		private static IEnumerator WaitForArrivalThenGamble(NPC npc, Vector3 targetPosition, int bet, float maxDistance, GamblingSessionMode mode, int spinCount, int endTime, float timeBetweenSpins, int startTime)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			TimeManager timeManager = NetworkSingleton<TimeManager>.Instance;
			int currentTime = (((Object)(object)timeManager != (Object)null) ? timeManager.CurrentTime : (-1));
			if (currentTime >= 0 && currentTime < startTime)
			{
				while ((Object)(object)timeManager != (Object)null && timeManager.CurrentTime < startTime)
				{
					yield return (object)new WaitForSeconds(1f);
				}
			}
			if (npc != null && (Object)(object)npc.gameObject != (Object)null && !npc.Movement.CanGetTo(targetPosition))
			{
				Logger.Warning("[" + npc.ID + "] NPC can't pathfind to target, searching for alternative");
				SlotMachine machine = SlotMachineHelper.FindNearestSlotMachine(targetPosition, maxDistance * 2f);
				if (!((Object)(object)machine != (Object)null))
				{
					Logger.Error("[" + npc.ID + "] No alternative slot machine found, aborting");
					yield break;
				}
				targetPosition = ((Component)machine).transform.position;
			}
			float arrivalThreshold = 2f;
			int maxWaitTime = 300;
			int waitedSeconds = 0;
			while (npc != null && (Object)(object)npc.gameObject != (Object)null && waitedSeconds < maxWaitTime)
			{
				float distance = Vector3.Distance(npc.Movement.FootPosition, targetPosition);
				bool isMoving = npc.Movement.IsMoving;
				if (distance <= arrivalThreshold && !isMoving)
				{
					break;
				}
				yield return (object)new WaitForSeconds(1f);
				waitedSeconds++;
			}
			if (waitedSeconds >= maxWaitTime)
			{
				Logger.Warning($"[{npc?.ID}] Max wait time reached ({maxWaitTime}s), proceeding anyway");
			}
			if (npc != null && (Object)(object)npc.gameObject != (Object)null)
			{
				yield return GamblingSession(npc, targetPosition, bet, maxDistance, mode, spinCount, endTime, timeBetweenSpins);
			}
			else
			{
				Logger.Error("[" + npc?.ID + "] NPC is null when trying to start gambling session");
			}
		}

		private static IEnumerator GamblingSessionDelayed(NPC npc, Vector3 position, int bet, float maxDistance, GamblingSessionMode mode, int spinCount, int endTime, float timeBetweenSpins, int startTime)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			TimeManager timeManager = NetworkSingleton<TimeManager>.Instance;
			while ((Object)(object)timeManager != (Object)null && timeManager.CurrentTime < startTime)
			{
				yield return (object)new WaitForSeconds(1f);
			}
			yield return GamblingSession(npc, position, bet, maxDistance, mode, spinCount, endTime, timeBetweenSpins);
		}

		private static IEnumerator GamblingSession(NPC npc, Vector3 position, int bet, float maxDistance, GamblingSessionMode mode, int spinCount, int endTime, float timeBetweenSpins)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			yield return (object)new WaitForSeconds(1f);
			int num;
			if (npc != null)
			{
				NPC s1NPC = npc.S1NPC;
				num = (((Object)(object)((s1NPC != null) ? s1NPC.Inventory : null) != (Object)null) ? 1 : 0);
			}
			else
			{
				num = 0;
			}
			if (num != 0)
			{
				float currentCash = SlotMachineHelper.GetNPCCash(npc);
				NPCInventory inventory = npc.S1NPC.Inventory;
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(inventory, "RandomCash");
				bool enabled = default(bool);
				int num2;
				if (obj is bool)
				{
					enabled = (bool)obj;
					num2 = 1;
				}
				else
				{
					num2 = 0;
				}
				bool randomCash = (byte)((uint)num2 & (enabled ? 1u : 0u)) != 0;
				int randomCashMin = ((global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(inventory, "RandomCashMin") is int min) ? min : 0);
				int randomCashMax = ((global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(inventory, "RandomCashMax") is int max) ? max : 0);
				if (currentCash == 0f && randomCash && randomCashMax > 0)
				{
					int cashToAdd = Random.Range(Mathf.Max(randomCashMin, bet), randomCashMax + 1);
					SlotMachineHelper.AddNPCCash(npc, cashToAdd);
					yield return null;
				}
			}
			int completedSpins = 0;
			TimeManager timeManager = NetworkSingleton<TimeManager>.Instance;
			int loopIteration = 0;
			while (true)
			{
				loopIteration++;
				if (SlotMachineHelper.IsSceneTransitionInProgress)
				{
					break;
				}
				if (npc == null || (Object)(object)npc.gameObject == (Object)null)
				{
					if (!SlotMachineHelper.IsSceneTransitionInProgress)
					{
						Logger.Warning("[" + npc?.ID + "] NPC is null in gambling session loop, breaking");
					}
					break;
				}
				float npcCash = SlotMachineHelper.GetNPCCash(npc);
				int currentTime = (((Object)(object)timeManager != (Object)null) ? timeManager.CurrentTime : (-1));
				if (1 == 0)
				{
				}
				bool flag = mode switch
				{
					GamblingSessionMode.SingleSpin => completedSpins < 1, 
					GamblingSessionMode.SpinCount => completedSpins < spinCount, 
					GamblingSessionMode.UntilTime => (Object)(object)timeManager != (Object)null && currentTime < endTime, 
					GamblingSessionMode.UntilBroke => npcCash >= (float)bet, 
					GamblingSessionMode.UntilTimeOrBroke => (Object)(object)timeManager != (Object)null && currentTime < endTime && npcCash >= (float)bet, 
					_ => false, 
				};
				if (1 == 0)
				{
				}
				if (!flag || npcCash < (float)bet)
				{
					break;
				}
				if (!SlotMachineHelper.UseSlotMachine(npc, position, bet, maxDistance))
				{
					if (SlotMachineHelper.IsSceneTransitionInProgress)
					{
						break;
					}
					Logger.Warning($"[{npc.ID}] Failed to use slot machine (attempt {loopIteration}), will retry in 5s");
					yield return (object)new WaitForSeconds(5f);
				}
				else
				{
					completedSpins++;
					if (mode != GamblingSessionMode.SingleSpin || completedSpins < 1)
					{
						yield return (object)new WaitForSeconds(timeBetweenSpins);
					}
				}
			}
		}
	}
	public sealed class UseVendingMachineSpec : IScheduleActionSpec
	{
		public int StartTime { get; set; }

		public string? MachineGUID { get; set; }

		public string? Name { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			NPCSignal_UseVendingMachine val = schedule.AddActionInternal<NPCSignal_UseVendingMachine>(StartTime, string.IsNullOrEmpty(Name) ? "UseVending" : Name);
			if ((Object)(object)val == (Object)null || string.IsNullOrEmpty(MachineGUID))
			{
				return;
			}
			try
			{
				Guid val2 = default(Guid);
				((Guid)(ref val2))..ctor(MachineGUID);
				VendingMachine machineOverride = GUIDManager.GetObject<VendingMachine>(val2);
				val.MachineOverride = machineOverride;
			}
			catch
			{
			}
		}
	}
	public sealed class WalkToSpec : IScheduleActionSpec
	{
		public Vector3 Destination { get; set; }

		public int StartTime { get; set; }

		public Vector3? Forward { get; set; }

		public bool FaceDestinationDirection { get; set; } = true;

		public float Within { get; set; } = 1f;

		public bool WarpIfSkipped { get; set; } = false;

		public string? Name { get; set; }

		void IScheduleActionSpec.ApplyTo(NPCSchedule schedule)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			NPCSignal_WalkToLocation val = schedule.AddActionInternal<NPCSignal_WalkToLocation>(StartTime, string.IsNullOrEmpty(Name) ? "WalkTo" : Name);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Vector3? forward = null;
			Vector3 value;
			if (Forward.HasValue)
			{
				value = Forward.Value;
				if (((Vector3)(ref value)).sqrMagnitude > 0.001f)
				{
					value = Forward.Value;
					forward = ((Vector3)(ref value)).normalized;
					goto IL_00ea;
				}
			}
			Vector3 position = schedule.NPC.gameObject.transform.position;
			Vector3 val2 = Destination - position;
			if (((Vector3)(ref val2)).sqrMagnitude > 0.001f)
			{
				forward = ((Vector3)(ref val2)).normalized;
			}
			goto IL_00ea;
			IL_00ea:
			Vector3 destination = Destination;
			NavMeshHit val3 = default(NavMeshHit);
			if (NavMesh.SamplePosition(Destination, ref val3, 5f, -1))
			{
				((Vector3)(ref destination))..ctor(Destination.x, ((NavMeshHit)(ref val3)).position.y, Destination.z);
			}
			Transform val4 = NPCDestinationContainer.CreateDestinationMarker(((Object)schedule.NPC.gameObject).name, "Destination", destination, forward);
			if (!((Object)(object)val4 != (Object)null))
			{
				return;
			}
			val.Destination = val4;
			int faceDestinationDir;
			if (Forward.HasValue)
			{
				value = Forward.Value;
				if (((Vector3)(ref value)).sqrMagnitude > 0.001f)
				{
					faceDestinationDir = 1;
					goto IL_01a5;
				}
			}
			faceDestinationDir = (FaceDestinationDirection ? 1 : 0);
			goto IL_01a5;
			IL_01a5:
			val.FaceDestinationDir = (byte)faceDestinationDir != 0;
			val.DestinationThreshold = Mathf.Max(0.01f, Within);
			val.WarpIfSkipped = WarpIfSkipped;
		}
	}
	public sealed class LocationBasedActionSpecBuilder
	{
		private readonly PrefabScheduleBuilder _plan;

		private readonly LocationBasedActionSpec _spec;

		private bool _isCommitted;

		internal LocationBasedActionSpecBuilder(PrefabScheduleBuilder plan, Vector3 destination, int startTime, int durationMinutes)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			_plan = plan;
			_spec = new LocationBasedActionSpec
			{
				Destination = destination,
				StartTime = startTime,
				DurationMinutes = durationMinutes
			};
		}

		public LocationBasedActionSpecBuilder Within(float value)
		{
			_spec.Within = value;
			return this;
		}

		public LocationBasedActionSpecBuilder FaceDestinationDirection(bool value = true)
		{
			_spec.FaceDestinationDirection = value;
			return this;
		}

		public LocationBasedActionSpecBuilder WarpIfSkipped(bool value = true)
		{
			_spec.WarpIfSkipped = value;
			return this;
		}

		public LocationBasedActionSpecBuilder Named(string value)
		{
			_spec.Name = value;
			return this;
		}

		public LocationBasedActionSpecBuilder WithSpraySurfaceInRegion(Region region)
		{
			_spec.GraffitiRegion = region;
			return this;
		}

		public LocationBasedActionSpecBuilder WithSpraySurface(Guid guid)
		{
			_spec.GraffitiSurfaceGuid = guid;
			return this;
		}

		public LocationBasedActionSpecBuilder WithSpraySurface(SpraySurface surface)
		{
			if (surface != null)
			{
				_spec.GraffitiSurfaceGuid = surface.GUID;
			}
			return this;
		}

		public LocationBasedActionSpecBuilder WithItem(EquippablePath equippablePath)
		{
			_spec.EquippableAssetPath = equippablePath.ResourcePath;
			return this;
		}

		public LocationBasedActionSpecBuilder WithDrink(EquippablePath drinkEquippablePath)
		{
			_spec.DrinkEquippablePath = drinkEquippablePath.ResourcePath;
			return this;
		}

		public PrefabScheduleBuilder OnArriveNone()
		{
			return Commit(LocationArriveBehaviour.None);
		}

		public PrefabScheduleBuilder OnArriveSmokeBreak()
		{
			return Commit(LocationArriveBehaviour.SmokeBreak);
		}

		public PrefabScheduleBuilder OnArriveGraffiti()
		{
			return Commit(LocationArriveBehaviour.Graffiti);
		}

		public PrefabScheduleBuilder OnArriveDrinking()
		{
			return Commit(LocationArriveBehaviour.Drinking);
		}

		public PrefabScheduleBuilder OnArriveHoldItem()
		{
			return Commit(LocationArriveBehaviour.HoldItem);
		}

		private PrefabScheduleBuilder Commit(LocationArriveBehaviour arriveBehaviour)
		{
			if (_isCommitted)
			{
				return _plan;
			}
			_spec.ArriveBehaviour = arriveBehaviour;
			_plan.Add(_spec);
			_isCommitted = true;
			return _plan;
		}
	}
	internal static class NPCDestinationContainer
	{
		private const string NPC_CONTAINERS_PATH = "@Managers/@NPCs/NPC Containers";

		public static GameObject? GetOrCreateContainer(string? npcName)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(npcName))
			{
				return null;
			}
			GameObject val = GameObject.Find("@Managers/@NPCs/NPC Containers");
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = GameObject.Find("@Managers");
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = new GameObject("@Managers");
				}
				Transform val3 = val2.transform.Find("@NPCs");
				if ((Object)(object)val3 == (Object)null)
				{
					val3 = new GameObject("@NPCs").transform;
					val3.SetParent(val2.transform);
				}
				val = new GameObject("NPC Containers");
				val.transform.SetParent(val3);
			}
			Transform val4 = val.transform.Find(npcName);
			if ((Object)(object)val4 == (Object)null)
			{
				GameObject val5 = new GameObject(npcName);
				val5.transform.SetParent(val.transform);
				return val5;
			}
			return ((Component)val4).gameObject;
		}

		public static Transform? CreateDestinationMarker(string? npcName, string markerName, Vector3 position, Vector3? forward = null)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0076: 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)
			GameObject orCreateContainer = GetOrCreateContainer(npcName);
			if ((Object)(object)orCreateContainer == (Object)null)
			{
				return null;
			}
			GameObject val = new GameObject(markerName);
			val.transform.SetParent(orCreateContainer.transform);
			val.transform.position = position;
			if (forward.HasValue)
			{
				Vector3 value = forward.Value;
				if (((Vector3)(ref value)).sqrMagnitude > 0.001f)
				{
					Transform transform = val.transform;
					value = forward.Value;
					transform.forward = ((Vector3)(ref value)).normalized;
					goto IL_0098;
				}
			}
			val.transform.forward = Vector3.forward;
			goto IL_0098;
			IL_0098:
			return val.transform;
		}
	}
	public sealed class PrefabScheduleBuilder
	{
		private static readonly Log Logger = new Log("PrefabScheduleBuilder");

		private readonly List<IScheduleActionSpec> _specs = new List<IScheduleActionSpec>();

		internal List<IScheduleActionSpec> Build()
		{
			return _specs;
		}

		public PrefabScheduleBuilder WalkTo(Vector3 destination, int startTime, bool faceDestinationDir = true, float within = 1f, bool warpIfSkipped = false, Vector3? forward = null, string? name = null)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new WalkToSpec
			{
				Destination = destination,
				StartTime = startTime,
				FaceDestinationDirection = faceDestinationDir,
				Within = within,
				WarpIfSkipped = warpIfSkipped,
				Forward = forward,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder SitAtSeatSet(string? seatSetName, int startTime, int durationMinutes = 60, bool warpIfSkipped = false, string? name = null, string? seatSetPath = null)
		{
			if (!string.IsNullOrEmpty(seatSetName) || !string.IsNullOrEmpty(seatSetPath))
			{
				_specs.Add(new SitSpec
				{
					SeatSetName = seatSetName,
					SeatSetPath = seatSetPath,
					StartTime = startTime,
					DurationMinutes = durationMinutes,
					WarpIfSkipped = warpIfSkipped,
					Name = name
				});
			}
			return this;
		}

		[Obsolete("NPCSignal_WaitForDelivery was removed in game version 0.4.6. Use EnsureCustomer(); deal attendance is configured automatically.")]
		public PrefabScheduleBuilder EnsureDealSignal()
		{
			_specs.Add(new EnsureDealSignalSpec());
			return this;
		}

		public PrefabScheduleBuilder Add(IScheduleActionSpec? spec)
		{
			if (spec != null)
			{
				_specs.Add(spec);
			}
			return this;
		}

		public PrefabScheduleBuilder UseVendingMachine(int startTime, string? machineGUID = null, string? name = null)
		{
			_specs.Add(new UseVendingMachineSpec
			{
				StartTime = startTime,
				MachineGUID = machineGUID,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder UseSlotMachine(int startTime, Vector3 machinePosition, int betAmount = 10, GamblingSessionMode sessionMode = GamblingSessionMode.SingleSpin, float maxSearchDistance = 5f, string? name = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new UseSlotMachineSpec
			{
				StartTime = startTime,
				MachinePosition = machinePosition,
				BetAmount = betAmount,
				SessionMode = sessionMode,
				MaxSearchDistance = maxSearchDistance,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder UseSlotMachineMultipleTimes(int startTime, Vector3 machinePosition, int spinCount, int betAmount = 10, float timeBetweenSpins = 10f, float maxSearchDistance = 5f, string? name = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new UseSlotMachineSpec
			{
				StartTime = startTime,
				MachinePosition = machinePosition,
				BetAmount = betAmount,
				SessionMode = GamblingSessionMode.SpinCount,
				SpinCount = spinCount,
				TimeBetweenSpins = timeBetweenSpins,
				MaxSearchDistance = maxSearchDistance,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder UseSlotMachineUntilTime(int startTime, int endTime, Vector3 machinePosition, int betAmount = 10, float timeBetweenSpins = 10f, bool stopIfBroke = true, float maxSearchDistance = 5f, global::S1API.Map.Building? building = null, string? name = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new UseSlotMachineSpec
			{
				StartTime = startTime,
				MachinePosition = machinePosition,
				BetAmount = betAmount,
				SessionMode = (stopIfBroke ? GamblingSessionMode.UntilTimeOrBroke : GamblingSessionMode.UntilTime),
				EndTime = endTime,
				TimeBetweenSpins = timeBetweenSpins,
				MaxSearchDistance = maxSearchDistance,
				Building = building,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder UseSlotMachineUntilBroke(int startTime, Vector3 machinePosition, int betAmount = 10, float timeBetweenSpins = 10f, float maxSearchDistance = 5f, string? name = null)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new UseSlotMachineSpec
			{
				StartTime = startTime,
				MachinePosition = machinePosition,
				BetAmount = betAmount,
				SessionMode = GamblingSessionMode.UntilBroke,
				TimeBetweenSpins = timeBetweenSpins,
				MaxSearchDistance = maxSearchDistance,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder UseATM(int startTime, string? atmGUID = null, string? name = null)
		{
			_specs.Add(new UseATMSpec
			{
				StartTime = startTime,
				ATMGUID = atmGUID,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder LocationDialogue(Vector3 destination, int startTime, bool faceDestinationDir = true, float within = 1f, bool warpIfSkipped = false, int greetingOverrideToEnable = -1, int choiceToEnable = -1, string? name = null)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new LocationDialogueSpec
			{
				Destination = destination,
				Forward = null,
				StartTime = startTime,
				FaceDestinationDirection = faceDestinationDir,
				Within = within,
				WarpIfSkipped = warpIfSkipped,
				GreetingOverrideToEnable = greetingOverrideToEnable,
				ChoiceToEnable = choiceToEnable,
				Name = name
			});
			return this;
		}

		public LocationBasedActionSpecBuilder LocationBased(Vector3 destination, int startTime, int durationMinutes = 60)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return new LocationBasedActionSpecBuilder(this, destination, startTime, durationMinutes);
		}

		[Obsolete("HandleDeal is no longer needed as of game version 0.4.2f4. Deal handling is now automatic through DealerAttendDealBehaviour.")]
		public PrefabScheduleBuilder HandleDeal(int startTime, string? name = null)
		{
			_specs.Add(new HandleDealSpec
			{
				StartTime = startTime,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder StayInBuilding(global::S1API.Map.Building? building, int startTime, int durationMinutes = 60, int? doorIndex = null, string? name = null)
		{
			if (building == null)
			{
				Logger.Error($"StayInBuilding called with null building at time {startTime}. Action will not be added to schedule.");
				return this;
			}
			string name2 = building.Name;
			if (string.IsNullOrEmpty(name2))
			{
				Logger.Error($"StayInBuilding called with building that has null/empty Name at time {startTime}. Building wrapper exists but Name property is invalid.");
				return this;
			}
			_specs.Add(new StayInBuildingSpec
			{
				BuildingName = name2,
				BuildingIdentifierType = building.DeferredIdentifierType,
				StartTime = startTime,
				DurationMinutes = durationMinutes,
				DoorIndex = doorIndex,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder DriveToCarPark(ParkingLotWrapper lot, LandVehicle vehicle, int startTime, ParkingAlignment? alignment = null, bool? overrideParkingType = null, string? name = null)
		{
			_specs.Add(new DriveToCarParkSpec
			{
				StartTime = startTime,
				ParkingLot = lot,
				Vehicle = vehicle,
				Alignment = alignment,
				OverrideParkingType = overrideParkingType,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder DriveToCarPark(string parkingLotGUID, string vehicleGUID, int startTime, ParkingAlignment? alignment = null, bool? overrideParkingType = null, string? name = null)
		{
			_specs.Add(new DriveToCarParkSpec
			{
				StartTime = startTime,
				ParkingLotGUID = parkingLotGUID,
				VehicleGUID = vehicleGUID,
				Alignment = alignment,
				OverrideParkingType = overrideParkingType,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder DriveToCarParkByName(string parkingLotName, string vehicleName, int startTime, ParkingAlignment? alignment = null, bool? overrideParkingType = null, string? name = null)
		{
			_specs.Add(new DriveToCarParkSpec
			{
				StartTime = startTime,
				ParkingLotName = parkingLotName,
				VehicleName = vehicleName,
				Alignment = alignment,
				OverrideParkingType = overrideParkingType,
				Name = name
			});
			return this;
		}

		public PrefabScheduleBuilder DriveToCarParkWithCreateVehicle(string parkingLotName, string vehicleCode, int startTime, Vector3 vehicleSpawnPosition, Quaternion? vehicleSpawnRotation = null, ParkingAlignment? alignment = null, bool? overrideParkingType = null, string? name = null)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			_specs.Add(new DriveToCarParkSpec
			{
				StartTime = startTime,
				ParkingLotName = parkingLotName,
				VehicleCode = vehicleCode,
				VehicleSpawnPosition = vehicleSpawnPosition,
				VehicleSpawnRotation = vehicleSpawnRotation,
				Alignment = alignment,
				OverrideParkingType = overrideParkingType,
				Name = name
			});
			return this;
		}
	}
}
namespace S1API.Entities.Relation
{
	public sealed class NPCRelationshipDataBuilder
	{
		internal sealed class RelationshipDefaultsData
		{
			public float? RelationDelta;

			public bool? Unlocked;

			public NPCRelationship.UnlockType? UnlockType;

			public List<string>? ConnectionIDs;
		}

		private static readonly Log Logger = new Log("NPCRelationshipDataBuilder");

		private float? _relationDelta;

		private bool? _unlocked;

		private NPCRelationship.UnlockType? _unlockType;

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

		public NPCRelationshipDataBuilder WithDelta(float delta)
		{
			_relationDelta = Mathf.Clamp(delta, 0f, 5f);
			return this;
		}

		public NPCRelationshipDataBuilder WithNormalized(float normalized)
		{
			float num = Mathf.Clamp01(normalized);
			_relationDelta = num * 5f;
			return this;
		}

		public NPCRelationshipDataBuilder SetUnlocked(bool unlocked)
		{
			_unlocked = unlocked;
			return this;
		}

		public NPCRelationshipDataBuilder SetUnlockType(NPCRelationship.UnlockType type)
		{
			_unlockType = type;
			return this;
		}

		public NPCRelationshipDataBuilder SetUnlockType(string typeName)
		{
			if (!string.IsNullOrEmpty(typeName) && Enum.TryParse<NPCRelationship.UnlockType>(typeName, ignoreCase: true, out var result))
			{
				_unlockType = result;
			}
			return this;
		}

		public NPCRelationshipDataBuilder WithConnectionsById(IEnumerable<string> ids)
		{
			_connectionIDs.Clear();
			if (ids == null)
			{
				return this;
			}
			int num = 0;
			foreach (string id in ids)
			{
				if (!string.IsNullOrEmpty(id) && !_connectionIDs.Contains<string>(id, StringComparer.OrdinalIgnoreCase))
				{
					_connectionIDs.Add(id);
					num++;
				}
			}
			return this;
		}

		public NPCRelationshipDataBuilder WithConnectionsById(params string[] ids)
		{
			return WithConnectionsById((IEnumerable<string>)ids);
		}

		[Obsolete("Use WithConnections<T1, T2, ...>() or WithConnectionsById instead. NPC instances are not available during prefab configuration.")]
		public NPCRelationshipDataBuilder WithConnections(IEnumerable<NPC?>? npcs)
		{
			Logger.Warning("[Relationship Data] WithConnections(NPC[]) is obsolete. Use WithConnections<T1, T2, ...>() or WithConnectionsById instead to resolve IDs in Menu scene.");
			return WithConnections(npcs?.Select((NPC n) => n?.GetType()).ToArray());
		}

		[Obsolete("Use WithConnections<T1, T2, ...>() or WithConnectionsById instead. NPC instances are not available during prefab configuration.")]
		public NPCRelationshipDataBuilder WithConnections(params NPC?[]? npcs)
		{
			return WithConnections((IEnumerable<NPC?>?)npcs);
		}

		public NPCRelationshipDataBuilder WithConnections<T1, T2>() where T1 : NPC where T2 : NPC
		{
			return WithConnections(typeof(T1), typeof(T2));
		}

		public NPCRelationshipDataBuilder WithConnections<T1, T2, T3>() where T1 : NPC where T2 : NPC where T3 : NPC
		{
			return WithConnections(typeof(T1), typeof(T2), typeof(T3));
		}

		public NPCRelationshipDataBuilder WithConnections(params Type?[]? npcTypes)
		{
			_connectionIDs.Clear();
			if (npcTypes == null || npcTypes.Length == 0)
			{
				return this;
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			foreach (Type type in npcTypes)
			{
				if (type == null)
				{
					num2++;
					Logger.Warning("[Relationship Data] WithConnections: Received null NPC type");
					continue;
				}
				if (!typeof(NPC).IsAssignableFrom(type))
				{
					Logger.Warning("[Relationship Data] WithConnections: Type '" + type.Name + "' is not an NPC type");
					continue;
				}
				string text = NPCTypeUtils.TryGetStaticNPCId(type);
				if (string.IsNullOrEmpty(text) && type.Assembly == typeof(NPCRelationshipDataBuilder).Assembly)
				{
					text = NPCTypeUtils.TryResolveNPCIdFromType(type);
					if (!string.IsNullOrEmpty(text))
					{
						num4++;
					}
				}
				if (string.IsNullOrEmpty(text))
				{
					num3++;
					Logger.Warning("[Relationship Data] WithConnections: Could not resolve ID for NPC type '" + type.Name + "'. Ensure the NPC class has a static NPCId property (e.g., public new static string NPCId => \"npc_id\";)");
				}
				else if (!_connectionIDs.Contains<string>(text, StringComparer.OrdinalIgnoreCase))
				{
					_connectionIDs.Add(text);
					num++;
				}
			}
			return this;
		}

		[HideFromIl2Cpp]
		internal RelationshipDefaultsData CaptureData()
		{
			return new RelationshipDefaultsData
			{
				RelationDelta = _relationDelta,
				Unlocked = _unlocked,
				UnlockType = _unlockType,
				ConnectionIDs = ((_connectionIDs.Count > 0) ? new List<string>(_connectionIDs) : null)
			};
		}

		public void ApplyTo(NPCRelationData relationData, NPC owner, bool preserveUnlockState = false)
		{
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			if (relationData == null)
			{
				return;
			}
			try
			{
				if (_relationDelta.HasValue)
				{
					relationData.SetRelationship(_relationDelta.Value, true);
				}
			}
			catch
			{
			}
			try
			{
				if (_connectionIDs.Count > 0)
				{
					List<NPC> nPCRegistry = NPCManager.NPCRegistry;
					List<NPC> connections = relationData.Connections;
					if (connections != null)
					{
						Enumerator<NPC> enumerator = connections.GetEnumerator();
						while (enumerator.MoveNext())
						{
							NPC current = enumerator.Current;
							object obj2;
							if (current == null)
							{
								obj2 = null;
							}
							else
							{
								NPCRelationData relationData2 = current.RelationData;
								obj2 = ((relationData2 != null) ? relationData2.Connections : null);
							}
							((List<NPC>)obj2)?.Remove(owner);
						}
						int count = connections.Count;
						connections.Clear();
						int num = 0;
						int num2 = 0;
						for (int i = 0; i < _connectionIDs.Count; i++)
						{
							string text = _connectionIDs[i];
							NPC val = null;
							Enumerator<NPC> enumerator2 = nPCRegistry.GetEnumerator();
							while (enumerator2.MoveNext())
							{
								NPC current2 = enumerator2.Current;
								if ((Object)(object)current2 != (Object)null && current2 != owner && string.Equals(current2.ID, text, StringComparison.OrdinalIgnoreCase))
								{
									val = current2;
									break;
								}
							}
							if ((Object)(object)val != (Object)null)
							{
								if (!connections.Contains(val))
								{
									connections.Add(val);
									num++;
								}
								else
								{
									num++;
								}
								NPCRelationData relationData3 = val.RelationData;
								List<NPC> val2 = ((relationData3 != null) ? relationData3.Connections : null);
								if (val2 != null && !val2.Contains(owner))
								{
									val2.Add(owner);
								}
							}
							else
							{
								num2++;
								Logger.Warning($"[Relationship Data] ApplyTo: Connection ID '{text}' not found in NPC registry for NPC '{((owner != null) ? owner.ID : null) ?? "<null>"}'");
							}
						}
					}
					else
					{
						Logger.Warning("[Relationship Data] ApplyTo: Connections list is null for NPC '" + (((owner != null) ? owner.ID : null) ?? "<null>") + "'");
					}
				}
			}
			catch (Exception ex)
			{
				Logger.Error("[Relationship Data] ApplyTo: Exception applying connections to NPC '" + (((owner != null) ? owner.ID : null) ?? "<null>") + "': " + ex.Message);
			}
			try
			{
				if (!preserveUnlockState && _unlocked.HasValue)
				{
					if (_unlocked.Value)
					{
						NPCRelationship.UnlockType t = ((!_unlockType.HasValue) ? NPCRelationship.UnlockType.DirectApproach : _unlockType.Value);
						relationData.Unlock(ToS1(t), false);
					}
					else if (_unlockType.HasValue)
					{
						(typeof(NPCRelationData).GetProperty("UnlockType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetSetMethod(nonPublic: true))?.Invoke(relationData, new object[1] { ToS1(_unlockType.Value) });
					}
				}
				else if (_unlockType.HasValue && !preserveUnlockState)
				{
					(typeof(NPCRelationData).GetProperty("UnlockType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetSetMethod(nonPublic: true))?.Invoke(relationData, new object[1] { ToS1(_unlockType.Value) });
				}
			}
			catch
			{
			}
		}

		private static EUnlockType ToS1(NPCRelationship.UnlockType t)
		{
			return (EUnlockType)((t != NPCRelationship.UnlockType.Recommendation) ? 1 : 0);
		}
	}
}
namespace S1API.Entities.NPCs
{
	public class DanSamwell : NPC
	{
		public new static string NPCId => "dan_samwell";

		internal DanSamwell()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "dan_samwell"))
		{
		}
	}
	public class IgorRomanovich : NPC
	{
		public new static string NPCId => "igor_romanovich";

		internal IgorRomanovich()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "igor_romanovich"))
		{
		}
	}
	public class MannyOakfield : NPC
	{
		public new static string NPCId => "manny_oakfield";

		internal MannyOakfield()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "manny_oakfield"))
		{
		}
	}
	public class OscarHolland : NPC
	{
		public new static string NPCId => "oscar_holland";

		internal OscarHolland()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "oscar_holland"))
		{
		}
	}
	public class StanCarney : NPC
	{
		public new static string NPCId => "stan_carney";

		internal StanCarney()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "stan_carney"))
		{
		}
	}
	public class UncleNelson : NPC
	{
		public new static string NPCId => "uncle_nelson";

		internal UncleNelson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "uncle_nelson"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Westville
{
	public class CharlesRowland : NPC
	{
		public new static string NPCId => "charles_rowland";

		internal CharlesRowland()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "charles_rowland"))
		{
		}
	}
	public class DeanWebster : NPC
	{
		public new static string NPCId => "dean_webster";

		internal DeanWebster()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "dean_webster"))
		{
		}
	}
	public class DorisLubbin : NPC
	{
		public new static string NPCId => "doris_lubbin";

		internal DorisLubbin()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "doris_lubbin"))
		{
		}
	}
	public class GeorgeGreene : NPC
	{
		public new static string NPCId => "george_greene";

		internal GeorgeGreene()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "george_greene"))
		{
		}
	}
	public class JerryMontero : NPC
	{
		public new static string NPCId => "jerry_montero";

		internal JerryMontero()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jerry_montero"))
		{
		}
	}
	public class JoyceBall : NPC
	{
		public new static string NPCId => "joyce_ball";

		internal JoyceBall()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "joyce_ball"))
		{
		}
	}
	public class KeithWagner : NPC
	{
		public new static string NPCId => "keith_wagner";

		internal KeithWagner()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "keith_wagner"))
		{
		}
	}
	public class KimDelaney : NPC
	{
		public new static string NPCId => "kim_delaney";

		internal KimDelaney()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "kim_delaney"))
		{
		}
	}
	public class MegCooley : NPC
	{
		public new static string NPCId => "meg_cooley";

		internal MegCooley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "meg_cooley"))
		{
		}
	}
	public class MollyPresley : NPC
	{
		public new static string NPCId => "molly_presley";

		internal MollyPresley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "molly_presley"))
		{
		}
	}
	public class ShirleyWatts : NPC
	{
		public new static string NPCId => "shirley_watts";

		internal ShirleyWatts()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "shirley_watts"))
		{
		}
	}
	public class TrentSherman : NPC
	{
		public new static string NPCId => "trent_sherman";

		internal TrentSherman()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "trent_sherman"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Uptown
{
	public class FionaHancock : NPC
	{
		public new static string NPCId => "fiona_hancock";

		internal FionaHancock()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "fiona_hancock"))
		{
		}
	}
	public class HerbertBleuball : NPC
	{
		public new static string NPCId => "herbert_bleuball";

		internal HerbertBleuball()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "herbert_bleuball"))
		{
		}
	}
	public class JenHeard : NPC
	{
		public new static string NPCId => "jen_heard";

		internal JenHeard()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jen_heard"))
		{
		}
	}
	public class LeoRivers : NPC
	{
		public new static string NPCId => "leo_rivers";

		internal LeoRivers()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "leo_rivers"))
		{
		}
	}
	public class LilyTurner : NPC
	{
		public new static string NPCId => "lily_turner";

		internal LilyTurner()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "lily_turner"))
		{
		}
	}
	public class MichaelBoog : NPC
	{
		public new static string NPCId => "michael_boog";

		internal MichaelBoog()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "michael_boog"))
		{
		}
	}
	public class PearlMoore : NPC
	{
		public new static string NPCId => "pearl_moore";

		internal PearlMoore()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "pearl_moore"))
		{
		}
	}
	public class RayHoffman : NPC
	{
		public new static string NPCId => "ray_hoffman";

		internal RayHoffman()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "ray_hoffman"))
		{
		}
	}
	public class TobiasWentworth : NPC
	{
		public new static string NPCId => "tobias_wentworth";

		internal TobiasWentworth()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "tobias_wentworth"))
		{
		}
	}
	public class WalterCussler : NPC
	{
		public new static string NPCId => "walter_cussler";

		internal WalterCussler()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "walter_cussler"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Suburbia
{
	public class AlisonKnight : NPC
	{
		public new static string NPCId => "alison_knight";

		internal AlisonKnight()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "alison_knight"))
		{
		}
	}
	public class CarlBundy : NPC
	{
		public new static string NPCId => "carl_bundy";

		internal CarlBundy()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "carl_bundy"))
		{
		}
	}
	public class ChrisSullivan : NPC
	{
		public new static string NPCId => "chris_sullivan";

		internal ChrisSullivan()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "chris_sullivan"))
		{
		}
	}
	public class DennisKennedy : NPC
	{
		public new static string NPCId => "dennis_kennedy";

		internal DennisKennedy()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "dennis_kennedy"))
		{
		}
	}
	public class HankStevenson : NPC
	{
		public new static string NPCId => "hank_stevenson";

		internal HankStevenson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "hank_stevenson"))
		{
		}
	}
	public class HaroldColt : NPC
	{
		public new static string NPCId => "harold_colt";

		internal HaroldColt()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "harold_colt"))
		{
		}
	}
	public class JackieStevenson : NPC
	{
		public new static string NPCId => "jackie_stevenson";

		internal JackieStevenson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jackie_stevenson"))
		{
		}
	}
	public class JackKnight : NPC
	{
		public new static string NPCId => "jack_knight";

		internal JackKnight()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jack_knight"))
		{
		}
	}
	public class JeremyWilkinson : NPC
	{
		public new static string NPCId => "jeremy_wilkinson";

		internal JeremyWilkinson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jeremy_wilkinson"))
		{
		}
	}
	public class KarenKennedy : NPC
	{
		public new static string NPCId => "karen_kennedy";

		internal KarenKennedy()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "karen_kennedy"))
		{
		}
	}
	public class WeiLong : NPC
	{
		public new static string NPCId => "wei_long";

		internal WeiLong()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "wei_long"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.PoliceOfficers
{
	public class OfficerBailey : NPC
	{
		public new static string NPCId => "officerbailey";

		internal OfficerBailey()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officerbailey"))
		{
		}
	}
	public class OfficerCooper : NPC
	{
		public new static string NPCId => "officercooper";

		internal OfficerCooper()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officercooper"))
		{
		}
	}
	public class OfficerGreen : NPC
	{
		public new static string NPCId => "officergreen";

		internal OfficerGreen()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officergreen"))
		{
		}
	}
	public class OfficerHoward : NPC
	{
		public new static string NPCId => "officerhoward";

		internal OfficerHoward()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officerhoward"))
		{
		}
	}
	public class OfficerJackson : NPC
	{
		public new static string NPCId => "officerjackson";

		internal OfficerJackson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officerjackson"))
		{
		}
	}
	public class OfficerLee : NPC
	{
		public new static string NPCId => "officerlee";

		internal OfficerLee()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officerlee"))
		{
		}
	}
	public class OfficerLopez : NPC
	{
		public new static string NPCId => "officerlopez";

		internal OfficerLopez()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officerlopez"))
		{
		}
	}
	public class OfficerMurphy : NPC
	{
		public new static string NPCId => "officermurphy";

		internal OfficerMurphy()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officermurphy"))
		{
		}
	}
	public class OfficerOakley : NPC
	{
		public new static string NPCId => "officeroakley";

		internal OfficerOakley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "officeroakley"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Northtown
{
	public class AlbertHoover : NPC
	{
		public new static string NPCId => "albert_hoover";

		internal AlbertHoover()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "albert_hoover"))
		{
		}
	}
	public class AustinSteiner : NPC
	{
		public new static string NPCId => "austin_steiner";

		internal AustinSteiner()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "austin_steiner"))
		{
		}
	}
	public class BenjiColeman : NPC
	{
		public new static string NPCId => "benji_coleman";

		internal BenjiColeman()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "benji_coleman"))
		{
		}
	}
	public class BethPenn : NPC
	{
		public new static string NPCId => "beth_penn";

		internal BethPenn()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "beth_penn"))
		{
		}
	}
	public class ChloeBowers : NPC
	{
		public new static string NPCId => "chloe_bowers";

		internal ChloeBowers()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "chloe_bowers"))
		{
		}
	}
	public class DonnaMartin : NPC
	{
		public new static string NPCId => "donna_martin";

		internal DonnaMartin()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "donna_martin"))
		{
		}
	}
	public class GeraldinePoon : NPC
	{
		public new static string NPCId => "geraldine_poon";

		internal GeraldinePoon()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "geraldine_poon"))
		{
		}
	}
	public class JessiWaters : NPC
	{
		public new static string NPCId => "jessi_waters";

		internal JessiWaters()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jessi_waters"))
		{
		}
	}
	public class KathyHenderson : NPC
	{
		public new static string NPCId => "kathy_henderson";

		internal KathyHenderson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "kathy_henderson"))
		{
		}
	}
	public class KyleCooley : NPC
	{
		public new static string NPCId => "kyle_cooley";

		internal KyleCooley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "kyle_cooley"))
		{
		}
	}
	public class LudwigMeyer : NPC
	{
		public new static string NPCId => "ludwig_meyer";

		internal LudwigMeyer()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "ludwig_meyer"))
		{
		}
	}
	public class MickLubbin : NPC
	{
		public new static string NPCId => "mick_lubbin";

		internal MickLubbin()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "mick_lubbin"))
		{
		}
	}
	public class Ming : NPC
	{
		public new static string NPCId => "ming";

		internal Ming()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "ming"))
		{
		}
	}
	public class PeggyMyers : NPC
	{
		public new static string NPCId => "peggy_myers";

		internal PeggyMyers()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "peggy_myers"))
		{
		}
	}
	public class PeterFile : NPC
	{
		public new static string NPCId => "peter_file";

		internal PeterFile()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "peter_file"))
		{
		}
	}
	public class SamThompson : NPC
	{
		public new static string NPCId => "sam_thompson";

		internal SamThompson()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "sam_thompson"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Downtown
{
	public class BradCrosby : NPC
	{
		public new static string NPCId => "brad_crosby";

		internal BradCrosby()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "brad_crosby"))
		{
		}
	}
	public class ElizabethHomley : NPC
	{
		public new static string NPCId => "elizabeth_homley";

		internal ElizabethHomley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "elizabeth_homley"))
		{
		}
	}
	public class EugeneBuckley : NPC
	{
		public new static string NPCId => "eugene_buckley";

		internal EugeneBuckley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "eugene_buckley"))
		{
		}
	}
	public class GregFliggle : NPC
	{
		public new static string NPCId => "greg_fliggle";

		internal GregFliggle()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "greg_fliggle"))
		{
		}
	}
	public class JeffGilmore : NPC
	{
		public new static string NPCId => "jeff_gilmore";

		internal JeffGilmore()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jeff_gilmore"))
		{
		}
	}
	public class JenniferRivera : NPC
	{
		public new static string NPCId => "jennifer_rivera";

		internal JenniferRivera()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jennifer_rivera"))
		{
		}
	}
	public class KevinOakley : NPC
	{
		public new static string NPCId => "kevin_oakley";

		internal KevinOakley()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "kevin_oakley"))
		{
		}
	}
	public class LouisFourier : NPC
	{
		public new static string NPCId => "louis_fourier";

		internal LouisFourier()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "louis_fourier"))
		{
		}
	}
	public class LucyPennington : NPC
	{
		public new static string NPCId => "lucy_pennington";

		internal LucyPennington()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "lucy_pennington"))
		{
		}
	}
	public class PhilipWentworth : NPC
	{
		public new static string NPCId => "philip_wentworth";

		internal PhilipWentworth()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "philip_wentworth"))
		{
		}
	}
	public class RandyCaulfield : NPC
	{
		public new static string NPCId => "randy_caulfield";

		internal RandyCaulfield()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "randy_caulfield"))
		{
		}
	}
}
namespace S1API.Entities.NPCs.Docks
{
	public class AnnaChesterfield : NPC
	{
		public new static string NPCId => "anna_chesterfield";

		internal AnnaChesterfield()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "anna_chesterfield"))
		{
		}
	}
	public class BillyKramer : NPC
	{
		public new static string NPCId => "billy_kramer";

		internal BillyKramer()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "billy_kramer"))
		{
		}
	}
	public class CrankyFrank : NPC
	{
		public new static string NPCId => "cranky_frank";

		internal CrankyFrank()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "cranky_frank"))
		{
		}
	}
	public class GenghisBarn : NPC
	{
		public new static string NPCId => "genghis_barn";

		internal GenghisBarn()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "genghis_barn"))
		{
		}
	}
	public class JaneLucero : NPC
	{
		public new static string NPCId => "jane_lucero";

		internal JaneLucero()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "jane_lucero"))
		{
		}
	}
	public class JavierPerez : NPC
	{
		public new static string NPCId => "javier_perez";

		internal JavierPerez()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "javier_perez"))
		{
		}
	}
	public class LisaGardener : NPC
	{
		public new static string NPCId => "lisa_gardener";

		internal LisaGardener()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "lisa_gardener"))
		{
		}
	}
	public class MacCooper : NPC
	{
		public new static string NPCId => "mac_cooper";

		internal MacCooper()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "mac_cooper"))
		{
		}
	}
	public class MarcoBaron : NPC
	{
		public new static string NPCId => "marco_baron";

		internal MarcoBaron()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "marco_baron"))
		{
		}
	}
	public class MelissaWood : NPC
	{
		public new static string NPCId => "melissa_wood";

		internal MelissaWood()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "melissa_wood"))
		{
		}
	}
	public class SalvadorMoreno : NPC
	{
		public new static string NPCId => "salvador_moreno";

		internal SalvadorMoreno()
			: base(((IEnumerable<NPC>)NPCManager.NPCRegistry.ToArray()).First((NPC n) => n.ID == "salvador_moreno"))
		{
		}
	}
}
namespace S1API.Entities.Interfaces
{
	public interface IEntity
	{
		GameObject gameObject { get; }

		Vector3 Position { get; set; }

		float Scale { get; set; }
	}
	public interface IHealth
	{
		float CurrentHealth { get; }

		float MaxHealth { get; set; }

		bool IsDead { get; }

		bool IsInvincible { get; set; }

		event Action OnDeath;

		void Revive();

		void Damage(int amount);

		void Heal(int amount);

		void Kill();
	}
}
namespace S1API.Entities.Impostors
{
	public sealed class AvatarImpostorDefinition
	{
		public string Name { get; }

		public string ResourcePath { get; }

		internal Texture2D Texture { get; }

		internal AvatarImpostorDefinition(string name, string resourcePath, Texture2D texture)
		{
			Name = name;
			ResourcePath = resourcePath;
			Texture = texture;
		}

		public override string ToString()
		{
			return Name + " (" + ResourcePath + ")";
		}
	}
	public static class NPCImpostorCatalog
	{
		public static IReadOnlyList<AvatarImpostorDefinition> GetAll()
		{
			return ImpostorTextureResolver.GetAllDefinitions();
		}

		public static bool TryFind(string name, out AvatarImpostorDefinition? impostor)
		{
			impostor = ImpostorTextureResolver.FindDefinition(name);
			return impostor != null;
		}

		public static AvatarImpostorDefinition? Find(string name)
		{
			return ImpostorTextureResolver.FindDefinition(name);
		}

		public static AvatarImpostorDefinition? GetRandom(int seed)
		{
			IReadOnlyList<AvatarImpostorDefinition> all = GetAll();
			if (all.Count == 0)
			{
				return null;
			}
			int index = new Random(seed).Next(all.Count);
			return all[index];
		}
	}
}
namespace S1API.Entities.Equippables
{
	public readonly struct EquippablePath
	{
		public static readonly EquippablePath Baton = new EquippablePath("Avatar/Equippables/Baton");

		public static readonly EquippablePath Beer = new EquippablePath("Avatar/Equippables/Beer");

		public static readonly EquippablePath Coffee = new EquippablePath("Avatar/Equippables/Coffee");

		public static readonly EquippablePath Cuke = new EquippablePath("Avatar/Equippables/Cuke");

		public static readonly EquippablePath Hammer = new EquippablePath("Avatar/Equippables/Hammer");

		public static readonly EquippablePath Joint = new EquippablePath("Avatar/Equippables/Joint");

		public static readonly EquippablePath Phone_Lowered = new EquippablePath("Avatar/Equippables/Phone_Lowered");

		public static readonly EquippablePath Phone_Raised = new EquippablePath("Avatar/Equippables/Phone_Raised");

		public static readonly EquippablePath Pipe = new EquippablePath("Avatar/Equippables/Pipe");

		public static readonly EquippablePath TrashBag = new EquippablePath("Avatar/Equippables/TrashBag");

		public static readonly EquippablePath BrokenBottle = new EquippablePath("Avatar/Equippables/BrokenBottle");

		public static readonly EquippablePath Knife = new EquippablePath("Avatar/Equippables/Knife");

		public static readonly EquippablePath M1911 = new EquippablePath("Avatar/Equippables/M1911");

		public static readonly EquippablePath PumpShotgun = new EquippablePath("Avatar/Equippables/PumpShotgun");

		public static readonly EquippablePath Revolver = new EquippablePath("Avatar/Equippables/Revolver");

		public static readonly EquippablePath Taser = new EquippablePath("Avatar/Equippables/Taser");

		public static readonly EquippablePath Flashlight = new EquippablePath("Tools/Flashlight/Flashlight_AvatarEquippable");

		public static readonly EquippablePath TrashGrabber = new EquippablePath("Tools/TrashGrabber/TrashGrabber_AvatarEquippable");

		public static readonly EquippablePath WateringCan = new EquippablePath("Tools/WateringCan/WateringCan_AvatarEquippable");

		public static readonly EquippablePath Trimmers = new EquippablePath("Tools/Trimmers/Trimmers_AvatarEquippable");

		public static readonly EquippablePath EnergyDrink = new EquippablePath("ingredients/energydrink/EnergyDrink_AvatarEquippable");

		public static readonly EquippablePath SprayPaint = new EquippablePath("Weapons/SprayPaint/SprayPaint_AvatarEquippable");

		public string ResourcePath { get; }

		private EquippablePath(string path)
		{
			ResourcePath = path ?? string.Empty;
		}

		public static EquippablePath Custom(string resourcePath)
		{
			return new EquippablePath(resourcePath);
		}

		public static implicit operator EquippablePath(string path)
		{
			return new EquippablePath(path ?? string.Empty);
		}

		public override string ToString()
		{
			return ResourcePath;
		}
	}
	public class Misc
	{
		public const string Baton = "Avatar/Equippables/Baton";

		public const string Beer = "Avatar/Equippables/Beer";

		public const string Coffee = "Avatar/Equippables/Coffee";

		public const string Cuke = "Avatar/Equippables/Cuke";

		public const string Hammer = "Avatar/Equippables/Hammer";

		public const string Joint = "Avatar/Equippables/Joint";

		public const string Phone_Lowered = "Avatar/Equippables/Phone_Lowered";

		public const string Phone_Raised = "Avatar/Equippables/Phone_Raised";

		public const string Pipe = "Avatar/Equippables/Pipe";

		public const string TrashBag = "Avatar/Equippables/TrashBag";
	}
	public class Weapon
	{
		public const string BrokenBottle = "Avatar/Equippables/BrokenBottle";

		public const string Knife = "Avatar/Equippables/Knife";

		public const string M1911 = "Avatar/Equippables/M1911";

		public const string PumpShotgun = "Avatar/Equippables/PumpShotgun";

		public const string Revolver = "Avatar/Equippables/Revolver";

		public const string Taser = "Avatar/Equippables/Taser";
	}
}
namespace S1API.Entities.Employees
{
	public static class EmployeeManager
	{
		private static readonly Log Logger = new Log("EmployeeManager");

		public static EmployeeAppearance? GetAppearance(bool male, int index)
		{
			if (!NetworkSingleton<EmployeeManager>.InstanceExists)
			{
				Logger.Error("EmployeeManager instance does not exist; cannot get appearance");
				return null;
			}
			EmployeeAppearance appearance = NetworkSingleton<EmployeeManager>.Instance.GetAppearance(male, index);
			return (appearance == null) ? null : new EmployeeAppearance(appearance);
		}

		public static bool GetRandomAppearance(bool male, out int index, out AvatarSettings? settings)
		{
			if (!NetworkSingleton<EmployeeManager>.InstanceExists)
			{
				settings = null;
				index = -1;
				Logger.Error("EmployeeManager instance does not exist; cannot get random appearance");
				return false;
			}
			int num = default(int);
			AvatarSettings val = default(AvatarSettings);
			NetworkSingleton<EmployeeManager>.Instance.GetRandomAppearance(male, ref num, ref val);
			if ((Object)(object)val == (Object)null)
			{
				settings = null;
				index = -1;
				return false;
			}
			index = num;
			settings = new AvatarSettings(val);
			return true;
		}
	}
	public class EmployeeAppearance
	{
		internal EmployeeAppearance S1EmployeeAppearance;

		public AvatarSettings Settings => new AvatarSettings(S1EmployeeAppearance.Settings);

		public Sprite Mugshot => S1EmployeeAppearance.Mugshot;

		internal EmployeeAppearance(EmployeeAppearance s1EmployeeAppearance)
		{
			S1EmployeeAppearance = s1EmployeeAppearance;
		}
	}
}
namespace S1API.Entities.Dialogue
{
	public sealed class DialogueDatabaseBuilder
	{
		internal sealed class BuildResult
		{
			internal readonly DialogueDatabase Database;

			internal readonly List<ModuleSpec> ModuleSpecs;

			internal BuildResult(DialogueDatabase database, List<ModuleSpec> moduleSpecs)
			{
				Database = database;
				ModuleSpecs = moduleSpecs;
			}
		}

		internal sealed class ModuleSpec
		{
			internal readonly string ModuleName;

			internal readonly List<Entry> Entries;

			internal ModuleSpec(string moduleName, List<Entry> entries)
			{
				ModuleName = moduleName;
				Entries = entries;
			}
		}

		private readonly List<(string key, string[] lines)> _genericEntries = new List<(string, string[])>();

		private readonly Dictionary<string, List<(string key, string[] lines)>> _modules = new Dictionary<string, List<(string, string[])>>(StringComparer.OrdinalIgnoreCase);

		public DialogueDatabaseBuilder WithGeneric(string key, params string[] lines)
		{
			if (!string.IsNullOrEmpty(key) && lines != null)
			{
				_genericEntries.Add((key, lines));
			}
			return this;
		}

		public DialogueDatabaseBuilder WithModuleEntry(string moduleName, string key, params string[] lines)
		{
			if (string.IsNullOrEmpty(moduleName) || string.IsNullOrEmpty(key) || lines == null)
			{
				return this;
			}
			if (!_modules.TryGetValue(moduleName, out List<(string, string[])> value))
			{
				value = new List<(string, string[])>();
				_modules[moduleName] = value;
			}
			value.Add((key, lines));
			return this;
		}

		internal BuildResult BuildInternal()
		{
			//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_0051: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			DialogueDatabase val = ScriptableObject.CreateInstance<DialogueDatabase>();
			List<Entry> list = new List<Entry>();
			foreach (var genericEntry in _genericEntries)
			{
				string item = genericEntry.key;
				string[] item2 = genericEntry.lines;
				DialogueChain val2 = new DialogueChain
				{
					Lines = Il2CppStringArray.op_Implicit(item2 ?? Array.Empty<string>())
				};
				Entry val3 = new Entry();
				val3.Key = item;
				val3.Chains = Il2CppReferenceArray<DialogueChain>.op_Implicit((DialogueChain[])(object)new DialogueChain[1] { val2 });
				list.Add(val3);
			}
			val.GenericEntries = ToIl2CppList(list);
			List<ModuleSpec> list2 = new List<ModuleSpec>();
			foreach (KeyValuePair<string, List<(string, string[])>> module in _modules)
			{
				List<Entry> list3 = new List<Entry>();
				foreach (var item5 in module.Value)
				{
					string item3 = item5.Item1;
					string[] item4 = item5.Item2;
					DialogueChain val4 = new DialogueChain
					{
						Lines = Il2CppStringArray.op_Implicit(item4 ?? Array.Empty<string>())
					};
					Entry val3 = new Entry();
					val3.Key = item3;
					val3.Chains = Il2CppReferenceArray<DialogueChain>.op_Implicit((DialogueChain[])(object)new DialogueChain[1] { val4 });
					list3.Add(val3);
				}
				list2.Add(new ModuleSpec(module.Key, list3));
			}
			return new BuildResult(val, list2);
		}

		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
	public sealed class DialogueContainerBuilder
	{
		public sealed class ChoiceList
		{
			private readonly NodeSpec _node;

			private ChoiceList(NodeSpec node)
			{
				_node = node;
			}

			public ChoiceList Add(string choiceLabel, string shownText, string? targetNodeLabel = null)
			{
				if (string.IsNullOrEmpty(choiceLabel))
				{
					return this;
				}
				ChoiceSpec choiceSpec = _node.AddChoice(choiceLabel, shownText ?? string.Empty);
				if (!string.IsNullOrEmpty(targetNodeLabel))
				{
					_node.Builder._links.Add(new LinkSpec(_node.Label, choiceSpec.Label, targetNodeLabel));
				}
				return this;
			}
		}

		private sealed class NodeSpec
		{
			internal readonly string Guid = System.Guid.NewGuid().ToString();

			internal readonly DialogueContainerBuilder Builder;

			internal readonly List<ChoiceSpec> Choices = new List<ChoiceSpec>();

			internal string Label;

			internal string Text;

			internal NodeSpec(DialogueContainerBuilder builder, string label, string text)
			{
				Builder = builder;
				Label = label;
				Text = text;
			}

			internal ChoiceSpec AddChoice(string label, string text)
			{
				ChoiceSpec choiceSpec = new ChoiceSpec(label, text);
				Choices.Add(choiceSpec);
				return choiceSpec;
			}

			internal ChoiceSpec? GetChoice(string label)
			{
				return Choices.Find((ChoiceSpec x) => string.Equals(x.Label, label, StringComparison.OrdinalIgnoreCase));
			}
		}

		private sealed class ChoiceSpec
		{
			internal readonly string Guid = System.Guid.NewGuid().ToString();

			internal readonly string Label;

			internal readonly string Text;

			internal ChoiceSpec(string label, string text)
			{
				Label = label;
				Text = text;
			}
		}

		private readonly struct LinkSpec
		{
			internal readonly string FromNodeLabel;

			internal readonly string ChoiceLabel;

			internal readonly string ToNodeLabel;

			internal LinkSpec(string from, string choice, string to)
			{
				FromNodeLabel = from;
				ChoiceLabel = choice;
				ToNodeLabel = to;
			}
		}

		private readonly Dictionary<string, NodeSpec> _nodes = new Dictionary<string, NodeSpec>(StringComparer.OrdinalIgnoreCase);

		private readonly List<LinkSpec> _links = new List<LinkSpec>();

		private bool _allowExit = true;

		public DialogueContainerBuilder AddNode(string nodeLabel, string text, Action<ChoiceList>? choices = null)
		{
			if (string.IsNullOrEmpty(nodeLabel))
			{
				return this;
			}
			if (!_nodes.TryGetValue(nodeLabel, out NodeSpec value))
			{
				value = new NodeSpec(this, nodeLabel, text ?? string.Empty);
				_nodes[nodeLabel] = value;
			}
			else
			{
				value.Text = text ?? string.Empty;
			}
			if (choices != null && typeof(ChoiceList).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[1] { typeof(NodeSpec) }, null)?.Invoke(new object[1] { value }) is ChoiceList obj)
			{
				choices(obj);
			}
			return this;
		}

		public DialogueContainerBuilder SetAllowExit(bool allow)
		{
			_allowExit = allow;
			return this;
		}

		internal DialogueContainer Build(string containerName)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			DialogueContainer val = ScriptableObject.CreateInstance<DialogueContainer>();
			((Object)val).name = (string.IsNullOrEmpty(containerName) ? "CustomContainer" : containerName);
			List<DialogueNodeData> list = new List<DialogueNodeData>();
			foreach (KeyValuePair<string, NodeSpec> node in _nodes)
			{
				NodeSpec value = node.Value;
				DialogueNodeData item = new DialogueNodeData
				{
					Guid = value.Guid,
					DialogueNodeLabel = value.Label,
					DialogueText = value.Text,
					Position = Vector2.zero,
					choices = Il2CppReferenceArray<DialogueChoiceData>.op_Implicit(BuildChoices(value))
				};
				list.Add(item);
			}
			val.DialogueNodeData = ToIl2CppList(list);
			List<NodeLinkData> list2 = new List<NodeLinkData>();
			foreach (LinkSpec link in _links)
			{
				if (_nodes.TryGetValue(link.FromNodeLabel, out NodeSpec value2))
				{
					ChoiceSpec choice = value2.GetChoice(link.ChoiceLabel);
					if (choice != null && _nodes.TryGetValue(link.ToNodeLabel, out NodeSpec value3))
					{
						list2.Add(new NodeLinkData
						{
							BaseDialogueOrBranchNodeGuid = value2.Guid,
							BaseChoiceOrOptionGUID = choice.Guid,
							TargetNodeGuid = value3.Guid
						});
					}
				}
			}
			val.NodeLinks = ToIl2CppList(list2);
			val.SetAllowExit(_allowExit);
			return val;
		}

		private static DialogueChoiceData[] BuildChoices(NodeSpec node)
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			List<DialogueChoiceData> list = new List<DialogueChoiceData>();
			foreach (ChoiceSpec choice in node.Choices)
			{
				list.Add(new DialogueChoiceData
				{
					Guid = choice.Guid,
					ChoiceLabel = choice.Label,
					ChoiceText = choice.Text,
					ShowWorldspaceDialogue = true
				});
			}
			return list.ToArray();
		}

		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
}
namespace S1API.Entities.Dealer
{
	public sealed class DealerDataBuilder
	{
		internal class DealerConfigData
		{
			public float SigningFee { get; set; } = 500f;

			public float Cut { get; set; } = 0.2f;

			public DealerType DealerType { get; set; } = DealerType.PlayerDealer;

			public string HomeName { get; set; } = "Home";

			public global::S1API.Map.Building? Home { get; set; } = null;

			public bool SellInsufficientQualityItems { get; set; } = false;

			public bool SellExcessQualityItems { get; set; } = true;

			public string CompletedDealsVariable { get; set; } = string.Empty;

			public List<DealerRecommendationBuilder.RecommendationConfigData> Recommendations { get; } = new List<DealerRecommendationBuilder.RecommendationConfigData>();
		}

		private readonly DealerConfigData _data;

		internal DealerDataBuilder()
		{
			_data = new DealerConfigData();
		}

		public DealerDataBuilder WithSigningFee(float fee)
		{
			_data.SigningFee = Mathf.Max(0f, fee);
			return this;
		}

		public DealerDataBuilder WithCut(float percentage)
		{
			_data.Cut = Mathf.Clamp01(percentage);
			return this;
		}

		public DealerDataBuilder WithDealerType(DealerType type)
		{
			_data.DealerType = type;
			return this;
		}

		public DealerDataBuilder WithHomeName(string name)
		{
			_data.HomeName = name ?? "Home";
			return this;
		}

		public DealerDataBuilder WithHome(global::S1API.Map.Building building)
		{
			_data.Home = building;
			if (building != null)
			{
				_data.HomeName = building.Name;
			}
			return this;
		}

		public DealerDataBuilder AllowInsufficientQuality(bool allow)
		{
			_data.SellInsufficientQualityItems = allow;
			return this;
		}

		public DealerDataBuilder AllowExcessQuality(bool allow)
		{
			_data.SellExcessQualityItems = allow;
			return this;
		}

		public DealerDataBuilder WithCompletedDealsVariable(string varName)
		{
			_data.CompletedDealsVariable = varName ?? string.Empty;
			return this;
		}

		public DealerDataBuilder WithRecommendation(Action<DealerRecommendationBuilder> configure)
		{
			if (configure == null)
			{
				return this;
			}
			DealerRecommendationBuilder dealerRecommendationBuilder = new DealerRecommendationBuilder();
			configure(dealerRecommendationBuilder);
			DealerRecommendationBuilder.RecommendationConfigData recommendationConfigData = dealerRecommendationBuilder.BuildInternal();
			if (!string.IsNullOrWhiteSpace(recommendationConfigData.CustomerId) && recommendationConfigData.RecommendationTrigger.HasValue)
			{
				_data.Recommendations.Add(recommendationConfigData);
			}
			return this;
		}

		internal DealerConfigData BuildInternal()
		{
			return _data;
		}
	}
	public sealed class DealerRecommendationBuilder
	{
		internal enum Trigger
		{
			DealCompleted
		}

		internal sealed class RecommendationConfigData
		{
			public string CustomerId { get; set; } = string.Empty;

			public Trigger? RecommendationTrigger { get; set; }
		}

		private readonly RecommendationConfigData _data;

		internal DealerRecommendationBuilder()
		{
			_data = new RecommendationConfigData();
		}

		public DealerRecommendationBuilder FromCustomer(NPC customer)
		{
			_data.CustomerId = customer?.ID ?? string.Empty;
			return this;
		}

		public DealerRecommendationBuilder FromCustomer(string customerId)
		{
			_data.CustomerId = customerId ?? string.Empty;
			return this;
		}

		public DealerRecommendationBuilder FromCustomer<TCustomer>() where TCustomer : NPC
		{
			_data.CustomerId = NPCTypeUtils.TryGetStaticNPCId(typeof(TCustomer)) ?? NPCTypeUtils.TryResolveNPCIdFromType(typeof(TCustomer)) ?? string.Empty;
			return this;
		}

		public DealerRecommendationBuilder OnDealCompleted()
		{
			_data.RecommendationTrigger = Trigger.DealCompleted;
			return this;
		}

		internal RecommendationConfigData BuildInternal()
		{
			return _data;
		}
	}
}
namespace S1API.Entities.Customer
{
	public sealed class CustomerDataBuilder
	{
		private readonly CustomerData _data;

		internal CustomerDataBuilder()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			_data = ScriptableObject.CreateInstance<CustomerData>();
			_data.DefaultAffinityData = new CustomerAffinityData();
		}

		public CustomerDataBuilder WithSpending(float minWeekly, float maxWeekly)
		{
			_data.MinWeeklySpend = Mathf.Max(0f, minWeekly);
			_data.MaxWeeklySpend = Mathf.Max(_data.MinWeeklySpend, maxWeekly);
			return this;
		}

		public CustomerDataBuilder WithOrdersPerWeek(int min, int max)
		{
			_data.MinOrdersPerWeek = Mathf.Clamp(min, 0, 7);
			_data.MaxOrdersPerWeek = Mathf.Clamp(Mathf.Max(min, max), 0, 7);
			return this;
		}

		public CustomerDataBuilder WithPreferredOrderDay(string day)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(day) && Enum.TryParse<EDay>(day, ignoreCase: true, out EDay result))
			{
				_data.PreferredOrderDay = result;
			}
			return this;
		}

		public CustomerDataBuilder WithPreferredOrderDay(Day day)
		{
			_data.PreferredOrderDay = (EDay)day;
			return this;
		}

		public CustomerDataBuilder WithOrderTime(int hhmm)
		{
			_data.OrderTime = Mathf.Clamp(hhmm, 0, 2359);
			return this;
		}

		public CustomerDataBuilder WithStandards(string standards)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(standards) && Enum.TryParse<ECustomerStandard>(standards, ignoreCase: true, out ECustomerStandard result))
			{
				_data.Standards = result;
			}
			return this;
		}

		public CustomerDataBuilder WithStandards(CustomerStandard standards)
		{
			_data.Standards = (ECustomerStandard)standards;
			return this;
		}

		public CustomerDataBuilder AllowDirectApproach(bool allow)
		{
			_data.CanBeDirectlyApproached = allow;
			return this;
		}

		public CustomerDataBuilder GuaranteeFirstSample(bool guarantee)
		{
			_data.GuaranteeFirstSampleSuccess = guarantee;
			return this;
		}

		public CustomerDataBuilder WithMutualRelationRequirement(float minAt50, float maxAt100)
		{
			_data.MinMutualRelationRequirement = Mathf.Clamp(minAt50, 0f, 5f);
			_data.MaxMutualRelationRequirement = Mathf.Clamp(maxAt100, 0f, 5f);
			return this;
		}

		public CustomerDataBuilder WithCallPoliceChance(float chance)
		{
			_data.CallPoliceChance = Mathf.Clamp01(chance);
			return this;
		}

		public CustomerDataBuilder WithDependence(float baseAddiction, float dependenceMultiplier = 1f)
		{
			_data.BaseAddiction = Mathf.Clamp01(baseAddiction);
			_data.DependenceMultiplier = Mathf.Clamp(dependenceMultiplier, 0f, 2f);
			return this;
		}

		public CustomerDataBuilder WithAffinities(IEnumerable<(string drugType, float affinity)> entries)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			_data.DefaultAffinityData = new CustomerAffinityData();
			Array values = Enum.GetValues(typeof(EDrugType));
			foreach (object item in values)
			{
				_data.DefaultAffinityData.ProductAffinities.Add(new ProductTypeAffinity
				{
					DrugType = (EDrugType)item,
					Affinity = 0f
				});
			}
			if (entries != null)
			{
				foreach (var (value, num) in entries)
				{
					if (string.IsNullOrEmpty(value) || !Enum.TryParse<EDrugType>(value, ignoreCase: true, out EDrugType result))
					{
						continue;
					}
					ProductTypeAffinity val = null;
					Enumerator<ProductTypeAffinity> enumerator3 = _data.DefaultAffinityData.ProductAffinities.GetEnumerator();
					while (enumerator3.MoveNext())
					{
						ProductTypeAffinity current2 = enumerator3.Current;
						if (current2 != null && current2.DrugType == result)
						{
							val = current2;
							break;
						}
					}
					if (val != null)
					{
						val.Affinity = Mathf.Clamp(num, -1f, 1f);
					}
				}
			}
			return this;
		}

		public CustomerDataBuilder WithAffinities(IEnumerable<(DrugType drugType, float affinity)> entries)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			_data.DefaultAffinityData = new CustomerAffinityData();
			Array values = Enum.GetValues(typeof(EDrugType));
			foreach (object item3 in values)
			{
				_data.DefaultAffinityData.ProductAffinities.Add(new ProductTypeAffinity
				{
					DrugType = (EDrugType)item3,
					Affinity = 0f
				});
			}
			if (entries != null)
			{
				foreach (var entry in entries)
				{
					DrugType item = entry.drugType;
					float item2 = entry.affinity;
					EDrugType val = (EDrugType)item;
					ProductTypeAffinity val2 = null;
					Enumerator<ProductTypeAffinity> enumerator3 = _data.DefaultAffinityData.ProductAffinities.GetEnumerator();
					while (enumerator3.MoveNext())
					{
						ProductTypeAffinity current3 = enumerator3.Current;
						if (current3 != null && current3.DrugType == val)
						{
							val2 = current3;
							break;
						}
					}
					if (val2 != null)
					{
						val2.Affinity = Mathf.Clamp(item2, -1f, 1f);
					}
				}
			}
			return this;
		}

		public CustomerDataBuilder WithAffinity(DrugType drugType, float affinity)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			if (_data.DefaultAffinityData == null)
			{
				_data.DefaultAffinityData = new CustomerAffinityData();
			}
			ProductTypeAffinity val = null;
			Enumerator<ProductTypeAffinity> enumerator = _data.DefaultAffinityData.ProductAffinities.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ProductTypeAffinity current = enumerator.Current;
				if (current != null && (int)current.DrugType == (int)drugType)
				{
					val = current;
					break;
				}
			}
			if (val == null)
			{
				_data.DefaultAffinityData.ProductAffinities.Add(new ProductTypeAffinity
				{
					DrugType = (EDrugType)drugType,
					Affinity = Mathf.Clamp(affinity, -1f, 1f)
				});
			}
			else
			{
				val.Affinity = Mathf.Clamp(affinity, -1f, 1f);
			}
			return this;
		}

		public CustomerDataBuilder WithPreferredPropertiesByName(params string[] propertyNames)
		{
			if (propertyNames == null || propertyNames.Length == 0)
			{
				return this;
			}
			List<Effect> list = new List<Effect>();
			string[] array = new string[5] { "Properties/Tier1", "Properties/Tier2", "Properties/Tier3", "Properties/Tier4", "Properties/Tier5" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				Il2CppArrayBase<Effect> val = Resources.LoadAll<Effect>(text);
				if (val == null || val.Length == 0)
				{
					continue;
				}
				foreach (string text2 in propertyNames)
				{
					if (string.IsNullOrEmpty(text2))
					{
						continue;
					}
					Effect val2 = null;
					foreach (Effect item in val)
					{
						if ((Object)(object)item != (Object)null && string.Equals(((Object)item).name, text2, StringComparison.OrdinalIgnoreCase))
						{
							val2 = item;
							break;
						}
					}
					if ((Object)(object)val2 != (Object)null && !list.Contains(val2))
					{
						list.Add(val2);
					}
				}
			}
			_data.PreferredProperties = ToIl2CppList(list);
			return this;
		}

		public CustomerDataBuilder WithPreferredPropertiesById(params string[] propertyIds)
		{
			if (propertyIds == null || propertyIds.Length == 0)
			{
				return this;
			}
			List<Effect> list = new List<Effect>();
			string[] array = new string[5] { "Properties/Tier1", "Properties/Tier2", "Properties/Tier3", "Properties/Tier4", "Properties/Tier5" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				Il2CppArrayBase<Effect> val = Resources.LoadAll<Effect>(text);
				if (val == null || val.Length == 0)
				{
					continue;
				}
				foreach (string text2 in propertyIds)
				{
					if (string.IsNullOrEmpty(text2))
					{
						continue;
					}
					Effect val2 = null;
					foreach (Effect item in val)
					{
						if ((Object)(object)item != (Object)null && string.Equals(item.ID, text2, StringComparison.OrdinalIgnoreCase))
						{
							val2 = item;
							break;
						}
					}
					if ((Object)(object)val2 != (Object)null && !list.Contains(val2))
					{
						list.Add(val2);
					}
				}
			}
			_data.PreferredProperties = ToIl2CppList(list);
			return this;
		}

		public CustomerDataBuilder WithPreferredProperties(params ProductPropertyWrapper[] wrappers)
		{
			if (wrappers == null || wrappers.Length == 0)
			{
				return this;
			}
			List<Effect> list = new List<Effect>();
			foreach (ProductPropertyWrapper productPropertyWrapper in wrappers)
			{
				if (productPropertyWrapper != null)
				{
					Effect innerProperty = productPropertyWrapper.InnerProperty;
					if ((Object)(object)innerProperty != (Object)null && !list.Contains(innerProperty))
					{
						list.Add(innerProperty);
					}
				}
			}
			_data.PreferredProperties = ToIl2CppList(list);
			return this;
		}

		public CustomerDataBuilder WithPreferredProperties(params PropertyBase[] properties)
		{
			if (properties == null || properties.Length == 0)
			{
				return this;
			}
			List<Effect> source = PropertyResolver.ResolveToGameProperties(properties);
			_data.PreferredProperties = ToIl2CppList(source);
			return this;
		}

		internal CustomerData BuildInternal()
		{
			return _data;
		}

		private static List<T> ToIl2CppList<T>(List<T> source)
		{
			List<T> val = new List<T>();
			if (source == null)
			{
				return val;
			}
			for (int i = 0; i < source.Count; i++)
			{
				val.Add(source[i]);
			}
			return val;
		}
	}
}
namespace S1API.Entities.Behaviour
{
	public class CombatBehaviour
	{
		private static readonly Log Logger = new Log("CombatBehaviour");

		internal readonly NPC NPC;

		public float GiveUpRange
		{
			get
			{
				return NPC.S1NPC.Behaviour.CombatBehaviour.GiveUpRange;
			}
			set
			{
				NPC.S1NPC.Behaviour.CombatBehaviour.GiveUpRange = value;
			}
		}

		public float GiveUpTime
		{
			get
			{
				return NPC.S1NPC.Behaviour.CombatBehaviour.DefaultSearchTime;
			}
			set
			{
				NPC.S1NPC.Behaviour.CombatBehaviour.DefaultSearchTime = value;
			}
		}

		public string DefaultWeaponAssetPath
		{
			get
			{
				object? obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(NPC.S1NPC.Behaviour.CombatBehaviour, "DefaultWeapon");
				AvatarWeapon val = (AvatarWeapon)(((obj is AvatarWeapon) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
				return ((val != null) ? ((AvatarEquippable)val).AssetPath : null) ?? string.Empty;
			}
			set
			{
				if (string.IsNullOrEmpty(value))
				{
					SetDefaultWeaponInternal(null);
					return;
				}
				Object obj = Resources.Load(value);
				if (!CrossType.Is<GameObject>((object)obj, out GameObject result) || (Object)(object)result == (Object)null)
				{
					Logger.Error("Could not find weapon at path: " + value);
					return;
				}
				AvatarEquippable val = result.GetComponent<AvatarEquippable>() ?? result.GetComponentInChildren<AvatarEquippable>(true);
				AvatarWeapon result2;
				if ((Object)(object)val == (Object)null)
				{
					Logger.Error("Could not get AvatarEquippable from weapon at path: " + value);
				}
				else if (!CrossType.Is<AvatarWeapon>((object)val, out result2))
				{
					Logger.Error("AvatarEquippable at path is not an AvatarWeapon: " + value);
				}
				else
				{
					SetDefaultWeaponInternal(result2);
				}
			}
		}

		internal CombatBehaviour(NPC npc)
		{
			NPC = npc;
		}

		private void SetDefaultWeaponInternal(AvatarWeapon? weapon)
		{
			CombatBehaviour combatBehaviour = NPC.S1NPC.Behaviour.CombatBehaviour;
			MethodInfo method = ((object)combatBehaviour).GetType().GetMethod("SetDefaultWeapon", BindingFlags.Instance | BindingFlags.Public);
			if (method != null)
			{
				method.Invoke(combatBehaviour, new object[1] { weapon });
			}
			else if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(combatBehaviour, "DefaultWeapon", weapon))
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(combatBehaviour, "_defaultWeapon", weapon);
			}
		}

		public void SetAndAttackTarget(IEntity target)
		{
			NetworkObject component = target.gameObject.GetComponent<NetworkObject>();
			NPC.S1NPC.Behaviour.CombatBehaviour.SetTargetAndEnable_Server(component);
		}

		public void SetCurrentWeapon(string weaponPath)
		{
			NPC.S1NPC.Behaviour.CombatBehaviour.SetWeapon(weaponPath);
		}

		public void SetCurrentWeapon(Equippable equippable)
		{
			if (equippable == null)
			{
				Debug.LogError(Object.op_Implicit("Cannot set weapon: Equippable is null"));
				return;
			}
			string assetPathFromEquippable = GetAssetPathFromEquippable(equippable);
			if (string.IsNullOrEmpty(assetPathFromEquippable))
			{
				Debug.LogError(Object.op_Implicit("Cannot set weapon: Could not extract asset path from Equippable"));
			}
			else
			{
				SetCurrentWeapon(assetPathFromEquippable);
			}
		}

		public void SetDefaultWeapon(Equippable equippable)
		{
			if (equippable == null)
			{
				Debug.LogError(Object.op_Implicit("Cannot set default weapon: Equippable is null"));
				return;
			}
			string assetPathFromEquippable = GetAssetPathFromEquippable(equippable);
			if (string.IsNullOrEmpty(assetPathFromEquippable))
			{
				Debug.LogError(Object.op_Implicit("Cannot set default weapon: Could not extract asset path from Equippable"));
			}
			else
			{
				DefaultWeaponAssetPath = assetPathFromEquippable;
			}
		}

		public void SetCurrentWeapon(EquippableBuilder equippableBuilder)
		{
			if (equippableBuilder == null)
			{
				Debug.LogError(Object.op_Implicit("Cannot set weapon: EquippableBuilder is null"));
				return;
			}
			Equippable currentWeapon = equippableBuilder.Build();
			SetCurrentWeapon(currentWeapon);
		}

		public void SetDefaultWeapon(EquippableBuilder equippableBuilder)
		{
			if (equippableBuilder == null)
			{
				Debug.LogError(Object.op_Implicit("Cannot set default weapon: EquippableBuilder is null"));
				return;
			}
			Equippable defaultWeapon = equippableBuilder.Build();
			SetDefaultWeapon(defaultWeapon);
		}

		private string? GetAssetPathFromEquippable(Equippable equippable)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			if ((Object)(object)equippable?.S1Equippable == (Object)null)
			{
				return null;
			}
			GameObject gameObject = ((Component)equippable.S1Equippable).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return null;
			}
			AvatarEquippable val = gameObject.GetComponent<AvatarEquippable>();
			if ((Object)(object)val == (Object)null)
			{
				val = gameObject.GetComponentInChildren<AvatarEquippable>();
			}
			if ((Object)(object)val == (Object)null)
			{
				IEnumerator enumerator = gameObject.transform.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						Transform val2 = (Transform)enumerator.Current;
						val = ((Component)val2).GetComponent<AvatarEquippable>();
						if ((Object)(object)val != (Object)null)
						{
							break;
						}
					}
				}
				finally
				{
					if (enumerator is IDisposable disposable)
					{
						disposable.Dispose();
					}
				}
			}
			return (val != null) ? val.AssetPath : null;
		}
	}
}
namespace S1API.Entities.Appearances.FaceLayerFields
{
	public class Eyes : BaseFaceAppearance
	{
		public const string EyeShadow = "Avatar/Layers/Face/EyeShadow";

		public const string Freckles = "Avatar/Layers/Face/Freckles";

		public const string OldPersonWrinkles = "Avatar/Layers/Face/OldPersonWrinkles";

		public const string TiredEyes = "Avatar/Layers/Face/TiredEyes";
	}
	public class Face : BaseFaceAppearance
	{
		public const string Agape = "Avatar/Layers/Face/Face_Agape";

		public const string Agitated = "Avatar/Layers/Face/Face_Agitated";

		public const string FrownPout = "Avatar/Layers/Face/Face_FrownPout";

		public const string Neutral = "Avatar/Layers/Face/Face_Neutral";

		public const string NeutralPout = "Avatar/Layers/Face/Face_NeutralPout";

		public const string OpenMouthSmile = "Avatar/Layers/Face/Face_OpenMouthSmile";

		public const string Scared = "Avatar/Layers/Face/Face_Scared";

		public const string SlightFrown = "Avatar/Layers/Face/Face_SlightFrown";

		public const string SlightSmile = "Avatar/Layers/Face/Face_SlightSmile";

		public const string Smile = "Avatar/Layers/Face/Face_Smile";

		public const string SmugPout = "Avatar/Layers/Face/Face_SmugPout";

		public const string Surprised = "Avatar/Layers/Face/Face_Surprised";

		public const string FaceTattoos1 = "Avatar/Layers/Face/FaceTattoos1";
	}
	public class FaceTattoos : BaseFaceAppearance
	{
		public const string ForeheadCross = "Avatar/Layers/Tattoos/face/Face_ForeheadCross";

		public const string Sword = "Avatar/Layers/Tattoos/face/Face_Sword";

		public const string Teardrop = "Avatar/Layers/Tattoos/face/Face_Teardrop";

		public const string Tribal = "Avatar/Layers/Tattoos/face/Face_Tribal";
	}
	public class FacialHair : BaseFaceAppearance
	{
		public const string Goatee = "Avatar/Layers/Face/FacialHair_Goatee";

		public const string Stubble = "Avatar/Layers/Face/FacialHair_Stubble";

		public const string Swirl = "Avatar/Layers/Face/FacialHair_Swirl";
	}
}
namespace S1API.Entities.Appearances.CustomizationFields
{
	public class EyeBallTint : BaseAppearance
	{
	}
	public class EyebrowRestingAngle : BaseAppearance
	{
	}
	public class EyebrowRestingHeight : BaseAppearance
	{
	}
	public class EyebrowScale : BaseAppearance
	{
	}
	public class EyebrowThickness : BaseAppearance
	{
	}
	public class EyeLidRestingStateLeft : BaseAppearance
	{
	}
	public class EyeLidRestingStateRight : BaseAppearance
	{
	}
	public class Gender : BaseAppearance
	{
	}
	public class HairColor : BaseAppearance
	{
	}
	public class HairStyle : BaseAppearance
	{
		public const string Afro = "Avatar/Hair/afro/Afro";

		public const string Balding = "Avatar/Hair/balding/Balding";

		public const string BowlCut = "Avatar/Hair/bowlcut/BowlCut";

		public const string Bun = "Avatar/Hair/bun/Bun";

		public const string BuzzCut = "Avatar/Hair/buzzcut/BuzzCut";

		public const string DoubleTopKnot = "Avatar/Hair/doubletopknot/DoubleTopKnot";

		public const string Franklin = "Avatar/Hair/franklin/Franklin";

		public const string FringePonyTail = "Avatar/Hair/fringeponytail/FringePonyTail";

		public const string HighBun = "Avatar/Hair/highbun/HighBun";

		[Obsolete("The Jesus hairstyle was removed in game version 0.4.6 and now resolves to no hair.")]
		public const string Jesus = "";

		public const string LongCurly = "Avatar/Hair/longcurly/LongCurly";

		public const string LongSlicked = "Avatar/Hair/longslicked/LongSlicked";

		public const string LowBun = "Avatar/Hair/lowbun/LowBun";

		public const string MessyBob = "Avatar/Hair/messybob/MessyBob";

		public const string MidFringe = "Avatar/Hair/midfringe/MidFringe";

		public const string Mohawk = "Avatar/Hair/mohawk/Mohawk";

		public const string Monk = "Avatar/Hair/monk/Monk";

		public const string Peaked = "Avatar/Hair/peaked/Peaked";

		public const string Receding = "Avatar/Hair/receding/Receding";

		public const string ShoulderLength = "Avatar/Hair/shoulderlength/ShoulderLength";

		public const string SidePartBob = "Avatar/Hair/sidepartbob/SidePartBob";

		public const string Spiky = "Avatar/Hair/spiky/Spiky";

		public const string CloseBuzzCut = "Avatar/Hair/closebuzzcut/CloseBuzzCut";

		public const string Tony = "Avatar/Hair/tony/Tony";
	}
	public class Height : BaseAppearance
	{
	}
	public class PupilDilation : BaseAppearance
	{
	}
	public class SkinColor : BaseAppearance
	{
	}
	public class Weight : BaseAppearance
	{
	}
}
namespace S1API.Entities.Appearances.BodyLayerFields
{
	public class Accessories : BaseBodyAppearance
	{
		public const string FingerlessGloves = "Avatar/Layers/Accessories/FingerlessGloves";

		public const string Gloves = "Avatar/Layers/Accessories/Gloves";
	}
	public class ChestTattoos : BaseBodyAppearance
	{
		public const string Bird = "Avatar/Layers/Tattoos/chest/Chest_Bird";

		public const string DeadFace = "Avatar/Layers/Tattoos/chest/Chest_DeadFace";

		public const string Egg = "Avatar/Layers/Tattoos/chest/Chest_Egg";

		public const string LBC = "Avatar/Layers/Tattoos/chest/Chest_LBC";

		public const string Sword = "Avatar/Layers/Tattoos/chest/Chest_Sword";

		public const string UpperBody = "Avatar/Layers/Tattoos/UpperBodyTattoos";
	}
	public class LeftArmTattoos : BaseBodyAppearance
	{
		public const string Alien = "Avatar/Layers/Tattoos/leftarm/LeftArm_Alien";

		public const string Heart = "Avatar/Layers/Tattoos/leftarm/LeftArm_Heart";

		public const string Peace = "Avatar/Layers/Tattoos/leftarm/LeftArm_Peace";

		public const string Web = "Avatar/Layers/Tattoos/leftarm/LeftArm_Web";

		public const string Weed = "Avatar/Layers/Tattoos/leftarm/LeftArm_Weed";
	}
	public class Pants : BaseBodyAppearance
	{
		public const string CargoPants = "Avatar/Layers/Bottom/CargoPants";

		public const string FemaleUnderwear = "Avatar/Layers/Bottom/FemaleUnderwear";

		public const string Jeans = "Avatar/Layers/Bottom/Jeans";

		public const string Jorts = "Avatar/Layers/Bottom/Jorts";

		public const string MaleUnderwear = "Avatar/Layers/Bottom/MaleUnderwear";
	}
	public class RightArmTattoos : BaseBodyAppearance
	{
		public const string Alien = "Avatar/Layers/Tattoos/rightarm/RightArm_Alien";

		public const string Heart = "Avatar/Layers/Tattoos/rightarm/RightArm_Heart";

		public const string Peace = "Avatar/Layers/Tattoos/rightarm/RightArm_Peace";

		public const string Web = "Avatar/Layers/Tattoos/rightarm/RightArm_Web";

		public const string Weed = "Avatar/Layers/Tattoos/rightarm/RightArm_Weed";
	}
	public class Shirts : BaseBodyAppearance
	{
		public const string Buttonup = "Avatar/Layers/Top/Buttonup";

		public const string ChestHair = "Avatar/Layers/Top/ChestHair1";

		public const string FastFoodTShirt = "Avatar/Layers/Top/FastFood T-Shirt";

		public const string FlannelButtonUp = "Avatar/Layers/Top/FlannelButtonUp";

		public const string GasStationTShirt = "Avatar/Layers/Top/GasStation T-Shirt";

		public const string HazmatSuit = "Avatar/Layers/Top/HazmatSuit";

		public const string Nipples = "Avatar/Layers/Top/Nipples";

		public const string Overalls = "Avatar/Layers/Top/Overalls";

		public const string RolledButtonUp = "Avatar/Layers/Top/RolledButtonUp";

		public const string TShirt = "Avatar/Layers/Top/T-Shirt";

		public const string TuckedTShirt = "Avatar/Layers/Top/Tucked T-Shirt";

		public const string UpperBodyTattoos = "Avatar/Layers/Top/UpperBodyTattoos";

		public const string VNeck = "Avatar/Layers/Top/V-Neck";
	}
}
namespace S1API.Entities.Appearances.Base
{
	public class BaseAccessoryAppearance
	{
		internal static List<string> GetConstPaths<T>() where T : BaseAccessoryAppearance
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetConstStringFields(typeof(T));
		}
	}
	public class BaseAppearance
	{
		internal static List<string> GetConstPaths<T>() where T : BaseAppearance
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetConstStringFields(typeof(T));
		}
	}
	public class BaseBodyAppearance
	{
		internal static List<string> GetConstPaths<T>() where T : BaseBodyAppearance
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetConstStringFields(typeof(T));
		}
	}
	public class BaseFaceAppearance
	{
		internal static List<string> GetConstPaths<T>() where T : BaseFaceAppearance
		{
			return global::S1API.Internal.Utils.ReflectionUtils.GetConstStringFields(typeof(T));
		}
	}
}
namespace S1API.Entities.Appearances.AccessoryFields
{
	public class Bottom : BaseAccessoryAppearance
	{
		public const string LongSkirt = "Avatar/Accessories/Bottom/LongSkirt/LongSkirt";

		public const string MediumSkirt = "Avatar/Accessories/Bottom/MediumSkirt/MediumSkirt";
	}
	public class Chest : BaseAccessoryAppearance
	{
		public const string Blazer = "Avatar/Accessories/Chest/Blazer/Blazer";

		public const string BulletProofVest = "Avatar/Accessories/Chest/BulletProofVest/BulletProofVest";

		public const string BulletProofVestPolice = "Avatar/Accessories/Chest/BulletProofVest/BulletProofVest_Police";

		public const string CollarJacket = "Avatar/Accessories/Chest/CollarJacket/CollarJacket";

		public const string OpenVest = "Avatar/Accessories/Chest/OpenVest/OpenVest";
	}
	public class FacialHairAccessory : BaseAccessoryAppearance
	{
		public const string Chevron = "Avatar/Accessories/FacialHair/Chevron/Chevron";
	}
	public class Feet : BaseAccessoryAppearance
	{
		public const string CombatBoots = "Avatar/Accessories/Feet/CombatBoots/CombatBoots";

		public const string DressShoes = "Avatar/Accessories/Feet/DressShoes/DressShoes";

		public const string Flats = "Avatar/Accessories/Feet/Flats/Flats";

		public const string Sandals = "Avatar/Accessories/Feet/Sandals/Sandals";

		public const string Sneakers = "Avatar/Accessories/Feet/Sneakers/Sneakers";
	}
	public class Hands : BaseAccessoryAppearance
	{
		public const string Polex = "Avatar/Accessories/Hands/Polex/Polex";
	}
	public class Head : BaseAccessoryAppearance
	{
		public const string BucketHat = "Avatar/Accessories/Head/BucketHat/BucketHat";

		public const string Cap = "Avatar/Accessories/Head/Cap/Cap";

		public const string CapFastFood = "Avatar/Accessories/Head/Cap/Cap_FastFood";

		public const string ChefHat = "Avatar/Accessories/Head/ChefHat/ChefHat";

		public const string CowboyHat = "Avatar/Accessories/Head/CowboyHat/CowboyHat";

		public const string FlatCap = "Avatar/Accessories/Head/FlatCap/FlatCap";

		public const string LegendSunglasses = "Avatar/Accessories/Head/LegendSunglasses/LegendSunglasses";

		public const string Oakleys = "Avatar/Accessories/Head/Oakleys/Oakleys";

		public const string PoliceCap = "Avatar/Accessories/Head/PoliceCap/PoliceCap";

		public const string PorkpieHat = "Avatar/Accessories/Head/PorkpieHat/PorkpieHat";

		public const string RectangleFrameGlasses = "Avatar/Accessories/Head/RectangleFrameGlasses/RectangleFrameGlasses";

		public const string Respirator = "Avatar/Accessories/Head/Respirator/Respirator";

		public const string SaucePan = "Avatar/Accessories/Head/SaucePan/SaucePan";

		public const string SmallRoundGlasses = "Avatar/Accessories/Head/SmallRoundGlasses/SmallRoundGlasses";

		public const string Beanie = "Avatar/Accessories/Head/Beanie/Beanie";

		public const string TrashCrown = "Avatar/Accessories/Head/TrashCrown/TrashCrown";

		public const string SantaHat = "Avatar/Accessories/Head/SantaHat/SantaHat";

		public const string MushroomHat = "Avatar/Accessories/Head/MushroomHat/MushroomHat";
	}
	public class Neck : BaseAccessoryAppearance
	{
		public const string GoldChain = "Avatar/Accessories/Neck/GoldChain/GoldChain";
	}
	public class Waist : BaseAccessoryAppearance
	{
		public const string Apron = "Avatar/Accessories/Waist/Apron/Apron";

		public const string Belt = "Avatar/Accessories/Waist/Belt/Belt";

		public const string HazmatSuit = "Avatar/Accessories/Waist/HazmatSuit/HazmatSuit";

		public const string PoliceBelt = "Avatar/Accessories/Waist/PoliceBelt/PoliceBelt";

		public const string PriestGown = "Avatar/Accessories/Waist/PriestGown/PriestGown";
	}
}
namespace S1API.Entities.Actions
{
	public sealed class NPCDrinking
	{
		internal readonly NPC NPC;

		public bool IsActive
		{
			get
			{
				DrinkItem component = GetComponent();
				return (Object)(object)component != (Object)null && component.active;
			}
		}

		internal NPCDrinking(NPC npc)
		{
			NPC = npc;
		}

		private DrinkItem? GetComponent()
		{
			NPC nPC = NPC;
			object result;
			if (nPC == null)
			{
				result = null;
			}
			else
			{
				NPC s1NPC = nPC.S1NPC;
				result = ((s1NPC != null) ? ((Component)s1NPC).GetComponentInChildren<DrinkItem>(true) : null);
			}
			return (DrinkItem?)result;
		}

		public void Begin()
		{
			DrinkItem component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.Begin();
			}
		}

		public void End()
		{
			DrinkItem component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.End();
			}
		}
	}
	public sealed class NPCItemHolding
	{
		internal readonly NPC NPC;

		public bool IsActive
		{
			get
			{
				HoldItem component = GetComponent();
				return (Object)(object)component != (Object)null && component.active;
			}
		}

		internal NPCItemHolding(NPC npc)
		{
			NPC = npc;
		}

		private HoldItem? GetComponent()
		{
			NPC nPC = NPC;
			object result;
			if (nPC == null)
			{
				result = null;
			}
			else
			{
				NPC s1NPC = nPC.S1NPC;
				result = ((s1NPC != null) ? ((Component)s1NPC).GetComponentInChildren<HoldItem>(true) : null);
			}
			return (HoldItem?)result;
		}

		public void Begin()
		{
			HoldItem component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.Begin();
			}
		}

		public void End()
		{
			HoldItem component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.End();
			}
		}
	}
	public sealed class NPCSmoking
	{
		internal readonly NPC NPC;

		private bool _isActive;

		public bool IsActive => _isActive;

		internal NPCSmoking(NPC npc)
		{
			NPC = npc;
		}

		private SmokeCigarette? GetComponent()
		{
			NPC nPC = NPC;
			object result;
			if (nPC == null)
			{
				result = null;
			}
			else
			{
				NPC s1NPC = nPC.S1NPC;
				result = ((s1NPC != null) ? ((Component)s1NPC).GetComponentInChildren<SmokeCigarette>(true) : null);
			}
			return (SmokeCigarette?)result;
		}

		private bool EnsureConfigured(SmokeCigarette comp)
		{
			if ((Object)(object)NPC?.S1NPC == (Object)null)
			{
				return false;
			}
			comp._npc = NPC.S1NPC;
			if ((Object)(object)comp._cigarette == (Object)null)
			{
				comp._cigarette = ResolveCigaretteData();
			}
			return (Object)(object)comp._npc != (Object)null && (Object)(object)comp._cigarette != (Object)null;
		}

		private static EquippableData ResolveCigaretteData()
		{
			return Resources.Load<EquippableData>("equippables/cigarette/Cigarette");
		}

		private void SetActive(bool value)
		{
			_isActive = value;
		}

		public void Begin()
		{
			SmokeCigarette component = GetComponent();
			if ((Object)(object)component != (Object)null && EnsureConfigured(component))
			{
				component.Begin();
				SetActive(value: true);
			}
		}

		public void End()
		{
			SmokeCigarette component = GetComponent();
			if ((Object)(object)component != (Object)null && _isActive)
			{
				component.End();
				SetActive(value: false);
			}
		}
	}
	public sealed class NPCSprayPainting
	{
		internal readonly NPC NPC;

		private bool _isActive;

		public bool IsActive => _isActive;

		internal NPCSprayPainting(NPC npc)
		{
			NPC = npc;
		}

		private SprayPaint? GetComponent()
		{
			NPC nPC = NPC;
			object result;
			if (nPC == null)
			{
				result = null;
			}
			else
			{
				NPC s1NPC = nPC.S1NPC;
				result = ((s1NPC != null) ? ((Component)s1NPC).GetComponentInChildren<SprayPaint>(true) : null);
			}
			return (SprayPaint?)result;
		}

		private void SetActive(bool value)
		{
			_isActive = value;
		}

		public void Begin()
		{
			SprayPaint component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.Begin();
				SetActive(value: true);
			}
		}

		public void End()
		{
			SprayPaint component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.End();
				SetActive(value: false);
			}
		}

		public void SetEffect(bool enabled, Color color = default(Color))
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			SprayPaint component = GetComponent();
			if ((Object)(object)component != (Object)null)
			{
				component.SetEffect(enabled, color);
			}
		}
	}
}
namespace S1API.Economy
{
	public sealed class Contract
	{
		internal readonly Contract S1Contract;

		public float Payment => S1Contract.Payment;

		public int WindowStartTime => (S1Contract.DeliveryWindow != null) ? S1Contract.DeliveryWindow.WindowStartTime : 0;

		public int WindowEndTime => (S1Contract.DeliveryWindow != null) ? S1Contract.DeliveryWindow.WindowEndTime : 0;

		public int TotalQuantity
		{
			get
			{
				int num = 0;
				ProductList productList = S1Contract.ProductList;
				if (productList != null && productList.entries != null)
				{
					for (int i = 0; i < productList.entries.Count; i++)
					{
						num += Math.Max(0, productList.entries[i].Quantity);
					}
				}
				return num;
			}
		}

		internal Contract(Contract contract)
		{
			S1Contract = contract ?? throw new ArgumentNullException("contract");
		}

		public IEnumerable<(string productId, int quantity, Quality minQuality)> GetOrders()
		{
			ProductList list = S1Contract.ProductList;
			if (list != null && list.entries != null)
			{
				for (int i = 0; i < list.entries.Count; i++)
				{
					Entry e = list.entries[i];
					yield return (productId: e.ProductID, quantity: Math.Max(0, e.Quantity), minQuality: e.Quality.ToAPI());
				}
			}
		}
	}
	public sealed class ContractInfo
	{
		public sealed class OrderLine
		{
			public string ProductId { get; set; } = string.Empty;

			public int Quantity { get; set; }

			public Quality MinQuality { get; set; }
		}

		public float Payment { get; set; }

		public List<OrderLine> Orders { get; } = new List<OrderLine>();

		public string DeliveryLocationGuid { get; set; } = string.Empty;

		public (int startTime, int endTime)? DeliveryWindow { get; set; }

		public bool IsCounterOffer { get; set; }

		public bool Expires { get; set; } = true;

		public int ExpiresAfterMinutes { get; set; } = 600;

		public int PickupScheduleIndex { get; set; } = 0;

		public ContractInfo AddProduct(ProductDefinition definition, int quantity, Quality minQuality)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			return AddProductById(definition.ID, quantity, minQuality);
		}

		public ContractInfo AddProductById(string productId, int quantity, Quality minQuality)
		{
			if (string.IsNullOrWhiteSpace(productId))
			{
				throw new ArgumentException("Product ID cannot be empty", "productId");
			}
			Orders.Add(new OrderLine
			{
				ProductId = productId,
				Quantity = Math.Max(1, quantity),
				MinQuality = minQuality
			});
			return this;
		}

		public ContractInfo WithWindow(int startTime, int endTime)
		{
			DeliveryWindow = (ClampTime(startTime), ClampTime(endTime));
			return this;
		}

		private static int ClampTime(int hhmm)
		{
			if (hhmm < 0)
			{
				return 0;
			}
			if (hhmm > 2359)
			{
				return 2359;
			}
			return hhmm;
		}

		internal ContractInfo ToInternal()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0075: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			ProductList val = new ProductList();
			for (int i = 0; i < Orders.Count; i++)
			{
				OrderLine orderLine = Orders[i];
				val.entries.Add(new Entry
				{
					ProductID = orderLine.ProductId,
					Quantity = Math.Max(1, orderLine.Quantity),
					Quality = orderLine.MinQuality.ToInternal()
				});
			}
			QuestWindowConfig val2 = new QuestWindowConfig
			{
				IsEnabled = DeliveryWindow.HasValue,
				WindowStartTime = (DeliveryWindow?.startTime ?? 0),
				WindowEndTime = (DeliveryWindow?.endTime ?? 0)
			};
			return new ContractInfo(Math.Max(0f, Payment), val, DeliveryLocationGuid ?? string.Empty, val2, Expires, Math.Max(0, ExpiresAfterMinutes), Math.Max(0, PickupScheduleIndex), IsCounterOffer);
		}
	}
	public sealed class ContractInfoBuilder
	{
		private float _payment;

		private readonly List<ContractInfo.OrderLine> _orders = new List<ContractInfo.OrderLine>();

		private DeliveryLocation? _deliveryLocation;

		private (int startTime, int endTime)? _deliveryWindow;

		private bool _isCounterOffer;

		private bool _expires = true;

		private int _expiresAfterMinutes = 600;

		private int _pickupScheduleIndex = 0;

		public ContractInfoBuilder WithPayment(float payment)
		{
			_payment = Math.Max(0f, payment);
			return this;
		}

		public ContractInfoBuilder AddProduct(ProductDefinition definition, int quantity, Quality minQuality)
		{
			if (definition == null)
			{
				throw new ArgumentNullException("definition");
			}
			_orders.Add(new ContractInfo.OrderLine
			{
				ProductId = definition.ID,
				Quantity = Math.Max(1, quantity),
				MinQuality = minQuality
			});
			return this;
		}

		public ContractInfoBuilder AddProducts(IEnumerable<(ProductDefinition definition, int quantity, Quality minQuality)> products)
		{
			if (products == null)
			{
				return this;
			}
			foreach (var (definition, quantity, minQuality) in products)
			{
				AddProduct(definition, quantity, minQuality);
			}
			return this;
		}

		public ContractInfoBuilder WithDeliveryLocation(DeliveryLocation location)
		{
			_deliveryLocation = location;
			return this;
		}

		public ContractInfoBuilder WithDeliveryLocationByName(string locationName)
		{
			_deliveryLocation = DeliveryLocation.GetByName(locationName);
			return this;
		}

		public ContractInfoBuilder WithDeliveryLocationByGuid(string locationGuid)
		{
			_deliveryLocation = DeliveryLocation.GetByGuid(locationGuid);
			return this;
		}

		public ContractInfoBuilder WithDeliveryWindow(int startTime, int endTime)
		{
			_deliveryWindow = (ClampTime(startTime), ClampTime(endTime));
			return this;
		}

		public ContractInfoBuilder WithDeliveryWindow(TimeSpan startTime, TimeSpan endTime)
		{
			int startTime2 = (int)(startTime.TotalHours * 100.0) + startTime.Minutes;
			int endTime2 = (int)(endTime.TotalHours * 100.0) + endTime.Minutes;
			return WithDeliveryWindow(startTime2, endTime2);
		}

		public ContractInfoBuilder WithoutDeliveryWindow()
		{
			_deliveryWindow = null;
			return this;
		}

		public ContractInfoBuilder AsCounterOffer(bool isCounterOffer = true)
		{
			_isCounterOffer = isCounterOffer;
			return this;
		}

		public ContractInfoBuilder WithExpiration(bool expires)
		{
			_expires = expires;
			return this;
		}

		public ContractInfoBuilder ExpiresAfter(int minutes)
		{
			_expiresAfterMinutes = Math.Max(0, minutes);
			return this;
		}

		public ContractInfoBuilder WithPickupScheduleIndex(int index)
		{
			_pickupScheduleIndex = Math.Max(0, index);
			return this;
		}

		public static ContractInfo QuickContract(ProductDefinition definition, int quantity, float payment, Quality minQuality = Quality.Standard)
		{
			return new ContractInfoBuilder().WithPayment(payment).AddProduct(definition, quantity, minQuality).Build();
		}

		public ContractInfo Build()
		{
			if (_orders.Count == 0)
			{
				throw new InvalidOperationException("Contract must have at least one product");
			}
			ContractInfo contractInfo = new ContractInfo
			{
				Payment = _payment,
				DeliveryLocationGuid = (_deliveryLocation?.GUID ?? string.Empty),
				DeliveryWindow = _deliveryWindow,
				IsCounterOffer = _isCounterOffer,
				Expires = _expires,
				ExpiresAfterMinutes = _expiresAfterMinutes,
				PickupScheduleIndex = _pickupScheduleIndex
			};
			foreach (ContractInfo.OrderLine order in _orders)
			{
				contractInfo.Orders.Add(order);
			}
			return contractInfo;
		}

		private static int ClampTime(int hhmm)
		{
			if (hhmm < 0)
			{
				return 0;
			}
			if (hhmm > 2359)
			{
				return 2359;
			}
			return hhmm;
		}
	}
	public sealed class ContractReceipt
	{
		public int ReceiptId { get; set; } = -1;

		public string CustomerId { get; set; } = string.Empty;

		public float AmountPaid { get; set; } = 0f;

		public (int days, int time) CompletionTime { get; set; } = (days: 0, time: 0);

		public (string id, int quantity)[] Items { get; set; } = Array.Empty<(string, int)>();
	}
	public enum CustomerStandard
	{
		VeryLow,
		Low,
		Moderate,
		High,
		VeryHigh
	}
	public enum DealerType
	{
		PlayerDealer,
		CartelDealer
	}
}
namespace S1API.Doors
{
	public enum DoorAccess
	{
		Open,
		ExitOnly,
		EnterOnly,
		Closed
	}
	public sealed class DoorController
	{
		private readonly DoorController _controller;

		internal DoorController Controller => _controller;

		public DoorAccess PlayerAccess
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected I4, but got Unknown
				return (DoorAccess)_controller.PlayerAccess;
			}
			set
			{
				_controller.PlayerAccess = (EDoorAccess)value;
			}
		}

		public bool IsOpen => _controller.IsOpen;

		public bool AutoOpenForPlayer
		{
			get
			{
				return _controller.AutoOpenForPlayer;
			}
			set
			{
				_controller.AutoOpenForPlayer = value;
			}
		}

		public bool OpenableByNPCs
		{
			get
			{
				object obj = global::S1API.Internal.Utils.ReflectionUtils.TryGetFieldOrProperty(_controller, "OpenableByNPCs");
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			set
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(_controller, "OpenableByNPCs", value);
			}
		}

		public event Action<DoorSide>? OnDoorOpened;

		public event Action? OnDoorOpenedAny;

		public event Action? OnDoorClosed;

		public DoorController(GameObject gameObject)
		{
			_controller = gameObject.GetComponent<DoorController>();
			if ((Object)(object)_controller == (Object)null)
			{
				throw new ArgumentException("GameObject '" + ((Object)gameObject).name + "' does not contain a DoorController component");
			}
			SubscribeToEvents();
		}

		private void SubscribeToEvents()
		{
			global::S1API.Utils.EventHelper.AddListener<EDoorSide>(HandleDoorOpened, _controller.onDoorOpened);
			global::S1API.Utils.EventHelper.AddListener(HandleDoorClosed, _controller.onDoorClosed);
		}

		private void HandleDoorOpened(EDoorSide side)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected I4, but got Unknown
			this.OnDoorOpened?.Invoke((DoorSide)side);
			this.OnDoorOpenedAny?.Invoke();
		}

		private void HandleDoorClosed()
		{
			this.OnDoorClosed?.Invoke();
		}

		public void SetIsOpen(bool open, DoorSide side)
		{
			_controller.SetIsOpen(open, (EDoorSide)side);
		}
	}
	public enum DoorSide
	{
		Interior,
		Exterior
	}
}
namespace S1API.Dialogues
{
	public static class DialogueChoiceListener
	{
		private static string? _expectedChoiceLabel;

		private static Action? _callback;

		internal static void ResetState()
		{
			_expectedChoiceLabel = null;
			_callback = null;
		}

		public static void Register(DialogueHandler handlerRef, string label, Action action)
		{
			_expectedChoiceLabel = label;
			_callback = action;
			if (!((Object)(object)handlerRef != (Object)null))
			{
				return;
			}
			handlerRef.onDialogueChoiceChosen.AddListener(UnityAction<string>.op_Implicit((Action<string>)delegate(string choice)
			{
				if (choice == _expectedChoiceLabel)
				{
					UnityAction.op_Implicit((Action)ForwardCall).Invoke();
				}
			}));
			static void ForwardCall()
			{
				OnChoice();
			}
		}

		private static void OnChoice()
		{
			_callback?.Invoke();
		}
	}
	public static class DialogueChoicePaging
	{
		private static readonly Log Logger = new Log("S1API.DialogueChoicePaging");

		private const string HarmonyId = "S1API.DialogueChoicePaging";

		private static bool _enabled;

		private static bool _patched;

		private static DialogueChoicePagingOptions _options = new DialogueChoicePagingOptions();

		private static DialogueHandler? _handler;

		private static DialogueNodeData? _node;

		private static string? _text;

		private static List<DialogueChoiceData>? _fullChoices;

		private static int _pageIndex;

		private static int _pageCount;

		public static bool IsEnabled => _enabled;

		private static bool PagingActive => _enabled && _fullChoices != null && _pageCount > 1;

		public static void Enable(DialogueChoicePagingOptions options)
		{
			_options = (options ?? new DialogueChoicePagingOptions()).Normalize();
			_enabled = true;
			EnsurePatched();
		}

		public static void Disable()
		{
			_enabled = false;
			ClearPaging();
		}

		private static int ClampInt(int value, int min, int max)
		{
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		private static void EnsurePatched()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			if (_patched)
			{
				return;
			}
			try
			{
				Harmony val = new Harmony("S1API.DialogueChoicePaging");
				Type typeFromHandle = typeof(DialogueCanvas);
				MethodInfo method = global::S1API.Utils.ReflectionUtils.GetMethod(typeFromHandle, "DisplayDialogueNode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo method2 = global::S1API.Utils.ReflectionUtils.GetMethod(typeFromHandle, "ChoiceSelected", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo method3 = global::S1API.Utils.ReflectionUtils.GetMethod(typeFromHandle, "EndDialogue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				MethodInfo method4 = global::S1API.Utils.ReflectionUtils.GetMethod(typeFromHandle, "IsChoiceValid", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method == null || method2 == null || method3 == null || method4 == null)
				{
					Logger.Warning("DialogueCanvas methods not found; paging will be unavailable.");
					return;
				}
				HarmonyMethod val2 = new HarmonyMethod(typeof(DialogueChoicePaging).GetMethod("DisplayDialogueNodePrefix", BindingFlags.Static | BindingFlags.NonPublic));
				HarmonyMethod val3 = new HarmonyMethod(typeof(DialogueChoicePaging).GetMethod("DisplayDialogueNodePostfix", BindingFlags.Static | BindingFlags.NonPublic));
				val.Patch((MethodBase)method, val2, val3, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				HarmonyMethod val4 = new HarmonyMethod(typeof(DialogueChoicePaging).GetMethod("ChoiceSelectedPrefix", BindingFlags.Static | BindingFlags.NonPublic));
				val.Patch((MethodBase)method2, val4, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				HarmonyMethod val5 = new HarmonyMethod(typeof(DialogueChoicePaging).GetMethod("EndDialoguePostfix", BindingFlags.Static | BindingFlags.NonPublic));
				val.Patch((MethodBase)method3, (HarmonyMethod)null, val5, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				HarmonyMethod val6 = new HarmonyMethod(typeof(DialogueChoicePaging).GetMethod("IsChoiceValidPrefix", BindingFlags.Static | BindingFlags.NonPublic));
				val.Patch((MethodBase)method4, val6, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_patched = true;
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to patch DialogueCanvas for paging: " + ex.Message);
			}
		}

		private static bool IsChoiceValidPrefix(int choiceIndex, ref string reason, ref bool __result)
		{
			try
			{
				if (!PagingActive)
				{
					return true;
				}
				if ((Object)(object)_handler == (Object)null || _fullChoices == null)
				{
					return true;
				}
				if (IsMoreIndex(choiceIndex))
				{
					reason = string.Empty;
					__result = true;
					return false;
				}
				int count = _fullChoices.Count;
				int num = _pageIndex * _options.ChoicesPerPage;
				int val = Math.Max(0, count - num);
				int num2 = Math.Min(_options.ChoicesPerPage, val);
				if (choiceIndex < 0 || choiceIndex >= num2)
				{
					reason = string.Empty;
					__result = false;
					return false;
				}
				int num3 = num + choiceIndex;
				List<DialogueChoiceData> currentChoices = _handler.CurrentChoices;
				if (currentChoices == null || num3 < 0 || num3 >= currentChoices.Count)
				{
					reason = string.Empty;
					__result = false;
					return false;
				}
				DialogueChoiceData val2 = currentChoices[num3];
				string text = ((val2 != null) ? val2.ChoiceLabel : null) ?? string.Empty;
				if (string.IsNullOrWhiteSpace(text))
				{
					reason = string.Empty;
					__result = false;
					return false;
				}
				string text2 = default(string);
				bool flag = _handler.CheckChoice(text, ref text2);
				reason = text2;
				__result = flag;
				return false;
			}
			catch
			{
				return true;
			}
		}

		private static bool IsMoreIndex(int choiceIndex)
		{
			if (!PagingActive)
			{
				return false;
			}
			if (_fullChoices == null)
			{
				return false;
			}
			int count = _fullChoices.Count;
			int num = _pageIndex * _options.ChoicesPerPage;
			int val = Math.Max(0, count - num);
			int num2 = Math.Min(_options.ChoicesPerPage, val);
			int num3 = num2;
			return choiceIndex == num3;
		}

		private static void DisplayDialogueNodePrefix(DialogueHandler diag, DialogueNodeData node, string dialogueText, ref List<DialogueChoiceData> choices)
		{
			try
			{
				if (!_enabled)
				{
					return;
				}
				if (choices == null || choices.Count <= _options.MaxVisibleChoices)
				{
					ClearPagingIfNewNode(diag, node);
					return;
				}
				if ((Object)(object)_handler != (Object)(object)diag || _node != node)
				{
					_handler = diag;
					_node = node;
					_text = dialogueText;
					_pageIndex = 0;
					_fullChoices = CopyList(choices);
					_pageCount = ComputePageCount(_fullChoices.Count);
				}
				else
				{
					_text = dialogueText;
					if (_fullChoices == null || _fullChoices.Count != choices.Count)
					{
						_fullChoices = CopyList(choices);
						_pageCount = ComputePageCount(_fullChoices.Count);
						_pageIndex = ClampInt(_pageIndex, 0, Math.Max(0, _pageCount - 1));
					}
				}
				if (PagingActive)
				{
					choices = BuildPageChoices(_fullChoices, _pageIndex, _pageCount);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Dialogue choice paging DisplayDialogueNodePrefix failed: " + ex.Message);
			}
		}

		private static void DisplayDialogueNodePostfix(DialogueHandler diag)
		{
			try
			{
				if (PagingActive && !((Object)(object)_handler != (Object)(object)diag))
				{
					diag.CurrentChoices = _fullChoices;
				}
			}
			catch
			{
			}
		}

		private static bool ChoiceSelectedPrefix(DialogueCanvas __instance, ref int choiceIndex)
		{
			try
			{
				if (!PagingActive)
				{
					return true;
				}
				if ((Object)(object)__instance == (Object)null)
				{
					return true;
				}
				if (_fullChoices == null || (Object)(object)_handler == (Object)null || _node == null || _text == null)
				{
					return true;
				}
				int count = _fullChoices.Count;
				int num = _pageIndex * _options.ChoicesPerPage;
				int val = Math.Max(0, count - num);
				int num2 = Math.Min(_options.ChoicesPerPage, val);
				int num3 = num2;
				if (choiceIndex == num3)
				{
					_pageIndex = NextPageIndex(_pageIndex, _pageCount, _options.WrapPages);
					__instance.SkipNextRollout = true;
					__instance.DisplayDialogueNode(_handler, _node, _text, _fullChoices);
					return false;
				}
				if (choiceIndex < 0 || choiceIndex >= num2)
				{
					return true;
				}
				choiceIndex = num + choiceIndex;
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("Dialogue choice paging ChoiceSelectedPrefix failed: " + ex.Message);
				return true;
			}
		}

		private static int NextPageIndex(int currentPageIndex, int pageCount, bool wrap)
		{
			if (pageCount <= 1)
			{
				return 0;
			}
			int num = currentPageIndex + 1;
			if (num < pageCount)
			{
				return num;
			}
			return (!wrap) ? currentPageIndex : 0;
		}

		private static void EndDialoguePostfix()
		{
			ClearPaging();
		}

		private static void ClearPagingIfNewNode(DialogueHandler diag, DialogueNodeData node)
		{
			if ((Object)(object)_handler != (Object)(object)diag || _node != node)
			{
				ClearPaging();
			}
		}

		private static void ClearPaging()
		{
			_handler = null;
			_node = null;
			_text = null;
			_fullChoices = null;
			_pageIndex = 0;
			_pageCount = 0;
		}

		private static int ComputePageCount(int totalChoices)
		{
			if (totalChoices <= _options.MaxVisibleChoices)
			{
				return 0;
			}
			return (totalChoices + _options.ChoicesPerPage - 1) / _options.ChoicesPerPage;
		}

		private static List<DialogueChoiceData> CopyList(List<DialogueChoiceData> src)
		{
			List<DialogueChoiceData> val = new List<DialogueChoiceData>();
			if (src == null)
			{
				return val;
			}
			for (int i = 0; i < src.Count; i++)
			{
				DialogueChoiceData val2 = src[i];
				if (val2 != null)
				{
					val.Add(val2);
				}
			}
			return val;
		}

		private static List<DialogueChoiceData> BuildPageChoices(List<DialogueChoiceData> full, int pageIndex, int pageCount)
		{
			//IL_015e: 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_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			List<DialogueChoiceData> val = new List<DialogueChoiceData>();
			int count = full.Count;
			int num = pageIndex * _options.ChoicesPerPage;
			int num2 = Math.Min(_options.ChoicesPerPage, Math.Max(0, count - num));
			for (int i = 0; i < num2; i++)
			{
				DialogueChoiceData val2 = full[num + i];
				if (val2 != null)
				{
					val.Add(val2);
				}
			}
			string choiceLabel = string.Empty;
			try
			{
				int num3 = NextPageIndex(pageIndex, pageCount, _options.WrapPages);
				int num4 = num3 * _options.ChoicesPerPage;
				if (num4 >= 0 && num4 < full.Count)
				{
					DialogueChoiceData val3 = full[num4];
					if (val3 != null && !string.IsNullOrWhiteSpace(val3.ChoiceLabel))
					{
						choiceLabel = val3.ChoiceLabel;
					}
				}
			}
			catch
			{
			}
			string choiceText;
			try
			{
				choiceText = string.Format(_options.MoreTextFormat, pageIndex + 1, pageCount);
			}
			catch
			{
				choiceText = $"More ({pageIndex + 1}/{pageCount})";
			}
			val.Add(new DialogueChoiceData
			{
				ChoiceLabel = choiceLabel,
				ChoiceText = choiceText
			});
			return val;
		}
	}
	public sealed class DialogueChoicePagingOptions
	{
		public int MaxVisibleChoices { get; set; } = 8;

		public int ChoicesPerPage { get; set; } = 7;

		public bool WrapPages { get; set; } = true;

		public string MoreTextFormat { get; set; } = "More ({0}/{1})";

		internal DialogueChoicePagingOptions Normalize()
		{
			DialogueChoicePagingOptions dialogueChoicePagingOptions = new DialogueChoicePagingOptions
			{
				MaxVisibleChoices = MaxVisibleChoices,
				ChoicesPerPage = ChoicesPerPage,
				WrapPages = WrapPages,
				MoreTextFormat = MoreTextFormat
			};
			if (dialogueChoicePagingOptions.MaxVisibleChoices < 2)
			{
				dialogueChoicePagingOptions.MaxVisibleChoices = 2;
			}
			int num = Math.Max(1, dialogueChoicePagingOptions.MaxVisibleChoices - 1);
			if (dialogueChoicePagingOptions.ChoicesPerPage < 1)
			{
				dialogueChoicePagingOptions.ChoicesPerPage = 1;
			}
			if (dialogueChoicePagingOptions.ChoicesPerPage > num)
			{
				dialogueChoicePagingOptions.ChoicesPerPage = num;
			}
			if (string.IsNullOrWhiteSpace(dialogueChoicePagingOptions.MoreTextFormat))
			{
				dialogueChoicePagingOptions.MoreTextFormat = "More ({0}/{1})";
			}
			return dialogueChoicePagingOptions;
		}
	}
	public class DialogueInjection
	{
		public Predicate<NPC> AppliesTo;

		public string ContainerName;

		public string FromNodeGuid;

		public string ToNodeGuid;

		public string ChoiceLabel;

		public string ChoiceText;

		public Action OnConfirmed;

		public DialogueInjection(Predicate<NPC> appliesToNpc, string container, string from, string to, string label, string text, Action onConfirmed)
		{
			AppliesTo = appliesToNpc;
			ContainerName = container;
			FromNodeGuid = from;
			ToNodeGuid = to;
			ChoiceLabel = label;
			ChoiceText = text;
			OnConfirmed = onConfirmed;
		}

		public DialogueInjection(string npc, string container, string from, string to, string label, string text, Action onConfirmed)
			: this((NPC x) => x.ID.Equals(npc), container, from, to, label, text, onConfirmed)
		{
		}
	}
	public static class DialogueInjector
	{
		private static List<DialogueInjection> _pendingInjections = new List<DialogueInjection>();

		private static bool _isHooked = false;

		public static void Register(DialogueInjection injection)
		{
			_pendingInjections.Add(injection);
			HookUpdateLoop();
		}

		internal static void ResetState()
		{
			_pendingInjections.Clear();
			_isHooked = false;
		}

		private static void HookUpdateLoop()
		{
			if (!_isHooked)
			{
				_isHooked = true;
				MelonCoroutines.Start(WaitForNPCsAndInject());
			}
		}

		private static IEnumerator WaitForNPCsAndInject()
		{
			while (_pendingInjections.Count > 0)
			{
				for (int i = _pendingInjections.Count - 1; i >= 0; i--)
				{
					DialogueInjection injection = _pendingInjections[i];
					NPC target = null;
					foreach (NPC npc in NPC.All)
					{
						if (npc == null || !injection.AppliesTo(npc))
						{
							continue;
						}
						target = npc;
						break;
					}
					if (target != null)
					{
						TryInject(injection, target.S1NPC);
						_pendingInjections.RemoveAt(i);
					}
				}
				yield return (object)new WaitForSeconds(0.5f);
			}
			_isHooked = false;
		}

		private static void TryInject(DialogueInjection injection, NPC npc)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			DialogueHandler componentInChildren = ((Component)npc).GetComponentInChildren<DialogueHandler>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			DialogueContainer val = ResolveContainer(componentInChildren, injection.ContainerName);
			if ((Object)(object)val == (Object)null || val.DialogueNodeData == null)
			{
				return;
			}
			DialogueNodeData val2 = null;
			for (int i = 0; i < val.DialogueNodeData.Count; i++)
			{
				DialogueNodeData val3 = val.DialogueNodeData.ToArray()[i];
				if (val3 != null && !(val3.Guid != injection.FromNodeGuid))
				{
					val2 = val3;
					break;
				}
			}
			if (val2 != null)
			{
				DialogueChoiceData val4 = new DialogueChoiceData
				{
					Guid = Guid.NewGuid().ToString(),
					ChoiceLabel = injection.ChoiceLabel,
					ChoiceText = injection.ChoiceText
				};
				List<DialogueChoiceData> list = new List<DialogueChoiceData>();
				if (val2.choices != null)
				{
					list.AddRange((IEnumerable<DialogueChoiceData>)val2.choices);
				}
				list.Add(val4);
				val2.choices = Il2CppReferenceArray<DialogueChoiceData>.op_Implicit(list.ToArray());
				NodeLinkData val5 = new NodeLinkData
				{
					BaseDialogueOrBranchNodeGuid = injection.FromNodeGuid,
					BaseChoiceOrOptionGUID = val4.Guid,
					TargetNodeGuid = injection.ToNodeGuid
				};
				DialogueContainer val6 = val;
				if (val6.NodeLinks == null)
				{
					List<NodeLinkData> val7 = (val6.NodeLinks = new List<NodeLinkData>());
				}
				val.NodeLinks.Add(val5);
				DialogueChoiceListener.Register(componentInChildren, injection.ChoiceLabel, injection.OnConfirmed);
			}
		}

		private static DialogueContainer? ResolveContainer(DialogueHandler handler, string containerName)
		{
			if ((Object)(object)handler == (Object)null || string.IsNullOrEmpty(containerName))
			{
				return null;
			}
			DialogueController component = ((Component)handler).GetComponent<DialogueController>();
			if ((Object)(object)component != (Object)null)
			{
				if ((Object)(object)component.GenericDialogue != (Object)null && ((Object)component.GenericDialogue).name == containerName)
				{
					return component.GenericDialogue;
				}
				if ((Object)(object)component.OverrideContainer != (Object)null && ((Object)component.OverrideContainer).name == containerName)
				{
					return component.OverrideContainer;
				}
			}
			NPC componentInParent = ((Component)handler).GetComponentInParent<NPC>();
			NPCEvent_LocationDialogue val = ((componentInParent != null) ? ((Component)componentInParent).GetComponentInChildren<NPCEvent_LocationDialogue>(true) : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val.DialogueOverride != (Object)null && ((Object)val.DialogueOverride).name == containerName)
			{
				return val.DialogueOverride;
			}
			List<DialogueContainer> dialogueContainers = handler.dialogueContainers;
			if (dialogueContainers == null)
			{
				return null;
			}
			for (int i = 0; i < dialogueContainers.Count; i++)
			{
				DialogueContainer val2 = dialogueContainers.ToArray()[i];
				if ((Object)(object)val2 != (Object)null && ((Object)val2).name == containerName)
				{
					return val2;
				}
			}
			return null;
		}
	}
}
namespace S1API.Deliveries
{
	public sealed class Delivery
	{
		internal DeliveryInstance NativeDelivery { get; }

		public string Id => NativeDelivery.DeliveryID ?? string.Empty;

		public string StoreName => NativeDelivery.StoreName ?? string.Empty;

		public string DestinationCode => NativeDelivery.DestinationCode ?? string.Empty;

		public int LoadingDockIndex => NativeDelivery.LoadingDockIndex;

		public PropertyWrapper? Destination
		{
			get
			{
				try
				{
					Property destination = NativeDelivery.Destination;
					return ((Object)(object)destination == (Object)null) ? null : new PropertyWrapper(destination);
				}
				catch
				{
					return null;
				}
			}
		}

		public DeliveryStatus Status => (DeliveryStatus)NativeDelivery.Status;

		public int MinutesUntilArrival => NativeDelivery.TimeUntilArrival;

		public IReadOnlyList<DeliveryItem> Items => DeliveryItem.Snapshot((IEnumerable<StringIntPair>?)NativeDelivery.Items);

		public Shop? Shop => DeliveryRegistry.ResolveShop(StoreName);

		public LandVehicle? ActiveVehicle
		{
			get
			{
				DeliveryVehicle activeVehicle = NativeDelivery.ActiveVehicle;
				LandVehicle val = ((activeVehicle != null) ? activeVehicle.Vehicle : null);
				return ((Object)(object)val == (Object)null) ? null : new LandVehicle(val);
			}
		}

		internal Delivery(DeliveryInstance delivery)
		{
			NativeDelivery = delivery ?? throw new ArgumentNullException("delivery");
		}

		public DeliveryReceipt ToReceipt()
		{
			return new DeliveryReceipt(NativeDelivery);
		}
	}
	public sealed class DeliveryItem
	{
		private static readonly IReadOnlyList<DeliveryItem> EmptyItems = new ReadOnlyCollection<DeliveryItem>(Array.Empty<DeliveryItem>());

		public string ItemId { get; }

		public int Quantity { get; }

		internal DeliveryItem(string itemId, int quantity)
		{
			ItemId = itemId ?? string.Empty;
			Quantity = quantity;
		}

		internal static IReadOnlyList<DeliveryItem> Snapshot(IEnumerable<StringIntPair>? nativeItems)
		{
			if (nativeItems == null)
			{
				return EmptyItems;
			}
			List<DeliveryItem> list = new List<DeliveryItem>();
			foreach (StringIntPair nativeItem in nativeItems)
			{
				if (nativeItem != null)
				{
					list.Add(new DeliveryItem(nativeItem.String, nativeItem.Int));
				}
			}
			IReadOnlyList<DeliveryItem> result;
			if (list.Count != 0)
			{
				IReadOnlyList<DeliveryItem> readOnlyList = new ReadOnlyCollection<DeliveryItem>(list);
				result = readOnlyList;
			}
			else
			{
				result = EmptyItems;
			}
			return result;
		}
	}
	public sealed class DeliveryReceipt
	{
		private readonly IReadOnlyList<DeliveryItem> items;

		public string Id { get; }

		public string StoreName { get; }

		public string DestinationCode { get; }

		public int LoadingDockIndex { get; }

		public IReadOnlyList<DeliveryItem> Items => items;

		internal DeliveryReceipt(DeliveryReceipt receipt)
			: this((receipt != null) ? receipt.DeliveryID : null, (receipt != null) ? receipt.StoreName : null, (receipt != null) ? receipt.DestinationCode : null, (receipt != null) ? receipt.LoadingDockIndex : (-1), (IEnumerable<StringIntPair>?)((receipt != null) ? receipt.Items : null))
		{
		}

		internal DeliveryReceipt(DeliveryInstance delivery)
			: this((delivery != null) ? delivery.DeliveryID : null, (delivery != null) ? delivery.StoreName : null, (delivery != null) ? delivery.DestinationCode : null, (delivery != null) ? delivery.LoadingDockIndex : (-1), (IEnumerable<StringIntPair>?)((delivery != null) ? delivery.Items : null))
		{
		}

		private DeliveryReceipt(string? id, string? storeName, string? destinationCode, int loadingDockIndex, IEnumerable<StringIntPair>? nativeItems)
		{
			Id = id ?? string.Empty;
			StoreName = storeName ?? string.Empty;
			DestinationCode = destinationCode ?? string.Empty;
			LoadingDockIndex = loadingDockIndex;
			items = DeliveryItem.Snapshot(nativeItems);
		}
	}
	public static class DeliveryRegistry
	{
		private static readonly Log Logger = new Log("DeliveryRegistry");

		private static readonly IReadOnlyList<Delivery> EmptyDeliveries = new ReadOnlyCollection<Delivery>(Array.Empty<Delivery>());

		private static readonly IReadOnlyList<DeliveryReceipt> EmptyReceipts = new ReadOnlyCollection<DeliveryReceipt>(Array.Empty<DeliveryReceipt>());

		public static event Action<Delivery>? Created;

		public static event Action<Delivery, DeliveryStatus, DeliveryStatus>? StatusChanged;

		public static event Action<Delivery>? Completed;

		public static IReadOnlyList<Delivery> GetAll()
		{
			DeliveryManager nativeManager = GetNativeManager();
			if (((nativeManager != null) ? nativeManager.Deliveries : null) == null)
			{
				return EmptyDeliveries;
			}
			List<Delivery> list = new List<Delivery>();
			Enumerator<DeliveryInstance> enumerator = nativeManager.Deliveries.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeliveryInstance current = enumerator.Current;
				if (current != null)
				{
					list.Add(new Delivery(current));
				}
			}
			IReadOnlyList<Delivery> result;
			if (list.Count != 0)
			{
				IReadOnlyList<Delivery> readOnlyList = new ReadOnlyCollection<Delivery>(list);
				result = readOnlyList;
			}
			else
			{
				result = EmptyDeliveries;
			}
			return result;
		}

		public static Delivery? GetById(string id)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				return null;
			}
			DeliveryManager nativeManager = GetNativeManager();
			if (((nativeManager != null) ? nativeManager.Deliveries : null) == null)
			{
				return null;
			}
			Enumerator<DeliveryInstance> enumerator = nativeManager.Deliveries.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeliveryInstance current = enumerator.Current;
				if (current != null && string.Equals(current.DeliveryID, id, StringComparison.Ordinal))
				{
					return new Delivery(current);
				}
			}
			return null;
		}

		public static IReadOnlyList<Delivery> GetForShop(Shop shop)
		{
			if (shop == null)
			{
				throw new ArgumentNullException("shop");
			}
			return GetForShop(shop.Name);
		}

		public static IReadOnlyList<Delivery> GetForShop(string shopName)
		{
			if (string.IsNullOrWhiteSpace(shopName))
			{
				return EmptyDeliveries;
			}
			DeliveryManager nativeManager = GetNativeManager();
			if (((nativeManager != null) ? nativeManager.Deliveries : null) == null)
			{
				return EmptyDeliveries;
			}
			List<Delivery> list = new List<Delivery>();
			Enumerator<DeliveryInstance> enumerator = nativeManager.Deliveries.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeliveryInstance current = enumerator.Current;
				if (current != null && string.Equals(current.StoreName, shopName, StringComparison.Ordinal))
				{
					list.Add(new Delivery(current));
				}
			}
			IReadOnlyList<Delivery> result;
			if (list.Count != 0)
			{
				IReadOnlyList<Delivery> readOnlyList = new ReadOnlyCollection<Delivery>(list);
				result = readOnlyList;
			}
			else
			{
				result = EmptyDeliveries;
			}
			return result;
		}

		public static IReadOnlyList<DeliveryReceipt> GetHistory()
		{
			DeliveryManager nativeManager = GetNativeManager();
			if ((Object)(object)nativeManager == (Object)null)
			{
				return EmptyReceipts;
			}
			List<DeliveryReceipt> displayedDeliveryHistory = nativeManager.DisplayedDeliveryHistory;
			if (displayedDeliveryHistory == null)
			{
				return EmptyReceipts;
			}
			List<DeliveryReceipt> list = new List<DeliveryReceipt>();
			Enumerator<DeliveryReceipt> enumerator = displayedDeliveryHistory.GetEnumerator();
			while (enumerator.MoveNext())
			{
				DeliveryReceipt current = enumerator.Current;
				if (current != null)
				{
					list.Add(new DeliveryReceipt(current));
				}
			}
			IReadOnlyList<DeliveryReceipt> result;
			if (list.Count != 0)
			{
				IReadOnlyList<DeliveryReceipt> readOnlyList = new ReadOnlyCollection<DeliveryReceipt>(list);
				result = readOnlyList;
			}
			else
			{
				result = EmptyReceipts;
			}
			return result;
		}

		internal static Shop? ResolveShop(string shopName)
		{
			if (string.IsNullOrWhiteSpace(shopName))
			{
				return null;
			}
			try
			{
				if (ShopInterface.AllShops == null)
				{
					return null;
				}
				Enumerator<ShopInterface> enumerator = ShopInterface.AllShops.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ShopInterface current = enumerator.Current;
					if ((Object)(object)current != (Object)null && string.Equals(current.ShopName, shopName, StringComparison.Ordinal))
					{
						return new Shop(current);
					}
				}
			}
			catch
			{
				return null;
			}
			return null;
		}

		internal static void NotifyCreated(DeliveryInstance delivery)
		{
			if (delivery == null || DeliveryRegistry.Created == null)
			{
				return;
			}
			Delivery obj = new Delivery(delivery);
			Delegate[] invocationList = DeliveryRegistry.Created.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<Delivery> action = (Action<Delivery>)invocationList[i];
				try
				{
					action(obj);
				}
				catch (Exception ex)
				{
					Logger.Warning("A DeliveryRegistry.Created subscriber failed: " + ex.Message);
				}
			}
		}

		internal static void NotifyStatusChanged(DeliveryInstance delivery, DeliveryStatus previousStatus, DeliveryStatus currentStatus)
		{
			if (delivery == null || previousStatus == currentStatus || DeliveryRegistry.StatusChanged == null)
			{
				return;
			}
			Delivery arg = new Delivery(delivery);
			Delegate[] invocationList = DeliveryRegistry.StatusChanged.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<Delivery, DeliveryStatus, DeliveryStatus> action = (Action<Delivery, DeliveryStatus, DeliveryStatus>)invocationList[i];
				try
				{
					action(arg, previousStatus, currentStatus);
				}
				catch (Exception ex)
				{
					Logger.Warning("A DeliveryRegistry.StatusChanged subscriber failed: " + ex.Message);
				}
			}
		}

		internal static void NotifyCompleted(DeliveryInstance delivery)
		{
			if (delivery == null || DeliveryRegistry.Completed == null)
			{
				return;
			}
			Delivery obj = new Delivery(delivery);
			Delegate[] invocationList = DeliveryRegistry.Completed.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<Delivery> action = (Action<Delivery>)invocationList[i];
				try
				{
					action(obj);
				}
				catch (Exception ex)
				{
					Logger.Warning("A DeliveryRegistry.Completed subscriber failed: " + ex.Message);
				}
			}
		}

		private static DeliveryManager? GetNativeManager()
		{
			try
			{
				if (!NetworkSingleton<DeliveryManager>.InstanceExists)
				{
					return null;
				}
				return NetworkSingleton<DeliveryManager>.Instance;
			}
			catch
			{
				return null;
			}
		}
	}
	public enum DeliveryStatus
	{
		InTransit,
		Waiting,
		Arrived,
		Completed
	}
}
namespace S1API.DeadDrops
{
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
	public sealed class DeadDropGuidAttribute : Attribute
	{
		public string Guid { get; }

		public DeadDropGuidAttribute(string guid)
		{
			if (!System.Guid.TryParse(guid, out var result))
			{
				throw new ArgumentException("The dead-drop GUID is invalid.", "guid");
			}
			Guid = result.ToString("D");
		}
	}
	public class DeadDropInstance : IGUIDReference
	{
		internal readonly DeadDrop S1DeadDrop;

		private StorageInstance? _cachedStorage;

		public string GUID => ((object)S1DeadDrop.GUID/*cast due to .constrained prefix*/).ToString();

		public string Name => S1DeadDrop.DeadDropName;

		public string Description => S1DeadDrop.DeadDropDescription;

		public Region Region => (Region)S1DeadDrop.Region;

		public StorageInstance Storage => _cachedStorage ?? (_cachedStorage = new StorageInstance((StorageEntity)(object)S1DeadDrop.Storage));

		public int ItemCount => ((StorageEntity)S1DeadDrop.Storage).ItemCount;

		public bool IsEmpty => ItemCount == 0;

		public Vector3 Position => ((Component)S1DeadDrop).transform.position;

		internal DeadDropInstance(DeadDrop deadDrop)
		{
			S1DeadDrop = deadDrop;
		}

		internal static DeadDropInstance? GetFromGUID(string guid)
		{
			return DeadDropManager.All.FirstOrDefault((DeadDropInstance deadDrop) => deadDrop.GUID == guid);
		}
	}
	public static class DeadDropManager
	{
		public static DeadDropInstance[] All => ((IEnumerable<DeadDrop>)DeadDrop.DeadDrops.ToArray()).Select((DeadDrop deadDrop) => new DeadDropInstance(deadDrop)).ToArray();

		public static DeadDropInstance[] Empty => All.Where((DeadDropInstance d) => d.IsEmpty).ToArray();

		public static DeadDropInstance? GetByGUID(string guid)
		{
			return All.FirstOrDefault((DeadDropInstance d) => string.Equals(d.GUID, guid, StringComparison.OrdinalIgnoreCase));
		}

		public static DeadDropInstance? Get<T>() where T : IDeadDropIdentifier
		{
			return GetByGUID(GetGuid<T>());
		}

		public static string GetGuid<T>() where T : IDeadDropIdentifier
		{
			DeadDropGuidAttribute customAttribute = typeof(T).GetCustomAttribute<DeadDropGuidAttribute>();
			if (customAttribute == null)
			{
				throw new InvalidOperationException($"Dead-drop identifier '{typeof(T).FullName}' has no {"DeadDropGuidAttribute"}.");
			}
			return customAttribute.Guid;
		}

		public static DeadDropInstance? GetClosest(Vector3 origin, bool mustBeEmpty = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			DeadDropInstance[] source = (mustBeEmpty ? Empty : All);
			return source.OrderBy((DeadDropInstance d) => Vector3.Distance(d.Position, origin)).FirstOrDefault();
		}

		public static DeadDropInstance? GetRandomEmptyNear(Vector3 origin)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			List<DeadDropInstance> list = Empty.OrderBy((DeadDropInstance d) => Vector3.Distance(d.Position, origin)).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			if (list.Count > 1)
			{
				list.RemoveAt(0);
			}
			if (list.Count > 1)
			{
				list.RemoveRange(list.Count / 2, list.Count / 2);
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list[Random.Range(0, list.Count)];
		}
	}
	public interface IDeadDropIdentifier
	{
	}
}
namespace S1API.DeadDrops.Native
{
	[DeadDropGuid("fe1782b0-64e5-4ae6-a3f9-56af509af104")]
	public sealed class BehindSupermarket : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("d66b3fd6-7b7f-4e98-b000-6d5a197f7437")]
	public sealed class BehindMotelOffice : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("eda8c6a4-07be-4d8f-97f4-ddd6dfca19df")]
	public sealed class SkatePark : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("64d10032-64a9-4cd9-8750-8048d71c5029")]
	public sealed class BehindGasMart : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("0fd91cf3-ac6a-41ce-968f-1f356f996a83")]
	public sealed class UnderWestBridge : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("f5614c42-2c74-42d5-bee2-025e84718792")]
	public sealed class BehindCasino : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("79200bb6-7d39-44d9-ab22-c63f136d8cdf")]
	public sealed class TacoTicklersExteriorWall : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("d28c727e-5175-4989-8c33-2a36c159c817")]
	public sealed class TownHallFountain : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("fde97bca-d21a-476c-bf03-b00768a45030")]
	public sealed class PawnShopWestWall : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("58ec86b5-647e-456d-9266-4cd77413e9c3")]
	public sealed class BehindSlopShop : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("94eef741-d688-4380-ac64-cf190e812b10")]
	public sealed class Gazebo : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("baf08ceb-a0e7-4e4a-baa8-6b4cc992cb15")]
	public sealed class BehindRandysBaitAndTackle : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("e5399b56-22a5-4a2c-a254-cc81e3ab2f75")]
	public sealed class BehindBank : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("51e8f8ec-adcb-4800-8020-55cc24f9ba40")]
	public sealed class BehindCrimsonCanary : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("766389cd-b2e3-44ec-84fe-9c59eccfcdd7")]
	public sealed class BehindThompsonConstruction : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("4ac50ff1-ad3c-415b-aa77-c80249dfa473")]
	public sealed class CentralCanal : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("dd3d22f1-da56-4673-9203-640eeaf915fc")]
	public sealed class NorthArcadeWall : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("b77ed1a0-c729-41d5-b8a2-81b480ca971f")]
	public sealed class BrownApartmentBlock : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("683fa5b9-c55d-4b3f-8026-6f29857d09d1")]
	public sealed class BehindMedicalPractice : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("555e565d-2f65-4882-9edb-7167168b2e00")]
	public sealed class BehindLaundromat : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("aaea12a7-ee38-47ba-aeb8-fb0d45a03957")]
	public sealed class BehindAutoShop : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("eff8fff2-0f89-4936-aef5-c4d383ea4f50")]
	public sealed class GreyDocksBuilding : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("5aeef10c-955d-4fdb-9061-38f4ad7a6289")]
	public sealed class BehindGroceryStore : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("86835825-f5f8-454d-9c74-c31e257f9cc2")]
	public sealed class BehindFireStation : IDeadDropIdentifier
	{
	}
	[DeadDropGuid("3ed706ba-458d-44b5-95cd-d65e4a699043")]
	public sealed class BehindTopTattoo : IDeadDropIdentifier
	{
	}
}
namespace S1API.Cutscenes
{
	public sealed class CutsceneBuilder
	{
		private readonly string _id;

		private string _name;

		private float _duration;

		private float? _fov;

		private Vector3 _initialPosition;

		private Quaternion _initialRotation = Quaternion.identity;

		private Action<CutsceneFrame>? _cameraUpdate;

		private Action? _started;

		private Action<CutsceneEndReason>? _ended;

		private float _fadeInDuration;

		private float _fadeInDelay;

		private float _fadeOutDuration;

		private float _holdToSkipDuration;

		private string? _titleCardText;

		private float _titleCardDuration;

		private bool _hasDuration;

		private bool _hasInitialCamera;

		public CutsceneBuilder(string id)
		{
			//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)
			_id = NormalizeId(id);
			_name = _id;
		}

		public CutsceneBuilder WithName(string name)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			_name = name.Trim();
			if (_name.Length == 0)
			{
				throw new ArgumentException("Cutscene names cannot be empty or whitespace.", "name");
			}
			return this;
		}

		public CutsceneBuilder WithDuration(float seconds)
		{
			ValidatePositiveFinite(seconds, "seconds");
			_duration = seconds;
			_hasDuration = true;
			return this;
		}

		public CutsceneBuilder WithFov(float fov)
		{
			if (!IsFinite(fov) || fov <= 0f || fov >= 180f)
			{
				throw new ArgumentOutOfRangeException("fov", fov, "Cutscene FOV must be finite, greater than zero, and less than 180 degrees.");
			}
			_fov = fov;
			return this;
		}

		public CutsceneBuilder WithInitialCamera(Vector3 position, Quaternion rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_002a: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsFinite(position))
			{
				throw new ArgumentException("The initial camera position must contain finite values.", "position");
			}
			if (!IsFinite(rotation) || rotation == default(Quaternion))
			{
				throw new ArgumentException("The initial camera rotation must be a finite, non-zero quaternion.", "rotation");
			}
			_initialPosition = position;
			_initialRotation = ((Quaternion)(ref rotation)).normalized;
			_hasInitialCamera = true;
			return this;
		}

		public CutsceneBuilder WithCameraUpdate(Action<CutsceneFrame> update)
		{
			_cameraUpdate = update ?? throw new ArgumentNullException("update");
			return this;
		}

		public CutsceneBuilder OnStarted(Action callback)
		{
			_started = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public CutsceneBuilder OnEnded(Action<CutsceneEndReason> callback)
		{
			_ended = callback ?? throw new ArgumentNullException("callback");
			return this;
		}

		public CutsceneBuilder WithFadeIn(float seconds)
		{
			return WithFadeIn(seconds, 0f);
		}

		public CutsceneBuilder WithFadeIn(float seconds, float delaySeconds)
		{
			ValidateNonNegativeFinite(seconds, "seconds");
			ValidateNonNegativeFinite(delaySeconds, "delaySeconds");
			_fadeInDuration = seconds;
			_fadeInDelay = delaySeconds;
			return this;
		}

		public CutsceneBuilder WithFadeOut(float seconds)
		{
			ValidateNonNegativeFinite(seconds, "seconds");
			_fadeOutDuration = seconds;
			return this;
		}

		public CutsceneBuilder WithHoldToSkip(float seconds = 0.5f)
		{
			ValidatePositiveFinite(seconds, "seconds");
			_holdToSkipDuration = seconds;
			return this;
		}

		public CutsceneBuilder WithTitleCard(string text, float duration = 2f)
		{
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			string text2 = text.Trim();
			if (text2.Length == 0)
			{
				throw new ArgumentException("Title card text cannot be empty or whitespace.", "text");
			}
			ValidatePositiveFinite(duration, "duration");
			_titleCardText = text2;
			_titleCardDuration = duration;
			return this;
		}

		public CutsceneHandle Build()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (!_hasDuration)
			{
				throw new InvalidOperationException("A cutscene duration must be configured with WithDuration().");
			}
			if (!_hasInitialCamera)
			{
				throw new InvalidOperationException("An initial camera pose must be configured with WithInitialCamera().");
			}
			return new CutsceneHandle(new CutsceneConfiguration(_id, _name, _duration, _fov, _initialPosition, _initialRotation, _cameraUpdate, _started, _ended, _fadeInDuration, _fadeInDelay, _fadeOutDuration, _holdToSkipDuration, _titleCardText, _titleCardDuration));
		}

		private static string NormalizeId(string id)
		{
			if (id == null)
			{
				throw new ArgumentNullException("id");
			}
			string text = id.Trim();
			if (text.Length == 0)
			{
				throw new ArgumentException("Cutscene IDs cannot be empty or whitespace.", "id");
			}
			return text;
		}

		private static void ValidatePositiveFinite(float value, string parameterName)
		{
			if (!IsFinite(value) || value <= 0f)
			{
				throw new ArgumentOutOfRangeException(parameterName, value, "The value must be finite and greater than zero.");
			}
		}

		private static void ValidateNonNegativeFinite(float value, string parameterName)
		{
			if (!IsFinite(value) || value < 0f)
			{
				throw new ArgumentOutOfRangeException(parameterName, value, "The value must be finite and greater than or equal to zero.");
			}
		}

		private static bool IsFinite(float value)
		{
			return !float.IsNaN(value) && !float.IsInfinity(value);
		}

		private static bool IsFinite(Vector3 value)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			return IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z);
		}

		private static bool IsFinite(Quaternion value)
		{
			//IL_0000: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			return IsFinite(value.x) && IsFinite(value.y) && IsFinite(value.z) && IsFinite(value.w);
		}
	}
	public sealed class CutsceneCamera
	{
		private readonly Transform _transform;

		public Vector3 Position
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _transform.position;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_transform.position = value;
			}
		}

		public Quaternion Rotation
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return _transform.rotation;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				_transform.rotation = value;
			}
		}

		public Vector3 Forward => _transform.forward;

		internal CutsceneCamera(Transform transform)
		{
			_transform = transform;
		}

		public void SetPositionAndRotation(Vector3 position, Quaternion rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			_transform.SetPositionAndRotation(position, rotation);
		}
	}
	public enum CutsceneEndReason
	{
		Completed,
		Skipped,
		Stopped,
		SceneChanged,
		Failed
	}
	public sealed class CutsceneFrame
	{
		public CutsceneCamera Camera { get; }

		public float UnscaledDeltaTime { get; }

		public float Elapsed { get; }

		public float Progress { get; }

		internal CutsceneFrame(CutsceneCamera camera, float unscaledDeltaTime, float elapsed, float progress)
		{
			Camera = camera;
			UnscaledDeltaTime = unscaledDeltaTime;
			Elapsed = elapsed;
			Progress = progress;
		}
	}
	public sealed class CutsceneHandle : IDisposable
	{
		private readonly CutsceneConfiguration _configuration;

		private CutsceneCamera? _camera;

		private CutscenePresentationRuntime? _presentation;

		private bool _disposed;

		private bool _endCallbackPending;

		public string Id => _configuration.Id;

		public string Name => _configuration.Name;

		public bool IsPlaying => CutsceneManager.Active == this;

		public float Elapsed { get; private set; }

		public float Progress => Math.Min(1f, Elapsed / _configuration.Duration);

		public CutsceneEndReason? EndReason { get; private set; }

		internal CutsceneHandle(CutsceneConfiguration configuration)
		{
			_configuration = configuration;
		}

		public bool Play()
		{
			if (_disposed)
			{
				return false;
			}
			return CutsceneManager.TryPlay(this);
		}

		public bool Stop()
		{
			return CutsceneManager.TryEnd(this, CutsceneEndReason.Stopped);
		}

		public bool Skip()
		{
			return CutsceneManager.TryEnd(this, CutsceneEndReason.Skipped);
		}

		public void Dispose()
		{
			if (!_disposed)
			{
				Stop();
				_disposed = true;
			}
		}

		internal bool Begin(NativeCutsceneAdapter adapter)
		{
			//IL_0041: 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)
			Elapsed = 0f;
			EndReason = null;
			_endCallbackPending = true;
			if (!adapter.TryBegin(_configuration.Id, _configuration.Name, _configuration.InitialPosition, _configuration.InitialRotation, _configuration.Fov, out _camera))
			{
				_endCallbackPending = false;
				_camera = null;
				EndReason = CutsceneEndReason.Failed;
				return false;
			}
			try
			{
				_configuration.Started?.Invoke();
				InvokeCameraUpdate(0f);
				_presentation = new CutscenePresentationRuntime(_configuration);
				_presentation.Begin();
				return true;
			}
			catch (Exception exception)
			{
				CutsceneManager.FailFromCallback(this, exception);
				return false;
			}
		}

		internal void Tick(float unscaledDeltaTime)
		{
			if (_camera == null)
			{
				CutsceneManager.TryEnd(this, CutsceneEndReason.Failed);
				return;
			}
			float num = Math.Max(0f, unscaledDeltaTime);
			Elapsed = Math.Min(_configuration.Duration, Elapsed + num);
			try
			{
				InvokeCameraUpdate(num);
				CutscenePresentationRuntime? presentation = _presentation;
				if (presentation != null && presentation.Tick(num, Elapsed))
				{
					CutsceneManager.TryEnd(this, CutsceneEndReason.Skipped);
					return;
				}
			}
			catch (Exception exception)
			{
				CutsceneManager.FailFromCallback(this, exception);
				return;
			}
			if (Elapsed >= _configuration.Duration)
			{
				CutsceneManager.TryEnd(this, CutsceneEndReason.Completed);
			}
		}

		internal void Complete(CutsceneEndReason reason)
		{
			_presentation?.End(reason);
			_presentation = null;
			_camera = null;
			EndReason = reason;
			if (!_endCallbackPending)
			{
				return;
			}
			_endCallbackPending = false;
			try
			{
				_configuration.Ended?.Invoke(reason);
			}
			catch (Exception exception)
			{
				CutsceneManager.LogCallbackFailure(Id, "ended", exception);
			}
		}

		internal void DrawPresentation()
		{
			_presentation?.Draw();
		}

		private void InvokeCameraUpdate(float unscaledDeltaTime)
		{
			if (_configuration.CameraUpdate != null && _camera != null)
			{
				_configuration.CameraUpdate(new CutsceneFrame(_camera, unscaledDeltaTime, Elapsed, Progress));
			}
		}
	}
	public static class CutsceneManager
	{
		private static readonly Log Logger = new Log("Cutscenes");

		private static NativeCutsceneAdapter? _adapter;

		private static bool _ending;

		public static CutsceneHandle? Active { get; private set; }

		public static bool IsPlaying => Active != null;

		public static bool StopActive()
		{
			CutsceneHandle active = Active;
			return active != null && TryEnd(active, CutsceneEndReason.Stopped);
		}

		internal static bool TryPlay(CutsceneHandle handle)
		{
			if (Active != null)
			{
				Logger.Warning($"Could not play cutscene '{handle.Id}' because '{Active.Id}' is already active.");
				return false;
			}
			NativeCutsceneAdapter adapter = (_adapter = new NativeCutsceneAdapter());
			Active = handle;
			if (handle.Begin(adapter))
			{
				return true;
			}
			if (Active == handle)
			{
				EndInternal(handle, CutsceneEndReason.Failed);
			}
			return false;
		}

		internal static bool TryEnd(CutsceneHandle handle, CutsceneEndReason reason)
		{
			if (Active != handle || _ending)
			{
				return false;
			}
			EndInternal(handle, reason);
			return true;
		}

		internal static void Tick(float unscaledDeltaTime)
		{
			Active?.Tick(unscaledDeltaTime);
		}

		internal static void DrawPresentation()
		{
			Active?.DrawPresentation();
		}

		internal static void CleanupForSceneChange()
		{
			CutsceneHandle active = Active;
			if (active != null)
			{
				EndInternal(active, CutsceneEndReason.SceneChanged);
			}
		}

		internal static void Deinitialize()
		{
			CutsceneHandle active = Active;
			if (active != null)
			{
				EndInternal(active, CutsceneEndReason.Stopped);
			}
		}

		internal static void FailFromCallback(CutsceneHandle handle, Exception exception)
		{
			LogCallbackFailure(handle.Id, "camera/started", exception);
			TryEnd(handle, CutsceneEndReason.Failed);
		}

		internal static void LogCallbackFailure(string id, string callbackName, Exception exception)
		{
			Logger.Error($"Cutscene '{id}' {callbackName} callback failed: {exception.GetType().Name}: {exception.Message}");
		}

		private static void EndInternal(CutsceneHandle handle, CutsceneEndReason requestedReason)
		{
			_ending = true;
			CutsceneEndReason reason = requestedReason;
			try
			{
				if (_adapter != null && !_adapter.TryEnd(out Exception exception))
				{
					reason = CutsceneEndReason.Failed;
					if (exception != null)
					{
						Logger.Error($"Cutscene '{handle.Id}' native cleanup failed: {exception.GetType().Name}: {exception.Message}");
					}
				}
			}
			finally
			{
				_adapter = null;
				Active = null;
				_ending = false;
				handle.Complete(reason);
			}
		}
	}
}
namespace S1API.Console
{
	public abstract class BaseConsoleCommand
	{
		public abstract string CommandWord { get; }

		public abstract string CommandDescription { get; }

		public abstract string ExampleUsage { get; }

		public abstract void ExecuteCommand(List<string> args);
	}
	public static class ConsoleHelper
	{
		private static readonly Log Logger = new Log("ConsoleHelper");

		private static bool _setPlayerEnergyUnavailableWarningLogged;

		public static void Submit(string command)
		{
			Console.SubmitCommand(command);
		}

		public static void Submit(IEnumerable<string> arguments)
		{
			List<string> val = new List<string>();
			if (arguments is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				while (enumerator.MoveNext())
				{
					if (enumerator.Current is string text)
					{
						val.Add(text);
					}
				}
			}
			Console.SubmitCommand(val);
		}

		public static void RunCashCommand(int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ChangeCashCommand val = new ChangeCashCommand();
			List<string> val2 = new List<string>();
			val2.Add(amount.ToString());
			((ConsoleCommand)val).Execute(val2);
		}

		public static void RunOnlineBalanceCommand(int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ChangeOnlineBalanceCommand val = new ChangeOnlineBalanceCommand();
			List<string> val2 = new List<string>();
			val2.Add(amount.ToString());
			((ConsoleCommand)val).Execute(val2);
		}

		public static void AddItemToInventory(string itemCode, int? quantity = null)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			AddItemToInventoryCommand val = new AddItemToInventoryCommand();
			List<string> val2 = new List<string>();
			val2.Add(itemCode);
			if (quantity.HasValue)
			{
				val2.Add(quantity.Value.ToString());
			}
			((ConsoleCommand)val).Execute(val2);
		}

		public static void ClearInventory()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ClearInventoryCommand val = new ClearInventoryCommand();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void ClearTrash()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ClearTrash val = new ClearTrash();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void ClearWanted()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ClearWanted val = new ClearWanted();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void GiveXp(int amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			GiveXP val = new GiveXP();
			List<string> val2 = new List<string>();
			val2.Add(amount.ToString());
			((ConsoleCommand)val).Execute(val2);
		}

		public static void GrowPlants()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			GrowPlants val = new GrowPlants();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void LowerWanted()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			LowerWanted val = new LowerWanted();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void RaiseWanted()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			RaisedWanted val = new RaisedWanted();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SaveGame()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			Save val = new Save();
			List<string> val2 = new List<string>();
			((ConsoleCommand)val).Execute(val2);
		}

		public static void DiscoverProduct(string productCode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetDiscovered val = new SetDiscovered();
			List<string> val2 = new List<string>();
			val2.Add(productCode);
			((ConsoleCommand)val).Execute(val2);
		}

		[Obsolete("Player energy was removed from newer game builds. This method is retained as a compatibility no-op where unavailable and may be removed in a future S1API version.")]
		public static void SetPlayerEnergyLevel(float amount)
		{
			LogSetPlayerEnergyUnavailable();
		}

		private static void LogSetPlayerEnergyUnavailable()
		{
			if (!_setPlayerEnergyUnavailableWarningLogged)
			{
				_setPlayerEnergyUnavailableWarningLogged = true;
				Logger.Warning("SetPlayerEnergyLevel is unavailable because player energy is not present in this game build.");
			}
		}

		public static void SetPlayerHealth(float amount)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetHealth val = new SetHealth();
			List<string> val2 = new List<string>();
			val2.Add(amount.ToString(CultureInfo.InvariantCulture));
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetPlayerJumpMultiplier(float multiplier)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetJumpMultiplier val = new SetJumpMultiplier();
			List<string> val2 = new List<string>();
			val2.Add(multiplier.ToString(CultureInfo.InvariantCulture));
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetLawIntensity(float intensity)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetLawIntensity val = new SetLawIntensity();
			List<string> val2 = new List<string>();
			val2.Add(intensity.ToString(CultureInfo.InvariantCulture));
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetPlayerMoveSpeedMultiplier(float multiplier)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetMoveSpeedCommand val = new SetMoveSpeedCommand();
			List<string> val2 = new List<string>();
			val2.Add(multiplier.ToString(CultureInfo.InvariantCulture));
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetQuality(Quality quality)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetQuality val = new SetQuality();
			List<string> val2 = new List<string>();
			val2.Add(quality.ToString());
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetQuestState(string questName, QuestState state)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetQuestState val = new SetQuestState();
			List<string> val2 = new List<string>();
			val2.Add(questName);
			val2.Add(state.ToString());
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetNpcRelationship(string npcId, float level)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetRelationship val = new SetRelationship();
			List<string> val2 = new List<string>();
			val2.Add(npcId);
			val2.Add(level.ToString(CultureInfo.InvariantCulture));
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetNpcRelationship(NPC npc, float level)
		{
			SetNpcRelationship(npc.ID, level);
		}

		public static void UnlockNpc(NPC npc)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetUnlocked val = new SetUnlocked();
			List<string> val2 = new List<string>();
			val2.Add(npc.ID);
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SetTime(string hhmm)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SetTimeCommand val = new SetTimeCommand();
			List<string> val2 = new List<string>();
			val2.Add(hhmm);
			((ConsoleCommand)val).Execute(val2);
		}

		public static void SpawnVehicle(string vehicleCode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			SpawnVehicleCommand val = new SpawnVehicleCommand();
			List<string> val2 = new List<string>();
			val2.Add(vehicleCode);
			((ConsoleCommand)val).Execute(val2);
		}
	}
	public static class ConsoleItemAliases
	{
		public static void Register(string alias, string canonicalItemId)
		{
			ConsoleItemAliasRegistry.Register(alias, canonicalItemId, ItemManager.IsItemRegistered);
		}
	}
	internal static class CustomConsoleRegistry
	{
		private static readonly Log Logger = new Log("Console");

		private static readonly Dictionary<string, BaseConsoleCommand> registry = new Dictionary<string, BaseConsoleCommand>(StringComparer.OrdinalIgnoreCase);

		internal static IReadOnlyDictionary<string, BaseConsoleCommand> RegisteredCommands => registry;

		internal static void Register(BaseConsoleCommand command)
		{
			if (command != null)
			{
				string text = (command.CommandWord ?? string.Empty).Trim();
				if (string.IsNullOrEmpty(text))
				{
					Logger.Warning("Skipping registration of command with empty CommandWord");
				}
				else
				{
					registry[text] = command;
				}
			}
		}

		internal static bool TryExecuteManaged(List<string> args)
		{
			if (args == null || args.Count == 0)
			{
				return false;
			}
			for (int i = 0; i < args.Count; i++)
			{
				if (args[i] != null)
				{
					args[i] = args[i].ToLowerInvariant();
				}
			}
			string text = args[0];
			if (!registry.TryGetValue(text, out BaseConsoleCommand value))
			{
				return false;
			}
			try
			{
				List<string> list = new List<string>(args);
				list.RemoveAt(0);
				value.ExecuteCommand(list);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("[Console] Error executing custom command '" + text + "': " + ex.Message);
				return false;
			}
		}

		internal static bool TryExecute(List<string> args)
		{
			if (args == null || args.Count == 0)
			{
				return false;
			}
			string text = (args[0] ?? string.Empty).ToLower();
			if (!registry.TryGetValue(text, out BaseConsoleCommand value))
			{
				return false;
			}
			try
			{
				List<string> list = new List<string>(Math.Max(args.Count - 1, 0));
				for (int i = 1; i < args.Count; i++)
				{
					string item = args[i];
					list.Add(item);
				}
				value.ExecuteCommand(list);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Warning("[Console] Error executing custom command '" + text + "' (Il2Cpp): " + ex.Message);
				return false;
			}
		}
	}
}
namespace S1API.Conditions
{
	public class SystemTriggerEntry
	{
		internal readonly SystemTrigger S1SystemTrigger;

		public event Action OnEvaluateTrue
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1SystemTrigger.onEvaluateTrue);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1SystemTrigger.onEvaluateTrue);
			}
		}

		public event Action OnEvaluateFalse
		{
			add
			{
				global::S1API.Utils.EventHelper.AddListener(value, S1SystemTrigger.onEvaluateFalse);
			}
			remove
			{
				global::S1API.Utils.EventHelper.RemoveListener(value, S1SystemTrigger.onEvaluateFalse);
			}
		}

		internal SystemTriggerEntry(SystemTrigger systemTrigger)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			S1SystemTrigger = systemTrigger;
			S1SystemTrigger.Conditions = new Conditions();
			Conditions conditions = S1SystemTrigger.Conditions;
			if (conditions.ConditionList == null)
			{
				Il2CppReferenceArray<Condition> val = (conditions.ConditionList = Il2CppReferenceArray<Condition>.op_Implicit(Array.Empty<Condition>()));
			}
			conditions = S1SystemTrigger.Conditions;
			if (conditions.QuestConditionList == null)
			{
				Il2CppReferenceArray<QuestCondition> val3 = (conditions.QuestConditionList = Il2CppReferenceArray<QuestCondition>.op_Implicit(Array.Empty<QuestCondition>()));
			}
			SystemTrigger s1SystemTrigger = S1SystemTrigger;
			if (s1SystemTrigger.onEvaluateTrueVariableSetters == null)
			{
				Il2CppReferenceArray<VariableSetter> val5 = (s1SystemTrigger.onEvaluateTrueVariableSetters = Il2CppReferenceArray<VariableSetter>.op_Implicit(Array.Empty<VariableSetter>()));
			}
			s1SystemTrigger = S1SystemTrigger;
			if (s1SystemTrigger.onEvaluateFalseVariableSetters == null)
			{
				Il2CppReferenceArray<VariableSetter> val5 = (s1SystemTrigger.onEvaluateFalseVariableSetters = Il2CppReferenceArray<VariableSetter>.op_Implicit(Array.Empty<VariableSetter>()));
			}
			s1SystemTrigger = S1SystemTrigger;
			if (s1SystemTrigger.onEvaluateTrueQuestSetters == null)
			{
				Il2CppReferenceArray<QuestStateSetter> val8 = (s1SystemTrigger.onEvaluateTrueQuestSetters = Il2CppReferenceArray<QuestStateSetter>.op_Implicit(Array.Empty<QuestStateSetter>()));
			}
			s1SystemTrigger = S1SystemTrigger;
			if (s1SystemTrigger.onEvaluateFalseQuestSetters == null)
			{
				Il2CppReferenceArray<QuestStateSetter> val8 = (s1SystemTrigger.onEvaluateFalseQuestSetters = Il2CppReferenceArray<QuestStateSetter>.op_Implicit(Array.Empty<QuestStateSetter>()));
			}
		}

		public void AddVariableSetter(EvaluationType evaluation, string variableName, string newValue)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			VariableSetter val = new VariableSetter
			{
				VariableName = variableName,
				NewValue = newValue
			};
			switch (evaluation)
			{
			case EvaluationType.PassOnTrue:
				S1SystemTrigger.onEvaluateTrueVariableSetters = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<VariableSetter>(S1SystemTrigger.onEvaluateTrueVariableSetters, (VariableSetter[]?)(object)new VariableSetter[1] { val });
				break;
			case EvaluationType.PassOnFalse:
				S1SystemTrigger.onEvaluateFalseVariableSetters = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<VariableSetter>(S1SystemTrigger.onEvaluateFalseVariableSetters, (VariableSetter[]?)(object)new VariableSetter[1] { val });
				break;
			}
		}

		public void AddQuestSetter(EvaluationType evaluation, Quest questData, QuestAction? questAction = null, Tuple<int, QuestState>? questEntryState = null)
		{
			//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_0019: Expected O, but got Unknown
			QuestStateSetter val = new QuestStateSetter
			{
				QuestName = questData.S1Quest.Title
			};
			if (questAction.HasValue)
			{
				val.SetQuestState = true;
				val.QuestState = (EQuestAction)questAction.Value;
			}
			if (questEntryState != null)
			{
				val.SetQuestEntryState = true;
				val.QuestEntryIndex = questEntryState.Item1;
				val.QuestEntryState = (EQuestState)questEntryState.Item2;
			}
			switch (evaluation)
			{
			case EvaluationType.PassOnTrue:
				S1SystemTrigger.onEvaluateTrueQuestSetters = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<QuestStateSetter>(S1SystemTrigger.onEvaluateTrueQuestSetters, (QuestStateSetter[]?)(object)new QuestStateSetter[1] { val });
				break;
			case EvaluationType.PassOnFalse:
				S1SystemTrigger.onEvaluateFalseQuestSetters = global::S1API.Internal.Utils.ArrayExtensions.AddItemToArray<QuestStateSetter>(S1SystemTrigger.onEvaluateFalseQuestSetters, (QuestStateSetter[]?)(object)new QuestStateSetter[1] { val });
				break;
			}
		}

		public void Trigger()
		{
			S1SystemTrigger.Trigger();
		}
	}
}
namespace S1API.Casino
{
	public enum GamblingSessionMode
	{
		SingleSpin,
		SpinCount,
		UntilTime,
		UntilBroke,
		UntilTimeOrBroke
	}
	public static class SlotMachineHelper
	{
		private sealed class ActiveSpin
		{
			public SlotMachine Machine { get; }

			public object? CoroutineHandle { get; set; }

			internal ActiveSpin(SlotMachine machine)
			{
				Machine = machine;
			}
		}

		public enum Outcome
		{
			Jackpot,
			BigWin,
			SmallWin,
			MiniWin,
			NoWin
		}

		private static readonly Log Logger = new Log("SlotMachineHelper");

		private static bool _lifecycleHooksRegistered;

		private static bool _isSceneChangeInProgress;

		private static readonly List<ActiveSpin> ActiveSpins = new List<ActiveSpin>();

		internal static bool IsSceneTransitionInProgress => _isSceneChangeInProgress;

		public static float GetNPCCash(NPC npc)
		{
			object obj;
			if (npc == null)
			{
				obj = null;
			}
			else
			{
				NPC s1NPC = npc.S1NPC;
				obj = ((s1NPC != null) ? s1NPC.Inventory : null);
			}
			if ((Object)obj == (Object)null)
			{
				return 0f;
			}
			try
			{
				float num = 0f;
				NPCInventory inventory = npc.S1NPC.Inventory;
				return inventory.GetCashInInventory();
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to get cash for NPC " + npc?.ID + ": " + ex.Message);
				return 0f;
			}
		}

		public static bool RemoveNPCCash(NPC npc, int amount)
		{
			object obj;
			if (npc == null)
			{
				obj = null;
			}
			else
			{
				NPC s1NPC = npc.S1NPC;
				obj = ((s1NPC != null) ? s1NPC.Inventory : null);
			}
			if ((Object)obj == (Object)null || amount <= 0)
			{
				return false;
			}
			try
			{
				NPCInventory inventory = npc.S1NPC.Inventory;
				float nPCCash = GetNPCCash(npc);
				if (nPCCash < (float)amount)
				{
					return false;
				}
				MethodInfo method = ((object)inventory).GetType().GetMethod("RemoveCash", BindingFlags.Instance | BindingFlags.Public);
				if (method != null)
				{
					method.Invoke(inventory, new object[1] { (float)amount });
					float nPCCash2 = GetNPCCash(npc);
					float num = nPCCash - nPCCash2;
					if (num >= (float)amount - 0.01f)
					{
						return true;
					}
					Logger.Warning($"[{npc.ID}] RemoveNPCCash: Partial removal (Requested: ${amount}, Actual: ${num})");
					return false;
				}
				Logger.Warning("[" + npc.ID + "] RemoveNPCCash: RemoveCash method not found on inventory type");
				return false;
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to remove cash for NPC " + npc?.ID + ": " + ex.Message);
				Logger.Warning("Stack trace: " + ex.StackTrace);
				return false;
			}
		}

		public static void AddNPCCash(NPC npc, int amount)
		{
			object obj;
			if (npc == null)
			{
				obj = null;
			}
			else
			{
				NPC s1NPC = npc.S1NPC;
				obj = ((s1NPC != null) ? s1NPC.Inventory : null);
			}
			if ((Object)obj == (Object)null || amount <= 0)
			{
				Log logger = Logger;
				DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(58, 3);
				defaultInterpolatedStringHandler.AppendLiteral("AddNPCCash: Invalid parameters - NPC=");
				defaultInterpolatedStringHandler.AppendFormatted(npc?.ID);
				defaultInterpolatedStringHandler.AppendLiteral(", Amount=");
				defaultInterpolatedStringHandler.AppendFormatted(amount);
				defaultInterpolatedStringHandler.AppendLiteral(", Inventory=");
				object obj2;
				if (npc == null)
				{
					obj2 = null;
				}
				else
				{
					NPC s1NPC2 = npc.S1NPC;
					obj2 = ((s1NPC2 != null) ? s1NPC2.Inventory : null);
				}
				defaultInterpolatedStringHandler.AppendFormatted(((Object)obj2 != (Object)null) ? "Valid" : "Null");
				logger.Warning(defaultInterpolatedStringHandler.ToStringAndClear());
				return;
			}
			try
			{
				NPCInventory inventory = npc.S1NPC.Inventory;
				npc.Inventory?.EnsureInitialized();
				if (inventory.ItemSlots == null || inventory.ItemSlots.Count == 0)
				{
					Logger.Warning("[" + npc.ID + "] AddNPCCash: Inventory slots not initialized (ItemSlots is null or empty). Cannot add cash.");
					return;
				}
				int num = 0;
				int num2 = 0;
				for (int i = 0; i < inventory.ItemSlots.Count; i++)
				{
					ItemSlot val = inventory.ItemSlots[i];
					if (val == null)
					{
						continue;
					}
					try
					{
						bool valueOrDefault = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(val, "IsLocked") as bool? == true;
						bool valueOrDefault2 = global::S1API.Utils.ReflectionUtils.TryGetFieldOrProperty(val, "IsAddLocked") as bool? == true;
						if (!valueOrDefault && !valueOrDefault2)
						{
							num++;
							if (val.ItemInstance == null)
							{
								num2++;
							}
						}
					}
					catch
					{
					}
				}
				try
				{
					MethodInfo method = ((object)inventory).GetType().GetMethod("AddCash", BindingFlags.Instance | BindingFlags.Public);
					if (method != null)
					{
						method.Invoke(inventory, new object[1] { (float)amount });
						return;
					}
					throw new MissingMethodException("AddCash method not found! Did Schedule 1 update recently?");
				}
				catch (Exception ex)
				{
					Logger.Warning($"[{npc.ID}] AddNPCCash: Could not use AddCash method ({ex.Message}), falling back to manual insertion");
					MoneyManager instance = NetworkSingleton<MoneyManager>.Instance;
					if ((Object)(object)instance == (Object)null)
					{
						Logger.Warning("[" + npc.ID + "] AddNPCCash: MoneyManager not available to create cash item");
						return;
					}
					float num3 = amount;
					while (num3 > 0.1f)
					{
						float num4 = Mathf.Min(num3, 1000f);
						num3 -= num4;
						CashInstance cashInstance = instance.GetCashInstance((float)(int)num4);
						if (cashInstance == null)
						{
							Logger.Warning($"[{npc.ID}] AddNPCCash: GetCashInstance returned null for chunk ${num4}");
							break;
						}
						if (!inventory.CanItemFit((ItemInstance)(object)cashInstance))
						{
							Logger.Warning($"[{npc.ID}] AddNPCCash: Cash item (${num4}) cannot fit. UnlockedSlots={num}, FreeSlots={num2}");
							break;
						}
						inventory.InsertItem((ItemInstance)(object)cashInstance, true);
					}
				}
			}
			catch (Exception ex2)
			{
				Logger.Warning("[" + npc.ID + "] AddNPCCash: Failed with exception: " + ex2.Message);
				Logger.Warning("[" + npc.ID + "] AddNPCCash: Stack trace: " + ex2.StackTrace);
			}
		}

		public static bool UseSlotMachine(NPC npc, Vector3 machinePosition, int betAmount, float maxSearchDistance = 5f)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected I4, but got Unknown
			if (npc == null || betAmount <= 0)
			{
				return false;
			}
			try
			{
				EnsureLifecycleHooks();
				if (_isSceneChangeInProgress)
				{
					return false;
				}
				SlotMachine val = FindNearestSlotMachine(machinePosition, maxSearchDistance);
				if ((Object)(object)val == (Object)null)
				{
					Logger.Warning($"No slot machine found near position {machinePosition}");
					return false;
				}
				if (val.IsSpinning)
				{
					return false;
				}
				float nPCCash = GetNPCCash(npc);
				if (nPCCash < (float)betAmount)
				{
					return false;
				}
				if (!RemoveNPCCash(npc, betAmount))
				{
					Logger.Warning("Failed to remove cash from NPC " + npc.ID);
					return false;
				}
				ESymbol[] array = (ESymbol[])(object)new ESymbol[((Il2CppArrayBase<SlotReel>)(object)val.Reels).Length];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = (ESymbol)(int)SlotMachine.GetRandomSymbol();
				}
				ActiveSpin activeSpin = new ActiveSpin(val);
				activeSpin.CoroutineHandle = MelonCoroutines.Start(SpinSlotMachineForNPC(npc, val, array, betAmount, activeSpin));
				RegisterActiveSpin(activeSpin);
				return true;
			}
			catch (Exception ex)
			{
				Logger.Error("Failed to use slot machine for NPC " + npc.ID + ": " + ex.Message);
				return false;
			}
		}

		public static SlotMachine? FindNearestSlotMachine(Vector3 position, float maxDistance)
		{
			//IL_0062: 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)
			try
			{
				Il2CppArrayBase<SlotMachine> val = Object.FindObjectsOfType<SlotMachine>();
				if (val == null || val.Length == 0)
				{
					return null;
				}
				SlotMachine result = null;
				float num = float.MaxValue;
				foreach (SlotMachine item in val)
				{
					if (!((Object)(object)item == (Object)null) && !((Object)(object)((Component)item).gameObject == (Object)null))
					{
						float num2 = Vector3.Distance(position, ((Component)item).transform.position);
						if (num2 < num && num2 <= maxDistance)
						{
							num = num2;
							result = item;
						}
					}
				}
				return result;
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to find slot machine: " + ex.Message);
				return null;
			}
		}

		private static IEnumerator SpinSlotMachineForNPC(NPC npc, SlotMachine machine, ESymbol[] symbols, int betAmount, ActiveSpin activeSpin)
		{
			try
			{
				SetMachineSpinning(machine, isSpinning: true);
				int i;
				for (i = 0; i < ((Il2CppArrayBase<SlotReel>)(object)machine.Reels).Length; i++)
				{
					yield return (object)new WaitForSeconds(0.2f);
					if (ShouldAbortSpin(npc, machine) || !TryInvokeMachineStep(machine, delegate
					{
						((Il2CppArrayBase<SlotReel>)(object)machine.Reels)[i].Spin();
					}, $"spin reel {i}") || (i == 0 && (Object)(object)machine.SpinLoop != (Object)null && !TryInvokeMachineStep(machine, delegate
					{
						machine.SpinLoop.Play();
					}, "start spin loop")))
					{
						yield break;
					}
				}
				yield return (object)new WaitForSeconds(0.5f);
				if (ShouldAbortSpin(npc, machine))
				{
					yield break;
				}
				EOutcome outcome = EvaluateOutcome(machine, symbols);
				int i2;
				for (i2 = 0; i2 < ((Il2CppArrayBase<SlotReel>)(object)machine.Reels).Length; i2++)
				{
					if (i2 == ((Il2CppArrayBase<SlotReel>)(object)machine.Reels).Length - 1 && (int)outcome != 0 && symbols.Length >= 3 && (int)symbols[i2 - 1] == (int)symbols[i2 - 2])
					{
						yield return (object)new WaitForSeconds(0.3f);
						if (ShouldAbortSpin(npc, machine))
						{
							yield break;
						}
					}
					yield return (object)new WaitForSeconds(0.6f);
					if (ShouldAbortSpin(npc, machine))
					{
						yield break;
					}
					if ((int)outcome == 0)
					{
						if (i2 == 0)
						{
							if ((Object)(object)machine.JackpotSound != (Object)null && !TryInvokeMachineStep(machine, delegate
							{
								machine.JackpotSound.Play();
							}, "play jackpot sound"))
							{
								yield break;
							}
						}
						else
						{
							yield return (object)new WaitForSeconds(0.35f);
							if (ShouldAbortSpin(npc, machine))
							{
								yield break;
							}
						}
					}
					if (!TryInvokeMachineStep(machine, delegate
					{
						((Il2CppArrayBase<SlotReel>)(object)machine.Reels)[i2].Stop(symbols[i2]);
					}, $"stop reel {i2}"))
					{
						yield break;
					}
				}
				if ((Object)(object)machine.SpinLoop != (Object)null && !TryInvokeMachineStep(machine, delegate
				{
					machine.SpinLoop.Stop();
				}, "stop spin loop"))
				{
					yield break;
				}
				int winAmount = GetWinAmount(outcome, betAmount);
				if (winAmount > 0 && npc != null && (Object)(object)npc.gameObject != (Object)null)
				{
					AddNPCCash(npc, winAmount);
				}
				try
				{
					MethodInfo displayMethod = typeof(SlotMachine).GetMethod("DisplayOutcome", BindingFlags.Instance | BindingFlags.NonPublic);
					if (displayMethod != null && !ShouldAbortSpin(npc, machine))
					{
						displayMethod.Invoke(machine, new object[2] { outcome, winAmount });
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to display outcome: " + ex.Message);
				}
			}
			finally
			{
				if ((Object)(object)machine != (Object)null && (Object)(object)machine.SpinLoop != (Object)null)
				{
					TryInvokeMachineStep(machine, delegate
					{
						machine.SpinLoop.Stop();
					}, "final spin loop stop");
				}
				SetMachineSpinning(machine, isSpinning: false);
				UnregisterActiveSpin(activeSpin);
			}
		}

		private static void EnsureLifecycleHooks()
		{
			if (!_lifecycleHooksRegistered)
			{
				GameLifecycle.OnPreSceneChange += HandlePreSceneChange;
				GameLifecycle.OnLoadComplete += HandleLoadComplete;
				_lifecycleHooksRegistered = true;
			}
		}

		private static void HandlePreSceneChange()
		{
			_isSceneChangeInProgress = true;
			CancelAllActiveSpins();
		}

		private static void HandleLoadComplete()
		{
			_isSceneChangeInProgress = false;
		}

		private static void RegisterActiveSpin(ActiveSpin activeSpin)
		{
			ActiveSpins.Add(activeSpin);
		}

		private static void UnregisterActiveSpin(ActiveSpin activeSpin)
		{
			ActiveSpins.Remove(activeSpin);
		}

		private static void CancelAllActiveSpins()
		{
			if (ActiveSpins.Count == 0)
			{
				return;
			}
			ActiveSpin[] array = ActiveSpins.ToArray();
			ActiveSpins.Clear();
			ActiveSpin[] array2 = array;
			foreach (ActiveSpin activeSpin in array2)
			{
				try
				{
					if (activeSpin.CoroutineHandle != null)
					{
						MelonCoroutines.Stop(activeSpin.CoroutineHandle);
					}
				}
				catch (Exception ex)
				{
					Logger.Warning("Failed to stop active slot machine coroutine during scene change: " + ex.Message);
				}
				SetMachineSpinning(activeSpin.Machine, isSpinning: false);
			}
		}

		private static bool ShouldAbortSpin(NPC? npc, SlotMachine? machine)
		{
			if (_isSceneChangeInProgress)
			{
				return true;
			}
			if (npc == null || (Object)(object)npc.gameObject == (Object)null)
			{
				return true;
			}
			if ((Object)(object)machine == (Object)null || (Object)(object)((Component)machine).gameObject == (Object)null || machine.Reels == null)
			{
				return true;
			}
			return false;
		}

		private static bool TryInvokeMachineStep(SlotMachine machine, Action action, string stepName)
		{
			if (_isSceneChangeInProgress || (Object)(object)machine == (Object)null || (Object)(object)((Component)machine).gameObject == (Object)null)
			{
				return false;
			}
			try
			{
				action();
				return true;
			}
			catch (Exception ex)
			{
				if (!_isSceneChangeInProgress)
				{
					Logger.Warning("Aborting slot machine spin during " + stepName + ": " + ex.Message);
				}
				return false;
			}
		}

		private static void SetMachineSpinning(SlotMachine? machine, bool isSpinning)
		{
			if ((Object)(object)machine == (Object)null)
			{
				return;
			}
			try
			{
				PropertyInfo property = typeof(SlotMachine).GetProperty("IsSpinning");
				if (property != null && property.CanWrite)
				{
					property.SetValue(machine, isSpinning);
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to set slot machine spinning state: " + ex.Message);
			}
		}

		private static EOutcome EvaluateOutcome(SlotMachine machine, ESymbol[] outcome)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (typeof(SlotMachine).GetMethod("EvaluateOutcome", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(machine, new object[1] { outcome }) is EOutcome result)
				{
					return result;
				}
			}
			catch (Exception ex)
			{
				Logger.Warning("Failed to call EvaluateOutcome via reflection: " + ex.Message);
			}
			if (IsUniform(outcome))
			{
				if ((int)outcome[0] == 5)
				{
					return (EOutcome)0;
				}
				if ((int)outcome[0] == 4)
				{
					return (EOutcome)1;
				}
				if (IsFruit(outcome[0]))
				{
					return (EOutcome)2;
				}
			}
			if (IsAllFruit(outcome))
			{
				return (EOutcome)3;
			}
			return (EOutcome)4;
		}

		private static int GetWinAmount(EOutcome outcome, int betAmount)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			int result = (int)outcome switch
			{
				0 => betAmount * 100, 
				1 => betAmount * 25, 
				2 => betAmount * 10, 
				3 => betAmount * 2, 
				_ => 0, 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		private static bool IsUniform(ESymbol[] symbols)
		{
			for (int i = 1; i < symbols.Length; i++)
			{
				if ((int)symbols[i] != (int)symbols[i - 1])
				{
					return false;
				}
			}
			return true;
		}

		private static bool IsFruit(ESymbol symbol)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			return (int)symbol == 0 || (int)symbol == 1 || (int)symbol == 2 || (int)symbol == 3;
		}

		private static bool IsAllFruit(ESymbol[] symbols)
		{
			for (int i = 0; i < symbols.Length; i++)
			{
				if (!IsFruit(symbols[i]))
				{
					return false;
				}
			}
			return true;
		}
	}
}
namespace S1API.Cartel
{
	public sealed class Cartel
	{
		private class EventWrapper
		{
			private readonly Action<CartelStatus, CartelStatus> _handler;

			public EventWrapper(Action<CartelStatus, CartelStatus> handler)
			{
				_handler = handler;
			}

			public void Handle(ECartelStatus oldStatus, ECartelStatus newStatus)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				_handler?.Invoke(ConvertStatus(oldStatus), ConvertStatus(newStatus));
			}

			private static CartelStatus ConvertStatus(object status)
			{
				if (status == null)
				{
					return CartelStatus.Unknown;
				}
				int num = (int)status;
				if (1 == 0)
				{
				}
				CartelStatus result = num switch
				{
					0 => CartelStatus.Unknown, 
					1 => CartelStatus.Truced, 
					2 => CartelStatus.Hostile, 
					3 => CartelStatus.Defeated, 
					_ => CartelStatus.Unknown, 
				};
				if (1 == 0)
				{
				}
				return result;
			}
		}

		private static Cartel? _cachedInstance;

		private static Cartel? _lastS1Cartel;

		private static readonly Dictionary<Action<CartelStatus, CartelStatus>, object> _eventDelegates = new Dictionary<Action<CartelStatus, CartelStatus>, object>();

		internal readonly Cartel S1Cartel;

		public static Cartel? Instance
		{
			get
			{
				Cartel instance = NetworkSingleton<Cartel>.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					_cachedInstance = null;
					_lastS1Cartel = null;
					return null;
				}
				if (_cachedInstance != null && (Object)(object)_lastS1Cartel == (Object)(object)instance)
				{
					return _cachedInstance;
				}
				_cachedInstance = new Cartel(instance);
				_lastS1Cartel = instance;
				return _cachedInstance;
			}
		}

		public CartelStatus Status => ConvertStatus(S1Cartel.Status);

		public int HoursSinceStatusChange => S1Cartel.HoursSinceStatusChange;

		public GoonManager? GoonPool
		{
			get
			{
				GoonPool goonPool = S1Cartel.GoonPool;
				if ((Object)(object)goonPool == (Object)null)
				{
					return null;
				}
				return new GoonManager(goonPool);
			}
		}

		public CartelInfluence? Influence
		{
			get
			{
				CartelInfluence influence = S1Cartel.Influence;
				if ((Object)(object)influence == (Object)null)
				{
					return null;
				}
				return new CartelInfluence(influence);
			}
		}

		public event Action<CartelStatus, CartelStatus> OnStatusChange
		{
			add
			{
				if (value == null)
				{
					return;
				}
				EventInfo eventInfo = typeof(Cartel).GetEvent("OnStatusChange", BindingFlags.Instance | BindingFlags.Public);
				if (eventInfo == null)
				{
					return;
				}
				Type typeFromHandle = typeof(ECartelStatus);
				Type type = typeof(Action<, >).MakeGenericType(typeFromHandle, typeFromHandle);
				EventWrapper firstArgument = new EventWrapper(value);
				MethodInfo method = typeof(EventWrapper).GetMethod("Handle", BindingFlags.Instance | BindingFlags.Public);
				if (method == null)
				{
					return;
				}
				Delegate obj = Delegate.CreateDelegate(type, firstArgument, method);
				Type type2 = typeof(Action<, >).MakeGenericType(typeFromHandle, typeFromHandle);
				MethodInfo method2 = typeof(DelegateSupport).GetMethod("ConvertDelegate", BindingFlags.Static | BindingFlags.Public);
				if (!(method2 == null))
				{
					MethodInfo methodInfo = method2.MakeGenericMethod(type2);
					object obj2 = methodInfo.Invoke(null, new object[1] { obj });
					if (obj2 != null)
					{
						eventInfo.GetAddMethod()?.Invoke(S1Cartel, new object[1] { obj2 });
						_eventDelegates[value] = obj2;
					}
				}
			}
			remove
			{
				if (value != null && _eventDelegates.TryGetValue(value, out object value2))
				{
					EventInfo eventInfo = typeof(Cartel).GetEvent("OnStatusChange", BindingFlags.Instance | BindingFlags.Public);
					if (eventInfo != null)
					{
						eventInfo.GetRemoveMethod()?.Invoke(S1Cartel, new object[1] { value2 });
					}
					_eventDelegates.Remove(value);
				}
			}
		}

		internal Cartel(Cartel cartel)
		{
			S1Cartel = cartel;
		}

		public void SetStatus(CartelStatus status, bool resetTimer = true)
		{
			S1Cartel.SetStatus_Server((ECartelStatus)status, resetTimer);
		}

		private static CartelStatus ConvertStatus(object status)
		{
			if (status == null)
			{
				return CartelStatus.Unknown;
			}
			int num = (int)status;
			if (1 == 0)
			{
			}
			CartelStatus result = num switch
			{
				0 => CartelStatus.Unknown, 
				1 => CartelStatus.Truced, 
				2 => CartelStatus.Hostile, 
				3 => CartelStatus.Defeated, 
				_ => CartelStatus.Unknown, 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class CartelGoon
	{
		internal readonly CartelGoon S1Goon;

		public bool IsConscious => ((NPC)S1Goon).IsConscious;

		public bool IsSpawned => ((NetworkBehaviour)S1Goon).IsSpawned;

		public Vector3 Position => ((Component)S1Goon).transform.position;

		public GameObject GameObject => ((Component)S1Goon).gameObject;

		internal CartelGoon(CartelGoon goon)
		{
			S1Goon = goon;
		}

		public void WarpTo(Vector3 position)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			NPCMovement movement = ((NPC)S1Goon).Movement;
			if (movement != null)
			{
				movement.Warp(position);
			}
		}

		public void AttackPlayer()
		{
			Player local = Player.Local;
			if (!((Object)(object)local == (Object)null))
			{
				ICombatTargetable component = ((Component)local).GetComponent<ICombatTargetable>();
				if (component != null)
				{
					S1Goon.AttackEntity(component, true);
				}
			}
		}

		public void Attack(IEntity target)
		{
			if (!((Object)(object)target?.gameObject == (Object)null))
			{
				ICombatTargetable component = target.gameObject.GetComponent<ICombatTargetable>();
				if (component != null)
				{
					S1Goon.AttackEntity(component, true);
				}
			}
		}

		public void Despawn()
		{
			S1Goon.Despawn();
		}

		public void SetDefaultWeapon(string? weaponAssetPath)
		{
			NPCBehaviour behaviour = ((NPC)S1Goon).Behaviour;
			CombatBehaviour val = ((behaviour != null) ? behaviour.CombatBehaviour : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if (string.IsNullOrEmpty(weaponAssetPath))
			{
				SetCombatDefaultWeapon(val, null);
				return;
			}
			Object obj = Resources.Load(weaponAssetPath);
			GameObject val2 = (GameObject)(object)((obj is GameObject) ? obj : null);
			if ((Object)(object)val2 != (Object)null)
			{
				AvatarWeapon component = Object.Instantiate<GameObject>(val2).GetComponent<AvatarWeapon>();
				SetCombatDefaultWeapon(val, component);
			}
		}

		private static void SetCombatDefaultWeapon(object combatBehaviour, object? weapon)
		{
			MethodInfo method = combatBehaviour.GetType().GetMethod("SetDefaultWeapon", BindingFlags.Instance | BindingFlags.Public);
			if (method != null)
			{
				method.Invoke(combatBehaviour, new object[1] { weapon });
			}
			else if (!global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(combatBehaviour, "DefaultWeapon", weapon))
			{
				global::S1API.Internal.Utils.ReflectionUtils.TrySetFieldOrProperty(combatBehaviour, "_defaultWeapon", weapon);
			}
		}
	}
	public class CartelInfluence
	{
		internal readonly CartelInfluence S1Influence;

		internal CartelInfluence(CartelInfluence influence)
		{
			S1Influence = influence;
		}

		public float GetInfluence(Region region)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			return S1Influence.GetInfluence(ConvertToGameRegion(region));
		}

		public void ChangeInfluence(Region region, float amount)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			S1Influence.ChangeInfluence(ConvertToGameRegion(region), amount);
		}

		private static EMapRegion ConvertToGameRegion(Region region)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return (EMapRegion)region;
		}
	}
	public enum CartelStatus
	{
		Unknown,
		Truced,
		Hostile,
		Defeated
	}
	public class GoonManager
	{
		internal readonly GoonPool S1GoonPool;

		public int AvailableGoonCount => S1GoonPool.UnspawnedGoonCount;

		internal GoonManager(GoonPool goonPool)
		{
			S1GoonPool = goonPool;
		}

		public CartelGoon? SpawnGoon(Vector3 position)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (AvailableGoonCount == 0)
			{
				return null;
			}
			List<CartelGoon> val = S1GoonPool.SpawnMultipleGoons(position, 1, true);
			if (val == null || val.Count == 0)
			{
				return null;
			}
			return new CartelGoon(val[0]);
		}

		public List<CartelGoon> SpawnGoons(Vector3 position, int count)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			List<CartelGoon> list = new List<CartelGoon>();
			if (count <= 0 || AvailableGoonCount == 0)
			{
				return list;
			}
			int num = Math.Min(count, AvailableGoonCount);
			List<CartelGoon> val = S1GoonPool.SpawnMultipleGoons(position, num, true);
			if (val == null)
			{
				return list;
			}
			Enumerator<CartelGoon> enumerator = val.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CartelGoon current = enumerator.Current;
				if ((Object)(object)current != (Object)null)
				{
					list.Add(new CartelGoon(current));
				}
			}
			return list;
		}

		public List<CartelGoon> SpawnGoonsAtPositions(Vector3[] positions)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			List<CartelGoon> list = new List<CartelGoon>();
			if (positions == null || positions.Length == 0)
			{
				return list;
			}
			List<CartelGoon> list2 = SpawnGoons(positions[0], positions.Length);
			for (int i = 0; i < list2.Count && i < positions.Length; i++)
			{
				list2[i].WarpTo(positions[i]);
				list.Add(list2[i]);
			}
			return list;
		}
	}
}
namespace S1API.Building
{
	public class BuildEventArgs
	{
		public ItemInstance ItemInstance { get; internal set; }

		public GameObject GameObject { get; internal set; }

		public string? ItemId => ItemInstance?.Definition?.ID;

		public StorageEntity? Storage { get; internal set; }

		internal BuildEventArgs(ItemInstance itemInstance, GameObject gameObject, StorageEntity? storage = null)
		{
			ItemInstance = itemInstance;
			GameObject = gameObject;
			Storage = storage;
		}
	}
	public static class BuildEvents
	{
		private static readonly Log Logger = new Log("BuildEvents");

		public static event Action<BuildEventArgs>? OnGridItemCreated;

		public static event Action<BuildEventArgs>? OnSurfaceItemCreated;

		public static event Action<BuildEventArgs>? OnBuildableItemInitialized;

		internal static void RaiseGridItemCreated(BuildEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				BuildEvents.OnGridItemCreated?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnGridItemCreated handler for item '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}

		internal static void RaiseSurfaceItemCreated(BuildEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				BuildEvents.OnSurfaceItemCreated?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnSurfaceItemCreated handler for item '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}

		internal static void RaiseBuildableItemInitialized(BuildEventArgs args)
		{
			if (args == null)
			{
				return;
			}
			try
			{
				BuildEvents.OnBuildableItemInitialized?.Invoke(args);
			}
			catch (Exception ex)
			{
				Logger.Error($"Exception in OnBuildableItemInitialized handler for item '{args.ItemId}': {ex.Message}\n{ex.StackTrace}");
			}
		}
	}
	public static class BuildManager
	{
		public static bool IsBuilding => NetworkSingleton<BuildManager>.Instance.isBuilding;

		public static GameObject? CurrentBuildHandler => NetworkSingleton<BuildManager>.Instance.currentBuildHandler;

		public static void StartBuilding(ItemInstance item)
		{
			NetworkSingleton<BuildManager>.Instance.StartBuilding(item.S1ItemInstance);
		}

		public static void StopBuilding()
		{
			NetworkSingleton<BuildManager>.Instance.StopBuilding();
		}

		public static GameObject CreateGridItem(ItemInstance item, Grid grid, Vector2 originCoordinate, int rotation, string guid = "")
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			GridItem val = NetworkSingleton<BuildManager>.Instance.CreateGridItem(item.S1ItemInstance, grid, originCoordinate, rotation, guid, (Action<GridItem>)null);
			return ((Component)val).gameObject;
		}

		public static GameObject CreateSurfaceItem(ItemInstance item, Surface parentSurface, Vector3 relativePosition, Quaternion relativeRotation, string guid = "")
		{
			//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)
			SurfaceItem val = NetworkSingleton<BuildManager>.Instance.CreateSurfaceItem(item.S1ItemInstance, parentSurface, relativePosition, relativeRotation, guid);
			return ((Component)val).gameObject;
		}
	}
}
namespace S1API.Avatar
{
	public sealed class Avatar
	{
		internal readonly Avatar S1Avatar;

		public GameObject? GameObject
		{
			get
			{
				Avatar s1Avatar = S1Avatar;
				return (s1Avatar != null) ? ((Component)s1Avatar).gameObject : null;
			}
		}

		public bool IsActive => (Object)(object)S1Avatar != (Object)null && (Object)(object)((Component)S1Avatar).gameObject != (Object)null && ((Component)S1Avatar).gameObject.activeSelf;

		internal Avatar(Avatar avatar)
		{
			S1Avatar = avatar;
		}

		public void LoadAvatarSettings(AvatarSettings settings)
		{
			if (!((Object)(object)S1Avatar == (Object)null) && !((Object)(object)settings?.S1AvatarSettings == (Object)null))
			{
				S1Avatar.LoadAvatarSettings(settings.S1AvatarSettings);
			}
		}

		public static Avatar[] FindInScene(bool includeInactive = false)
		{
			Il2CppArrayBase<Avatar> val = Object.FindObjectsOfType<Avatar>(includeInactive);
			if (val == null || val.Length == 0)
			{
				return Array.Empty<Avatar>();
			}
			return (from a in (IEnumerable<Avatar>)val
				where (Object)(object)a != (Object)null
				select new Avatar(a)).ToArray();
		}
	}
	public sealed class AvatarSettings
	{
		public sealed class EyeLidConfiguration
		{
			public float TopLidOpen { get; set; }

			public float BottomLidOpen { get; set; }
		}

		public sealed class LayerSetting
		{
			public string LayerPath { get; set; } = string.Empty;

			public Color LayerTint { get; set; }
		}

		public sealed class AccessorySetting
		{
			public string Path { get; set; } = string.Empty;

			public Color Color { get; set; }
		}

		internal readonly AvatarSettings S1AvatarSettings;

		public float Gender
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.Gender : 0.5f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.Gender = value;
				}
			}
		}

		public float Height
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.Height : 1f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.Height = value;
				}
			}
		}

		public float Weight
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.Weight : 0.5f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.Weight = value;
				}
			}
		}

		public Color32 SkinColor
		{
			get
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return Color32.op_Implicit((s1AvatarSettings != null) ? s1AvatarSettings.SkinColor : Color32.op_Implicit(new Color32((byte)150, (byte)120, (byte)95, byte.MaxValue)));
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.SkinColor = Color32.op_Implicit(value);
				}
			}
		}

		public string HairPath
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return ((s1AvatarSettings != null) ? s1AvatarSettings.HairPath : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.HairPath = value ?? string.Empty;
				}
			}
		}

		public Color HairColor
		{
			get
			{
				//IL_0011: 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)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.HairColor : Color.black;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.HairColor = value;
				}
			}
		}

		public Color32 LeftEyeLidColor
		{
			get
			{
				//IL_0017: 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_0010: 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)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return Color32.op_Implicit((s1AvatarSettings != null) ? s1AvatarSettings.LeftEyeLidColor : Color32.op_Implicit(SkinColor));
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.LeftEyeLidColor = Color32.op_Implicit(value);
				}
			}
		}

		public Color32 RightEyeLidColor
		{
			get
			{
				//IL_0017: 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_0010: 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)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return Color32.op_Implicit((s1AvatarSettings != null) ? s1AvatarSettings.RightEyeLidColor : Color32.op_Implicit(SkinColor));
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.RightEyeLidColor = Color32.op_Implicit(value);
				}
			}
		}

		public Color EyeBallTint
		{
			get
			{
				//IL_0011: 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)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.EyeBallTint : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyeBallTint = value;
				}
			}
		}

		public float PupilDilation
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.PupilDilation : 0.5f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.PupilDilation = value;
				}
			}
		}

		public string EyeballMaterialIdentifier
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return ((s1AvatarSettings != null) ? s1AvatarSettings.EyeballMaterialIdentifier : null) ?? "Default";
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyeballMaterialIdentifier = value ?? "Default";
				}
			}
		}

		public float EyebrowScale
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.EyebrowScale : 1f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyebrowScale = value;
				}
			}
		}

		public float EyebrowThickness
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.EyebrowThickness : 1f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyebrowThickness = value;
				}
			}
		}

		public float EyebrowRestingHeight
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.EyebrowRestingHeight : 0f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyebrowRestingHeight = value;
				}
			}
		}

		public float EyebrowRestingAngle
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return (s1AvatarSettings != null) ? s1AvatarSettings.EyebrowRestingAngle : 0f;
			}
			set
			{
				if ((Object)(object)S1AvatarSettings != (Object)null)
				{
					S1AvatarSettings.EyebrowRestingAngle = value;
				}
			}
		}

		public EyeLidConfiguration LeftEyeRestingState
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				if (s1AvatarSettings != null)
				{
					_ = s1AvatarSettings.LeftEyeRestingState;
					if (0 == 0)
					{
						return new EyeLidConfiguration
						{
							TopLidOpen = S1AvatarSettings.LeftEyeRestingState.topLidOpen,
							BottomLidOpen = S1AvatarSettings.LeftEyeRestingState.bottomLidOpen
						};
					}
				}
				return new EyeLidConfiguration
				{
					TopLidOpen = 0.5f,
					BottomLidOpen = 0.5f
				};
			}
			set
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null && value != null)
				{
					S1AvatarSettings.LeftEyeRestingState = new EyeLidConfiguration
					{
						topLidOpen = value.TopLidOpen,
						bottomLidOpen = value.BottomLidOpen
					};
				}
			}
		}

		public EyeLidConfiguration RightEyeRestingState
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				if (s1AvatarSettings != null)
				{
					_ = s1AvatarSettings.RightEyeRestingState;
					if (0 == 0)
					{
						return new EyeLidConfiguration
						{
							TopLidOpen = S1AvatarSettings.RightEyeRestingState.topLidOpen,
							BottomLidOpen = S1AvatarSettings.RightEyeRestingState.bottomLidOpen
						};
					}
				}
				return new EyeLidConfiguration
				{
					TopLidOpen = 0.5f,
					BottomLidOpen = 0.5f
				};
			}
			set
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1AvatarSettings != (Object)null && value != null)
				{
					S1AvatarSettings.RightEyeRestingState = new EyeLidConfiguration
					{
						topLidOpen = value.TopLidOpen,
						bottomLidOpen = value.BottomLidOpen
					};
				}
			}
		}

		public int FaceLayerCount
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return ((s1AvatarSettings == null) ? ((int?)null) : s1AvatarSettings.FaceLayerSettings?.Count).GetValueOrDefault();
			}
		}

		public int BodyLayerCount
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return ((s1AvatarSettings == null) ? ((int?)null) : s1AvatarSettings.BodyLayerSettings?.Count).GetValueOrDefault();
			}
		}

		public int AccessoryCount
		{
			get
			{
				AvatarSettings s1AvatarSettings = S1AvatarSettings;
				return ((s1AvatarSettings == null) ? ((int?)null) : s1AvatarSettings.AccessorySettings?.Count).GetValueOrDefault();
			}
		}

		internal AvatarSettings(AvatarSettings settings)
		{
			S1AvatarSettings = settings;
		}

		public static AvatarSettings Create()
		{
			AvatarSettings val = ScriptableObject.CreateInstance<AvatarSettings>();
			((Object)val).hideFlags = (HideFlags)32;
			return new AvatarSettings(val);
		}

		public void AddFaceLayer(string layerPath, Color layerTint)
		{
			//IL_004e: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if (!((Object)(object)S1AvatarSettings == (Object)null) && !string.IsNullOrWhiteSpace(layerPath))
			{
				if (S1AvatarSettings.FaceLayerSettings == null)
				{
					S1AvatarSettings.FaceLayerSettings = new List<LayerSetting>();
				}
				S1AvatarSettings.FaceLayerSettings.Add(new LayerSetting
				{
					layerPath = layerPath,
					layerTint = layerTint
				});
			}
		}

		public void AddBodyLayer(string layerPath, Color layerTint)
		{
			//IL_004e: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if (!((Object)(object)S1AvatarSettings == (Object)null) && !string.IsNullOrWhiteSpace(layerPath))
			{
				if (S1AvatarSettings.BodyLayerSettings == null)
				{
					S1AvatarSettings.BodyLayerSettings = new List<LayerSetting>();
				}
				S1AvatarSettings.BodyLayerSettings.Add(new LayerSetting
				{
					layerPath = layerPath,
					layerTint = layerTint
				});
			}
		}

		public void AddAccessory(string path, Color color)
		{
			//IL_004e: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			if (!((Object)(object)S1AvatarSettings == (Object)null) && !string.IsNullOrWhiteSpace(path))
			{
				if (S1AvatarSettings.AccessorySettings == null)
				{
					S1AvatarSettings.AccessorySettings = new List<AccessorySetting>();
				}
				S1AvatarSettings.AccessorySettings.Add(new AccessorySetting
				{
					path = path,
					color = color
				});
			}
		}

		public void SetFaceLayers(List<LayerSetting> layers)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0076: Expected O, but got Unknown
			if ((Object)(object)S1AvatarSettings == (Object)null)
			{
				return;
			}
			List<LayerSetting> val = new List<LayerSetting>();
			if (layers != null)
			{
				foreach (LayerSetting layer in layers)
				{
					if (!string.IsNullOrWhiteSpace(layer.LayerPath))
					{
						val.Add(new LayerSetting
						{
							layerPath = layer.LayerPath,
							layerTint = layer.LayerTint
						});
					}
				}
			}
			S1AvatarSettings.FaceLayerSettings = val;
		}

		public void SetBodyLayers(List<LayerSetting> layers)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0076: Expected O, but got Unknown
			if ((Object)(object)S1AvatarSettings == (Object)null)
			{
				return;
			}
			List<LayerSetting> val = new List<LayerSetting>();
			if (layers != null)
			{
				foreach (LayerSetting layer in layers)
				{
					if (!string.IsNullOrWhiteSpace(layer.LayerPath))
					{
						val.Add(new LayerSetting
						{
							layerPath = layer.LayerPath,
							layerTint = layer.LayerTint
						});
					}
				}
			}
			S1AvatarSettings.BodyLayerSettings = val;
		}

		public void SetAccessories(List<AccessorySetting> accessories)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0076: Expected O, but got Unknown
			if ((Object)(object)S1AvatarSettings == (Object)null)
			{
				return;
			}
			List<AccessorySetting> val = new List<AccessorySetting>();
			if (accessories != null)
			{
				foreach (AccessorySetting accessory in accessories)
				{
					if (!string.IsNullOrWhiteSpace(accessory.Path))
					{
						val.Add(new AccessorySetting
						{
							path = accessory.Path,
							color = accessory.Color
						});
					}
				}
			}
			S1AvatarSettings.AccessorySettings = val;
		}

		public List<LayerSetting> GetFaceLayers()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			List<LayerSetting> list = new List<LayerSetting>();
			AvatarSettings s1AvatarSettings = S1AvatarSettings;
			if (((s1AvatarSettings != null) ? s1AvatarSettings.FaceLayerSettings : null) == null)
			{
				return list;
			}
			for (int i = 0; i < S1AvatarSettings.FaceLayerSettings.Count; i++)
			{
				LayerSetting val = S1AvatarSettings.FaceLayerSettings[i];
				list.Add(new LayerSetting
				{
					LayerPath = (val.layerPath ?? string.Empty),
					LayerTint = val.layerTint
				});
			}
			return list;
		}

		public List<LayerSetting> GetBodyLayers()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			List<LayerSetting> list = new List<LayerSetting>();
			AvatarSettings s1AvatarSettings = S1AvatarSettings;
			if (((s1AvatarSettings != null) ? s1AvatarSettings.BodyLayerSettings : null) == null)
			{
				return list;
			}
			for (int i = 0; i < S1AvatarSettings.BodyLayerSettings.Count; i++)
			{
				LayerSetting val = S1AvatarSettings.BodyLayerSettings[i];
				list.Add(new LayerSetting
				{
					LayerPath = (val.layerPath ?? string.Empty),
					LayerTint = val.layerTint
				});
			}
			return list;
		}

		public List<AccessorySetting> GetAccessories()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			List<AccessorySetting> list = new List<AccessorySetting>();
			AvatarSettings s1AvatarSettings = S1AvatarSettings;
			if (((s1AvatarSettings != null) ? s1AvatarSettings.AccessorySettings : null) == null)
			{
				return list;
			}
			for (int i = 0; i < S1AvatarSettings.AccessorySettings.Count; i++)
			{
				AccessorySetting val = S1AvatarSettings.AccessorySettings[i];
				list.Add(new AccessorySetting
				{
					Path = (val.path ?? string.Empty),
					Color = val.color
				});
			}
			return list;
		}
	}
	public sealed class BasicAvatarSettings
	{
		internal readonly BasicAvatarSettings S1BasicAvatarSettings;

		public int Gender
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Gender : 0;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Gender = value;
				}
			}
		}

		public float Weight
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Weight : 0.5f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Weight = value;
				}
			}
		}

		public Color SkinColor
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (Color)((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.SkinColor : new Color(0.6f, 0.5f, 0.4f));
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.SkinColor = value;
				}
			}
		}

		public string HairStyle
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.HairStyle : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.HairStyle = value ?? string.Empty;
				}
			}
		}

		public Color HairColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.HairColor : Color.black;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.HairColor = value;
				}
			}
		}

		public string Mouth
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Mouth : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Mouth = value ?? string.Empty;
				}
			}
		}

		public string FacialHair
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.FacialHair : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.FacialHair = value ?? string.Empty;
				}
			}
		}

		public string FacialDetails
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.FacialDetails : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.FacialDetails = value ?? string.Empty;
				}
			}
		}

		public float FacialDetailsIntensity
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.FacialDetailsIntensity : 0f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.FacialDetailsIntensity = value;
				}
			}
		}

		public Color EyeballColor
		{
			get
			{
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (Color)((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyeballColor : new Color(0.2f, 0.4f, 0.6f));
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyeballColor = value;
				}
			}
		}

		public float UpperEyeLidRestingPosition
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.UpperEyeLidRestingPosition : 0.5f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.UpperEyeLidRestingPosition = value;
				}
			}
		}

		public float LowerEyeLidRestingPosition
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.LowerEyeLidRestingPosition : 0.5f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.LowerEyeLidRestingPosition = value;
				}
			}
		}

		public float PupilDilation
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.PupilDilation : 1f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.PupilDilation = value;
				}
			}
		}

		public float EyebrowScale
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyebrowScale : 1f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyebrowScale = value;
				}
			}
		}

		public float EyebrowThickness
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyebrowThickness : 1f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyebrowThickness = value;
				}
			}
		}

		public float EyebrowRestingHeight
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyebrowRestingHeight : 0f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyebrowRestingHeight = value;
				}
			}
		}

		public float EyebrowRestingAngle
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyebrowRestingAngle : 0f;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyebrowRestingAngle = value;
				}
			}
		}

		public string Top
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Top : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Top = value ?? string.Empty;
				}
			}
		}

		public Color TopColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.TopColor : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.TopColor = value;
				}
			}
		}

		public string Bottom
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Bottom : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Bottom = value ?? string.Empty;
				}
			}
		}

		public Color BottomColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.BottomColor : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.BottomColor = value;
				}
			}
		}

		public string Shoes
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Shoes : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Shoes = value ?? string.Empty;
				}
			}
		}

		public Color ShoesColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.ShoesColor : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.ShoesColor = value;
				}
			}
		}

		public string Headwear
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Headwear : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Headwear = value ?? string.Empty;
				}
			}
		}

		public Color HeadwearColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.HeadwearColor : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.HeadwearColor = value;
				}
			}
		}

		public string Eyewear
		{
			get
			{
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return ((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Eyewear : null) ?? string.Empty;
			}
			set
			{
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.Eyewear = value ?? string.Empty;
				}
			}
		}

		public Color EyewearColor
		{
			get
			{
				//IL_0011: 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)
				BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
				return (s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.EyewearColor : Color.white;
			}
			set
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)S1BasicAvatarSettings != (Object)null)
				{
					S1BasicAvatarSettings.EyewearColor = value;
				}
			}
		}

		internal BasicAvatarSettings(BasicAvatarSettings settings)
		{
			S1BasicAvatarSettings = settings;
		}

		public static BasicAvatarSettings Create()
		{
			BasicAvatarSettings val = ScriptableObject.CreateInstance<BasicAvatarSettings>();
			((Object)val).hideFlags = (HideFlags)32;
			return new BasicAvatarSettings(val);
		}

		public List<string> GetTattoos()
		{
			List<string> list = new List<string>();
			BasicAvatarSettings s1BasicAvatarSettings = S1BasicAvatarSettings;
			if (((s1BasicAvatarSettings != null) ? s1BasicAvatarSettings.Tattoos : null) == null)
			{
				return list;
			}
			for (int i = 0; i < S1BasicAvatarSettings.Tattoos.Count; i++)
			{
				list.Add(S1BasicAvatarSettings.Tattoos[i] ?? string.Empty);
			}
			return list;
		}

		public void SetTattoos(List<string> tattoos)
		{
			if ((Object)(object)S1BasicAvatarSettings == (Object)null)
			{
				return;
			}
			List<string> val = new List<string>();
			if (tattoos != null)
			{
				foreach (string tattoo in tattoos)
				{
					if (!string.IsNullOrWhiteSpace(tattoo))
					{
						val.Add(tattoo);
					}
				}
			}
			S1BasicAvatarSettings.Tattoos = val;
		}

		public void AddTattoo(string tattooPath)
		{
			if (!((Object)(object)S1BasicAvatarSettings == (Object)null) && !string.IsNullOrWhiteSpace(tattooPath))
			{
				if (S1BasicAvatarSettings.Tattoos == null)
				{
					S1BasicAvatarSettings.Tattoos = new List<string>();
				}
				S1BasicAvatarSettings.Tattoos.Add(tattooPath);
			}
		}

		public AvatarSettings ToAvatarSettings()
		{
			if ((Object)(object)S1BasicAvatarSettings == (Object)null)
			{
				return AvatarSettings.Create();
			}
			AvatarSettings avatarSettings = S1BasicAvatarSettings.GetAvatarSettings();
			return new AvatarSettings(avatarSettings);
		}

		public void SetValue<T>(string fieldName, T value)
		{
			if (!((Object)(object)S1BasicAvatarSettings == (Object)null) && !string.IsNullOrWhiteSpace(fieldName))
			{
				S1BasicAvatarSettings.SetValue<T>(fieldName, value);
			}
		}

		public T? GetValue<T>(string fieldName)
		{
			if ((Object)(object)S1BasicAvatarSettings == (Object)null || string.IsNullOrWhiteSpace(fieldName))
			{
				return default(T);
			}
			return S1BasicAvatarSettings.GetValue<T>(fieldName);
		}
	}
	public sealed class Seat
	{
		internal static readonly List<Seat> All = new List<Seat>();

		private readonly WeakReference<AvatarSeat> seatReference;

		private readonly WeakReference<AvatarSeatSet>? seatSetReference;

		private readonly Transform? seatTransform;

		private readonly Transform? sittingPoint;

		private readonly Transform? accessPoint;

		private readonly string hierarchyPath;

		private readonly string seatSetName;

		private readonly int? seatIndex;

		public string Label
		{
			get
			{
				if (!string.IsNullOrEmpty(seatSetName))
				{
					return seatIndex.HasValue ? $"{seatSetName}[{seatIndex.Value}] ({HierarchyPath})" : (seatSetName + " (" + HierarchyPath + ")");
				}
				return HierarchyPath;
			}
		}

		public string HierarchyPath => hierarchyPath;

		public string SeatSetName => seatSetName;

		public int? IndexInSet => seatIndex;

		public Vector3 SittingPosition
		{
			get
			{
				//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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: 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_0045: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)sittingPoint != (Object)null)
				{
					return sittingPoint.position;
				}
				if ((Object)(object)seatTransform != (Object)null)
				{
					return seatTransform.position;
				}
				return Vector3.zero;
			}
		}

		public Quaternion SittingRotation
		{
			get
			{
				//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_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: 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_0045: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)sittingPoint != (Object)null)
				{
					return sittingPoint.rotation;
				}
				if ((Object)(object)seatTransform != (Object)null)
				{
					return seatTransform.rotation;
				}
				return Quaternion.identity;
			}
		}

		public Vector3 AccessPosition
		{
			get
			{
				//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_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_0028: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)accessPoint != (Object)null)
				{
					return accessPoint.position;
				}
				return SittingPosition;
			}
		}

		public Quaternion AccessRotation
		{
			get
			{
				//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_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_0028: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)accessPoint != (Object)null)
				{
					return accessPoint.rotation;
				}
				return SittingRotation;
			}
		}

		public static int Count => All.Count;

		private Seat(AvatarSeat seat)
		{
			seatReference = new WeakReference<AvatarSeat>(seat);
			seatTransform = (((Object)(object)seat != (Object)null) ? ((Component)seat).transform : null);
			sittingPoint = ((seat != null) ? seat.SittingPoint : null);
			accessPoint = ((seat != null) ? seat.AccessPoint : null);
			hierarchyPath = BuildTransformPath(seatTransform);
			AvatarSeatSet val = (AvatarSeatSet)(((Object)(object)seat != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)val != (Object)null)
			{
				seatSetReference = new WeakReference<AvatarSeatSet>(val);
				GameObject gameObject = ((Component)val).gameObject;
				seatSetName = (((Object)(object)gameObject != (Object)null) ? ((Object)gameObject).name : string.Empty);
				try
				{
					if (val.Seats == null)
					{
						return;
					}
					for (int i = 0; i < ((Il2CppArrayBase<AvatarSeat>)(object)val.Seats).Length; i++)
					{
						if (((Il2CppArrayBase<AvatarSeat>)(object)val.Seats)[i] == seat)
						{
							seatIndex = i;
							break;
						}
					}
					return;
				}
				catch
				{
					return;
				}
			}
			seatSetName = string.Empty;
		}

		public AvatarSeat? ResolveGameSeat()
		{
			seatReference.TryGetTarget(out AvatarSeat target);
			return target;
		}

		public AvatarSeatSet? ResolveSeatSet()
		{
			if (seatSetReference == null)
			{
				return null;
			}
			seatSetReference.TryGetTarget(out AvatarSeatSet target);
			return target;
		}

		public GameObject? ResolveSeatGameObject()
		{
			AvatarSeat val = ResolveGameSeat();
			return ((Object)(object)val != (Object)null) ? ((Component)val).gameObject : null;
		}

		public static Seat[] GetAll()
		{
			return All.ToArray();
		}

		public static Seat[] GetBySeatSet(string setName)
		{
			if (string.IsNullOrEmpty(setName))
			{
				return Array.Empty<Seat>();
			}
			return All.Where((Seat s) => !string.IsNullOrEmpty(s.seatSetName) && string.Equals(s.seatSetName, setName, StringComparison.OrdinalIgnoreCase)).ToArray();
		}

		public static Seat? FindByPathSuffix(string pathSuffix)
		{
			if (string.IsNullOrEmpty(pathSuffix))
			{
				return null;
			}
			for (int i = 0; i < All.Count; i++)
			{
				Seat seat = All[i];
				if (seat != null && seat.HierarchyPath.EndsWith(pathSuffix, StringComparison.OrdinalIgnoreCase))
				{
					return seat;
				}
			}
			return null;
		}

		internal static void Register(AvatarSeat seat)
		{
			if ((Object)(object)seat == (Object)null)
			{
				return;
			}
			for (int i = 0; i < All.Count; i++)
			{
				if ((Object)(object)All[i]?.ResolveGameSeat() == (Object)(object)seat)
				{
					All[i] = new Seat(seat);
					return;
				}
			}
			All.Add(new Seat(seat));
		}

		internal static void Unregister(AvatarSeat seat)
		{
			if ((Object)(object)seat == (Object)null)
			{
				return;
			}
			for (int num = All.Count - 1; num >= 0; num--)
			{
				Seat seat2 = All[num];
				if (seat2 == null || (Object)(object)seat2.ResolveGameSeat() == (Object)(object)seat)
				{
					All.RemoveAt(num);
				}
			}
		}

		internal static void Clear()
		{
			All.Clear();
		}

		private static string BuildTransformPath(Transform? transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(96);
			AppendRecursive(transform, stringBuilder);
			return stringBuilder.ToString();
		}

		private static void AppendRecursive(Transform current, StringBuilder builder)
		{
			if ((Object)(object)current == (Object)null)
			{
				return;
			}
			if ((Object)(object)current.parent != (Object)null)
			{
				AppendRecursive(current.parent, builder);
				if (builder.Length > 0)
				{
					builder.Append('/');
				}
			}
			builder.Append(((Object)current).name);
		}
	}
}
namespace S1API.AssetBundles
{
	public static class AssetLoader
	{
		private static readonly Log _logger = new Log("AssetLoader");

		private static readonly Dictionary<string, WrappedAssetBundle> _cachedAssetBundles = new Dictionary<string, WrappedAssetBundle>();

		public static WrappedAssetBundle GetAssetBundleFromStream(string fullResourceName, Assembly overrideAssembly)
		{
			if (_cachedAssetBundles.TryGetValue(fullResourceName, out WrappedAssetBundle value))
			{
				return value;
			}
			using Stream stream = overrideAssembly.GetManifestResourceStream(fullResourceName);
			if (stream == null)
			{
				throw new Exception($"Embedded resource '{fullResourceName}' not found in {overrideAssembly.FullName}.");
			}
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			Il2CppAssetBundle val = Il2CppAssetBundleManager.LoadFromMemory(Il2CppStructArray<byte>.op_Implicit(array));
			if (val == null)
			{
				throw new Exception("Failed to load AssetBundle from memory: " + fullResourceName);
			}
			WrappedAssetBundle wrappedAssetBundle = new WrappedAssetBundle(val);
			_cachedAssetBundles.TryAdd(fullResourceName, wrappedAssetBundle);
			return wrappedAssetBundle;
		}

		public static T EasyLoad<T>(string bundleName, string objectName) where T : Object
		{
			WrappedAssetBundle bundle;
			return EasyLoad<T>(bundleName, objectName, Assembly.GetExecutingAssembly(), out bundle);
		}

		public static T EasyLoad<T>(string bundleName, string objectName, out WrappedAssetBundle bundle) where T : Object
		{
			return EasyLoad<T>(bundleName, objectName, Assembly.GetExecutingAssembly(), out bundle);
		}

		public static T EasyLoad<T>(string bundleName, string objectName, Assembly assemblyOverride) where T : Object
		{
			WrappedAssetBundle bundle;
			return EasyLoad<T>(bundleName, objectName, assemblyOverride, out bundle);
		}

		public static T EasyLoad<T>(string bundleName, string objectName, Assembly assemblyOverride, out WrappedAssetBundle bundle) where T : Object
		{
			bundle = GetAssetBundleFromStream(assemblyOverride.GetName().Name + "." + bundleName, assemblyOverride);
			return bundle.LoadAsset<T>(objectName);
		}
	}
	public class WrappedAssetBundle
	{
		private readonly Il2CppAssetBundle _realBundle;

		public bool IsStreamedAssetBundle => _realBundle.isStreamedSceneAssetBundle;

		public WrappedAssetBundle(Il2CppAssetBundle realBundle)
		{
			_realBundle = realBundle;
		}

		public bool Contains(string name)
		{
			return _realBundle.Contains(name);
		}

		public string[] GetAllAssetNames()
		{
			return Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)_realBundle.GetAllAssetNames());
		}

		public string[] GetAllScenePaths()
		{
			return Il2CppArrayBase<string>.op_Implicit((Il2CppArrayBase<string>)(object)_realBundle.GetAllScenePaths());
		}

		public Object Load(string name)
		{
			return LoadAsset(name);
		}

		public Object LoadAsset(string name)
		{
			return this.LoadAsset<Object>(name);
		}

		public T Load<T>(string name) where T : Object
		{
			return LoadAsset<T>(name);
		}

		public T LoadAsset<T>(string name) where T : Object
		{
			return _realBundle.LoadAsset<T>(name);
		}

		public Object Load(string name, Type type)
		{
			return LoadAsset(name, type);
		}

		public Object LoadAsset(string name, Type type)
		{
			return _realBundle.LoadAsset(name, type);
		}

		public WrappedAssetBundleRequest LoadAssetAsync(string name)
		{
			return this.LoadAssetAsync<Object>(name);
		}

		public WrappedAssetBundleRequest LoadAssetAsync<T>(string name) where T : Object
		{
			return new WrappedAssetBundleRequest(_realBundle.LoadAssetAsync<T>(name));
		}

		public WrappedAssetBundleRequest LoadAssetAsync(string name, Type type)
		{
			return new WrappedAssetBundleRequest(_realBundle.LoadAssetAsync(name, type));
		}

		public Object[] LoadAll()
		{
			return LoadAllAssets();
		}

		public Object[] LoadAllAssets()
		{
			return this.LoadAllAssets<Object>();
		}

		public T[] LoadAllAssets<T>() where T : Object
		{
			return Il2CppArrayBase<T>.op_Implicit((Il2CppArrayBase<T>)(object)_realBundle.LoadAllAssets<T>());
		}

		public Object[] LoadAllAssets(Type type)
		{
			return Il2CppArrayBase<Object>.op_Implicit((Il2CppArrayBase<Object>)(object)_realBundle.LoadAllAssets(type));
		}

		public Object[] LoadAssetWithSubAssets(string name)
		{
			return this.LoadAssetWithSubAssets<Object>(name);
		}

		public T[] LoadAssetWithSubAssets<T>(string name) where T : Object
		{
			return Il2CppArrayBase<T>.op_Implicit((Il2CppArrayBase<T>)(object)_realBundle.LoadAssetWithSubAssets<T>(name));
		}

		public Object[] LoadAssetWithSubAssets(string name, Type type)
		{
			return Il2CppArrayBase<Object>.op_Implicit((Il2CppArrayBase<Object>)(object)_realBundle.LoadAssetWithSubAssets(name, type));
		}

		public void Unload(bool unloadAllLoadedObjects)
		{
			_realBundle.Unload(unloadAllLoadedObjects);
		}
	}
	public class WrappedAssetBundleRequest
	{
		private readonly Il2CppAssetBundleRequest _realRequest;

		public Object Asset => _realRequest.asset;

		public Object[] AllAssets => Il2CppArrayBase<Object>.op_Implicit((Il2CppArrayBase<Object>)(object)_realRequest.allAssets);

		internal WrappedAssetBundleRequest(Il2CppAssetBundleRequest realRequest)
		{
			_realRequest = realRequest;
		}
	}
}