using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using ReksikPerformance.Rejoin;
using ReksikPerformance.Reliability;
using ReksikPerformance.ReliabilityGuards;
using TMPro;
using UnboundLib;
using UnboundLib.GameModes;
using UnboundLib.Utils.UI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ReksikPerformance")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f6034f7bbf3bfa1247464cb333b4b126defee508")]
[assembly: AssemblyProduct("ReksikPerformance")]
[assembly: AssemblyTitle("ReksikPerformance")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ReksikPerformance
{
	internal sealed class AdaptivePerformanceController
	{
		private const int MaximumTier = 3;

		private const float MinimumTierHoldSeconds = 3.5f;

		private float _pressureSeconds;

		private float _recoverySeconds;

		private float _lastTierChangeAt = -1000f;

		private int _statusTier = -1;

		private string _statusState = string.Empty;

		public int Tier { get; private set; }

		public string StatusText { get; private set; } = "T0 STABLE";

		public void Tick(PerformanceSettings settings, MetricsSampler metrics, VfxBudgetController vfx, CompatibilityGuard compatibility)
		{
			if (!settings.AdaptiveEnabled.Value || !settings.Enabled.Value || settings.Profile.Value == PerformanceProfile.Vanilla || compatibility.PerformanceImprovementsDetected || !metrics.HasSnapshot)
			{
				Reset(vfx, compatibility.PerformanceImprovementsDetected ? "DEFERRED" : "OFF");
				return;
			}
			float num = ResolveTargetFps(settings.TargetFrameRate.Value);
			float num2 = num * 0.88f;
			float num3 = num * 0.97f;
			float num4 = Mathf.Min(Time.unscaledDeltaTime, 0.25f);
			bool flag = metrics.FramesPerSecond < num2 || metrics.OnePercentLowFps < num * 0.68f;
			bool flag2 = metrics.FramesPerSecond >= num3 && metrics.OnePercentLowFps >= num * 0.84f;
			if (Time.unscaledTime - _lastTierChangeAt < 3.5f)
			{
				_pressureSeconds = Mathf.Max(0f, _pressureSeconds - num4);
				_recoverySeconds = Mathf.Max(0f, _recoverySeconds - num4);
				UpdateStatus("HOLD");
				return;
			}
			if (flag)
			{
				_pressureSeconds += num4;
				_recoverySeconds = Mathf.Max(0f, _recoverySeconds - num4 * 2f);
			}
			else if (flag2)
			{
				_recoverySeconds += num4;
				_pressureSeconds = Mathf.Max(0f, _pressureSeconds - num4);
			}
			else
			{
				_pressureSeconds = Mathf.Max(0f, _pressureSeconds - num4 * 0.5f);
				_recoverySeconds = Mathf.Max(0f, _recoverySeconds - num4 * 0.5f);
			}
			float num5 = Clamp(settings.AdaptivePressureSeconds.Value, 2f, 20f);
			float num6 = Clamp(settings.AdaptiveRecoverySeconds.Value, 5f, 60f);
			if (_pressureSeconds >= num5 && Tier < 3)
			{
				Tier++;
				OnTierChanged(vfx);
			}
			else if (_recoverySeconds >= num6 && Tier > 0)
			{
				Tier--;
				OnTierChanged(vfx);
			}
			UpdateStatus(flag ? "PRESSURE" : (flag2 ? "RECOVERING" : "STABLE"));
		}

		public void Reset(VfxBudgetController vfx, string reason = "OFF")
		{
			_pressureSeconds = 0f;
			_recoverySeconds = 0f;
			_lastTierChangeAt = -1000f;
			Tier = 0;
			vfx.SetAdaptiveTier(0);
			UpdateStatus(reason);
		}

		private void OnTierChanged(VfxBudgetController vfx)
		{
			_pressureSeconds = 0f;
			_recoverySeconds = 0f;
			_lastTierChangeAt = Time.unscaledTime;
			vfx.SetAdaptiveTier(Tier);
		}

		private void UpdateStatus(string state)
		{
			if (_statusTier != Tier || !string.Equals(_statusState, state, StringComparison.Ordinal))
			{
				_statusTier = Tier;
				_statusState = state;
				StatusText = $"T{Tier} {state}";
			}
		}

		private static float ResolveTargetFps(int configuredTarget)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (configuredTarget >= 30)
			{
				return configuredTarget;
			}
			Resolution currentResolution = Screen.currentResolution;
			int refreshRate = ((Resolution)(ref currentResolution)).refreshRate;
			if (refreshRate < 30)
			{
				return 60f;
			}
			return refreshRate;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return min;
			}
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
	internal sealed class CompatibilityGuard
	{
		public const string PerformanceImprovementsGuid = "pykess.rounds.plugins.performanceimprovements";

		public bool PerformanceImprovementsDetected { get; }

		public string StatusText
		{
			get
			{
				if (!PerformanceImprovementsDetected)
				{
					return "NATIVE MODE | NO OVERLAPPING PERFORMANCE PLUGIN DETECTED";
				}
				return "COMPATIBILITY MODE | EXISTING PERFORMANCE IMPROVEMENTS DETECTED";
			}
		}

		public CompatibilityGuard()
		{
			PerformanceImprovementsDetected = Chainloader.PluginInfos.ContainsKey("pykess.rounds.plugins.performanceimprovements");
		}
	}
	internal sealed class GraphicsController
	{
		private readonly struct Snapshot
		{
			private bool RunInBackground { get; }

			private int TargetFrameRate { get; }

			private int VSyncCount { get; }

			private int AntiAliasing { get; }

			private ShadowQuality Shadows { get; }

			private float ShadowDistance { get; }

			private int PixelLightCount { get; }

			private AnisotropicFiltering AnisotropicFiltering { get; }

			private int MasterTextureLimit { get; }

			private float LodBias { get; }

			private Snapshot(bool runInBackground, int targetFrameRate, int vSyncCount, int antiAliasing, ShadowQuality shadows, float shadowDistance, int pixelLightCount, AnisotropicFiltering anisotropicFiltering, int masterTextureLimit, float lodBias)
			{
				//IL_001e: 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_0036: 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)
				RunInBackground = runInBackground;
				TargetFrameRate = targetFrameRate;
				VSyncCount = vSyncCount;
				AntiAliasing = antiAliasing;
				Shadows = shadows;
				ShadowDistance = shadowDistance;
				PixelLightCount = pixelLightCount;
				AnisotropicFiltering = anisotropicFiltering;
				MasterTextureLimit = masterTextureLimit;
				LodBias = lodBias;
			}

			public static Snapshot Capture()
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				return new Snapshot(Application.runInBackground, Application.targetFrameRate, QualitySettings.vSyncCount, QualitySettings.antiAliasing, QualitySettings.shadows, QualitySettings.shadowDistance, QualitySettings.pixelLightCount, QualitySettings.anisotropicFiltering, QualitySettings.masterTextureLimit, QualitySettings.lodBias);
			}

			public void Restore()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				Application.runInBackground = RunInBackground;
				Application.targetFrameRate = TargetFrameRate;
				QualitySettings.vSyncCount = VSyncCount;
				QualitySettings.antiAliasing = AntiAliasing;
				QualitySettings.shadows = Shadows;
				QualitySettings.shadowDistance = ShadowDistance;
				QualitySettings.pixelLightCount = PixelLightCount;
				QualitySettings.anisotropicFiltering = AnisotropicFiltering;
				QualitySettings.masterTextureLimit = MasterTextureLimit;
				QualitySettings.lodBias = LodBias;
			}
		}

		private readonly ManualLogSource _logger;

		private readonly Snapshot _startup;

		public GraphicsController(ManualLogSource logger)
		{
			_logger = logger;
			_startup = Snapshot.Capture();
		}

		public void Apply(PerformanceSettings settings, CompatibilityGuard compatibility)
		{
			Restore();
			if (settings.ReliabilityEnabled.Value && settings.RunInBackgroundForReliability.Value)
			{
				Application.runInBackground = true;
			}
			if (settings.Enabled.Value && settings.Profile.Value != PerformanceProfile.Vanilla)
			{
				Application.targetFrameRate = NormalizeTargetFrameRate(settings.TargetFrameRate.Value);
				QualitySettings.vSyncCount = Clamp(settings.VSyncCount.Value, 0, 4);
				QualitySettings.antiAliasing = NormalizeAntiAliasing(settings.AntiAliasing.Value);
				QualitySettings.masterTextureLimit = Clamp(settings.TextureLimit.Value, 0, 3);
				QualitySettings.lodBias = Clamp(settings.LodBias.Value, 0.1f, 5f);
				QualitySettings.anisotropicFiltering = (AnisotropicFiltering)(settings.AnisotropicFiltering.Value ? 2 : 0);
				if (!compatibility.PerformanceImprovementsDetected)
				{
					QualitySettings.shadows = (ShadowQuality)(settings.Shadows.Value ? 2 : 0);
					QualitySettings.shadowDistance = Clamp(settings.ShadowDistance.Value, 0f, 500f);
					QualitySettings.pixelLightCount = Clamp(settings.PixelLightCount.Value, 0, 32);
				}
				_logger.LogDebug((object)($"Applied local profile {settings.Profile.Value}; target={Application.targetFrameRate}, " + $"vSync={QualitySettings.vSyncCount}, compatibility={compatibility.PerformanceImprovementsDetected}."));
			}
		}

		public void Restore()
		{
			_startup.Restore();
		}

		private static int NormalizeTargetFrameRate(int value)
		{
			if (value >= 0)
			{
				return Clamp(value, 30, 1000);
			}
			return -1;
		}

		private static int NormalizeAntiAliasing(int value)
		{
			if (value < 8)
			{
				if (value < 4)
				{
					if (value < 2)
					{
						return 0;
					}
					return 2;
				}
				return 4;
			}
			return 8;
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
	internal sealed class MetricsOverlay
	{
		private GUIStyle? _style;

		private Texture2D? _background;

		public void Draw(string text)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			EnsureStyle();
			if (_style != null)
			{
				GUI.Label(new Rect((float)Screen.width - 390f, 18f, 372f, 76f), text, _style);
			}
		}

		public void Dispose()
		{
			if ((Object)(object)_background != (Object)null)
			{
				Object.Destroy((Object)(object)_background);
				_background = null;
			}
			_style = null;
		}

		private void EnsureStyle()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			if (_style == null)
			{
				_background = new Texture2D(1, 1, (TextureFormat)4, false)
				{
					hideFlags = (HideFlags)61
				};
				_background.SetPixel(0, 0, new Color(0.035f, 0.04f, 0.065f, 0.92f));
				_background.Apply(false, true);
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)3,
					fontSize = 13,
					padding = new RectOffset(12, 12, 7, 7)
				};
				val.normal.background = _background;
				val.normal.textColor = new Color(0.9f, 0.94f, 1f, 1f);
				_style = val;
			}
		}
	}
	internal sealed class MetricsSampler
	{
		private const int WindowCapacity = 600;

		private readonly float[] _frameTimes = new float[600];

		private readonly float[] _sortBuffer = new float[600];

		private int _count;

		private int _cursor;

		private float _nextSnapshotAt;

		private int _lastGcCollections;

		public float FramesPerSecond { get; private set; }

		public float AverageFrameMilliseconds { get; private set; }

		public float OnePercentLowFps { get; private set; }

		public float ManagedMemoryMegabytes { get; private set; }

		public int GcCollectionsSinceLastSnapshot { get; private set; }

		public bool HasSnapshot { get; private set; }

		public string OverlayText { get; private set; } = "Sampling...";

		public MetricsSampler()
		{
			_lastGcCollections = TotalGcCollections();
		}

		public void Tick(PerformanceProfile profile, int particles, int trails, string compatibility, string adaptiveStatus)
		{
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			if (unscaledDeltaTime > 0f && unscaledDeltaTime < 5f && !float.IsNaN(unscaledDeltaTime))
			{
				_frameTimes[_cursor] = unscaledDeltaTime;
				_cursor = (_cursor + 1) % 600;
				if (_count < 600)
				{
					_count++;
				}
			}
			if (!(Time.unscaledTime < _nextSnapshotAt) && _count != 0)
			{
				_nextSnapshotAt = Time.unscaledTime + 0.5f;
				Recalculate(profile, particles, trails, compatibility, adaptiveStatus);
			}
		}

		private void Recalculate(PerformanceProfile profile, int particles, int trails, string compatibility, string adaptiveStatus)
		{
			float num = 0f;
			for (int i = 0; i < _count; i++)
			{
				float num2 = _frameTimes[i];
				_sortBuffer[i] = num2;
				num += num2;
			}
			Array.Sort(_sortBuffer, 0, _count);
			float num3 = num / (float)_count;
			int num4 = Math.Max(0, Math.Min(_count - 1, (int)Math.Ceiling((float)_count * 0.99f) - 1));
			float num5 = _sortBuffer[num4];
			AverageFrameMilliseconds = num3 * 1000f;
			FramesPerSecond = ((num3 > 0f) ? (1f / num3) : 0f);
			OnePercentLowFps = ((num5 > 0f) ? (1f / num5) : 0f);
			ManagedMemoryMegabytes = (float)GC.GetTotalMemory(forceFullCollection: false) / 1048576f;
			int num6 = TotalGcCollections();
			GcCollectionsSinceLastSnapshot = Math.Max(0, num6 - _lastGcCollections);
			_lastGcCollections = num6;
			HasSnapshot = true;
			string text = (compatibility.StartsWith("COMPATIBILITY", StringComparison.Ordinal) ? "COMPAT" : "NATIVE");
			OverlayText = "REKSIK PERFORMANCE  |  " + profile.ToString().ToUpperInvariant() + "  |  " + text + "  |  ADAPT " + adaptiveStatus + "\n" + $"FPS {FramesPerSecond:0}  |  1% LOW {OnePercentLowFps:0}  |  {AverageFrameMilliseconds:0.0} ms\n" + $"MEM {ManagedMemoryMegabytes:0} MB  |  GC +{GcCollectionsSinceLastSnapshot}  |  VFX {particles}/{trails}";
		}

		private static int TotalGcCollections()
		{
			return GC.CollectionCount(0) + GC.CollectionCount(1) + GC.CollectionCount(2);
		}
	}
	internal static class PerformanceMenu
	{
		private sealed class View
		{
			private sealed class TogglePresentation
			{
				public string BaseLabel { get; }

				public TextMeshProUGUI Label { get; }

				public TogglePresentation(string baseLabel, TextMeshProUGUI label)
				{
					BaseLabel = baseLabel;
					Label = label;
				}
			}

			private readonly ReksikPerformancePlugin _plugin;

			private readonly Dictionary<PerformanceProfile, Button> _profiles = new Dictionary<PerformanceProfile, Button>();

			private readonly Dictionary<Toggle, TogglePresentation> _togglePresentations = new Dictionary<Toggle, TogglePresentation>();

			private Toggle? _enabled;

			private Toggle? _overlay;

			private Toggle? _reliabilityEnabled;

			private Toggle? _writeDiagnostics;

			private Toggle? _runInBackground;

			private Toggle? _commonGuards;

			private Toggle? _experimentalRejoin;

			private Toggle? _adaptive;

			private Toggle? _shadows;

			private Toggle? _anisotropic;

			private TextMeshProUGUI? _compatibility;

			private TextMeshProUGUI? _reliabilityLive;

			private TextMeshProUGUI? _live;

			private TMP_InputField? _fps;

			private TMP_InputField? _vSync;

			private TMP_InputField? _aa;

			private TMP_InputField? _particles;

			private TMP_InputField? _trail;

			private bool _refreshing;

			public GameObject Root { get; }

			public View(GameObject root, ReksikPerformancePlugin plugin)
			{
				Root = root;
				_plugin = plugin;
			}

			public void Build()
			{
				//IL_0008: 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_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_019a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0282: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0456: Unknown result type (might be due to invalid IL or missing references)
				//IL_0472: Unknown result type (might be due to invalid IL or missing references)
				AddText("REKSIK PERFORMANCE  /  LOCAL CONTROL", 33, Accent, 42f);
				AddText("SESSION RELIABILITY | SQUEEZE FPS | LIVE EVIDENCE", 18, Muted, 27f);
				_compatibility = AddText(string.Empty, 18, Muted, 36f);
				AddText("PILLAR 1  /  SESSION RELIABILITY", 22, Accent, 30f);
				_reliabilityEnabled = AddToggle("ENABLE PASSIVE SESSION RELIABILITY", _plugin.Settings.ReliabilityEnabled.Value, _plugin.Settings.SetReliabilityEnabled);
				_writeDiagnostics = AddToggle("WRITE BOUNDED DISCONNECT DIAGNOSTICS", _plugin.Settings.WriteReliabilityDiagnostics.Value, _plugin.Settings.SetWriteReliabilityDiagnostics);
				_runInBackground = AddToggle("KEEP CLIENT ACTIVE WHILE UNFOCUSED", _plugin.Settings.RunInBackgroundForReliability.Value, _plugin.Settings.SetRunInBackgroundForReliability);
				_commonGuards = AddToggle("COMMON DISCONNECT GUARDS  (RESTART REQUIRED)", _plugin.Settings.CommonDisconnectGuards.Value, _plugin.Settings.SetCommonDisconnectGuards);
				_experimentalRejoin = AddToggle("EXPERIMENTAL NON-HOST REJOIN  (RESTART / HOST + CLIENT)", _plugin.Settings.ExperimentalRejoinEnabled.Value, _plugin.Settings.SetExperimentalRejoinEnabled);
				_reliabilityLive = AddText(string.Empty, 17, Muted, 118f);
				AddText("PILLAR 2  /  SQUEEZE FPS", 22, Accent, 30f);
				_enabled = AddToggle("ENABLE LOCAL PERFORMANCE PROFILE", _plugin.Settings.Enabled.Value, _plugin.Settings.SetEnabled);
				_adaptive = AddToggle("ADAPTIVE VFX PRESSURE CONTROL  (DEFAULT ON)", _plugin.Settings.AdaptiveEnabled.Value, _plugin.Settings.SetAdaptiveEnabled);
				_overlay = AddToggle("SHOW LIVE METRICS OVERLAY", _plugin.Settings.ShowOverlay.Value, _plugin.Settings.SetOverlay);
				AddText("FPS / VISUAL PROFILE", 21, Text, 29f);
				AddProfile(PerformanceProfile.Vanilla, "VANILLA  -  RESTORE STARTUP VALUES");
				AddProfile(PerformanceProfile.MaxFps, "MAX FPS  -  SQUEEZE EVERY LOCAL FRAME");
				AddProfile(PerformanceProfile.Balanced, "BALANCED  -  LONG SESSION DEFAULT");
				AddProfile(PerformanceProfile.Competitive, "COMPETITIVE  -  FRAME PACING FIRST");
				AddProfile(PerformanceProfile.Potato, "POTATO  -  MAXIMUM LOCAL RELIEF");
				AddProfile(PerformanceProfile.Cinematic, "CINEMATIC  -  VISUAL QUALITY");
				_shadows = AddToggle("LOCAL SHADOWS", _plugin.Settings.Shadows.Value, _plugin.Settings.SetShadows);
				_anisotropic = AddToggle("ANISOTROPIC FILTERING", _plugin.Settings.AnisotropicFiltering.Value, _plugin.Settings.SetAnisotropicFiltering);
				_fps = AddNumberInput("MAX FPS  (-1 = PLATFORM DEFAULT)", delegate(float value)
				{
					_plugin.Settings.SetTargetFrameRate((int)value);
				});
				_vSync = AddNumberInput("VSYNC INTERVAL  (0-4)", delegate(float value)
				{
					_plugin.Settings.SetVSyncCount((int)value);
				});
				_aa = AddNumberInput("MSAA SAMPLES  (0/2/4/8)", delegate(float value)
				{
					_plugin.Settings.SetAntiAliasing((int)value);
				});
				_particles = AddNumberInput("PARTICLES PER SYSTEM  (16-10000)", delegate(float value)
				{
					_plugin.Settings.SetParticleLimit((int)value);
				});
				_trail = AddNumberInput("TRAIL LIFETIME MULTIPLIER  (0-1.5)", _plugin.Settings.SetTrailLifetimeMultiplier);
				AddText("VFX MODE", 21, Text, 29f);
				AddButton("FULL  -  NO VFX CHANGES", delegate
				{
					_plugin.Settings.SetVfxBudget(LocalVfxBudget.Full);
				});
				AddButton("REDUCED  -  SOFT PARTICLE / TRAIL BUDGET", delegate
				{
					_plugin.Settings.SetVfxBudget(LocalVfxBudget.Reduced);
				});
				AddButton("MINIMAL  -  AGGRESSIVE LOCAL VFX BUDGET", delegate
				{
					_plugin.Settings.SetVfxBudget(LocalVfxBudget.Minimal);
				});
				_live = AddText(string.Empty, 18, Muted, 72f);
				AddText("Reliability is passive and evidence-first. Graphics changes are client-local and restorable.", 16, Muted, 34f);
			}

			public void Refresh()
			{
				//IL_0306: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0379: Unknown result type (might be due to invalid IL or missing references)
				//IL_0372: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_enabled == (Object)null || (Object)(object)_overlay == (Object)null || (Object)(object)_shadows == (Object)null || (Object)(object)_anisotropic == (Object)null || (Object)(object)_reliabilityEnabled == (Object)null || (Object)(object)_writeDiagnostics == (Object)null || (Object)(object)_runInBackground == (Object)null || (Object)(object)_commonGuards == (Object)null || (Object)(object)_experimentalRejoin == (Object)null || (Object)(object)_adaptive == (Object)null || (Object)(object)_reliabilityLive == (Object)null || (Object)(object)_compatibility == (Object)null || (Object)(object)_live == (Object)null || (Object)(object)_fps == (Object)null || (Object)(object)_vSync == (Object)null || (Object)(object)_aa == (Object)null || (Object)(object)_particles == (Object)null || (Object)(object)_trail == (Object)null)
				{
					return;
				}
				_refreshing = true;
				try
				{
					PerformanceSettings settings = _plugin.Settings;
					SetToggleState(_enabled, settings.Enabled.Value);
					SetToggleState(_overlay, settings.ShowOverlay.Value);
					SetToggleState(_reliabilityEnabled, settings.ReliabilityEnabled.Value);
					SetToggleState(_writeDiagnostics, settings.WriteReliabilityDiagnostics.Value);
					SetToggleState(_runInBackground, settings.RunInBackgroundForReliability.Value);
					SetToggleState(_commonGuards, settings.CommonDisconnectGuards.Value);
					SetToggleState(_experimentalRejoin, settings.ExperimentalRejoinEnabled.Value);
					SetToggleState(_adaptive, settings.AdaptiveEnabled.Value);
					SetToggleState(_shadows, settings.Shadows.Value);
					SetToggleState(_anisotropic, settings.AnisotropicFiltering.Value);
					_fps.SetTextWithoutNotify(settings.TargetFrameRate.Value.ToString(CultureInfo.InvariantCulture));
					_vSync.SetTextWithoutNotify(settings.VSyncCount.Value.ToString(CultureInfo.InvariantCulture));
					_aa.SetTextWithoutNotify(settings.AntiAliasing.Value.ToString(CultureInfo.InvariantCulture));
					_particles.SetTextWithoutNotify(settings.ParticleLimit.Value.ToString(CultureInfo.InvariantCulture));
					_trail.SetTextWithoutNotify(settings.TrailLifetimeMultiplier.Value.ToString("0.##", CultureInfo.InvariantCulture));
					foreach (KeyValuePair<PerformanceProfile, Button> profile in _profiles)
					{
						((Graphic)((Component)profile.Value).GetComponentInChildren<TextMeshProUGUI>()).color = ((profile.Key == settings.Profile.Value) ? Accent : Text);
					}
					bool performanceImprovementsDetected = _plugin.Compatibility.PerformanceImprovementsDetected;
					((TMP_Text)_compatibility).text = _plugin.Compatibility.StatusText + (performanceImprovementsDetected ? "\nVFX AND SHADOW/LIGHT KNOBS ARE DEFERRED TO AVOID DOUBLE CONTROL." : string.Empty);
					((Graphic)_compatibility).color = (performanceImprovementsDetected ? Warning : Accent);
					MetricsSampler metrics = _plugin.Metrics;
					SessionReliabilitySummary sessionReliabilitySummary = SessionReliabilitySummary.FromLatest();
					ReliabilityGuardStatus status = ReliabilityGuard.GetStatus();
					ExperimentalRejoinStatus status2 = ExperimentalRejoin.Status;
					long num = status.EntityLagRoundEndsSuppressed + status.NetworkPhysicsUpdatesSkipped + status.FollowPlayerUpdatesSkipped + status.SetPlayerSpriteLayerStartsSkipped + status.RwfFollowPlayerUpdatesSkipped + status.ModdingUtilsDestroyedPlayersSkipped + status.StaleProjectileHitsDropped + status.GearUpLifeforceTerminalCallsGuarded + status.GearUpArcaneNullHitsDropped;
					((TMP_Text)_reliabilityLive).text = sessionReliabilitySummary.CompactLine + "\n" + string.Format("GUARDS: {0}  |  PATCHED {1}  |  INTERVENTIONS {2}\n", status.Installed ? "ACTIVE" : "OFF", status.InstalledPatchCount, num) + $"REJOIN: {status2.State}  |  ATTEMPTS {status2.AttemptsStarted}  |  SUCCESS {status2.SuccessfulRejoins}\n" + "WARM STATE: " + ExperimentalRejoinController.StatusText + (status2.NeedsWarmStateRestore ? "\nWAITING FOR SAFE POINT-BOUNDARY VALIDATION." : string.Empty);
					((TMP_Text)_live).text = "LIVE  |  RELIABILITY " + (settings.ReliabilityEnabled.Value ? "ON" : "OFF") + "  |  " + settings.Profile.Value.ToString().ToUpperInvariant() + "  |  ADAPT " + _plugin.Adaptive.StatusText + "  |  " + $"FPS {metrics.FramesPerSecond:0}  |  1% LOW {metrics.OnePercentLowFps:0}  |  " + $"{metrics.AverageFrameMilliseconds:0.0} ms\n" + $"MEM {metrics.ManagedMemoryMegabytes:0} MB  |  GC +{metrics.GcCollectionsSinceLastSnapshot}  |  " + $"TRACKED VFX {_plugin.Vfx.TrackedParticleSystems}/{_plugin.Vfx.TrackedTrails}";
				}
				finally
				{
					_refreshing = false;
				}
			}

			private void AddProfile(PerformanceProfile profile, string label)
			{
				Button value = AddButton(label, delegate
				{
					_plugin.Settings.ApplyProfile(profile);
				});
				_profiles.Add(profile, value);
			}

			private Toggle AddToggle(string label, bool initialValue, Action<bool> action)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				GameObject obj = MenuHandler.CreateToggle(initialValue, label, Root, (UnityAction<bool>)delegate(bool value)
				{
					if (!_refreshing)
					{
						action(value);
					}
				}, 22, false, (Color?)Text, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
				Compact(obj, 38f);
				Toggle component = obj.GetComponent<Toggle>();
				TextMeshProUGUI componentInChildren = obj.GetComponentInChildren<TextMeshProUGUI>();
				_togglePresentations[component] = new TogglePresentation(label, componentInChildren);
				StyleToggle(component);
				SetToggleState(component, initialValue);
				return component;
			}

			private Button AddButton(string label, Action action)
			{
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				GameObject obj = MenuHandler.CreateButton(label, Root, (UnityAction)delegate
				{
					if (!_refreshing)
					{
						action();
					}
				}, 20, false, (Color?)Text, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
				Compact(obj, 36f);
				Button component = obj.GetComponent<Button>();
				Style((Selectable)(object)component);
				return component;
			}

			private TMP_InputField AddNumberInput(string label, Action<float> action)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				AddText(label, 18, Text, 26f);
				GameObject obj = MenuHandler.CreateInputField("value", 21, Root, (UnityAction<string>)delegate
				{
				});
				Compact(obj, 39f);
				TMP_InputField componentInChildren = obj.GetComponentInChildren<TMP_InputField>();
				((UnityEventBase)componentInChildren.onValueChanged).RemoveAllListeners();
				((UnityEvent<string>)(object)componentInChildren.onEndEdit).AddListener((UnityAction<string>)delegate(string text)
				{
					if (!_refreshing)
					{
						if (TryParseFinite(text, out var value))
						{
							action(value);
						}
						Refresh();
					}
				});
				Style((Selectable)(object)componentInChildren);
				Image component = ((Component)componentInChildren).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = Dark;
				}
				return componentInChildren;
			}

			private TextMeshProUGUI AddText(string value, int size, Color color, float height)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				TextMeshProUGUI val = default(TextMeshProUGUI);
				MenuHandler.CreateText(value, Root, ref val, size, false, (Color?)color, (TMP_FontAsset)null, (Material)null, (TextAlignmentOptions?)null);
				Compact(((Component)val).gameObject, height);
				return val;
			}

			private static bool TryParseFinite(string text, out float value)
			{
				if ((float.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value) || float.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out value)) && !float.IsNaN(value))
				{
					return !float.IsInfinity(value);
				}
				return false;
			}

			private static void Compact(GameObject gameObject, float height)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				RectTransform component = gameObject.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(component.sizeDelta.x, height);
				}
				LayoutElement component2 = gameObject.GetComponent<LayoutElement>();
				if ((Object)(object)component2 != (Object)null)
				{
					component2.preferredHeight = height;
					component2.minHeight = height;
				}
			}

			private static void Style(Selectable selectable)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				ColorBlock colors = selectable.colors;
				((ColorBlock)(ref colors)).normalColor = Dark;
				((ColorBlock)(ref colors)).highlightedColor = DarkHighlight;
				((ColorBlock)(ref colors)).pressedColor = Accent;
				((ColorBlock)(ref colors)).disabledColor = new Color(0.04f, 0.04f, 0.055f, 0.45f);
				((ColorBlock)(ref colors)).colorMultiplier = 1f;
				selectable.colors = colors;
			}

			private static void StyleToggle(Toggle toggle)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)toggle == (Object)null)
				{
					return;
				}
				Graphic graphic = toggle.graphic;
				if ((Object)(object)graphic != (Object)null && (Object)(object)((Selectable)toggle).targetGraphic == (Object)(object)graphic)
				{
					ColorBlock colors = ((Selectable)toggle).colors;
					((ColorBlock)(ref colors)).normalColor = Accent;
					((ColorBlock)(ref colors)).highlightedColor = new Color(0.52f, 1f, 1f, 1f);
					((ColorBlock)(ref colors)).pressedColor = Color.white;
					((ColorBlock)(ref colors)).disabledColor = new Color(Accent.r, Accent.g, Accent.b, 0.45f);
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((Selectable)toggle).colors = colors;
				}
				else
				{
					Style((Selectable)(object)toggle);
					if ((Object)(object)graphic != (Object)null)
					{
						graphic.color = Accent;
					}
				}
			}

			private void SetToggleState(Toggle toggle, bool enabled)
			{
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				toggle.isOn = enabled;
				if (_togglePresentations.TryGetValue(toggle, out TogglePresentation value))
				{
					((TMP_Text)value.Label).text = (enabled ? "[ON]  " : "[OFF]  ") + value.BaseLabel;
					((Graphic)value.Label).color = (enabled ? Accent : Text);
				}
				if ((Object)(object)toggle.graphic != (Object)null && (Object)(object)((Selectable)toggle).targetGraphic != (Object)(object)toggle.graphic)
				{
					toggle.graphic.color = Accent;
				}
			}
		}

		private static readonly Color Text = new Color(0.9f, 0.93f, 0.98f, 1f);

		private static readonly Color Muted = new Color(0.55f, 0.6f, 0.7f, 1f);

		private static readonly Color Accent = new Color(0.24f, 0.86f, 0.92f, 1f);

		private static readonly Color Warning = new Color(1f, 0.67f, 0.3f, 1f);

		private static readonly Color Dark = new Color(0.045f, 0.055f, 0.085f, 0.98f);

		private static readonly Color DarkHighlight = new Color(0.08f, 0.18f, 0.22f, 1f);

		private static readonly List<View> Views = new List<View>();

		private static ReksikPerformancePlugin? _plugin;

		private static bool _registered;

		private static float _nextRefreshAt;

		public static void Register(ReksikPerformancePlugin plugin)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			_plugin = plugin;
			if (!_registered)
			{
				Unbound.RegisterMenu("REKSIK PERFORMANCE", new UnityAction(RefreshAll), (Action<GameObject>)Build, (GameObject)null, true);
				_registered = true;
			}
		}

		public static void Tick()
		{
			if (!(Time.unscaledTime < _nextRefreshAt))
			{
				_nextRefreshAt = Time.unscaledTime + 0.5f;
				RefreshAll();
			}
		}

		private static void Build(GameObject root)
		{
			if (!((Object)(object)_plugin == (Object)null))
			{
				View view = new View(root, _plugin);
				Views.Add(view);
				view.Build();
				view.Refresh();
			}
		}

		private static void RefreshAll()
		{
			for (int num = Views.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)Views[num].Root == (Object)null)
				{
					Views.RemoveAt(num);
				}
				else
				{
					Views[num].Refresh();
				}
			}
		}
	}
	public enum PerformanceProfile
	{
		Vanilla,
		MaxFps,
		Balanced,
		Competitive,
		Potato,
		Cinematic,
		Custom
	}
	public enum LocalVfxBudget
	{
		Full,
		Reduced,
		Minimal
	}
	internal sealed class PerformanceSettings
	{
		private bool _suppressEvents;

		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<PerformanceProfile> Profile { get; }

		public ConfigEntry<bool> ReliabilityEnabled { get; }

		public ConfigEntry<bool> WriteReliabilityDiagnostics { get; }

		public ConfigEntry<bool> RunInBackgroundForReliability { get; }

		public ConfigEntry<bool> CommonDisconnectGuards { get; }

		public ConfigEntry<bool> ExperimentalRejoinEnabled { get; }

		public ConfigEntry<int> RejoinPlayerTtlMilliseconds { get; }

		public ConfigEntry<int> RejoinEmptyRoomTtlMilliseconds { get; }

		public ConfigEntry<float> RejoinTimeoutSeconds { get; }

		public ConfigEntry<float> RejoinRetryDelaySeconds { get; }

		public ConfigEntry<bool> ShowOverlay { get; }

		public ConfigEntry<int> TargetFrameRate { get; }

		public ConfigEntry<int> VSyncCount { get; }

		public ConfigEntry<bool> AdaptiveEnabled { get; }

		public ConfigEntry<float> AdaptivePressureSeconds { get; }

		public ConfigEntry<float> AdaptiveRecoverySeconds { get; }

		public ConfigEntry<int> AntiAliasing { get; }

		public ConfigEntry<bool> Shadows { get; }

		public ConfigEntry<float> ShadowDistance { get; }

		public ConfigEntry<int> PixelLightCount { get; }

		public ConfigEntry<bool> AnisotropicFiltering { get; }

		public ConfigEntry<int> TextureLimit { get; }

		public ConfigEntry<float> LodBias { get; }

		public ConfigEntry<LocalVfxBudget> VfxBudget { get; }

		public ConfigEntry<int> ParticleLimit { get; }

		public ConfigEntry<float> TrailLifetimeMultiplier { get; }

		public ConfigEntry<float> VfxRescanSeconds { get; }

		public event Action? Changed;

		public PerformanceSettings(ConfigFile config)
		{
			Enabled = config.Bind<bool>("General", "Enabled", true, "Apply the selected local performance profile.");
			Profile = config.Bind<PerformanceProfile>("General", "Profile", PerformanceProfile.Balanced, "Vanilla restores the values captured at startup. Custom uses the fields below.");
			ReliabilityEnabled = config.Bind<bool>("Session Reliability", "Enabled", true, "Run the passive session recorder and reliability diagnostics independently of the FPS profile.");
			WriteReliabilityDiagnostics = config.Bind<bool>("Session Reliability", "WriteDiagnosticsToDisk", true, "Write bounded, privacy-safe disconnect diagnostics under BepInEx/config/ReksikPerformance.");
			RunInBackgroundForReliability = config.Bind<bool>("Session Reliability", "RunInBackground", true, "Keep the local Unity client active while ROUNDS is unfocused to reduce Alt-Tab stalls.");
			CommonDisconnectGuards = config.Bind<bool>("Session Reliability", "CommonDisconnectGuards", true, "Install narrow guards for confirmed disconnect-adjacent error storms. Restart required.");
			ExperimentalRejoinEnabled = config.Bind<bool>("Experimental Rejoin", "Enabled", false, "Opt-in non-host Photon transport rejoin experiment. Restart required; disabled by default.");
			RejoinPlayerTtlMilliseconds = config.Bind<int>("Experimental Rejoin", "PlayerTtlMilliseconds", 60000, "Inactive actor retention. Host and client must opt in before room creation.");
			RejoinEmptyRoomTtlMilliseconds = config.Bind<int>("Experimental Rejoin", "EmptyRoomTtlMilliseconds", 30000, "Empty Photon room retention for the experiment.");
			RejoinTimeoutSeconds = config.Bind<float>("Experimental Rejoin", "ReconnectTimeoutSeconds", 12f, "Bounded timeout per transport rejoin attempt.");
			RejoinRetryDelaySeconds = config.Bind<float>("Experimental Rejoin", "RetryDelaySeconds", 1f, "Delay before the one bounded retry.");
			ShowOverlay = config.Bind<bool>("Diagnostics", "ShowOverlay", false, "Show a compact local FPS, frame-time and memory overlay.");
			TargetFrameRate = config.Bind<int>("Frame Pacing", "TargetFrameRate", 120, "Custom target FPS. -1 uses Unity's platform default.");
			VSyncCount = config.Bind<int>("Frame Pacing", "VSyncCount", 0, "Custom VSync interval from 0 to 4.");
			AdaptiveEnabled = config.Bind<bool>("Adaptive", "Enabled", true, "Gradually reduce local VFX after sustained frame pressure.");
			AdaptivePressureSeconds = config.Bind<float>("Adaptive", "PressureSeconds", 4f, "Seconds below target before increasing the adaptive tier.");
			AdaptiveRecoverySeconds = config.Bind<float>("Adaptive", "RecoverySeconds", 10f, "Seconds of stable headroom before recovering one tier.");
			AntiAliasing = config.Bind<int>("Graphics", "AntiAliasing", 2, "Custom MSAA samples: 0, 2, 4, or 8.");
			Shadows = config.Bind<bool>("Graphics", "Shadows", true, "Enable local real-time shadows.");
			ShadowDistance = config.Bind<float>("Graphics", "ShadowDistance", 35f, "Local shadow distance.");
			PixelLightCount = config.Bind<int>("Graphics", "PixelLightCount", 2, "Maximum local pixel lights.");
			AnisotropicFiltering = config.Bind<bool>("Graphics", "AnisotropicFiltering", true, "Force anisotropic texture filtering.");
			TextureLimit = config.Bind<int>("Graphics", "TextureLimit", 0, "Texture downscale level from 0 to 3.");
			LodBias = config.Bind<float>("Graphics", "LodBias", 1f, "Local level-of-detail bias.");
			VfxBudget = config.Bind<LocalVfxBudget>("VFX", "Budget", LocalVfxBudget.Reduced, "Local-only particle and trail budget.");
			ParticleLimit = config.Bind<int>("VFX", "ParticleLimitPerSystem", 512, "Maximum particles per active particle system.");
			TrailLifetimeMultiplier = config.Bind<float>("VFX", "TrailLifetimeMultiplier", 0.75f, "Local trail lifetime multiplier.");
			VfxRescanSeconds = config.Bind<float>("VFX", "RescanSeconds", 12f, "Seconds between VFX discovery passes. Adaptive tier changes reuse tracked objects without rescanning.");
			Subscribe<bool>(Enabled);
			Subscribe<PerformanceProfile>(Profile);
			Subscribe<bool>(ReliabilityEnabled);
			Subscribe<bool>(WriteReliabilityDiagnostics);
			Subscribe<bool>(RunInBackgroundForReliability);
			Subscribe<bool>(CommonDisconnectGuards);
			Subscribe<bool>(ExperimentalRejoinEnabled);
			Subscribe<int>(RejoinPlayerTtlMilliseconds);
			Subscribe<int>(RejoinEmptyRoomTtlMilliseconds);
			Subscribe<float>(RejoinTimeoutSeconds);
			Subscribe<float>(RejoinRetryDelaySeconds);
			Subscribe<bool>(ShowOverlay);
			Subscribe<int>(TargetFrameRate);
			Subscribe<int>(VSyncCount);
			Subscribe<bool>(AdaptiveEnabled);
			Subscribe<float>(AdaptivePressureSeconds);
			Subscribe<float>(AdaptiveRecoverySeconds);
			Subscribe<int>(AntiAliasing);
			Subscribe<bool>(Shadows);
			Subscribe<float>(ShadowDistance);
			Subscribe<int>(PixelLightCount);
			Subscribe<bool>(AnisotropicFiltering);
			Subscribe<int>(TextureLimit);
			Subscribe<float>(LodBias);
			Subscribe<LocalVfxBudget>(VfxBudget);
			Subscribe<int>(ParticleLimit);
			Subscribe<float>(TrailLifetimeMultiplier);
			Subscribe<float>(VfxRescanSeconds);
		}

		public void SetEnabled(bool value)
		{
			Enabled.Value = value;
		}

		public void SetOverlay(bool value)
		{
			ShowOverlay.Value = value;
		}

		public void SetReliabilityEnabled(bool value)
		{
			ReliabilityEnabled.Value = value;
		}

		public void SetWriteReliabilityDiagnostics(bool value)
		{
			WriteReliabilityDiagnostics.Value = value;
		}

		public void SetRunInBackgroundForReliability(bool value)
		{
			RunInBackgroundForReliability.Value = value;
		}

		public void SetCommonDisconnectGuards(bool value)
		{
			CommonDisconnectGuards.Value = value;
		}

		public void SetExperimentalRejoinEnabled(bool value)
		{
			ExperimentalRejoinEnabled.Value = value;
		}

		public void SetAdaptiveEnabled(bool value)
		{
			AdaptiveEnabled.Value = value;
		}

		public void SetShadows(bool value)
		{
			SetCustom(Shadows, value);
		}

		public void SetAnisotropicFiltering(bool value)
		{
			SetCustom(AnisotropicFiltering, value);
		}

		public void SetTargetFrameRate(int value)
		{
			SetCustom(TargetFrameRate, (value < 0) ? (-1) : Clamp(value, 30, 1000));
		}

		public void SetVSyncCount(int value)
		{
			SetCustom(VSyncCount, Clamp(value, 0, 4));
		}

		public void SetAntiAliasing(int value)
		{
			int value2 = ((value >= 8) ? 8 : ((value >= 4) ? 4 : ((value >= 2) ? 2 : 0)));
			SetCustom(AntiAliasing, value2);
		}

		public void SetParticleLimit(int value)
		{
			SetCustom(ParticleLimit, Clamp(value, 16, 10000));
		}

		public void SetTrailLifetimeMultiplier(float value)
		{
			SetCustom(TrailLifetimeMultiplier, Clamp(value, 0f, 1.5f));
		}

		public void SetVfxBudget(LocalVfxBudget value)
		{
			SetCustom(VfxBudget, value);
		}

		public void ApplyProfile(PerformanceProfile profile)
		{
			_suppressEvents = true;
			try
			{
				Profile.Value = profile;
				switch (profile)
				{
				case PerformanceProfile.MaxFps:
					SetProfileValues(-1, 0, 0, shadows: false, 0f, 0, anisotropic: false, 0, 0.65f, LocalVfxBudget.Minimal, 128, 0.35f);
					break;
				case PerformanceProfile.Balanced:
					SetProfileValues(120, 0, 2, shadows: true, 35f, 2, anisotropic: true, 0, 1f, LocalVfxBudget.Reduced, 512, 0.75f);
					break;
				case PerformanceProfile.Competitive:
					SetProfileValues(240, 0, 0, shadows: false, 10f, 0, anisotropic: false, 0, 0.75f, LocalVfxBudget.Minimal, 192, 0.45f);
					break;
				case PerformanceProfile.Potato:
					SetProfileValues(90, 0, 0, shadows: false, 0f, 0, anisotropic: false, 1, 0.5f, LocalVfxBudget.Minimal, 96, 0.25f);
					break;
				case PerformanceProfile.Cinematic:
					SetProfileValues(120, 0, 8, shadows: true, 100f, 8, anisotropic: true, 0, 2f, LocalVfxBudget.Full, 10000, 1f);
					break;
				}
			}
			finally
			{
				_suppressEvents = false;
			}
			this.Changed?.Invoke();
		}

		private void SetProfileValues(int targetFps, int vSync, int antiAliasing, bool shadows, float shadowDistance, int pixelLights, bool anisotropic, int textureLimit, float lodBias, LocalVfxBudget vfxBudget, int particleLimit, float trailMultiplier)
		{
			TargetFrameRate.Value = targetFps;
			VSyncCount.Value = vSync;
			AntiAliasing.Value = antiAliasing;
			Shadows.Value = shadows;
			ShadowDistance.Value = shadowDistance;
			PixelLightCount.Value = pixelLights;
			AnisotropicFiltering.Value = anisotropic;
			TextureLimit.Value = textureLimit;
			LodBias.Value = lodBias;
			VfxBudget.Value = vfxBudget;
			ParticleLimit.Value = particleLimit;
			TrailLifetimeMultiplier.Value = trailMultiplier;
		}

		private void SetCustom<T>(ConfigEntry<T> entry, T value)
		{
			_suppressEvents = true;
			try
			{
				Profile.Value = PerformanceProfile.Custom;
				entry.Value = value;
			}
			finally
			{
				_suppressEvents = false;
			}
			this.Changed?.Invoke();
		}

		private void Subscribe<T>(ConfigEntry<T> entry)
		{
			entry.SettingChanged += delegate
			{
				if (!_suppressEvents)
				{
					this.Changed?.Invoke();
				}
			};
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return min;
			}
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.reksikperformance.rounds", "ReksikPerformance", "0.3.1")]
	[BepInProcess("Rounds.exe")]
	public sealed class ReksikPerformancePlugin : BaseUnityPlugin
	{
		public const string ModId = "com.reksikperformance.rounds";

		public const string ModName = "ReksikPerformance";

		public const string Version = "0.3.1";

		private Harmony? _harmony;

		private GraphicsController? _graphics;

		private MetricsOverlay? _overlay;

		private bool _reliabilityStarted;

		private bool _lastReliabilityEnabled;

		private bool _lastWriteDiagnostics;

		internal PerformanceSettings Settings { get; private set; }

		internal CompatibilityGuard Compatibility { get; private set; }

		internal VfxBudgetController Vfx { get; private set; }

		internal MetricsSampler Metrics { get; private set; }

		internal AdaptivePerformanceController Adaptive { get; private set; }

		private void Awake()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			Compatibility = new CompatibilityGuard();
			Settings = new PerformanceSettings(((BaseUnityPlugin)this).Config);
			Metrics = new MetricsSampler();
			Adaptive = new AdaptivePerformanceController();
			_overlay = new MetricsOverlay();
			_graphics = new GraphicsController(((BaseUnityPlugin)this).Logger);
			Vfx = new VfxBudgetController(((BaseUnityPlugin)this).Logger);
			Settings.Changed += ApplySettings;
			ApplySettings();
			_harmony = new Harmony("com.reksikperformance.rounds");
			if (Settings.CommonDisconnectGuards.Value)
			{
				ReliabilityGuard.Install(_harmony, ((BaseUnityPlugin)this).Logger);
			}
			ExperimentalRejoin.Install(_harmony, ((BaseUnityPlugin)this).Logger, new ExperimentalRejoinOptions
			{
				Enabled = Settings.ExperimentalRejoinEnabled.Value,
				PlayerTtlMilliseconds = Settings.RejoinPlayerTtlMilliseconds.Value,
				EmptyRoomTtlMilliseconds = Settings.RejoinEmptyRoomTtlMilliseconds.Value,
				ReconnectTimeoutSeconds = Settings.RejoinTimeoutSeconds.Value,
				RetryDelaySeconds = Settings.RejoinRetryDelaySeconds.Value
			});
			ExperimentalRejoinController.Install(((BaseUnityPlugin)this).Logger);
			SceneManager.sceneLoaded += OnSceneLoaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("ReksikPerformance 0.3.1 loaded. " + Compatibility.StatusText));
		}

		private void Start()
		{
			PerformanceMenu.Register(this);
		}

		private void Update()
		{
			Vfx.Tick();
			Metrics.Tick(Settings.Profile.Value, Vfx.TrackedParticleSystems, Vfx.TrackedTrails, Compatibility.StatusText, Adaptive.StatusText);
			Adaptive.Tick(Settings, Metrics, Vfx, Compatibility);
			PerformanceMenu.Tick();
		}

		private void OnGUI()
		{
			if (Settings.ShowOverlay.Value && _overlay != null)
			{
				_overlay.Draw(Metrics.OverlayText);
			}
		}

		private void OnDestroy()
		{
			Settings.Changed -= ApplySettings;
			Vfx.RestoreAll();
			_graphics?.Restore();
			_overlay?.Dispose();
			SessionReliabilityApi.Stop();
			ExperimentalRejoinController.Shutdown();
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void ApplySettings()
		{
			_graphics?.Apply(Settings, Compatibility);
			Vfx.Apply(Settings, Compatibility);
			ApplyReliabilitySettings();
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			Vfx.NotifySceneChanged();
		}

		private void ApplyReliabilitySettings()
		{
			bool value = Settings.ReliabilityEnabled.Value;
			bool value2 = Settings.WriteReliabilityDiagnostics.Value;
			if (!_reliabilityStarted || value != _lastReliabilityEnabled || value2 != _lastWriteDiagnostics)
			{
				SessionReliabilityApi.Start((BaseUnityPlugin)(object)this, ((BaseUnityPlugin)this).Logger, new SessionReliabilityOptions
				{
					Enabled = value,
					WriteDiagnosticsToDisk = value2
				});
				_reliabilityStarted = true;
				_lastReliabilityEnabled = value;
				_lastWriteDiagnostics = value2;
			}
		}
	}
	internal sealed class VfxBudgetController
	{
		private readonly struct ParticleState
		{
			public ParticleSystem System { get; }

			public int MaxParticles { get; }

			public float RateOverTimeMultiplier { get; }

			public float RateOverDistanceMultiplier { get; }

			public ParticleState(ParticleSystem system, int maxParticles, float rateOverTimeMultiplier, float rateOverDistanceMultiplier)
			{
				System = system;
				MaxParticles = maxParticles;
				RateOverTimeMultiplier = rateOverTimeMultiplier;
				RateOverDistanceMultiplier = rateOverDistanceMultiplier;
			}
		}

		private readonly struct TrailState
		{
			public TrailRenderer Renderer { get; }

			public float Lifetime { get; }

			public TrailState(TrailRenderer renderer, float lifetime)
			{
				Renderer = renderer;
				Lifetime = lifetime;
			}
		}

		private readonly struct LightState
		{
			public Light Component { get; }

			public LightRenderMode RenderMode { get; }

			public LightShadows Shadows { get; }

			public LightState(Light component, LightRenderMode renderMode, LightShadows shadows)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				Component = component;
				RenderMode = renderMode;
				Shadows = shadows;
			}
		}

		private const int ReducedLightLimit = 24;

		private const int MinimalLightLimit = 12;

		private readonly Dictionary<int, ParticleState> _particles = new Dictionary<int, ParticleState>(128);

		private readonly Dictionary<int, TrailState> _trails = new Dictionary<int, TrailState>(128);

		private readonly Dictionary<int, LightState> _lights = new Dictionary<int, LightState>(64);

		private readonly List<int> _deadParticleIds = new List<int>(32);

		private readonly List<int> _deadTrailIds = new List<int>(32);

		private readonly List<int> _deadLightIds = new List<int>(16);

		private readonly ManualLogSource _logger;

		private bool _active;

		private bool _staticBudgetEnabled;

		private bool _adaptiveEnabled;

		private int _baseParticleLimit;

		private float _baseTrailMultiplier;

		private int _baseLightLimit;

		private int _particleLimit;

		private float _particleRetention = 1f;

		private float _emissionRetention = 1f;

		private float _trailMultiplier = 1f;

		private int _lightLimit = int.MaxValue;

		private int _adaptiveTier;

		private float _scanInterval;

		private float _nextScanAt;

		public int TrackedParticleSystems => _particles.Count;

		public int TrackedTrails => _trails.Count;

		public int TrackedLights => _lights.Count;

		public int AdaptiveTier => _adaptiveTier;

		private bool IsBudgetingNow
		{
			get
			{
				if (!_staticBudgetEnabled)
				{
					if (_adaptiveEnabled)
					{
						return _adaptiveTier > 0;
					}
					return false;
				}
				return true;
			}
		}

		public VfxBudgetController(ManualLogSource logger)
		{
			_logger = logger;
		}

		public void Apply(PerformanceSettings settings, CompatibilityGuard compatibility)
		{
			RestoreAll();
			bool flag = settings.Enabled.Value && settings.Profile.Value != PerformanceProfile.Vanilla && !compatibility.PerformanceImprovementsDetected;
			_staticBudgetEnabled = settings.VfxBudget.Value != LocalVfxBudget.Full;
			_adaptiveEnabled = settings.AdaptiveEnabled.Value;
			_active = flag && (_staticBudgetEnabled || _adaptiveEnabled);
			if (!_adaptiveEnabled || !flag)
			{
				_adaptiveTier = 0;
			}
			_baseParticleLimit = (_staticBudgetEnabled ? Clamp(settings.ParticleLimit.Value, 16, 10000) : int.MaxValue);
			_baseTrailMultiplier = (_staticBudgetEnabled ? Clamp(settings.TrailLifetimeMultiplier.Value, 0f, 1.5f) : 1f);
			_baseLightLimit = ResolveBaseLightLimit(settings.VfxBudget.Value);
			_scanInterval = Clamp(settings.VfxRescanSeconds.Value, 10f, 30f);
			_nextScanAt = 0f;
			UpdateEffectiveLimits();
			if (_active && IsBudgetingNow)
			{
				ScanAndApply();
			}
			else if (compatibility.PerformanceImprovementsDetected)
			{
				_logger.LogInfo((object)"VFX budgeting deferred to Performance Improvements compatibility mode.");
			}
		}

		public void Tick()
		{
			if (_active && IsBudgetingNow && !(Time.unscaledTime < _nextScanAt))
			{
				ScanAndApply();
			}
		}

		public void SetAdaptiveTier(int tier)
		{
			int num = Clamp(tier, 0, 3);
			if (_adaptiveTier == num)
			{
				return;
			}
			_adaptiveTier = num;
			UpdateEffectiveLimits();
			if (_active)
			{
				ApplyToTrackedObjects();
				if (IsBudgetingNow)
				{
					_nextScanAt = 0f;
				}
				else
				{
					ClearTracking();
				}
			}
		}

		public void NotifySceneChanged()
		{
			_nextScanAt = 0f;
		}

		private void UpdateEffectiveLimits()
		{
			switch (_adaptiveTier)
			{
			case 1:
				_particleRetention = 0.8f;
				_emissionRetention = 0.9f;
				_trailMultiplier = _baseTrailMultiplier * 0.85f;
				_lightLimit = Min(_baseLightLimit, 20);
				break;
			case 2:
				_particleRetention = 0.6f;
				_emissionRetention = 0.72f;
				_trailMultiplier = _baseTrailMultiplier * 0.65f;
				_lightLimit = Min(_baseLightLimit, 10);
				break;
			case 3:
				_particleRetention = 0.4f;
				_emissionRetention = 0.55f;
				_trailMultiplier = _baseTrailMultiplier * 0.45f;
				_lightLimit = Min(_baseLightLimit, 5);
				break;
			default:
				_particleRetention = 1f;
				_emissionRetention = 1f;
				_trailMultiplier = _baseTrailMultiplier;
				_lightLimit = _baseLightLimit;
				break;
			}
			_particleLimit = _baseParticleLimit;
		}

		private void ApplyToTrackedObjects()
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Invalid comparison between Unknown and I4
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Invalid comparison between Unknown and I4
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			foreach (ParticleState value in _particles.Values)
			{
				ApplyParticleState(value);
			}
			foreach (TrailState value2 in _trails.Values)
			{
				if (!((Object)(object)value2.Renderer == (Object)null))
				{
					float num = value2.Lifetime * _trailMultiplier;
					if (Mathf.Abs(value2.Renderer.time - num) > 0.0001f)
					{
						value2.Renderer.time = num;
					}
				}
			}
			int num2 = 0;
			foreach (LightState value3 in _lights.Values)
			{
				Light component = value3.Component;
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				bool flag = (int)value3.RenderMode != 2 || (int)value3.Shadows > 0;
				if (!((Behaviour)component).enabled || !flag || num2 < _lightLimit)
				{
					if (((Behaviour)component).enabled && flag)
					{
						num2++;
					}
					component.renderMode = value3.RenderMode;
					component.shadows = value3.Shadows;
				}
				else
				{
					component.renderMode = (LightRenderMode)2;
					component.shadows = (LightShadows)0;
				}
			}
		}

		private void ApplyParticleState(ParticleState state)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)state.System == (Object)null))
			{
				int num = Mathf.CeilToInt((float)state.MaxParticles * _particleRetention);
				if (state.MaxParticles > 0 && num < 1)
				{
					num = 1;
				}
				int left = Min(state.MaxParticles, _particleLimit);
				left = Min(left, num);
				MainModule main = state.System.main;
				if (((MainModule)(ref main)).maxParticles != left)
				{
					((MainModule)(ref main)).maxParticles = left;
				}
				EmissionModule emission = state.System.emission;
				float num2 = state.RateOverTimeMultiplier * _emissionRetention;
				float num3 = state.RateOverDistanceMultiplier * _emissionRetention;
				if (Mathf.Abs(((EmissionModule)(ref emission)).rateOverTimeMultiplier - num2) > 0.0001f)
				{
					((EmissionModule)(ref emission)).rateOverTimeMultiplier = num2;
				}
				if (Mathf.Abs(((EmissionModule)(ref emission)).rateOverDistanceMultiplier - num3) > 0.0001f)
				{
					((EmissionModule)(ref emission)).rateOverDistanceMultiplier = num3;
				}
			}
		}

		public void RestoreAll()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			foreach (ParticleState value in _particles.Values)
			{
				if (!((Object)(object)value.System == (Object)null))
				{
					MainModule main = value.System.main;
					((MainModule)(ref main)).maxParticles = value.MaxParticles;
					EmissionModule emission = value.System.emission;
					((EmissionModule)(ref emission)).rateOverTimeMultiplier = value.RateOverTimeMultiplier;
					((EmissionModule)(ref emission)).rateOverDistanceMultiplier = value.RateOverDistanceMultiplier;
				}
			}
			foreach (TrailState value2 in _trails.Values)
			{
				if ((Object)(object)value2.Renderer != (Object)null)
				{
					value2.Renderer.time = value2.Lifetime;
				}
			}
			foreach (LightState value3 in _lights.Values)
			{
				if ((Object)(object)value3.Component != (Object)null)
				{
					value3.Component.renderMode = value3.RenderMode;
					value3.Component.shadows = value3.Shadows;
				}
			}
			ClearTracking();
			_active = false;
		}

		private void ScanAndApply()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Invalid comparison between Unknown and I4
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: 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)
			_nextScanAt = Time.unscaledTime + _scanInterval;
			PurgeDestroyed();
			ParticleSystem[] array = Resources.FindObjectsOfTypeAll<ParticleSystem>();
			Scene scene;
			foreach (ParticleSystem val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				scene = ((Component)val).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					int instanceID = ((Object)val).GetInstanceID();
					if (!_particles.TryGetValue(instanceID, out var value))
					{
						MainModule main = val.main;
						EmissionModule emission = val.emission;
						value = new ParticleState(val, ((MainModule)(ref main)).maxParticles, ((EmissionModule)(ref emission)).rateOverTimeMultiplier, ((EmissionModule)(ref emission)).rateOverDistanceMultiplier);
						_particles.Add(instanceID, value);
					}
				}
			}
			TrailRenderer[] array2 = Resources.FindObjectsOfTypeAll<TrailRenderer>();
			foreach (TrailRenderer val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				scene = ((Component)val2).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					int instanceID2 = ((Object)val2).GetInstanceID();
					if (!_trails.TryGetValue(instanceID2, out var value2))
					{
						value2 = new TrailState(val2, val2.time);
						_trails.Add(instanceID2, value2);
					}
				}
			}
			Light[] array3 = Resources.FindObjectsOfTypeAll<Light>();
			foreach (Light val3 in array3)
			{
				if ((Object)(object)val3 == (Object)null || (int)val3.type == 1)
				{
					continue;
				}
				scene = ((Component)val3).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					int instanceID3 = ((Object)val3).GetInstanceID();
					if (!_lights.TryGetValue(instanceID3, out var value3))
					{
						value3 = new LightState(val3, val3.renderMode, val3.shadows);
						_lights.Add(instanceID3, value3);
					}
				}
			}
			ApplyToTrackedObjects();
		}

		private void PurgeDestroyed()
		{
			_deadParticleIds.Clear();
			foreach (KeyValuePair<int, ParticleState> particle in _particles)
			{
				if ((Object)(object)particle.Value.System == (Object)null)
				{
					_deadParticleIds.Add(particle.Key);
				}
			}
			foreach (int deadParticleId in _deadParticleIds)
			{
				_particles.Remove(deadParticleId);
			}
			_deadTrailIds.Clear();
			foreach (KeyValuePair<int, TrailState> trail in _trails)
			{
				if ((Object)(object)trail.Value.Renderer == (Object)null)
				{
					_deadTrailIds.Add(trail.Key);
				}
			}
			foreach (int deadTrailId in _deadTrailIds)
			{
				_trails.Remove(deadTrailId);
			}
			_deadLightIds.Clear();
			foreach (KeyValuePair<int, LightState> light in _lights)
			{
				if ((Object)(object)light.Value.Component == (Object)null)
				{
					_deadLightIds.Add(light.Key);
				}
			}
			foreach (int deadLightId in _deadLightIds)
			{
				_lights.Remove(deadLightId);
			}
		}

		private void ClearTracking()
		{
			_particles.Clear();
			_trails.Clear();
			_lights.Clear();
			_deadParticleIds.Clear();
			_deadTrailIds.Clear();
			_deadLightIds.Clear();
		}

		private static int ResolveBaseLightLimit(LocalVfxBudget budget)
		{
			return budget switch
			{
				LocalVfxBudget.Reduced => 24, 
				LocalVfxBudget.Minimal => 12, 
				_ => int.MaxValue, 
			};
		}

		private static int Min(int left, int right)
		{
			if (left >= right)
			{
				return right;
			}
			return left;
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return min;
			}
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
}
namespace ReksikPerformance.Rejoin
{
	public static class ExperimentalRejoin
	{
		private const string HarmonyIdRwf = "io.olavim.rounds.rwf";

