using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LotsOfBalls")]
[assembly: AssemblyTitle("LotsOfBalls")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LotsOfBalls
{
	[BepInPlugin("Omniscye.LotsOfBalls", "LotsOfBalls", "1.0")]
	public class LotsOfBalls : BaseUnityPlugin
	{
		internal static LotsOfBalls Instance { get; private set; }

		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void Update()
		{
		}
	}
}
namespace EmpressMods.SphereFlood
{
	[BepInPlugin("com.omniscye.levelpointspheres", "Level Point Sphere Flood", "2.1.0")]
	public class LevelPointSphereFlood : BaseUnityPlugin
	{
		private Harmony _harmony;

		public static LevelPointSphereFlood I;

		public static ConfigEntry<int> CFG_SphereCount;

		public static ConfigEntry<float> CFG_SphereScale;

		public static ConfigEntry<bool> CFG_GridMode;

		public static ConfigEntry<float> CFG_GridGapMeters;

		public static ConfigEntry<bool> CFG_SnapToGround;

		public static ConfigEntry<int> CFG_SnapEveryNth;

		public static ConfigEntry<float> CFG_RB_Mass;

		public static ConfigEntry<float> CFG_RB_Drag;

		public static ConfigEntry<float> CFG_RB_AngularDrag;

		public static ConfigEntry<float> CFG_RB_SleepThreshold;

		public static ConfigEntry<float> CFG_CellSize;

		public static ConfigEntry<int> CFG_ActiveCellRadius;

		public static ConfigEntry<float> CFG_CullRefreshInterval;

		public static ConfigEntry<int> CFG_ToggleBudgetPerFrame;

		public static ConfigEntry<bool> CFG_HideRendererWhenCulled;

		public static ConfigEntry<int> CFG_MaxActiveCount;

		public static ConfigEntry<int> CFG_SpheresPerPoint;

		public static ConfigEntry<float> CFG_PerPointJitterRadius;

		public static ConfigEntry<bool> CFG_PerPointSpiral;

		public static ConfigEntry<bool> CFG_AddImpactDetector;

		public static ConfigEntry<bool> CFG_AddDetectorOnlyIfCompatible;

		internal static int GenSerialCounter = 0;

		internal static int LastSpawnedGenSerial = -1;

		internal static Level LastSpawnedLevelRef = null;

		internal static bool SpawnedThisLevel = false;

		private void Awake()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Expected O, but got Unknown
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Expected O, but got Unknown
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Expected O, but got Unknown
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Expected O, but got Unknown
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			I = this;
			CFG_SphereCount = ((BaseUnityPlugin)this).Config.Bind<int>("SphereFlood", "SphereCount", 10000, new ConfigDescription("Total spheres to spawn (grid mode).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 20000), Array.Empty<object>()));
			CFG_SphereScale = ((BaseUnityPlugin)this).Config.Bind<float>("SphereFlood", "SphereScale", 0.3f, new ConfigDescription("Uniform local scale.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 2f), Array.Empty<object>()));
			CFG_GridMode = ((BaseUnityPlugin)this).Config.Bind<bool>("SphereFlood", "GridMode", false, "When true, spawn a grid centered on one discovered anchor (nearest level point). When false, spawn at ALL discovered level points.");
			CFG_GridGapMeters = ((BaseUnityPlugin)this).Config.Bind<float>("SphereFlood", "GridGapMeters", 0.02f, new ConfigDescription("Extra gap beyond diameter to avoid initial overlaps.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 0.25f), Array.Empty<object>()));
			CFG_SnapToGround = ((BaseUnityPlugin)this).Config.Bind<bool>("SphereFlood", "SnapToGround", false, "Raycast down to place on ground (expensive at high counts).");
			CFG_SnapEveryNth = ((BaseUnityPlugin)this).Config.Bind<int>("SphereFlood", "SnapEveryNth", 0, new ConfigDescription("If >0, only snap every Nth sphere (amortize raycasts).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 5000), Array.Empty<object>()));
			CFG_RB_Mass = ((BaseUnityPlugin)this).Config.Bind<float>("Rigidbody", "Mass", 0.05f, new ConfigDescription("Rigidbody mass.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.001f, 5f), Array.Empty<object>()));
			CFG_RB_Drag = ((BaseUnityPlugin)this).Config.Bind<float>("Rigidbody", "Drag", 0f, new ConfigDescription("Linear drag.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			CFG_RB_AngularDrag = ((BaseUnityPlugin)this).Config.Bind<float>("Rigidbody", "AngularDrag", 0.05f, new ConfigDescription("Angular drag.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			CFG_RB_SleepThreshold = ((BaseUnityPlugin)this).Config.Bind<float>("Rigidbody", "SleepThreshold", 0.1f, new ConfigDescription("Higher = sleeps more aggressively.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.0001f, 1f), Array.Empty<object>()));
			CFG_CellSize = ((BaseUnityPlugin)this).Config.Bind<float>("Culling", "CellSize", 20f, new ConfigDescription("Meters per culling cell (XZ).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(2f, 100f), Array.Empty<object>()));
			CFG_ActiveCellRadius = ((BaseUnityPlugin)this).Config.Bind<int>("Culling", "ActiveCellRadius", 1, new ConfigDescription("Cells active around player (square radius).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()));
			CFG_CullRefreshInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Culling", "CullRefreshInterval", 0.25f, new ConfigDescription("Seconds between culling region updates.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 2f), Array.Empty<object>()));
			CFG_ToggleBudgetPerFrame = ((BaseUnityPlugin)this).Config.Bind<int>("Culling", "ToggleBudgetPerFrame", 600, new ConfigDescription("Max enable/disable ops per frame to avoid spikes.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(50, 5000), Array.Empty<object>()));
			CFG_HideRendererWhenCulled = ((BaseUnityPlugin)this).Config.Bind<bool>("Culling", "HideRendererWhenCulled", true, "Also disable MeshRenderer for culled spheres.");
			CFG_MaxActiveCount = ((BaseUnityPlugin)this).Config.Bind<int>("Culling", "MaxActiveCount", 800, new ConfigDescription("Hard cap on concurrently active (enabled) spheres; nearest to player win.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(100, 20000), Array.Empty<object>()));
			CFG_SpheresPerPoint = ((BaseUnityPlugin)this).Config.Bind<int>("PerPoint", "SpheresPerPoint", 100, new ConfigDescription("Number of spheres to spawn at each discovered level point.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10000), Array.Empty<object>()));
			CFG_PerPointJitterRadius = ((BaseUnityPlugin)this).Config.Bind<float>("PerPoint", "PerPointJitterRadius", 1.5f, new ConfigDescription("Max horizontal jitter radius per point (meters).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 20f), Array.Empty<object>()));
			CFG_PerPointSpiral = ((BaseUnityPlugin)this).Config.Bind<bool>("PerPoint", "UseSpiralDistribution", true, "Use golden-angle spiral distribution per point.");
			CFG_AddImpactDetector = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "AddImpactDetector", false, "Attach PhysGrabObjectImpactDetector (not recommended for thousands). Defaults OFF.");
			CFG_AddDetectorOnlyIfCompatible = ((BaseUnityPlugin)this).Config.Bind<bool>("Compatibility", "AddDetectorOnlyIfCompatible", true, "Only add detector if PhysGrabObject already exists.");
			CFG_SpheresPerPoint.Value = 100;
			CFG_MaxActiveCount.Value = 800;
			CFG_ActiveCellRadius.Value = 1;
			CFG_CellSize.Value = 20f;
			_harmony = new Harmony("com.omniscye.levelpointspheres");
			_harmony.PatchAll();
			SphereSpawnWatchdog.Ensure();
			((BaseUnityPlugin)this).Logger.LogInfo((object)$"[SphereFlood] v2.1.0 loaded. Grid={CFG_GridMode.Value}, Count={CFG_SphereCount.Value}, Scale={CFG_SphereScale.Value}");
		}

		private void OnDestroy()
		{
			try
			{
				Harmony harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch
			{
			}
			SphereManager.ClearAll();
			GridCuller.Reset();
		}

		internal static void Log(string msg)
		{
			if ((Object)(object)I != (Object)null)
			{
				((BaseUnityPlugin)I).Logger.LogInfo((object)msg);
			}
			else
			{
				Debug.Log((object)msg);
			}
		}

		internal static void LogWarn(string msg)
		{
			if ((Object)(object)I != (Object)null)
			{
				((BaseUnityPlugin)I).Logger.LogWarning((object)msg);
			}
			else
			{
				Debug.LogWarning((object)msg);
			}
		}
	}
	[HarmonyPatch(typeof(LevelGenerator), "Generate")]
	public static class Patch_LevelGenerator_Generate
	{
		[CompilerGenerated]
		private sealed class <CoSpawnAfterGen>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int genSerial;

			private LevelGenerator <lg>5__1;

			private float <timeout>5__2;

			private List<Transform> <points>5__3;

			private Vector3 <anchor>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0059;
				case 1:
					<>1__state = -1;
					goto IL_0059;
				case 2:
					<>1__state = -1;
					goto IL_00c2;
				case 3:
					<>1__state = -1;
					break;
				case 4:
					{
						<>1__state = -1;
						break;
					}
					IL_0059:
					if (LooksLikeMenuOrSplash())
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<lg>5__1 = null;
					<timeout>5__2 = Time.time + 30f;
					goto IL_00c2;
					IL_00c2:
					if (Time.time < <timeout>5__2)
					{
						<lg>5__1 = LevelGenerator.Instance;
						if (!((Object)(object)<lg>5__1 != (Object)null) || !<lg>5__1.Generated)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
					}
					if ((Object)(object)<lg>5__1 == (Object)null || !<lg>5__1.Generated)
					{
						LevelPointSphereFlood.LogWarn("[SphereFlood] Timeout waiting for LevelGenerator.Generated");
						return false;
					}
					if (LevelPointSphereFlood.LastSpawnedGenSerial == genSerial)
					{
						return false;
					}
					<points>5__3 = LevelPoints.FindLikelyLevelPoints_CurrentWorld();
					<anchor>5__4 = AnchorChooser.ChooseAnchor(<points>5__3);
					LevelPointSphereFlood.Log($"[SphereFlood] Candidate points: {<points>5__3.Count}. Anchor at {<anchor>5__4}");
					if (LevelPointSphereFlood.CFG_GridMode.Value)
					{
						<>2__current = SphereManager.CoSpawnGrid(<anchor>5__4);
						<>1__state = 3;
						return true;
					}
					<>2__current = SphereManager.CoSpawnOnePerPoint(<points>5__3);
					<>1__state = 4;
					return true;
				}
				GridCuller.Ensure();
				LevelPointSphereFlood.LastSpawnedGenSerial = genSerial;
				LevelPointSphereFlood.LastSpawnedLevelRef = <lg>5__1.Level;
				LevelPointSphereFlood.SpawnedThisLevel = true;
				return false;
			}

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

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

		private static void Prefix(LevelGenerator __instance)
		{
			LevelPointSphereFlood.GenSerialCounter++;
		}

		public static void Postfix(LevelGenerator __instance)
		{
			int genSerialCounter = LevelPointSphereFlood.GenSerialCounter;
			if ((Object)(object)LevelPointSphereFlood.I != (Object)null)
			{
				((MonoBehaviour)LevelPointSphereFlood.I).StartCoroutine(CoSpawnAfterGen(genSerialCounter));
			}
		}

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

		private static bool LooksLikeMenuOrSplash()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name ?? string.Empty;
			if (text.IndexOf("Lobby", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (text.IndexOf("Menu", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (text.IndexOf("Title", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			if (text.IndexOf("Splash", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(RunManager), "ChangeLevel")]
	public static class Patch_RunManager_ChangeLevel
	{
		private static void Postfix()
		{
			LevelPointSphereFlood.SpawnedThisLevel = false;
			LevelPointSphereFlood.LastSpawnedLevelRef = null;
			LevelPointSphereFlood.LastSpawnedGenSerial = -1;
			SphereManager.ClearAll();
			GridCuller.Reset();
		}
	}
	public class SphereSpawnWatchdog : MonoBehaviour
	{
		private static SphereSpawnWatchdog _i;

		private float _next;

		public static void Ensure()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_i != (Object)null))
			{
				GameObject val = new GameObject("[SphereFlood] Watchdog");
				Object.DontDestroyOnLoad((Object)(object)val);
				_i = val.AddComponent<SphereSpawnWatchdog>();
			}
		}

		private void Update()
		{
			if (!(Time.time < _next))
			{
				_next = Time.time + 1f;
				int genSerialCounter = LevelPointSphereFlood.GenSerialCounter;
				LevelGenerator instance = LevelGenerator.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.Generated && LevelPointSphereFlood.LastSpawnedGenSerial != genSerialCounter)
				{
					Patch_LevelGenerator_Generate.Postfix(instance);
				}
			}
		}
	}
	public static class LevelPoints
	{
		private static readonly string[] NEEDLES = new string[15]
		{
			"levelpoint", "level spawn", "levelspawn", "enemyspawn", "spawnpoint", "spawn point", "aispawn", "respawnpoint", "respawn", "wavespawn",
			"spawner", "ghostspawn", "eventspawn", "huntspawn", "ghostpoint"
		};

		private static bool LooksLikeSpawnType(string typeNameLower)
		{
			for (int i = 0; i < NEEDLES.Length; i++)
			{
				if (typeNameLower.Contains(NEEDLES[i]))
				{
					return true;
				}
			}
			return false;
		}

		private static bool LooksLikeSpawnName(string nameLower)
		{
			for (int i = 0; i < NEEDLES.Length; i++)
			{
				if (nameLower.Contains(NEEDLES[i]))
				{
					return true;
				}
			}
			return false;
		}

		public static List<Transform> FindLikelyLevelPoints_CurrentWorld()
		{
			List<Transform> list = new List<Transform>(256);
			MonoBehaviour[] array = Object.FindObjectsOfType<MonoBehaviour>(true);
			foreach (MonoBehaviour val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				GameObject gameObject = ((Component)val).gameObject;
				if (Object.op_Implicit((Object)(object)gameObject) && gameObject.activeInHierarchy && !((Object)gameObject).name.StartsWith("[SphereFlood]"))
				{
					string typeNameLower = ((object)val).GetType().Name.ToLowerInvariant();
					if (LooksLikeSpawnType(typeNameLower))
					{
						list.Add(((Component)val).transform);
					}
				}
			}
			Transform[] array2 = Object.FindObjectsOfType<Transform>(true);
			foreach (Transform val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				GameObject gameObject2 = ((Component)val2).gameObject;
				if (Object.op_Implicit((Object)(object)gameObject2) && gameObject2.activeInHierarchy && !((Object)gameObject2).name.StartsWith("[SphereFlood]"))
				{
					string nameLower = ((Object)val2).name.ToLowerInvariant();
					if (LooksLikeSpawnName(nameLower))
					{
						list.Add(val2);
					}
				}
			}
			return list.Distinct().ToList();
		}
	}
	public static class AnchorChooser
	{
		public static Vector3 ChooseAnchor(List<Transform> points)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			PlayerAvatar val = FindLocalPlayer();
			Transform val2 = null;
			if (points != null && points.Count > 0)
			{
				if ((Object)(object)val != (Object)null)
				{
					Vector3 position = ((Component)val).transform.position;
					float num = float.MaxValue;
					for (int i = 0; i < points.Count; i++)
					{
						Transform val3 = points[i];
						if (Object.op_Implicit((Object)(object)val3))
						{
							Vector3 val4 = val3.position - position;
							float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
							if (sqrMagnitude < num)
							{
								num = sqrMagnitude;
								val2 = val3;
							}
						}
					}
				}
				if (!Object.op_Implicit((Object)(object)val2))
				{
					val2 = points[0];
				}
			}
			if (Object.op_Implicit((Object)(object)val2))
			{
				return val2.position;
			}
			if ((Object)(object)val != (Object)null)
			{
				return ((Component)val).transform.position + ((Component)val).transform.forward * 2f;
			}
			return Vector3.zero;
		}

		private static PlayerAvatar FindLocalPlayer()
		{
			try
			{
				PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>(true);
				foreach (PlayerAvatar val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Type type = ((object)val).GetType();
					try
					{
						FieldInfo field = type.GetField("isLocal", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field != null && field.FieldType == typeof(bool) && (bool)field.GetValue(val))
						{
							return val;
						}
					}
					catch
					{
					}
					try
					{
						PropertyInfo property = type.GetProperty("IsLocal", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property != null && property.PropertyType == typeof(bool) && (bool)property.GetValue(val))
						{
							return val;
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
	public static class SphereManager
	{
		public struct SphereRec
		{
			public GameObject go;

			public Rigidbody rb;

			public Collider col;

			public MeshRenderer mr;

			public Vector2Int cell;

			public bool active;
		}

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

			private object <>2__current;

			public Vector3 anchor;

			private int <target>5__1;

			private float <r>5__2;

			private float <diameter>5__3;

			private float <spacing>5__4;

			private int <gridX>5__5;

			private int <gridZ>5__6;

			private int <halfX>5__7;

			private int <halfZ>5__8;

			private int <snapStride>5__9;

			private bool <doSnap>5__10;

			private int <spawned>5__11;

			private int <yieldBudget>5__12;

			private int <iz>5__13;

			private int <ix>5__14;

			private Vector3 <pos>5__15;

			private Vector3 <origin>5__16;

			private RaycastHit <rh>5__17;

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

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

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

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

			private bool MoveNext()
			{
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0256: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_020a: Unknown result type (might be due to invalid IL or missing references)
				//IL_020f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_0245: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_02a6;
				}
				<>1__state = -1;
				ClearAll();
				EnsureRoot();
				EnsureMaterial();
				<target>5__1 = Mathf.Max(1, LevelPointSphereFlood.CFG_SphereCount.Value);
				<r>5__2 = Mathf.Max(0.01f, LevelPointSphereFlood.CFG_SphereScale.Value);
				<diameter>5__3 = <r>5__2 * 2f;
				<spacing>5__4 = <diameter>5__3 + Mathf.Max(0f, LevelPointSphereFlood.CFG_GridGapMeters.Value);
				<gridX>5__5 = Mathf.CeilToInt(Mathf.Sqrt((float)<target>5__1));
				<gridZ>5__6 = Mathf.CeilToInt((float)<target>5__1 / (float)<gridX>5__5);
				<halfX>5__7 = <gridX>5__5 / 2;
				<halfZ>5__8 = <gridZ>5__6 / 2;
				<snapStride>5__9 = Mathf.Max(0, LevelPointSphereFlood.CFG_SnapEveryNth.Value);
				<doSnap>5__10 = LevelPointSphereFlood.CFG_SnapToGround.Value && (<snapStride>5__9 == 0 || <snapStride>5__9 >= 1);
				<spawned>5__11 = 0;
				<yieldBudget>5__12 = Mathf.Max(64, LevelPointSphereFlood.CFG_ToggleBudgetPerFrame.Value);
				<iz>5__13 = 0;
				goto IL_02e3;
				IL_02e3:
				if (<iz>5__13 < <gridZ>5__6)
				{
					<ix>5__14 = 0;
					goto IL_02b9;
				}
				LevelPointSphereFlood.Log($"[SphereFlood] Grid spawn complete. {<spawned>5__11} spheres. Grid {<gridX>5__5}x{<gridZ>5__6}, spacing={<spacing>5__4:0.###}m");
				return false;
				IL_02b9:
				if (<ix>5__14 < <gridX>5__5 && <spawned>5__11 < <target>5__1)
				{
					<pos>5__15 = anchor + new Vector3((float)(<ix>5__14 - <halfX>5__7) * <spacing>5__4, 0f, (float)(<iz>5__13 - <halfZ>5__8) * <spacing>5__4);
					if (<doSnap>5__10 && (<snapStride>5__9 == 0 || <spawned>5__11 % <snapStride>5__9 == 0))
					{
						<origin>5__16 = <pos>5__15 + Vector3.up * 2f;
						if (Physics.Raycast(<origin>5__16, Vector3.down, ref <rh>5__17, 6f, -1, (QueryTriggerInteraction)1))
						{
							<pos>5__15 = ((RaycastHit)(ref <rh>5__17)).point + Vector3.up * 0.02f;
						}
					}
					SpawnOne(<pos>5__15, Quaternion.identity, <r>5__2);
					<spawned>5__11++;
					if (<spawned>5__11 % <yieldBudget>5__12 == 0)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_02a6;
				}
				<iz>5__13++;
				goto IL_02e3;
				IL_02a6:
				<ix>5__14++;
				goto IL_02b9;
			}

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

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

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

			private object <>2__current;

			public List<Transform> points;

			private int <perPoint>5__1;

			private float <jitter>5__2;

			private bool <spiral>5__3;

			private float <r>5__4;

			private int <snapStride>5__5;

			private bool <doSnap>5__6;

			private long <totalPlanned>5__7;

			private int <spawned>5__8;

			private int <yieldBudget>5__9;

			private int <i>5__10;

			private int <j>5__11;

			private int <i>5__12;

			private Transform <p>5__13;

			private Vector3 <basePos>5__14;

			private Quaternion <rot>5__15;

			private int <j>5__16;

			private Vector3 <pos>5__17;

			private Vector3 <origin>5__18;

			private RaycastHit <rh>5__19;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_0290: Unknown result type (might be due to invalid IL or missing references)
				//IL_0295: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0336: Unknown result type (might be due to invalid IL or missing references)
				//IL_033c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0316: Unknown result type (might be due to invalid IL or missing references)
				//IL_031b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_032a: Unknown result type (might be due to invalid IL or missing references)
				//IL_032f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_025a: Unknown result type (might be due to invalid IL or missing references)
				//IL_025f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_038c;
				}
				<>1__state = -1;
				ClearAll();
				EnsureRoot();
				EnsureMaterial();
				if (points == null || points.Count == 0)
				{
					return false;
				}
				<i>5__10 = 0;
				while (<i>5__10 < points.Count)
				{
					<j>5__11 = Random.Range(<i>5__10, points.Count);
					List<Transform> list = points;
					int index = <i>5__10;
					List<Transform> list2 = points;
					int index2 = <j>5__11;
					Transform value = points[<j>5__11];
					Transform value2 = points[<i>5__10];
					list[index] = value;
					list2[index2] = value2;
					<i>5__10++;
				}
				<perPoint>5__1 = Mathf.Max(1, LevelPointSphereFlood.CFG_SpheresPerPoint.Value);
				<jitter>5__2 = Mathf.Max(0f, LevelPointSphereFlood.CFG_PerPointJitterRadius.Value);
				<spiral>5__3 = LevelPointSphereFlood.CFG_PerPointSpiral.Value;
				<r>5__4 = Mathf.Max(0.01f, LevelPointSphereFlood.CFG_SphereScale.Value);
				<snapStride>5__5 = Mathf.Max(0, LevelPointSphereFlood.CFG_SnapEveryNth.Value);
				<doSnap>5__6 = LevelPointSphereFlood.CFG_SnapToGround.Value && (<snapStride>5__5 == 0 || <snapStride>5__5 >= 1);
				<totalPlanned>5__7 = (long)points.Count * (long)<perPoint>5__1;
				if (<totalPlanned>5__7 > 200000)
				{
					LevelPointSphereFlood.LogWarn($"[SphereFlood] Warning: planning to spawn {<totalPlanned>5__7:N0} objects. This will be heavy; culling will cap actives but spawn time/memory will grow.");
				}
				<spawned>5__8 = 0;
				<yieldBudget>5__9 = Mathf.Max(64, LevelPointSphereFlood.CFG_ToggleBudgetPerFrame.Value);
				<i>5__12 = 0;
				goto IL_03d0;
				IL_038c:
				<j>5__16++;
				goto IL_039f;
				IL_03d0:
				if (<i>5__12 < points.Count)
				{
					<p>5__13 = points[<i>5__12];
					if (!Object.op_Implicit((Object)(object)<p>5__13))
					{
						goto IL_03be;
					}
					<basePos>5__14 = <p>5__13.position;
					<rot>5__15 = <p>5__13.rotation;
					<j>5__16 = 0;
					goto IL_039f;
				}
				LevelPointSphereFlood.Log($"[SphereFlood] Per-point spawn complete: {<spawned>5__8} spheres across {points.Count} points (per point={<perPoint>5__1}).");
				return false;
				IL_039f:
				if (<j>5__16 < <perPoint>5__1)
				{
					<pos>5__17 = <basePos>5__14 + JitterOffset(<j>5__16, <perPoint>5__1, <jitter>5__2, <spiral>5__3);
					if (<doSnap>5__6 && (<snapStride>5__5 == 0 || <spawned>5__8 % <snapStride>5__5 == 0))
					{
						<origin>5__18 = <pos>5__17 + Vector3.up * 2f;
						if (Physics.Raycast(<origin>5__18, Vector3.down, ref <rh>5__19, 6f, -1, (QueryTriggerInteraction)1))
						{
							<pos>5__17 = ((RaycastHit)(ref <rh>5__19)).point + Vector3.up * 0.02f;
						}
					}
					SpawnOne(<pos>5__17, <rot>5__15, <r>5__4);
					<spawned>5__8++;
					if (<spawned>5__8 % <yieldBudget>5__9 == 0)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_038c;
				}
				<p>5__13 = null;
				goto IL_03be;
				IL_03be:
				<i>5__12++;
				goto IL_03d0;
			}

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

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

		private static readonly List<SphereRec> _spheres = new List<SphereRec>(16384);

		private static readonly Dictionary<Vector2Int, List<int>> _cellToIndices = new Dictionary<Vector2Int, List<int>>(1024);

		private static readonly List<int> _scratch = new List<int>(2048);

		private static GameObject _root;

		private static Material _matRed;

		public static int Count => _spheres.Count;

		public static void ClearAll()
		{
			for (int num = _spheres.Count - 1; num >= 0; num--)
			{
				SphereRec sphereRec = _spheres[num];
				if (Object.op_Implicit((Object)(object)sphereRec.go))
				{
					Object.Destroy((Object)(object)sphereRec.go);
				}
			}
			_spheres.Clear();
			_cellToIndices.Clear();
			if (Object.op_Implicit((Object)(object)_root))
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
		}

		private static void EnsureRoot()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)_root))
			{
				_root = new GameObject("[SphereFlood] Root");
				Object.DontDestroyOnLoad((Object)(object)_root);
			}
		}

		private static void EnsureMaterial()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)_matRed))
			{
				_matRed = new Material(Shader.Find("Standard"));
				_matRed.color = Color.red;
				_matRed.enableInstancing = true;
			}
		}

		[IteratorStateMachine(typeof(<CoSpawnGrid>d__11))]
		public static IEnumerator CoSpawnGrid(Vector3 anchor)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoSpawnGrid>d__11(0)
			{
				anchor = anchor
			};
		}

		[IteratorStateMachine(typeof(<CoSpawnOnePerPoint>d__12))]
		public static IEnumerator CoSpawnOnePerPoint(List<Transform> points)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoSpawnOnePerPoint>d__12(0)
			{
				points = points
			};
		}

		private static Vector3 JitterOffset(int j, int perPoint, float radius, bool spiral)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			if (radius <= 0f)
			{
				return Vector3.zero;
			}
			if (!spiral)
			{
				Vector2 val = Random.insideUnitCircle * radius;
				return new Vector3(val.x, 0f, val.y);
			}
			float num = ((perPoint <= 1) ? 0f : (((float)j + 0.5f) / (float)perPoint));
			float num2 = Mathf.Sqrt(num) * radius;
			float num3 = 2.3999631f * (float)j;
			return new Vector3(Mathf.Cos(num3) * num2, 0f, Mathf.Sin(num3) * num2);
		}

		private static void SpawnOne(Vector3 position, Quaternion rotation, float radius)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)0);
			((Object)val).name = "LP_Sphere";
			val.transform.SetParent(_root.transform, false);
			val.transform.position = position;
			val.transform.rotation = rotation;
			val.transform.localScale = Vector3.one * Mathf.Max(0.01f, radius);
			Collider component = val.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				component.isTrigger = false;
			}
			Rigidbody val2 = val.GetComponent<Rigidbody>() ?? val.AddComponent<Rigidbody>();
			val2.useGravity = true;
			val2.collisionDetectionMode = (CollisionDetectionMode)0;
			val2.interpolation = (RigidbodyInterpolation)0;
			val2.mass = Mathf.Max(0.001f, LevelPointSphereFlood.CFG_RB_Mass.Value);
			val2.drag = Mathf.Max(0f, LevelPointSphereFlood.CFG_RB_Drag.Value);
			val2.angularDrag = Mathf.Max(0f, LevelPointSphereFlood.CFG_RB_AngularDrag.Value);
			val2.sleepThreshold = Mathf.Clamp(LevelPointSphereFlood.CFG_RB_SleepThreshold.Value, 0.0001f, 1f);
			MeshRenderer component2 = val.GetComponent<MeshRenderer>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Renderer)component2).sharedMaterial = _matRed;
				((Renderer)component2).shadowCastingMode = (ShadowCastingMode)0;
				((Renderer)component2).receiveShadows = false;
			}
			if (LevelPointSphereFlood.CFG_AddImpactDetector.Value)
			{
				bool flag = (Object)(object)val.GetComponent<PhysGrabObject>() != (Object)null;
				if (!LevelPointSphereFlood.CFG_AddDetectorOnlyIfCompatible.Value || flag)
				{
					try
					{
						PhysGrabObjectImpactDetector val3 = val.AddComponent<PhysGrabObjectImpactDetector>();
						if (!flag)
						{
							((Behaviour)val3).enabled = false;
						}
					}
					catch (Exception ex)
					{
						LevelPointSphereFlood.LogWarn("[SphereFlood] ImpactDetector add failed: " + ex.Message);
					}
				}
			}
			Vector2Int val4 = ToCell(position);
			int count = _spheres.Count;
			if (!_cellToIndices.TryGetValue(val4, out List<int> value))
			{
				value = new List<int>(32);
				_cellToIndices[val4] = value;
			}
			value.Add(count);
			_spheres.Add(new SphereRec
			{
				go = val,
				rb = val2,
				col = component,
				mr = component2,
				cell = val4,
				active = true
			});
		}

		public static Vector2Int ToCell(Vector3 pos)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Max(1f, LevelPointSphereFlood.CFG_CellSize.Value);
			int num2 = Mathf.FloorToInt(pos.x / num);
			int num3 = Mathf.FloorToInt(pos.z / num);
			return new Vector2Int(num2, num3);
		}

		internal static void CollectIndicesInCells(HashSet<Vector2Int> cells, List<int> outIndices)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			outIndices.Clear();
			foreach (Vector2Int cell in cells)
			{
				if (_cellToIndices.TryGetValue(cell, out List<int> value))
				{
					outIndices.AddRange(value);
				}
			}
		}

		internal static bool TryGetPosition(int idx, out Vector3 pos)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			pos = default(Vector3);
			if ((uint)idx >= (uint)_spheres.Count)
			{
				return false;
			}
			SphereRec sphereRec = _spheres[idx];
			if (!Object.op_Implicit((Object)(object)sphereRec.go))
			{
				return false;
			}
			pos = sphereRec.go.transform.position;
			return true;
		}

		internal static void EnableIndex(int i)
		{
			if ((uint)i >= (uint)_spheres.Count)
			{
				return;
			}
			SphereRec value = _spheres[i];
			if (Object.op_Implicit((Object)(object)value.go) && !value.active)
			{
				if (Object.op_Implicit((Object)(object)value.col))
				{
					value.col.enabled = true;
				}
				if (Object.op_Implicit((Object)(object)value.rb))
				{
					value.rb.isKinematic = false;
					value.rb.WakeUp();
				}
				if (LevelPointSphereFlood.CFG_HideRendererWhenCulled.Value && Object.op_Implicit((Object)(object)value.mr))
				{
					((Renderer)value.mr).enabled = true;
				}
				value.active = true;
				_spheres[i] = value;
			}
		}

		internal static void DisableIndex(int i)
		{
			if ((uint)i >= (uint)_spheres.Count)
			{
				return;
			}
			SphereRec value = _spheres[i];
			if (Object.op_Implicit((Object)(object)value.go) && value.active)
			{
				if (Object.op_Implicit((Object)(object)value.rb))
				{
					value.rb.isKinematic = true;
					value.rb.Sleep();
				}
				if (Object.op_Implicit((Object)(object)value.col))
				{
					value.col.enabled = false;
				}
				if (LevelPointSphereFlood.CFG_HideRendererWhenCulled.Value && Object.op_Implicit((Object)(object)value.mr))
				{
					((Renderer)value.mr).enabled = false;
				}
				value.active = false;
				_spheres[i] = value;
			}
		}
	}
	public class GridCuller : MonoBehaviour
	{
		private struct Scored
		{
			public int idx;

			public float d2;
		}

		private static GridCuller _i;

		private float _nextAt = 0f;

		private readonly HashSet<Vector2Int> _activeCells = new HashSet<Vector2Int>();

		private readonly HashSet<int> _targetEnabled = new HashSet<int>();

		private readonly HashSet<int> _currentlyEnabled = new HashSet<int>();

		private readonly List<int> _work = new List<int>(4096);

		private static readonly List<int> _scratchIndices = new List<int>(8192);

		private static readonly List<Scored> _scored = new List<Scored>(8192);

		public static void Ensure()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if ((Object)(object)_i == (Object)null)
			{
				GameObject val = new GameObject("[SphereFlood] GridCuller");
				Object.DontDestroyOnLoad((Object)(object)val);
				_i = val.AddComponent<GridCuller>();
			}
			_i._nextAt = 0f;
		}

		public static void Reset()
		{
			if ((Object)(object)_i != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_i).gameObject);
				_i = null;
			}
		}

		private void Update()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			float time = Time.time;
			if (time < _nextAt)
			{
				return;
			}
			_nextAt = time + Mathf.Max(0.05f, LevelPointSphereFlood.CFG_CullRefreshInterval.Value);
			PlayerAvatar val = FindLocalPlayer();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)val).transform.position;
			_activeCells.Clear();
			Vector2Int val2 = SphereManager.ToCell(position);
			int num = Mathf.Max(1, LevelPointSphereFlood.CFG_ActiveCellRadius.Value);
			for (int i = -num; i <= num; i++)
			{
				for (int j = -num; j <= num; j++)
				{
					_activeCells.Add(new Vector2Int(((Vector2Int)(ref val2)).x + j, ((Vector2Int)(ref val2)).y + i));
				}
			}
			_targetEnabled.Clear();
			SphereManager.CollectIndicesInCells(_activeCells, _scratchIndices);
			for (int k = 0; k < _scratchIndices.Count; k++)
			{
				_targetEnabled.Add(_scratchIndices[k]);
			}
			int num2 = Mathf.Max(100, LevelPointSphereFlood.CFG_MaxActiveCount.Value);
			if (_targetEnabled.Count > num2)
			{
				_scored.Clear();
				foreach (int item in _targetEnabled)
				{
					if (SphereManager.TryGetPosition(item, out var pos))
					{
						Vector3 val3 = pos - position;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						_scored.Add(new Scored
						{
							idx = item,
							d2 = sqrMagnitude
						});
					}
				}
				_scored.Sort((Scored a, Scored b) => a.d2.CompareTo(b.d2));
				_targetEnabled.Clear();
				for (int l = 0; l < _scored.Count && l < num2; l++)
				{
					_targetEnabled.Add(_scored[l].idx);
				}
			}
			int num3 = Mathf.Max(1, LevelPointSphereFlood.CFG_ToggleBudgetPerFrame.Value);
			int num4 = 0;
			if (_currentlyEnabled.Count > 0)
			{
				_work.Clear();
				_work.AddRange(_currentlyEnabled);
				for (int m = 0; m < _work.Count; m++)
				{
					if (num4 >= num3)
					{
						break;
					}
					int num5 = _work[m];
					if (!_targetEnabled.Contains(num5))
					{
						SphereManager.DisableIndex(num5);
						_currentlyEnabled.Remove(num5);
						num4++;
					}
				}
			}
			if (num4 >= num3)
			{
				return;
			}
			foreach (int item2 in _targetEnabled)
			{
				if (num4 >= num3)
				{
					break;
				}
				if (!_currentlyEnabled.Contains(item2))
				{
					SphereManager.EnableIndex(item2);
					_currentlyEnabled.Add(item2);
					num4++;
				}
			}
		}

		private static PlayerAvatar FindLocalPlayer()
		{
			try
			{
				PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>(true);
				foreach (PlayerAvatar val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Type type = ((object)val).GetType();
					try
					{
						FieldInfo field = type.GetField("isLocal", BindingFlags.Instance | BindingFlags.NonPublic);
						if (field != null && field.FieldType == typeof(bool) && (bool)field.GetValue(val))
						{
							return val;
						}
					}
					catch
					{
					}
					try
					{
						PropertyInfo property = type.GetProperty("IsLocal", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property != null && property.PropertyType == typeof(bool) && (bool)property.GetValue(val))
						{
							return val;
						}
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
			return null;
		}
	}
}