using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ScrapVisbility")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ScrapVisbility")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8a6853bd-bdc9-4741-95c7-5aa2c8c6a6f9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace LC_MissionRandomizer;

[BepInPlugin("yellowcube.lc.mission_randomizer", "Mission Randomizer", "0.1.25")]
public class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "yellowcube.lc.mission_randomizer";

	public const string PluginName = "Mission Randomizer";

	public const string PluginVersion = "0.1.25";

	internal static ManualLogSource Log;

	internal static Plugin Instance;

	private Harmony harmony;

	internal ConfigEntry<bool> ModEnabled;

	internal ConfigEntry<bool> BlockMoonTerminalCommands;

	internal ConfigEntry<bool> ForceStarterMoon;

	internal ConfigEntry<bool> RestrictTerminalMoonCatalogue;

	internal ConfigEntry<bool> DisableOutsideAndDaytimePower;

	internal ConfigEntry<bool> ShowMonitorStats;

	internal ConfigEntry<bool> DebugLogging;

	internal ConfigEntry<bool> AutoFileDebugLogging;

	internal ConfigEntry<bool> HostDebugTeleportScrapWithP;

	internal ConfigEntry<bool> NormalizeGeneratedScrapValue;

	internal ConfigEntry<bool> EnforceGeneratedScrapCount;

	internal ConfigEntry<bool> PreClampScrapValuesBeforeGeneration;

	internal ConfigEntry<bool> CleaningCompanySupport;

	internal ConfigEntry<int> MinimumTotalScrapValue;

	internal ConfigEntry<int> MaximumTotalScrapValueCap;

	internal ConfigEntry<float> QuotaCoverageMultiplier;

	internal ConfigEntry<int> MinimumScrapCount;

	internal ConfigEntry<int> MaximumScrapCountCap;

	internal ConfigEntry<int> MaximumMissionScrapCount;

	internal ConfigEntry<int> MaximumInsideEnemyPowerCap;

	internal ConfigEntry<int> MaximumMinEnemiesToSpawn;

	internal ConfigEntry<float> MaximumFactorySizeMultiplier;

	internal ConfigEntry<float> MaximumScrapAmountMultiplier;

	internal ConfigEntry<float> MaximumScrapValueMultiplier;

	internal ConfigEntry<float> CleaningCompanyConversionSearchRadius;

	internal ConfigEntry<float> CleaningCompanyConversionWindowSeconds;

	internal ConfigEntry<int> SeedOffset;

	private void Awake()
	{
		//IL_042a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0434: Expected O, but got Unknown
		Instance = this;
		Log = ((BaseUnityPlugin)this).Logger;
		try
		{
			((BaseUnityPlugin)this).Config.SaveOnConfigSet = true;
		}
		catch
		{
		}
		ModEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable or disable the mission randomizer.");
		BlockMoonTerminalCommands = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "BlockMoonTerminalCommands", true, "If true, the moons and route terminal commands are replaced with mission information / blocked.");
		ForceStarterMoon = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ForceStarterMoon", true, "If true, the current level is forced back to the starter moon while in orbit and before loading a level.");
		RestrictTerminalMoonCatalogue = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "RestrictTerminalMoonCatalogue", false, "If true, the terminal moon catalogue is trimmed to only the starter moon and the Company. Leave false if another mod expects the normal catalogue.");
		DisableOutsideAndDaytimePower = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "DisableOutsideAndDaytimePower", true, "If true, outside and daytime enemy power caps are forced to zero.");
		ShowMonitorStats = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ShowMonitorStats", true, "If true, ship monitor text is replaced with the current randomized mission stats.");
		DebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DebugEnabled", false, "If true, enable diagnostic console logging and allow debug files to be written.");
		AutoFileDebugLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "WriteDebugFiles", true, "If true and DebugEnabled is true, write orbit / landed / manual diagnostic snapshots to BepInEx/MissionRandomizerDebugLogs.");
		HostDebugTeleportScrapWithP = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "HostCanPressPToTeleportScrap", false, "If true, the host can press P to teleport scrap to themselves for testing. This only works on the host/server and does not sync scrap positions to clients.");
		NormalizeGeneratedScrapValue = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "NormalizeGeneratedScrapValue", true, "If true, the host keeps generated mission scrap inside the displayed total value range. It no longer forces the total to always equal the max value.");
		EnforceGeneratedScrapCount = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "EnforceGeneratedScrapCount", true, "If true, the host removes excess generated mission scrap above the mission profile max count before vanilla scrap values sync.");
		PreClampScrapValuesBeforeGeneration = ((BaseUnityPlugin)this).Config.Bind<bool>("Gameplay", "PreScaleScrapValuesBeforeGeneration", false, "Legacy option. Keep this off. The mod now edits the real vanilla scrap values before the vanilla scrap sync instead of using temporary fake item ranges.");
		CleaningCompanySupport = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "CleaningCompanySupport", true, "If true, preserve scrap value for direct Cleaning Company conversions: Scav Goop / Thumper Drool to Dirty Water, and Bone Pile / Nail Pile Item / BrackenDustItem / Ethereal Essence / Hoarding Bug Eggs / Spore Pile to Full Garbage Bag.");
		MinimumTotalScrapValue = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MinimumTotalScrapValue", 220, "Lowest maxTotalScrapValue the mod will generate.");
		MaximumTotalScrapValueCap = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MaximumTotalScrapValueCap", 1250, "Hard cap for generated maxTotalScrapValue.");
		QuotaCoverageMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "QuotaCoverageMultiplier", 1.2f, "Each remaining day tries to offer at least quotaRemaining / daysLeft multiplied by this value.");
		MinimumScrapCount = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MinimumScrapCount", 12, "Lowest generated minScrap count.");
		MaximumScrapCountCap = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MaximumScrapCountCap", 48, "Legacy cap for generated maxScrap count. MaximumMissionScrapCount is the main physical scrap cap.");
		MaximumMissionScrapCount = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MaximumMissionScrapCount", 48, "Hard cap for how many physical mission scrap items can spawn. This does not cap total scrap value.");
		MaximumInsideEnemyPowerCap = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MaximumInsideEnemyPowerCap", 14, "Hard cap for generated maxEnemyPowerCount.");
		MaximumMinEnemiesToSpawn = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "MaximumMinEnemiesToSpawn", 3, "Hard cap for RoundManager.minEnemiesToSpawn.");
		MaximumFactorySizeMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "MaximumFactorySizeMultiplier", 2.05f, "Hard cap for generated factorySizeMultiplier / RoundManager.mapSizeMultiplier.");
		MaximumScrapAmountMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "MaximumScrapAmountMultiplier", 2.25f, "Hard cap for RoundManager.scrapAmountMultiplier.");
		MaximumScrapValueMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Scaling", "MaximumScrapValueMultiplier", 2.25f, "Hard cap for RoundManager.scrapValueMultiplier.");
		CleaningCompanyConversionSearchRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Compatibility", "CleaningCompanyConversionSearchRadius", 6f, "How close a newly appeared scrap item must be to a disappeared Cleaning Company mess or converted scrap item to inherit its value.");
		CleaningCompanyConversionWindowSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Compatibility", "CleaningCompanyConversionWindowSeconds", 4f, "How long a disappeared scrap value stays pending while waiting for a nearby newly appeared scrap item.");
		SeedOffset = ((BaseUnityPlugin)this).Config.Bind<int>("Scaling", "SeedOffset", 7319, "Change this to produce a different deterministic mission sequence.");
		try
		{
			((BaseUnityPlugin)this).Config.Save();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Mission Randomizer config saved to: " + ((BaseUnityPlugin)this).Config.ConfigFilePath));
		}
		catch (Exception ex)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("Mission Randomizer config save failed: " + ex.Message));
		}
		MissionController.Initialize(this);
		harmony = new Harmony("yellowcube.lc.mission_randomizer");
		harmony.PatchAll(typeof(Plugin).Assembly);
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Mission Randomizer 0.1.25 loaded.");
	}

	private void OnDestroy()
	{
		try
		{
			MissionController.Shutdown();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
		catch
		{
		}
	}

	private void OnGUI()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Invalid comparison between Unknown and I4
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Invalid comparison between Unknown and I4
		Event current = Event.current;
		if (current != null && (int)current.type == 4 && (int)current.keyCode == 112 && HostDebugTeleportScrapWithP != null && HostDebugTeleportScrapWithP.Value)
		{
			MissionController.DebugTeleportScrapToPlayer();
		}
	}
}
internal static class MissionController
{
	[CompilerGenerated]
	private sealed class <DelayedNormalizeSpawnedScrap>d__65 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string reason;