		private const string HarmonyIdUnbound = "com.willis.rounds.unbound";

		private static readonly object Gate = new object();

		private static readonly HashSet<string> RecoverableCauses = new HashSet<string>(StringComparer.Ordinal) { "Exception", "ServerTimeout", "ClientTimeout" };

		private static ManualLogSource? logger;

		private static ExperimentalRejoinOptions options = new ExperimentalRejoinOptions();

		private static ExperimentalRejoinBehaviour? behaviour;

		private static Type? photonNetworkType;

		private static Type? photonPlayerType;

		private static Type? roomOptionsType;

		private static PropertyInfo? photonInRoom;

		private static PropertyInfo? photonIsConnected;

		private static PropertyInfo? photonIsConnectedAndReady;

		private static PropertyInfo? photonIsMasterClient;

		private static MethodInfo? reconnectAndRejoin;

		private static MethodInfo? photonDisconnect;

		private static MethodInfo? networkRestart;

		private static MemberInfo? playerTtlMember;

		private static MemberInfo? emptyRoomTtlMember;

		private static PropertyInfo? playerIsInactive;

		private static bool installed;

		private static bool criticalHooksReady;

		private static ExperimentalRejoinState state = ExperimentalRejoinState.Disabled;

		private static string detail = "Disabled by default.";

		private static bool needsWarmStateRestore;

		private static int roomsPrepared;

		private static int attemptsStarted;

		private static int successfulRejoins;

		private static int failedRejoins;

		private static int suppressedInactiveLeaveCallbacks;

		private static int rejectedDisconnects;

		public static bool IsInstalled => installed;

		public static bool IsEnabled
		{
			get
			{
				if (installed && criticalHooksReady)
				{
					return options.Enabled;
				}
				return false;
			}
		}

		public static ExperimentalRejoinState State => state;

		public static bool NeedsWarmStateRestore => needsWarmStateRestore;

		public static string StatusText => state.ToString() + ": " + detail;

		public static ExperimentalRejoinStatus Status
		{
			get
			{
				lock (Gate)
				{
					return new ExperimentalRejoinStatus(state, detail, installed, IsEnabled, needsWarmStateRestore, roomsPrepared, attemptsStarted, successfulRejoins, failedRejoins, suppressedInactiveLeaveCallbacks, rejectedDisconnects);
				}
			}
		}

		internal static bool PhotonInRoom => ReadPhotonBool(photonInRoom);

		internal static bool PhotonIsConnected => ReadPhotonBool(photonIsConnected);

		internal static bool PhotonIsConnectedAndReady => ReadPhotonBool(photonIsConnectedAndReady);

		internal static bool PhotonIsMaster => ReadPhotonBool(photonIsMasterClient);

		internal static ExperimentalRejoinOptions Options => options;

		public static void Install(Harmony harmony, ManualLogSource suppliedLogger, ExperimentalRejoinOptions suppliedOptions)
		{
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			if (harmony == null)
			{
				throw new ArgumentNullException("harmony");
			}
			if (suppliedLogger == null)
			{
				throw new ArgumentNullException("suppliedLogger");
			}
			if (suppliedOptions == null)
			{
				throw new ArgumentNullException("suppliedOptions");
			}
			lock (Gate)
			{
				if (installed)
				{
					return;
				}
				logger = suppliedLogger;
				options = suppliedOptions;
				options.Normalize();
				SetState(ExperimentalRejoinState.Installing, "Resolving exact Photon and ROUNDS hooks.");
				if (!ResolveCriticalSymbols())
				{
					installed = true;
					criticalHooksReady = false;
					SetState(ExperimentalRejoinState.FailedClosed, "Exact Photon/ROUNDS symbols were unavailable; no disconnect flow was intercepted.");
					logger.LogWarning((object)"Experimental Rejoin failed closed: required runtime symbols were unavailable.");
					return;
				}
				bool flag = PatchRoomCreation(harmony);
				bool flag2 = PatchExact(harmony, FindExactMethod(FindType("NetworkConnectionHandler"), "OnDisconnected", false, "Photon.Realtime.DisconnectCause"), "RecoverableDisconnectPrefix", 800, critical: true);
				bool flag3 = PatchExact(harmony, FindExactMethod(FindType("NetworkConnectionHandler"), "OnJoinRoomFailed", false, "System.Int16", "System.String"), "JoinRoomFailedPrefix", 800, critical: true);
				bool flag4 = PatchInactivePlayerLeaveCallbacks(harmony);
				criticalHooksReady = flag && flag2 && flag3 && flag4;
				installed = true;
				if (!criticalHooksReady)
				{
					SetState(ExperimentalRejoinState.FailedClosed, "One or more critical hooks were missing; automatic rejoin remains inactive.");
					logger.LogWarning((object)"Experimental Rejoin failed closed because its complete critical hook set was not available.");
					return;
				}
				GameObject val = new GameObject("ReksikPerformance.ExperimentalRejoin");
				Object.DontDestroyOnLoad((Object)val);
				behaviour = val.AddComponent<ExperimentalRejoinBehaviour>();
				behaviour.Initialize();
				if (options.Enabled)
				{
					SetState(ExperimentalRejoinState.Armed, "Opt-in active for non-host transport loss; warm state is recovered only at the next point.");
					logger.LogWarning((object)"EXPERIMENTAL Rejoin enabled. It does not provide seamless host recovery or mid-point deck restoration.");
				}
				else
				{
					SetState(ExperimentalRejoinState.Disabled, "Installed but disabled by default. Vanilla disconnect behavior is unchanged.");
					logger.LogInfo((object)"Experimental Rejoin installed in disabled state.");
				}
			}
		}

		public static void AcknowledgeWarmStateRestoredAtPointBoundary()
		{
			lock (Gate)
			{
				needsWarmStateRestore = false;
				if (IsEnabled && state == ExperimentalRejoinState.RejoinedWarmStatePending)
				{
					SetState(ExperimentalRejoinState.Armed, "Warm state restore acknowledged at a point boundary.");
				}
			}
		}

		internal static void RejectWarmStateAtPointBoundary(string reason)
		{
			lock (Gate)
			{
				needsWarmStateRestore = false;
				SetState(IsEnabled ? ExperimentalRejoinState.Armed : ExperimentalRejoinState.Disabled, "Warm-state validation rejected at a safe point boundary. Future receipts may arm again. " + reason);
			}
		}

		internal static bool ReadPhotonBool(PropertyInfo? property, bool fallback = false)
		{
			if (property == null)
			{
				return fallback;
			}
			try
			{
				return (property.GetValue(null, null) is bool flag) ? flag : fallback;
			}
			catch
			{
				return fallback;
			}
		}

		internal static bool InvokeReconnectAndRejoin()
		{
			if (reconnectAndRejoin == null)
			{
				return false;
			}
			try
			{
				object obj = reconnectAndRejoin.Invoke(null, null);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception exception)
			{
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogWarning((object)("ReconnectAndRejoin invocation failed: " + Unwrap(exception).Message));
				}
				return false;
			}
		}