		public float delaySeconds;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedNormalizeSpawnedScrap>d__65(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (delaySeconds > 0f)
				{
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			NormalizeSpawnedScrapForCurrentRoll(reason, writeLog: true);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DelayedRestoreTemporaryScrapValueRanges>d__67 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string reason;

		public float delaySeconds;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedRestoreTemporaryScrapValueRanges>d__67(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (delaySeconds > 0f)
				{
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			RestoreTemporaryScrapValueRanges(reason, writeLog: true);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DelayedSendRollToClient>d__174 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ulong clientId;

		public float delaySeconds;

		private StartOfRound <start>5__1;

		private RoundManager <round>5__2;

		private TimeOfDay <time>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedSendRollToClient>d__174(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<start>5__1 = null;
			<round>5__2 = null;
			<time>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (delaySeconds > 0f)
				{
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
			{
				return false;
			}
			if (!HasRoll)
			{
				<start>5__1 = StartOfRound.Instance;
				<round>5__2 = RoundManager.Instance;
				<time>5__3 = TimeOfDay.Instance;
				if ((Object)(object)<start>5__1 != (Object)null && (Object)(object)<round>5__2 != (Object)null && (Object)(object)<time>5__3 != (Object)null)
				{
					EnsureRollForCurrentOrbit(<start>5__1, <round>5__2, <time>5__3);
				}
				<start>5__1 = null;
				<round>5__2 = null;
				<time>5__3 = null;
			}
			if (HasRoll)
			{
				SendRollToClient(CurrentRoll, clientId);
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <DelayedSendScrapValuesToClient>d__159 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public ulong clientId;

		public float delaySeconds;

		private List<ScrapComponentRecord> <records>5__1;

		private int <total>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <DelayedSendScrapValuesToClient>d__159(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<records>5__1 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (delaySeconds > 0f)
				{
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (!HasRoll)
			{
				return false;
			}
			if (IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
			{
				return false;
			}
			<records>5__1 = CollectMissionScrapRecords(includeHeld: false);
			<total>5__2 = SumScrapRecordValues(<records>5__1);
			if (<records>5__1.Count > 0)
			{
				SendScrapValueSyncToClient(<records>5__1, <total>5__2, clientId, "late join delayed sync");
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <EarlyLiveScrapNormalizeCoroutine>d__61 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public string reason;

		public float delaySeconds;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <EarlyLiveScrapNormalizeCoroutine>d__61(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				if (delaySeconds > 0f)
				{
					<>2__current = (object)new WaitForSeconds(delaySeconds);
					<>1__state = 1;
					return true;
				}
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			earlyLiveScrapNormalizeScheduled = false;
			NormalizeSpawnedScrapForCurrentRoll(reason, writeLog: true);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <RapidNormalizeSpawnedScrapAtRoundStart>d__66 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <RapidNormalizeSpawnedScrapAtRoundStart>d__66(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = null;
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				NormalizeSpawnedScrapForCurrentRoll("round start rapid single-frame safety", writeLog: false);
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 2;
				return true;
			case 2:
				<>1__state = -1;
				NormalizeSpawnedScrapForCurrentRoll("round start rapid 0.50s safety", writeLog: false);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	private const string NetMessageName = "yellowcube.mission_randomizer.roll.v1";

	private const string NetRequestMessageName = "yellowcube.mission_randomizer.roll_request.v1";

	private const string NetScrapValuesMessageName = "yellowcube.mission_randomizer.scrap_values.v1";

	private const string NetScrapValuesRequestMessageName = "yellowcube.mission_randomizer.scrap_values_request.v1";

	private static Plugin plugin;

	private static bool networkRegistered;

	private static bool sceneHooked;

	private static NetworkManager registeredNetworkManager;

	private static StartOfRound trackedStartOfRound;

	private static RoundManager trackedRoundManager;

	private static float nextClientRollRequestTime;

	private static float nextClientScrapValueRequestTime;

	private static int clientScrapValueRequestSeed = int.MinValue;

	private static int clientScrapValueRequestAttempts;

	private static int clientScrapValueSyncReceivedSeed = int.MinValue;

	private static float nextPendingScrapApplyTime;

	private static int pendingScrapValueTotal;

	private static int runtimeRandomSeedSalt;

	private static string runtimeRandomSeedReason = string.Empty;

	private static readonly List<PendingScrapValue> pendingScrapValues = new List<PendingScrapValue>();

	private static readonly Dictionary<ulong, float> nextServerScrapValueResponseByClient = new Dictionary<ulong, float>();

	private static readonly List<CleaningConversionRecord> pendingCleaningConversions = new List<CleaningConversionRecord>();

	private static readonly List<OriginalScrapItemValueRange> temporaryScrapValueRanges = new List<OriginalScrapItemValueRange>();

	private static string lastRollKey = string.Empty;

	private static float nextPeriodicBroadcastTime;

	private static float nextMonitorRefreshTime;

	private static float nextMissingMonitorLogTime;

	private static float nextScrapDebugTime;

	private static float nextCleaningConversionCleanupTime;

	private static int orbitDebugSequence;

	private static int landingSnapshotStage;

	private static float nextLandingSnapshotTime;

	private static string currentMissionDebugPrefix = string.Empty;

	private static TerminalNode missionTerminalNode;

	private static TerminalNode routeMissionTerminalNode;

	private static TerminalNode routeCompanyTerminalNode;

	private static TerminalNode routeMissionPromptTerminalNode;

	private static TerminalNode routeCompanyPromptTerminalNode;

	private static int pendingTerminalRoute;

	private static float pendingTerminalRouteExpiresAt;

	private static bool earlyLiveScrapNormalizeScheduled;

	private static float nextEarlyLiveScrapNormalizeAllowedTime;

	internal static MissionRoll CurrentRoll;

	internal static bool HasRoll;

	internal static void Initialize(Plugin owner)
	{
		plugin = owner;
		if (!sceneHooked)
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
			sceneHooked = true;
		}
	}

	internal static void Shutdown()
	{
		ResetMissionRuntimeState("Plugin shutdown", keepTrackedInstances: false);
		ResetNetworkRegistration("Plugin shutdown");
		if (sceneHooked)
		{
			try
			{
				SceneManager.sceneLoaded -= OnSceneLoaded;
			}
			catch
			{
			}
			sceneHooked = false;
		}
	}

	private static bool ShouldDebugLog()
	{
		return (Object)(object)plugin != (Object)null && plugin.DebugLogging != null && plugin.DebugLogging.Value;
	}

	private static bool ShouldWriteDebugFiles()
	{
		return (Object)(object)plugin != (Object)null && plugin.DebugLogging != null && plugin.DebugLogging.Value && plugin.AutoFileDebugLogging != null && plugin.AutoFileDebugLogging.Value;
	}

	private static int GetConfiguredMaxMissionScrapCount()
	{
		if ((Object)(object)plugin == (Object)null || plugin.MaximumMissionScrapCount == null)
		{
			return 48;
		}
		return Mathf.Clamp(plugin.MaximumMissionScrapCount.Value, 1, 500);
	}

	private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		nextMonitorRefreshTime = 0f;
		if (((Scene)(ref scene)).name.Equals("MainMenu", StringComparison.OrdinalIgnoreCase))
		{
			ResetMissionRuntimeState("Main menu loaded", keepTrackedInstances: false);
			ResetNetworkRegistration("Main menu loaded");
		}
		TryRegisterNetworking();
	}

	internal static void UpdateLoop()
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value)
		{
			return;
		}
		TryRegisterNetworking();
		StartOfRound instance = StartOfRound.Instance;
		RoundManager instance2 = RoundManager.Instance;
		TimeOfDay instance3 = TimeOfDay.Instance;
		if ((Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null || (Object)(object)instance3 == (Object)null)
		{
			return;
		}
		DetectNewGameSystemInstances(instance, instance2);
		RequestRollFromHostIfNeeded();
		CleanupExpiredCleaningCompanyConversions();
		bool @bool = GetBool(instance, "inShipPhase", fallback: false);
		bool bool2 = GetBool(instance, "shipHasLanded", fallback: false);
		bool bool3 = GetBool(instance, "shipIsLeaving", fallback: false);
		if (!IsServerOrNoNetwork())
		{
			ApplyPendingScrapValues("client update loop");
			RequestScrapValuesFromHostIfNeeded(bool2, bool3);
		}
		HandleAutomaticLandingDebugSnapshots(instance, instance2, instance3, @bool, bool2, bool3);
		bool flag = IsCompanyRouteActive(instance2, instance3);
		if (@bool && !bool2 && !bool3 && !flag)
		{
			EnsureRollForCurrentOrbit(instance, instance2, instance3);
			if (plugin.ForceStarterMoon.Value)
			{
				ForceStarterLevel(instance2, instance3);
			}
			if (plugin.RestrictTerminalMoonCatalogue.Value)
			{
				RestrictTerminalCatalogueToStarter();
			}
		}
		if (!flag && IsServerOrNoNetwork() && HasRoll && Time.realtimeSinceStartup >= nextPeriodicBroadcastTime)
		{
			nextPeriodicBroadcastTime = Time.realtimeSinceStartup + 5f;
			BroadcastRoll(CurrentRoll);
		}
		if (!flag && HasRoll)
		{
			ApplyRollToGameObjects(CurrentRoll, "UpdateLoop");
		}
		if (!flag && plugin.ShowMonitorStats.Value && Time.realtimeSinceStartup >= nextMonitorRefreshTime)
		{
			nextMonitorRefreshTime = Time.realtimeSinceStartup + 0.75f;
			UpdateMonitorText();
		}
	}

	private static void DetectNewGameSystemInstances(StartOfRound start, RoundManager round)
	{
		if ((Object)(object)trackedStartOfRound != (Object)null && trackedStartOfRound != start)
		{
			ResetMissionRuntimeState("StartOfRound instance changed", keepTrackedInstances: true);
		}
		if ((Object)(object)trackedRoundManager != (Object)null && trackedRoundManager != round)
		{
			ResetMissionRuntimeState("RoundManager instance changed", keepTrackedInstances: true);
		}
		trackedStartOfRound = start;
		trackedRoundManager = round;
	}

	private static void ResetMissionRuntimeState(string reason, bool keepTrackedInstances)
	{
		HasRoll = false;
		CurrentRoll = default(MissionRoll);
		lastRollKey = string.Empty;
		nextPeriodicBroadcastTime = 0f;
		nextMonitorRefreshTime = 0f;
		nextMissingMonitorLogTime = 0f;
		nextClientRollRequestTime = 0f;
		nextClientScrapValueRequestTime = 0f;
		clientScrapValueRequestSeed = int.MinValue;
		clientScrapValueRequestAttempts = 0;
		clientScrapValueSyncReceivedSeed = int.MinValue;
		nextPendingScrapApplyTime = 0f;
		pendingScrapValueTotal = 0;
		pendingScrapValues.Clear();
		nextServerScrapValueResponseByClient.Clear();
		pendingCleaningConversions.Clear();
		nextCleaningConversionCleanupTime = 0f;
		nextScrapDebugTime = 0f;
		orbitDebugSequence = 0;
		landingSnapshotStage = 0;
		nextLandingSnapshotTime = 0f;
		currentMissionDebugPrefix = string.Empty;
		missionTerminalNode = null;
		routeMissionTerminalNode = null;
		routeCompanyTerminalNode = null;
		routeMissionPromptTerminalNode = null;
		routeCompanyPromptTerminalNode = null;
		pendingTerminalRoute = 0;
		pendingTerminalRouteExpiresAt = 0f;
		earlyLiveScrapNormalizeScheduled = false;
		nextEarlyLiveScrapNormalizeAllowedTime = 0f;
		RestoreTemporaryScrapValueRanges("runtime reset: " + reason, writeLog: false);
		if (!keepTrackedInstances || reason.IndexOf("Main menu", StringComparison.OrdinalIgnoreCase) >= 0 || reason.IndexOf("Plugin shutdown", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			runtimeRandomSeedSalt = 0;
			runtimeRandomSeedReason = string.Empty;
		}
		if (!keepTrackedInstances)
		{
			trackedStartOfRound = null;
			trackedRoundManager = null;
		}
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission runtime state reset: " + reason));
		}
	}

	private static void RequestRollFromHostIfNeeded()
	{
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null || !singleton.IsClient || singleton.IsServer || HasRoll || Time.realtimeSinceStartup < nextClientRollRequestTime)
			{
				return;
			}
			nextClientRollRequestTime = Time.realtimeSinceStartup + 2f;
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
			try
			{
				singleton.CustomMessagingManager.SendNamedMessage("yellowcube.mission_randomizer.roll_request.v1", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Mission roll request failed: " + ex.Message));
			}
		}
	}

	internal static void BeforeLoadNewLevel()
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value)
		{
			return;
		}
		StartOfRound instance = StartOfRound.Instance;
		RoundManager instance2 = RoundManager.Instance;
		TimeOfDay instance3 = TimeOfDay.Instance;
		if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance2 == (Object)null) && !((Object)(object)instance3 == (Object)null) && !IsCompanyRouteActive(instance2, instance3))
		{
			EnsureRollForCurrentOrbit(instance, instance2, instance3);
			if (HasRoll)
			{
				ApplyMissionRandomSeedToGameObjects(CurrentRoll, instance2, instance, "BeforeLoadNewLevel");
			}
			if (plugin.ForceStarterMoon.Value)
			{
				ForceStarterLevel(instance2, instance3);
			}
			if (HasRoll)
			{
				ApplyRollToGameObjects(CurrentRoll, "BeforeLoadNewLevel");
			}
		}
	}

	internal static void AfterGrabbableObjectStart(Component component)
	{
		HandleCleaningCompanyGrabbableStart(component);
	}

	internal static void BeforeSpawnScrapInLevel(RoundManager round)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !IsServerOrNoNetwork() || IsCompanyRouteActive(round, TimeOfDay.Instance))
		{
			return;
		}
		if (!HasRoll)
		{
			StartOfRound instance = StartOfRound.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)round != (Object)null && (Object)(object)instance2 != (Object)null)
			{
				EnsureRollForCurrentOrbit(instance, round, instance2);
			}
		}
		if (HasRoll)
		{
			ApplyRollToGameObjects(CurrentRoll, "BeforeSpawnScrapInLevel");
			RestoreTemporaryScrapValueRanges("BeforeSpawnScrapInLevel cleanup", writeLog: false);
		}
	}

	internal static void AfterSpawnScrapInLevel(RoundManager round)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !IsServerOrNoNetwork() || IsCompanyRouteActive(round, TimeOfDay.Instance))
		{
			return;
		}
		if (!HasRoll)
		{
			StartOfRound instance = StartOfRound.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)round != (Object)null && (Object)(object)instance2 != (Object)null)
			{
				EnsureRollForCurrentOrbit(instance, round, instance2);
			}
		}
		if (!HasRoll)
		{
			return;
		}
		ApplyRollToGameObjects(CurrentRoll, "AfterSpawnScrapInLevel");
		try
		{
			RestoreTemporaryScrapValueRanges("right after SpawnScrapInLevel", writeLog: false);
			((MonoBehaviour)plugin).StartCoroutine(DelayedRestoreTemporaryScrapValueRanges("after round start scrap generation safety", 1f));
		}
		catch (Exception ex)
		{
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Mission scrap normalization scheduling failed: " + ex.Message));
			}
		}
	}

	internal static void BeforeVanillaScrapValuesSync(RoundManager round, NetworkObjectReference[] spawnedScrap, int[] scrapValues)
	{
		//IL_00f0: 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)
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !IsServerOrNoNetwork() || IsCompanyRouteActive(round, TimeOfDay.Instance))
		{
			return;
		}
		if (!HasRoll)
		{
			StartOfRound instance = StartOfRound.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)round != (Object)null && (Object)(object)instance2 != (Object)null)
			{
				EnsureRollForCurrentOrbit(instance, round, instance2);
			}
		}
		if (!HasRoll || spawnedScrap == null || scrapValues == null || spawnedScrap.Length == 0 || scrapValues.Length == 0)
		{
			return;
		}
		int num = Mathf.Min(spawnedScrap.Length, scrapValues.Length);
		List<ScrapComponentRecord> list = new List<ScrapComponentRecord>();
		List<int> list2 = new List<int>();
		for (int i = 0; i < num; i++)
		{
			NetworkObject val = null;
			try
			{
				NetworkObjectReference val2 = spawnedScrap[i];
				if (!((NetworkObjectReference)(ref val2)).TryGet(ref val, NetworkManager.Singleton))
				{
					val = null;
				}
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
			{
				continue;
			}
			Component val3 = (Component)(object)((Component)val).GetComponent<GrabbableObject>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = (Component)(object)((Component)val).GetComponentInChildren<GrabbableObject>(true);
			}
			if ((Object)(object)val3 == (Object)null || !IsScrapGrabbable(val3))
			{
				continue;
			}
			object field = GetField<object>(val3, "itemProperties", null);
			if (field != null && GetBool(field, "isScrap", fallback: false))
			{
				string itemDisplayName = GetItemDisplayName(val3, field);
				if (!IsApparatusItem(val3, val3.gameObject, itemDisplayName))
				{
					int value = Mathf.Max(1, scrapValues[i]);
					list.Add(new ScrapComponentRecord
					{
						Component = val3,
						GameObject = val3.gameObject,
						Value = value,
						ItemName = itemDisplayName,
						SyncIndex = i
					});
					list2.Add(i);
				}
			}
		}
		if (list.Count == 0)
		{
			return;
		}
		int num2 = Mathf.Min(CurrentRoll.MaxScrap, GetConfiguredMaxMissionScrapCount());
		int num3 = 0;
		int num4 = 0;
		if (plugin.EnforceGeneratedScrapCount.Value && list.Count > num2)
		{
			list.Sort((ScrapComponentRecord a, ScrapComponentRecord b) => b.Value.CompareTo(a.Value));
			int num5 = list.Count - num2;
			for (int j = 0; j < num5; j++)
			{
				ScrapComponentRecord scrapComponentRecord = list[j];
				num3++;
				num4 += Mathf.Max(0, scrapComponentRecord.Value);
				if (scrapComponentRecord.SyncIndex >= 0 && scrapComponentRecord.SyncIndex < scrapValues.Length)
				{
					scrapValues[scrapComponentRecord.SyncIndex] = 0;
				}
				DespawnOrDestroyScrap(scrapComponentRecord.Component);
			}
			list.RemoveRange(0, num5);
		}
		int minimumTotalScrapValueForRoll = GetMinimumTotalScrapValueForRoll(CurrentRoll);
		int num6 = Mathf.Max(minimumTotalScrapValueForRoll, CurrentRoll.MaxTotalScrapValue);
		int num7 = 0;
		for (int k = 0; k < list.Count; k++)
		{
			num7 += Mathf.Max(1, list[k].Value);
		}
		int num8 = num7;
		bool flag = num3 > 0;
		if (plugin.NormalizeGeneratedScrapValue.Value && list.Count > 0 && (num7 < minimumTotalScrapValueForRoll || num7 > num6))
		{
			int targetValue = ChooseScrapTotalValueWithinRange(CurrentRoll, num7, list.Count);
			NormalizeScrapRecordValues(list, targetValue);
			num8 = SumScrapRecordValues(list);
			flag = true;
		}
		else
		{
			for (int l = 0; l < list.Count; l++)
			{
				SetScrapValue(list[l].Component, list[l].Value);
			}
		}
		for (int m = 0; m < list.Count; m++)
		{
			int syncIndex = list[m].SyncIndex;
			if (syncIndex >= 0 && syncIndex < scrapValues.Length)
			{
				scrapValues[syncIndex] = Mathf.Max(1, list[m].Value);
			}
		}
		if ((Object)(object)round != (Object)null)
		{
			SetField(round, "totalScrapValueInLevel", (float)num8);
		}
		BroadcastScrapValueSync(list, num8, "before vanilla scrap value sync");
		RestoreTemporaryScrapValueRanges("before vanilla scrap value sync", writeLog: false);
		if (plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission scrap values applied before vanilla sync: final " + list.Count + " / $" + num8 + ", removed " + num3 + " / $" + num4 + ", allowed count <= " + num2 + ", allowed range $" + minimumTotalScrapValueForRoll + "-$" + num6 + ", adjusted=" + flag + "."));
		}
	}

	internal static void BeforeFinishGeneratingNewLevelClientRpc(RoundManager round)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !IsServerOrNoNetwork())
		{
			return;
		}
		if ((Object)(object)round == (Object)null)
		{
			round = RoundManager.Instance;
		}
		if (IsCompanyRouteActive(round, TimeOfDay.Instance))
		{
			return;
		}
		if (!HasRoll)
		{
			StartOfRound instance = StartOfRound.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)round != (Object)null && (Object)(object)instance2 != (Object)null)
			{
				EnsureRollForCurrentOrbit(instance, round, instance2);
			}
		}
		if (!HasRoll)
		{
			return;
		}
		ApplyRollToGameObjects(CurrentRoll, "BeforeFinishGeneratingNewLevelClientRpc");
		NormalizeSpawnedScrapForCurrentRoll("BeforeFinishGeneratingNewLevelClientRpc live scrap pass", writeLog: true);
		try
		{
			ScheduleEarlyLiveScrapNormalize("post FinishGeneratingNewLevelClientRpc safety", 0.1f);
		}
		catch
		{
		}
	}

	private static void ScheduleEarlyLiveScrapNormalize(string reason, float delaySeconds)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !IsServerOrNoNetwork() || !HasRoll || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			return;
		}
		float realtimeSinceStartup = Time.realtimeSinceStartup;
		if (earlyLiveScrapNormalizeScheduled || realtimeSinceStartup < nextEarlyLiveScrapNormalizeAllowedTime)
		{
			return;
		}
		earlyLiveScrapNormalizeScheduled = true;
		nextEarlyLiveScrapNormalizeAllowedTime = realtimeSinceStartup + 0.2f;
		try
		{
			((MonoBehaviour)plugin).StartCoroutine(EarlyLiveScrapNormalizeCoroutine(reason, delaySeconds));
		}
		catch
		{
			earlyLiveScrapNormalizeScheduled = false;
		}
	}

	[IteratorStateMachine(typeof(<EarlyLiveScrapNormalizeCoroutine>d__61))]
	private static IEnumerator EarlyLiveScrapNormalizeCoroutine(string reason, float delaySeconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <EarlyLiveScrapNormalizeCoroutine>d__61(0)
		{
			reason = reason,
			delaySeconds = delaySeconds
		};
	}

	private static int GetMinimumTotalScrapValueForRoll(MissionRoll roll)
	{
		int num = Mathf.Max(1, roll.MaxTotalScrapValue);
		int num2 = Mathf.RoundToInt((float)num * 0.8f);
		return Mathf.Clamp(num2, 1, num);
	}

	private static int ChooseScrapTotalValueWithinRange(MissionRoll roll, int sourceTotal, int scrapCount)
	{
		int minimumTotalScrapValueForRoll = GetMinimumTotalScrapValueForRoll(roll);
		int num = Mathf.Max(minimumTotalScrapValueForRoll, roll.MaxTotalScrapValue);
		if (num <= minimumTotalScrapValueForRoll)
		{
			return num;
		}
		int seed = roll.Seed;
		seed = (seed * 397) ^ Mathf.Max(1, sourceTotal);
		seed = (seed * 397) ^ Mathf.Max(1, scrapCount);
		seed = (seed * 397) ^ 0x4D52564C;
		Random random = new Random(seed);
		return random.Next(minimumTotalScrapValueForRoll, num + 1);
	}

	private static string TotalScrapValueRangeText(MissionRoll roll)
	{
		return "$" + GetMinimumTotalScrapValueForRoll(roll) + " - $" + Mathf.Max(GetMinimumTotalScrapValueForRoll(roll), roll.MaxTotalScrapValue);
	}

	[IteratorStateMachine(typeof(<DelayedNormalizeSpawnedScrap>d__65))]
	private static IEnumerator DelayedNormalizeSpawnedScrap(string reason, float delaySeconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedNormalizeSpawnedScrap>d__65(0)
		{
			reason = reason,
			delaySeconds = delaySeconds
		};
	}

	[IteratorStateMachine(typeof(<RapidNormalizeSpawnedScrapAtRoundStart>d__66))]
	private static IEnumerator RapidNormalizeSpawnedScrapAtRoundStart()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <RapidNormalizeSpawnedScrapAtRoundStart>d__66(0);
	}

	[IteratorStateMachine(typeof(<DelayedRestoreTemporaryScrapValueRanges>d__67))]
	private static IEnumerator DelayedRestoreTemporaryScrapValueRanges(string reason, float delaySeconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedRestoreTemporaryScrapValueRanges>d__67(0)
		{
			reason = reason,
			delaySeconds = delaySeconds
		};
	}

	internal static void AfterMapScreenUpdate()
	{
		if (!((Object)(object)plugin == (Object)null) && plugin.ModEnabled.Value && plugin.ShowMonitorStats.Value && !IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			UpdateMonitorText();
		}
	}

	internal static void DebugTeleportScrapToPlayer()
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || plugin.HostDebugTeleportScrapWithP == null || !plugin.HostDebugTeleportScrapWithP.Value || Time.realtimeSinceStartup < nextScrapDebugTime)
		{
			return;
		}
		nextScrapDebugTime = Time.realtimeSinceStartup + 0.75f;
		if (!IsServerOrNoNetwork())
		{
			SendDebugChatLine("Mission Debug: press P on the host/server. Scrap movement must be server authoritative.");
			return;
		}
		StartOfRound instance = StartOfRound.Instance;
		RoundManager instance2 = RoundManager.Instance;
		TimeOfDay instance3 = TimeOfDay.Instance;
		if ((Object)(object)instance == (Object)null || (Object)(object)instance2 == (Object)null || (Object)(object)instance3 == (Object)null)
		{
			SendDebugChatLine("Mission Debug: StartOfRound, RoundManager, or TimeOfDay is missing.");
			return;
		}
		if (IsCompanyRouteActive(instance2, instance3))
		{
			SendDebugChatLine("Mission Debug: Company route active. Mission randomizer scrap controls are disabled at the Company.");
			return;
		}
		if (!HasRoll)
		{
			EnsureRollForCurrentOrbit(instance, instance2, instance3);
		}
		NormalizeSpawnedScrapForCurrentRoll("Before manual P teleport", writeLog: true);
		ScrapDebugStats scrapDebugStats = TeleportSpawnedScrapToLocalPlayer(instance);
		string text = BuildActualVsExpectedDebugReport(instance2, instance3, scrapDebugStats);
		string[] array = SplitDebugReportForChat(text);
		foreach (string message in array)
		{
			SendDebugChatLine(message);
		}
		if (plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission Debug P report:\n" + text));
		}
		if (!ShouldWriteDebugFiles())
		{
			return;
		}
		try
		{
			WriteDebugTextFile("MANUAL_P_TELEPORT", BuildFullMissionDebugFileReport("MANUAL_P_TELEPORT", instance2, instance3, scrapDebugStats));
		}
		catch (Exception ex)
		{
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Could not write manual P debug file: " + ex.Message));
			}
		}
	}

	private static void ResetLandingDebugStateForNewMission()
	{
		orbitDebugSequence++;
		landingSnapshotStage = 0;
		nextLandingSnapshotTime = 0f;
		currentMissionDebugPrefix = DateTime.Now.ToString("yyyyMMdd_HHmmss") + "_mission" + orbitDebugSequence.ToString("000") + "_seed" + (HasRoll ? CurrentRoll.Seed.ToString() : "none");
	}

	private static void HandleAutomaticLandingDebugSnapshots(StartOfRound start, RoundManager round, TimeOfDay time, bool inShipPhase, bool shipHasLanded, bool shipIsLeaving)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !ShouldWriteDebugFiles() || !IsServerOrNoNetwork() || !HasRoll)
		{
			return;
		}
		if (inShipPhase && !shipHasLanded && !shipIsLeaving)
		{
			landingSnapshotStage = 0;
			nextLandingSnapshotTime = 0f;
		}
		else if (!inShipPhase || shipHasLanded)
		{
			if (landingSnapshotStage == 0)
			{
				landingSnapshotStage = 1;
				nextLandingSnapshotTime = Time.realtimeSinceStartup + 8f;
			}
			else if (landingSnapshotStage == 1 && Time.realtimeSinceStartup >= nextLandingSnapshotTime)
			{
				WriteLandedScrapDebugFile("AUTO_8_SECONDS_AFTER_LANDING", start, round, time);
				landingSnapshotStage = 2;
				nextLandingSnapshotTime = Time.realtimeSinceStartup + 12f;
			}
			else if (landingSnapshotStage == 2 && Time.realtimeSinceStartup >= nextLandingSnapshotTime)
			{
				WriteLandedScrapDebugFile("AUTO_20_SECONDS_AFTER_LANDING", start, round, time);
				landingSnapshotStage = 3;
			}
		}
	}

	private static void WriteOrbitMissionDebugFile(string reason, RoundManager round, TimeOfDay time)
	{
		if ((Object)(object)plugin == (Object)null || !ShouldWriteDebugFiles())
		{
			return;
		}
		try
		{
			string report = BuildFullMissionDebugFileReport(reason, round, time, null);
			WriteDebugTextFile("ORBIT_" + SanitizeFilePart(reason), report);
		}
		catch (Exception ex)
		{
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Could not write orbit mission debug file: " + ex.Message));
			}
		}
	}

	private static void WriteLandedScrapDebugFile(string reason, StartOfRound start, RoundManager round, TimeOfDay time)
	{
		if ((Object)(object)plugin == (Object)null || !ShouldWriteDebugFiles())
		{
			return;
		}
		try
		{
			NormalizeSpawnedScrapForCurrentRoll("Before landed debug snapshot " + reason, writeLog: true);
			ScrapDebugStats value = CollectSpawnedScrapStats(start, teleportToPlayer: false);
			string report = BuildFullMissionDebugFileReport(reason, round, time, value);
			WriteDebugTextFile("LANDED_" + SanitizeFilePart(reason), report);
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)("Mission Randomizer wrote landed debug snapshot: " + reason + " actualMissionScrapCount=" + value.SpawnedScrapCount + " actualMissionScrapValue=$" + value.TotalScrapValue));
			}
		}
		catch (Exception ex)
		{
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Could not write landed scrap debug file: " + ex.Message));
			}
		}
	}

	private static void WriteDebugTextFile(string suffix, string report)
	{
		string text = Path.Combine(Paths.BepInExRootPath, "MissionRandomizerDebugLogs");
		Directory.CreateDirectory(text);
		if (string.IsNullOrWhiteSpace(currentMissionDebugPrefix))
		{
			currentMissionDebugPrefix = DateTime.Now.ToString("yyyyMMdd_HHmmss") + "_mission_unknown";
		}
		string path = currentMissionDebugPrefix + "_" + suffix + ".txt";
		string text2 = Path.Combine(text, path);
		File.WriteAllText(text2, report ?? string.Empty);
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission Randomizer debug file written: " + text2));
		}
	}

	private static string SanitizeFilePart(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return "UNKNOWN";
		}
		StringBuilder stringBuilder = new StringBuilder(value.Length);
		foreach (char c in value)
		{
			if (char.IsLetterOrDigit(c) || c == '_' || c == '-')
			{
				stringBuilder.Append(c);
			}
			else
			{
				stringBuilder.Append('_');
			}
		}
		return stringBuilder.ToString();
	}

	private static ScrapDebugStats TeleportSpawnedScrapToLocalPlayer(StartOfRound start)
	{
		return CollectSpawnedScrapStats(start, teleportToPlayer: true);
	}

	private static ScrapDebugStats CollectSpawnedScrapStats(StartOfRound start, bool teleportToPlayer)
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: 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_00e2: 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_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: 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_0166: 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_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b0: 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_034e: 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_035c: Unknown result type (might be due to invalid IL or missing references)
		//IL_042a: Unknown result type (might be due to invalid IL or missing references)
		//IL_042f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0438: Unknown result type (might be due to invalid IL or missing references)
		//IL_039d: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0505: Unknown result type (might be due to invalid IL or missing references)
		//IL_050a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0513: Unknown result type (might be due to invalid IL or missing references)
		//IL_0479: Unknown result type (might be due to invalid IL or missing references)
		//IL_047e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0482: Unknown result type (might be due to invalid IL or missing references)
		//IL_0484: Unknown result type (might be due to invalid IL or missing references)
		//IL_0486: Unknown result type (might be due to invalid IL or missing references)
		ScrapDebugStats result = default(ScrapDebugStats);
		StringBuilder stringBuilder = new StringBuilder();
		StringBuilder stringBuilder2 = new StringBuilder();
		StringBuilder stringBuilder3 = new StringBuilder();
		StringBuilder stringBuilder4 = new StringBuilder();
		Component val = (((Object)(object)start != (Object)null) ? GetField<Component>(start, "localPlayerController", null) : null);
		Transform val2 = (((Object)(object)val != (Object)null) ? val.transform : null);
		if ((Object)(object)val2 == (Object)null && (Object)(object)Camera.main != (Object)null)
		{
			val2 = ((Component)Camera.main).transform;
		}
		if (teleportToPlayer && (Object)(object)val2 == (Object)null)
		{
			result.Error = "Could not find local player transform.";
			return result;
		}
		Vector3 val3 = (((Object)(object)val2 != (Object)null) ? (val2.position + val2.forward * 2f + Vector3.up * 0.75f) : Vector3.zero);
		Component[] array = Resources.FindObjectsOfTypeAll<Component>();
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		int num5 = int.MaxValue;
		int num6 = int.MinValue;
		Component[] array2 = array;
		foreach (Component val4 in array2)
		{
			if ((Object)(object)val4 == (Object)null || (Object)(object)val4.gameObject == (Object)null)
			{
				continue;
			}
			GameObject gameObject = val4.gameObject;
			Scene scene = gameObject.scene;
			if (!((Scene)(ref scene)).IsValid())
			{
				continue;
			}
			scene = gameObject.scene;
			if (!((Scene)(ref scene)).isLoaded || !gameObject.activeInHierarchy || !IsScrapGrabbable(val4))
			{
				continue;
			}
			int @int = GetInt(val4, "scrapValue", 0);
			bool flag = GetBool(val4, "isHeld", fallback: false) || GetBool(val4, "isHeldByEnemy", fallback: false);
			bool inShip = GetBool(val4, "isInShipRoom", fallback: false) || GetBool(val4, "isInElevator", fallback: false);
			bool @bool = GetBool(val4, "isInFactory", fallback: false);
			object field = GetField<object>(val4, "itemProperties", null);
			bool flag2 = field != null && GetBool(field, "isScrap", fallback: false);
			string itemDisplayName = GetItemDisplayName(val4, field);
			bool flag3 = IsApparatusItem(val4, gameObject, itemDisplayName);
			bool flag4 = flag2 && !flag3;
			string path = GetPath(gameObject.transform);
			Vector3 position = val4.transform.position;
			num4++;
			result.RawValuedGrabbableCount++;
			result.RawValuedGrabbableValue += @int;
			int index = num4;
			string name = ((Object)gameObject).name;
			string name2 = ((object)val4).GetType().Name;
			scene = gameObject.scene;
			string value = BuildScrapLine(index, @int, itemDisplayName, name, name2, ((Scene)(ref scene)).name, position, flag2, flag3, flag, inShip, @bool, path);
			stringBuilder4.Append(value);
			if (flag4)
			{
				result.SpawnedScrapCount++;
				result.TotalScrapValue += @int;
				result.ItemPropertiesScrapCount++;
				result.ItemPropertiesScrapValue += @int;
				num5 = Mathf.Min(num5, @int);
				num6 = Mathf.Max(num6, @int);
				num++;
				int index2 = num;
				string name3 = ((Object)gameObject).name;
				string name4 = ((object)val4).GetType().Name;
				scene = gameObject.scene;
				stringBuilder.Append(BuildScrapLine(index2, @int, itemDisplayName, name3, name4, ((Scene)(ref scene)).name, position, flag2, flag3, flag, inShip, @bool, path));
				if (flag)
				{
					result.HeldOrSkippedCount++;
				}
				else if (teleportToPlayer)
				{
					Vector3 val5 = ScrapDebugOffset(result.TeleportedCount);
					TeleportScrapComponent(val4, val3 + val5);
					result.TeleportedCount++;
				}
			}
			else if (flag3 && flag2)
			{
				result.ApparatusCount++;
				result.ApparatusValue += @int;
				result.TrueScrapIncludingApparatusCount++;
				result.TrueScrapIncludingApparatusValue += @int;
				num2++;
				int index3 = num2;
				string name5 = ((Object)gameObject).name;
				string name6 = ((object)val4).GetType().Name;
				scene = gameObject.scene;
				stringBuilder2.Append(BuildScrapLine(index3, @int, itemDisplayName, name5, name6, ((Scene)(ref scene)).name, position, flag2, flag3, flag, inShip, @bool, path));
				if (flag)
				{
					result.HeldOrSkippedCount++;
				}
				else if (teleportToPlayer)
				{
					Vector3 val6 = ScrapDebugOffset(result.TeleportedCount);
					TeleportScrapComponent(val4, val3 + val6);
					result.TeleportedCount++;
				}
			}
			else
			{
				if (flag2)
				{
					result.TrueScrapIncludingApparatusCount++;
					result.TrueScrapIncludingApparatusValue += @int;
				}
				else
				{
					result.ValueOnlyCount++;
					result.ValueOnlyValue += @int;
				}
				num3++;
				int index4 = num3;
				string name7 = ((Object)gameObject).name;
				string name8 = ((object)val4).GetType().Name;
				scene = gameObject.scene;
				stringBuilder3.Append(BuildScrapLine(index4, @int, itemDisplayName, name7, name8, ((Scene)(ref scene)).name, position, flag2, flag3, flag, inShip, @bool, path));
			}
		}
		result.TrueScrapIncludingApparatusCount = result.SpawnedScrapCount + result.ApparatusCount;
		result.TrueScrapIncludingApparatusValue = result.TotalScrapValue + result.ApparatusValue;
		result.MinScrapValue = ((result.SpawnedScrapCount > 0) ? num5 : 0);
		result.MaxScrapValue = ((result.SpawnedScrapCount > 0) ? num6 : 0);
		result.ItemBreakdown = stringBuilder.ToString();
		result.ApparatusBreakdown = stringBuilder2.ToString();
		result.NonScrapBreakdown = stringBuilder3.ToString();
		result.RawBreakdown = stringBuilder4.ToString();
		return result;
	}

	private static void PreClampSpawnableScrapValueRanges(RoundManager round, string reason)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.PreClampScrapValuesBeforeGeneration.Value || !HasRoll || !IsServerOrNoNetwork() || IsCompanyRouteActive(round, TimeOfDay.Instance))
		{
			return;
		}
		SelectableLevel val = null;
		if ((Object)(object)round != (Object)null)
		{
			val = GetField<SelectableLevel>(round, "currentLevel", null);
		}
		if ((Object)(object)val == (Object)null && (Object)(object)TimeOfDay.Instance != (Object)null)
		{
			val = GetField<SelectableLevel>(TimeOfDay.Instance, "currentLevel", null);
		}
		if ((Object)(object)val == (Object)null)
		{
			val = GetStarterLevel();
		}
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		object field = GetField<object>(val, "spawnableScrap", null);
		if (!(field is IEnumerable enumerable))
		{
			return;
		}
		List<SpawnableItemValueFields> list = new List<SpawnableItemValueFields>();
		foreach (object item in enumerable)
		{
			if (item == null)
			{
				continue;
			}
			object obj = GetField<object>(item, "spawnableItem", null);
			if (obj == null)
			{
				obj = item;
			}
			if (obj == null)
			{
				continue;
			}
			FieldInfo fieldInfo = FindField(obj.GetType(), "minValue");
			FieldInfo fieldInfo2 = FindField(obj.GetType(), "maxValue");
			if (fieldInfo == null || fieldInfo2 == null)
			{
				continue;
			}
			int num = 0;
			int num2 = 0;
			try
			{
				num = Convert.ToInt32(fieldInfo.GetValue(obj));
			}
			catch
			{
				num = 0;
			}
			try
			{
				num2 = Convert.ToInt32(fieldInfo2.GetValue(obj));
			}
			catch
			{
				num2 = 0;
			}
			if (num <= 0 && num2 <= 0)
			{
				continue;
			}
			bool flag = false;
			for (int i = 0; i < temporaryScrapValueRanges.Count; i++)
			{
				if (temporaryScrapValueRanges[i].Item == obj)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				temporaryScrapValueRanges.Add(new OriginalScrapItemValueRange
				{
					Item = obj,
					MinValue = num,
					MaxValue = num2
				});
			}
			list.Add(new SpawnableItemValueFields
			{
				Item = obj,
				MinField = fieldInfo,
				MaxField = fieldInfo2,
				OldMin = num,
				OldMax = num2,
				OldMid = Mathf.Max(1f, (float)(num + num2) * 0.5f)
			});
		}
		if (list.Count == 0)
		{
			return;
		}
		float num3 = 0f;
		for (int j = 0; j < list.Count; j++)
		{
			num3 += list[j].OldMid;
		}
		num3 = Mathf.Max(1f, num3 / (float)list.Count);
		int num4 = Mathf.Max(1, Mathf.RoundToInt((float)(CurrentRoll.MinScrap + CurrentRoll.MaxScrap) * 0.5f));
		float num5 = Mathf.Max(1f, (float)CurrentRoll.MaxTotalScrapValue / (float)num4);
		float num6 = Mathf.Clamp(num5 / num3, 0.02f, 2f);
		int num7 = 0;
		for (int k = 0; k < list.Count; k++)
		{
			SpawnableItemValueFields spawnableItemValueFields = list[k];
			int num8 = Mathf.Max(1, Mathf.RoundToInt((float)spawnableItemValueFields.OldMin * num6));
			int num9 = Mathf.Max(num8, Mathf.RoundToInt((float)spawnableItemValueFields.OldMax * num6));
			int num10 = Mathf.Max(num8, Mathf.CeilToInt(num5 * 3f));
			num9 = Mathf.Min(num9, num10);
			num8 = Mathf.Min(num8, num9);
			try
			{
				spawnableItemValueFields.MinField.SetValue(spawnableItemValueFields.Item, num8);
			}
			catch
			{
			}
			try
			{
				spawnableItemValueFields.MaxField.SetValue(spawnableItemValueFields.Item, num9);
			}
			catch
			{
			}
			num7++;
		}
		if (num7 > 0 && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission pre-scaled scrap item value ranges before generation (" + reason + "): " + num7 + " spawnable entries. Expected count " + num4 + ", target average $" + Mathf.RoundToInt(num5) + ", scale " + num6.ToString("0.000") + "."));
		}
	}

	private static void RestoreTemporaryScrapValueRanges(string reason, bool writeLog)
	{
		if (temporaryScrapValueRanges.Count == 0)
		{
			return;
		}
		int num = 0;
		for (int i = 0; i < temporaryScrapValueRanges.Count; i++)
		{
			OriginalScrapItemValueRange originalScrapItemValueRange = temporaryScrapValueRanges[i];
			if (originalScrapItemValueRange == null || originalScrapItemValueRange.Item == null)
			{
				continue;
			}
			try
			{
				FieldInfo fieldInfo = FindField(originalScrapItemValueRange.Item.GetType(), "minValue");
				FieldInfo fieldInfo2 = FindField(originalScrapItemValueRange.Item.GetType(), "maxValue");
				if (fieldInfo != null)
				{
					fieldInfo.SetValue(originalScrapItemValueRange.Item, originalScrapItemValueRange.MinValue);
				}
				if (fieldInfo2 != null)
				{
					fieldInfo2.SetValue(originalScrapItemValueRange.Item, originalScrapItemValueRange.MaxValue);
				}
				num++;
			}
			catch
			{
			}
		}
		temporaryScrapValueRanges.Clear();
		if (writeLog && (Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission restored temporary scrap item value ranges (" + reason + "): " + num + " items restored."));
		}
	}

	private static void NormalizeSpawnedScrapForCurrentRoll(string reason, bool writeLog)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !HasRoll || !IsServerOrNoNetwork() || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance) || (!plugin.NormalizeGeneratedScrapValue.Value && !plugin.EnforceGeneratedScrapCount.Value))
		{
			return;
		}
		RoundManager instance = RoundManager.Instance;
		List<ScrapComponentRecord> list = CollectMissionScrapRecords(includeHeld: false);
		int count = list.Count;
		int num = SumScrapRecordValues(list);
		int num2 = 0;
		int num3 = 0;
		int num4 = Mathf.Min(CurrentRoll.MaxScrap, GetConfiguredMaxMissionScrapCount());
		if (plugin.EnforceGeneratedScrapCount.Value && list.Count > num4)
		{
			list.Sort((ScrapComponentRecord a, ScrapComponentRecord b) => b.Value.CompareTo(a.Value));
			int num5 = list.Count - num4;
			for (int i = 0; i < num5; i++)
			{
				ScrapComponentRecord scrapComponentRecord = list[i];
				num2++;
				num3 += scrapComponentRecord.Value;
				DespawnOrDestroyScrap(scrapComponentRecord.Component);
			}
			list.RemoveRange(0, num5);
		}
		int minimumTotalScrapValueForRoll = GetMinimumTotalScrapValueForRoll(CurrentRoll);
		int num6 = Mathf.Max(minimumTotalScrapValueForRoll, CurrentRoll.MaxTotalScrapValue);
		int num7 = SumScrapRecordValues(list);
		bool flag = false;
		if (plugin.NormalizeGeneratedScrapValue.Value && list.Count > 0 && (num7 < minimumTotalScrapValueForRoll || num7 > num6))
		{
			int targetValue = ChooseScrapTotalValueWithinRange(CurrentRoll, num7, list.Count);
			NormalizeScrapRecordValues(list, targetValue);
			num7 = SumScrapRecordValues(list);
			flag = true;
		}
		if ((Object)(object)instance != (Object)null)
		{
			SetField(instance, "totalScrapValueInLevel", (float)num7);
		}
		BroadcastScrapValueSync(list, num7, reason);
		if (writeLog && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission scrap value range check (" + reason + "): original " + count + " / $" + num + ", removed " + num2 + " / $" + num3 + ", final " + list.Count + " / $" + num7 + ", allowed count <= " + num4 + ", allowed value range $" + minimumTotalScrapValueForRoll + "-$" + num6 + ", adjustedValue=" + flag + "."));
		}
	}

	private static void HandleCleaningCompanyGrabbableStart(Component component)
	{
		if (!CleaningCompanyEnabled() || (Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null || !IsServerOrNoNetwork() || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance) || !IsScrapGrabbable(component))
		{
			return;
		}
		object field = GetField<object>(component, "itemProperties", null);
		if (field == null || !GetBool(field, "isScrap", fallback: false))
		{
			return;
		}
		string name = ((object)component).GetType().Name;
		string itemDisplayName = GetItemDisplayName(component, field);
		string objectName = ((Object)component.gameObject).name ?? string.Empty;
		if (IsApparatusItem(component, component.gameObject, itemDisplayName))
		{
			return;
		}
		TryApplyCleaningCompanyConvertedValue(component, "new scrap appeared");
		string messType;
		string outputType;
		bool flag = TryGetCleaningCompanyMessConversion(name, itemDisplayName, objectName, out messType, out outputType);
		bool flag2 = IsCleaningCompanyOutputType(name, itemDisplayName, objectName);
		if (flag || flag2)
		{
			CleaningMessValueTracker cleaningMessValueTracker = component.gameObject.GetComponent<CleaningMessValueTracker>();
			if ((Object)(object)cleaningMessValueTracker == (Object)null)
			{
				cleaningMessValueTracker = component.gameObject.AddComponent<CleaningMessValueTracker>();
			}
			if (flag)
			{
				cleaningMessValueTracker.Initialize(component, messType, outputType, tracksCleaningSource: true);
			}
			else
			{
				cleaningMessValueTracker.Initialize(component, GetCleaningCompanyOutputType(name, itemDisplayName, objectName), string.Empty, tracksCleaningSource: false);
			}
		}
	}

	private static bool CleaningCompanyEnabled()
	{
		return (Object)(object)plugin != (Object)null && plugin.ModEnabled.Value && plugin.CleaningCompanySupport != null && plugin.CleaningCompanySupport.Value;
	}

	internal static void NotifyCleaningCompanyMessGone(CleaningMessValueTracker tracker, string reason)
	{
		//IL_00f9: 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_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_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		if (!CleaningCompanyEnabled() || (Object)(object)tracker == (Object)null || !IsServerOrNoNetwork() || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			return;
		}
		Component scrapComponent = tracker.ScrapComponent;
		int num = Mathf.Max(1, tracker.LastKnownValue);
		if ((Object)(object)scrapComponent != (Object)null)
		{
			num = Mathf.Max(1, GetInt(scrapComponent, "scrapValue", num));
		}
		Vector3 position = tracker.LastKnownPosition;
		try
		{
			if ((Object)(object)((Component)tracker).transform != (Object)null)
			{
				position = ((Component)tracker).transform.position;
			}
		}
		catch
		{
		}
		CleaningConversionRecord cleaningConversionRecord = new CleaningConversionRecord
		{
			MessType = (string.IsNullOrEmpty(tracker.MessType) ? "scrap" : tracker.MessType),
			OutputType = (string.IsNullOrEmpty(tracker.OutputType) ? "*" : tracker.OutputType),
			Value = num,
			Position = position,
			CreatedAt = Time.realtimeSinceStartup,
			SourceInstanceId = tracker.SourceInstanceId,
			SourceObjectName = (tracker.SourceObjectName ?? string.Empty)
		};
		pendingCleaningConversions.Add(cleaningConversionRecord);
		CleanupExpiredCleaningCompanyConversions();
		TryApplyCleaningCompanyQueuedValuesToExistingOutputs("scrap disappeared " + reason);
		if (ShouldDebugLog())
		{
			Plugin.Log.LogInfo((object)("Cleaning Company value queued: " + cleaningConversionRecord.MessType + " -> " + cleaningConversionRecord.OutputType + " value=$" + cleaningConversionRecord.Value + " reason=" + reason + "."));
		}
	}

	private static void CleanupExpiredCleaningCompanyConversions()
	{
		if (pendingCleaningConversions.Count == 0 || Time.realtimeSinceStartup < nextCleaningConversionCleanupTime)
		{
			return;
		}
		nextCleaningConversionCleanupTime = Time.realtimeSinceStartup + 0.5f;
		float realtimeSinceStartup = Time.realtimeSinceStartup;
		float num = (((Object)(object)plugin != (Object)null && plugin.CleaningCompanyConversionWindowSeconds != null) ? Mathf.Max(0.25f, plugin.CleaningCompanyConversionWindowSeconds.Value) : 4f);
		for (int num2 = pendingCleaningConversions.Count - 1; num2 >= 0; num2--)
		{
			if (realtimeSinceStartup - pendingCleaningConversions[num2].CreatedAt > num)
			{
				pendingCleaningConversions.RemoveAt(num2);
			}
		}
	}

	private static void TryApplyCleaningCompanyQueuedValuesToExistingOutputs(string reason)
	{
		if (!CleaningCompanyEnabled() || pendingCleaningConversions.Count == 0)
		{
			return;
		}
		GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
		for (int i = 0; i < array.Length; i++)
		{
			if (pendingCleaningConversions.Count == 0)
			{
				break;
			}
			Component val = (Component)(object)array[i];
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.gameObject == (Object)null) && IsRecentlyStartedCleaningTrackedScrap(val))
			{
				TryApplyCleaningCompanyConvertedValue(val, reason);
			}
		}
	}

	private static bool TryApplyCleaningCompanyConvertedValue(Component outputComponent, string reason)
	{
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: 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_0181: Unknown result type (might be due to invalid IL or missing references)
		if (!CleaningCompanyEnabled() || (Object)(object)outputComponent == (Object)null || (Object)(object)outputComponent.gameObject == (Object)null || pendingCleaningConversions.Count == 0)
		{
			return false;
		}
		if (!IsScrapGrabbable(outputComponent))
		{
			return false;
		}
		object field = GetField<object>(outputComponent, "itemProperties", null);
		if (field == null || !GetBool(field, "isScrap", fallback: false))
		{
			return false;
		}
		string name = ((object)outputComponent).GetType().Name;
		string itemDisplayName = GetItemDisplayName(outputComponent, field);
		string objectName = ((Object)outputComponent.gameObject).name ?? string.Empty;
		if (IsApparatusItem(outputComponent, outputComponent.gameObject, itemDisplayName))
		{
			return false;
		}
		Vector3 position = outputComponent.transform.position;
		float num = (((Object)(object)plugin != (Object)null && plugin.CleaningCompanyConversionSearchRadius != null) ? Mathf.Max(0.25f, plugin.CleaningCompanyConversionSearchRadius.Value) : 6f);
		float num2 = num * num;
		int instanceID = ((Object)outputComponent.gameObject).GetInstanceID();
		int num3 = -1;
		float num4 = float.MaxValue;
		for (int i = 0; i < pendingCleaningConversions.Count; i++)
		{
			CleaningConversionRecord cleaningConversionRecord = pendingCleaningConversions[i];
			if (cleaningConversionRecord.SourceInstanceId != instanceID && CleaningCompanyOutputMatches(cleaningConversionRecord.OutputType, name, itemDisplayName, objectName))
			{
				Vector3 val = cleaningConversionRecord.Position - position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude <= num2 && sqrMagnitude < num4)
				{
					num4 = sqrMagnitude;
					num3 = i;
				}
			}
		}
		if (num3 < 0)
		{
			return false;
		}
		CleaningConversionRecord cleaningConversionRecord2 = pendingCleaningConversions[num3];
		pendingCleaningConversions.RemoveAt(num3);
		int num5 = Mathf.Max(1, cleaningConversionRecord2.Value);
		SetScrapValue(outputComponent, num5);
		RoundManager instance = RoundManager.Instance;
		int num6 = (((Object)(object)instance != (Object)null) ? Mathf.RoundToInt(GetField(instance, "totalScrapValueInLevel", 0f)) : 0);
		if (num6 <= 0)
		{
			num6 = num5;
		}
		List<ScrapComponentRecord> list = new List<ScrapComponentRecord>();
		list.Add(new ScrapComponentRecord
		{
			Component = outputComponent,
			GameObject = outputComponent.gameObject,
			Value = num5,
			ItemName = itemDisplayName,
			SyncIndex = -1
		});
		BroadcastScrapValueSync(list, num6, "Cleaning Company nearby conversion " + reason);
		CleaningMessValueTracker component = outputComponent.gameObject.GetComponent<CleaningMessValueTracker>();
		if ((Object)(object)component != (Object)null)
		{
			component.LastKnownValue = num5;
		}
		if (ShouldDebugLog())
		{
			Plugin.Log.LogInfo((object)("Cleaning Company preserved nearby value: " + cleaningConversionRecord2.MessType + " -> " + BuildCleaningCompanyScrapToken(name, itemDisplayName, objectName) + " value=$" + num5 + " reason=" + reason + "."));
		}
		return true;
	}

	private static bool IsRecentlyStartedCleaningTrackedScrap(Component component)
	{
		if ((Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null)
		{
			return false;
		}
		CleaningMessValueTracker component2 = component.gameObject.GetComponent<CleaningMessValueTracker>();
		if ((Object)(object)component2 == (Object)null)
		{
			return false;
		}
		float num = (((Object)(object)plugin != (Object)null && plugin.CleaningCompanyConversionWindowSeconds != null) ? Mathf.Max(0.25f, plugin.CleaningCompanyConversionWindowSeconds.Value) : 4f);
		return Time.realtimeSinceStartup - component2.CreatedAt <= num;
	}

	private static bool CleaningCompanyOutputMatches(string expectedOutputType, string typeName, string itemName, string objectName)
	{
		if (string.IsNullOrEmpty(expectedOutputType))
		{
			return false;
		}
		string cleaningCompanyOutputType = GetCleaningCompanyOutputType(typeName, itemName, objectName);
		return !string.IsNullOrEmpty(cleaningCompanyOutputType) && string.Equals(cleaningCompanyOutputType, expectedOutputType, StringComparison.OrdinalIgnoreCase);
	}

	private static bool TryGetCleaningCompanyMessConversion(string typeName, string itemName, string objectName, out string messType, out string outputType)
	{
		string token = BuildCleaningCompanyScrapToken(typeName, itemName, objectName);
		messType = string.Empty;
		outputType = string.Empty;
		if (TokenMatchesAnyCleaningName(token, "Scav Goop"))
		{
			messType = "Scav Goop";
			outputType = "Dirty Water";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Thumper Drool"))
		{
			messType = "Thumper Drool";
			outputType = "Dirty Water";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Bone Pile"))
		{
			messType = "Bone Pile";
			outputType = "Full Garbage Bag";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Nail Pile Item"))
		{
			messType = "Nail Pile Item";
			outputType = "Full Garbage Bag";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "BrackenDustItem"))
		{
			messType = "BrackenDustItem";
			outputType = "Full Garbage Bag";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Ethereal Essence"))
		{
			messType = "Ethereal Essence";
			outputType = "Full Garbage Bag";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Hoarding Bug Eggs"))
		{
			messType = "Hoarding Bug Eggs";
			outputType = "Full Garbage Bag";
			return true;
		}
		if (TokenMatchesAnyCleaningName(token, "Spore Pile"))
		{
			messType = "Spore Pile";
			outputType = "Full Garbage Bag";
			return true;
		}
		return false;
	}

	private static bool IsCleaningCompanyOutputType(string typeName, string itemName, string objectName)
	{
		string cleaningCompanyOutputType = GetCleaningCompanyOutputType(typeName, itemName, objectName);
		return !string.IsNullOrEmpty(cleaningCompanyOutputType);
	}

	private static string GetCleaningCompanyOutputType(string typeName, string itemName, string objectName)
	{
		string token = BuildCleaningCompanyScrapToken(typeName, itemName, objectName);
		if (TokenMatchesAnyCleaningName(token, "Dirty Water"))
		{
			return "Dirty Water";
		}
		if (TokenMatchesAnyCleaningName(token, "Full Garbage Bag"))
		{
			return "Full Garbage Bag";
		}
		return string.Empty;
	}

	private static string BuildCleaningCompanyScrapToken(string typeName, string itemName, string objectName)
	{
		string text = ((typeName ?? string.Empty) + " " + (itemName ?? string.Empty) + " " + (objectName ?? string.Empty)).Trim();
		return string.IsNullOrEmpty(text) ? "scrap" : text;
	}

	private static bool TokenMatchesAnyCleaningName(string token, params string[] names)
	{
		for (int i = 0; i < names.Length; i++)
		{
			if (TokenMatchesCleaningName(token, names[i]))
			{
				return true;
			}
		}
		return false;
	}

	private static bool TokenMatchesCleaningName(string token, string name)
	{
		if (string.IsNullOrEmpty(token) || string.IsNullOrEmpty(name))
		{
			return false;
		}
		string text = NormalizeCleaningName(token);
		string value = NormalizeCleaningName(name);
		return text.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static string NormalizeCleaningName(string value)
	{
		if (string.IsNullOrEmpty(value))
		{
			return string.Empty;
		}
		StringBuilder stringBuilder = new StringBuilder(value.Length);
		foreach (char c in value)
		{
			if (char.IsLetterOrDigit(c))
			{
				stringBuilder.Append(char.ToLowerInvariant(c));
			}
		}
		return stringBuilder.ToString();
	}

	private static List<ScrapComponentRecord> CollectMissionScrapRecords(bool includeHeld)
	{
		//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_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)
		List<ScrapComponentRecord> list = new List<ScrapComponentRecord>();
		Component[] array = Resources.FindObjectsOfTypeAll<Component>();
		Component[] array2 = array;
		foreach (Component val in array2)
		{
			if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null)
			{
				continue;
			}
			GameObject gameObject = val.gameObject;
			Scene scene = gameObject.scene;
			if (!((Scene)(ref scene)).IsValid())
			{
				continue;
			}
			scene = gameObject.scene;
			if (!((Scene)(ref scene)).isLoaded || !gameObject.activeInHierarchy || !IsScrapGrabbable(val) || ((GetBool(val, "isHeld", fallback: false) || GetBool(val, "isHeldByEnemy", fallback: false)) && !includeHeld))
			{
				continue;
			}
			object field = GetField<object>(val, "itemProperties", null);
			if (field != null && GetBool(field, "isScrap", fallback: false))
			{
				string itemDisplayName = GetItemDisplayName(val, field);
				if (!IsApparatusItem(val, gameObject, itemDisplayName))
				{
					list.Add(new ScrapComponentRecord
					{
						Component = val,
						GameObject = gameObject,
						Value = GetInt(val, "scrapValue", 0),
						ItemName = itemDisplayName
					});
				}
			}
		}
		return list;
	}

	private static int SumScrapRecordValues(List<ScrapComponentRecord> records)
	{
		int num = 0;
		if (records == null)
		{
			return 0;
		}
		for (int i = 0; i < records.Count; i++)
		{
			if (records[i] != null && (Object)(object)records[i].Component != (Object)null)
			{
				num += Mathf.Max(0, GetInt(records[i].Component, "scrapValue", records[i].Value));
			}
		}
		return num;
	}

	private static void NormalizeScrapRecordValues(List<ScrapComponentRecord> records, int targetValue)
	{
		if (records == null || records.Count == 0)
		{
			return;
		}
		targetValue = Mathf.Max(records.Count, targetValue);
		int num = 0;
		for (int i = 0; i < records.Count; i++)
		{
			num += Mathf.Max(1, records[i].Value);
		}
		if (num <= 0)
		{
			num = records.Count;
		}
		int[] array = new int[records.Count];
		int num2 = 0;
		for (int j = 0; j < records.Count; j++)
		{
			float num3 = (float)Mathf.Max(1, records[j].Value) / (float)num * (float)targetValue;
			num2 += (array[j] = Mathf.Max(1, Mathf.FloorToInt(num3)));
		}
		int num4 = targetValue - num2;
		int num5 = 0;
		while (num4 != 0 && num5 < 100000)
		{
			int num6 = num5 % array.Length;
			if (num4 > 0)
			{
				array[num6]++;
				num4--;
			}
			else if (array[num6] > 1)
			{
				array[num6]--;
				num4++;
			}
			num5++;
		}
		for (int k = 0; k < records.Count; k++)
		{
			SetScrapValue(records[k].Component, array[k]);
			records[k].Value = array[k];
		}
	}

	private static void SetScrapValue(Component component, int value)
	{
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		value = Mathf.Max(0, value);
		try
		{
			MethodInfo method = ((object)component).GetType().GetMethod("SetScrapValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(int) }, null);
			if (method != null)
			{
				method.Invoke(component, new object[1] { value });
			}
		}
		catch
		{
		}
		ForceScrapValueFields(component, value);
	}

	private static void ForceScrapValueFields(Component component, int value)
	{
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		value = Mathf.Max(0, value);
		try
		{
			SetField(component, "scrapValue", value);
		}
		catch
		{
		}
		try
		{
			ScanNodeProperties val = (((Object)(object)component.gameObject != (Object)null) ? component.gameObject.GetComponentInChildren<ScanNodeProperties>(true) : null);
			if ((Object)(object)val != (Object)null)
			{
				val.scrapValue = value;
				val.subText = "Value: $" + value;
			}
		}
		catch
		{
		}
	}

	private static void DespawnOrDestroyScrap(Component component)
	{
		if ((Object)(object)component == (Object)null || (Object)(object)component.gameObject == (Object)null)
		{
			return;
		}
		try
		{
			NetworkObject component2 = component.GetComponent<NetworkObject>();
			if ((Object)(object)component2 != (Object)null && component2.IsSpawned && IsServerOrNoNetwork())
			{
				component2.Despawn(true);
				return;
			}
		}
		catch
		{
		}
		try
		{
			Object.Destroy((Object)(object)component.gameObject);
		}
		catch
		{
		}
	}

	private static string BuildScrapLine(int index, int scrapValue, string itemName, string objectName, string typeName, string sceneName, Vector3 pos, bool itemPropertiesSaysScrap, bool isApparatus, bool held, bool inShip, bool inFactory, string path)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append("  ");
		stringBuilder.Append(index.ToString("000"));
		stringBuilder.Append(" | value=$");
		stringBuilder.Append(scrapValue);
		stringBuilder.Append(" | item='");
		stringBuilder.Append(itemName);
		stringBuilder.Append("' | object='");
		stringBuilder.Append(objectName);
		stringBuilder.Append("' | type=");
		stringBuilder.Append(typeName);
		stringBuilder.Append(" | scene=");
		stringBuilder.Append(sceneName);
		stringBuilder.Append(" | pos=");
		stringBuilder.Append(FormatVector(pos));
		stringBuilder.Append(" | itemProperties.isScrap=");
		stringBuilder.Append(itemPropertiesSaysScrap);
		stringBuilder.Append(" | apparatus=");
		stringBuilder.Append(isApparatus);
		stringBuilder.Append(" | held=");
		stringBuilder.Append(held);
		stringBuilder.Append(" | inShip=");
		stringBuilder.Append(inShip);
		stringBuilder.Append(" | inFactory=");
		stringBuilder.Append(inFactory);
		stringBuilder.Append(" | path=");
		stringBuilder.Append(path);
		stringBuilder.AppendLine();
		return stringBuilder.ToString();
	}

	private static bool IsApparatusItem(Component component, GameObject gameObject, string itemName)
	{
		string text = (((Object)(object)component != (Object)null) ? ((object)component).GetType().Name : string.Empty);
		string text2 = (((Object)(object)gameObject != (Object)null) ? ((Object)gameObject).name : string.Empty);
		if (!string.IsNullOrEmpty(text) && text.IndexOf("Lung", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (!string.IsNullOrEmpty(text2) && text2.IndexOf("LungApparatus", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (!string.IsNullOrEmpty(itemName) && itemName.IndexOf("Apparatus", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		return false;
	}

	private static string GetItemDisplayName(Component component, object itemProperties)
	{
		string text = ((itemProperties != null) ? GetField<string>(itemProperties, "itemName", null) : null);
		if (!string.IsNullOrWhiteSpace(text))
		{
			return text;
		}
		text = GetField<string>(component, "itemName", null);
		if (!string.IsNullOrWhiteSpace(text))
		{
			return text;
		}
		return ((Object)(object)component != (Object)null && (Object)(object)component.gameObject != (Object)null) ? ((Object)component.gameObject).name : "unknown";
	}

	private static string FormatVector(Vector3 value)
	{
		return "(" + value.x.ToString("0.00") + ", " + value.y.ToString("0.00") + ", " + value.z.ToString("0.00") + ")";
	}

	private static Vector3 ScrapDebugOffset(int index)
	{
		//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_003f: Unknown result type (might be due to invalid IL or missing references)
		int num = index % 7;
		int num2 = index / 7 % 7;
		int num3 = index / 49;
		float num4 = (float)(num - 3) * 0.55f;
		float num5 = (float)(num2 - 3) * 0.55f;
		float num6 = (float)num3 * 0.2f;
		return new Vector3(num4, num6, num5);
	}

	private static void TeleportScrapComponent(Component component, Vector3 position)
	{
		//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_0056: 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_007b: 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)
		Transform transform = component.transform;
		transform.position = position;
		transform.rotation = Quaternion.identity;
		Rigidbody component2 = component.GetComponent<Rigidbody>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.velocity = Vector3.zero;
			component2.angularVelocity = Vector3.zero;
			component2.position = position;
		}
		SetField(component, "startFallingPosition", position);
		SetField(component, "targetFloorPosition", position);
		SetField(component, "floorYRot", transform.eulerAngles.y);
		SetField(component, "fallTime", 1f);
		SetField(component, "hasHitGround", true);
		SetField(component, "reachedFloorTarget", true);
		SetField(component, "isInElevator", false);
		SetField(component, "isInShipRoom", false);
		SetField(component, "isInFactory", true);
	}

	private static bool IsScrapGrabbable(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return false;
		}
		if (!TypeIsOrInherits(((object)component).GetType(), "GrabbableObject"))
		{
			return false;
		}
		object field = GetField<object>(component, "itemProperties", null);
		if (field != null && GetBool(field, "isScrap", fallback: false))
		{
			return true;
		}
		return GetInt(component, "scrapValue", 0) > 0;
	}

	private static bool TypeIsOrInherits(Type type, string typeName)
	{
		while (type != null)
		{
			if (string.Equals(type.Name, typeName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			type = type.BaseType;
		}
		return false;
	}

	private static string BuildActualVsExpectedDebugReport(RoundManager round, TimeOfDay time, ScrapDebugStats scrapStats)
	{
		StringBuilder stringBuilder = new StringBuilder();
		MissionRoll currentRoll = CurrentRoll;
		SelectableLevel activeLevel = GetActiveLevel(round, time);
		stringBuilder.AppendLine("Mission Debug: actual mission scrap " + scrapStats.SpawnedScrapCount + " items / $" + scrapStats.TotalScrapValue + " excluding apparatus. Apparatus " + scrapStats.ApparatusCount + " / $" + scrapStats.ApparatusValue + ". Raw valued objects " + scrapStats.RawValuedGrabbableCount + " / $" + scrapStats.RawValuedGrabbableValue + ". Teleported true scrap " + scrapStats.TeleportedCount + ".");
		if (!string.IsNullOrEmpty(scrapStats.Error))
		{
			stringBuilder.AppendLine("Mission Debug error: " + scrapStats.Error);
		}
		if (HasRoll)
		{
			float num = (((Object)(object)round != (Object)null) ? GetFloat(round, "scrapAmountMultiplier", currentRoll.ScrapAmountMultiplier) : currentRoll.ScrapAmountMultiplier);
			int num2 = Mathf.RoundToInt((float)currentRoll.MinScrap * num);
			int num3 = Mathf.CeilToInt((float)currentRoll.MaxScrap * num);
			stringBuilder.AppendLine("Expected orbit roll: rank " + currentRoll.Rank + ", displayed scrap " + currentRoll.MinScrap + "-" + currentRoll.MaxScrap + ", effective if multiplier applies " + num2 + "-" + num3 + ", value range " + TotalScrapValueRangeText(currentRoll) + ", power " + currentRoll.MaxInsideEnemyPower + ", size " + currentRoll.FactorySizeMultiplier.ToString("0.00") + ", amount x" + num.ToString("0.00") + ", value x" + currentRoll.ScrapValueMultiplier.ToString("0.00") + ".");
		}
		else
		{
			stringBuilder.AppendLine("Expected orbit roll: no mission roll exists yet.");
		}
		if ((Object)(object)activeLevel != (Object)null)
		{
			string field = GetField(activeLevel, "riskLevel", "?");
			int @int = GetInt(activeLevel, "minScrap", -1);
			int int2 = GetInt(activeLevel, "maxScrap", -1);
			int int3 = GetInt(activeLevel, "maxTotalScrapValue", -1);
			int int4 = GetInt(activeLevel, "maxEnemyPowerCount", -1);
			int int5 = GetInt(activeLevel, "maxOutsideEnemyPowerCount", -1);
			int int6 = GetInt(activeLevel, "maxDaytimeEnemyPowerCount", -1);
			float @float = GetFloat(activeLevel, "factorySizeMultiplier", -1f);
			stringBuilder.AppendLine("Actual level values: risk " + field + ", scrap " + @int + "-" + int2 + ", max value $" + int3 + ", inside power " + int4 + ", outside/day " + int5 + "/" + int6 + ", size " + @float.ToString("0.00") + ".");
		}
		else
		{
			stringBuilder.AppendLine("Actual level values: no active SelectableLevel found.");
		}
		if ((Object)(object)round != (Object)null)
		{
			float float2 = GetFloat(round, "currentMaxInsidePower", -1f);
			float float3 = GetFloat(round, "currentMaxOutsidePower", -1f);
			int int7 = GetInt(round, "currentMaxInsideDiversityLevel", -1);
			int int8 = GetInt(round, "minEnemiesToSpawn", -1);
			int int9 = GetInt(round, "hourTimeBetweenEnemySpawnBatches", -1);
			float float4 = GetFloat(round, "mapSizeMultiplier", -1f);
			float float5 = GetFloat(round, "scrapAmountMultiplier", -1f);
			float float6 = GetFloat(round, "scrapValueMultiplier", -1f);
			stringBuilder.AppendLine("Actual round values: inside/outside power " + float2.ToString("0.##") + "/" + float3.ToString("0.##") + ", diversity " + int7 + ", min enemies " + int8 + ", batch hours " + int9 + ", size " + float4.ToString("0.00") + ", amount x" + float5.ToString("0.00") + ", value x" + float6.ToString("0.00") + ".");
		}
		return stringBuilder.ToString().Trim();
	}

	private static string BuildFullMissionDebugFileReport(string reason, RoundManager round, TimeOfDay time, ScrapDebugStats? scrapStatsNullable)
	{
		StringBuilder stringBuilder = new StringBuilder();
		SelectableLevel activeLevel = GetActiveLevel(round, time);
		stringBuilder.AppendLine("============================================================");
		stringBuilder.AppendLine("LC MISSION RANDOMIZER DEBUG FILE");
		stringBuilder.AppendLine("============================================================");
		stringBuilder.AppendLine("Reason: " + reason);
		stringBuilder.AppendLine("Local time: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
		stringBuilder.AppendLine("UTC time: " + DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") + " UTC");
		stringBuilder.AppendLine("Plugin version: 0.1.25");
		stringBuilder.AppendLine("Server/host authoritative side: " + IsServerOrNoNetwork());
		stringBuilder.AppendLine("Has mission roll: " + HasRoll);
		stringBuilder.AppendLine();
		AppendSceneList(stringBuilder);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== EXPECTED ORBIT MISSION ROLL ===");
		if (HasRoll)
		{
			AppendExpectedRoll(stringBuilder, CurrentRoll);
		}
		else
		{
			stringBuilder.AppendLine("No mission roll exists yet.");
		}
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== VALUES THIS MOD TRIED TO APPLY ===");
		if (HasRoll)
		{
			AppendAttemptedChangedValues(stringBuilder, CurrentRoll);
		}
		else
		{
			stringBuilder.AppendLine("No attempted values. No roll exists yet.");
		}
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== ACTUAL SELECTABLE LEVEL VALUES NOW ===");
		AppendSelectableLevelValues(stringBuilder, activeLevel);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== ACTUAL ROUND MANAGER VALUES NOW ===");
		AppendRoundManagerValues(stringBuilder, round);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== ACTUAL TIME OF DAY VALUES NOW ===");
		AppendTimeOfDayValues(stringBuilder, time);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("=== TERMINAL / CATALOGUE SNAPSHOT ===");
		AppendTerminalSnapshot(stringBuilder);
		stringBuilder.AppendLine();
		if (scrapStatsNullable.HasValue)
		{
			ScrapDebugStats value = scrapStatsNullable.Value;
			stringBuilder.AppendLine("=== SPAWNED SCRAP SNAPSHOT ===");
			stringBuilder.AppendLine("Raw valued grabbables found: " + value.RawValuedGrabbableCount + " / $" + value.RawValuedGrabbableValue);
			stringBuilder.AppendLine("Actual mission scrap only, excluding apparatus and non-scrap valued items: " + value.SpawnedScrapCount + " / $" + value.TotalScrapValue);
			stringBuilder.AppendLine("True scrap including apparatus: " + value.TrueScrapIncludingApparatusCount + " / $" + value.TrueScrapIncludingApparatusValue);
			stringBuilder.AppendLine("Apparatus only: " + value.ApparatusCount + " / $" + value.ApparatusValue);
			stringBuilder.AppendLine("Non-scrap valued grabbables, keys/manual/sticky notes/etc: " + value.ValueOnlyCount + " / $" + value.ValueOnlyValue);
			stringBuilder.AppendLine("Held/skipped count: " + value.HeldOrSkippedCount);
			stringBuilder.AppendLine("Teleported true scrap count: " + value.TeleportedCount);
			stringBuilder.AppendLine("Mission scrap min item value: $" + value.MinScrapValue);
			stringBuilder.AppendLine("Mission scrap max item value: $" + value.MaxScrapValue);
			if (!string.IsNullOrEmpty(value.Error))
			{
				stringBuilder.AppendLine("Error: " + value.Error);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("--- ACTUAL LOADED MISSION SCRAP ITEMS ONLY ---");
			stringBuilder.Append(value.ItemBreakdown);
			if (string.IsNullOrWhiteSpace(value.ItemBreakdown))
			{
				stringBuilder.AppendLine("No actual mission scrap items were found.");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("--- APPARATUS ITEMS, LOGGED SEPARATELY ---");
			stringBuilder.Append(value.ApparatusBreakdown);
			if (string.IsNullOrWhiteSpace(value.ApparatusBreakdown))
			{
				stringBuilder.AppendLine("No apparatus item was found.");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("--- NON-SCRAP VALUED GRABBABLES, EXCLUDED FROM MISSION SCRAP TOTAL ---");
			stringBuilder.Append(value.NonScrapBreakdown);
			if (string.IsNullOrWhiteSpace(value.NonScrapBreakdown))
			{
				stringBuilder.AppendLine("No non-scrap valued grabbables were found.");
			}
			stringBuilder.AppendLine();
			if (HasRoll)
			{
				float num = (((Object)(object)round != (Object)null) ? GetFloat(round, "scrapAmountMultiplier", CurrentRoll.ScrapAmountMultiplier) : CurrentRoll.ScrapAmountMultiplier);
				int num2 = Mathf.RoundToInt((float)CurrentRoll.MinScrap * num);
				int num3 = Mathf.CeilToInt((float)CurrentRoll.MaxScrap * num);
				stringBuilder.AppendLine("=== EXPECTED VS ACTUAL QUICK CHECK ===");
				stringBuilder.AppendLine("Displayed/base scrap count range: " + CurrentRoll.MinScrap + " - " + CurrentRoll.MaxScrap);
				stringBuilder.AppendLine("RoundManager.scrapAmountMultiplier at snapshot: " + num.ToString("0.000"));
				stringBuilder.AppendLine("Effective generated range if the game applies that multiplier: " + num2 + " - " + num3);
				stringBuilder.AppendLine("Actual loaded mission scrap count, excluding apparatus: " + value.SpawnedScrapCount);
				stringBuilder.AppendLine("Base displayed count inside expected range: " + (value.SpawnedScrapCount >= CurrentRoll.MinScrap && value.SpawnedScrapCount <= CurrentRoll.MaxScrap));
				stringBuilder.AppendLine("Effective multiplied count inside expected range: " + (value.SpawnedScrapCount >= num2 && value.SpawnedScrapCount <= num3));
				stringBuilder.AppendLine("Expected total scrap value range target: " + TotalScrapValueRangeText(CurrentRoll));
				stringBuilder.AppendLine("Actual loaded mission scrap value, excluding apparatus: $" + value.TotalScrapValue);
				stringBuilder.AppendLine("Actual loaded mission scrap over max target by: $" + (value.TotalScrapValue - CurrentRoll.MaxTotalScrapValue));
				stringBuilder.AppendLine("Actual true scrap including apparatus over max target by: $" + (value.TrueScrapIncludingApparatusValue - CurrentRoll.MaxTotalScrapValue));
				stringBuilder.AppendLine();
			}
		}
		return stringBuilder.ToString();
	}

	private static void AppendSceneList(StringBuilder sb)
	{
		//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)
		sb.AppendLine("=== LOADED SCENES ===");
		for (int i = 0; i < SceneManager.sceneCount; i++)
		{
			Scene sceneAt = SceneManager.GetSceneAt(i);
			sb.AppendLine("Scene[" + i + "] name='" + ((Scene)(ref sceneAt)).name + "' path='" + ((Scene)(ref sceneAt)).path + "' loaded=" + ((Scene)(ref sceneAt)).isLoaded + " rootCount=" + ((Scene)(ref sceneAt)).rootCount);
		}
	}

	private static void AppendExpectedRoll(StringBuilder sb, MissionRoll r)
	{
		sb.AppendLine("Seed: " + r.Seed);
		sb.AppendLine("Quota: $" + r.QuotaFulfilled + " / $" + r.ProfitQuota + " remaining=$" + r.QuotaRemaining + " daysLeft=" + r.DaysLeft + " quotaNumber=" + r.QuotaNumber);
		sb.AppendLine("Rank: " + r.Rank + " rankIndex=" + r.RankIndex + " difficultyScore=" + r.DifficultyScore.ToString("0.000"));
		sb.AppendLine("Scrap count target: " + r.MinScrap + " - " + r.MaxScrap);
		sb.AppendLine("Total scrap value range target: " + TotalScrapValueRangeText(r));
		sb.AppendLine("Inside/outside/daytime enemy power: " + r.MaxInsideEnemyPower + " / " + r.MaxOutsideEnemyPower + " / " + r.MaxDaytimeEnemyPower);
		sb.AppendLine("Min enemies to spawn: " + r.MinEnemiesToSpawn);
		sb.AppendLine("Spawn batch hours: " + r.SpawnBatchHours);
		sb.AppendLine("Inside diversity: " + r.MaxInsideDiversity);
		sb.AppendLine("Factory size multiplier: " + r.FactorySizeMultiplier.ToString("0.000"));
		sb.AppendLine("RoundManager scrap amount multiplier: " + r.ScrapAmountMultiplier.ToString("0.000"));
		sb.AppendLine("RoundManager scrap value multiplier: " + r.ScrapValueMultiplier.ToString("0.000"));
	}

	private static void AppendAttemptedChangedValues(StringBuilder sb, MissionRoll r)
	{
		int minimumTotalScrapValueForRoll = GetMinimumTotalScrapValueForRoll(r);
		sb.AppendLine("SelectableLevel.PlanetName -> Mission Zone");
		sb.AppendLine("SelectableLevel.riskLevel -> " + r.Rank);
		sb.AppendLine("SelectableLevel.factorySizeMultiplier -> " + r.FactorySizeMultiplier.ToString("0.000"));
		sb.AppendLine("SelectableLevel.minScrap -> " + r.MinScrap);
		sb.AppendLine("SelectableLevel.maxScrap -> " + r.MaxScrap);
		sb.AppendLine("SelectableLevel.minTotalScrapValue -> " + minimumTotalScrapValueForRoll);
		sb.AppendLine("SelectableLevel.maxTotalScrapValue -> " + r.MaxTotalScrapValue);
		sb.AppendLine("SelectableLevel.maxEnemyPowerCount -> " + r.MaxInsideEnemyPower);
		sb.AppendLine("SelectableLevel.maxOutsideEnemyPowerCount -> " + r.MaxOutsideEnemyPower);
		sb.AppendLine("SelectableLevel.maxDaytimeEnemyPowerCount -> " + r.MaxDaytimeEnemyPower);
		sb.AppendLine("SelectableLevel.spawnEnemiesAndScrap -> true");
		sb.AppendLine("RoundManager.scrapValueMultiplier -> " + r.ScrapValueMultiplier.ToString("0.000"));
		sb.AppendLine("RoundManager.scrapAmountMultiplier -> " + r.ScrapAmountMultiplier.ToString("0.000"));
		sb.AppendLine("RoundManager.mapSizeMultiplier -> " + r.FactorySizeMultiplier.ToString("0.000"));
		sb.AppendLine("RoundManager.currentMaxInsidePower -> " + r.MaxInsideEnemyPower);
		sb.AppendLine("RoundManager.currentMaxOutsidePower -> " + r.MaxOutsideEnemyPower);
		sb.AppendLine("RoundManager.currentMaxInsideDiversityLevel -> " + r.MaxInsideDiversity);
		sb.AppendLine("RoundManager.currentMaxOutsideDiversityLevel -> " + ((!plugin.DisableOutsideAndDaytimePower.Value) ? r.MaxInsideDiversity : 0));
		sb.AppendLine("RoundManager.minEnemiesToSpawn -> " + r.MinEnemiesToSpawn);
		sb.AppendLine("RoundManager.minOutsideEnemiesToSpawn -> 0");
		sb.AppendLine("RoundManager.hourTimeBetweenEnemySpawnBatches -> " + r.SpawnBatchHours);
	}

	private static void AppendSelectableLevelValues(StringBuilder sb, SelectableLevel level)
	{
		if ((Object)(object)level == (Object)null)
		{
			sb.AppendLine("No active SelectableLevel found.");
			return;
		}
		sb.AppendLine("Unity name: " + ((Object)level).name);
		sb.AppendLine("PlanetName: " + GetField(level, "PlanetName", "?"));
		sb.AppendLine("sceneName: " + GetField(level, "sceneName", "?"));
		sb.AppendLine("levelID: " + GetInt(level, "levelID", -1));
		sb.AppendLine("riskLevel: " + GetField(level, "riskLevel", "?"));
		sb.AppendLine("spawnEnemiesAndScrap: " + GetBool(level, "spawnEnemiesAndScrap", fallback: false));
		sb.AppendLine("factorySizeMultiplier: " + GetFloat(level, "factorySizeMultiplier", -1f).ToString("0.000"));
		sb.AppendLine("minScrap: " + GetInt(level, "minScrap", -1));
		sb.AppendLine("maxScrap: " + GetInt(level, "maxScrap", -1));
		sb.AppendLine("minTotalScrapValue: " + GetInt(level, "minTotalScrapValue", -1));
		sb.AppendLine("maxTotalScrapValue: " + GetInt(level, "maxTotalScrapValue", -1));
		sb.AppendLine("maxEnemyPowerCount: " + GetInt(level, "maxEnemyPowerCount", -1));
		sb.AppendLine("maxOutsideEnemyPowerCount: " + GetInt(level, "maxOutsideEnemyPowerCount", -1));
		sb.AppendLine("maxDaytimeEnemyPowerCount: " + GetInt(level, "maxDaytimeEnemyPowerCount", -1));
		sb.AppendLine("maxInsideDiversityPowerCount: " + GetInt(level, "maxInsideDiversityPowerCount", -1));
		sb.AppendLine("maxOutsideDiversityPowerCount: " + GetInt(level, "maxOutsideDiversityPowerCount", -1));
		sb.AppendLine("spawnableScrap.Count: " + GetListCount(GetField<object>(level, "spawnableScrap", null)));
		sb.AppendLine("Enemies.Count: " + GetListCount(GetField<object>(level, "Enemies", null)));
		sb.AppendLine("OutsideEnemies.Count: " + GetListCount(GetField<object>(level, "OutsideEnemies", null)));
		sb.AppendLine("DaytimeEnemies.Count: " + GetListCount(GetField<object>(level, "DaytimeEnemies", null)));
	}

	private static void AppendRoundManagerValues(StringBuilder sb, RoundManager round)
	{
		if ((Object)(object)round == (Object)null)
		{
			sb.AppendLine("RoundManager.Instance is null.");
			return;
		}
		SelectableLevel field = GetField<SelectableLevel>(round, "currentLevel", null);
		sb.AppendLine("currentLevel: " + (((Object)(object)field != (Object)null) ? ((Object)field).name : "null"));
		sb.AppendLine("scrapValueMultiplier: " + GetFloat(round, "scrapValueMultiplier", -1f).ToString("0.000"));
		sb.AppendLine("scrapAmountMultiplier: " + GetFloat(round, "scrapAmountMultiplier", -1f).ToString("0.000"));
		sb.AppendLine("mapSizeMultiplier: " + GetFloat(round, "mapSizeMultiplier", -1f).ToString("0.000"));
		sb.AppendLine("currentMaxInsidePower: " + GetFloat(round, "currentMaxInsidePower", -1f).ToString("0.000"));
		sb.AppendLine("currentMaxOutsidePower: " + GetFloat(round, "currentMaxOutsidePower", -1f).ToString("0.000"));
		sb.AppendLine("currentMaxInsideDiversityLevel: " + GetInt(round, "currentMaxInsideDiversityLevel", -1));
		sb.AppendLine("currentMaxOutsideDiversityLevel: " + GetInt(round, "currentMaxOutsideDiversityLevel", -1));
		sb.AppendLine("minEnemiesToSpawn: " + GetInt(round, "minEnemiesToSpawn", -1));
		sb.AppendLine("minOutsideEnemiesToSpawn: " + GetInt(round, "minOutsideEnemiesToSpawn", -1));
		sb.AppendLine("hourTimeBetweenEnemySpawnBatches: " + GetInt(round, "hourTimeBetweenEnemySpawnBatches", -1));
		sb.AppendLine("totalScrapValueInLevel: " + GetFloat(round, "totalScrapValueInLevel", -1f).ToString("0.000"));
		sb.AppendLine("scrapCollectedInLevel: " + GetInt(round, "scrapCollectedInLevel", -1));
		sb.AppendLine("valueOfFoundScrapItems: " + GetInt(round, "valueOfFoundScrapItems", -1));
		Transform field2 = GetField<Transform>(round, "spawnedScrapContainer", null);
		sb.AppendLine("spawnedScrapContainer: " + (((Object)(object)field2 != (Object)null) ? (GetPath(field2) + " childCount=" + field2.childCount) : "null"));
		sb.AppendLine("currentEnemyPower: " + GetFloat(round, "currentEnemyPower", -1f).ToString("0.000"));
		sb.AppendLine("currentOutsideEnemyPower: " + GetFloat(round, "currentOutsideEnemyPower", -1f).ToString("0.000"));
	}

	private static void AppendTimeOfDayValues(StringBuilder sb, TimeOfDay time)
	{
		if ((Object)(object)time == (Object)null)
		{
			sb.AppendLine("TimeOfDay.Instance is null.");
			return;
		}
		SelectableLevel field = GetField<SelectableLevel>(time, "currentLevel", null);
		sb.AppendLine("currentLevel: " + (((Object)(object)field != (Object)null) ? ((Object)field).name : "null"));
		sb.AppendLine("profitQuota: " + GetInt(time, "profitQuota", -1));
		sb.AppendLine("quotaFulfilled: " + GetInt(time, "quotaFulfilled", -1));
		sb.AppendLine("timesFulfilledQuota: " + GetInt(time, "timesFulfilledQuota", -1));
		sb.AppendLine("daysUntilDeadline: " + GetInt(time, "daysUntilDeadline", -1));
		sb.AppendLine("hoursUntilDeadline: " + GetInt(time, "hoursUntilDeadline", -1));
		sb.AppendLine("currentDayTime: " + GetFloat(time, "currentDayTime", -1f).ToString("0.000"));
		sb.AppendLine("globalTime: " + GetFloat(time, "globalTime", -1f).ToString("0.000"));
	}

	private static void AppendTerminalSnapshot(StringBuilder sb)
	{
		Terminal val = null;
		try
		{
			Terminal[] array = Resources.FindObjectsOfTypeAll<Terminal>();
			if (array != null && array.Length != 0)
			{
				val = array[0];
			}
		}
		catch
		{
		}
		if ((Object)(object)val == (Object)null)
		{
			sb.AppendLine("No Terminal object found.");
			return;
		}
		sb.AppendLine("Terminal object: " + ((Object)val).name + " path=" + GetPath(((Component)val).transform));
		sb.AppendLine("groupCredits: " + GetInt(val, "groupCredits", -1));
		sb.AppendLine("moonsCatalogueList.Count: " + GetListCount(GetField<object>(val, "moonsCatalogueList", null)));
		sb.AppendLine("buyableVehicles.Count: " + GetListCount(GetField<object>(val, "buyableVehicles", null)));
	}

	private static int GetListCount(object list)
	{
		if (list == null)
		{
			return -1;
		}
		try
		{
			if (list is ICollection collection)
			{
				return collection.Count;
			}
			PropertyInfo property = list.GetType().GetProperty("Count", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				return Convert.ToInt32(property.GetValue(list, null));
			}
		}
		catch
		{
		}
		return -1;
	}

	private static string[] SplitDebugReportForChat(string report)
	{
		if (string.IsNullOrWhiteSpace(report))
		{
			return new string[1] { "Mission Debug: no report." };
		}
		return report.Replace("\r", "").Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
	}

	private static void SendDebugChatLine(string message)
	{
		if (string.IsNullOrWhiteSpace(message))
		{
			return;
		}
		string text = (message.StartsWith("Mission Debug", StringComparison.OrdinalIgnoreCase) ? message : ("Mission Debug: " + message));
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)text);
		}
		try
		{
			HUDManager instance = HUDManager.Instance;
			if (!((Object)(object)instance == (Object)null) && !TryInvokeHudTextMethod(instance, "AddTextToChatOnServer", text) && !TryInvokeHudTextMethod(instance, "AddChatMessage", text))
			{
				TryInvokeHudDisplayTip(instance, "Mission Debug", text);
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("SendDebugChatLine failed: " + ex.Message));
			}
		}
	}

	private static bool TryInvokeHudTextMethod(HUDManager hud, string methodName, string message)
	{
		if ((Object)(object)hud == (Object)null)
		{
			return false;
		}
		Type type = ((object)hud).GetType();
		while (type != null)
		{
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo in array)
			{
				if (!string.Equals(methodInfo.Name, methodName, StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				object[] array2 = new object[parameters.Length];
				bool flag = true;
				for (int j = 0; j < parameters.Length; j++)
				{
					Type parameterType = parameters[j].ParameterType;
					if (parameterType == typeof(string))
					{
						array2[j] = ((j == 0) ? message : string.Empty);
						continue;
					}
					if (parameterType == typeof(int))
					{
						array2[j] = -1;
						continue;
					}
					if (parameterType == typeof(bool))
					{
						array2[j] = false;
						continue;
					}
					if (parameterType == typeof(float))
					{
						array2[j] = 0f;
						continue;
					}
					if (parameters[j].HasDefaultValue)
					{
						array2[j] = parameters[j].DefaultValue;
						continue;
					}
					flag = false;
					break;
				}
				if (flag)
				{
					methodInfo.Invoke(hud, array2);
					return true;
				}
			}
			type = type.BaseType;
		}
		return false;
	}

	private static bool TryInvokeHudDisplayTip(HUDManager hud, string title, string message)
	{
		if ((Object)(object)hud == (Object)null)
		{
			return false;
		}
		Type type = ((object)hud).GetType();
		while (type != null)
		{
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo[] array = methods;
			foreach (MethodInfo methodInfo in array)
			{
				if (!string.Equals(methodInfo.Name, "DisplayTip", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				object[] array2 = new object[parameters.Length];
				int num = 0;
				bool flag = true;
				for (int j = 0; j < parameters.Length; j++)
				{
					Type parameterType = parameters[j].ParameterType;
					if (parameterType == typeof(string))
					{
						switch (num)
						{
						case 0:
							array2[j] = title;
							break;
						case 1:
							array2[j] = message;
							break;
						default:
							array2[j] = "LC_Tip1";
							break;
						}
						num++;
					}
					else if (parameterType == typeof(bool))
					{
						array2[j] = false;
					}
					else if (parameterType == typeof(float))
					{
						array2[j] = 0f;
					}
					else
					{
						if (!parameters[j].HasDefaultValue)
						{
							flag = false;
							break;
						}
						array2[j] = parameters[j].DefaultValue;
					}
				}
				if (flag)
				{
					methodInfo.Invoke(hud, array2);
					return true;
				}
			}
			type = type.BaseType;
		}
		return false;
	}

	internal static bool TryHandleTerminalCommand(Terminal terminal, ref TerminalNode result)
	{
		if ((Object)(object)plugin == (Object)null || !plugin.ModEnabled.Value || !plugin.BlockMoonTerminalCommands.Value)
		{
			return true;
		}
		string terminalCommand = GetTerminalCommand(terminal);
		if (string.IsNullOrWhiteSpace(terminalCommand))
		{
			return true;
		}
		string text = NormalizeTerminalCommand(terminalCommand);
		if (pendingTerminalRoute != 0 && Time.realtimeSinceStartup > pendingTerminalRouteExpiresAt)
		{
			pendingTerminalRoute = 0;
			pendingTerminalRouteExpiresAt = 0f;
		}
		if (IsTerminalDenyCommand(text) && pendingTerminalRoute != 0)
		{
			pendingTerminalRoute = 0;
			pendingTerminalRouteExpiresAt = 0f;
			result = GetMissionTerminalNode("Route cancelled.\n\nAllowed routes:\n- MISSION or EXPERIMENTATION\n- COMPANY\n\n");
			return false;
		}
		if (IsTerminalConfirmCommand(text) && pendingTerminalRoute != 0)
		{
			bool flag = pendingTerminalRoute == 1;
			pendingTerminalRoute = 0;
			pendingTerminalRouteExpiresAt = 0f;
			SelectableLevel val = (flag ? GetStarterLevel() : GetCompanyLevel());
			if ((Object)(object)val != (Object)null)
			{
				result = GetRouteTerminalNode(val, flag);
				return false;
			}
			result = GetMissionTerminalNode("Unable to find that route target.\n\n");
			return false;
		}
		if (IsTerminalConfirmCommand(text) && IsCurrentTerminalNodeBlockedRoute(terminal))
		{
			result = GetMissionTerminalNode("That moon route is disabled in this modpack.\n\nAllowed routes:\n- MISSION or EXPERIMENTATION\n- COMPANY\n\nType MISSION to route to the randomized facility mission. Type COMPANY to route to the Company building.\n\n");
			return false;
		}
		if (IsMissionRouteCommand(text))
		{
			SelectableLevel starterLevel = GetStarterLevel();
			if ((Object)(object)starterLevel != (Object)null)
			{
				pendingTerminalRoute = 1;
				pendingTerminalRouteExpiresAt = Time.realtimeSinceStartup + 30f;
				result = GetRoutePromptTerminalNode(missionRoute: true);
				return false;
			}
		}
		if (IsCompanyRouteCommand(text))
		{
			SelectableLevel companyLevel = GetCompanyLevel();
			if ((Object)(object)companyLevel != (Object)null)
			{
				pendingTerminalRoute = 2;
				pendingTerminalRouteExpiresAt = Time.realtimeSinceStartup + 30f;
				result = GetRoutePromptTerminalNode(missionRoute: false);
				return false;
			}
			return true;
		}
		int num;
		switch (text)
		{
		default:
			num = ((text == "missioninfo") ? 1 : 0);
			break;
		case "moons":
		case "moon":
		case "missions":
		case "level":
		case "levels":
		case "profile":
		case "mission profile":
		case "missionprofile":
		case "mission info":
			num = 1;
			break;
		}
		bool flag2 = (byte)num != 0;
		bool flag3 = text == "route" || text.StartsWith("route ") || text == "reroute" || text.StartsWith("reroute ");
		bool flag4 = IsBlockedMoonRouteCommand(text);
		if (flag3 || flag4)
		{
			pendingTerminalRoute = 0;
			pendingTerminalRouteExpiresAt = 0f;
			result = GetMissionTerminalNode("That moon route is disabled in this modpack.\n\nAllowed routes:\n- MISSION or EXPERIMENTATION\n- COMPANY\n\nType MISSION to return to the randomized facility mission. Type COMPANY to route to the Company building.\n\n");
			return false;
		}
		if (!flag2)
		{
			return true;
		}
		if (IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			result = GetMissionTerminalNode("The ship is currently routed to the Company building.\n\nMission randomizer stats do not apply at the Company.\n\nType MISSION to return to the randomized facility mission.\n\n");
			return false;
		}
		result = GetMissionTerminalNode(BuildTerminalMissionText());
		return false;
	}

	private static string NormalizeTerminalCommand(string command)
	{
		if (command == null)
		{
			return string.Empty;
		}
		string text = command.Trim().ToLowerInvariant();
		text = text.Replace("-", " ").Replace("_", " ").Replace(".", " ")
			.Replace(",", " ");
		while (text.Contains("  "))
		{
			text = text.Replace("  ", " ");
		}
		return text.Trim();
	}

	private static string RouteTargetFromCommand(string normalized)
	{
		if (string.IsNullOrWhiteSpace(normalized))
		{
			return string.Empty;
		}
		if (normalized == "route" || normalized == "reroute")
		{
			return string.Empty;
		}
		if (normalized.StartsWith("route "))
		{
			return normalized.Substring(6).Trim();
		}
		if (normalized.StartsWith("reroute "))
		{
			return normalized.Substring(8).Trim();
		}
		return normalized;
	}

	private static bool IsTerminalConfirmCommand(string normalized)
	{
		return normalized == "confirm" || normalized == "con" || normalized == "c";
	}

	private static bool IsTerminalDenyCommand(string normalized)
	{
		int result;
		switch (normalized)
		{
		default:
			result = ((normalized == "back") ? 1 : 0);
			break;
		case "deny":
		case "den":
		case "d":
		case "cancel":
			result = 1;
			break;
		}
		return (byte)result != 0;
	}

	private static bool IsCurrentTerminalNodeBlockedRoute(Terminal terminal)
	{
		if ((Object)(object)terminal == (Object)null)
		{
			return false;
		}
		TerminalNode field = GetField<TerminalNode>(terminal, "currentNode", null);
		if ((Object)(object)field == (Object)null)
		{
			return false;
		}
		int field2 = GetField(field, "buyRerouteToMoon", -1);
		if (field2 < 0)
		{
			return false;
		}
		SelectableLevel selectableLevelById = GetSelectableLevelById(field2);
		if ((Object)(object)selectableLevelById == (Object)null)
		{
			return true;
		}
		return !IsStarterLevel(selectableLevelById) && !IsCompanyLevel(selectableLevelById);
	}

	private static SelectableLevel GetSelectableLevelById(int levelId)
	{
		SelectableLevel[] array = Resources.FindObjectsOfTypeAll<SelectableLevel>();
		foreach (SelectableLevel val in array)
		{
			if (!((Object)(object)val == (Object)null) && GetField(val, "levelID", -999) == levelId)
			{
				return val;
			}
		}
		return null;
	}

	private static bool IsMissionRouteCommand(string normalized)
	{
		string target = RouteTargetFromCommand(normalized);
		return IsAllowedTerminalMoonTarget(target, "mission", "random mission", "facility", "facility mission", "experimentation", "41 experimentation", "experiment", "exp", "41");
	}

	private static bool IsCompanyRouteCommand(string normalized)
	{
		string target = RouteTargetFromCommand(normalized);
		return IsAllowedTerminalMoonTarget(target, "company", "the company", "company building", "gordion", "71 gordion", "com", "comp", "gor", "71");
	}

	private static bool IsAllowedTerminalMoonTarget(string target, params string[] allowedTargets)
	{
		if (string.IsNullOrWhiteSpace(target))
		{
			return false;
		}
		target = NormalizeTerminalCommand(target);
		for (int i = 0; i < allowedTargets.Length; i++)
		{
			string text = NormalizeTerminalCommand(allowedTargets[i]);
			if (target == text)
			{
				return true;
			}
			if (target.Length >= 3 && text.Length >= 3 && text.StartsWith(target, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsBlockedMoonRouteCommand(string normalized)
	{
		string text = RouteTargetFromCommand(normalized);
		if (string.IsNullOrWhiteSpace(text))
		{
			return false;
		}
		text = NormalizeTerminalCommand(text);
		if (IsMissionRouteCommand(normalized) || IsCompanyRouteCommand(normalized))
		{
			return false;
		}
		string[] array = new string[44]
		{
			"assurance", "220 assurance", "assure", "ass", "220", "vow", "56 vow", "56", "offense", "21 offense",
			"off", "21", "march", "61 march", "mar", "61", "adamance", "20 adamance", "ada", "20",
			"rend", "85 rend", "ren", "85", "dine", "7 dine", "din", "7", "titan", "8 titan",
			"tit", "8", "artifice", "68 artifice", "art", "68", "embrion", "5 embrion", "emb", "5",
			"liquidation", "44 liquidation", "liq", "44"
		};
		for (int i = 0; i < array.Length; i++)
		{
			if (TerminalMoonNameMatches(text, array[i]))
			{
				return true;
			}
		}
		SelectableLevel[] array2 = Resources.FindObjectsOfTypeAll<SelectableLevel>();
		SelectableLevel[] array3 = array2;
		foreach (SelectableLevel val in array3)
		{
			if (!((Object)(object)val == (Object)null) && !IsCompanyLevel(val) && !IsStarterLevel(val))
			{
				string moonName = NormalizeTerminalCommand(((Object)val).name ?? string.Empty);
				string text2 = NormalizeTerminalCommand(GetField(val, "PlanetName", string.Empty) ?? string.Empty);
				string moonName2 = NormalizeTerminalCommand(GetField(val, "sceneName", string.Empty) ?? string.Empty);
				string moonName3 = RemoveLeadingNumber(text2);
				string leadingNumber = GetLeadingNumber(text2);
				if (TerminalMoonNameMatches(text, moonName) || TerminalMoonNameMatches(text, text2) || TerminalMoonNameMatches(text, moonName3) || TerminalMoonNameMatches(text, moonName2) || TerminalMoonNameMatches(text, leadingNumber))
				{
					return true;
				}
			}
		}
		return false;
	}

	private static bool TerminalMoonNameMatches(string typedTarget, string moonName)
	{
		if (string.IsNullOrWhiteSpace(typedTarget) || string.IsNullOrWhiteSpace(moonName))
		{
			return false;
		}
		string text = NormalizeTerminalCommand(typedTarget);
		string text2 = NormalizeTerminalCommand(moonName);
		string text3 = RemoveLeadingNumber(text2);
		string leadingNumber = GetLeadingNumber(text2);
		if (text == text2 || text == text3 || text == leadingNumber)
		{
			return true;
		}
		if (text.Length >= 1)
		{
			if (!string.IsNullOrWhiteSpace(text2) && text2.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(text3) && text3.StartsWith(text, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
		}
		return false;
	}

	private static string GetLeadingNumber(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		value = value.Trim();
		int i;
		for (i = 0; i < value.Length && char.IsDigit(value[i]); i++)
		{
		}
		return (i <= 0) ? string.Empty : value.Substring(0, i).Trim();
	}

	private static string RemoveLeadingNumber(string value)
	{
		if (string.IsNullOrWhiteSpace(value))
		{
			return string.Empty;
		}
		value = value.Trim();
		int i;
		for (i = 0; i < value.Length && char.IsDigit(value[i]); i++)
		{
		}
		return value.Substring(i).Trim();
	}

	private static void EnsureRollForCurrentOrbit(StartOfRound start, RoundManager round, TimeOfDay time)
	{
		if (!IsServerOrNoNetwork() || IsCompanyRouteActive(round, time))
		{
			return;
		}
		int @int = GetInt(time, "profitQuota", 130);
		int int2 = GetInt(time, "quotaFulfilled", 0);
		int int3 = GetInt(time, "timesFulfilledQuota", 0);
		int daysUntilDeadline = Mathf.Max(1, GetInt(time, "daysUntilDeadline", 3));
		int int4 = GetInt(time, "hoursUntilDeadline", 0);
		string text = @int + ":" + int2 + ":" + int3 + ":" + daysUntilDeadline + ":" + int4;
		if (!HasRoll || !(text == lastRollKey))
		{
			CurrentRoll = GenerateRoll(@int, int2, int3, daysUntilDeadline, int4);
			HasRoll = true;
			lastRollKey = text;
			ApplyRollToGameObjects(CurrentRoll, "Generated");
			BroadcastRoll(CurrentRoll);
			if (plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)("Generated mission roll: " + CurrentRoll.ToLogString()));
			}
			ResetLandingDebugStateForNewMission();
			WriteOrbitMissionDebugFile("GENERATED_IN_ORBIT", round, time);
		}
	}

	private static int EnsureRuntimeRandomSeedSalt(string reason)
	{
		if (runtimeRandomSeedSalt != 0)
		{
			return runtimeRandomSeedSalt;
		}
		int num = (int)DateTime.UtcNow.Ticks;
		int tickCount = Environment.TickCount;
		int num2 = 0;
		try
		{
			num2 = Random.Range(int.MinValue, int.MaxValue);
		}
		catch
		{
			num2 = 0;
		}
		int num3 = (((Object)(object)plugin != (Object)null) ? plugin.SeedOffset.Value : 7319);
		num3 = (num3 * 397) ^ num;
		num3 = (num3 * 397) ^ tickCount;
		num3 = (num3 * 397) ^ num2;
		num3 = (num3 * 397) ^ Guid.NewGuid().GetHashCode();
		if (num3 == 0)
		{
			num3 = 1;
		}
		runtimeRandomSeedSalt = num3;
		runtimeRandomSeedReason = reason ?? string.Empty;
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission runtime random seed salt initialized (" + runtimeRandomSeedReason + "): " + runtimeRandomSeedSalt + "."));
		}
		return runtimeRandomSeedSalt;
	}

	private static void ApplyMissionRandomSeedToGameObjects(MissionRoll roll, RoundManager round, StartOfRound start, string reason)
	{
		if (!IsServerOrNoNetwork())
		{
			return;
		}
		int num = ((roll.Seed != 0) ? roll.Seed : EnsureRuntimeRandomSeedSalt(reason));
		try
		{
			if ((Object)(object)start != (Object)null)
			{
				SetField(start, "randomMapSeed", num);
				SetField(start, "randomSeed", num);
				SetField(start, "randomSeedNumber", num);
				SetField(start, "overrideSeedNumber", num);
				SetField(start, "overrideRandomSeed", true);
				SetField(start, "hasInitializedRandomSeed", false);
				SetField(start, "hasInitializedLevelRandomSeed", false);
			}
			if ((Object)(object)round != (Object)null)
			{
				SetField(round, "randomMapSeed", num);
				SetField(round, "randomSeed", num);
				SetField(round, "randomSeedNumber", num);
				SetField(round, "overrideSeedNumber", num);
				SetField(round, "overrideRandomSeed", true);
				SetField(round, "hasInitializedRandomSeed", false);
				SetField(round, "hasInitializedLevelRandomSeed", false);
			}
		}
		catch
		{
		}
	}

	internal static void AfterChooseNewRandomMapSeed(StartOfRound start)
	{
		if (!((Object)(object)plugin == (Object)null) && plugin.ModEnabled.Value && IsServerOrNoNetwork() && !IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			int seed = (HasRoll ? CurrentRoll.Seed : EnsureRuntimeRandomSeedSalt("ChooseNewRandomMapSeed"));
			MissionRoll missionRoll2;
			if (!HasRoll)
			{
				MissionRoll missionRoll = default(MissionRoll);
				missionRoll.Seed = seed;
				missionRoll2 = missionRoll;
			}
			else
			{
				missionRoll2 = CurrentRoll;
			}
			MissionRoll roll = missionRoll2;
			ApplyMissionRandomSeedToGameObjects(roll, RoundManager.Instance, start, "ChooseNewRandomMapSeed");
		}
	}

	private static MissionRoll GenerateRoll(int profitQuota, int quotaFulfilled, int timesFulfilledQuota, int daysUntilDeadline, int hoursUntilDeadline)
	{
		int num = Mathf.Max(0, profitQuota - quotaFulfilled);
		int num2 = Mathf.Clamp(daysUntilDeadline, 1, 3);
		int num3 = Mathf.Max(1, timesFulfilledQuota + 1);
		int num4 = EnsureRuntimeRandomSeedSalt("GenerateRoll");
		num4 = num4 * 31 + plugin.SeedOffset.Value;
		num4 = num4 * 31 + profitQuota;
		num4 = num4 * 31 + quotaFulfilled;
		num4 = num4 * 31 + timesFulfilledQuota;
		num4 = num4 * 31 + daysUntilDeadline;
		num4 = num4 * 31 + hoursUntilDeadline;
		num4 = num4 * 31 + DateTime.UtcNow.DayOfYear;
		Random random = new Random(num4);
		float num5 = Mathf.Clamp(num3 - 1, 0, 25);
		float num6 = Mathf.Clamp01((float)num / 2000f);
		float num7 = (float)random.NextDouble();
		float num8 = Mathf.Clamp(num5 * 0.85f + num6 * 4.5f + num7 * 3f, 0f, 20f);
		int num9 = Mathf.CeilToInt((float)num / (float)num2 * Mathf.Max(1f, plugin.QuotaCoverageMultiplier.Value));
		int num10 = 220 + Mathf.RoundToInt(num5 * 60f) + random.Next(0, 180);
		int num11 = Mathf.Clamp(Mathf.Max(num9, num10), plugin.MinimumTotalScrapValue.Value, plugin.MaximumTotalScrapValueCap.Value);
		int configuredMaxMissionScrapCount = GetConfiguredMaxMissionScrapCount();
		int num12 = Mathf.Clamp(plugin.MinimumScrapCount.Value + Mathf.RoundToInt(num5 * 0.55f) + random.Next(0, 5), 1, configuredMaxMissionScrapCount);
		int maxScrap = Mathf.Clamp(num12 + 4 + Mathf.RoundToInt(num5 * 0.35f) + random.Next(0, 8), num12, configuredMaxMissionScrapCount);
		int num13 = Mathf.Clamp(3 + Mathf.RoundToInt(num8 * 0.65f) + random.Next(0, 3), 1, plugin.MaximumInsideEnemyPowerCap.Value);
		int minEnemiesToSpawn = Mathf.Clamp(Mathf.FloorToInt(num8 / 5f), 0, plugin.MaximumMinEnemiesToSpawn.Value);
		int spawnBatchHours = ((num8 >= 11f) ? 1 : 2);
		int maxInsideDiversity = Mathf.Clamp(2 + Mathf.RoundToInt(num8 * 0.5f), 2, 100);
		float factorySizeMultiplier = Mathf.Clamp(0.85f + num5 * 0.055f + (float)random.NextDouble() * 0.35f, 0.75f, plugin.MaximumFactorySizeMultiplier.Value);
		float scrapAmountMultiplier = 1f;
		float scrapValueMultiplier = 1f;
		string rank = RankFromScore(num8, num13, num11);
		int rankIndex = RankIndex(rank);
		MissionRoll result = default(MissionRoll);
		result.Seed = num4;
		result.ProfitQuota = profitQuota;
		result.QuotaFulfilled = quotaFulfilled;
		result.QuotaRemaining = num;
		result.DaysLeft = num2;
		result.QuotaNumber = num3;
		result.Rank = rank;
		result.RankIndex = rankIndex;
		result.DifficultyScore = num8;
		result.MaxTotalScrapValue = num11;
		result.MinScrap = num12;
		result.MaxScrap = maxScrap;
		result.MaxInsideEnemyPower = num13;
		result.MaxOutsideEnemyPower = ((!plugin.DisableOutsideAndDaytimePower.Value) ? Mathf.Clamp(num13 - 2, 0, plugin.MaximumInsideEnemyPowerCap.Value) : 0);
		result.MaxDaytimeEnemyPower = ((!plugin.DisableOutsideAndDaytimePower.Value) ? Mathf.Clamp(num13 - 4, 0, plugin.MaximumInsideEnemyPowerCap.Value) : 0);
		result.MinEnemiesToSpawn = minEnemiesToSpawn;
		result.SpawnBatchHours = spawnBatchHours;
		result.MaxInsideDiversity = maxInsideDiversity;
		result.FactorySizeMultiplier = factorySizeMultiplier;
		result.ScrapAmountMultiplier = scrapAmountMultiplier;
		result.ScrapValueMultiplier = scrapValueMultiplier;
		return result;
	}

	private static string RankFromScore(float score, int enemyPower, int maxValue)
	{
		float num = score + (float)enemyPower * 0.25f + Mathf.Clamp((float)maxValue / 1000f, 0f, 1.5f);
		if (num < 3f)
		{
			return "D";
		}
		if (num < 5f)
		{
			return "C";
		}
		if (num < 7f)
		{
			return "B";
		}
		if (num < 9f)
		{
			return "A";
		}
		if (num < 11f)
		{
			return "S";
		}
		if (num < 13f)
		{
			return "S+";
		}
		if (num < 15f)
		{
			return "S++";
		}
		return "S+++";
	}

	private static int RankIndex(string rank)
	{
		return rank switch
		{
			"D" => 0, 
			"C" => 1, 
			"B" => 2, 
			"A" => 3, 
			"S" => 4, 
			"S+" => 5, 
			"S++" => 6, 
			_ => 7, 
		};
	}

	private static string RankFromIndex(int index)
	{
		return index switch
		{
			0 => "D", 
			1 => "C", 
			2 => "B", 
			3 => "A", 
			4 => "S", 
			5 => "S+", 
			6 => "S++", 
			_ => "S+++", 
		};
	}

	private static void ApplyRollToGameObjects(MissionRoll roll, string reason)
	{
		try
		{
			RoundManager instance = RoundManager.Instance;
			TimeOfDay instance2 = TimeOfDay.Instance;
			if (!IsCompanyRouteActive(instance, instance2))
			{
				if (plugin.ForceStarterMoon.Value)
				{
					ForceStarterLevel(instance, instance2);
				}
				SelectableLevel activeLevel = GetActiveLevel(instance, instance2);
				if ((Object)(object)activeLevel != (Object)null)
				{
					ApplyRollToLevel(activeLevel, roll);
				}
				if ((Object)(object)instance != (Object)null)
				{
					ApplyRollToRoundManager(instance, roll);
				}
				ApplyMissionRandomSeedToGameObjects(roll, instance, StartOfRound.Instance, reason);
				if ((Object)(object)instance2 != (Object)null)
				{
					SetField(instance2, "currentLevel", activeLevel);
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("ApplyRollToGameObjects failed during " + reason + ": " + ex.Message));
		}
	}

	private static void ApplyRollToLevel(SelectableLevel level, MissionRoll roll)
	{
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: 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_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_019a: 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_01aa: Expected O, but got Unknown
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Expected O, but got Unknown
		SetField(level, "PlanetName", "Mission Zone");
		SetField(level, "riskLevel", roll.Rank);
		SetField(level, "factorySizeMultiplier", roll.FactorySizeMultiplier);
		SetField(level, "minScrap", roll.MinScrap);
		SetField(level, "maxScrap", roll.MaxScrap);
		SetField(level, "minTotalScrapValue", GetMinimumTotalScrapValueForRoll(roll));
		SetField(level, "maxTotalScrapValue", roll.MaxTotalScrapValue);
		SetField(level, "maxEnemyPowerCount", roll.MaxInsideEnemyPower);
		SetField(level, "maxOutsideEnemyPowerCount", roll.MaxOutsideEnemyPower);
		SetField(level, "maxDaytimeEnemyPowerCount", roll.MaxDaytimeEnemyPower);
		SetField(level, "spawnEnemiesAndScrap", true);
		SetField(level, "currentWeather", "None");
		SetField(level, "overrideWeather", false);
		try
		{
			AnimationCurve value = new AnimationCurve((Keyframe[])(object)new Keyframe[4]
			{
				new Keyframe(0f, 0.1f + roll.DifficultyScore * 0.01f),
				new Keyframe(0.35f, 0.35f + roll.DifficultyScore * 0.025f),
				new Keyframe(0.7f, 0.75f + roll.DifficultyScore * 0.035f),
				new Keyframe(1f, 1f + roll.DifficultyScore * 0.045f)
			});
			SetField(level, "enemySpawnChanceThroughoutDay", value);
			if (plugin.DisableOutsideAndDaytimePower.Value)
			{
				AnimationCurve value2 = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0f, 0f),
					new Keyframe(1f, 0f)
				});
				SetField(level, "outsideEnemySpawnChanceThroughDay", value2);
				SetField(level, "daytimeEnemySpawnChanceThroughDay", value2);
			}
		}
		catch
		{
		}
	}

	private static void ApplyRollToRoundManager(RoundManager round, MissionRoll roll)
	{
		SetField(round, "scrapValueMultiplier", roll.ScrapValueMultiplier);
		SetField(round, "scrapAmountMultiplier", roll.ScrapAmountMultiplier);
		SetField(round, "mapSizeMultiplier", roll.FactorySizeMultiplier);
		SetField(round, "currentMaxInsidePower", (float)roll.MaxInsideEnemyPower);
		SetField(round, "currentMaxOutsidePower", (float)roll.MaxOutsideEnemyPower);
		SetField(round, "currentMaxInsideDiversityLevel", roll.MaxInsideDiversity);
		SetField(round, "currentMaxOutsideDiversityLevel", (!plugin.DisableOutsideAndDaytimePower.Value) ? roll.MaxInsideDiversity : 0);
		SetField(round, "minEnemiesToSpawn", roll.MinEnemiesToSpawn);
		SetField(round, "minOutsideEnemiesToSpawn", 0);
		SetField(round, "hourTimeBetweenEnemySpawnBatches", roll.SpawnBatchHours);
	}

	private static void ForceStarterLevel(RoundManager round, TimeOfDay time)
	{
		SelectableLevel starterLevel = GetStarterLevel();
		if (!((Object)(object)starterLevel == (Object)null))
		{
			if ((Object)(object)round != (Object)null)
			{
				SetField(round, "currentLevel", starterLevel);
			}
			if ((Object)(object)time != (Object)null)
			{
				SetField(time, "currentLevel", starterLevel);
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				SetField(instance, "currentLevel", starterLevel);
			}
		}
	}

	private static void ForceSpecificLevel(SelectableLevel level, RoundManager round, TimeOfDay time)
	{
		if (!((Object)(object)level == (Object)null))
		{
			if ((Object)(object)round != (Object)null)
			{
				SetField(round, "currentLevel", level);
			}
			if ((Object)(object)time != (Object)null)
			{
				SetField(time, "currentLevel", level);
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				SetField(instance, "currentLevel", level);
			}
		}
	}

	private static bool IsCompanyRouteActive(RoundManager round, TimeOfDay time)
	{
		SelectableLevel field = GetField<SelectableLevel>(round, "currentLevel", null);
		if (IsCompanyLevel(field))
		{
			return true;
		}
		SelectableLevel field2 = GetField<SelectableLevel>(time, "currentLevel", null);
		if (IsCompanyLevel(field2))
		{
			return true;
		}
		StartOfRound instance = StartOfRound.Instance;
		SelectableLevel field3 = GetField<SelectableLevel>(instance, "currentLevel", null);
		if (IsCompanyLevel(field3))
		{
			return true;
		}
		return false;
	}

	private static bool IsCompanyLevel(SelectableLevel level)
	{
		if ((Object)(object)level == (Object)null)
		{
			return false;
		}
		string text = ((Object)level).name ?? string.Empty;
		string text2 = GetField(level, "PlanetName", string.Empty) ?? string.Empty;
		string text3 = GetField(level, "sceneName", string.Empty) ?? string.Empty;
		return text.IndexOf("Company", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Gordion", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("Company", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("Gordion", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("Company", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("Gordion", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static bool IsStarterLevel(SelectableLevel level)
	{
		if ((Object)(object)level == (Object)null)
		{
			return false;
		}
		string text = ((Object)level).name ?? string.Empty;
		string text2 = GetField(level, "PlanetName", string.Empty) ?? string.Empty;
		string text3 = GetField(level, "sceneName", string.Empty) ?? string.Empty;
		return GetField(level, "levelID", -999) == 0 || text.IndexOf("Experimentation", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("Experimentation", StringComparison.OrdinalIgnoreCase) >= 0 || text3.IndexOf("Experimentation", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static SelectableLevel GetCompanyLevel()
	{
		try
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			if ((Object)(object)val != (Object)null)
			{
				SelectableLevel[] field = GetField<SelectableLevel[]>(val, "moonsCatalogueList", null);
				if (field != null)
				{
					for (int i = 0; i < field.Length; i++)
					{
						if (IsCompanyLevel(field[i]))
						{
							return field[i];
						}
					}
				}
			}
			SelectableLevel[] array = Resources.FindObjectsOfTypeAll<SelectableLevel>();
			SelectableLevel[] array2 = array;
			foreach (SelectableLevel val2 in array2)
			{
				if (IsCompanyLevel(val2))
				{
					return val2;
				}
			}
		}
		catch
		{
		}
		return null;
	}

	private static SelectableLevel GetActiveLevel(RoundManager round, TimeOfDay time)
	{
		SelectableLevel field = GetField<SelectableLevel>(round, "currentLevel", null);
		if (IsCompanyLevel(field))
		{
			return field;
		}
		SelectableLevel field2 = GetField<SelectableLevel>(time, "currentLevel", null);
		if (IsCompanyLevel(field2))
		{
			return field2;
		}
		SelectableLevel val = (plugin.ForceStarterMoon.Value ? GetStarterLevel() : null);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		field = GetField<SelectableLevel>(round, "currentLevel", null);
		if ((Object)(object)field != (Object)null)
		{
			return field;
		}
		field2 = GetField<SelectableLevel>(time, "currentLevel", null);
		if ((Object)(object)field2 != (Object)null)
		{
			return field2;
		}
		return GetStarterLevel();
	}

	private static SelectableLevel GetStarterLevel()
	{
		try
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			if ((Object)(object)val != (Object)null)
			{
				SelectableLevel[] field = GetField<SelectableLevel[]>(val, "moonsCatalogueList", null);
				if (field != null && field.Length != 0 && (Object)(object)field[0] != (Object)null)
				{
					return field[0];
				}
			}
			SelectableLevel[] array = Resources.FindObjectsOfTypeAll<SelectableLevel>();
			SelectableLevel result = null;
			int num = int.MaxValue;
			SelectableLevel[] array2 = array;
			foreach (SelectableLevel val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					string text = ((Object)val2).name ?? string.Empty;
					string text2 = GetField(val2, "PlanetName", string.Empty) ?? string.Empty;
					int field2 = GetField(val2, "levelID", 9999);
					if (text.IndexOf("Experimentation", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("Experimentation", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return val2;
					}
					if (field2 < num && text2.IndexOf("Gordion", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("Company", StringComparison.OrdinalIgnoreCase) < 0)
					{
						num = field2;
						result = val2;
					}
				}
			}
			return result;
		}
		catch
		{
			return null;
		}
	}

	private static void RestrictTerminalCatalogueToStarter()
	{
		Terminal val = Object.FindObjectOfType<Terminal>();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		SelectableLevel starterLevel = GetStarterLevel();
		if ((Object)(object)starterLevel == (Object)null)
		{
			return;
		}
		SelectableLevel companyLevel = GetCompanyLevel();
		SelectableLevel[] array = (SelectableLevel[])(object)((!((Object)(object)companyLevel != (Object)null) || !((Object)(object)companyLevel != (Object)(object)starterLevel)) ? new SelectableLevel[1] { starterLevel } : new SelectableLevel[2] { starterLevel, companyLevel });
		SelectableLevel[] field = GetField<SelectableLevel[]>(val, "moonsCatalogueList", null);
		bool flag = field == null || field.Length != array.Length;
		if (!flag && field != null)
		{
			for (int i = 0; i < array.Length; i++)
			{
				if ((Object)(object)field[i] != (Object)(object)array[i])
				{
					flag = true;
					break;
				}
			}
		}
		if (flag)
		{
			SetField(val, "moonsCatalogueList", array);
		}
	}

	private static void RequestScrapValuesFromHostIfNeeded(bool shipHasLanded, bool shipIsLeaving)
	{
		//IL_00e2: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null || !singleton.IsClient || singleton.IsServer || !HasRoll || !shipHasLanded || shipIsLeaving)
			{
				return;
			}
			int seed = CurrentRoll.Seed;
			if (clientScrapValueSyncReceivedSeed == seed)
			{
				return;
			}
			if (clientScrapValueRequestSeed != seed)
			{
				clientScrapValueRequestSeed = seed;
				clientScrapValueRequestAttempts = 0;
				nextClientScrapValueRequestTime = 0f;
			}
			if (clientScrapValueRequestAttempts < 5 && !(Time.realtimeSinceStartup < nextClientScrapValueRequestTime))
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref seed, default(ForPrimitives));
					singleton.CustomMessagingManager.SendNamedMessage("yellowcube.mission_randomizer.scrap_values_request.v1", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
				clientScrapValueRequestAttempts++;
				float num = ((clientScrapValueRequestAttempts <= 1) ? 1.25f : Mathf.Min(8f, 1.5f + (float)clientScrapValueRequestAttempts * 1.5f));
				nextClientScrapValueRequestTime = Time.realtimeSinceStartup + num;
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("Scrap value sync request failed: " + ex.Message));
			}
		}
	}

	[IteratorStateMachine(typeof(<DelayedSendScrapValuesToClient>d__159))]
	private static IEnumerator DelayedSendScrapValuesToClient(ulong clientId, float delaySeconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedSendScrapValuesToClient>d__159(0)
		{
			clientId = clientId,
			delaySeconds = delaySeconds
		};
	}

	private static bool ShouldLogScrapSync(string reason)
	{
		if (string.IsNullOrEmpty(reason))
		{
			return true;
		}
		if (reason.IndexOf("request", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (reason.IndexOf("late join", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (reason.IndexOf("immediate", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (reason.IndexOf("safety", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		return false;
	}

	private static void BroadcastScrapValueSync(List<ScrapComponentRecord> records, int finalTotal, string reason)
	{
		//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_0059: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.CustomMessagingManager != null && singleton.IsServer && records != null && records.Count != 0)
			{
				FastBufferWriter val = CreateScrapValueWriter(records, finalTotal);
				try
				{
					singleton.CustomMessagingManager.SendNamedMessageToAll("yellowcube.mission_randomizer.scrap_values.v1", val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
				if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value && ShouldLogScrapSync(reason))
				{
					Plugin.Log.LogInfo((object)("Broadcast scrap value sync (" + reason + "): " + records.Count + " items / $" + finalTotal + "."));
				}
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("BroadcastScrapValueSync failed: " + ex.Message));
			}
		}
	}

	private static void SendScrapValueSyncToClient(List<ScrapComponentRecord> records, int finalTotal, ulong clientId, string reason)
	{
		//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)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.CustomMessagingManager != null && singleton.IsServer && records != null && records.Count != 0)
			{
				FastBufferWriter val = CreateScrapValueWriter(records, finalTotal);
				try
				{
					singleton.CustomMessagingManager.SendNamedMessage("yellowcube.mission_randomizer.scrap_values.v1", clientId, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
				if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Sent scrap value sync to client " + clientId + " (" + reason + "): " + records.Count + " items / $" + finalTotal + "."));
				}
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("SendScrapValueSyncToClient failed: " + ex.Message));
			}
		}
	}

	private static FastBufferWriter CreateScrapValueWriter(List<ScrapComponentRecord> records, int finalTotal)
	{
		//IL_0068: 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_007c: 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_0090: 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_014b: 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_0150: 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_0115: 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_0129: Unknown result type (might be due to invalid IL or missing references)
		int num = 0;
		for (int i = 0; i < records.Count; i++)
		{
			NetworkObject networkObjectForScrap = GetNetworkObjectForScrap(records[i].Component);
			if ((Object)(object)networkObjectForScrap != (Object)null && networkObjectForScrap.IsSpawned)
			{
				num++;
			}
		}
		FastBufferWriter result = default(FastBufferWriter);
		((FastBufferWriter)(ref result))..ctor(32 + num * 16, (Allocator)2, -1);
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref CurrentRoll.Seed, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref finalTotal, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref num, default(ForPrimitives));
		for (int j = 0; j < records.Count; j++)
		{
			NetworkObject networkObjectForScrap2 = GetNetworkObjectForScrap(records[j].Component);
			if (!((Object)(object)networkObjectForScrap2 == (Object)null) && networkObjectForScrap2.IsSpawned)
			{
				ulong networkObjectId = networkObjectForScrap2.NetworkObjectId;
				int @int = GetInt(records[j].Component, "scrapValue", records[j].Value);
				((FastBufferWriter)(ref result)).WriteValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref @int, default(ForPrimitives));
			}
		}
		return result;
	}

	private static void OnReceiveScrapValuesRequestMessage(ulong senderClientId, FastBufferReader reader)
	{
		//IL_0031: 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)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsServer)
			{
				return;
			}
			int num = 0;
			try
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			}
			catch
			{
			}
			if (!HasRoll || (num != 0 && num != CurrentRoll.Seed))
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!nextServerScrapValueResponseByClient.TryGetValue(senderClientId, out var value) || !(realtimeSinceStartup < value))
			{
				nextServerScrapValueResponseByClient[senderClientId] = realtimeSinceStartup + 1.5f;
				List<ScrapComponentRecord> list = CollectMissionScrapRecords(includeHeld: false);
				int finalTotal = SumScrapRecordValues(list);
				if (list.Count > 0)
				{
					SendScrapValueSyncToClient(list, finalTotal, senderClientId, "client requested scrap values");
				}
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("OnReceiveScrapValuesRequestMessage failed: " + ex.Message));
			}
		}
	}

	private static void OnReceiveScrapValuesMessage(ulong senderClientId, FastBufferReader reader)
	{
		//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_003f: 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_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: 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_0133: 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)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton != (Object)null && singleton.IsServer)
			{
				return;
			}
			int num = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
			int num2 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
			int num3 = default(int);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num3, default(ForPrimitives));
			if (HasRoll && num != CurrentRoll.Seed)
			{
				if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
				{
					Plugin.Log.LogWarning((object)("Ignored scrap value sync for wrong seed. Received " + num + ", current " + CurrentRoll.Seed + "."));
				}
				return;
			}
			pendingScrapValues.Clear();
			pendingScrapValueTotal = num2;
			clientScrapValueSyncReceivedSeed = num;
			clientScrapValueRequestAttempts = 0;
			ulong networkObjectId = default(ulong);
			int value = default(int);
			for (int i = 0; i < num3; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref networkObjectId, default(ForPrimitives));
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref value, default(ForPrimitives));
				pendingScrapValues.Add(new PendingScrapValue
				{
					NetworkObjectId = networkObjectId,
					Value = value
				});
			}
			ApplyPendingScrapValues("received scrap value sync");
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogInfo((object)("Received scrap value sync from host: " + num3 + " items / $" + num2 + ". Pending after first apply: " + pendingScrapValues.Count + "."));
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("OnReceiveScrapValuesMessage failed: " + ex.Message));
			}
		}
	}

	private static void ApplyPendingScrapValues(string reason)
	{
		if (pendingScrapValues.Count == 0 || Time.realtimeSinceStartup < nextPendingScrapApplyTime)
		{
			return;
		}
		nextPendingScrapApplyTime = Time.realtimeSinceStartup + 0.05f;
		int num = 0;
		for (int num2 = pendingScrapValues.Count - 1; num2 >= 0; num2--)
		{
			PendingScrapValue pendingScrapValue = pendingScrapValues[num2];
			if (TryApplyScrapValueToNetworkObject(pendingScrapValue.NetworkObjectId, pendingScrapValue.Value))
			{
				pendingScrapValues.RemoveAt(num2);
				num++;
			}
		}
		RoundManager instance = RoundManager.Instance;
		if ((Object)(object)instance != (Object)null && pendingScrapValueTotal > 0)
		{
			SetField(instance, "totalScrapValueInLevel", (float)pendingScrapValueTotal);
		}
		if (num > 0 && (Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Applied " + num + " synced scrap values on client (" + reason + "). Remaining pending: " + pendingScrapValues.Count + "."));
		}
	}

	private static bool TryApplyScrapValueToNetworkObject(ulong networkObjectId, int value)
	{
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.SpawnManager == null)
			{
				return false;
			}
			if (!singleton.SpawnManager.SpawnedObjects.TryGetValue(networkObjectId, out var value2))
			{
				return false;
			}
			if ((Object)(object)value2 == (Object)null || (Object)(object)((Component)value2).gameObject == (Object)null)
			{
				return false;
			}
			Component val = FindScrapComponentUnderNetworkObject(value2);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			SetScrapValue(val, value);
			return true;
		}
		catch
		{
			return false;
		}
	}

	private static Component FindScrapComponentUnderNetworkObject(NetworkObject networkObject)
	{
		if ((Object)(object)networkObject == (Object)null || (Object)(object)((Component)networkObject).gameObject == (Object)null)
		{
			return null;
		}
		Component[] componentsInChildren = ((Component)networkObject).gameObject.GetComponentsInChildren<Component>(true);
		foreach (Component val in componentsInChildren)
		{
			if ((Object)(object)val == (Object)null || (Object)(object)val.gameObject == (Object)null || !IsScrapGrabbable(val))
			{
				continue;
			}
			object field = GetField<object>(val, "itemProperties", null);
			if (field != null && GetBool(field, "isScrap", fallback: false))
			{
				string itemDisplayName = GetItemDisplayName(val, field);
				if (!IsApparatusItem(val, val.gameObject, itemDisplayName))
				{
					return val;
				}
			}
		}
		return null;
	}

	private static NetworkObject GetNetworkObjectForScrap(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		NetworkObject val = null;
		try
		{
			val = component.GetComponent<NetworkObject>();
		}
		catch
		{
		}
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		try
		{
			val = component.GetComponentInParent<NetworkObject>();
		}
		catch
		{
		}
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		try
		{
			val = component.GetComponentInChildren<NetworkObject>(true);
		}
		catch
		{
		}
		return val;
	}

	private static void TryRegisterNetworking()
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Expected O, but got Unknown
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Expected O, but got Unknown
		NetworkManager singleton = NetworkManager.Singleton;
		if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null)
		{
			return;
		}
		if (networkRegistered)
		{
			if (registeredNetworkManager == singleton)
			{
				return;
			}
			ResetNetworkRegistration("NetworkManager instance changed");
		}
		singleton.CustomMessagingManager.RegisterNamedMessageHandler("yellowcube.mission_randomizer.roll.v1", new HandleNamedMessageDelegate(OnReceiveRollMessage));
		singleton.CustomMessagingManager.RegisterNamedMessageHandler("yellowcube.mission_randomizer.roll_request.v1", new HandleNamedMessageDelegate(OnReceiveRollRequestMessage));
		singleton.CustomMessagingManager.RegisterNamedMessageHandler("yellowcube.mission_randomizer.scrap_values.v1", new HandleNamedMessageDelegate(OnReceiveScrapValuesMessage));
		singleton.CustomMessagingManager.RegisterNamedMessageHandler("yellowcube.mission_randomizer.scrap_values_request.v1", new HandleNamedMessageDelegate(OnReceiveScrapValuesRequestMessage));
		singleton.OnClientConnectedCallback += OnClientConnected;
		singleton.OnClientDisconnectCallback += OnClientDisconnected;
		registeredNetworkManager = singleton;
		networkRegistered = true;
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)"Registered mission randomizer network handlers.");
		}
	}

	private static void ResetNetworkRegistration(string reason)
	{
		try
		{
			if ((Object)(object)registeredNetworkManager != (Object)null)
			{
				if (registeredNetworkManager.CustomMessagingManager != null)
				{
					try
					{
						registeredNetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler("yellowcube.mission_randomizer.roll.v1");
					}
					catch
					{
					}
					try
					{
						registeredNetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler("yellowcube.mission_randomizer.roll_request.v1");
					}
					catch
					{
					}
					try
					{
						registeredNetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler("yellowcube.mission_randomizer.scrap_values.v1");
					}
					catch
					{
					}
					try
					{
						registeredNetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler("yellowcube.mission_randomizer.scrap_values_request.v1");
					}
					catch
					{
					}
				}
				try
				{
					registeredNetworkManager.OnClientConnectedCallback -= OnClientConnected;
				}
				catch
				{
				}
				try
				{
					registeredNetworkManager.OnClientDisconnectCallback -= OnClientDisconnected;
				}
				catch
				{
				}
			}
		}
		catch
		{
		}
		registeredNetworkManager = null;
		networkRegistered = false;
		if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
		{
			Plugin.Log.LogInfo((object)("Mission randomizer network handlers reset: " + reason));
		}
	}

	private static void OnClientConnected(ulong clientId)
	{
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.IsServer && (Object)(object)plugin != (Object)null)
			{
				((MonoBehaviour)plugin).StartCoroutine(DelayedSendRollToClient(clientId, 0.5f));
				((MonoBehaviour)plugin).StartCoroutine(DelayedSendRollToClient(clientId, 2f));
				((MonoBehaviour)plugin).StartCoroutine(DelayedSendScrapValuesToClient(clientId, 2.5f));
				((MonoBehaviour)plugin).StartCoroutine(DelayedSendScrapValuesToClient(clientId, 5f));
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("OnClientConnected mission sync failed: " + ex.Message));
			}
		}
	}

	private static void OnClientDisconnected(ulong clientId)
	{
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && !singleton.IsServer && clientId == singleton.LocalClientId)
			{
				ResetMissionRuntimeState("Local client disconnected", keepTrackedInstances: false);
				ResetNetworkRegistration("Local client disconnected");
			}
		}
		catch
		{
		}
	}

	[IteratorStateMachine(typeof(<DelayedSendRollToClient>d__174))]
	private static IEnumerator DelayedSendRollToClient(ulong clientId, float delaySeconds)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <DelayedSendRollToClient>d__174(0)
		{
			clientId = clientId,
			delaySeconds = delaySeconds
		};
	}

	private static void BroadcastRoll(MissionRoll roll)
	{
		//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_003d: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || singleton.CustomMessagingManager == null || !singleton.IsServer)
			{
				return;
			}
			FastBufferWriter val = CreateRollWriter(roll);
			try
			{
				singleton.CustomMessagingManager.SendNamedMessageToAll("yellowcube.mission_randomizer.roll.v1", val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(FastBufferWriter)(ref val)).Dispose();
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("BroadcastRoll failed: " + ex.Message));
		}
	}

	private static void SendRollToClient(MissionRoll roll, ulong clientId)
	{
		//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_0041: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if (!((Object)(object)singleton == (Object)null) && singleton.CustomMessagingManager != null && singleton.IsServer)
			{
				FastBufferWriter val = CreateRollWriter(roll);
				try
				{
					singleton.CustomMessagingManager.SendNamedMessage("yellowcube.mission_randomizer.roll.v1", clientId, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val)).Dispose();
				}
				if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Sent mission roll to client " + clientId + ": " + roll.ToLogString()));
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("SendRollToClient failed: " + ex.Message));
		}
	}

	private static FastBufferWriter CreateRollWriter(MissionRoll roll)
	{
		//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_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0062: 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_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_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: 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_00c2: 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_00da: 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_00f2: 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_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: 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_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: 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_016a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: 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_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		FastBufferWriter result = default(FastBufferWriter);
		((FastBufferWriter)(ref result))..ctor(128, (Allocator)2, -1);
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.Seed, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.ProfitQuota, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.QuotaFulfilled, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.QuotaRemaining, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.DaysLeft, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.QuotaNumber, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.RankIndex, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<float>(ref roll.DifficultyScore, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxTotalScrapValue, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MinScrap, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxScrap, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxInsideEnemyPower, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxOutsideEnemyPower, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxDaytimeEnemyPower, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MinEnemiesToSpawn, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.SpawnBatchHours, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<int>(ref roll.MaxInsideDiversity, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<float>(ref roll.FactorySizeMultiplier, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<float>(ref roll.ScrapAmountMultiplier, default(ForPrimitives));
		((FastBufferWriter)(ref result)).WriteValueSafe<float>(ref roll.ScrapValueMultiplier, default(ForPrimitives));
		return result;
	}

	private static void OnReceiveRollRequestMessage(ulong senderClientId, FastBufferReader reader)
	{
		try
		{
			NetworkManager singleton = NetworkManager.Singleton;
			if ((Object)(object)singleton == (Object)null || !singleton.IsServer || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
			{
				return;
			}
			if (!HasRoll)
			{
				StartOfRound instance = StartOfRound.Instance;
				RoundManager instance2 = RoundManager.Instance;
				TimeOfDay instance3 = TimeOfDay.Instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance2 != (Object)null && (Object)(object)instance3 != (Object)null)
				{
					EnsureRollForCurrentOrbit(instance, instance2, instance3);
				}
			}
			if (HasRoll)
			{
				SendRollToClient(CurrentRoll, senderClientId);
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("OnReceiveRollRequestMessage failed: " + ex.Message));
			}
		}
	}

	private static void OnReceiveRollMessage(ulong senderClientId, FastBufferReader reader)
	{
		//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)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: 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_0080: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_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)
		//IL_00c8: 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_00e0: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0110: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0128: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: 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_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: 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_0200: 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)
		try
		{
			if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.Singleton.IsServer)
			{
				return;
			}
			MissionRoll currentRoll = default(MissionRoll);
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.Seed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.ProfitQuota, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.QuotaFulfilled, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.QuotaRemaining, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.DaysLeft, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.QuotaNumber, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.RankIndex, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref currentRoll.DifficultyScore, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxTotalScrapValue, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MinScrap, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxScrap, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxInsideEnemyPower, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxOutsideEnemyPower, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxDaytimeEnemyPower, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MinEnemiesToSpawn, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.SpawnBatchHours, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref currentRoll.MaxInsideDiversity, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref currentRoll.FactorySizeMultiplier, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref currentRoll.ScrapAmountMultiplier, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref currentRoll.ScrapValueMultiplier, default(ForPrimitives));
			currentRoll.Rank = RankFromIndex(currentRoll.RankIndex);
			if (!IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
			{
				CurrentRoll = currentRoll;
				HasRoll = true;
				ApplyRollToGameObjects(CurrentRoll, "ReceivedNetworkRoll");
				UpdateMonitorText();
				if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
				{
					Plugin.Log.LogInfo((object)("Received mission roll from host: " + CurrentRoll.ToLogString()));
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("OnReceiveRollMessage failed: " + ex.Message));
		}
	}

	private static bool IsServerOrNoNetwork()
	{
		NetworkManager singleton = NetworkManager.Singleton;
		if ((Object)(object)singleton == (Object)null)
		{
			return true;
		}
		return singleton.IsServer || singleton.IsHost;
	}

	private static void UpdateMonitorText()
	{
		if (!HasRoll || IsCompanyRouteActive(RoundManager.Instance, TimeOfDay.Instance))
		{
			return;
		}
		string value = BuildLevelMonitorMissionText();
		bool flag = false;
		try
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				object field = GetField<object>(instance, "screenLevelDescription", null);
				if (field != null)
				{
					SetTextObjectText(field, value);
					flag = true;
				}
			}
			if (!flag)
			{
				Object[] array = Resources.FindObjectsOfTypeAll<Object>();
				Object[] array2 = array;
				foreach (Object val in array2)
				{
					if (val == (Object)null)
					{
						continue;
					}
					Type type = ((object)val).GetType();
					string text = type.FullName ?? type.Name;
					if (text.IndexOf("TextMeshProUGUI", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("TMP_Text", StringComparison.OrdinalIgnoreCase) < 0)
					{
						continue;
					}
					Component val2 = (Component)(object)((val is Component) ? val : null);
					if ((Object)(object)val2 == (Object)null || (Object)(object)val2.gameObject == (Object)null)
					{
						continue;
					}
					string path = GetPath(val2.transform);
					if (!IsNeverMissionMonitorPath(path))
					{
						string text2 = GetTextObjectText(val) ?? string.Empty;
						if (LooksLikeVanillaMoonMissionMonitor(text2, path))
						{
							SetTextObjectText(val, value);
							flag = true;
						}
					}
				}
			}
			if (!flag && (Object)(object)plugin != (Object)null && plugin.DebugLogging.Value && Time.realtimeSinceStartup >= nextMissingMonitorLogTime)
			{
				nextMissingMonitorLogTime = Time.realtimeSinceStartup + 10f;
				Plugin.Log.LogWarning((object)"Could not find the lower moon mission monitor text. The quota monitor was intentionally not edited.");
			}
		}
		catch (Exception ex)
		{
			if ((Object)(object)plugin != (Object)null && plugin.DebugLogging.Value)
			{
				Plugin.Log.LogWarning((object)("UpdateMonitorText failed: " + ex.Message));
			}
		}
	}

	private static bool IsNeverMissionMonitorPath(string path)
	{
		if (string.IsNullOrEmpty(path))
		{
			return false;
		}
		if (path.IndexOf("Terminal", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (path.IndexOf("Systems/UI", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (path.IndexOf("MonitorWall/Cube/Canvas (1)", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (path.IndexOf("ProfitQuota", StringComparison.OrdinalIgnoreCase) >= 0 || path.IndexOf("QuotaRemainder", StringComparison.OrdinalIgnoreCase) >= 0 || path.IndexOf("QuotaTotal", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		if (path.IndexOf("ElevatorPanelScreen", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		return false;
	}

	private static bool LooksLikeVanillaMoonMissionMonitor(string text, string path)
	{
		if (!string.IsNullOrEmpty(path))
		{
			if (path.IndexOf("screenLevelDescription", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (path.IndexOf("LevelDescription", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
		}
		if (string.IsNullOrWhiteSpace(text))
		{
			return false;
		}
		string text2 = text.ToLowerInvariant();
		if (text2.Contains("orbiting:") || text2.Contains("population:") || text2.Contains("conditions:") || text2.Contains("fauna:"))
		{
			return true;
		}
		return false;
	}

	private static string BuildLevelMonitorMissionText()
	{
		MissionRoll currentRoll = CurrentRoll;
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendLine("MISSION PROFILE");
		stringBuilder.AppendLine("RANK: " + currentRoll.Rank + "   QUOTA: " + currentRoll.QuotaFulfilled + "/" + currentRoll.ProfitQuota);
		stringBuilder.AppendLine("DAYS LEFT: " + currentRoll.DaysLeft);
		stringBuilder.AppendLine("VALUE RANGE: " + TotalScrapValueRangeText(currentRoll));
		stringBuilder.AppendLine("SCRAP: " + currentRoll.MinScrap + " - " + currentRoll.MaxScrap);
		stringBuilder.AppendLine("INSIDE POWER: " + currentRoll.MaxInsideEnemyPower);
		stringBuilder.AppendLine("PRESSURE: " + PressureText(currentRoll));
		stringBuilder.AppendLine("SURFACE: STARTER SHELL");
		return stringBuilder.ToString();
	}

	private static string BuildMonitorMissionText()
	{
		MissionRoll currentRoll = CurrentRoll;
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendLine("RANK: " + currentRoll.Rank);
		stringBuilder.AppendLine("QUOTA: " + currentRoll.QuotaFulfilled + " / " + currentRoll.ProfitQuota);
		stringBuilder.AppendLine("DAYS LEFT: " + currentRoll.DaysLeft);
		stringBuilder.AppendLine("VALUE RANGE: " + TotalScrapValueRangeText(currentRoll));
		stringBuilder.AppendLine("SCRAP: " + currentRoll.MinScrap + " - " + currentRoll.MaxScrap);
		stringBuilder.AppendLine("INSIDE POWER: " + currentRoll.MaxInsideEnemyPower);
		stringBuilder.AppendLine("SPAWN PRESSURE: " + PressureText(currentRoll));
		return stringBuilder.ToString();
	}

	private static string BuildTerminalMissionText()
	{
		if (!HasRoll)
		{
			return "No mission profile has been generated yet. Wait until the ship is in orbit.\n\n";
		}
		MissionRoll currentRoll = CurrentRoll;
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.AppendLine("CURRENT RANDOMIZED MISSION");
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("Difficulty rank: " + currentRoll.Rank);
		stringBuilder.AppendLine("Quota cycle: " + currentRoll.QuotaNumber);
		stringBuilder.AppendLine("Quota progress: " + currentRoll.QuotaFulfilled + " / " + currentRoll.ProfitQuota);
		stringBuilder.AppendLine("Quota remaining: " + currentRoll.QuotaRemaining);
		stringBuilder.AppendLine("Days left: " + currentRoll.DaysLeft);
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("Scrap value range: " + TotalScrapValueRangeText(currentRoll));
		stringBuilder.AppendLine("Scrap amount: " + currentRoll.MinScrap + " - " + currentRoll.MaxScrap);
		stringBuilder.AppendLine("Interior enemy power: " + currentRoll.MaxInsideEnemyPower);
		stringBuilder.AppendLine("Interior size multiplier: " + currentRoll.FactorySizeMultiplier.ToString("0.00"));
		stringBuilder.AppendLine("Spawn pressure: " + PressureText(currentRoll));
		stringBuilder.AppendLine();
		stringBuilder.AppendLine("Moon routing is disabled. The starter surface is used as a shell and these randomized mission stats control the facility run.");
		stringBuilder.AppendLine();
		return stringBuilder.ToString();
	}

	private static string PressureText(MissionRoll r)
	{
		if (r.DifficultyScore < 4f)
		{
			return "LOW";
		}
		if (r.DifficultyScore < 8f)
		{
			return "MEDIUM";
		}
		if (r.DifficultyScore < 12f)
		{
			return "HIGH";
		}
		string[] array = new string[21]
		{
			"EXTREME", "DEADLY", "FATAL", "BRUTAL", "SAVAGE", "CHAOTIC", "NIGHTMARE", "HELL", "DOOMED", "INSANE",
			"RUTHLESS", "CARNAGE", "MAYHEM", "APOCALYPTIC", "TERMINAL", "FORSAKEN", "ANNIHILATION", "OBLIVION", "NO RETURN", "UNFAIR",
			"IMPOSSIBLE"
		};
		float num = Mathf.InverseLerp(12f, 20f, r.DifficultyScore);
		int num2 = Mathf.Clamp(Mathf.FloorToInt(num * (float)array.Length), 0, array.Length - 1);
		return array[num2];
	}

	private static TerminalNode GetRoutePromptTerminalNode(bool missionRoute)
	{
		TerminalNode val = (missionRoute ? routeMissionPromptTerminalNode : routeCompanyPromptTerminalNode);
		if ((Object)(object)val == (Object)null)
		{
			val = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)val).name = (missionRoute ? "MissionRandomizerRouteMissionPromptNode" : "MissionRandomizerRouteCompanyPromptNode");
			SetField(val, "clearPreviousText", true);
			SetField(val, "maxCharactersToType", 35);
			SetField(val, "buyItemIndex", -1);
			SetField(val, "buyVehicleIndex", -1);
			SetField(val, "buyRerouteToMoon", -1);
			SetField(val, "displayPlanetInfo", -1);
			SetField(val, "shipUnlockableID", -1);
			SetField(val, "itemCost", 0);
			SetField(val, "creatureFileID", -1);
			SetField(val, "storyLogFileID", -1);
			if (missionRoute)
			{
				routeMissionPromptTerminalNode = val;
			}
			else
			{
				routeCompanyPromptTerminalNode = val;
			}
		}
		SetField(val, "buyRerouteToMoon", -1);
		SetField(val, "displayPlanetInfo", -1);
		SetField(val, "itemCost", 0);
		if (missionRoute)
		{
			SetField(val, "displayText", "Route the ship to the randomized facility mission?\n\nThe ship will use Experimentation as the surface shell. Mission stats will randomize in orbit and apply when the facility loads.\n\nPlease CONFIRM or DENY.\n\n");
		}
		else
		{
			SetField(val, "displayText", "Route the ship to the Company building?\n\nMission randomizer values will not apply while at the Company.\n\nPlease CONFIRM or DENY.\n\nType MISSION later to return to the randomized facility mission.\n\n");
		}
		return val;
	}

	private static TerminalNode GetRouteTerminalNode(SelectableLevel level, bool missionRoute)
	{
		TerminalNode val = (missionRoute ? routeMissionTerminalNode : routeCompanyTerminalNode);
		if ((Object)(object)val == (Object)null)
		{
			val = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)val).name = (missionRoute ? "MissionRandomizerRouteMissionNode" : "MissionRandomizerRouteCompanyNode");
			SetField(val, "clearPreviousText", true);
			SetField(val, "maxCharactersToType", 35);
			SetField(val, "buyItemIndex", -1);
			SetField(val, "buyVehicleIndex", -1);
			SetField(val, "shipUnlockableID", -1);
			SetField(val, "itemCost", 0);
			SetField(val, "creatureFileID", -1);
			SetField(val, "storyLogFileID", -1);
			if (missionRoute)
			{
				routeMissionTerminalNode = val;
			}
			else
			{
				routeCompanyTerminalNode = val;
			}
		}
		int field = GetField(level, "levelID", (!missionRoute) ? (-1) : 0);
		SetField(val, "buyRerouteToMoon", field);
		SetField(val, "displayPlanetInfo", -1);
		SetField(val, "itemCost", 0);
		if (missionRoute)
		{
			SetField(val, "displayText", "Routing ship to the randomized facility mission.\n\nExperimentation is used as the surface shell. Mission stats will apply in orbit and when the facility loads.\n\n");
		}
		else
		{
			SetField(val, "displayText", "Routing ship to the Company building.\n\nMission randomizer values will not apply while at the Company.\n\nType MISSION later to return to the randomized facility mission.\n\n");
		}
		return val;
	}

	private static TerminalNode GetMissionTerminalNode(string text)
	{
		if ((Object)(object)missionTerminalNode == (Object)null)
		{
			missionTerminalNode = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)missionTerminalNode).name = "MissionRandomizerNode";
			SetField(missionTerminalNode, "clearPreviousText", true);
			SetField(missionTerminalNode, "maxCharactersToType", 35);
			SetField(missionTerminalNode, "buyItemIndex", -1);
			SetField(missionTerminalNode, "buyVehicleIndex", -1);
			SetField(missionTerminalNode, "buyRerouteToMoon", -1);
			SetField(missionTerminalNode, "displayPlanetInfo", -1);
			SetField(missionTerminalNode, "shipUnlockableID", -1);
			SetField(missionTerminalNode, "itemCost", 0);
			SetField(missionTerminalNode, "creatureFileID", -1);
			SetField(missionTerminalNode, "storyLogFileID", -1);
		}
		SetField(missionTerminalNode, "displayText", text);
		return missionTerminalNode;
	}

	private static string GetTerminalCommand(Terminal terminal)
	{
		string text = GetField(terminal, "currentText", string.Empty) ?? string.Empty;
		if (string.IsNullOrWhiteSpace(text) && (Object)(object)terminal != (Object)null)
		{
			object field = GetField<object>(terminal, "screenText", null);
			text = GetTextObjectText(field) ?? string.Empty;
		}
		text = text.Replace("\r", "\n").Trim();
		int num = text.LastIndexOf('\n');
		if (num >= 0 && num < text.Length - 1)
		{
			text = text.Substring(num + 1).Trim();
		}
		while (text.StartsWith(">"))
		{
			text = text.Substring(1).Trim();
		}
		return text.ToLowerInvariant();
	}

	private static string GetTextObjectText(object textObject)
	{
		if (textObject == null)
		{
			return null;
		}
		try
		{
			Type type = textObject.GetType();
			PropertyInfo property = type.GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null)
			{
				object value = property.GetValue(textObject, null);
				return value as string;
			}
			FieldInfo fieldInfo = FindField(type, "text");
			if (fieldInfo != null)
			{
				object value2 = fieldInfo.GetValue(textObject);
				return value2 as string;
			}
		}
		catch
		{
		}
		return null;
	}

	private static void SetTextObjectText(object textObject, string value)
	{
		if (textObject == null)
		{
			return;
		}
		try
		{
			Type type = textObject.GetType();
			PropertyInfo property = type.GetProperty("text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanWrite)
			{
				property.SetValue(textObject, value, null);
				MarkTextObjectDirty(textObject);
				return;
			}
			FieldInfo fieldInfo = FindField(type, "text");
			if (fieldInfo != null)
			{
				fieldInfo.SetValue(textObject, value);
				MarkTextObjectDirty(textObject);
				return;
			}
			FieldInfo fieldInfo2 = FindField(type, "m_text");
			if (fieldInfo2 != null)
			{
				fieldInfo2.SetValue(textObject, value);
				MarkTextObjectDirty(textObject);
			}
		}
		catch
		{
		}
	}

	private static void MarkTextObjectDirty(object textObject)
	{
		if (textObject == null)
		{
			return;
		}
		try
		{
			Type type = textObject.GetType();
			InvokeNoArgMethod(type, textObject, "SetVerticesDirty");
			InvokeNoArgMethod(type, textObject, "SetLayoutDirty");
			InvokeNoArgMethod(type, textObject, "SetAllDirty");
		}
		catch
		{
		}
	}

	private static void InvokeNoArgMethod(Type type, object instance, string methodName)
	{
		while (type != null)
		{
			MethodInfo method = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method != null)
			{
				method.Invoke(instance, null);
				break;
			}
			type = type.BaseType;
		}
	}

	private static string GetPath(Transform transform)
	{
		if ((Object)(object)transform == (Object)null)
		{
			return string.Empty;
		}
		string text = ((Object)transform).name;
		Transform parent = transform.parent;
		while ((Object)(object)parent != (Object)null)
		{
			text = ((Object)parent).name + "/" + text;
			parent = parent.parent;
		}
		return text;
	}

	private static FieldInfo FindField(Type type, string fieldName)
	{
		while (type != null)
		{
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				return field;
			}
			type = type.BaseType;
		}
		return null;
	}

	private static T GetField<T>(object instance, string fieldName, T fallback)
	{
		if (instance == null)
		{
			return fallback;
		}
		try
		{
			FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
			if (fieldInfo == null)
			{
				return fallback;
			}
			object value = fieldInfo.GetValue(instance);
			if (value is T)
			{
				T result = (T)value;
				if (true)
				{
					return result;
				}
			}
		}
		catch
		{
		}
		return fallback;
	}

	private static void SetField(object instance, string fieldName, object value)
	{
		if (instance == null)
		{
			return;
		}
		try
		{
			FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
			if (!(fieldInfo == null))
			{
				if (value != null && fieldInfo.FieldType.IsEnum && value is string value2)
				{
					object value3 = Enum.Parse(fieldInfo.FieldType, value2);
					fieldInfo.SetValue(instance, value3);
				}
				else if (value != null && fieldInfo.FieldType == typeof(float) && value is int num)
				{
					fieldInfo.SetValue(instance, (float)num);
				}
				else if (value != null && fieldInfo.FieldType == typeof(int) && value is float num2)
				{
					fieldInfo.SetValue(instance, Mathf.RoundToInt(num2));
				}
				else
				{
					fieldInfo.SetValue(instance, value);
				}
			}
		}
		catch
		{
		}
	}

	private static bool GetBool(object instance, string fieldName, bool fallback)
	{
		return GetField(instance, fieldName, fallback);
	}

	private static float GetFloat(object instance, string fieldName, float fallback)
	{
		if (instance == null)
		{
			return fallback;
		}
		try
		{
			FieldInfo fieldInfo = FindField(instance.GetType(), fieldName);
			if (fieldInfo == null)
			{
				return fallback;
			}
			object value = fieldInfo.GetValue(instance);
			if (value is float result)
			{
				return result;
			}
			if (value is int num)
			{
				return num;
			}
			if (value is double)
			{
				double num2 = (double)value;
				if (true)
				{
					return (float)num2;
				}
			}
		}
		catch
		{
		}
		return fallback;
	}

	private static int GetInt(object instance, string fieldName, int fallback)
	{
		return GetField(instance, fieldName, fallback);
	}
}
internal class CleaningConversionRecord
{
	public string MessType;

	public string OutputType;

	public int Value;

	public Vector3 Position;

	public float CreatedAt;

	public int SourceInstanceId;

	public string SourceObjectName;
}
internal class CleaningMessValueTracker : MonoBehaviour
{
	public Component ScrapComponent;

	public string MessType;

	public string OutputType;

	public int LastKnownValue;

	public Vector3 LastKnownPosition;

	public float CreatedAt;

	public int SourceInstanceId;

	public string SourceObjectName;

	public bool TracksCleaningSource;

	private bool notified;

	public void Initialize(Component component, string messType, string outputType, bool tracksCleaningSource)
	{
		//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)
		ScrapComponent = component;
		MessType = messType;
		OutputType = outputType;
		TracksCleaningSource = tracksCleaningSource;
		LastKnownValue = ((!((Object)(object)component != (Object)null)) ? 1 : MissionControllerSafeGetScrapValue(component));
		LastKnownPosition = ((Component)this).transform.position;
		CreatedAt = Time.realtimeSinceStartup;
		SourceInstanceId = (((Object)(object)((Component)this).gameObject != (Object)null) ? ((Object)((Component)this).gameObject).GetInstanceID() : 0);
		SourceObjectName = (((Object)(object)((Component)this).gameObject != (Object)null) ? ((Object)((Component)this).gameObject).name : string.Empty);
		notified = false;
	}

	private static int MissionControllerSafeGetScrapValue(Component component)
	{
		try
		{
			FieldInfo field = ((object)component).GetType().GetField("scrapValue", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null)
			{
				return Mathf.Max(1, Convert.ToInt32(field.GetValue(component)));
			}
		}
		catch
		{
		}
		return 1;
	}

	private void LateUpdate()
	{
		//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)
		if ((Object)(object)ScrapComponent != (Object)null)
		{
			LastKnownValue = MissionControllerSafeGetScrapValue(ScrapComponent);
			LastKnownPosition = ((Component)this).transform.position;
		}
	}

	private void OnDisable()
	{
		NotifyOnce("disabled");
	}

	private void OnDestroy()
	{
		NotifyOnce("destroyed");
	}

	private void NotifyOnce(string reason)
	{
		if (!notified)
		{
			notified = true;
			if (TracksCleaningSource)
			{
				MissionController.NotifyCleaningCompanyMessGone(this, reason);
			}
		}
	}
}
internal class ScrapComponentRecord
{
	public Component Component;

	public GameObject GameObject;

	public int Value;

	public string ItemName;

	public int SyncIndex;
}
internal sealed class SpawnableItemValueFields
{
	public object Item;

	public FieldInfo MinField;

	public FieldInfo MaxField;

	public int OldMin;

	public int OldMax;

	public float OldMid;
}
internal class OriginalScrapItemValueRange
{
	public object Item;

	public int MinValue;

	public int MaxValue;
}
internal struct PendingScrapValue
{
	public ulong NetworkObjectId;

	public int Value;
}
internal struct ScrapDebugStats
{
	public int SpawnedScrapCount;

	public int TeleportedCount;

	public int HeldOrSkippedCount;

	public int TotalScrapValue;

	public int ItemPropertiesScrapCount;

	public int ItemPropertiesScrapValue;

	public int ValueOnlyCount;

	public int ValueOnlyValue;

	public int RawValuedGrabbableCount;

	public int RawValuedGrabbableValue;

	public int ApparatusCount;

	public int ApparatusValue;

	public int TrueScrapIncludingApparatusCount;

	public int TrueScrapIncludingApparatusValue;

	public int MinScrapValue;

	public int MaxScrapValue;

	public string ItemBreakdown;

	public string ApparatusBreakdown;

	public string NonScrapBreakdown;

	public string RawBreakdown;

	public string Error;
}
internal struct MissionRoll
{
	public int Seed;

	public int ProfitQuota;

	public int QuotaFulfilled;

	public int QuotaRemaining;

	public int DaysLeft;

	public int QuotaNumber;

	public string Rank;

	public int RankIndex;

	public float DifficultyScore;

	public int MaxTotalScrapValue;

	public int MinScrap;

	public int MaxScrap;

	public int MaxInsideEnemyPower;

	public int MaxOutsideEnemyPower;

	public int MaxDaytimeEnemyPower;

	public int MinEnemiesToSpawn;

	public int SpawnBatchHours;

	public int MaxInsideDiversity;

	public float FactorySizeMultiplier;

	public float ScrapAmountMultiplier;

	public float ScrapValueMultiplier;

	public string ToLogString()
	{
		return $"seed={Seed}, quota={QuotaFulfilled}/{ProfitQuota}, daysLeft={DaysLeft}, rank={Rank}, valueRange={Mathf.RoundToInt((float)MaxTotalScrapValue * 0.8f)}-{MaxTotalScrapValue}, scrap={MinScrap}-{MaxScrap}, insidePower={MaxInsideEnemyPower}, factory={FactorySizeMultiplier:0.00}, amountMult={ScrapAmountMultiplier:0.00}, valueMult={ScrapValueMultiplier:0.00}";
	}
}
[HarmonyPatch(typeof(StartOfRound), "SetMapScreenInfoToCurrentLevel")]
internal static class StartOfRound_SetMapScreenInfoToCurrentLevel_Patch
{
	private static void Postfix()
	{
		MissionController.AfterMapScreenUpdate();
	}
}
[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
internal static class RoundManager_LoadNewLevel_Patch
{
	private static void Prefix()
	{
		MissionController.BeforeLoadNewLevel();
	}
}
[HarmonyPatch(typeof(StartOfRound), "ChooseNewRandomMapSeed")]
internal static class StartOfRound_ChooseNewRandomMapSeed_Patch
{
	private static void Postfix(StartOfRound __instance)
	{
		MissionController.AfterChooseNewRandomMapSeed(__instance);
	}
}
[HarmonyPatch(typeof(GrabbableObject), "Start")]
internal static class GrabbableObject_Start_Patch
{
	private static void Postfix(GrabbableObject __instance)
	{
		MissionController.AfterGrabbableObjectStart((Component)(object)__instance);
	}
}
[HarmonyPatch(typeof(RoundManager), "FinishGeneratingNewLevelClientRpc")]
internal static class RoundManager_FinishGeneratingNewLevelClientRpc_Patch
{
	private static void Prefix(RoundManager __instance)
	{
		MissionController.BeforeFinishGeneratingNewLevelClientRpc(__instance);
	}
}
[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
internal static class RoundManager_SpawnScrapInLevel_Patch
{
	private static void Prefix(RoundManager __instance)
	{
		MissionController.BeforeSpawnScrapInLevel(__instance);
	}

	private static void Postfix(RoundManager __instance)
	{
		MissionController.AfterSpawnScrapInLevel(__instance);
	}
}
[HarmonyPatch(typeof(RoundManager), "waitForScrapToSpawnToSync")]
internal static class RoundManager_WaitForScrapToSpawnToSync_Patch
{
	private static void Prefix(RoundManager __instance, NetworkObjectReference[] __0, int[] __1)
	{
		MissionController.BeforeVanillaScrapValuesSync(__instance, __0, __1);
	}
}
[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
internal static class Terminal_ParsePlayerSentence_Patch
{
	private static bool Prefix(Terminal __instance, ref TerminalNode __result)
	{
		return MissionController.TryHandleTerminalCommand(__instance, ref __result);
	}
}
[HarmonyPatch(typeof(StartOfRound), "Update")]
internal static class StartOfRound_Update_Patch
{
	private static void Postfix()
	{
		MissionController.UpdateLoop();
	}
}