		internal static void DisconnectForRetry()
		{
			if (photonDisconnect == null)
			{
				return;
			}
			try
			{
				photonDisconnect.Invoke(null, null);
			}
			catch (Exception exception)
			{
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)("Could not reset Photon before the bounded retry: " + Unwrap(exception).Message));
				}
			}
		}

		internal static void MarkAttemptStarted(int number)
		{
			lock (Gate)
			{
				attemptsStarted++;
				SetState((number == 1) ? ExperimentalRejoinState.Reconnecting : ExperimentalRejoinState.Retrying, "Reconnect attempt " + number + " of 2.");
			}
		}

		internal static void MarkWaitingForRoom(int number)
		{
			lock (Gate)
			{
				SetState(ExperimentalRejoinState.WaitingForRoom, "Photon accepted attempt " + number + "; waiting for the prior room.");
			}
		}

		internal static void MarkSuccess()
		{
			lock (Gate)
			{
				successfulRejoins++;
				needsWarmStateRestore = true;
				SetState(ExperimentalRejoinState.RejoinedWarmStatePending, "Transport rejoined. Mid-point state is unsafe; recover cards/player state at the next point.");
			}
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogWarning((object)"Photon rejoin succeeded, but warm gameplay state is pending. Continue safely from the next point only.");
			}
			ExperimentalRejoinController.NotifyTransportRejoined();
		}

		internal static void MarkFailureAndFallback(object handler, string reason)
		{
			lock (Gate)
			{
				failedRejoins++;
				SetState(ExperimentalRejoinState.FallingBackToVanilla, reason);
			}
			ManualLogSource? obj = logger;
			if (obj != null)
			{
				obj.LogWarning((object)"Experimental rejoin exhausted its bounded retry. Falling back to vanilla restart.");
			}
			ExperimentalRejoinController.NotifyAttemptAborted(reason);
			try
			{
				networkRestart?.Invoke(handler, null);
			}
			catch (Exception exception)
			{
				SetState(ExperimentalRejoinState.FailedClosed, "Vanilla NetworkRestart invocation failed after rejoin exhaustion.");
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogError((object)("Vanilla NetworkRestart fallback failed: " + Unwrap(exception)));
				}
			}
		}

		internal static void AbortForFatalCause(string cause)
		{
			lock (Gate)
			{
				rejectedDisconnects++;
				SetState(ExperimentalRejoinState.FallingBackToVanilla, "Reconnect aborted for non-recoverable cause: " + cause + ".");
			}
			behaviour?.AbortCurrentAttempt();
			ExperimentalRejoinController.NotifyAttemptAborted("Reconnect aborted for non-recoverable cause: " + cause + ".");
		}

		private static bool RoomCreationPrefix(object[] __args)
		{
			if (!IsEnabled || roomOptionsType == null)
			{
				return true;
			}
			object obj = __args.FirstOrDefault((object arg) => arg != null && roomOptionsType.IsInstanceOfType(arg));
			if (obj == null)
			{
				return true;
			}
			try
			{
				SetIntMember(playerTtlMember, obj, options.PlayerTtlMilliseconds);
				SetIntMember(emptyRoomTtlMember, obj, options.EmptyRoomTtlMilliseconds);
				lock (Gate)
				{
					roomsPrepared++;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogWarning((object)("Could not apply Photon room TTLs; vanilla room options were kept: " + ex.Message));
				}
			}
			return true;
		}

		private static bool InactivePlayerLeftPrefix(object[] __args)
		{
			if (!IsEnabled || photonPlayerType == null || playerIsInactive == null)
			{
				return true;
			}
			object obj = __args.FirstOrDefault((object arg) => arg != null && photonPlayerType.IsInstanceOfType(arg));
			if (obj == null)
			{
				return true;
			}
			try
			{
				object value = playerIsInactive.GetValue(obj, null);
				bool flag = default(bool);
				int num;
				if (value is bool)
				{
					flag = (bool)value;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) == 0)
				{
					return true;
				}
				lock (Gate)
				{
					suppressedInactiveLeaveCallbacks++;
				}
				return false;
			}
			catch
			{
				return true;
			}
		}

		private static bool RecoverableDisconnectPrefix(object __instance, object[] __args)
		{
			if (!IsEnabled || (Object)(object)behaviour == (Object)null)
			{
				return true;
			}
			string text = ((__args.Length != 0 && __args[0] != null) ? (__args[0].ToString() ?? "Unknown") : "Unknown");
			if (!RecoverableCauses.Contains(text))
			{
				if (string.Equals(text, "DisconnectByClientLogic", StringComparison.Ordinal) && behaviour.IsResettingTransportForRetry)
				{
					return false;
				}
				if (behaviour.IsAttemptActive)
				{
					AbortForFatalCause(text);
				}
				else
				{
					lock (Gate)
					{
						rejectedDisconnects++;
					}
				}
				return true;
			}
			bool isAttemptActive = behaviour.IsAttemptActive;
			if (!isAttemptActive && !ExperimentalRejoinController.TryGetWarmStateRejoinAdmission(out string reasonCode, out string reasonDetail))
			{
				lock (Gate)
				{
					rejectedDisconnects++;
				}
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)("Experimental rejoin declined [warm-receipt=" + reasonCode + "]: " + reasonDetail));
				}
				return true;
			}
			if (behaviour.TryBegin(__instance, text))
			{
				if (!isAttemptActive)
				{
					ExperimentalRejoinController.NotifyRecoverableDisconnectAccepted(text);
				}
				return false;
			}
			lock (Gate)
			{
				rejectedDisconnects++;
			}
			return true;
		}

		private static bool JoinRoomFailedPrefix()
		{
			if (!((Object)(object)behaviour == (Object)null))
			{
				return !behaviour.IsAttemptActive;
			}
			return true;
		}

		private static bool ResolveCriticalSymbols()
		{
			photonNetworkType = FindType("Photon.Pun.PhotonNetwork");
			photonPlayerType = FindType("Photon.Realtime.Player");
			roomOptionsType = FindType("Photon.Realtime.RoomOptions");
			Type type = FindType("NetworkConnectionHandler");
			if (photonNetworkType == null || photonPlayerType == null || roomOptionsType == null || type == null)
			{
				return false;
			}
			photonInRoom = FindStaticBoolProperty(photonNetworkType, "InRoom");
			photonIsConnected = FindStaticBoolProperty(photonNetworkType, "IsConnected");
			photonIsConnectedAndReady = FindStaticBoolProperty(photonNetworkType, "IsConnectedAndReady");
			photonIsMasterClient = FindStaticBoolProperty(photonNetworkType, "IsMasterClient");
			reconnectAndRejoin = FindExactMethod(photonNetworkType, "ReconnectAndRejoin", true);
			photonDisconnect = FindExactMethod(photonNetworkType, "Disconnect", true);
			networkRestart = FindExactMethod(type, "NetworkRestart", false);
			playerTtlMember = FindIntMember(roomOptionsType, "PlayerTtl");
			emptyRoomTtlMember = FindIntMember(roomOptionsType, "EmptyRoomTtl");
			playerIsInactive = photonPlayerType.GetProperty("IsInactive", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (photonInRoom != null && photonIsConnected != null && photonIsConnectedAndReady != null && photonIsMasterClient != null && reconnectAndRejoin != null && reconnectAndRejoin.ReturnType == typeof(bool) && photonDisconnect != null && photonDisconnect.ReturnType == typeof(void) && networkRestart != null && networkRestart.ReturnType == typeof(void) && playerTtlMember != null && emptyRoomTtlMember != null && playerIsInactive != null)
			{
				return playerIsInactive.PropertyType == typeof(bool);
			}
			return false;
		}

		private static bool PatchRoomCreation(Harmony harmony)
		{
			if (photonNetworkType == null || roomOptionsType == null)
			{
				return false;
			}
			bool flag = false;
			string[] source = new string[2] { "CreateRoom", "JoinOrCreateRoom" };
			MethodInfo[] methods = photonNetworkType.GetMethods(BindingFlags.Static | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (source.Contains<string>(methodInfo.Name, StringComparer.Ordinal) && !(methodInfo.ReturnType != typeof(bool)) && methodInfo.GetParameters().Any((ParameterInfo parameter) => parameter.ParameterType == roomOptionsType) && PatchExact(harmony, methodInfo, "RoomCreationPrefix", 800, critical: true))
				{
					flag |= methodInfo.Name == "CreateRoom";
				}
			}
			return flag;
		}

		private static bool PatchInactivePlayerLeaveCallbacks(Harmony harmony)
		{
			bool flag = false;
			bool flag2 = false;
			string[] array = new string[3] { "NetworkConnectionHandler", "UnboundLib.NetworkEventCallbacks", "RWF.PrivateRoomHandler" };
			foreach (string text in array)
			{
				Type type = FindType(text);
				if (!(type == null))
				{
					MethodInfo original = FindExactMethod(type, "OnPlayerLeftRoom", false, "Photon.Realtime.Player");
					if (PatchExact(harmony, original, "InactivePlayerLeftPrefix", 800, text != "RWF.PrivateRoomHandler"))
					{
						flag |= text == "NetworkConnectionHandler";
						flag2 |= text == "UnboundLib.NetworkEventCallbacks";
					}
				}
			}
			return flag && flag2;
		}

		private static bool PatchExact(Harmony harmony, MethodInfo? original, string prefixName, int priority, bool critical)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			if (original == null)
			{
				if (critical)
				{
					ManualLogSource? obj = logger;
					if (obj != null)
					{
						obj.LogWarning((object)("Experimental Rejoin exact hook was not found for prefix " + prefixName + "."));
					}
				}
				return false;
			}
			MethodInfo method = typeof(ExperimentalRejoin).GetMethod(prefixName, BindingFlags.Static | BindingFlags.NonPublic);
			if (method == null)
			{
				return false;
			}
			try
			{
				HarmonyMethod val = new HarmonyMethod(method);
				val.priority = priority;
				val.before = new string[2] { "io.olavim.rounds.rwf", "com.willis.rounds.unbound" };
				HarmonyMethod val2 = val;
				harmony.Patch((MethodBase)original, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				return true;
			}
			catch (Exception exception)
			{
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogWarning((object)("Experimental Rejoin did not patch " + original.DeclaringType?.FullName + "." + original.Name + ": " + Unwrap(exception).Message));
				}
				return false;
			}
		}

		private static MethodInfo? FindExactMethod(Type? type, string name, bool isStatic, params string[] parameterTypeNames)
		{
			if (type == null)
			{
				return null;
			}
			BindingFlags bindingAttr = (BindingFlags)(0x30 | (isStatic ? 8 : 4));
			foreach (MethodInfo item in from candidate in type.GetMethods(bindingAttr)
				where candidate.Name == name
				select candidate)
			{
				ParameterInfo[] parameters = item.GetParameters();
				if (parameters.Length != parameterTypeNames.Length)
				{
					continue;
				}
				bool flag = true;
				for (int num = 0; num < parameters.Length; num++)
				{
					if (!string.Equals(parameters[num].ParameterType.FullName, parameterTypeNames[num], StringComparison.Ordinal))
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return item;
				}
			}
			return null;
		}

		private static Type? FindType(string fullName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(fullName, throwOnError: false, ignoreCase: false);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}

		private static PropertyInfo? FindStaticBoolProperty(Type type, string name)
		{
			PropertyInfo property = type.GetProperty(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(property != null) || !(property.PropertyType == typeof(bool)) || !(property.GetMethod != null))
			{
				return null;
			}
			return property;
		}

		private static MemberInfo? FindIntMember(Type type, string name)
		{
			FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(int))
			{
				return field;
			}
			PropertyInfo property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (!(property != null) || !(property.PropertyType == typeof(int)) || !property.CanWrite)
			{
				return null;
			}
			return property;
		}

		private static void SetIntMember(MemberInfo? member, object instance, int value)
		{
			if (member is FieldInfo fieldInfo)
			{
				fieldInfo.SetValue(instance, value);
				return;
			}
			if (member is PropertyInfo propertyInfo)
			{
				propertyInfo.SetValue(instance, value, null);
				return;
			}
			throw new MissingMemberException("Expected writable Int32 room option member.");
		}

		private static Exception Unwrap(Exception exception)
		{
			if (!(exception is TargetInvocationException { InnerException: not null } ex))
			{
				return exception;
			}
			return ex.InnerException;
		}

		private static void SetState(ExperimentalRejoinState newState, string newDetail)
		{
			state = newState;
			detail = newDetail;
		}
	}
	internal sealed class ExperimentalRejoinBehaviour : MonoBehaviour
	{
		private object? disconnectHandler;

		private Coroutine? attemptCoroutine;

		private bool hasRoomContext;

		private bool lastRoomWasHost;

		private bool abortRequested;

		private bool resettingTransportForRetry;

		internal bool IsAttemptActive => attemptCoroutine != null;

		internal bool IsResettingTransportForRetry => resettingTransportForRetry;

		internal void Initialize()
		{
			hasRoomContext = false;
			lastRoomWasHost = false;
			abortRequested = false;
			resettingTransportForRetry = false;
		}

		internal bool TryBegin(object handler, string cause)
		{
			if (attemptCoroutine != null)
			{
				return true;
			}
			if (!hasRoomContext || lastRoomWasHost)
			{
				return false;
			}
			disconnectHandler = handler;
			abortRequested = false;
			attemptCoroutine = ((MonoBehaviour)this).StartCoroutine(RejoinWithOneRetry(cause));
			return true;
		}

		internal void AbortCurrentAttempt()
		{
			abortRequested = true;
		}

		private void Update()
		{
			if (ExperimentalRejoin.PhotonInRoom)
			{
				hasRoomContext = true;
				lastRoomWasHost = ExperimentalRejoin.PhotonIsMaster;
			}
			else if (ExperimentalRejoin.PhotonIsConnectedAndReady && attemptCoroutine == null)
			{
				hasRoomContext = false;
				lastRoomWasHost = false;
			}
		}

		private IEnumerator RejoinWithOneRetry(string cause)
		{
			for (int attempt = 1; attempt <= 2; attempt++)
			{
				if (abortRequested)
				{
					FinishWithoutFallback();
					yield break;
				}
				if (attempt > 1)
				{
					ExperimentalRejoin.MarkAttemptStarted(attempt);
					if (ExperimentalRejoin.PhotonIsConnected)
					{
						resettingTransportForRetry = true;
						ExperimentalRejoin.DisconnectForRetry();
						float disconnectDeadline = Time.realtimeSinceStartup + Mathf.Min(3f, ExperimentalRejoin.Options.ReconnectTimeoutSeconds);
						while (ExperimentalRejoin.PhotonIsConnected && Time.realtimeSinceStartup < disconnectDeadline && !abortRequested)
						{
							yield return null;
						}
						resettingTransportForRetry = false;
					}
					if (abortRequested)
					{
						FinishWithoutFallback();
						yield break;
					}
					yield return (object)new WaitForSecondsRealtime(ExperimentalRejoin.Options.RetryDelaySeconds);
				}
				else
				{
					ExperimentalRejoin.MarkAttemptStarted(attempt);
				}
				if (!ExperimentalRejoin.InvokeReconnectAndRejoin())
				{
					continue;
				}
				ExperimentalRejoin.MarkWaitingForRoom(attempt);
				float deadline = Time.realtimeSinceStartup + ExperimentalRejoin.Options.ReconnectTimeoutSeconds;
				while (Time.realtimeSinceStartup < deadline && !abortRequested)
				{
					if (ExperimentalRejoin.PhotonInRoom && ExperimentalRejoin.PhotonIsConnectedAndReady)
					{
						ExperimentalRejoin.MarkSuccess();
						FinishWithoutFallback();
						yield break;
					}
					yield return null;
				}
			}
			object obj = disconnectHandler;
			FinishWithoutFallback();
			if (!abortRequested && obj != null)
			{
				ExperimentalRejoin.MarkFailureAndFallback(obj, "Attempts exhausted after recoverable disconnect: " + cause + ".");
			}
		}

		private void FinishWithoutFallback()
		{
			disconnectHandler = null;
			resettingTransportForRetry = false;
			attemptCoroutine = null;
		}
	}
	public sealed class ExperimentalRejoinOptions
	{
		public bool Enabled { get; set; }

		public int PlayerTtlMilliseconds { get; set; } = 60000;

		public int EmptyRoomTtlMilliseconds { get; set; } = 30000;

		public float ReconnectTimeoutSeconds { get; set; } = 12f;

		public float RetryDelaySeconds { get; set; } = 1f;

		internal void Normalize()
		{
			PlayerTtlMilliseconds = Clamp(PlayerTtlMilliseconds, 5000, 300000);
			EmptyRoomTtlMilliseconds = Clamp(EmptyRoomTtlMilliseconds, 0, 300000);
			ReconnectTimeoutSeconds = Clamp(ReconnectTimeoutSeconds, 3f, 30f);
			RetryDelaySeconds = Clamp(RetryDelaySeconds, 0.25f, 5f);
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static float Clamp(float value, float min, float max)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return min;
			}
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
	public enum ExperimentalRejoinState
	{
		Disabled,
		Installing,
		Armed,
		Reconnecting,
		WaitingForRoom,
		Retrying,
		RejoinedWarmStatePending,
		FailedClosed,
		FallingBackToVanilla
	}
	public sealed class ExperimentalRejoinStatus
	{
		public ExperimentalRejoinState State { get; }

		public string Detail { get; }

		public bool Installed { get; }

		public bool Enabled { get; }

		public bool NeedsWarmStateRestore { get; }

		public int RoomsPrepared { get; }

		public int AttemptsStarted { get; }

		public int SuccessfulRejoins { get; }

		public int FailedRejoins { get; }

		public int SuppressedInactiveLeaveCallbacks { get; }

		public int RejectedDisconnects { get; }

		internal ExperimentalRejoinStatus(ExperimentalRejoinState state, string detail, bool installed, bool enabled, bool needsWarmStateRestore, int roomsPrepared, int attemptsStarted, int successfulRejoins, int failedRejoins, int suppressedInactiveLeaveCallbacks, int rejectedDisconnects)
		{
			State = state;
			Detail = detail;
			Installed = installed;
			Enabled = enabled;
			NeedsWarmStateRestore = needsWarmStateRestore;
			RoomsPrepared = roomsPrepared;
			AttemptsStarted = attemptsStarted;
			SuccessfulRejoins = successfulRejoins;
			FailedRejoins = failedRejoins;
			SuppressedInactiveLeaveCallbacks = suppressedInactiveLeaveCallbacks;
			RejectedDisconnects = rejectedDisconnects;
		}
	}
}
namespace ReksikPerformance.ReliabilityGuards
{
	internal static class PatchContract
	{
		internal static Type? TypeInAssembly(string fullName, string assemblyName)
		{
			Type type = AccessTools.TypeByName(fullName);
			if (!(type != null) || !string.Equals(type.Assembly.GetName().Name, assemblyName, StringComparison.Ordinal))
			{
				return null;
			}
			return type;
		}

		internal static MethodInfo? ExactMethod(Type type, string name, BindingFlags flags, string returnTypeName, params string[] parameterTypeNames)
		{
			MethodInfo methodInfo = null;
			MethodInfo[] methods = type.GetMethods(flags);
			foreach (MethodInfo methodInfo2 in methods)
			{
				if (!string.Equals(methodInfo2.Name, name, StringComparison.Ordinal) || !string.Equals(methodInfo2.ReturnType.FullName, returnTypeName, StringComparison.Ordinal))
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo2.GetParameters();
				if (parameters.Length != parameterTypeNames.Length)
				{
					continue;
				}
				bool flag = true;
				for (int j = 0; j < parameters.Length; j++)
				{
					if (!string.Equals(parameters[j].ParameterType.FullName, parameterTypeNames[j], StringComparison.Ordinal))
					{
						flag = false;
						break;
					}
				}
				if (!flag || methodInfo != null)
				{
					return null;
				}
				methodInfo = methodInfo2;
			}
			return methodInfo;
		}

		internal static bool IsMissingUnityObject(object? candidate)
		{
			if (candidate == null)
			{
				return true;
			}
			Object val = (Object)((candidate is Object) ? candidate : null);
			if (val != null)
			{
				return val == (Object)null;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class EntityLagFixerRoundEndPatch
	{
		private const string PluginGuid = "entity-lag-fixer-upper";

		private static MethodInfo? target;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			if (!Chainloader.PluginInfos.TryGetValue("entity-lag-fixer-upper", out var value))
			{
				reason = "plugin GUID 'entity-lag-fixer-upper' is not loaded";
				return false;
			}
			Type type = PatchContract.TypeInAssembly("EntityLagFixerUpper", "EntityLagFixerUpper");
			if (type == null)
			{
				reason = "the exact EntityLagFixerUpper type/assembly contract was not found";
				return false;
			}
			if ((Object)(object)value.Instance != (Object)null && ((object)value.Instance).GetType().Assembly != type.Assembly)
			{
				reason = "the GUID owner does not match the discovered assembly";
				return false;
			}
			target = PatchContract.ExactMethod(type, "RoundEnd", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, "System.Collections.IEnumerator", "UnboundLib.GameModes.IGameModeHandler");
			if (target == null)
			{
				reason = "RoundEnd no longer has the audited static IEnumerator signature";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(ref IEnumerator __result)
		{
			__result = Empty();
			ReliabilityGuard.CountEntityLagRoundEnd();
			return false;
		}

		private static IEnumerator Empty()
		{
			yield break;
		}
	}
	[HarmonyPatch]
	internal static class NetworkPhysicsCollisionPatch
	{
		private static MethodInfo? target;

		private static FieldInfo? photonViewField;

		private static PropertyInfo? contactCountProperty;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			photonViewField = null;
			contactCountProperty = null;
			Type type = PatchContract.TypeInAssembly("NetworkPhysicsObject", "Assembly-CSharp");
			if (type == null)
			{
				reason = "the vanilla NetworkPhysicsObject type was not found";
				return false;
			}
			target = PatchContract.ExactMethod(type, "OnCollisionEnter2D", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "System.Void", "UnityEngine.Collision2D");
			photonViewField = AccessTools.Field(type, "photonView");
			contactCountProperty = AccessTools.TypeByName("UnityEngine.Collision2D")?.GetProperty("contactCount", BindingFlags.Instance | BindingFlags.Public);
			if (target == null || photonViewField == null || !string.Equals(photonViewField.FieldType.FullName, "Photon.Pun.PhotonView", StringComparison.Ordinal) || contactCountProperty?.PropertyType != typeof(int) || contactCountProperty.GetMethod == null)
			{
				reason = "the audited collision, PhotonView, or contact-count contract changed";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance, object? __0)
		{
			try
			{
				if (PatchContract.IsMissingUnityObject(photonViewField.GetValue(__instance)) || __0 == null || (int)contactCountProperty.GetValue(__0, null) <= 0)
				{
					ReliabilityGuard.CountNetworkPhysicsSkip();
					return false;
				}
			}
			catch
			{
				return true;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class FollowPlayerLateUpdatePatch
	{
		private static MethodInfo? target;

		private static FieldInfo? ownPlayerField;

		private static FieldInfo? targetField;

		private static FieldInfo? playerManagerInstanceField;

		private static MethodInfo? getOtherPlayerMethod;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			ownPlayerField = null;
			targetField = null;
			playerManagerInstanceField = null;
			getOtherPlayerMethod = null;
			Type type = PatchContract.TypeInAssembly("FollowPlayer", "Assembly-CSharp");
			Type playerType = PatchContract.TypeInAssembly("Player", "Assembly-CSharp");
			Type type2 = PatchContract.TypeInAssembly("PlayerManager", "Assembly-CSharp");
			if (type == null || playerType == null || type2 == null)
			{
				reason = "one or more audited vanilla player-follow types are absent";
				return false;
			}
			target = PatchContract.ExactMethod(type, "LateUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "System.Void");
			ownPlayerField = AccessTools.Field(type, "ownPlayer");
			targetField = AccessTools.Field(type, "target");
			playerManagerInstanceField = AccessTools.Field(type2, "instance");
			getOtherPlayerMethod = type2.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(delegate(MethodInfo method)
			{
				if (!string.Equals(method.Name, "GetOtherPlayer", StringComparison.Ordinal) || method.ReturnType != playerType)
				{
					return false;
				}
				ParameterInfo[] parameters = method.GetParameters();
				return parameters.Length == 1 && parameters[0].ParameterType == playerType;
			});
			FieldInfo? fieldInfo = targetField;
			bool flag = (object)fieldInfo != null && fieldInfo.FieldType.IsEnum && Enum.GetNames(targetField.FieldType).Contains("Self") && Enum.GetNames(targetField.FieldType).Contains("Other");
			if (target == null || ownPlayerField?.FieldType != playerType || !flag || playerManagerInstanceField?.FieldType != type2 || getOtherPlayerMethod == null || !typeof(Component).IsAssignableFrom(playerType) || !typeof(Behaviour).IsAssignableFrom(type))
			{
				reason = "the audited FollowPlayer ownership/target contract changed";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance)
		{
			object value;
			try
			{
				value = ownPlayerField.GetValue(__instance);
			}
			catch
			{
				return true;
			}
			if (PatchContract.IsMissingUnityObject(value))
			{
				Disable(__instance);
				ReliabilityGuard.CountFollowPlayerSkip(disabled: true);
				return false;
			}
			object value2;
			try
			{
				value2 = targetField.GetValue(__instance);
			}
			catch
			{
				return true;
			}
			if (!string.Equals(value2?.ToString(), "Other", StringComparison.Ordinal))
			{
				return true;
			}
			object value3 = playerManagerInstanceField.GetValue(null);
			if (PatchContract.IsMissingUnityObject(value3))
			{
				ReliabilityGuard.CountFollowPlayerSkip(disabled: false);
				return false;
			}
			object candidate;
			try
			{
				candidate = getOtherPlayerMethod.Invoke(value3, new object[1] { value });
			}
			catch
			{
				return true;
			}
			if (!PatchContract.IsMissingUnityObject(candidate))
			{
				return true;
			}
			Disable(__instance);
			ReliabilityGuard.CountFollowPlayerSkip(disabled: true);
			return false;
		}

		private static void Disable(object instance)
		{
			Behaviour val = (Behaviour)((instance is Behaviour) ? instance : null);
			if (val != null)
			{
				val.enabled = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class ProjectileHitRpcPatch
	{
		private static MethodInfo? target;

		private static MethodInfo? destroyTarget;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			destroyTarget = null;
			Type type = PatchContract.TypeInAssembly("ProjectileHit", "Assembly-CSharp");
			if (type == null)
			{
				reason = "the vanilla ProjectileHit type was not found";
				return false;
			}
			target = PatchContract.ExactMethod(type, "RPCA_DoHit", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "System.Void", "UnityEngine.Vector2", "UnityEngine.Vector2", "UnityEngine.Vector2", "System.Int32", "System.Int32", "System.Boolean");
			destroyTarget = PatchContract.ExactMethod(type, "DestroyMe", BindingFlags.Instance | BindingFlags.NonPublic, "System.Void");
			bool flag = target?.GetCustomAttributes(inherit: false).Any((object attribute) => string.Equals(attribute.GetType().FullName, "Photon.Pun.PunRPC", StringComparison.Ordinal)) ?? false;
			ParameterInfo[] array = target?.GetParameters() ?? Array.Empty<ParameterInfo>();
			bool flag2 = array.Length == 6 && string.Equals(array[3].Name, "viewID", StringComparison.Ordinal) && string.Equals(array[4].Name, "colliderID", StringComparison.Ordinal);
			if (target == null || destroyTarget == null || !flag || !flag2)
			{
				reason = "RPCA_DoHit no longer has the audited PunRPC, target-name, or terminal DestroyMe contract";
				return false;
			}
			bool flag3;
			bool flag4;
			bool flag5;
			try
			{
				KeyValuePair<OpCode, object>[] source = PatchProcessor.ReadMethodBody((MethodBase)target).ToArray();
				flag3 = source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo && string.Equals(methodInfo.DeclaringType?.FullName, "Photon.Pun.PhotonNetwork", StringComparison.Ordinal) && string.Equals(methodInfo.Name, "GetPhotonView", StringComparison.Ordinal) && string.Equals(methodInfo.ReturnType.FullName, "Photon.Pun.PhotonView", StringComparison.Ordinal) && methodInfo.GetParameters().Length == 1 && methodInfo.GetParameters()[0].ParameterType == typeof(int));
				flag4 = source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo && methodInfo.DeclaringType == typeof(Component) && string.Equals(methodInfo.Name, "GetComponentsInChildren", StringComparison.Ordinal) && methodInfo.IsGenericMethod && methodInfo.GetGenericArguments().Length == 1 && string.Equals(methodInfo.GetGenericArguments()[0].FullName, "UnityEngine.Collider2D", StringComparison.Ordinal) && methodInfo.GetParameters().Length == 0);
				flag5 = source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo && methodInfo.Module == destroyTarget.Module && methodInfo.MetadataToken == destroyTarget.MetadataToken);
			}
			catch
			{
				reason = "the live RPCA_DoHit method body could not be inspected safely";
				return false;
			}
			if (!flag3 || !flag4 || !flag5)
			{
				reason = "RPCA_DoHit no longer contains both audited target lookups and terminal cleanup";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(ProjectileHit __instance, int viewID, int colliderID)
		{
			if (viewID != -1)
			{
				PhotonView photonView;
				try
				{
					photonView = PhotonNetwork.GetPhotonView(viewID);
				}
				catch
				{
					return SuppressStale(__instance);
				}
				if ((Object)(object)photonView == (Object)null)
				{
					return SuppressStale(__instance);
				}
				return true;
			}
			if (colliderID == -1)
			{
				return true;
			}
			if (colliderID < 0)
			{
				return SuppressStale(__instance);
			}
			try
			{
				MapManager instance = MapManager.instance;
				if ((Object)(object)instance == (Object)null || instance.currentMap == null || (Object)(object)instance.currentMap.Map == (Object)null)
				{
					return SuppressStale(__instance);
				}
				Type type = AccessTools.TypeByName("UnityEngine.Collider2D");
				if (type == null)
				{
					return SuppressStale(__instance);
				}
				Component[] componentsInChildren = ((Component)instance.currentMap.Map).GetComponentsInChildren(type);
				if (colliderID >= componentsInChildren.Length || (Object)(object)componentsInChildren[colliderID] == (Object)null)
				{
					return SuppressStale(__instance);
				}
			}
			catch
			{
				return SuppressStale(__instance);
			}
			return true;
		}

		private static bool SuppressStale(ProjectileHit instance)
		{
			ReliabilityGuard.CountStaleProjectileHit();
			try
			{
				if ((Object)(object)instance != (Object)null)
				{
					destroyTarget?.Invoke(instance, null);
				}
			}
			catch
			{
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class GearUpLifeforcePatch
	{
		private const string TypeName = "GearUpCards.MonoBehaviours.OrbLifeforceDualityModifier";

		private static MethodInfo? target;

		private static FieldInfo? effectEnableField;

		private static FieldInfo? orbLifeTimeField;

		private static FieldInfo? orbMaxDurationField;

		private static FieldInfo? orbAliveTimeField;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			effectEnableField = null;
			orbLifeTimeField = null;
			orbMaxDurationField = null;
			orbAliveTimeField = null;
			Type type = PatchContract.TypeInAssembly("GearUpCards.MonoBehaviours.OrbLifeforceDualityModifier", "GearUpCards");
			if (type == null)
			{
				reason = "the audited GearUpCards type/assembly is not loaded";
				return false;
			}
			target = PatchContract.ExactMethod(type, "Update", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "System.Void");
			effectEnableField = AccessTools.Field(type, "effectEnable");
			orbLifeTimeField = AccessTools.Field(type, "orbLifeTime");
			orbMaxDurationField = AccessTools.Field(type, "orbMaxDuration");
			orbAliveTimeField = AccessTools.Field(type, "orbAliveTime");
			if (target == null || effectEnableField?.FieldType != typeof(bool) || orbLifeTimeField?.FieldType != typeof(float) || orbMaxDurationField?.FieldType != typeof(float) || orbAliveTimeField?.FieldType != typeof(float) || !typeof(Behaviour).IsAssignableFrom(type) || type.BaseType?.FullName != "RayHitEffect")
			{
				reason = "the audited GearUp Lifeforce lifetime contract changed";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!(bool)effectEnableField.GetValue(__instance))
				{
					return true;
				}
				float num = (float)orbLifeTimeField.GetValue(__instance);
				float num2 = (float)orbAliveTimeField.GetValue(__instance);
				float num3 = (float)orbMaxDurationField.GetValue(__instance);
				if (!(num < 0f) && !(num2 + TimeHandler.deltaTime >= num3))
				{
					return true;
				}
				Behaviour val = (Behaviour)__instance;
				Transform root = ((Component)val).transform.root;
				PhotonView val2 = ((Component)root).GetComponent<PhotonView>() ?? ((Component)root).GetComponentInChildren<PhotonView>();
				val.enabled = false;
				if ((Object)(object)val2 == (Object)null || !val2.IsMine)
				{
					ReliabilityGuard.CountLifeforceTerminalCall(suppressedRemoteDestroy: true);
					return false;
				}
				ReliabilityGuard.CountLifeforceTerminalCall(suppressedRemoteDestroy: false);
				return true;
			}
			catch
			{
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class GearUpArcaneConversionPatch
	{
		private const string TypeName = "GearUpCards.MonoBehaviours.ArcaneConversionModifier";

		private static MethodInfo? target;

		internal static bool CanPatch(out string reason)
		{
			target = null;
			Type type = PatchContract.TypeInAssembly("GearUpCards.MonoBehaviours.ArcaneConversionModifier", "GearUpCards");
			Type type2 = PatchContract.TypeInAssembly("HitInfo", "Assembly-CSharp");
			Type type3 = PatchContract.TypeInAssembly("HasToReturn", "Assembly-CSharp");
			if (type == null || type2 == null || type3 == null)
			{
				reason = "the audited GearUp or vanilla hit types are not loaded";
				return false;
			}
			target = PatchContract.ExactMethod(type, "DoHitEffect", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "HasToReturn", "HitInfo");
			FieldInfo fieldInfo = AccessTools.Field(type2, "transform");
			bool flag = type3.IsEnum && Enum.IsDefined(type3, "canContinue") && Convert.ToInt32(Enum.Parse(type3, "canContinue")) == 1;
			if (target == null || fieldInfo?.FieldType != typeof(Transform) || !flag || type.BaseType?.FullName != "RayHitEffect")
			{
				reason = "the audited GearUp Arcane hit/result contract changed";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(HitInfo? hit, ref HasToReturn __result)
		{
			if (hit != null && (Object)(object)hit.transform != (Object)null)
			{
				return true;
			}
			__result = (HasToReturn)1;
			ReliabilityGuard.CountArcaneNullHit();
			return false;
		}
	}
	public static class ReliabilityGuard
	{
		private delegate bool CompatibilityCheck(out string reason);

		private static readonly object InstallLock = new object();

		private static ManualLogSource? logger;

		private static int installed;

		private static int installedPatchCount;

		private static int skippedPatchCount;

		private static int failedPatchCount;

		private static int entityLagFixerActive;

		private static int networkPhysicsActive;

		private static int followPlayerActive;

		private static int setPlayerSpriteLayerActive;

		private static int rwfFollowPlayerActive;

		private static int moddingUtilsFullResetActive;

		private static int projectileHitActive;

		private static int gearUpLifeforceActive;

		private static int gearUpArcaneActive;

		private static long entityLagRoundEndsSuppressed;

		private static long networkPhysicsUpdatesSkipped;

		private static long followPlayerUpdatesSkipped;

		private static long followPlayerComponentsDisabled;

		private static long setPlayerSpriteLayerStartsSkipped;

		private static long rwfFollowPlayerUpdatesSkipped;

		private static long rwfFollowPlayerComponentsDisabled;

		private static long moddingUtilsDestroyedPlayersSkipped;

		private static long staleProjectileHitsDropped;

		private static long gearUpLifeforceTerminalCallsGuarded;

		private static long gearUpLifeforceRemoteDestroysSuppressed;

		private static long gearUpArcaneNullHitsDropped;

		private static int entityLagNoticeWritten;

		private static int networkPhysicsNoticeWritten;

		private static int followPlayerNoticeWritten;

		private static int setPlayerSpriteLayerNoticeWritten;

		private static int rwfFollowPlayerNoticeWritten;

		private static int moddingUtilsFullResetNoticeWritten;

		private static int projectileHitNoticeWritten;

		private static int lifeforceNoticeWritten;

		private static int arcaneNoticeWritten;

		public static ReliabilityGuardStatus Install(Harmony harmony, ManualLogSource suppliedLogger)
		{
			if (harmony == null)
			{
				throw new ArgumentNullException("harmony");
			}
			if (suppliedLogger == null)
			{
				throw new ArgumentNullException("suppliedLogger");
			}
			lock (InstallLock)
			{
				logger = suppliedLogger;
				if (Volatile.Read(in installed) != 0)
				{
					return GetStatus();
				}
				InstallPatch(harmony, typeof(EntityLagFixerRoundEndPatch), "EntityLagFixerUpper.RoundEnd", EntityLagFixerRoundEndPatch.CanPatch, delegate
				{
					Volatile.Write(ref entityLagFixerActive, 1);
				});
				InstallPatch(harmony, typeof(NetworkPhysicsCollisionPatch), "NetworkPhysicsObject.OnCollisionEnter2D", NetworkPhysicsCollisionPatch.CanPatch, delegate
				{
					Volatile.Write(ref networkPhysicsActive, 1);
				});
				InstallPatch(harmony, typeof(FollowPlayerLateUpdatePatch), "FollowPlayer.LateUpdate", FollowPlayerLateUpdatePatch.CanPatch, delegate
				{
					Volatile.Write(ref followPlayerActive, 1);
				});
				InstallPatch(harmony, typeof(SetPlayerSpriteLayerStartPatch), "SetPlayerSpriteLayer.Start", SetPlayerSpriteLayerStartPatch.CanPatch, delegate
				{
					Volatile.Write(ref setPlayerSpriteLayerActive, 1);
				});
				InstallPatch(harmony, typeof(RwfUiFollowPlayerUpdatePatch), "RWF.UI.FollowPlayer.Update", RwfUiFollowPlayerUpdatePatch.CanPatch, delegate
				{
					Volatile.Write(ref rwfFollowPlayerActive, 1);
				});
				InstallPatch(harmony, typeof(ModdingUtilsFullResetPrefixPatch), "ModdingUtils.PlayerPatchFullReset.Prefix", ModdingUtilsFullResetPrefixPatch.CanPatch, delegate
				{
					Volatile.Write(ref moddingUtilsFullResetActive, 1);
				});
				InstallPatch(harmony, typeof(ProjectileHitRpcPatch), "ProjectileHit.RPCA_DoHit", ProjectileHitRpcPatch.CanPatch, delegate
				{
					Volatile.Write(ref projectileHitActive, 1);
				});
				InstallPatch(harmony, typeof(GearUpLifeforcePatch), "GearUp OrbLifeforceDualityModifier.Update", GearUpLifeforcePatch.CanPatch, delegate
				{
					Volatile.Write(ref gearUpLifeforceActive, 1);
				});
				InstallPatch(harmony, typeof(GearUpArcaneConversionPatch), "GearUp ArcaneConversionModifier.DoHitEffect", GearUpArcaneConversionPatch.CanPatch, delegate
				{
					Volatile.Write(ref gearUpArcaneActive, 1);
				});
				Volatile.Write(ref installed, 1);
				suppliedLogger.LogInfo((object)($"Reliability Guard installed {installedPatchCount} compatible patches; " + $"{skippedPatchCount} skipped, {failedPatchCount} failed."));
				return GetStatus();
			}
		}

		public static ReliabilityGuardStatus GetStatus()
		{
			return new ReliabilityGuardStatus(Volatile.Read(in installed) != 0, Volatile.Read(in installedPatchCount), Volatile.Read(in skippedPatchCount), Volatile.Read(in failedPatchCount), Volatile.Read(in entityLagFixerActive) != 0, Volatile.Read(in networkPhysicsActive) != 0, Volatile.Read(in followPlayerActive) != 0, Volatile.Read(in setPlayerSpriteLayerActive) != 0, Volatile.Read(in rwfFollowPlayerActive) != 0, Volatile.Read(in moddingUtilsFullResetActive) != 0, Volatile.Read(in projectileHitActive) != 0, Volatile.Read(in gearUpLifeforceActive) != 0, Volatile.Read(in gearUpArcaneActive) != 0, Interlocked.Read(in entityLagRoundEndsSuppressed), Interlocked.Read(in networkPhysicsUpdatesSkipped), Interlocked.Read(in followPlayerUpdatesSkipped), Interlocked.Read(in followPlayerComponentsDisabled), Interlocked.Read(in setPlayerSpriteLayerStartsSkipped), Interlocked.Read(in rwfFollowPlayerUpdatesSkipped), Interlocked.Read(in rwfFollowPlayerComponentsDisabled), Interlocked.Read(in moddingUtilsDestroyedPlayersSkipped), Interlocked.Read(in staleProjectileHitsDropped), Interlocked.Read(in gearUpLifeforceTerminalCallsGuarded), Interlocked.Read(in gearUpLifeforceRemoteDestroysSuppressed), Interlocked.Read(in gearUpArcaneNullHitsDropped));
		}

		internal static void CountEntityLagRoundEnd()
		{
			Interlocked.Increment(ref entityLagRoundEndsSuppressed);
			LogFirst(ref entityLagNoticeWritten, "Reliability Guard suppressed EntityLagFixerUpper's unsafe local bullet cleanup.");
		}

		internal static void CountNetworkPhysicsSkip()
		{
			Interlocked.Increment(ref networkPhysicsUpdatesSkipped);
			LogFirst(ref networkPhysicsNoticeWritten, "Reliability Guard skipped a NetworkPhysicsObject collision with missing required state.");
		}

		internal static void CountFollowPlayerSkip(bool disabled)
		{
			Interlocked.Increment(ref followPlayerUpdatesSkipped);
			if (disabled)
			{
				Interlocked.Increment(ref followPlayerComponentsDisabled);
			}
			LogFirst(ref followPlayerNoticeWritten, "Reliability Guard stopped a FollowPlayer update after its followed player disappeared.");
		}

		internal static void CountSetPlayerSpriteLayerSkip()
		{
			Interlocked.Increment(ref setPlayerSpriteLayerStartsSkipped);
			LogFirst(ref setPlayerSpriteLayerNoticeWritten, "Reliability Guard skipped sprite-layer initialization with an incomplete player hierarchy.");
		}

		internal static void CountRwfFollowPlayerSkip()
		{
			Interlocked.Increment(ref rwfFollowPlayerUpdatesSkipped);
			Interlocked.Increment(ref rwfFollowPlayerComponentsDisabled);
			LogFirst(ref rwfFollowPlayerNoticeWritten, "Reliability Guard disabled an RWF spotlight after its followed player disappeared.");
		}

		internal static void CountModdingUtilsDestroyedPlayerSkip()
		{
			Interlocked.Increment(ref moddingUtilsDestroyedPlayersSkipped);
			LogFirst(ref moddingUtilsFullResetNoticeWritten, "Reliability Guard skipped ModdingUtils cleanup for an already-destroyed Player.");
		}

		internal static void CountStaleProjectileHit()
		{
			Interlocked.Increment(ref staleProjectileHitsDropped);
			LogFirst(ref projectileHitNoticeWritten, "Reliability Guard dropped an RPC hit whose exact target no longer exists and requested vanilla projectile cleanup.");
		}

		internal static void CountLifeforceTerminalCall(bool suppressedRemoteDestroy)
		{
			Interlocked.Increment(ref gearUpLifeforceTerminalCallsGuarded);
			if (suppressedRemoteDestroy)
			{
				Interlocked.Increment(ref gearUpLifeforceRemoteDestroysSuppressed);
			}
			LogFirst(ref lifeforceNoticeWritten, "Reliability Guard made GearUp Lifeforce orb destruction owner-only and one-shot.");
		}

		internal static void CountArcaneNullHit()
		{
			Interlocked.Increment(ref gearUpArcaneNullHitsDropped);
			LogFirst(ref arcaneNoticeWritten, "Reliability Guard ignored a GearUp Arcane Conversion hit with no target transform.");
		}

		private static void InstallPatch(Harmony harmony, Type patchType, string displayName, CompatibilityCheck compatibilityCheck, Action markActive)
		{
			try
			{
				if (!compatibilityCheck(out var reason))
				{
					Interlocked.Increment(ref skippedPatchCount);
					ManualLogSource? obj = logger;
					if (obj != null)
					{
						obj.LogInfo((object)("Reliability Guard skipped " + displayName + ": " + reason));
					}
					return;
				}
			}
			catch (Exception ex)
			{
				Interlocked.Increment(ref failedPatchCount);
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogWarning((object)("Reliability Guard could not validate " + displayName + "; leaving the original method intact. " + ex.GetType().Name + ": " + ex.Message));
				}
				return;
			}
			try
			{
				harmony.CreateClassProcessor(patchType).Patch();
				markActive();
				Interlocked.Increment(ref installedPatchCount);
				ManualLogSource? obj3 = logger;
				if (obj3 != null)
				{
					obj3.LogInfo((object)("Reliability Guard enabled " + displayName + "."));
				}
			}
			catch (Exception ex2)
			{
				Interlocked.Increment(ref failedPatchCount);
				ManualLogSource? obj4 = logger;
				if (obj4 != null)
				{
					obj4.LogWarning((object)("Reliability Guard could not patch " + displayName + "; leaving the original method intact. " + ex2.GetType().Name + ": " + ex2.Message));
				}
			}
		}

		private static void LogFirst(ref int gate, string message)
		{
			if (Interlocked.CompareExchange(ref gate, 1, 0) == 0)
			{
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)message);
				}
			}
		}
	}
	public sealed class ReliabilityGuardStatus
	{
		public bool Installed { get; }

		public int InstalledPatchCount { get; }

		public int SkippedPatchCount { get; }

		public int FailedPatchCount { get; }

		public bool EntityLagFixerActive { get; }

		public bool NetworkPhysicsActive { get; }

		public bool FollowPlayerActive { get; }

		public bool SetPlayerSpriteLayerActive { get; }

		public bool RwfFollowPlayerActive { get; }

		public bool ModdingUtilsFullResetActive { get; }

		public bool ProjectileHitActive { get; }

		public bool GearUpLifeforceActive { get; }

		public bool GearUpArcaneActive { get; }

		public long EntityLagRoundEndsSuppressed { get; }

		public long NetworkPhysicsUpdatesSkipped { get; }

		public long FollowPlayerUpdatesSkipped { get; }

		public long FollowPlayerComponentsDisabled { get; }

		public long SetPlayerSpriteLayerStartsSkipped { get; }

		public long RwfFollowPlayerUpdatesSkipped { get; }

		public long RwfFollowPlayerComponentsDisabled { get; }

		public long ModdingUtilsDestroyedPlayersSkipped { get; }

		public long StaleProjectileHitsDropped { get; }

		public long GearUpLifeforceTerminalCallsGuarded { get; }

		public long GearUpLifeforceRemoteDestroysSuppressed { get; }

		public long GearUpArcaneNullHitsDropped { get; }

		internal ReliabilityGuardStatus(bool installed, int installedPatchCount, int skippedPatchCount, int failedPatchCount, bool entityLagFixerActive, bool networkPhysicsActive, bool followPlayerActive, bool setPlayerSpriteLayerActive, bool rwfFollowPlayerActive, bool moddingUtilsFullResetActive, bool projectileHitActive, bool gearUpLifeforceActive, bool gearUpArcaneActive, long entityLagRoundEndsSuppressed, long networkPhysicsUpdatesSkipped, long followPlayerUpdatesSkipped, long followPlayerComponentsDisabled, long setPlayerSpriteLayerStartsSkipped, long rwfFollowPlayerUpdatesSkipped, long rwfFollowPlayerComponentsDisabled, long moddingUtilsDestroyedPlayersSkipped, long staleProjectileHitsDropped, long gearUpLifeforceTerminalCallsGuarded, long gearUpLifeforceRemoteDestroysSuppressed, long gearUpArcaneNullHitsDropped)
		{
			Installed = installed;
			InstalledPatchCount = installedPatchCount;
			SkippedPatchCount = skippedPatchCount;
			FailedPatchCount = failedPatchCount;
			EntityLagFixerActive = entityLagFixerActive;
			NetworkPhysicsActive = networkPhysicsActive;
			FollowPlayerActive = followPlayerActive;
			SetPlayerSpriteLayerActive = setPlayerSpriteLayerActive;
			RwfFollowPlayerActive = rwfFollowPlayerActive;
			ModdingUtilsFullResetActive = moddingUtilsFullResetActive;
			ProjectileHitActive = projectileHitActive;
			GearUpLifeforceActive = gearUpLifeforceActive;
			GearUpArcaneActive = gearUpArcaneActive;
			EntityLagRoundEndsSuppressed = entityLagRoundEndsSuppressed;
			NetworkPhysicsUpdatesSkipped = networkPhysicsUpdatesSkipped;
			FollowPlayerUpdatesSkipped = followPlayerUpdatesSkipped;
			FollowPlayerComponentsDisabled = followPlayerComponentsDisabled;
			SetPlayerSpriteLayerStartsSkipped = setPlayerSpriteLayerStartsSkipped;
			RwfFollowPlayerUpdatesSkipped = rwfFollowPlayerUpdatesSkipped;
			RwfFollowPlayerComponentsDisabled = rwfFollowPlayerComponentsDisabled;
			ModdingUtilsDestroyedPlayersSkipped = moddingUtilsDestroyedPlayersSkipped;
			StaleProjectileHitsDropped = staleProjectileHitsDropped;
			GearUpLifeforceTerminalCallsGuarded = gearUpLifeforceTerminalCallsGuarded;
			GearUpLifeforceRemoteDestroysSuppressed = gearUpLifeforceRemoteDestroysSuppressed;
			GearUpArcaneNullHitsDropped = gearUpArcaneNullHitsDropped;
		}
	}
	internal static class SessionTransitionPatchContract
	{
		internal const string RoundsWithFriendsPluginGuid = "io.olavim.rounds.rwf";

		internal const string ModdingUtilsPluginGuid = "pykess.rounds.plugins.moddingutils";

		internal static bool PluginOwnsType(string pluginGuid, Type type, out string reason)
		{
			if (!Chainloader.PluginInfos.TryGetValue(pluginGuid, out var value))
			{
				reason = "plugin GUID '" + pluginGuid + "' is not loaded";
				return false;
			}
			if ((Object)(object)value.Instance == (Object)null || ((object)value.Instance).GetType().Assembly != type.Assembly)
			{
				reason = "plugin GUID '" + pluginGuid + "' does not own the audited assembly";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		internal static KeyValuePair<OpCode, object>[] ReadBody(MethodInfo method)
		{
			return PatchProcessor.ReadMethodBody((MethodBase)method).ToArray();
		}

		internal static bool IsMember(object? candidate, MemberInfo expected)
		{
			if (candidate is MemberInfo memberInfo && memberInfo.Module == expected.Module)
			{
				return memberInfo.MetadataToken == expected.MetadataToken;
			}
			return false;
		}

		internal static bool Calls(IEnumerable<KeyValuePair<OpCode, object>> body, MethodInfo method)
		{
			return body.Any<KeyValuePair<OpCode, object>>((KeyValuePair<OpCode, object> instruction) => IsMember(instruction.Value, method));
		}

		internal static bool Reads(IEnumerable<KeyValuePair<OpCode, object>> body, FieldInfo field)
		{
			return body.Any<KeyValuePair<OpCode, object>>((KeyValuePair<OpCode, object> instruction) => IsMember(instruction.Value, field));
		}
	}
	[HarmonyPatch]
	internal static class SetPlayerSpriteLayerStartPatch
	{
		private static MethodInfo? target;

		private static Type? playerSkinHandlerType;

		private static Type? playerType;

		private static Type? holdingType;

		private static FieldInfo? holdingHoldableField;

		internal static bool CanPatch(out string reason)
		{
			reason = string.Empty;
			target = null;
			playerSkinHandlerType = null;
			playerType = null;
			holdingType = null;
			holdingHoldableField = null;
			Type type = PatchContract.TypeInAssembly("RWF.Patches.Player_Patch_AssignPlayerID", "RoundsWithFriends");
			if (type == null || !SessionTransitionPatchContract.PluginOwnsType("io.olavim.rounds.rwf", type, out reason))
			{
				if (type == null)
				{
					reason = "the exact RWF AssignPlayerID patch type is absent";
				}
				return false;
			}
			Type spriteLayerType = PatchContract.TypeInAssembly("SetPlayerSpriteLayer", "Assembly-CSharp");
			playerSkinHandlerType = PatchContract.TypeInAssembly("PlayerSkinHandler", "Assembly-CSharp");
			playerType = PatchContract.TypeInAssembly("Player", "Assembly-CSharp");
			holdingType = PatchContract.TypeInAssembly("Holding", "Assembly-CSharp");
			Type type2 = PatchContract.TypeInAssembly("Holdable", "Assembly-CSharp");
			if (spriteLayerType == null || playerSkinHandlerType == null || playerType == null || holdingType == null || type2 == null)
			{
				reason = "one or more audited vanilla sprite-layer types are absent";
				return false;
			}
			target = PatchContract.ExactMethod(spriteLayerType, "Start", BindingFlags.Instance | BindingFlags.NonPublic, "System.Void");
			MethodInfo methodInfo = PatchContract.ExactMethod(spriteLayerType, "setSpriteLayerOfChildren", BindingFlags.Instance | BindingFlags.NonPublic, "System.Void", "UnityEngine.GameObject", "System.Int32");
			MethodInfo methodInfo2 = PatchContract.ExactMethod(playerSkinHandlerType, "InitSpriteMask", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, "System.Void", "System.Int32");
			MethodInfo methodInfo3 = PatchContract.ExactMethod(type, "Postfix", BindingFlags.Static | BindingFlags.NonPublic, "System.Void", "Player");
			FieldInfo fieldInfo = AccessTools.Field(playerSkinHandlerType, "simpleSkin");
			FieldInfo fieldInfo2 = AccessTools.Field(playerType, "playerID");
			holdingHoldableField = AccessTools.Field(holdingType, "holdable");
			if (target == null || methodInfo == null || methodInfo2 == null || methodInfo3 == null || fieldInfo?.FieldType != typeof(bool) || fieldInfo2?.FieldType != typeof(int) || holdingHoldableField?.FieldType != type2 || !typeof(Component).IsAssignableFrom(spriteLayerType) || !typeof(Component).IsAssignableFrom(playerSkinHandlerType) || !typeof(Component).IsAssignableFrom(playerType) || !typeof(Component).IsAssignableFrom(holdingType) || !typeof(Component).IsAssignableFrom(type2))
			{
				reason = "the audited RWF/vanilla sprite-layer signature changed";
				return false;
			}
			try
			{
				KeyValuePair<OpCode, object>[] body = SessionTransitionPatchContract.ReadBody(target);
				KeyValuePair<OpCode, object>[] source = SessionTransitionPatchContract.ReadBody(methodInfo3);
				bool num = SessionTransitionPatchContract.Reads(body, fieldInfo) && SessionTransitionPatchContract.Reads(body, fieldInfo2) && SessionTransitionPatchContract.Reads(body, holdingHoldableField) && SessionTransitionPatchContract.Calls(body, methodInfo) && SessionTransitionPatchContract.Calls(body, methodInfo2);
				bool flag = source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo4 && methodInfo4.DeclaringType == typeof(Component) && string.Equals(methodInfo4.Name, "GetComponentInChildren", StringComparison.Ordinal) && methodInfo4.ReturnType == spriteLayerType && methodInfo4.IsGenericMethod && methodInfo4.GetGenericArguments().Length == 1 && methodInfo4.GetGenericArguments()[0] == spriteLayerType && methodInfo4.GetParameters().Length == 1 && methodInfo4.GetParameters()[0].ParameterType == typeof(bool));
				bool flag2 = source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo4 && string.Equals(methodInfo4.DeclaringType?.FullName, "UnboundLib.ExtensionMethods", StringComparison.Ordinal) && string.Equals(methodInfo4.Name, "InvokeMethod", StringComparison.Ordinal) && string.Equals(methodInfo4.DeclaringType?.Assembly.GetName().Name, "UnboundLib", StringComparison.Ordinal) && methodInfo4.ReturnType == typeof(object) && methodInfo4.GetParameters().Length == 3 && methodInfo4.GetParameters()[0].ParameterType == typeof(object) && methodInfo4.GetParameters()[1].ParameterType == typeof(string) && methodInfo4.GetParameters()[2].ParameterType == typeof(object[])) && source.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is string a && string.Equals(a, "Start", StringComparison.Ordinal));
				if (!num || !flag || !flag2)
				{
					reason = "the live RWF/vanilla sprite-layer IL contract changed";
					return false;
				}
			}
			catch
			{
				reason = "the live RWF/vanilla sprite-layer method bodies could not be inspected safely";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance)
		{
			Component val = (Component)((__instance is Component) ? __instance : null);
			if (val == null)
			{
				return true;
			}
			try
			{
				if (PatchContract.IsMissingUnityObject(val.gameObject) || PatchContract.IsMissingUnityObject(val.GetComponent(playerSkinHandlerType)) || PatchContract.IsMissingUnityObject(val.GetComponentInParent(playerType)))
				{
					return SuppressInvalidStart();
				}
				Component componentInParent = val.GetComponentInParent(holdingType);
				if (PatchContract.IsMissingUnityObject(componentInParent))
				{
					return SuppressInvalidStart();
				}
				if (PatchContract.IsMissingUnityObject(holdingHoldableField.GetValue(componentInParent)))
				{
					return SuppressInvalidStart();
				}
			}
			catch (MissingReferenceException)
			{
				return SuppressInvalidStart();
			}
			catch (NullReferenceException)
			{
				return SuppressInvalidStart();
			}
			catch
			{
				return true;
			}
			return true;
		}

		private static bool SuppressInvalidStart()
		{
			ReliabilityGuard.CountSetPlayerSpriteLayerSkip();
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RwfUiFollowPlayerUpdatePatch
	{
		private static MethodInfo? target;

		private static FieldInfo? playerField;

		internal static bool CanPatch(out string reason)
		{
			reason = string.Empty;
			target = null;
			playerField = null;
			Type type = PatchContract.TypeInAssembly("RWF.UI.FollowPlayer", "RoundsWithFriends");
			Type type2 = PatchContract.TypeInAssembly("Player", "Assembly-CSharp");
			if (type == null || type2 == null || !SessionTransitionPatchContract.PluginOwnsType("io.olavim.rounds.rwf", type, out reason))
			{
				if (type == null || type2 == null)
				{
					reason = "the exact RWF FollowPlayer/player types are absent";
				}
				return false;
			}
			target = PatchContract.ExactMethod(type, "Update", BindingFlags.Instance | BindingFlags.NonPublic, "System.Void");
			playerField = AccessTools.Field(type, "player");
			if (target == null || playerField?.FieldType != type2 || !typeof(Behaviour).IsAssignableFrom(type))
			{
				reason = "the audited RWF FollowPlayer signature changed";
				return false;
			}
			try
			{
				KeyValuePair<OpCode, object>[] array = SessionTransitionPatchContract.ReadBody(target);
				int num = Array.FindIndex(array, (KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo && string.Equals(methodInfo.DeclaringType?.FullName, "UnityEngine.Object", StringComparison.Ordinal) && string.Equals(methodInfo.Name, "Destroy", StringComparison.Ordinal) && methodInfo.GetParameters().Length == 1);
				bool num2 = array.Any((KeyValuePair<OpCode, object> instruction) => instruction.Value is MethodInfo methodInfo && string.Equals(methodInfo.DeclaringType?.FullName, "UnityEngine.Object", StringComparison.Ordinal) && string.Equals(methodInfo.Name, "op_Equality", StringComparison.Ordinal));
				bool flag = num >= 0 && array.Skip(num + 1).Any((KeyValuePair<OpCode, object> instruction) => SessionTransitionPatchContract.IsMember(instruction.Value, playerField));
				if (!num2 || !flag)
				{
					reason = "RWF FollowPlayer.Update no longer has the audited destroy-then-dereference IL";
					return false;
				}
			}
			catch
			{
				reason = "the live RWF FollowPlayer.Update body could not be inspected safely";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(object __instance)
		{
			object value;
			try
			{
				value = playerField.GetValue(__instance);
			}
			catch
			{
				return true;
			}
			if (!PatchContract.IsMissingUnityObject(value))
			{
				return true;
			}
			Behaviour val = (Behaviour)((__instance is Behaviour) ? __instance : null);
			if (val != null)
			{
				val.enabled = false;
			}
			ReliabilityGuard.CountRwfFollowPlayerSkip();
			return false;
		}
	}
	[HarmonyPatch]
	internal static class ModdingUtilsFullResetPrefixPatch
	{
		private static MethodInfo? target;

		internal static bool CanPatch(out string reason)
		{
			reason = string.Empty;
			target = null;
			Type type = PatchContract.TypeInAssembly("ModdingUtils.Patches.PlayerPatchFullReset", "ModdingUtils");
			Type type2 = PatchContract.TypeInAssembly("ModdingUtils.Extensions.CustomEffects", "ModdingUtils");
			Type type3 = PatchContract.TypeInAssembly("Player", "Assembly-CSharp");
			if (type == null || type2 == null || type3 == null || !SessionTransitionPatchContract.PluginOwnsType("pykess.rounds.plugins.moddingutils", type, out reason))
			{
				if (type == null || type2 == null || type3 == null)
				{
					reason = "the exact ModdingUtils FullReset contract types are absent";
				}
				return false;
			}
			target = PatchContract.ExactMethod(type, "Prefix", BindingFlags.Static | BindingFlags.NonPublic, "System.Void", "Player");
			MethodInfo methodInfo = PatchContract.ExactMethod(type2, "DestroyAllEffects", BindingFlags.Static | BindingFlags.Public, "System.Void", "UnityEngine.GameObject");
			MethodInfo methodInfo2 = typeof(Component).GetProperty("gameObject", BindingFlags.Instance | BindingFlags.Public)?.GetGetMethod();
			ParameterInfo[] array = target?.GetParameters() ?? Array.Empty<ParameterInfo>();
			if (target == null || methodInfo == null || methodInfo2 == null || array.Length != 1 || array[0].ParameterType != type3 || !string.Equals(array[0].Name, "__instance", StringComparison.Ordinal))
			{
				reason = "the audited ModdingUtils FullReset prefix signature changed";
				return false;
			}
			try
			{
				KeyValuePair<OpCode, object>[] body = SessionTransitionPatchContract.ReadBody(target);
				if (!SessionTransitionPatchContract.Calls(body, methodInfo2) || !SessionTransitionPatchContract.Calls(body, methodInfo))
				{
					reason = "the live ModdingUtils FullReset prefix IL contract changed";
					return false;
				}
			}
			catch
			{
				reason = "the live ModdingUtils FullReset prefix body could not be inspected safely";
				return false;
			}
			reason = string.Empty;
			return true;
		}

		[HarmonyPrepare]
		private static bool Prepare()
		{
			string reason;
			return CanPatch(out reason);
		}

		[HarmonyTargetMethod]
		private static MethodBase? TargetMethod()
		{
			MethodInfo? methodInfo = target;
			if ((object)methodInfo == null)
			{
				if (!CanPatch(out string _))
				{
					return null;
				}
				methodInfo = target;
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(Player __0)
		{
			if (PatchContract.IsMissingUnityObject(__0))
			{
				return SuppressDestroyedPlayer();
			}
			try
			{
				if (PatchContract.IsMissingUnityObject(((Component)__0).gameObject))
				{
					return SuppressDestroyedPlayer();
				}
			}
			catch (MissingReferenceException)
			{
				return SuppressDestroyedPlayer();
			}
			catch (NullReferenceException)
			{
				return SuppressDestroyedPlayer();
			}
			catch
			{
				return true;
			}
			return true;
		}

		private static bool SuppressDestroyedPlayer()
		{
			ReliabilityGuard.CountModdingUtilsDestroyedPlayerSkip();
			return false;
		}
	}
}
namespace ReksikPerformance.Reliability
{
	internal sealed class BoundedEventRateCounter
	{
		private readonly int[] counts;

		private readonly long[] seconds;

		public BoundedEventRateCounter(int windowSeconds)
		{
			int num = Math.Max(2, Math.Min(windowSeconds, 300));
			counts = new int[num];
			seconds = new long[num];
		}

		public int Add(DateTime utc)
		{
			long num = utc.Ticks / 10000000;
			int num2 = (int)(num % counts.Length);
			if (seconds[num2] != num)
			{
				seconds[num2] = num;
				counts[num2] = 0;
			}
			if (counts[num2] < int.MaxValue)
			{
				counts[num2]++;
			}
			return counts[num2];
		}

		public int Count(DateTime utc)
		{
			long num = utc.Ticks / 10000000;
			long num2 = num - (counts.Length - 1);
			long num3 = 0L;
			for (int i = 0; i < counts.Length; i++)
			{
				if (seconds[i] >= num2 && seconds[i] <= num)
				{
					num3 += counts[i];
					if (num3 >= int.MaxValue)
					{
						return int.MaxValue;
					}
				}
			}
			return (int)num3;
		}
	}
	internal sealed class ExceptionRateMonitor : IDisposable
	{
		private readonly object sync = new object();

		private readonly Queue<ExceptionFingerprint> recent;

		private readonly BoundedEventRateCounter rate = new BoundedEventRateCounter(60);

		private readonly string privacySalt = Guid.NewGuid().ToString("N");

		private readonly int capacity;

		private bool disposed;

		private long totalExceptions;

		private long totalErrors;

		public ExceptionRateMonitor(int capacity)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			this.capacity = Math.Max(8, capacity);
			recent = new Queue<ExceptionFingerprint>(this.capacity);
			Application.logMessageReceivedThreaded += new LogCallback(OnLogMessage);
		}

		public ExceptionRateSnapshot Capture(DateTime utcNow, bool includeRecent = true)
		{
			lock (sync)
			{
				TrimRateWindow(utcNow);
				int eventsLastMinute = rate.Count(utcNow);
				return new ExceptionRateSnapshot(totalExceptions, totalErrors, eventsLastMinute, includeRecent ? recent.ToArray() : Array.Empty<ExceptionFingerprint>());
			}
		}

		public void Dispose()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			lock (sync)
			{
				if (disposed)
				{
					return;
				}
				disposed = true;
			}
			Application.logMessageReceivedThreaded -= new LogCallback(OnLogMessage);
		}

		private unsafe void OnLogMessage(string condition, string stackTrace, LogType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if ((int)type != 4 && (int)type != 0 && (int)type != 1)
			{
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			lock (sync)
			{
				if (disposed)
				{
					return;
				}
				if ((int)type == 4)
				{
					totalExceptions++;
				}
				else
				{
					totalErrors++;
				}
				if (rate.Add(utcNow) <= 4)
				{
					string safeCategory = GetSafeCategory(condition, type);
					string fingerprint = StableHash(privacySalt + "|" + condition + "\n" + stackTrace);
					recent.Enqueue(new ExceptionFingerprint(utcNow, ((object)(*(LogType*)(&type))/*cast due to .constrained prefix*/).ToString(), safeCategory, fingerprint));
					while (recent.Count > capacity)
					{
						recent.Dequeue();
					}
				}
				TrimRateWindow(utcNow);
			}
		}

		private void TrimRateWindow(DateTime now)
		{
			DateTime dateTime = now.AddMinutes(-1.0);
			while (recent.Count > 0 && recent.Peek().Utc < dateTime)
			{
				recent.Dequeue();
			}
		}

		private unsafe static string GetSafeCategory(string condition, LogType type)
		{
			if (string.IsNullOrWhiteSpace(condition))
			{
				return ((object)(*(LogType*)(&type))/*cast due to .constrained prefix*/).ToString();
			}
			int num = condition.IndexOf(':');
			int num2 = condition.IndexOfAny(new char[2] { '\r', '\n' });
			int val = condition.Length;
			if (num >= 0)
			{
				val = Math.Min(val, num);
			}
			if (num2 >= 0)
			{
				val = Math.Min(val, num2);
			}
			val = Math.Min(val, 64);
			StringBuilder stringBuilder = new StringBuilder(val);
			for (int i = 0; i < val; i++)
			{
				char c = condition[i];
				if (char.IsLetterOrDigit(c) || c == '.' || c == '_' || c == '+' || c == '`')
				{
					stringBuilder.Append(c);
				}
			}
			string text = stringBuilder.ToString();
			if (text.EndsWith("Exception", StringComparison.Ordinal) || text.EndsWith("Error", StringComparison.Ordinal) || text.EndsWith("Assert", StringComparison.Ordinal))
			{
				return text;
			}
			return ((object)(*(LogType*)(&type))/*cast due to .constrained prefix*/).ToString();
		}

		internal static string StableHash(string value)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(value ?? string.Empty));
			StringBuilder stringBuilder = new StringBuilder(16);
			for (int i = 0; i < 8; i++)
			{
				stringBuilder.Append(array[i].ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal readonly struct ExceptionFingerprint
	{
		public DateTime Utc { get; }

		public string Severity { get; }

		public string Category { get; }

		public string Fingerprint { get; }

		public ExceptionFingerprint(DateTime utc, string severity, string category, string fingerprint)
		{
			Utc = utc;
			Severity = severity;
			Category = category;
			Fingerprint = fingerprint;
		}
	}
	internal readonly struct ExceptionRateSnapshot
	{
		public long TotalExceptions { get; }

		public long TotalErrors { get; }

		public int EventsLastMinute { get; }

		public ExceptionFingerprint[] Recent { get; }

		public ExceptionRateSnapshot(long totalExceptions, long totalErrors, int eventsLastMinute, ExceptionFingerprint[] recent)
		{
			TotalExceptions = totalExceptions;
			TotalErrors = totalErrors;
			EventsLastMinute = eventsLastMinute;
			Recent = recent;
		}
	}
	public enum ExperimentalWarmStateRestoreState
	{
		Disabled,
		Monitoring,
		SnapshotReady,
		DisconnectFrozen,
		AwaitingPointBoundary,
		ValidatingPointBoundary,
		Restored,
		Rejected
	}
	public static class ExperimentalRejoinController
	{
		private const float RollingSnapshotMaxAgeSeconds = 1f;

		private const float FrozenSnapshotMaxAgeSeconds = 300f;

		private const int PlayerReadyFrameBudget = 8;

		private static readonly object Gate = new object();

		private static ManualLogSource? logger;

		private static GameObject? host;

		private static Func<IGameModeHandler, IEnumerator>? pointStartHook;

		private static ExperimentalRejoinWarmStateSnapshot? rollingSnapshot;

		private static ExperimentalRejoinWarmStateSnapshot? frozenSnapshot;

		private static ExperimentalWarmStateRestoreState state = ExperimentalWarmStateRestoreState.Disabled;

		private static string detail = "Not installed.";

		private static string lastReceiptBlockCode = "not-installed";

		private static string lastReceiptBlockDetail = "The warm-state controller is not installed.";

		private static bool freshReceiptArmedLogged;

		private static bool installed;

		public static ExperimentalWarmStateRestoreState State
		{
			get
			{
				lock (Gate)
				{
					return state;
				}
			}
		}

		public static string StatusText
		{
			get
			{
				lock (Gate)
				{
					return state.ToString() + ": " + detail;
				}
			}
		}

		internal static bool CanBeginWarmStateRejoin
		{
			get
			{
				string reasonCode;
				string reasonDetail;
				return TryGetWarmStateRejoinAdmission(out reasonCode, out reasonDetail);
			}
		}

		internal static bool TryGetWarmStateRejoinAdmission(out string reasonCode, out string reasonDetail)
		{
			lock (Gate)
			{
				if (!installed)
				{
					reasonCode = "not-installed";
					reasonDetail = "The warm-state controller is not installed.";
					return false;
				}
				ExperimentalRejoinWarmStateSnapshot experimentalRejoinWarmStateSnapshot = rollingSnapshot;
				if (experimentalRejoinWarmStateSnapshot == null)
				{
					reasonCode = lastReceiptBlockCode;
					reasonDetail = lastReceiptBlockDetail;
					return false;
				}
				float num = Time.realtimeSinceStartup - experimentalRejoinWarmStateSnapshot.CapturedAtRealtime;
				if (num > 1f)
				{
					rollingSnapshot = null;
					lastReceiptBlockCode = "stale-receipt";
					reasonCode = "stale-receipt";
					reasonDetail = "The last locally owned room receipt is " + num.ToString("0.000", CultureInfo.InvariantCulture) + "s old; the admission limit is " + 1f.ToString("0.000", CultureInfo.InvariantCulture) + "s.";
					lastReceiptBlockDetail = reasonDetail;
					return false;
				}
				if (ExperimentalRejoin.PhotonInRoom && ExperimentalRejoin.PhotonIsMaster)
				{
					rollingSnapshot = null;
					lastReceiptBlockCode = "host";
					lastReceiptBlockDetail = "This client is the current room host; automatic host rejoin is forbidden.";
					reasonCode = lastReceiptBlockCode;
					reasonDetail = lastReceiptBlockDetail;
					return false;
				}
				if (string.IsNullOrEmpty(experimentalRejoinWarmStateSnapshot.RoomName))
				{
					reasonCode = "no-room";
					reasonDetail = "The rolling receipt has no exact Photon room identity.";
					return false;
				}
				if (experimentalRejoinWarmStateSnapshot.ActorNumber <= 0)
				{
					reasonCode = "invalid-actor";
					reasonDetail = "The rolling receipt has no valid Photon actor number.";
					return false;
				}
				reasonCode = "ready";
				reasonDetail = "A fresh locally owned non-host room receipt is available.";
				return true;
			}
		}

		public static void Install(ManualLogSource suppliedLogger)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			if (suppliedLogger == null)
			{
				throw new ArgumentNullException("suppliedLogger");
			}
			lock (Gate)
			{
				if (!installed)
				{
					logger = suppliedLogger;
					lastReceiptBlockCode = "no-room";
					lastReceiptBlockDetail = "No healthy Photon room has been observed yet.";
					freshReceiptArmedLogged = false;
					pointStartHook = OnPointStart;
					GameModeManager.AddHook("PointStart", pointStartHook);
					host = new GameObject("ReksikPerformance.ExperimentalRejoinWarmState");
					Object.DontDestroyOnLoad((Object)(object)host);
					host.AddComponent<ExperimentalRejoinWarmStateBehaviour>();
					installed = true;
					SetState(ExperimentalWarmStateRestoreState.Monitoring, "Waiting for an owned non-host player in a healthy Photon room.");
				}
			}
		}

		public static void Shutdown()
		{
			lock (Gate)
			{
				if (installed)
				{
					if (pointStartHook != null)
					{
						GameModeManager.RemoveHook("PointStart", pointStartHook);
					}
					if ((Object)(object)host != (Object)null)
					{
						Object.Destroy((Object)(object)host);
					}
					pointStartHook = null;
					host = null;
					rollingSnapshot = null;
					frozenSnapshot = null;
					lastReceiptBlockCode = "not-installed";
					lastReceiptBlockDetail = "The warm-state controller is not installed.";
					freshReceiptArmedLogged = false;
					installed = false;
					SetState(ExperimentalWarmStateRestoreState.Disabled, "Shut down.");
					logger = null;
				}
			}
		}

		internal static void TickSnapshot()
		{
			lock (Gate)
			{
				if (!installed || !ExperimentalRejoin.IsEnabled)
				{
					return;
				}
				if (ExperimentalRejoin.NeedsWarmStateRestore)
				{
					if (frozenSnapshot != null && state != ExperimentalWarmStateRestoreState.ValidatingPointBoundary)
					{
						SetState(ExperimentalWarmStateRestoreState.AwaitingPointBoundary, "Transport is back; gameplay validation is deferred to PointStart.");
					}
					return;
				}
				if (!ExperimentalRejoin.PhotonInRoom)
				{
					SetReceiptBlocked("no-room", "Photon does not currently report membership in a room.");
					return;
				}
				if (!ExperimentalRejoin.PhotonIsConnectedAndReady)
				{
					SetReceiptBlocked("room-not-ready", "Photon reports a room, but the client is not connected and ready.");
					return;
				}
				if (ExperimentalRejoin.PhotonIsMaster)
				{
					rollingSnapshot = null;
					SetReceiptBlocked("host", "This client is the room host; only non-host receipts can arm.");
					return;
				}
				Player val = FindOwnedLocalPlayer();
				if ((Object)(object)val == (Object)null)
				{
					SetReceiptBlocked("no-owned-player", "No ROUNDS player with a locally owned PhotonView is available.");
					return;
				}
				ExperimentalRejoinWarmStateSnapshot experimentalRejoinWarmStateSnapshot;
				string blockCode;
				string blockDetail;
				try
				{
					experimentalRejoinWarmStateSnapshot = TryCapture(val, out blockCode, out blockDetail);
				}
				catch (Exception ex)
				{
					SetReceiptBlocked("capture-error", "Warm receipt capture failed closed with " + ex.GetType().Name + ".");
					return;
				}
				if (experimentalRejoinWarmStateSnapshot == null)
				{
					SetReceiptBlocked(blockCode, blockDetail);
					return;
				}
				rollingSnapshot = experimentalRejoinWarmStateSnapshot;
				lastReceiptBlockCode = "ready";
				lastReceiptBlockDetail = "A fresh locally owned non-host room receipt is available.";
				SetState(ExperimentalWarmStateRestoreState.SnapshotReady, "Rolling receipt armed for player " + experimentalRejoinWarmStateSnapshot.PlayerId + " on actor " + experimentalRejoinWarmStateSnapshot.ActorNumber + ".");
				if (!freshReceiptArmedLogged)
				{
					freshReceiptArmedLogged = true;
					ManualLogSource? obj = logger;
					if (obj != null)
					{
						obj.LogInfo((object)("Experimental warm receipt armed [warm-receipt=ready]: captured a fresh room-bound locally owned player " + experimentalRejoinWarmStateSnapshot.PlayerId + " / actor " + experimentalRejoinWarmStateSnapshot.ActorNumber + "."));
					}
				}
			}
		}

		internal static void NotifyRecoverableDisconnectAccepted(string cause)
		{
			lock (Gate)
			{
				if (!installed)
				{
					return;
				}
				frozenSnapshot = rollingSnapshot;
				rollingSnapshot = null;
				lastReceiptBlockCode = "receipt-frozen";
				lastReceiptBlockDetail = "The verified receipt is frozen for the active reconnect attempt.";
				if (frozenSnapshot == null)
				{
					SetState(ExperimentalWarmStateRestoreState.Rejected, "Recoverable disconnect " + cause + " had no verified local snapshot; warm restore will not be acknowledged.");
					ManualLogSource? obj = logger;
					if (obj != null)
					{
						obj.LogWarning((object)"Experimental warm rejoin has no verified local snapshot. Transport may retry, but gameplay state will remain pending.");
					}
					return;
				}
				SetState(ExperimentalWarmStateRestoreState.DisconnectFrozen, "Frozen pre-disconnect receipt for actor " + frozenSnapshot.ActorNumber + " after " + cause + ".");
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogInfo((object)("Experimental warm rejoin froze player " + frozenSnapshot.PlayerId + " / actor " + frozenSnapshot.ActorNumber + " state receipt."));
				}
			}
		}

		internal static void NotifyTransportRejoined()
		{
			lock (Gate)
			{
				if (installed)
				{
					if (frozenSnapshot == null)
					{
						lastReceiptBlockCode = "missing-frozen-receipt";
						lastReceiptBlockDetail = "Photon rejoined without a verified pre-disconnect gameplay receipt.";
						SetState(ExperimentalWarmStateRestoreState.Rejected, lastReceiptBlockDetail);
					}
					else
					{
						SetState(ExperimentalWarmStateRestoreState.AwaitingPointBoundary, "Photon actor returned; waiting for PointStart before gameplay validation.");
					}
				}
			}
		}

		internal static void NotifyAttemptAborted(string reason)
		{
			lock (Gate)
			{
				if (installed)
				{
					ClearReceipts("attempt-aborted", "The previous reconnect attempt ended; waiting for a new healthy receipt.");
					SetState(ExperimentalWarmStateRestoreState.Rejected, reason);
				}
			}
		}

		private static IEnumerator OnPointStart(IGameModeHandler gameMode)
		{
			if (!installed || !ExperimentalRejoin.NeedsWarmStateRestore)
			{
				yield break;
			}
			lock (Gate)
			{
				SetState(ExperimentalWarmStateRestoreState.ValidatingPointBoundary, "PointStart reached; waiting briefly for the owned player to be reconstructed.");
			}
			Player localPlayer = null;
			for (int frame = 0; frame < 8; frame++)
			{
				localPlayer = FindOwnedLocalPlayer();
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.data != (Object)null && !localPlayer.data.dead && localPlayer.data.health > 0f)
				{
					break;
				}
				yield return null;
			}
			if (!TryValidateAndNormalizeAtPointBoundary(localPlayer, out string rejection))
			{
				ExperimentalRejoin.RejectWarmStateAtPointBoundary(rejection);
				lock (Gate)
				{
					ClearReceipts("point-validation-rejected", "The previous receipt failed point-boundary validation; waiting for a new one.");
					SetState(ExperimentalWarmStateRestoreState.Rejected, rejection + " Current state was not fabricated; future stable receipts may arm again.");
				}
				ManualLogSource? obj = logger;
				if (obj != null)
				{
					obj.LogWarning((object)("Experimental warm rejoin rejected at PointStart and re-armed future receipt capture: " + rejection));
				}
			}
			else
			{
				ExperimentalRejoin.AcknowledgeWarmStateRestoredAtPointBoundary();
				lock (Gate)
				{
					ClearReceipts("receipt-consumed", "The verified receipt was consumed; waiting for a new healthy receipt.");
					SetState(ExperimentalWarmStateRestoreState.Restored, "Owned actor and exact deck matched; point-boundary ammo normalization completed.");
				}
				ManualLogSource? obj2 = logger;
				if (obj2 != null)
				{
					obj2.LogInfo((object)"Experimental warm rejoin validated the local player at PointStart. Transient card runtime state restarted from the new point.");
				}
			}
		}

		private static bool TryValidateAndNormalizeAtPointBoundary(Player? localPlayer, out string rejection)
		{
			ExperimentalRejoinWarmStateSnapshot experimentalRejoinWarmStateSnapshot;
			lock (Gate)
			{
				experimentalRejoinWarmStateSnapshot = frozenSnapshot;
			}
			if (experimentalRejoinWarmStateSnapshot == null)
			{
				rejection = "No frozen pre-disconnect receipt exists.";
				return false;
			}
			if (!ExperimentalRejoin.PhotonInRoom || !ExperimentalRejoin.PhotonIsConnectedAndReady || ExperimentalRejoin.PhotonIsMaster)
			{
				rejection = "Photon room/ownership preconditions are not valid for a non-host restore.";
				return false;
			}
			string text = ((PhotonNetwork.CurrentRoom == null) ? string.Empty : PhotonNetwork.CurrentRoom.Name);
			if (string.IsNullOrEmpty(text) || !string.Equals(experimentalRejoinWarmStateSnapshot.RoomName, text, StringComparison.Ordinal))
			{
				rejection = "Photon room identity changed after transport rejoin.";
				return false;
			}
			if (Time.realtimeSinceStartup - experimentalRejoinWarmStateSnapshot.CapturedAtRealtime > 300f)
			{
				rejection = "The pre-disconnect receipt expired before a safe point boundary.";
				return false;
			}
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.data == (Object)null || (Object)(object)localPlayer.data.view == (Object)null)
			{
				rejection = "The owned local player was not reconstructed within the frame budget.";
				return false;
			}
			if (!localPlayer.data.view.IsMine)
			{
				rejection = "The reconstructed player is not owned by this client.";
				return false;
			}
			if (localPlayer.playerID != experimentalRejoinWarmStateSnapshot.PlayerId)
			{
				rejection = "Player ID changed from " + experimentalRejoinWarmStateSnapshot.PlayerId + " to " + localPlayer.playerID + ".";
				return false;
			}
			if (localPlayer.data.view.OwnerActorNr != experimentalRejoinWarmStateSnapshot.ActorNumber)
			{
				rejection = "Photon actor changed from " + experimentalRejoinWarmStateSnapshot.ActorNumber + " to " + localPlayer.data.view.OwnerActorNr + ".";
				return false;
			}
			if (localPlayer.data.dead || localPlayer.data.health <= 0f || float.IsNaN(localPlayer.data.health) || float.IsInfinity(localPlayer.data.health) || localPlayer.data.maxHealth <= 0f || float.IsNaN(localPlayer.data.maxHealth) || float.IsInfinity(localPlayer.data.maxHealth))
			{
				rejection = "The point-boundary health state is not valid; health was not overwritten.";
				return false;
			}
			Dictionary<string, int> dictionary = CaptureCardMultiset(localPlayer.data);
			if (dictionary == null || !CardMultisetsMatch(experimentalRejoinWarmStateSnapshot.Cards, dictionary))
			{
				rejection = "The reconstructed deck does not exactly match the frozen deck.";
				return false;
			}
			GunAmmo val = FindAmmo(localPlayer);
			if (experimentalRejoinWarmStateSnapshot.MaxAmmo >= 0)
			{
				if ((Object)(object)val == (Object)null)
				{
					rejection = "The pre-disconnect player had ammo state, but GunAmmo is unavailable.";
					return false;
				}
				val.ReloadAmmo(false);
			}
			rejection = string.Empty;
			return true;
		}

		private static ExperimentalRejoinWarmStateSnapshot? TryCapture(Player player, out string blockCode, out string blockDetail)
		{
			if ((Object)(object)player.data == (Object)null || (Object)(object)player.data.view == (Object)null || !player.data.view.IsMine)
			{
				blockCode = "no-owned-player";
				blockDetail = "The selected ROUNDS player does not have a locally owned PhotonView.";
				return null;
			}
			string text = ((PhotonNetwork.CurrentRoom == null) ? string.Empty : PhotonNetwork.CurrentRoom.Name);
			int ownerActorNr = player.data.view.OwnerActorNr;
			if (string.IsNullOrEmpty(text))
			{
				blockCode = "no-room";
				blockDetail = "Photon CurrentRoom has no exact room name for the receipt.";
				return null;
			}
			if (ownerActorNr <= 0)
			{
				blockCode = "invalid-actor";
				blockDetail = "The locally owned player PhotonView has no valid owner actor number.";
				return null;
			}
			Dictionary<string, int> dictionary = CaptureCardMultiset(player.data);
			if (dictionary == null)
			{
				blockCode = "invalid-deck";
				blockDetail = "The locally owned player's exact card multiset could not be captured.";
				return null;
			}
			GunAmmo val = FindAmmo(player);
			blockCode = "ready";
			blockDetail = "A fresh locally owned non-host room receipt is available.";
			return new ExperimentalRejoinWarmStateSnapshot(text, Time.realtimeSinceStartup, player.playerID, ownerActorNr, player.data.view.ViewID, player.data.health, player.data.maxHealth, ((Object)(object)val != (Object)null) ? val.maxAmmo : (-1), dictionary);
		}

		private static void SetReceiptBlocked(string code, string blockedDetail)
		{
			lastReceiptBlockCode = code;
			lastReceiptBlockDetail = blockedDetail;
			if (rollingSnapshot != null)
			{
				float num = Time.realtimeSinceStartup - rollingSnapshot.CapturedAtRealtime;
				if (num <= 1f && !string.Equals(code, "host", StringComparison.Ordinal))
				{
					SetState(ExperimentalWarmStateRestoreState.SnapshotReady, "Last verified receipt remains eligible for " + Math.Max(0f, 1f - num).ToString("0.000", CultureInfo.InvariantCulture) + "s; refresh blocked [" + code + "]: " + blockedDetail);
					return;
				}
				rollingSnapshot = null;
			}
			SetState(ExperimentalWarmStateRestoreState.Monitoring, "Receipt unavailable [" + code + "]: " + blockedDetail);
		}

		private static void ClearReceipts(string code, string clearedDetail)
		{
			rollingSnapshot = null;
			frozenSnapshot = null;
			lastReceiptBlockCode = code;
			lastReceiptBlockDetail = clearedDetail;
		}

		private static Player? FindOwnedLocalPlayer()
		{
			if ((Object)(object)PlayerManager.instance == (Object)null || PlayerManager.instance.players == null)
			{
				return null;
			}
			foreach (Player player in PlayerManager.instance.players)
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.data != (Object)null && (Object)(object)player.data.view != (Object)null && player.data.view.IsMine)
				{
					return player;
				}
			}
			return null;
		}

		private static GunAmmo? FindAmmo(Player player)
		{
			if ((Object)(object)player.data != (Object)null && (Object)(object)player.data.weaponHandler != (Object)null && (Object)(object)player.data.weaponHandler.gun != (Object)null)
			{
				GunAmmo componentInChildren = ((Component)player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					return componentInChildren;
				}
			}
			return ((Component)player).GetComponentInChildren<GunAmmo>();
		}

		private static Dictionary<string, int>? CaptureCardMultiset(CharacterData data)
		{
			if (data.currentCards == null)
			{
				return null;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			for (int i = 0; i < data.currentCards.Count; i++)
			{
				CardInfo val = data.currentCards[i];
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				string text = ((Object)val).name ?? string.Empty;
				string text2 = val.cardName ?? string.Empty;
				if (string.IsNullOrEmpty(text) && string.IsNullOrEmpty(text2))
				{
					return null;
				}
				string key = text + "\u001f" + text2;
				dictionary.TryGetValue(key, out var value);
				dictionary[key] = value + 1;
			}
			return dictionary;
		}

		private static bool CardMultisetsMatch(IReadOnlyDictionary<string, int> expected, IReadOnlyDictionary<string, int> actual)
		{
			if (expected.Count != actual.Count)
			{
				return false;
			}
			foreach (KeyValuePair<string, int> item in expected)
			{
				if (!actual.TryGetValue(item.Key, out var value) || value != item.Value)
				{
					return false;
				}
			}
			return true;
		}

		private static void SetState(ExperimentalWarmStateRestoreState newState, string newDetail)
		{
			state = newState;
			detail = newDetail;
		}
	}
	internal sealed class ExperimentalRejoinWarmStateBehaviour : MonoBehaviour
	{
		private const float SnapshotIntervalSeconds = 0.25f;

		private float nextSnapshotAt;

		private void Update()
		{
			if (!(Time.realtimeSinceStartup < nextSnapshotAt))
			{
				nextSnapshotAt = Time.realtimeSinceStartup + 0.25f;
				ExperimentalRejoinController.TickSnapshot();
			}
		}
	}
	internal sealed class ExperimentalRejoinWarmStateSnapshot
	{
		public string RoomName { get; }

		public float CapturedAtRealtime { get; }

		public int PlayerId { get; }

		public int ActorNumber { get; }

		public int ViewId { get; }

		public float Health { get; }

		public float MaxHealth { get; }

		public int MaxAmmo { get; }

		public IReadOnlyDictionary<string, int> Cards { get; }

		public ExperimentalRejoinWarmStateSnapshot(string roomName, float capturedAtRealtime, int playerId, int actorNumber, int viewId, float health, float maxHealth, int maxAmmo, Dictionary<string, int> cards)
		{
			RoomName = roomName ?? throw new ArgumentNullException("roomName");
			CapturedAtRealtime = capturedAtRealtime;
			PlayerId = playerId;
			ActorNumber = actorNumber;
			ViewId = viewId;
			Health = health;
			MaxHealth = maxHealth;
			MaxAmmo = maxAmmo;
			Cards = cards ?? throw new ArgumentNullException("cards");
		}
	}
	internal sealed class ReliabilityDiagnosticsWriter
	{
		private readonly object sync = new object();

		private readonly SessionReliabilityOptions options;

		private readonly ManualLogSource logger;

		private string? currentFile;

		private bool writeFailureReported;

		public ReliabilityDiagnosticsWriter(SessionReliabilityOptions options, ManualLogSource logger)
		{
			this.options = options;
			this.logger = logger;
		}

		public void Write(SessionReliabilitySnapshot snapshot, ReliabilityRuntimeSample[] recentSamples, ExceptionFingerprint[] recentExceptions)
		{
			if (!options.WriteDiagnosticsToDisk)
			{
				return;
			}
			lock (sync)
			{
				try
				{
					EnsureDestination();
					if (currentFile != null)
					{
						string text = Serialize(snapshot, recentSamples, recentExceptions);
						if (File.Exists(currentFile) && new FileInfo(currentFile).Length + Encoding.UTF8.GetByteCount(text) + 2 > options.MaximumDiagnosticFileBytes)
						{
							currentFile = CreateFileName();
							PruneOldFiles();
						}
						File.AppendAllText(currentFile, text + Environment.NewLine, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					}
				}
				catch (Exception ex)
				{
					if (!writeFailureReported)
					{
						writeFailureReported = true;
						logger.LogWarning((object)("Session Reliability could not write diagnostics (" + ex.GetType().Name + "). Runtime monitoring will continue in memory."));
					}
				}
			}
		}

		private void EnsureDestination()
		{
			if (currentFile == null)
			{
				Directory.CreateDirectory(options.DiagnosticsDirectory);
				currentFile = CreateFileName();
				PruneOldFiles();
				logger.LogInfo((object)("Session Reliability diagnostics enabled: " + Path.GetFileName(currentFile)));
			}
		}

		private string CreateFileName()
		{
			string path = "session-reliability-" + DateTime.UtcNow.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture) + "-" + Guid.NewGuid().ToString("N").Substring(0, 8) + ".jsonl";
			return Path.Combine(options.DiagnosticsDirectory, path);
		}

		private void PruneOldFiles()
		{
			string[] files = Directory.GetFiles(options.DiagnosticsDirectory, "session-reliability-*.jsonl");
			Array.Sort(files, (string left, string right) => File.GetLastWriteTimeUtc(right).CompareTo(File.GetLastWriteTimeUtc(left)));
			for (int num = Math.Max(0, options.MaximumDiagnosticFiles - 1); num < files.Length; num++)
			{
				try
				{
					File.Delete(files[num]);
				}
				catch
				{
				}
			}
		}

		private static string Serialize(SessionReliabilitySnapshot snapshot, ReliabilityRuntimeSample[] samples, ExceptionFingerprint[] exceptions)
		{
			StringBuilder stringBuilder = new StringBuilder(2048);
			stringBuilder.Append('{');
			Add(stringBuilder, "schema", "reksik-session-reliability-v2");
			Add(stringBuilder, "utc", snapshot.Utc.ToString("O", CultureInfo.InvariantCulture));
			Add(stringBuilder, "reason", snapshot.Reason);
			Add(stringBuilder, "previousClientState", snapshot.PreviousClientState);
			Add(stringBuilder, "photonAvailable", snapshot.PhotonAvailable);
			Add(stringBuilder, "photonProbeStatus", snapshot.PhotonProbeStatus);
			AddPropertyName(stringBuilder, "photonProbeIssues");
			AppendStringArray(stringBuilder, snapshot.PhotonProbeIssues);
			Add(stringBuilder, "connected", snapshot.IsConnected);
			Add(stringBuilder, "ready", snapshot.IsReady);
			Add(stringBuilder, "inRoom", snapshot.InRoom);
			Add(stringBuilder, "isMasterClient", snapshot.IsMasterClient);
			Add(stringBuilder, "clientState", snapshot.ClientState);
			Add(stringBuilder, "disconnectCause", snapshot.DisconnectCause);
			Add(stringBuilder, "roomFingerprint", snapshot.AnonymousRoomFingerprint);
			Add(stringBuilder, "playerCount", snapshot.PlayerCount);
			Add(stringBuilder, "maximumPlayers", snapshot.MaximumPlayers);
			AddNullable(stringBuilder, "roomIsOpen", snapshot.RoomIsOpen);
			Add(stringBuilder, "playerObjects", snapshot.ActivePlayerObjectCount);
			Add(stringBuilder, "photonViews", snapshot.PhotonViewCount);
			Add(stringBuilder, "projectiles", snapshot.ProjectileCount);
			Add(stringBuilder, "gameplayEntities", snapshot.GameplayEntityCount);
			Add(stringBuilder, "particleSystems", snapshot.ParticleSystemCount);
			Add(stringBuilder, "trails", snapshot.TrailCount);
			Add(stringBuilder, "exceptionsTotal", snapshot.ExceptionCount);
			Add(stringBuilder, "errorsTotal", snapshot.ErrorCount);
			Add(stringBuilder, "errorEventsLastMinute", snapshot.ErrorEventsLastMinute);
			AddPropertyName(stringBuilder, "compatibility");
			AppendStringArray(stringBuilder, snapshot.CompatibilityInventory);
			AddPropertyName(stringBuilder, "recentSamples");
			stringBuilder.Append('[');
			for (int i = 0; i < samples.Length; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(',');
				}
				ReliabilityRuntimeSample reliabilityRuntimeSample = samples[i];
				stringBuilder.Append('{');
				Add(stringBuilder, "utc", reliabilityRuntimeSample.Utc.ToString("O", CultureInfo.InvariantCulture));
				Add(stringBuilder, "state", reliabilityRuntimeSample.Photon.ClientState);
				Add(stringBuilder, "probeStatus", reliabilityRuntimeSample.Photon.ProbeStatus);
				Add(stringBuilder, "connected", reliabilityRuntimeSample.Photon.IsConnected);
				Add(stringBuilder, "ready", reliabilityRuntimeSample.Photon.IsReady);
				Add(stringBuilder, "inRoom", reliabilityRuntimeSample.Photon.InRoom);
				Add(stringBuilder, "players", reliabilityRuntimeSample.Photon.PlayerCount);
				Add(stringBuilder, "photonViews", reliabilityRuntimeSample.Counts.PhotonViews);
				Add(stringBuilder, "projectiles", reliabilityRuntimeSample.Counts.Projectiles);
				Add(stringBuilder, "entities", reliabilityRuntimeSample.Counts.GameplayEntities);
				TrimComma(stringBuilder);
				stringBuilder.Append('}');
			}
			stringBuilder.Append(']');
			AddPropertyName(stringBuilder, "recentErrors");
			stringBuilder.Append('[');
			for (int j = 0; j < exceptions.Length; j++)
			{
				if (j > 0)
				{
					stringBuilder.Append(',');
				}
				ExceptionFingerprint exceptionFingerprint = exceptions[j];
				stringBuilder.Append('{');
				Add(stringBuilder, "utc", exceptionFingerprint.Utc.ToString("O", CultureInfo.InvariantCulture));
				Add(stringBuilder, "severity", exceptionFingerprint.Severity);
				Add(stringBuilder, "category", exceptionFingerprint.Category);
				Add(stringBuilder, "fingerprint", exceptionFingerprint.Fingerprint);
				TrimComma(stringBuilder);
				stringBuilder.Append('}');
			}
			stringBuilder.Append(']');
			TrimComma(stringBuilder);
			stringBuilder.Append('}');
			return stringBuilder.ToString();
		}

		private static void Add(StringBuilder json, string name, string value)
		{
			AddPropertyName(json, name);
			AppendQuoted(json, value);
			json.Append(',');
		}

		private static void Add(StringBuilder json, string name, bool value)
		{
			AddPropertyName(json, name);
			json.Append(value ? "true" : "false").Append(',');
		}

		private static void Add(StringBuilder json, string name, int value)
		{
			AddPropertyName(json, name);
			json.Append(value.ToString(CultureInfo.InvariantCulture)).Append(',');
		}

		private static void Add(StringBuilder json, string name, long value)
		{
			AddPropertyName(json, name);
			json.Append(value.ToString(CultureInfo.InvariantCulture)).Append(',');
		}

		private static void AddNullable(StringBuilder json, string name, bool? value)
		{
			AddPropertyName(json, name);
			json.Append((!value.HasValue) ? "null" : (value.Value ? "true" : "false")).Append(',');
		}

		private static void AddPropertyName(StringBuilder json, string name)
		{
			if (json.Length > 0 && json[json.Length - 1] != '{' && json[json.Length - 1] != '[' && json[json.Length - 1] != ',')
			{
				json.Append(',');
			}
			AppendQuoted(json, name);
			json.Append(':');
		}

		private static void AppendStringArray(StringBuilder json, IReadOnlyList<string> values)
		{
			json.Append('[');
			for (int i = 0; i < values.Count; i++)
			{
				if (i > 0)
				{
					json.Append(',');
				}
				AppendQuoted(json, values[i]);
			}
			json.Append(']');
		}

		private static void AppendQuoted(StringBuilder json, string value)
		{
			json.Append('"');
			foreach (char c in value)
			{
				switch (c)
				{
				case '"':
					json.Append("\\\"");
					continue;
				case '\\':
					json.Append("\\\\");
					continue;
				case '\b':
					json.Append("\\b");
					continue;
				case '\f':
					json.Append("\\f");
					continue;
				case '\n':
					json.Append("\\n");
					continue;
				case '\r':
					json.Append("\\r");
					continue;
				case '\t':
					json.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder = json.Append("\\u");
					int num = c;
					stringBuilder.Append(num.ToString("x4"));
				}
				else
				{
					json.Append(c);
				}
			}
			json.Append('"');
		}

		private static void TrimComma(StringBuilder json)
		{
			if (json.Length > 0 && json[json.Length - 1] == ',')
			{
				json.Length--;
			}
		}
	}
	internal sealed class RuntimeReliabilityProbe
	{
		private const int MaxIssues = 16;

		private readonly Dictionary<string, Type?> typeCache = new Dictionary<string, Type>();

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

		private readonly List<string> knownIssues = new List<string>(16);

		private readonly List<string> currentIssues = new List<string>(16);

		private readonly string sessionPrivacySalt = Guid.NewGuid().ToString("N");

		private readonly ManualLogSource logger;

		private WorldCounts lastWorldCounts = WorldCounts.Unknown;

		private float nextWorldCountAt;

		public RuntimeReliabilityProbe(ManualLogSource suppliedLogger)
		{
			logger = suppliedLogger ?? throw new ArgumentNullException("suppliedLogger");
		}

		public ReliabilityRuntimeSample Sample(float realtime, float worldCountInterval)
		{
			PhotonState photon = ReadPhotonState();
			if (realtime >= nextWorldCountAt)
			{
				nextWorldCountAt = realtime + worldCountInterval;
				lastWorldCounts = ReadWorldCounts();
			}
			return new ReliabilityRuntimeSample(DateTime.UtcNow, photon, lastWorldCounts);
		}

		public string[] CaptureCompatibilityInventory()
		{
			try
			{
				List<string> list = new List<string>(Chainloader.PluginInfos.Count);
				foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
				{
					string value = pluginInfo.Value.Metadata.GUID ?? pluginInfo.Key;
					string value2 = pluginInfo.Value.Metadata.Version?.ToString() ?? "unknown";
					list.Add(SanitizeIdentifier(value) + "@" + SanitizeIdentifier(value2));
				}
				list.Sort(StringComparer.Ordinal);
				return list.ToArray();
			}
			catch
			{
				return Array.Empty<string>();
			}
		}

		private PhotonState ReadPhotonState()
		{
			currentIssues.Clear();
			Type type = ResolveType("Photon.Pun.PhotonNetwork");
			if (type == null)
			{
				ReportPhotonIssue("network.type", "MissingType");
				return PhotonState.UnavailableWith(CaptureIssues());
			}
			object obj = ReadMember(type, null, "NetworkingClient", isStatic: true, "network.client");
			object obj2 = ReadMember(type, null, "CurrentRoom", isStatic: true, "network.room") ?? ReadMember(obj?.GetType(), obj, "CurrentRoom", isStatic: false, "client.room");
			bool value;
			bool flag = TryReadBool(type, null, "IsConnected", isStatic: true, "network.connected", out value);
			TryReadBool(type, null, "IsConnectedAndReady", isStatic: true, "network.ready", out var value2);
			bool value3;
			bool flag2 = TryReadBool(type, null, "InRoom", isStatic: true, "network.inRoom", out value3);
			bool value4 = false;
			if (value3)
			{
				TryReadBool(type, null, "IsMasterClient", isStatic: true, "network.isMaster", out value4);
			}
			string value5 = Convert.ToString(ReadMember(type, null, "NetworkClientState", isStatic: true, "network.state") ?? ReadMember(obj?.GetType(), obj, "State", isStatic: false, "client.state")) ?? "unknown";
			string value6 = Convert.ToString(ReadMember(obj?.GetType(), obj, "DisconnectedCause", isStatic: false, "client.disconnectCause") ?? ReadMember(obj?.GetType(), obj, "DisconnectCause", isStatic: false, "client.disconnectCauseLegacy")) ?? string.Empty;
			string empty = string.Empty;
			string roomFingerprint = string.Empty;
			int playerCount = -1;
			int maxPlayers = -1;
			bool? roomIsOpen = null;
			if (value3 && obj2 != null)
			{
				empty = Convert.ToString(ReadMember(obj2.GetType(), obj2, "Name", isStatic: false, "room.name")) ?? string.Empty;
				roomFingerprint = ((empty.Length == 0) ? string.Empty : ("anon-" + ExceptionRateMonitor.StableHash(sessionPrivacySalt + "|" + empty)));
				playerCount = ReadInt(ReadMember(obj2.GetType(), obj2, "PlayerCount", isStatic: false, "room.playerCount"), -1);
				maxPlayers = ReadInt(ReadMember(obj2.GetType(), obj2, "MaxPlayers", isStatic: false, "room.maxPlayers"), -1);
				roomIsOpen = ReadNullableBool(ReadMember(obj2.GetType(), obj2, "IsOpen", isStatic: false, "room.isOpen"));
			}
			string[] array = CaptureIssues();
			string probeStatus = ((!(flag && flag2)) ? "unavailable" : ((array.Length == 0) ? "ok" : "partial"));
			return new PhotonState(available: true, flag, flag2, value, value2, value3, value4, SanitizeIdentifier(value5), SanitizeIdentifier(value6), roomFingerprint, playerCount, maxPlayers, roomIsOpen, probeStatus, array);
		}

		private WorldCounts ReadWorldCounts()
		{
			return new WorldCounts(CountObjects("Player"), CountObjects("Photon.Pun.PhotonView"), CountObjects("ProjectileHit"), CountObjects("HealthHandler"), CountObjects("UnityEngine.ParticleSystem"), CountObjects("UnityEngine.TrailRenderer"));
		}

		private int CountObjects(string fullName)
		{
			Type type = ResolveType(fullName);
			if (type == null)
			{
				return -1;
			}
			try
			{
				Object[] array = Object.FindObjectsOfType(type);
				return (array != null) ? array.Length : 0;
			}
			catch
			{
				return -1;
			}
		}

		private Type? ResolveType(string fullName)
		{
			if (typeCache.TryGetValue(fullName, out Type value))
			{
				return value;
			}
			Type type = Type.GetType(fullName + ", Assembly-CSharp", throwOnError: false) ?? Type.GetType(fullName + ", PhotonUnityNetworking", throwOnError: false) ?? Type.GetType(fullName + ", UnityEngine.CoreModule", throwOnError: false) ?? Type.GetType(fullName + ", UnityEngine.ParticleSystemModule", throwOnError: false);
			if (type == null)
			{
				Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
				for (int i = 0; i < assemblies.Length; i++)
				{
					type = assemblies[i].GetType(fullName, throwOnError: false);
					if (type != null)
					{
						break;
					}
				}
			}
			typeCache[fullName] = type;
			return type;
		}

		private static MemberInfo? FindReadableMember(Type type, string name, bool isStatic)
		{
			BindingFlags bindingAttr = (BindingFlags)(0x32 | (isStatic ? 8 : 4));
			Type type2 = type;
			while (type2 != null)
			{
				PropertyInfo[] properties = type2.GetProperties(bindingAttr);
				foreach (PropertyInfo propertyInfo in properties)
				{
					if (propertyInfo.Name == name && propertyInfo.GetIndexParameters().Length == 0 && propertyInfo.GetMethod != null)
					{
						return propertyInfo;
					}
				}
				FieldInfo[] fields = type2.GetFields(bindingAttr);
				for (int j = 0; j < fields.Length; j++)
				{
					if (fields[j].Name == name)
					{
						return fields[j];
					}
				}
				type2 = type2.BaseType;
			}
			return null;
		}

		private object? ReadMember(Type? type, object? instance, string name, bool isStatic, string stage)
		{
			if (type == null)
			{
				ReportPhotonIssue(stage, "MissingOwner");
				return null;
			}
			try
			{
				MemberInfo memberInfo = FindReadableMember(type, name, isStatic);
				if (memberInfo == null)
				{
					ReportPhotonIssue(stage, "MissingMember");
					return null;
				}
				return (memberInfo is PropertyInfo propertyInfo) ? propertyInfo.GetValue(instance, null) : ((FieldInfo)memberInfo).GetValue(instance);
			}
			catch (Exception ex)
			{
				Exception ex2 = ((ex is TargetInvocationException { InnerException: not null } ex3) ? ex3.InnerException : ex);
				ReportPhotonIssue(stage, ex2.GetType().Name);
				return null;
			}
		}

		private bool TryReadBool(Type type, object? instance, string name, bool isStatic, string stage, out bool value)
		{
			if (ReadMember(type, instance, name, isStatic, stage) is bool flag)
			{
				value = flag;
				return true;
			}
			value = false;
			ReportPhotonIssue(stage, "InvalidBool");
			return false;
		}

		private void ReportPhotonIssue(string stage, string issueType)
		{
			string text = SanitizeIdentifier(stage) + ":" + SanitizeIdentifier(issueType);
			if (currentIssues.Count < 16 && !currentIssues.Contains(text))
			{
				currentIssues.Add(text);
			}
			if (knownIssues.Count < 16 && issueKeys.Add(text))
			{
				knownIssues.Add(text);
				logger.LogWarning((object)("Session Reliability Photon probe partial: " + text + "."));
			}
		}

		private string[] CaptureIssues()
		{
			return currentIssues.ToArray();
		}

		private static bool? ReadNullableBool(object? value)
		{
			if (!(value is bool))
			{
				return null;
			}
			return (bool)value;
		}

		private static int ReadInt(object? value, int fallback)
		{
			try
			{
				return (value == null) ? fallback : Convert.ToInt32(value);
			}
			catch
			{
				return fallback;
			}
		}

		private static string SanitizeIdentifier(string value)
		{
			if (string.IsNullOrEmpty(value))
			{
				return string.Empty;
			}
			char[] array = new char[Math.Min(value.Length, 160)];
			int num = 0;
			for (int i = 0; i < value.Length; i++)
			{
				if (num >= array.Length)
				{
					break;
				}
				char c = value[i];
				if (char.IsLetterOrDigit(c) || c == '.' || c == '_' || c == '-' || c == '+' || c == '@' || c == ':')
				{
					array[num++] = c;
				}
			}
			if (num != 0)
			{
				return new string(array, 0, num);
			}
			return "unknown";
		}
	}
	internal readonly struct ReliabilityRuntimeSample
	{
		public DateTime Utc { get; }

		public PhotonState Photon { get; }

		public WorldCounts Counts { get; }

		public ReliabilityRuntimeSample(DateTime utc, PhotonState photon, WorldCounts counts)
		{
			Utc = utc;
			Photon = photon;
			Counts = counts;
		}
	}
	internal readonly struct PhotonState
	{
		public static readonly PhotonState Unavailable = UnavailableWith(Array.Empty<string>());

		public bool Available { get; }

		public bool ConnectionSignalValid { get; }

		public bool RoomSignalValid { get; }

		public bool IsConnected { get; }

		public bool IsReady { get; }

		public bool InRoom { get; }

		public bool IsMasterClient { get; }

		public string ClientState { get; }

		public string DisconnectCause { get; }

		public string RoomFingerprint { get; }

		public int PlayerCount { get; }

		public int MaxPlayers { get; }

		public bool? RoomIsOpen { get; }

		public string ProbeStatus { get; }

		public string[] ProbeIssues { get; }

		public static PhotonState UnavailableWith(string[] issues)
		{
			return new PhotonState(available: false, connectionSignalValid: false, roomSignalValid: false, isConnected: false, isReady: false, inRoom: false, isMasterClient: false, "unavailable", string.Empty, string.Empty, -1, -1, null, "unavailable", issues);
		}

		public PhotonState(bool available, bool connectionSignalValid, bool roomSignalValid, bool isConnected, bool isReady, bool inRoom, bool isMasterClient, string clientState, string disconnectCause, string roomFingerprint, int playerCount, int maxPlayers, bool? roomIsOpen, string probeStatus, string[] probeIssues)
		{
			Available = available;
			ConnectionSignalValid = connectionSignalValid;
			RoomSignalValid = roomSignalValid;
			IsConnected = isConnected;
			IsReady = isReady;
			InRoom = inRoom;
			IsMasterClient = isMasterClient;
			ClientState = clientState;
			DisconnectCause = disconnectCause;
			RoomFingerprint = roomFingerprint;
			PlayerCount = playerCount;
			MaxPlayers = maxPlayers;
			RoomIsOpen = roomIsOpen;
			ProbeStatus = probeStatus;
			ProbeIssues = probeIssues ?? Array.Empty<string>();
		}
	}
	internal readonly struct WorldCounts
	{
		public static readonly WorldCounts Unknown = new WorldCounts(-1, -1, -1, -1, -1, -1);

		public int Players { get; }

		public int PhotonViews { get; }

		public int Projectiles { get; }

		public int GameplayEntities { get; }

		public int ParticleSystems { get; }

		public int Trails { get; }

		public WorldCounts(int players, int photonViews, int projectiles, int gameplayEntities, int particleSystems, int trails)
		{
			Players = players;
			PhotonViews = photonViews;
			Projectiles = projectiles;
			GameplayEntities = gameplayEntities;
			ParticleSystems = particleSystems;
			Trails = trails;
		}
	}
	public static class SessionReliabilityApi
	{
		private static SessionReliabilityMonitor? monitor;

		public static bool IsRunning
		{
			get
			{
				if ((Object)(object)monitor != (Object)null)
				{
					return monitor.IsActive;
				}
				return false;
			}
		}

		public static SessionReliabilitySnapshot? LatestSnapshot => monitor?.LatestSnapshot;

		public static SessionReliabilityMonitor Start(BaseUnityPlugin plugin, ManualLogSource logger, SessionReliabilityOptions? options = null)
		{
			if ((Object)(object)plugin == (Object)null)
			{
				throw new ArgumentNullException("plugin");
			}
			if (logger == null)
			{
				throw new ArgumentNullException("logger");
			}
			if ((Object)(object)monitor != (Object)null)
			{
				monitor.Reconfigure(options ?? new SessionReliabilityOptions(), logger);
				return monitor;
			}
			SessionReliabilityMonitor obj = ((Component)plugin).gameObject.GetComponent<SessionReliabilityMonitor>() ?? ((Component)plugin).gameObject.AddComponent<SessionReliabilityMonitor>();
			obj.Initialize(options ?? new SessionReliabilityOptions(), logger);
			monitor = obj;
			return obj;
		}

		public static SessionReliabilitySnapshot? Capture(string reason = "manual")
		{
			return monitor?.CaptureSnapshot(reason);
		}

		public static void Stop()
		{
			if (!((Object)(object)monitor == (Object)null))
			{
				SessionReliabilityMonitor sessionReliabilityMonitor = monitor;
				monitor = null;
				sessionReliabilityMonitor.Shutdown();
				if ((Object)(object)sessionReliabilityMonitor != (Object)null)
				{
					Object.Destroy((Object)(object)sessionReliabilityMonitor);
				}
			}
		}

		internal static void NotifyDestroyed(SessionReliabilityMonitor destroyed)
		{
			if (monitor == destroyed)
			{
				monitor = null;
			}
		}
	}
	public sealed class SessionReliabilityMonitor : MonoBehaviour
	{
		private readonly Queue<ReliabilityRuntimeSample> recentSamples = new Queue<ReliabilityRuntimeSample>();

		private SessionReliabilityOptions? options;

		private ManualLogSource? logger;

		private RuntimeReliabilityProbe? probe;

		private ExceptionRateMonitor? exceptionMonitor;

		private ReliabilityDiagnosticsWriter? writer;

		private ReliabilityRuntimeSample lastSample;

		private bool hasSample;

		private bool initialized;

		private float nextSampleAt;

		private float nextSummaryAt;

		private string previousClientState = "unknown";

		private string lastKnownRoomFingerprint = string.Empty;

		private string[] compatibilityInventory = Array.Empty<string>();

		public bool IsActive => initialized;

		public SessionReliabilitySnapshot? LatestSnapshot { get; private set; }

		internal void Initialize(SessionReliabilityOptions suppliedOptions, ManualLogSource suppliedLogger)
		{
			if (!initialized)
			{
				suppliedOptions.Normalize();
				options = suppliedOptions;
				logger = suppliedLogger;
				if (!options.Enabled)
				{
					logger.LogInfo((object)"Session Reliability diagnostics are disabled.");
					return;
				}
				recentSamples.Clear();
				hasSample = false;
				previousClientState = "unknown";
				lastKnownRoomFingerprint = string.Empty;
				LatestSnapshot = null;
				nextSummaryAt = 0f;
				probe = new RuntimeReliabilityProbe(suppliedLogger);
				exceptionMonitor = new ExceptionRateMonitor(options.RecentExceptionCapacity);
				writer = new ReliabilityDiagnosticsWriter(options, logger);
				compatibilityInventory = probe.CaptureCompatibilityInventory();
				initialized = true;
				nextSampleAt = 0f;
				logger.LogInfo((object)"Session Reliability passive recorder started.");
			}
		}

		internal void Reconfigure(SessionReliabilityOptions suppliedOptions, ManualLogSource suppliedLogger)
		{
			if (initialized)
			{
				Shutdown();
			}
			Initialize(suppliedOptions, suppliedLogger);
		}

		public SessionReliabilitySnapshot? CaptureSnapshot(string reason = "manual")
		{
			if (!initialized || options == null || probe == null || exceptionMonitor == null || writer == null)
			{
				return null;
			}
			ReliabilityRuntimeSample sample = (hasSample ? lastSample : probe.Sample(Time.realtimeSinceStartup, options.WorldCountIntervalSeconds));
			if (!hasSample)
			{
				RecordSample(sample);
			}
			ExceptionRateSnapshot exceptions = exceptionMonitor.Capture(DateTime.UtcNow);
			string reason2 = SanitizeReason(reason);
			SessionReliabilitySnapshot sessionReliabilitySnapshot = (LatestSnapshot = new SessionReliabilitySnapshot(DateTime.UtcNow, reason2, previousClientState, lastKnownRoomFingerprint, sample, exceptions, compatibilityInventory));
			writer.Write(sessionReliabilitySnapshot, recentSamples.ToArray(), exceptions.Recent);
			return sessionReliabilitySnapshot;
		}

		internal void Shutdown()
		{
			if (initialized)
			{
				CaptureSnapshot("shutdown");
				exceptionMonitor?.Dispose();
				exceptionMonitor = null;
				initialized = false;
			}
		}

		private void Update()
		{
			if (!initialized || options == null || probe == null)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup < nextSampleAt))
			{
				nextSampleAt = realtimeSinceStartup + options.SampleIntervalSeconds;
				ReliabilityRuntimeSample sample = probe.Sample(realtimeSinceStartup, options.WorldCountIntervalSeconds);
				bool num = hasSample && lastSample.Photon.ConnectionSignalValid && sample.Photon.ConnectionSignalValid && lastSample.Photon.IsConnected && !sample.Photon.IsConnected;
				bool flag = hasSample && lastSample.Photon.RoomSignalValid && sample.Photon.RoomSignalValid && lastSample.Photon.InRoom && !sample.Photon.InRoom;
				previousClientState = (hasSample ? lastSample.Photon.ClientState : "none");
				RecordSample(sample);
				if (realtimeSinceStartup >= nextSummaryAt)
				{
					nextSummaryAt = realtimeSinceStartup + 2f;
					RefreshLatestSnapshot(sample);
				}
				if (num)
				{
					CaptureSnapshot("disconnect");
				}
				else if (flag)
				{
					CaptureSnapshot("room-leave");
				}
			}
		}

		private void RecordSample(ReliabilityRuntimeSample sample)
		{
			if (options != null)
			{
				if (!string.IsNullOrEmpty(sample.Photon.RoomFingerprint))
				{
					lastKnownRoomFingerprint = sample.Photon.RoomFingerprint;
				}
				lastSample = sample;
				hasSample = true;
				recentSamples.Enqueue(sample);
				while (recentSamples.Count > options.RecentSampleCapacity)
				{
					recentSamples.Dequeue();
				}
			}
		}

		private void RefreshLatestSnapshot(ReliabilityRuntimeSample sample)
		{
			if (exceptionMonitor != null)
			{
				ExceptionRateSnapshot exceptions = exceptionMonitor.Capture(DateTime.UtcNow, includeRecent: false);
				LatestSnapshot = new SessionReliabilitySnapshot(DateTime.UtcNow, "sample", previousClientState, lastKnownRoomFingerprint, sample, exceptions, compatibilityInventory);
			}
		}

		private void OnApplicationQuit()
		{
			if (initialized)
			{
				CaptureSnapshot("application-quit");
			}
		}

		private void OnDestroy()
		{
			Shutdown();
			SessionReliabilityApi.NotifyDestroyed(this);
		}

		private static string SanitizeReason(string reason)
		{
			if (string.IsNullOrWhiteSpace(reason))
			{
				return "manual";
			}
			char[] array = new char[Math.Min(reason.Length, 48)];
			int num = 0;
			for (int i = 0; i < reason.Length; i++)
			{
				if (num >= array.Length)
				{
					break;
				}
				char c = reason[i];
				if (char.IsLetterOrDigit(c) || c == '-' || c == '_' || c == '.')
				{
					array[num++] = c;
				}
			}
			if (num != 0)
			{
				return new string(array, 0, num);
			}
			return "manual";
		}
	}
	public sealed class SessionReliabilityOptions
	{
		public bool Enabled { get; set; } = true;

		public bool WriteDiagnosticsToDisk { get; set; } = true;

		public float SampleIntervalSeconds { get; set; } = 1f;

		public float WorldCountIntervalSeconds { get; set; } = 10f;

		public int RecentSampleCapacity { get; set; } = 30;

		public int RecentExceptionCapacity { get; set; } = 48;

		public int MaximumDiagnosticFiles { get; set; } = 5;

		public long MaximumDiagnosticFileBytes { get; set; } = 2097152L;

		public string DiagnosticsDirectory { get; set; } = Path.Combine(Paths.ConfigPath, "ReksikPerformance", "diagnostics");

		internal void Normalize()
		{
			SampleIntervalSeconds = Clamp(SampleIntervalSeconds, 0.25f, 30f);
			WorldCountIntervalSeconds = Clamp(WorldCountIntervalSeconds, SampleIntervalSeconds, 120f);
			RecentSampleCapacity = Clamp(RecentSampleCapacity, 5, 120);
			RecentExceptionCapacity = Clamp(RecentExceptionCapacity, 8, 256);
			MaximumDiagnosticFiles = Clamp(MaximumDiagnosticFiles, 1, 20);
			MaximumDiagnosticFileBytes = Clamp(MaximumDiagnosticFileBytes, 65536L, 16777216L);
		}

		private static float Clamp(float value, float min, float max)
		{
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return min;
			}
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static int Clamp(int value, int min, int max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}

		private static long Clamp(long value, long min, long max)
		{
			if (value >= min)
			{
				if (value <= max)
				{
					return value;
				}
				return max;
			}
			return min;
		}
	}
	public sealed class SessionReliabilitySnapshot
	{
		public DateTime Utc { get; }

		public string Reason { get; }

		public string PreviousClientState { get; }

		public bool PhotonAvailable { get; }

		public string PhotonProbeStatus { get; }

		public string[] PhotonProbeIssues { get; }

		public bool IsConnected { get; }

		public bool IsReady { get; }

		public bool InRoom { get; }

		public bool IsMasterClient { get; }

		public string ClientState { get; }

		public string DisconnectCause { get; }

		public string AnonymousRoomFingerprint { get; }

		public int PlayerCount { get; }

		public int MaximumPlayers { get; }

		public bool? RoomIsOpen { get; }

		public int ActivePlayerObjectCount { get; }

		public int PhotonViewCount { get; }

		public int ProjectileCount { get; }

		public int GameplayEntityCount { get; }

		public int ParticleSystemCount { get; }

		public int TrailCount { get; }

		public long ExceptionCount { get; }

		public long ErrorCount { get; }

		public int ErrorEventsLastMinute { get; }

		public string[] CompatibilityInventory { get; }

		internal SessionReliabilitySnapshot(DateTime utc, string reason, string previousClientState, string anonymousRoomFingerprint, ReliabilityRuntimeSample sample, ExceptionRateSnapshot exceptions, string[] compatibility)
		{
			Utc = utc;
			Reason = reason;
			PreviousClientState = previousClientState;
			PhotonAvailable = sample.Photon.Available;
			PhotonProbeStatus = sample.Photon.ProbeStatus;
			PhotonProbeIssues = sample.Photon.ProbeIssues;
			IsConnected = sample.Photon.IsConnected;
			IsReady = sample.Photon.IsReady;
			InRoom = sample.Photon.InRoom;
			IsMasterClient = sample.Photon.IsMasterClient;
			ClientState = sample.Photon.ClientState;
			DisconnectCause = sample.Photon.DisconnectCause;
			AnonymousRoomFingerprint = anonymousRoomFingerprint;
			PlayerCount = sample.Photon.PlayerCount;
			MaximumPlayers = sample.Photon.MaxPlayers;
			RoomIsOpen = sample.Photon.RoomIsOpen;
			ActivePlayerObjectCount = sample.Counts.Players;
			PhotonViewCount = sample.Counts.PhotonViews;
			ProjectileCount = sample.Counts.Projectiles;
			GameplayEntityCount = sample.Counts.GameplayEntities;
			ParticleSystemCount = sample.Counts.ParticleSystems;
			TrailCount = sample.Counts.Trails;
			ExceptionCount = exceptions.TotalExceptions;
			ErrorCount = exceptions.TotalErrors;
			ErrorEventsLastMinute = exceptions.EventsLastMinute;
			CompatibilityInventory = compatibility;
		}
	}
	public sealed class SessionReliabilitySummary
	{
		public bool HasData { get; }

		public string StatusKey { get; }

		public string ConnectionState { get; }

		public int ErrorsPerMinute { get; }

		public int Players { get; }

		public int PhotonViews { get; }

		public int Projectiles { get; }

		public int GameplayEntities { get; }

		public string CompactLine { get; }

		private SessionReliabilitySummary(bool hasData, string statusKey, string connectionState, int errorsPerMinute, int players, int photonViews, int projectiles, int gameplayEntities, string compactLine)
		{
			HasData = hasData;
			StatusKey = statusKey;
			ConnectionState = connectionState;
			ErrorsPerMinute = errorsPerMinute;
			Players = players;
			PhotonViews = photonViews;
			Projectiles = projectiles;
			GameplayEntities = gameplayEntities;
			CompactLine = compactLine;
		}

		public static SessionReliabilitySummary FromLatest()
		{
			return FromSnapshot(SessionReliabilityApi.LatestSnapshot);
		}

		public static SessionReliabilitySummary FromSnapshot(SessionReliabilitySnapshot? snapshot)
		{
			if (snapshot == null)
			{
				return new SessionReliabilitySummary(hasData: false, "waiting", "unknown", 0, -1, -1, -1, -1, "SESSION: waiting for first sample");
			}
			string text = ((!snapshot.PhotonAvailable) ? "photon-unavailable" : ((!snapshot.IsConnected) ? "disconnected" : ((!snapshot.InRoom) ? "connected-no-room" : ((snapshot.ErrorEventsLastMinute >= 10) ? "error-storm" : ((snapshot.ErrorEventsLastMinute < 3) ? "stable" : "watch")))));
			int num = ((snapshot.PlayerCount >= 0) ? snapshot.PlayerCount : snapshot.ActivePlayerObjectCount);
			string compactLine = "SESSION: " + text + " | NET " + snapshot.ClientState + " | P " + FormatCount(num) + " | V " + FormatCount(snapshot.PhotonViewCount) + " | B " + FormatCount(snapshot.ProjectileCount) + " | ERR/M " + snapshot.ErrorEventsLastMinute.ToString(CultureInfo.InvariantCulture);
			return new SessionReliabilitySummary(hasData: true, text, snapshot.ClientState, snapshot.ErrorEventsLastMinute, num, snapshot.PhotonViewCount, snapshot.ProjectileCount, snapshot.GameplayEntityCount, compactLine);
		}

		private static string FormatCount(int value)
		{
			if (value >= 0)
			{
				return value.ToString(CultureInfo.InvariantCulture);
			}
			return "?";
		}
	}
}