using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IssaPlugin.Integrations.ModConfigUI;
using IssaPlugin.Integrations.SpawnerUI;
using IssaPlugin.Items;
using IssaPlugin.Network;
using IssaPlugin.Overlays;
using IssaPlugin.Patches;
using ItemSpawner;
using Microsoft.CodeAnalysis;
using Mirror;
using ModConfig.Core;
using ModConfig.UI;
using TMPro;
using Unity.Collections;
using Unity.Profiling;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Localization;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("IssaPlugin")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.48.0")]
[assembly: AssemblyInformationalVersion("0.0.48+680a380554fa2995b7591876cfb515085a7d933d")]
[assembly: AssemblyProduct("My first plugin")]
[assembly: AssemblyTitle("IssaPlugin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.48.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace IssaPlugin
{
	public class AC130Config
	{
		private const string Section = "AC130";

		private const string MaydaySection = "AC130Mayday";

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> OrbitRadius { get; private set; }

		public ConfigEntry<float> OrbitSpeed { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> CameraPitch { get; private set; }

		public ConfigEntry<float> CameraDistance { get; private set; }

		public ConfigEntry<float> FireCooldown { get; private set; }

		public ConfigEntry<float> RocketAngularJitter { get; private set; }

		public ConfigEntry<float> RocketSpeedMultiplier { get; private set; }

		public ConfigEntry<bool> AimAssistEnabled { get; private set; }

		public ConfigEntry<float> AimAssistStrength { get; private set; }

		public ConfigEntry<float> AimAssistMaxAngle { get; private set; }

		public ConfigEntry<float> AimAssistMaxDistance { get; private set; }

		public ConfigEntry<bool> AimAssistAffectsHeavy { get; private set; }

		public ConfigEntry<bool> AimAssistTargetsSelf { get; private set; }

		public ConfigEntry<bool> AimAssistTargetsFinishedPlayers { get; private set; }

		public ConfigEntry<float> AimAssistTargetHeightOffset { get; private set; }

		public ConfigEntry<float> BoostMultiplier { get; private set; }

		public ConfigEntry<float> AltitudeOffsetMax { get; private set; }

		public ConfigEntry<float> AltitudeAdjustSpeed { get; private set; }

		public ConfigEntry<float> ZoomFov { get; private set; }

		public ConfigEntry<float> ZoomSpeed { get; private set; }

		public ConfigEntry<float> ApproachDistance { get; private set; }

		public ConfigEntry<float> ApproachSpeed { get; private set; }

		public ConfigEntry<float> BaseFov { get; private set; }

		public ConfigEntry<float> YawLimit { get; private set; }

		public ConfigEntry<float> PitchLimit { get; private set; }

		public ConfigEntry<float> MouseSensitivity { get; private set; }

		public ConfigEntry<float> HeavyFireCooldown { get; private set; }

		public ConfigEntry<float> HeavyShotsBeforeReload { get; private set; }

		public ConfigEntry<float> HeavyReloadTime { get; private set; }

		public ConfigEntry<bool> MaydayEnabled { get; private set; }

		public ConfigEntry<Key> MaydayKey { get; private set; }

		public ConfigEntry<float> MaydayDiveSteepRate { get; private set; }

		public ConfigEntry<float> MaydayInitialDiveAngle { get; private set; }

		public ConfigEntry<float> MaydayMaxDiveAngle { get; private set; }

		public ConfigEntry<float> MaydayPullInfluence { get; private set; }

		public ConfigEntry<float> MaydayRollSpeed { get; private set; }

		public ConfigEntry<float> MaydaySpeed { get; private set; }

		public ConfigEntry<float> MaydayDrift { get; private set; }

		public ConfigEntry<float> MaydayCenterBias { get; private set; }

		public ConfigEntry<float> MaydayCamYawLimit { get; private set; }

		public ConfigEntry<float> MaydayCamPitchLimit { get; private set; }

		public ConfigEntry<float> MaydayShakeBase { get; private set; }

		public ConfigEntry<float> MaydayShakeMax { get; private set; }

		public ConfigEntry<float> MaydayExplosionScale { get; private set; }

		public ConfigEntry<float> MaydayExplosionDuration { get; private set; }

		public ConfigEntry<float> MaydayRollTurnRate { get; private set; }

		public ConfigEntry<float> HitsToMayday { get; private set; }

		public ConfigEntry<float> RocketProximityFuse { get; private set; }

		public ConfigEntry<bool> ApplyCoffeeBoostAfterwards { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> HeavyRocketExplosionScale { get; private set; }

		public AC130Config(ConfigFile cfg, GlobalConfig global)
		{
			Uses = cfg.Bind<float>("AC130", "Uses", 1f, "Number of AC130 uses per pickup.");
			GiveKey = cfg.Bind<Key>("AC130", "GiveKey", (Key)104, "Key to press to add the AC130 to your inventory.");
			OrbitRadius = cfg.Bind<float>("AC130", "OrbitRadius", 100f, "Radius in units of the circle the gunship flies around the map centre.");
			OrbitSpeed = cfg.Bind<float>("AC130", "OrbitSpeed", 6f, "Degrees per second at which the gunship orbits the map centre.");
			Altitude = cfg.Bind<float>("AC130", "Altitude", 140f, "Height above the map centre the gunship flies at.");
			Duration = cfg.Bind<float>("AC130", "Duration", 20f, "How many seconds the AC130 remains active before leaving.");
			CameraPitch = cfg.Bind<float>("AC130", "CameraPitch", 80f, "Camera pitch angle in degrees during the AC130 (0 = horizontal, 90 = straight down).");
			CameraDistance = cfg.Bind<float>("AC130", "CameraDistance", 80f, "Camera distance addition from the gunship pivot during the AC130.");
			FireCooldown = cfg.Bind<float>("AC130", "FireCooldown", 0.35f, "Minimum seconds between rocket fires.");
			HeavyFireCooldown = cfg.Bind<float>("AC130", "HeavyFireCooldown", 3f, "Minimum seconds between heavy (big shot) rocket fires.");
			HeavyShotsBeforeReload = cfg.Bind<float>("AC130", "HeavyShotsBeforeReload", 3f, "Number of big shots before the heavy rocket must reload.");
			HeavyReloadTime = cfg.Bind<float>("AC130", "HeavyReloadTime", 8f, "Time in seconds for the heavy rocket to reload after depleting all big shots.");
			RocketAngularJitter = cfg.Bind<float>("AC130", "RocketAngularJitter", 0.5f, "Random angular jitter in degrees applied to each rocket fired from the AC130.");
			RocketSpeedMultiplier = cfg.Bind<float>("AC130", "RocketSpeedMultiplier", 1.75f, "Multiplier applied to the speed of rockets fired from the AC130. 1 = the game's default rocket velocity. Higher values shorten the travel time from the gunship to the ground.");
			AimAssistEnabled = cfg.Bind<bool>("AC130", "AimAssistEnabled", true, "Whether AC130 rockets drift subtly toward the player the shot was aimed most closely at.");
			AimAssistStrength = cfg.Bind<float>("AC130", "AimAssistStrength", 0.35f, "How strongly the rocket is nudged toward the assisted target, from 0 (no correction) to 1 (fire directly at the target). Values around 0.3 give a subtle drift that still rewards aiming.");
			AimAssistMaxAngle = cfg.Bind<float>("AC130", "AimAssistMaxAngle", 7f, "Half-angle in degrees of the cone around the aim direction that is searched for an aim-assist target. Shots aimed further off than this are not corrected.");
			AimAssistMaxDistance = cfg.Bind<float>("AC130", "AimAssistMaxDistance", 400f, "Maximum distance in units from the gunship at which a player can be picked as an aim-assist target.");
			AimAssistAffectsHeavy = cfg.Bind<bool>("AC130", "AimAssistAffectsHeavy", true, "Whether heavy (big shot) rockets also receive aim assist.");
			AimAssistTargetsSelf = cfg.Bind<bool>("AC130", "AimAssistTargetsSelf", false, "Whether aim assist may pick the AC130 user's own golfer as a target.");
			AimAssistTargetsFinishedPlayers = cfg.Bind<bool>("AC130", "AimAssistTargetsFinishedPlayers", false, "Whether aim assist may pick players who have already holed out.");
			AimAssistTargetHeightOffset = cfg.Bind<float>("AC130", "AimAssistTargetHeightOffset", 1f, "Height in units above a player's origin that aim assist aims at, so rockets are pulled toward the body rather than the feet.");
			BoostMultiplier = cfg.Bind<float>("AC130", "BoostMultiplier", 2.25f, "Multiplier applied to orbit speed when holding Left Shift.");
			AltitudeOffsetMax = cfg.Bind<float>("AC130", "AltitudeOffsetMax", 80f, "Maximum units the player can raise the gunship from its base altitude using Q/E.");
			AltitudeAdjustSpeed = cfg.Bind<float>("AC130", "AltitudeAdjustSpeed", 10f, "Units per second the gunship rises or descends when holding Q or E.");
			ZoomFov = cfg.Bind<float>("AC130", "ZoomFov", 20f, "Field of view when right-click zooming in the AC130. Lower values zoom in more (default camera FOV is typically 60).");
			ZoomSpeed = cfg.Bind<float>("AC130", "ZoomSpeed", 8f, "Speed at which the camera lerps to and from the zoomed FOV when right-clicking.");
			ApproachDistance = cfg.Bind<float>("AC130", "ApproachDistance", 200f, "How far away the AC130 spawns and flies in from before reaching the orbit point.");
			ApproachSpeed = cfg.Bind<float>("AC130", "ApproachSpeed", 60f, "Speed in units per second at which the AC130 flies in and out.");
			BaseFov = cfg.Bind<float>("AC130", "BaseFov", 60f, "Base field of view for the AC130 camera.");
			YawLimit = cfg.Bind<float>("AC130", "YawLimit", 40f, "How many degrees left/right the player can pan from the map centre.");
			PitchLimit = cfg.Bind<float>("AC130", "PitchLimit", 30f, "How many degrees up/down the player can pan from the map centre.");
			MouseSensitivity = cfg.Bind<float>("AC130", "MouseSensitivity", 0.15f, "How sensitive the player's mouse is to panning the camera.");
			ApplyCoffeeBoostAfterwards = cfg.Bind<bool>("AC130", "ApplyCoffeeBoostAfterwards", true, "Give the user of an AC130 a max coffee boost after the AC130 ends to make up for the time they spent sitting in the AC130, not golfing.");
			MaydayEnabled = cfg.Bind<bool>("AC130Mayday", "Enabled", true, "Whether the manual mayday self-destruct hotkey is available.");
			MaydayKey = cfg.Bind<Key>("AC130Mayday", "Key", (Key)27, "Hotkey to manually trigger mayday (self-destruct) while in an AC130 session.");
			MaydayDiveSteepRate = cfg.Bind<float>("AC130Mayday", "DiveSteepRate", 8f, "Degrees per second at which the dive pitch steepens toward vertical.");
			MaydayInitialDiveAngle = cfg.Bind<float>("AC130Mayday", "InitialDiveAngle", 20f, "Starting pitch angle (degrees below horizontal) when mayday begins.");
			MaydayMaxDiveAngle = cfg.Bind<float>("AC130Mayday", "MaxDiveAngle", 85f, "Maximum pitch angle (degrees below horizontal) the dive steepens to.");
			MaydayPullInfluence = cfg.Bind<float>("AC130Mayday", "PullInfluence", 6f, "Degrees per second of pitch influence the player has when holding W/S during mayday.");
			MaydayRollSpeed = cfg.Bind<float>("AC130Mayday", "RollSpeed", 45f, "Degrees per second the player can roll the gunship with A/D during mayday.");
			MaydaySpeed = cfg.Bind<float>("AC130Mayday", "Speed", 80f, "Forward speed of the gunship during the mayday dive in units per second.");
			MaydayDrift = cfg.Bind<float>("AC130Mayday", "Drift", 3f, "Maximum random lateral drift added to the dive direction per second.");
			MaydayCenterBias = cfg.Bind<float>("AC130Mayday", "CenterBias", 0.4f, "Lerp strength per second toward map centre during the dive. Higher = tighter spiral, lower = nearly straight. Default 0.4.");
			MaydayCamYawLimit = cfg.Bind<float>("AC130Mayday", "CamYawLimit", 25f, "How many degrees left/right the player can look during mayday.");
			MaydayCamPitchLimit = cfg.Bind<float>("AC130Mayday", "CamPitchLimit", 15f, "How many degrees up/down the player can look during mayday.");
			MaydayShakeBase = cfg.Bind<float>("AC130Mayday", "ShakeBase", 0.3f, "Camera shake intensity at the start of the mayday dive.");
			MaydayShakeMax = cfg.Bind<float>("AC130Mayday", "ShakeMax", 2.5f, "Maximum camera shake intensity at the end of the dive.");
			MaydayExplosionScale = cfg.Bind<float>("AC130Mayday", "ExplosionScale", 4f, "Explosion scale multiplier for the mayday crash. Affects blast radius, knockback, and VFX size.");
			MaydayExplosionDuration = cfg.Bind<float>("AC130Mayday", "ExplosionDuration", 12f, "How long (seconds) the crash explosion VFX lingers before being destroyed.");
			MaydayRollTurnRate = cfg.Bind<float>("AC130Mayday", "RollTurnRate", 45f, "Degrees per second of yaw the aircraft gains when fully banked (90° roll). Controls how tightly rolling steers the plane left/right.");
			HitsToMayday = cfg.Bind<float>("AC130Mayday", "HitsToMayday", 1f, "Number of rocket hits required to force the gunship into mayday. Only counts hits during an active session. Set to 0 to disable.");
			RocketProximityFuse = cfg.Bind<float>("AC130Mayday", "RocketProximityFuse", 4f, "Distance in metres at which a homing rocket detonates near the gunship. Must be less than 5 m so the explosion's overlap sphere (radius 5 m) still reaches the gunship and registers the hit.");
			ExplosionScale = cfg.Bind<float>("Explosions", "AC130Scale", 2.25f, "Multiplier for AC130 rocket explosions. Affects blast radius, knockback, and VFX size.");
			HeavyRocketExplosionScale = cfg.Bind<float>("Explosions", "AC130HeavyRocketScale", 5f, "Multiplier for AC130 heavy (big shot) rocket explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class AK47Config
	{
		private const string Section = "AK47";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FireRate { get; private set; }

		public ConfigEntry<float> Inaccuracy { get; private set; }

		public ConfigEntry<float> MaxAimingDistance { get; private set; }

		public ConfigEntry<float> MaxShotDistance { get; private set; }

		public ConfigEntry<float> ScreenShakeIntensity { get; private set; }

		public AK47Config(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("AK47", "GiveKey", (Key)80, "Debug key to add the Sub-Machine Gun to your inventory.");
			Uses = cfg.Bind<float>("AK47", "Uses", 10f, "Total bullets per Sub-Machine Gun pickup. Each shot consumes one use.");
			FireRate = cfg.Bind<float>("AK47", "FireRate", 0.04f, "Seconds between each bullet in the burst.");
			Inaccuracy = cfg.Bind<float>("AK47", "Inaccuracy", 5f, "Random spread angle (degrees) applied to each bullet. Higher = less accurate.");
			MaxAimingDistance = cfg.Bind<float>("AK47", "MaxAimingDistance", 500f, "Max distance used when computing the aim point for each bullet.");
			MaxShotDistance = cfg.Bind<float>("AK47", "MaxShotDistance", 500f, "Max raycast distance for each bullet.");
			ScreenShakeIntensity = cfg.Bind<float>("AK47", "ScreenShakeIntensity", 0.25f, "Intensity of the screen shake when firing the AK47. 0 disables it. Higher values shake more.");
		}
	}
	public class BaseballBatConfig
	{
		private const string Section = "BaseballBat";

		public ConfigEntry<float> PowerMultiplier { get; private set; }

		public ConfigEntry<float> GolfBallPowerMultiplier { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public BaseballBatConfig(ConfigFile cfg, GlobalConfig global)
		{
			PowerMultiplier = cfg.Bind<float>("BaseballBat", "PowerMultiplier", 2.5f, "Multiplier applied to swing power for non-golf-ball hits (e.g. golf carts).");
			GolfBallPowerMultiplier = cfg.Bind<float>("BaseballBat", "GolfBallPowerMultiplier", 1.25f, "Multiplier applied to swing power specifically for golf ball hits.");
			Uses = cfg.Bind<float>("BaseballBat", "Uses", 99f, "Number of swings before the bat is consumed. Set high for near-infinite use.");
			GiveKey = cfg.Bind<Key>("BaseballBat", "GiveKey", (Key)100, "Key to press to add the baseball bat to your inventory.");
		}
	}
	public class BearConfig
	{
		private const string Section = "Bear";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Count { get; private set; }

		public ConfigEntry<float> SpawnRadius { get; private set; }

		public ConfigEntry<float> SessionDuration { get; private set; }

		public ConfigEntry<float> WalkSpeed { get; private set; }

		public ConfigEntry<float> RunSpeed { get; private set; }

		public ConfigEntry<float> ChargeSpeed { get; private set; }

		public ConfigEntry<float> TurnSpeed { get; private set; }

		public ConfigEntry<float> WanderRadius { get; private set; }

		public ConfigEntry<float> ChargeRange { get; private set; }

		public ConfigEntry<float> AttackRange { get; private set; }

		public ConfigEntry<float> AttackCooldown { get; private set; }

		public ConfigEntry<float> AttackAnimationDuration { get; private set; }

		public ConfigEntry<float> SpawnAnimationDuration { get; private set; }

		public ConfigEntry<float> DeathAnimationDuration { get; private set; }

		public ConfigEntry<float> StunDuration { get; private set; }

		public ConfigEntry<float> EnrageDuration { get; private set; }

		public ConfigEntry<float> EnrageSpeedMultiplier { get; private set; }

		public ConfigEntry<float> MaxHP { get; private set; }

		public ConfigEntry<float> DamageDuelingPistol { get; private set; }

		public ConfigEntry<float> DamageElephantGun { get; private set; }

		public ConfigEntry<float> DamageRocketDirect { get; private set; }

		public ConfigEntry<float> DamageRocketExplosion { get; private set; }

		public ConfigEntry<float> DamageGolfClub { get; private set; }

		public ConfigEntry<float> DamageBaseballBat { get; private set; }

		public ConfigEntry<float> DamageOrbitalLaser { get; private set; }

		public ConfigEntry<float> MeleeKnockbackForce { get; private set; }

		public ConfigEntry<float> BatKnockbackForce { get; private set; }

		public ConfigEntry<float> MaxClimbHeight { get; private set; }

		public ConfigEntry<float> TargetLockDuration { get; private set; }

		public ConfigEntry<float> TargetStealThreshold { get; private set; }

		public ConfigEntry<float> TargetAbandonDistance { get; private set; }

		public ConfigEntry<float> AggroStealThreshold { get; private set; }

		public ConfigEntry<float> AggroDuration { get; private set; }

		public ConfigEntry<float> MeleeHitRange { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> LogMovementDiagnostics { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public BearConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Bear", "GiveKey", (Key)89, "Debug key to add the Bear item to your inventory.");
			Uses = cfg.Bind<float>("Bear", "Uses", 1f, "Number of uses per Bear item pickup.");
			Count = cfg.Bind<float>("Bear", "BearCount", 2f, "Number of bears spawned per item use.");
			SpawnRadius = cfg.Bind<float>("Bear", "SpawnRadius", 15f, "Radius around the player within which bears spawn.");
			SessionDuration = cfg.Bind<float>("Bear", "SessionDuration", 60f, "Seconds before all remaining bears are forcibly despawned.");
			WalkSpeed = cfg.Bind<float>("Bear", "WalkSpeed", 4f, "Bear movement speed while wandering or obstructed (units/sec).");
			RunSpeed = cfg.Bind<float>("Bear", "RunSpeed", 9f, "Bear movement speed while pursuing a target (units/sec).");
			ChargeSpeed = cfg.Bind<float>("Bear", "ChargeSpeed", 14f, "Bear movement speed during the committed charge phase (units/sec).");
			TurnSpeed = cfg.Bind<float>("Bear", "TurnSpeed", 6f, "How quickly the bear rotates to face its movement direction.");
			WanderRadius = cfg.Bind<float>("Bear", "WanderRadius", 12f, "Radius of the area the bear wanders within when idle.");
			ChargeRange = cfg.Bind<float>("Bear", "ChargeRange", 10f, "Distance at which the bear commits to a charge attack (units).");
			AttackRange = cfg.Bind<float>("Bear", "AttackRange", 2.8f, "Distance at which the bear's attack swing connects (units).");
			AttackCooldown = cfg.Bind<float>("Bear", "AttackCooldown", 0.7f, "Seconds of recovery after an attack before the bear can swipe again. The bear keeps tracking its target during this window rather than standing still.");
			AttackAnimationDuration = cfg.Bind<float>("Bear", "AttackAnimationDuration", 1.2f, "Total duration of the attack animation. Hit is applied at 55% of this value.");
			SpawnAnimationDuration = cfg.Bind<float>("Bear", "SpawnAnimationDuration", 2f, "Duration of the Buff/spawn-in animation before the bear begins hunting.");
			DeathAnimationDuration = cfg.Bind<float>("Bear", "DeathAnimationDuration", 2.5f, "How long the death animation plays before the bear is destroyed.");
			StunDuration = cfg.Bind<float>("Bear", "StunDuration", 2f, "Seconds the bear is stunned after being hit by an explosion.");
			EnrageDuration = cfg.Bind<float>("Bear", "EnrageDuration", 5f, "Seconds the bear runs at enrage speed after recovering from a stun.");
			EnrageSpeedMultiplier = cfg.Bind<float>("Bear", "EnrageSpeedMultiplier", 1.5f, "Speed multiplier applied to RunSpeed during enrage.");
			MaxHP = cfg.Bind<float>("Bear", "MaxHP", 100f, "Maximum HP for a bear. Each hit reduces HP by the weapon's damage value; bear dies at 0.");
			DamageDuelingPistol = cfg.Bind<float>("Bear", "DamageDuelingPistol", 25f, "HP damage dealt to a bear by a dueling pistol shot.");
			DamageElephantGun = cfg.Bind<float>("Bear", "DamageElephantGun", 50f, "HP damage dealt to a bear by an elephant gun shot.");
			DamageRocketDirect = cfg.Bind<float>("Bear", "DamageRocketDirect", 100f, "HP damage dealt to a bear by a direct rocket hit (explosion centre within 1.5 units).");
			DamageRocketExplosion = cfg.Bind<float>("Bear", "DamageRocketExplosion", 35f, "HP damage dealt to a bear by rocket splash damage (not a direct hit).");
			DamageGolfClub = cfg.Bind<float>("Bear", "DamageGolfClub", 25f, "HP damage dealt to a bear by a golf club swing.");
			DamageBaseballBat = cfg.Bind<float>("Bear", "DamageBaseballBat", 40f, "HP damage dealt to a bear by a baseball bat swing.");
			DamageOrbitalLaser = cfg.Bind<float>("Bear", "DamageOrbitalLaser", 100f, "HP damage dealt to a bear by the orbital laser.");
			MeleeKnockbackForce = cfg.Bind<float>("Bear", "MeleeKnockbackForce", 12f, "Impulse force applied to a bear's rigidbody when hit by a golf club swing.");
			BatKnockbackForce = cfg.Bind<float>("Bear", "BatKnockbackForce", 22f, "Impulse force applied to a bear's rigidbody when hit by a baseball bat swing.");
			MaxClimbHeight = cfg.Bind<float>("Bear", "MaxClimbHeight", 6f, "Max height difference (units) before a target is considered unreachable.");
			TargetLockDuration = cfg.Bind<float>("Bear", "TargetLockDuration", 8f, "Minimum seconds a bear keeps its target before re-evaluating.");
			TargetStealThreshold = cfg.Bind<float>("Bear", "TargetStealThreshold", 12f, "A new candidate must be this many units closer to steal the lock after the timer expires.");
			TargetAbandonDistance = cfg.Bind<float>("Bear", "TargetAbandonDistance", 65f, "If the locked target moves beyond this distance the lock is dropped immediately.");
			AggroStealThreshold = cfg.Bind<float>("Bear", "AggroStealThreshold", 4f, "A player who hit the bear can steal the lock if at least this many units closer (lower bar than normal steal).");
			AggroDuration = cfg.Bind<float>("Bear", "AggroDuration", 15f, "How long (seconds) aggro on a specific player lasts after they hit the bear.");
			MeleeHitRange = cfg.Bind<float>("Bear", "MeleeHitRange", 2.5f, "Radius (units) around the swing hitbox centre that counts as a golf-club/bat hit on a bear.");
			FriendlyFire = cfg.Bind<bool>("Bear", "FriendlyFire", false, "If false, bears will not target or attack the player who summoned them.");
			LogMovementDiagnostics = cfg.Bind<bool>("Bear", "LogMovementDiagnostics", false, "Logs once per second how far each bear intended to move versus how far it actually moved. Use to diagnose bears that animate but stay in place.");
			AttackFinishedPlayers = cfg.Bind<bool>("Bear", "AttackFinishedPlayers", false, "If true, bears will target players who have already holed out. If false, bears ignore them.");
		}
	}
	public class BlackHoleGrenadeConfig
	{
		private const string Section = "BlackHoleGrenade";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> MaxThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> GraceTime { get; private set; }

		public ConfigEntry<float> SuckDuration { get; private set; }

		public ConfigEntry<float> SuckRadius { get; private set; }

		public ConfigEntry<float> SuckForce { get; private set; }

		public ConfigEntry<float> MaxSuckForce { get; private set; }

		public ConfigEntry<float> SpitForce { get; private set; }

		public ConfigEntry<float> SpitVfxScale { get; private set; }

		public ConfigEntry<float> KnockdownRadius { get; private set; }

		public ConfigEntry<bool> ExcludeThrower { get; private set; }

		public ConfigEntry<float> BonusGolfCartForceMultiplier { get; private set; }

		public ConfigEntry<bool> AffectsGolfBalls { get; private set; }

		public ConfigEntry<bool> ElectroShieldPreventsEffect { get; private set; }

		public BlackHoleGrenadeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("BlackHoleGrenade", "GiveKey", (Key)91, "Debug key to add the Black Hole Grenade to your inventory.");
			Uses = cfg.Bind<float>("BlackHoleGrenade", "Uses", 1f, "Number of uses per Black Hole Grenade pickup.");
			ThrowSpeed = cfg.Bind<float>("BlackHoleGrenade", "ThrowSpeed", 20f, "Initial throw speed in m/s.");
			MaxThrowSpeed = cfg.Bind<float>("BlackHoleGrenade", "MaxThrowSpeed", 30f, "Server-side clamp on throw speed to prevent exploits.");
			LobAngle = cfg.Bind<float>("BlackHoleGrenade", "LobAngle", 0.4f, "Upward component added to the throw direction to create an arc. 0 = flat, 1 = 45° upward.");
			GraceTime = cfg.Bind<float>("BlackHoleGrenade", "GraceTime", 0.35f, "Seconds after throwing before the grenade can stick to the ground.");
			SuckDuration = cfg.Bind<float>("BlackHoleGrenade", "SuckDuration", 6f, "How many seconds the suction phase lasts before spitting.");
			SuckRadius = cfg.Bind<float>("BlackHoleGrenade", "SuckRadius", 35f, "Radius in units of the suction field.");
			SuckForce = cfg.Bind<float>("BlackHoleGrenade", "SuckForce", 8f, "Suction acceleration (m/s²) applied at the outer edge of the suction field.");
			MaxSuckForce = cfg.Bind<float>("BlackHoleGrenade", "MaxSuckForce", 40f, "Suction acceleration (m/s²) applied right at the center of the black hole.");
			SpitForce = cfg.Bind<float>("BlackHoleGrenade", "SpitForce", 35f, "Speed (m/s) at which objects and players are ejected during the spit phase.");
			SpitVfxScale = cfg.Bind<float>("BlackHoleGrenade", "SpitVfxScale", 3f, "Scale of the explosion VFX played on all clients when the black hole collapses.");
			KnockdownRadius = cfg.Bind<float>("BlackHoleGrenade", "KnockdownRadius", 15f, "Distance from the black hole at which a player gets knocked down. Must be less than SuckRadius. Set to 0 to disable.");
			ExcludeThrower = cfg.Bind<bool>("BlackHoleGrenade", "ExcludeThrower", true, "If true, the player who threw the grenade is not affected by suction or spit.");
			BonusGolfCartForceMultiplier = cfg.Bind<float>("BlackHoleGrenade", "BonusGolfCartForceMultiplier", 2f, "Additional force multiplier applied to golf carts.");
			AffectsGolfBalls = cfg.Bind<bool>("BlackHoleGrenade", "AffectsGolfBalls", true, "If true, the black hole grenade sucks in and spits out golf balls. Set to false to leave golf balls unaffected.");
			ElectroShieldPreventsEffect = cfg.Bind<bool>("BlackHoleGrenade", "ElectroShieldPreventsEffect", true, "If true, a player with an active electro shield is immune to the black hole's suction pull and spit ejection.");
		}
	}
	public class DonutConfig
	{
		private const string Section = "Donut";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Speed { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> TerrainFollowSpeed { get; private set; }

		public ConfigEntry<float> TurnSpeed { get; private set; }

		public ConfigEntry<float> CameraPitch { get; private set; }

		public ConfigEntry<float> CameraDistance { get; private set; }

		public ConfigEntry<float> MouseSensitivity { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> LaserUses { get; private set; }

		public ConfigEntry<float> LaserAnticipationDuration { get; private set; }

		public ConfigEntry<float> LaserCooldown { get; private set; }

		public ConfigEntry<float> HitsToDestroy { get; private set; }

		public ConfigEntry<float> CrashImpactForce { get; private set; }

		public ConfigEntry<float> CrashDownwardForce { get; private set; }

		public ConfigEntry<float> CrashTorque { get; private set; }

		public ConfigEntry<float> CrashExplosionScale { get; private set; }

		public ConfigEntry<bool> OverlayEnabled { get; private set; }

		public DonutConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Donut", "GiveKey", (Key)86, "Debug key to add the Donut to your inventory.");
			Uses = cfg.Bind<float>("Donut", "Uses", 1f, "Number of Donut uses per pickup.");
			OverlayEnabled = cfg.Bind<bool>("Donut", "OverlayEnabled", true, "Show the Donut screen overlay (vignette, scanlines, noise, crosshair, and laser-use dots) while piloting. Purely cosmetic — turn it off if the full-screen effects cost you frames.");
			Speed = cfg.Bind<float>("Donut", "Speed", 30f, "Horizontal movement speed of the Donut in units per second.");
			Altitude = cfg.Bind<float>("Donut", "Altitude", 20f, "Height above terrain the Donut hovers at.");
			TerrainFollowSpeed = cfg.Bind<float>("Donut", "TerrainFollowSpeed", 5f, "How quickly the Donut adjusts its altitude to match terrain changes (lerp speed).");
			TurnSpeed = cfg.Bind<float>("Donut", "TurnSpeed", 8f, "How quickly the Donut rotates to face the movement direction (Slerp speed).");
			CameraPitch = cfg.Bind<float>("Donut", "CameraPitch", 60f, "Camera pitch angle in degrees during the Donut session (0 = horizontal, 90 = straight down).");
			CameraDistance = cfg.Bind<float>("Donut", "CameraDistance", 40f, "Camera distance addition from the Donut during the session.");
			MouseSensitivity = cfg.Bind<float>("Donut", "MouseSensitivity", 0.2f, "Mouse X sensitivity for rotating the Donut orbit camera.");
			Duration = cfg.Bind<float>("Donut", "Duration", 30f, "How many seconds the Donut session lasts before automatically ending.");
			LaserUses = cfg.Bind<float>("Donut", "LaserUses", 3f, "How many orbital laser strikes the player can fire during a Donut session.");
			LaserAnticipationDuration = cfg.Bind<float>("Donut", "LaserAnticipationDuration", 1.5f, "Seconds of anticipation before the orbital laser fires. The laser tracks the Donut during this window.");
			LaserCooldown = cfg.Bind<float>("Donut", "LaserCooldown", 3f, "Minimum seconds between orbital laser fires.");
			HitsToDestroy = cfg.Bind<float>("Donut", "HitsToDestroy", 1f, "Rocket hits required to shoot down the Donut. Set to 0 to make it invincible.");
			CrashImpactForce = cfg.Bind<float>("Donut", "CrashImpactForce", 500f, "Impulse force applied to the Donut in the direction of the rocket hit when shot down.");
			CrashDownwardForce = cfg.Bind<float>("Donut", "CrashDownwardForce", 15f, "Impulse force applied to the Donut in the downward direction.");
			CrashTorque = cfg.Bind<float>("Donut", "CrashTorque", 1.2f, "Magnitude of the random tumble torque applied to the Donut when shot down.");
			CrashExplosionScale = cfg.Bind<float>("Donut", "CrashExplosionScale", 4f, "Explosion scale multiplier for when a Donut crashes. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class DroneSwarmConfig
	{
		private const string Section = "DroneSwarm";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> BaseDroneCount { get; private set; }

		public ConfigEntry<float> PerPlayerScalingFactor { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> WanderRadius { get; private set; }

		public ConfigEntry<float> WanderSpeed { get; private set; }

		public ConfigEntry<float> WanderTurnRate { get; private set; }

		public ConfigEntry<float> AltitudeVariance { get; private set; }

		public ConfigEntry<float> CircleTimeMin { get; private set; }

		public ConfigEntry<float> CircleTimeMax { get; private set; }

		public ConfigEntry<float> DiveSpeed { get; private set; }

		public ConfigEntry<float> DiveAcceleration { get; private set; }

		public ConfigEntry<float> HomingStopDistance { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public ConfigEntry<float> MaxSessionDuration { get; private set; }

		public DroneSwarmConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			GiveKey = cfg.Bind<Key>("DroneSwarm", "GiveKey", (Key)77, "Debug key to add the Drone Swarm item to your inventory.");
			Uses = cfg.Bind<float>("DroneSwarm", "Uses", 1f, "Number of uses per Drone Swarm pickup.");
			BaseDroneCount = cfg.Bind<float>("DroneSwarm", "BaseDroneCount", 15f, "Number of drones spawned per use. Keep at or below 12 to avoid network overhead.");
			PerPlayerScalingFactor = cfg.Bind<float>("DroneSwarm", "PerPlayerScalingFactor", 0.1f, new ConfigDescription("Increase the DroneCount as: DroneCount = BaseDroneCount * (1 + [NumPlayers * PerPlayerScalingFactor]). Set to 0 to disable.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			Altitude = cfg.Bind<float>("DroneSwarm", "Altitude", 300f, "Height (metres) at which drones circle above the player centroid.");
			WanderRadius = cfg.Bind<float>("DroneSwarm", "WanderRadius", 150f, "Maximum distance (metres) from the wander centre a drone waypoint may be placed.");
			WanderSpeed = cfg.Bind<float>("DroneSwarm", "WanderSpeed", 125f, "Cruise speed (metres/second) while drones are wandering before they dive.");
			WanderTurnRate = cfg.Bind<float>("DroneSwarm", "WanderTurnRate", 45f, "Maximum steering rate (degrees/second) while wandering. Lower = lazier, wider arcs. Higher = tighter turns.");
			AltitudeVariance = cfg.Bind<float>("DroneSwarm", "AltitudeVariance", 25f, "Half-range (metres) of random altitude variation added to each waypoint. Drones pick altitudes between Altitude ± AltitudeVariance.");
			CircleTimeMin = cfg.Bind<float>("DroneSwarm", "CircleTimeMin", 3f, "Minimum seconds a drone circles before diving (randomised per drone).");
			CircleTimeMax = cfg.Bind<float>("DroneSwarm", "CircleTimeMax", 30f, "Maximum seconds a drone circles before diving (randomised per drone).");
			DiveSpeed = cfg.Bind<float>("DroneSwarm", "DiveSpeed", 20f, "Initial dive speed in metres per second.");
			DiveAcceleration = cfg.Bind<float>("DroneSwarm", "DiveAcceleration", 40f, "How many metres per second the dive speed increases each second.");
			HomingStopDistance = cfg.Bind<float>("DroneSwarm", "HomingStopDistance", 75f, "Distance from the target (metres) at which the drone stops tracking and flies straight, giving the target a chance to dodge. Set to 0 to always home.");
			ArrivalRadius = cfg.Bind<float>("DroneSwarm", "ArrivalRadius", 3f, "Distance from the aim point (metres) at which the drone detonates.");
			ExplosionScale = cfg.Bind<float>("DroneSwarm", "ExplosionScale", 1.05f, "Scale multiplier for the drone impact explosion radius and force.");
			FriendlyFire = cfg.Bind<bool>("DroneSwarm", "FriendlyFire", false, "If true, drones may target the player who summoned them.");
			AttackFinishedPlayers = cfg.Bind<bool>("DroneSwarm", "AttackFinishedPlayers", false, "If true, drones may target players who have already holed out.");
			MaxSessionDuration = cfg.Bind<float>("DroneSwarm", "MaxSessionDuration", 60f, "Safety cap (seconds) after which any remaining drones are force-destroyed.");
		}
	}
	public class ExplosiveGolfBallsConfig
	{
		private const string Section = "ExplosiveGolfBalls";

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<bool> LockOnOnly { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ExplosiveGolfBallsConfig(ConfigFile cfg, GlobalConfig global)
		{
			Uses = cfg.Bind<float>("ExplosiveGolfBalls", "Uses", 3f, "Number of swings that will produce an exploding ball.");
			LockOnOnly = cfg.Bind<bool>("ExplosiveGolfBalls", "LockOnOnly", true, "When true, the explosion only triggers on lock-on (overcharge) shots.");
			ExplosionScale = cfg.Bind<float>("ExplosiveGolfBalls", "ExplosionScale", 1f, "Scale multiplier applied to the explosion radius and force.");
			GiveKey = cfg.Bind<Key>("ExplosiveGolfBalls", "GiveKey", (Key)0, "Debug key to add Explosive Golf Balls to your inventory.");
		}
	}
	public class FlamethrowerConfig
	{
		private const string Section = "Flamethrower";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FuelPerUse { get; private set; }

		public ConfigEntry<float> BurnDuration { get; private set; }

		public ConfigEntry<float> BurnRequestInterval { get; private set; }

		public FlamethrowerConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Flamethrower", "GiveKey", (Key)98, "Hotkey to give yourself a Flamethrower (debug/testing).");
			Uses = cfg.Bind<float>("Flamethrower", "Uses", 1f, "Number of fuel canisters per Flamethrower pickup. Each canister provides FuelPerUse seconds of fire.");
			FuelPerUse = cfg.Bind<float>("Flamethrower", "FuelPerUse", 3f, "Seconds of continuous fire provided by each fuel canister.");
			BurnDuration = cfg.Bind<float>("Flamethrower", "BurnDuration", 4f, "Seconds a hit player stays on fire after the last flamethrower contact. Resets on each new hit.");
			BurnRequestInterval = cfg.Bind<float>("Flamethrower", "BurnRequestInterval", 0.5f, "Minimum seconds between burn-request messages sent per victim while the flame collider overlaps them.");
		}
	}
	public class FreezeConfig
	{
		private const string Section = "FreezeWorld";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> Friction { get; private set; }

		public ConfigEntry<float> Bounciness { get; private set; }

		public ConfigEntry<float> CartSidewaysStiffness { get; private set; }

		public ConfigEntry<float> GripRadius { get; private set; }

		public ConfigEntry<bool> AffectsUser { get; private set; }

		public FreezeConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			GiveKey = cfg.Bind<Key>("FreezeWorld", "GiveKey", (Key)105, "Debug key to add the Freeze World item to your inventory.");
			Uses = cfg.Bind<float>("FreezeWorld", "Uses", 1f, "Number of uses per Freeze World pickup.");
			Duration = cfg.Bind<float>("FreezeWorld", "Duration", 15f, "Seconds the world stays frozen before physics and visuals are restored.");
			Friction = cfg.Bind<float>("FreezeWorld", "Friction", 0.05f, "Surface friction applied to all physics contacts during a freeze (0 = frictionless).");
			Bounciness = cfg.Bind<float>("FreezeWorld", "Bounciness", 0.2f, new ConfigDescription("Surface bounciness applied to all physics contacts during a freeze.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			CartSidewaysStiffness = cfg.Bind<float>("FreezeWorld", "CartSidewaysStiffness", 0.15f, "Sideways friction stiffness for golf cart wheel colliders while frozen (0 = no grip, 1 = normal). Lower values cause more drift.");
			GripRadius = cfg.Bind<float>("FreezeWorld", "GripRadius", 1.5f, "Distance (metres) from the local player's own ball within which normal traction is restored, allowing them to stop and take a shot.");
			AffectsUser = cfg.Bind<bool>("FreezeWorld", "AffectsUser", false, "Whether the player who activates Freeze World is themselves affected by its ice physics and movement restrictions. Defaults to false (activator is immune).");
		}
	}
	public class GlobalConfig
	{
		private readonly Dictionary<int, ConfigEntry<bool>> _itemEnabledEntries = new Dictionary<int, ConfigEntry<bool>>();

		private readonly Dictionary<int, ConfigEntry<bool>> _itemWarningEnabledEntries = new Dictionary<int, ConfigEntry<bool>>();

		public const int PoolAhead = 0;

		public const int PoolLead = 1;

		public const int PoolBehind50 = 2;

		public const int PoolBehind125 = 3;

		public const int PoolBehind200 = 4;

		public const int PoolMobility = 5;

		private static readonly (int pool, string suffix)[] PoolSuffixes = new(int, string)[6]
		{
			(1, "Lead"),
			(2, "Behind50"),
			(3, "Behind125"),
			(4, "Behind200"),
			(0, "Ahead"),
			(5, "Mobility")
		};

		private readonly Dictionary<(int itemType, int pool), ConfigEntry<float>> _poolWeightEntries = new Dictionary<(int, int), ConfigEntry<float>>();

		public ConfigEntry<bool> CustomItemSpawnsEnabled { get; private set; }

		public ConfigEntry<float> CustomItemSpawnRate { get; private set; }

		public ConfigEntry<bool> AllowHotkeyItemGiving { get; private set; }

		public ConfigEntry<bool> BloodEffectsEnabled { get; private set; }

		public ConfigEntry<float> NumInventorySlots { get; private set; }

		public ConfigEntry<bool> FirstPlaceStarEnabled { get; private set; }

		public ConfigEntry<float> FirstPlaceStarHeight { get; private set; }

		public ConfigEntry<bool> NetworkDiagnosticsEnabled { get; private set; }

		public ConfigEntry<float> NetworkDiagnosticsInterval { get; private set; }

		public ConfigEntry<int> NetworkDiagnosticsTopMessages { get; private set; }

		public ConfigEntry<bool> BomberOverlayEnabled { get; private set; }

		public ConfigEntry<bool> PlayerBoxOverlayEnabled { get; private set; }

		public ConfigEntry<bool> CustomVfxEnabled { get; private set; }

		public ConfigEntry<bool> PerfDiagnosticsEnabled { get; private set; }

		public ConfigEntry<bool> ModCpuProfilingEnabled { get; private set; }

		public ConfigEntry<float> PerfDiagnosticsInterval { get; private set; }

		public ConfigEntry<int> PerfDiagnosticsTopObjects { get; private set; }

		public ConfigEntry<Key> SpawnConfigUIKey { get; private set; }

		public ConfigEntry<Key> SpawnerToggleKey { get; private set; }

		public ConfigEntry<bool> SpawnerSuppressItemSpawner { get; private set; }

		public ConfigEntry<float> SpawnerUiScale { get; private set; }

		public ConfigEntry<bool> WarningsEnabled { get; private set; }

		public ConfigEntry<float> WarningDuration { get; private set; }

		public ConfigEntry<bool> WarningShowForSelf { get; private set; }

		public ConfigEntry<bool> WarningSymbolEnabled { get; private set; }

		public ConfigEntry<float> WarningPrefabScale { get; private set; }

		public ConfigEntry<float> WarningSymbolAlpha { get; private set; }

		public ConfigEntry<float> WarningPiPScale { get; private set; }

		public bool GetItemEnabled(ItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			ConfigEntry<bool> value;
			return !_itemEnabledEntries.TryGetValue((int)itemType, out value) || value.Value;
		}

		public void SetItemEnabled(ItemType itemType, bool enabled)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected I4, but got Unknown
			if (_itemEnabledEntries.TryGetValue((int)itemType, out var value))
			{
				value.Value = enabled;
			}
		}

		public bool GetItemWarningEnabled(ItemType itemType)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			ConfigEntry<bool> value;
			return WarningsEnabled.Value && _itemWarningEnabledEntries.TryGetValue((int)itemType, out value) && value.Value;
		}

		public float GetItemPoolWeight(ItemType itemType, int poolIndex)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected I4, but got Unknown
			ConfigEntry<float> value;
			return _poolWeightEntries.TryGetValue(((int)itemType, poolIndex), out value) ? value.Value : 0f;
		}

		public void SetItemPoolWeight(ItemType itemType, int poolIndex, float value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected I4, but got Unknown
			if (_poolWeightEntries.TryGetValue(((int)itemType, poolIndex), out var value2))
			{
				value2.Value = value;
			}
		}

		public GlobalConfig(ConfigFile cfg)
		{
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Expected O, but got Unknown
			CustomItemSpawnsEnabled = cfg.Bind<bool>("IssaPlugin", "Enabled", true, "Master kill-switch for allowing custom items to be spawned without having to set all spawn weights to 0.");
			CustomItemSpawnRate = cfg.Bind<float>("IssaPlugin", "CustomItemSpawnRate", 0.5f, "Global multiplier applied to every custom item's spawn weight. 1.0 = default, 0.5 = half as frequent, 0.0 = never spawn.");
			AllowHotkeyItemGiving = cfg.Bind<bool>("IssaPlugin", "AllowHotkeyItemGiving", false, "Whether non-host clients can use item hotkeys to give themselves items. The host is always exempt.");
			BloodEffectsEnabled = cfg.Bind<bool>("IssaPlugin", "BloodEffectsEnabled", true, "Whether blood splatter effects are shown when players are hit by guns. Each client sets this independently.");
			NumInventorySlots = cfg.Bind<float>("IssaPlugin", "NumInventorySlots", 6f, "Change the number of inventory slots available.");
			FirstPlaceStarEnabled = cfg.Bind<bool>("IssaPlugin", "FirstPlaceStarEnabled", false, "Show a gold star above the first-place player so they are easy to spot.");
			FirstPlaceStarHeight = cfg.Bind<float>("IssaPlugin", "FirstPlaceStarHeight", 1.5f, "Height in Unity units above the player's origin at which the gold star appears.");
			BomberOverlayEnabled = cfg.Bind<bool>("Diagnostics", "BomberOverlayEnabled", true, "A/B TEST. Set to false to disable the stealth bomber / predator missile screen overlay (scanlines, vignette, noise, glitch bands) entirely. Purely cosmetic — use it to measure how much of the FPS drop during those items comes from the overlay.");
			PlayerBoxOverlayEnabled = cfg.Bind<bool>("Diagnostics", "PlayerBoxOverlayEnabled", true, "A/B TEST. Set to false to disable the player target boxes and name labels drawn during stealth bomber targeting, predator missile steering, and AC130 sessions. Purely cosmetic — use it to measure how much of the FPS drop during those items comes from this overlay.");
			CustomVfxEnabled = cfg.Bind<bool>("Diagnostics", "CustomVfxEnabled", true, "A/B TEST. Set to false to disable all custom particle and trail VFX (explosions, smoke/fire trails, Red Bull and Spinach trails, black hole, drone explosions, blood splatter, and similar). Item mechanics are unaffected — only the visuals are skipped. Use it to test whether the mod's VFX prefabs, and the shaders they were converted to for URP, are responsible for frame drops.");
			NetworkDiagnosticsEnabled = cfg.Bind<bool>("Diagnostics", "NetworkDiagnosticsEnabled", false, "Log a periodic summary of network traffic and latency to the BepInEx log. Off by default. Enable this if you are reporting lag, so the log shows which messages dominate bandwidth.");
			NetworkDiagnosticsInterval = cfg.Bind<float>("Diagnostics", "NetworkDiagnosticsInterval", 30f, "Seconds between network diagnostics summaries. Only used when NetworkDiagnosticsEnabled is true.");
			PerfDiagnosticsEnabled = cfg.Bind<bool>("Diagnostics", "PerfDiagnosticsEnabled", false, "Log a periodic performance report: frame timing, CPU/GPU counters, GC allocation, a census of spawned network objects with per-type change since the last report, and physics object counts. Off by default. Enable this if you are reporting FPS problems.");
			ModCpuProfilingEnabled = cfg.Bind<bool>("Diagnostics", "ModCpuProfilingEnabled", false, "Attribute main-thread CPU time to the mod's own subsystems (Harmony patches, overlays, network bridges) and report it alongside the performance report. Answers how much of the frame the mod itself costs. Off by default: it adds timing overhead to every patch, including ones invoked from the physics worker thread, so enable it only while investigating. REQUIRES A GAME RESTART to take effect, because the timing wrappers are installed at startup.");
			PerfDiagnosticsInterval = cfg.Bind<float>("Diagnostics", "PerfDiagnosticsInterval", 30f, "Seconds between performance reports. Only used when PerfDiagnosticsEnabled is true.");
			PerfDiagnosticsTopObjects = cfg.Bind<int>("Diagnostics", "PerfDiagnosticsTopObjects", 15, "How many of the most numerous spawned object types to list in each performance report.");
			NetworkDiagnosticsTopMessages = cfg.Bind<int>("Diagnostics", "NetworkDiagnosticsTopMessages", 8, "How many of the heaviest message types to list in each diagnostics summary.");
			SpawnConfigUIKey = cfg.Bind<Key>("UI", "SpawnConfigUIKey", (Key)27, "Hotkey that opens/closes the Spawn Config GUI panel. The panel lets the host adjust per-pool spawn weights at runtime.");
			SpawnerToggleKey = cfg.Bind<Key>("UI", "SpawnerToggleKey", (Key)22, "Hotkey that opens/closes the item spawner window, which lets the host give any item to any player. Defaults to H to match the ItemSpawner mod. Set to None to disable the window entirely.");
			SpawnerUiScale = cfg.Bind<float>("UI", "SpawnerUiScale", 0f, new ConfigDescription("Size multiplier for the item spawner window. 0 (the default) scales it automatically from your screen height against a 1080p reference, so it stays the same apparent size on a 1440p or 4K display instead of shrinking. Set a value to override that -- 1 is the original fixed size, 2 is double.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 4f), Array.Empty<object>()));
			SpawnerSuppressItemSpawner = cfg.Bind<bool>("UI", "SpawnerSuppressItemSpawner", true, "When the ItemSpawner mod is also installed, hide its window so only our spawner (with search, source filtering, and a grid layout) appears. Set to false to show both.");
			Reg(cfg, _itemEnabledEntries, 100, "BaseballBatEnabled", "Baseball Bat");
			Reg(cfg, _itemEnabledEntries, 101, "StealthBomberEnabled", "Stealth Bomber");
			Reg(cfg, _itemEnabledEntries, 102, "PredatorMissileEnabled", "Predator Missile");
			Reg(cfg, _itemEnabledEntries, 103, "AC130Enabled", "AC-130 Gunship");
			Reg(cfg, _itemEnabledEntries, 104, "FreezeEnabled", "Freeze World");
			Reg(cfg, _itemEnabledEntries, 105, "LowGravityEnabled", "Low Gravity");
			Reg(cfg, _itemEnabledEntries, 106, "SniperRifleEnabled", "Sniper Rifle");
			Reg(cfg, _itemEnabledEntries, 107, "DonutEnabled", "Donut");
			Reg(cfg, _itemEnabledEntries, 108, "JavelinEnabled", "Javelin");
			Reg(cfg, _itemEnabledEntries, 109, "StickyGrenadeEnabled", "Sticky Grenade");
			Reg(cfg, _itemEnabledEntries, 110, "BearEnabled", "Bear");
			Reg(cfg, _itemEnabledEntries, 111, "NukeEnabled", "Nuke");
			Reg(cfg, _itemEnabledEntries, 112, "BlackHoleGrenadeEnabled", "Black Hole Grenade");
			Reg(cfg, _itemEnabledEntries, 113, "PlaceableWallEnabled", "Placeable Wall");
			Reg(cfg, _itemEnabledEntries, 114, "AK47Enabled", "AK-47");
			Reg(cfg, _itemEnabledEntries, 115, "HarrierEnabled", "Harrier Jet");
			Reg(cfg, _itemEnabledEntries, 116, "PositionSwapEnabled", "Position Swap");
			Reg(cfg, _itemEnabledEntries, 117, "PoisonJarEnabled", "Poison Jar");
			Reg(cfg, _itemEnabledEntries, 118, "DroneSwarmEnabled", "Drone Swarm");
			Reg(cfg, _itemEnabledEntries, 119, "RedBullEnabled", "Red Bull");
			Reg(cfg, _itemEnabledEntries, 120, "SuperDonutEnabled", "Super Donut");
			Reg(cfg, _itemEnabledEntries, 121, "GravityGunEnabled", "Gravity Gun");
			Reg(cfg, _itemEnabledEntries, 122, "RocketTetherEnabled", "Rocket Tether");
			Reg(cfg, _itemEnabledEntries, 123, "JetpackEnabled", "Jetpack");
			Reg(cfg, _itemEnabledEntries, 124, "TeleporterEnabled", "Teleporter");
			Reg(cfg, _itemEnabledEntries, 125, "SpinachEnabled", "Spinach");
			Reg(cfg, _itemEnabledEntries, 126, "FlamethrowerEnabled", "Flamethrower");
			Reg(cfg, _itemEnabledEntries, 127, "RocketTetherGrenadeEnabled", "Rocket Tether Grenade");
			Reg(cfg, _itemEnabledEntries, 135, "GolfCartLauncherEnabled", "Golf Cart Launcher");
			WarningsEnabled = cfg.Bind<bool>("Warnings", "Enabled", true, "Master toggle for all item-use warning banners and PiP cameras.");
			WarningDuration = cfg.Bind<float>("Warnings", "Duration", 5f, "How long (seconds) each warning banner and PiP camera is displayed.");
			WarningShowForSelf = cfg.Bind<bool>("Warnings", "ShowForSelf", false, "If true, the warning banner and PiP also appear for the player who used the item. Useful for testing.");
			WarningSymbolEnabled = cfg.Bind<bool>("Warnings", "WarningSymbolEnabled", true, "If true, the warning particle effect is shown. Each client can disable it locally.");
			WarningPrefabScale = cfg.Bind<float>("Warnings", "WarningSymbolScale", 0.75f, "Controls the size of the warning prefab.");
			WarningSymbolAlpha = cfg.Bind<float>("Warnings", "WarningSymbolAlpha", 0.5f, "Controls the alpha channel of the start color of the warning prefab.");
			WarningPiPScale = cfg.Bind<float>("Warnings", "PiPScale", 1f, "Scale multiplier for the PiP camera box (base size 320x180). Valid range: 0.5 (160x90) to 2.0 (640x360).");
			RegWarn(cfg, _itemWarningEnabledEntries, 100, "BaseballBatWarning", "Baseball Bat", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 101, "BomberWarning", "Stealth Bomber", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 102, "MissileWarning", "Predator Missile", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 103, "AC130Warning", "AC-130 Gunship", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 104, "FreezeWarning", "Freeze World", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 105, "LowGravityWarning", "Low Gravity", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 106, "SniperRifleWarning", "Sniper Rifle", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 107, "DonutWarning", "Donut", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 108, "JavelinWarning", "Javelin", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 109, "StickyGrenadeWarning", "Sticky Grenade", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 110, "BearWarning", "Bear", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 111, "NukeWarning", "Nuke", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 112, "BlackHoleGrenadeWarning", "Black Hole Grenade", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 113, "PlaceableWallWarning", "Placeable Wall", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 114, "AK47Warning", "AK-47", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 115, "HarrierWarning", "Harrier Jet", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 116, "PositionSwapWarning", "Position Swap", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 117, "PoisonJarWarning", "Poison Jar", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 118, "DroneSwarmWarning", "Drone Swarm", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 119, "RedBullWarning", "Red Bull", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 120, "SuperDonutWarning", "Super Donut", defaultOn: true);
			RegWarn(cfg, _itemWarningEnabledEntries, 121, "GravityGunWarning", "Gravity Gun", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 122, "RocketTetherWarning", "Rocket Tether", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 123, "JetpackWarning", "Jetpack", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 124, "TeleporterWarning", "Teleporter", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 125, "SpinachWarning", "Spinach", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 126, "FlamethrowerWarning", "Flamethrower", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 127, "RocketTetherGrenadeWarning", "Rocket Tether Grenade", defaultOn: false);
			RegWarn(cfg, _itemWarningEnabledEntries, 135, "GolfCartLauncherWarning", "Golf Cart Launcher", defaultOn: false);
			BindAllItemPoolWeights(cfg);
			static void Reg(ConfigFile c, Dictionary<int, ConfigEntry<bool>> map, int id, string key, string label)
			{
				map[id] = c.Bind<bool>("ItemEnabled", key, true, "Whether the " + label + " is enabled and can spawn.");
			}
			static void RegWarn(ConfigFile c, Dictionary<int, ConfigEntry<bool>> map, int id, string key, string label, bool defaultOn)
			{
				map[id] = c.Bind<bool>("ItemWarnings", key, defaultOn, "Show a warning to all other players when " + label + " is used.");
			}
		}

		private void BindAllItemPoolWeights(ConfigFile cfg)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			foreach (CustomItemDefinition allItem in ItemRegistry.AllItems)
			{
				(int, string)[] poolSuffixes = PoolSuffixes;
				for (int i = 0; i < poolSuffixes.Length; i++)
				{
					var (num, text) = poolSuffixes[i];
					_poolWeightEntries[((int)allItem.ItemType, num)] = cfg.Bind<float>("ItemBoxSpawns", allItem.ConfigKeyPrefix + "Weight" + text, allItem.GetDefaultPoolWeight(num), "Spawn weight for " + allItem.DisplayName + " in the '" + text + "' pool. 0 = never spawns in this pool.");
				}
			}
		}
	}
	public class GolfCartLauncherConfig
	{
		private const string Section = "GolfCartLauncher";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FireRate { get; private set; }

		public ConfigEntry<float> LaunchSpeed { get; private set; }

		public ConfigEntry<float> Inaccuracy { get; private set; }

		public ConfigEntry<float> MaxAimingDistance { get; private set; }

		public ConfigEntry<float> SpawnForwardOffset { get; private set; }

		public ConfigEntry<float> SpawnVerticalOffset { get; private set; }

		public ConfigEntry<float> SpinPitch { get; private set; }

		public ConfigEntry<float> SpinYaw { get; private set; }

		public ConfigEntry<float> SpinRoll { get; private set; }

		public ConfigEntry<float> Lifetime { get; private set; }

		public ConfigEntry<float> ScreenShakeIntensity { get; private set; }

		public ConfigEntry<Key> JoyrideToggleKey { get; private set; }

		public ConfigEntry<bool> ShowJoyrideHud { get; private set; }

		public ConfigEntry<float> JoyrideSpinRetention { get; private set; }

		public ConfigEntry<float> JoyrideLaunchSpeed { get; private set; }

		public ConfigEntry<float> SettleDamping { get; private set; }

		public ConfigEntry<float> SettleDuration { get; private set; }

		public ConfigEntry<float> SettleAngularThreshold { get; private set; }

		public GolfCartLauncherConfig(ConfigFile cfg, GlobalConfig global)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Expected O, but got Unknown
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Expected O, but got Unknown
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Expected O, but got Unknown
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Expected O, but got Unknown
			//IL_03df: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Expected O, but got Unknown
			GiveKey = cfg.Bind<Key>("GolfCartLauncher", "GiveKey", (Key)0, "Hotkey to give yourself a Golf Cart Launcher (debug/testing).");
			Uses = cfg.Bind<float>("GolfCartLauncher", "Uses", 5f, new ConfigDescription("Number of carts per Golf Cart Launcher pickup. Each shot consumes one use.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 50f), Array.Empty<object>()));
			FireRate = cfg.Bind<float>("GolfCartLauncher", "FireRate", 0.75f, new ConfigDescription("Seconds between successive shots while the fire button is held.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 10f), Array.Empty<object>()));
			LaunchSpeed = cfg.Bind<float>("GolfCartLauncher", "LaunchSpeed", 55f, new ConfigDescription("Speed (metres/second) the launched golf cart is given along the aim direction.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 300f), Array.Empty<object>()));
			Inaccuracy = cfg.Bind<float>("GolfCartLauncher", "Inaccuracy", 3f, new ConfigDescription("Random spread angle (degrees) applied to each launch. Higher = less accurate. 0 is perfectly accurate.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 90f), Array.Empty<object>()));
			MaxAimingDistance = cfg.Bind<float>("GolfCartLauncher", "MaxAimingDistance", 500f, new ConfigDescription("Max distance used when computing the aim point for each shot.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(10f, 2000f), Array.Empty<object>()));
			SpawnForwardOffset = cfg.Bind<float>("GolfCartLauncher", "SpawnForwardOffset", 4f, new ConfigDescription("Distance in front of the player the cart is spawned at. Must clear the player's own collider.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 20f), Array.Empty<object>()));
			SpawnVerticalOffset = cfg.Bind<float>("GolfCartLauncher", "SpawnVerticalOffset", 1.5f, new ConfigDescription("Vertical offset applied to the cart spawn position, relative to the player's feet.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>()));
			SpinPitch = cfg.Bind<float>("GolfCartLauncher", "SpinPitch", 360f, "Rotation speed (degrees/second) of the launched cart about its local right axis (forward tumble). Negative flips the direction.");
			SpinYaw = cfg.Bind<float>("GolfCartLauncher", "SpinYaw", 0f, "Rotation speed (degrees/second) of the launched cart about its local up axis (flat spin).");
			SpinRoll = cfg.Bind<float>("GolfCartLauncher", "SpinRoll", 0f, "Rotation speed (degrees/second) of the launched cart about its local forward axis (barrel roll).");
			Lifetime = cfg.Bind<float>("GolfCartLauncher", "Lifetime", 300f, new ConfigDescription("Seconds a launched cart survives before the server despawns it. 0 disables the timeout (carts persist until the hole ends).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 600f), Array.Empty<object>()));
			ScreenShakeIntensity = cfg.Bind<float>("GolfCartLauncher", "ScreenShakeIntensity", 0.425f, new ConfigDescription("Intensity of the screen shake when firing the Golf Cart Launcher. 0 disables it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 5f), Array.Empty<object>()));
			JoyrideToggleKey = cfg.Bind<Key>("GolfCartLauncher", "JoyrideToggleKey", (Key)36, "Key that toggles Joyride mode, where firing seats you in the launched cart and consumes the whole item. Only selectable while the launcher is at full uses.");
			ShowJoyrideHud = cfg.Bind<bool>("GolfCartLauncher", "ShowJoyrideHud", true, "Show the firing-mode indicator on the HUD while the Golf Cart Launcher is equipped.");
			JoyrideLaunchSpeed = cfg.Bind<float>("GolfCartLauncher", "JoyrideLaunchSpeed", 35f, new ConfigDescription("Speed (metres/second) of a cart launched in Joyride mode. Lower than LaunchSpeed by default, since you are riding it.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 300f), Array.Empty<object>()));
			JoyrideSpinRetention = cfg.Bind<float>("GolfCartLauncher", "JoyrideSpinRetention", 0f, new ConfigDescription("Fraction of the standard spin (SpinPitch/SpinYaw/SpinRoll) applied in Joyride mode. 0 = the cart flies level so the ride stays readable, 1 = the full standard tumble with you aboard.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			SettleDamping = cfg.Bind<float>("GolfCartLauncher", "SettleDamping", 14f, new ConfigDescription("How sharply a launched cart's leftover spin is bled off once it lands. Higher settles faster and more abruptly; 0 disables settling so carts tumble freely.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 40f), Array.Empty<object>()));
			SettleDuration = cfg.Bind<float>("GolfCartLauncher", "SettleDuration", 0.75f, new ConfigDescription("Seconds of ground contact after which a landed cart's remaining spin is zeroed outright.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
			SettleAngularThreshold = cfg.Bind<float>("GolfCartLauncher", "SettleAngularThreshold", 0.35f, new ConfigDescription("Spin (radians/second) below which a landed cart counts as settled. Keeps ordinary driving turns from being damped.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.01f, 5f), Array.Empty<object>()));
		}
	}
	public class GravityGunConfig
	{
		private const string Section = "GravityGun";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> LockOnRange { get; private set; }

		public ConfigEntry<float> LockOnConeAngleDeg { get; private set; }

		public ConfigEntry<float> TetherRadius { get; private set; }

		public ConfigEntry<float> TetherDuration { get; private set; }

		public ConfigEntry<float> SpringForce { get; private set; }

		public ConfigEntry<float> MaxPullSpeed { get; private set; }

		public ConfigEntry<float> InputSendInterval { get; private set; }

		public GravityGunConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("GravityGun", "GiveKey", (Key)78, "Hotkey to give yourself a Gravity Gun (debug/testing).");
			Uses = cfg.Bind<float>("GravityGun", "Uses", 1f, "Number of uses per Gravity Gun pickup.");
			LockOnRange = cfg.Bind<float>("GravityGun", "LockOnRange", 45f, "Maximum distance (units) at which the Gravity Gun can lock onto a target.");
			LockOnConeAngleDeg = cfg.Bind<float>("GravityGun", "LockOnConeAngleDeg", 40f, "Half-angle (degrees) of the aim cone used to filter lock-on candidates.");
			TetherRadius = cfg.Bind<float>("GravityGun", "TetherRadius", 20f, "Distance (units) at which the target orbits the wielder while tethered.");
			TetherDuration = cfg.Bind<float>("GravityGun", "TetherDuration", 5f, "Maximum tether duration in seconds before automatic release.");
			SpringForce = cfg.Bind<float>("GravityGun", "SpringForce", 12f, "Spring stiffness coefficient; higher values pull the target faster.");
			MaxPullSpeed = cfg.Bind<float>("GravityGun", "MaxPullSpeed", 18f, "Maximum velocity change (m/s) applied to the target per physics tick.");
			InputSendInterval = cfg.Bind<float>("GravityGun", "InputSendInterval", 0.05f, "Interval (seconds) between aim-tick messages sent to the server (~20 Hz).");
		}
	}
	public class HarrierConfig
	{
		private const string Section = "HarrierJet";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Altitude { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> FireInterval { get; private set; }

		public ConfigEntry<float> ApproachDistance { get; private set; }

		public ConfigEntry<float> ApproachSpeed { get; private set; }

		public ConfigEntry<float> DriftSpeed { get; private set; }

		public ConfigEntry<float> HoverRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> RocketJitter { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<float> HitsToDestroy { get; private set; }

		public ConfigEntry<float> CrashExplosionScale { get; private set; }

		public HarrierConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("HarrierJet", "GiveKey", (Key)93, "Debug key to add the Harrier Jet to your inventory.");
			Uses = cfg.Bind<float>("HarrierJet", "Uses", 1f, "Number of Harrier Jet uses per pickup.");
			Altitude = cfg.Bind<float>("HarrierJet", "Altitude", 175f, "Height above the map centre the Harrier hovers at while attacking.");
			Duration = cfg.Bind<float>("HarrierJet", "Duration", 30f, "How many seconds the Harrier remains on-station before flying out.");
			FireInterval = cfg.Bind<float>("HarrierJet", "FireInterval", 2.5f, "Seconds between each autonomous rocket fired by the Harrier.");
			ApproachDistance = cfg.Bind<float>("HarrierJet", "ApproachDistance", 600f, "How far away the Harrier spawns before flying in to its hover point.");
			ApproachSpeed = cfg.Bind<float>("HarrierJet", "ApproachSpeed", 100f, "Speed in units per second during fly-in and fly-out.");
			DriftSpeed = cfg.Bind<float>("HarrierJet", "DriftSpeed", 8f, "Units per second the Harrier drifts toward the player concentration centroid.");
			HoverRadius = cfg.Bind<float>("HarrierJet", "HoverRadius", 30f, "Maximum distance the Harrier can drift from its initial hover centre.");
			ExplosionScale = cfg.Bind<float>("HarrierJet", "ExplosionScale", 1.5f, "Scale multiplier applied to each rocket explosion from the Harrier.");
			RocketJitter = cfg.Bind<float>("HarrierJet", "RocketJitter", 4f, "Angular spread in degrees applied to each rocket. Higher = less accurate.");
			FriendlyFire = cfg.Bind<bool>("HarrierJet", "FriendlyFire", false, "If false, the Harrier will not target the player who summoned it.");
			HitsToDestroy = cfg.Bind<float>("HarrierJet", "HitsToDestroy", 3f, "Number of direct rocket hits required to shoot down the Harrier. Set to 0 to make it invincible.");
			CrashExplosionScale = cfg.Bind<float>("HarrierJet", "CrashExplosionScale", 3f, "Scale multiplier for the explosion spawned when the Harrier crashes into the ground.");
		}
	}
	public class HunterDroneConfig
	{
		private const string Section = "HunterDrone";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> LaunchSpeed { get; private set; }

		public ConfigEntry<float> Acceleration { get; private set; }

		public ConfigEntry<float> HomingStopDistance { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> ArmDelay { get; private set; }

		public ConfigEntry<float> ThrowerIgnoreDuration { get; private set; }

		public ConfigEntry<bool> FriendlyFire { get; private set; }

		public ConfigEntry<bool> AttackFinishedPlayers { get; private set; }

		public ConfigEntry<float> MaxFlightDistance { get; private set; }

		public ConfigEntry<float> MaxSpeed { get; private set; }

		public ConfigEntry<float> MaxActiveDrones { get; private set; }

		public ConfigEntry<float> MaxAimAngle { get; private set; }

		public ConfigEntry<float> MaxTargetDistance { get; private set; }

		public HunterDroneConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("HunterDrone", "GiveKey", (Key)80, "Debug key to add the Hunter Drone item to your inventory.");
			Uses = cfg.Bind<float>("HunterDrone", "Uses", 1f, "Number of uses per Hunter Drone pickup.");
			LaunchSpeed = cfg.Bind<float>("HunterDrone", "LaunchSpeed", 90f, "Initial flight speed of the drone in metres per second.");
			Acceleration = cfg.Bind<float>("HunterDrone", "Acceleration", 25f, "How many metres per second the drone's speed increases each second.");
			HomingStopDistance = cfg.Bind<float>("HunterDrone", "HomingStopDistance", 10f, "Distance from the target (metres) at which the drone locks its aim point and flies straight, giving the target a brief chance to dodge. Set to 0 to always track the target.");
			ArrivalRadius = cfg.Bind<float>("HunterDrone", "ArrivalRadius", 0.5f, "Distance from the aim point (metres) at which the drone detonates.");
			ExplosionScale = cfg.Bind<float>("HunterDrone", "ExplosionScale", 1.2f, "Scale multiplier for the drone impact explosion radius and force.");
			ArmDelay = cfg.Bind<float>("HunterDrone", "ArmDelay", 0f, "Seconds after launch before the drone starts checking for collision. Prevents the drone from detonating on the thrower immediately after being thrown.");
			ThrowerIgnoreDuration = cfg.Bind<float>("HunterDrone", "ThrowerIgnoreDuration", 1.5f, "Seconds after launch during which the drone cannot detonate on the player who threw it. Prevents the drone exploding inside its owner when thrown while running or jumping forward. Unlike ArmDelay, the drone still detonates normally on terrain and other players during this window, and the grace period ends early once the drone is clear of the thrower.");
			FriendlyFire = cfg.Bind<bool>("HunterDrone", "FriendlyFire", false, "If true, the drone may target the player who threw it.");
			AttackFinishedPlayers = cfg.Bind<bool>("HunterDrone", "AttackFinishedPlayers", false, "If true, the drone may target players who have already holed out.");
			MaxFlightDistance = cfg.Bind<float>("HunterDrone", "MaxFlightDistance", 500f, "Maximum distance in metres the drone may travel before self-detonating. Acts as a safety valve when no target exists or the drone misses.");
			MaxSpeed = cfg.Bind<float>("HunterDrone", "MaxSpeed", 300f, "Maximum flight speed in metres per second. Caps the speed gained through Acceleration so the drone cannot tunnel through targets at extreme velocity.");
			MaxActiveDrones = cfg.Bind<float>("HunterDrone", "MaxActiveDrones", 5f, "Maximum number of hunter drones a single player may have in flight at once.");
			MaxAimAngle = cfg.Bind<float>("HunterDrone", "MaxAimAngle", 20f, "Maximum angle in degrees between where the player is aiming and a player, for that player to be considered a target. If nobody is within this cone, the drone is not thrown and the item is not consumed.");
			MaxTargetDistance = cfg.Bind<float>("HunterDrone", "MaxTargetDistance", 500f, "Maximum distance in metres a player may be from the thrower and still be targetable by the Hunter Drone.");
		}
	}
	public class JavelinConfig
	{
		private const string Section = "Javelin";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ApexHeight { get; private set; }

		public ConfigEntry<float> AscentSpeed { get; private set; }

		public ConfigEntry<float> DiveSpeed { get; private set; }

		public ConfigEntry<float> DiveAcceleration { get; private set; }

		public ConfigEntry<float> ArrivalRadius { get; private set; }

		public ConfigEntry<float> Timeout { get; private set; }

		public ConfigEntry<float> ExplosionVfxDuration { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public JavelinConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Javelin", "GiveKey", (Key)87, "Debug key to add the Javelin to your inventory.");
			Uses = cfg.Bind<float>("Javelin", "Uses", 1f, "Number of Javelin uses per pickup.");
			ApexHeight = cfg.Bind<float>("Javelin", "ApexHeight", 80f, "How many units above the launch point the rocket climbs before turning.");
			AscentSpeed = cfg.Bind<float>("Javelin", "AscentSpeed", 35f, "Speed in units per second during the upward climb phase.");
			DiveSpeed = cfg.Bind<float>("Javelin", "DiveSpeed", 55f, "Initial speed in units per second when the rocket begins its dive.");
			DiveAcceleration = cfg.Bind<float>("Javelin", "DiveAcceleration", 25f, "Additional speed gained per second during the dive phase.");
			ArrivalRadius = cfg.Bind<float>("Javelin", "ArrivalRadius", 3f, "Distance from the target position at which the rocket detonates.");
			Timeout = cfg.Bind<float>("Javelin", "Timeout", 20f, "Maximum seconds before the rocket force-detonates if it hasn't hit yet.");
			ExplosionVfxDuration = cfg.Bind<float>("Javelin", "ExplosionVfxDuration", 5f, "Seconds before the Javelin explosion VFX prefab is destroyed on each client.");
			ExplosionScale = cfg.Bind<float>("Explosions", "JavelinScale", 3.5f, "Multiplier for Javelin explosions. Affects blast radius, knockback, and VFX size.");
		}
	}
	public class JetpackConfig
	{
		private const string Section = "Jetpack";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> FuelPerUse { get; private set; }

		public ConfigEntry<float> ThrustForce { get; private set; }

		public ConfigEntry<bool> UseJumpToActivate { get; private set; }

		public JetpackConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Jetpack", "GiveKey", (Key)69, "Hotkey to give yourself a Jetpack (debug/testing).");
			Uses = cfg.Bind<float>("Jetpack", "Uses", 1f, "Number of fuel canisters per Jetpack pickup. Each canister provides JetpackFuelPerUse seconds of thrust.");
			FuelPerUse = cfg.Bind<float>("Jetpack", "FuelPerUse", 1f, "Seconds of thrust provided by each fuel canister. When exhausted, one use is consumed.");
			ThrustForce = cfg.Bind<float>("Jetpack", "ThrustForce", 35f, "Upward acceleration (m/s²) applied each physics step while thrusting. Uses ForceMode.Acceleration.");
			UseJumpToActivate = cfg.Bind<bool>("Jetpack", "UseJumpToActivate", true, "When enabled, pressing Space (Jump) activates the jetpack even if it is not the active item. The fuel gauge is visible whenever the jetpack is in inventory.");
		}
	}
	public class LowGravityConfig
	{
		private const string Section = "LowGravity";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<float> Scale { get; private set; }

		public LowGravityConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("LowGravity", "GiveKey", (Key)84, "Debug key to add the Low Gravity item to your inventory.");
			Uses = cfg.Bind<float>("LowGravity", "Uses", 1f, "Number of uses per Low Gravity pickup.");
			Duration = cfg.Bind<float>("LowGravity", "Duration", 20f, "Seconds the reduced gravity lasts before physics is restored.");
			Scale = cfg.Bind<float>("LowGravity", "GravityScale", 0.25f, "Fraction of normal gravity applied during the effect (e.g. 0.25 = 25%). Affects golf balls (Rigidbody) and player fall/jump height equally, since PlayerMovement reads Physics.gravity directly.");
		}
	}
	public static class ModConfig
	{
		public static GlobalConfig Global { get; private set; }

		public static BaseballBatConfig BaseballBat { get; private set; }

		public static StealthBomberConfig StealthBomber { get; private set; }

		public static PredatorMissileConfig PredatorMissile { get; private set; }

		public static AC130Config AC130 { get; private set; }

		public static FreezeConfig Freeze { get; private set; }

		public static LowGravityConfig LowGravity { get; private set; }

		public static SniperRifleConfig SniperRifle { get; private set; }

		public static DonutConfig Donut { get; private set; }

		public static JavelinConfig Javelin { get; private set; }

		public static StickyGrenadeConfig StickyGrenade { get; private set; }

		public static BearConfig Bear { get; private set; }

		public static NukeConfig Nuke { get; private set; }

		public static BlackHoleGrenadeConfig BlackHoleGrenade { get; private set; }

		public static PlaceableWallConfig PlaceableWall { get; private set; }

		public static AK47Config AK47 { get; private set; }

		public static HarrierConfig Harrier { get; private set; }

		public static PositionSwapConfig PositionSwap { get; private set; }

		public static PoisonJarConfig PoisonJar { get; private set; }

		public static DroneSwarmConfig DroneSwarm { get; private set; }

		public static RedBullConfig RedBull { get; private set; }

		public static SuperDonutConfig SuperDonut { get; private set; }

		public static GravityGunConfig GravityGun { get; private set; }

		public static RocketTetherConfig RocketTether { get; private set; }

		public static JetpackConfig Jetpack { get; private set; }

		public static TeleporterConfig Teleporter { get; private set; }

		public static SpinachConfig Spinach { get; private set; }

		public static SuperJumboBurgerConfig SuperJumboBurger { get; private set; }

		public static FlamethrowerConfig Flamethrower { get; private set; }

		public static RocketTetherGrenadeConfig RocketTetherGrenade { get; private set; }

		public static WindStormConfig WindStorm { get; private set; }

		public static HunterDroneConfig HunterDrone { get; private set; }

		public static UfoAbductionConfig UfoAbduction { get; private set; }

		public static MoonConfig Moon { get; private set; }

		public static ShapeShifterConfig ShapeShifter { get; private set; }

		public static SuperShapeShifterConfig SuperShapeShifter { get; private set; }

		public static ExplosiveGolfBallsConfig ExplosiveGolfBalls { get; private set; }

		public static GolfCartLauncherConfig GolfCartLauncher { get; private set; }

		public static void Initialize(ConfigFile cfg)
		{
			Global = new GlobalConfig(cfg);
			BaseballBat = new BaseballBatConfig(cfg, Global);
			StealthBomber = new StealthBomberConfig(cfg, Global);
			PredatorMissile = new PredatorMissileConfig(cfg, Global);
			AC130 = new AC130Config(cfg, Global);
			Freeze = new FreezeConfig(cfg, Global);
			LowGravity = new LowGravityConfig(cfg, Global);
			SniperRifle = new SniperRifleConfig(cfg, Global);
			Donut = new DonutConfig(cfg, Global);
			Javelin = new JavelinConfig(cfg, Global);
			StickyGrenade = new StickyGrenadeConfig(cfg, Global);
			Bear = new BearConfig(cfg, Global);
			Nuke = new NukeConfig(cfg, Global);
			BlackHoleGrenade = new BlackHoleGrenadeConfig(cfg, Global);
			PlaceableWall = new PlaceableWallConfig(cfg, Global);
			AK47 = new AK47Config(cfg, Global);
			Harrier = new HarrierConfig(cfg, Global);
			PositionSwap = new PositionSwapConfig(cfg, Global);
			PoisonJar = new PoisonJarConfig(cfg, Global);
			DroneSwarm = new DroneSwarmConfig(cfg, Global);
			RedBull = new RedBullConfig(cfg, Global);
			SuperDonut = new SuperDonutConfig(cfg, Global);
			GravityGun = new GravityGunConfig(cfg, Global);
			RocketTether = new RocketTetherConfig(cfg, Global);
			Jetpack = new JetpackConfig(cfg, Global);
			Teleporter = new TeleporterConfig(cfg, Global);
			Spinach = new SpinachConfig(cfg, Global);
			SuperJumboBurger = new SuperJumboBurgerConfig(cfg, Global);
			Flamethrower = new FlamethrowerConfig(cfg, Global);
			RocketTetherGrenade = new RocketTetherGrenadeConfig(cfg, Global);
			WindStorm = new WindStormConfig(cfg, Global);
			HunterDrone = new HunterDroneConfig(cfg, Global);
			UfoAbduction = new UfoAbductionConfig(cfg, Global);
			Moon = new MoonConfig(cfg, Global);
			ShapeShifter = new ShapeShifterConfig(cfg, Global);
			SuperShapeShifter = new SuperShapeShifterConfig(cfg, Global);
			ExplosiveGolfBalls = new ExplosiveGolfBallsConfig(cfg, Global);
			GolfCartLauncher = new GolfCartLauncherConfig(cfg, Global);
		}

		public static bool GetItemEnabled(ItemType itemType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemEnabled(itemType);
		}

		public static void SetItemEnabled(ItemType itemType, bool enabled)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Global.SetItemEnabled(itemType, enabled);
		}

		public static float GetItemPoolWeight(ItemType t, int pool)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemPoolWeight(t, pool);
		}

		public static void SetItemPoolWeight(ItemType t, int pool, float v)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Global.SetItemPoolWeight(t, pool, v);
		}

		public static bool GetItemWarningEnabled(ItemType itemType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return Global.GetItemWarningEnabled(itemType);
		}
	}
	public class MoonConfig
	{
		private const string Section = "Moon";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ApproachDuration { get; private set; }

		public ConfigEntry<float> SpawnDistance { get; private set; }

		public ConfigEntry<float> SpawnHeight { get; private set; }

		public ConfigEntry<float> ImpactHeight { get; private set; }

		public ConfigEntry<float> SuckDuration { get; private set; }

		public ConfigEntry<float> PullForce { get; private set; }

		public ConfigEntry<float> MaxPullSpeed { get; private set; }

		public ConfigEntry<float> PullRadius { get; private set; }

		public ConfigEntry<bool> PullAffectsGolfBalls { get; private set; }

		public ConfigEntry<bool> PullAffectsWielder { get; private set; }

		public ConfigEntry<float> ExplosionForce { get; private set; }

		public ConfigEntry<float> ExplosionRadius { get; private set; }

		public ConfigEntry<float> InitialScale { get; private set; }

		public ConfigEntry<float> FinalScale { get; private set; }

		public ConfigEntry<float> FlyAwayDuration { get; private set; }

		public ConfigEntry<bool> DuskEnabled { get; private set; }

		public ConfigEntry<float> DuskFadeDuration { get; private set; }

		public MoonConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Moon", "GiveKey", (Key)0, "Hotkey to give yourself a Majora's Moon (debug/testing).");
			Uses = cfg.Bind<float>("Moon", "Uses", 1f, "Number of uses per Moon pickup.");
			ApproachDuration = cfg.Bind<float>("Moon", "ApproachDuration", 30f, "Seconds for the moon to travel from spawn to above the course.");
			SpawnDistance = cfg.Bind<float>("Moon", "SpawnDistance", 300f, "Horizontal distance (units) from the hole at which the moon spawns.");
			SpawnHeight = cfg.Bind<float>("Moon", "SpawnHeight", 1025f, "Height (units) above ground at which the moon spawns.");
			ImpactHeight = cfg.Bind<float>("Moon", "ImpactHeight", 350f, "Height (units) above the hole where the moon stops before pulling players in.");
			SuckDuration = cfg.Bind<float>("Moon", "SuckDuration", 8f, "Seconds the moon hovers at impact height while pulling all players upward.");
			PullForce = cfg.Bind<float>("Moon", "PullForce", 550f, "Peak upward pull force (m/s²) applied to the local player during the suck phase.");
			MaxPullSpeed = cfg.Bind<float>("Moon", "MaxPullSpeed", 999f, "Maximum velocity (m/s) toward the moon allowed during the suck phase.");
			PullRadius = cfg.Bind<float>("Moon", "PullRadius", 999f, "Distance (units) at which pull force begins to fall off quadratically.");
			ExplosionForce = cfg.Bind<float>("Moon", "ExplosionForce", 999f, "Peak velocity change (m/s) applied to non-player Rigidbodies at the moon's impact point.");
			ExplosionRadius = cfg.Bind<float>("Moon", "ExplosionRadius", 250f, "Radius (units) within which the explosion force affects nearby Rigidbodies.");
			PullAffectsGolfBalls = cfg.Bind<bool>("Moon", "PullAffectsGolfBalls", false, "If true, the moon's suck phase pulls nearby golf balls toward it.");
			PullAffectsWielder = cfg.Bind<bool>("Moon", "PullAffectsWielder", false, "If true, the player who used the Moon item is also pulled toward it.");
			InitialScale = cfg.Bind<float>("Moon", "InitialScale", 0.01f, "Initial scale of the moon.");
			FinalScale = cfg.Bind<float>("Moon", "FinalScale", 3f, "Final scale of the moon.");
			FlyAwayDuration = cfg.Bind<float>("Moon", "FlyAwayDuration", 5f, "Seconds the moon takes to fly back to its spawn point after the session ends. Set to 0 to destroy it instantly.");
			DuskEnabled = cfg.Bind<bool>("Moon", "DuskEnabled", true, "If true, the sky shifts to a dusk palette while the moon is active.");
			DuskFadeDuration = cfg.Bind<float>("Moon", "DuskFadeDuration", 3f, "Seconds to fade the sky in/out when the moon session begins or ends.");
		}
	}
	public class NukeConfig
	{
		private const string Section = "Nuke";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> DropHeight { get; private set; }

		public ConfigEntry<float> DropSpeed { get; private set; }

		public ConfigEntry<float> ExplosionScale { get; private set; }

		public ConfigEntry<float> SkyBlastForce { get; private set; }

		public ConfigEntry<float> SkyBlastRadius { get; private set; }

		public ConfigEntry<float> SkyBlastVerticalBias { get; private set; }

		public ConfigEntry<float> ExplosionVfxDuration { get; private set; }

		public ConfigEntry<float> ExplosionVfxScale { get; private set; }

		public ConfigEntry<bool> ExcludeThrower { get; private set; }

		public NukeConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("Nuke", "GiveKey", (Key)90, "Debug key to add the Nuke to your inventory.");
			Uses = cfg.Bind<float>("Nuke", "Uses", 1f, "Number of uses per Nuke pickup.");
			DropHeight = cfg.Bind<float>("Nuke", "DropHeight", 300f, "Units above the map centre at which the nuke bomb spawns.");
			DropSpeed = cfg.Bind<float>("Nuke", "DropSpeed", 80f, "Downward speed of the falling nuke bomb in units per second.");
			SkyBlastForce = cfg.Bind<float>("Nuke", "SkyBlastForce", 350f, "Extra upward impulse force applied to all rigidbodies within SkyBlastRadius after detonation. Stacks on top of the standard explosion knockback.");
			SkyBlastRadius = cfg.Bind<float>("Nuke", "SkyBlastRadius", 350f, "Radius (units) of the secondary sky blast. Should be large enough to cover the whole map so no one escapes.");
			SkyBlastVerticalBias = cfg.Bind<float>("Nuke", "SkyBlastVerticalBias", 0.7f, "Controls how much of the sky blast force goes upward versus outward (0 = all outward, 1 = all straight up). The horizontal direction is still relative to the explosion point, so players are pushed away from the blast site.");
			ExplosionVfxDuration = cfg.Bind<float>("Nuke", "ExplosionVfxDuration", 8f, "Seconds before the nuke explosion VFX prefab is destroyed on each client.");
			ExplosionVfxScale = cfg.Bind<float>("Nuke", "ExplosionVfxScale", 5f, "Uniform scale applied to the nuke explosion VFX transform on each client. Increase this to make the particle systems appear larger.");
			ExcludeThrower = cfg.Bind<bool>("Nuke", "ExcludeThrower", true, "If true, the sky blast does not apply force to the player who activated the nuke.");
			ExplosionScale = cfg.Bind<float>("Explosions", "NukeScale", 6f, "Explosion scale multiplier for the Nuke's detonation rocket. Affects blast radius, knockback force, and VFX size.");
		}
	}
	public class PlaceableWallConfig
	{
		private const string Section = "PlaceableWall";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> MaxPlacementDistance { get; private set; }

		public ConfigEntry<float> MinHoleDistance { get; private set; }

		public ConfigEntry<float> HealthPoints { get; private set; }

		public ConfigEntry<float> VelocityImpactFactor { get; private set; }

		public ConfigEntry<float> TorsionMultiplier { get; private set; }

		public ConfigEntry<float> RotationStep { get; private set; }

		public ConfigEntry<float> DebrisLifetime { get; private set; }

		public ConfigEntry<float> RocketExplosionForce { get; private set; }

		public ConfigEntry<float> DamageGolfClub { get; private set; }

		public ConfigEntry<float> DamageBaseballBat { get; private set; }

		public PlaceableWallConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("PlaceableWall", "GiveKey", (Key)92, "Debug key to add the Placeable Wall to your inventory.");
			Uses = cfg.Bind<float>("PlaceableWall", "Uses", 1f, "Number of wall placements per pickup.");
			MaxPlacementDistance = cfg.Bind<float>("PlaceableWall", "MaxPlacementDistance", 20f, "Maximum distance (units) from the player's camera at which a wall can be placed.");
			MinHoleDistance = cfg.Bind<float>("PlaceableWall", "MinHoleDistance", 3f, "Minimum XZ distance (units) from the hole centre that a wall may be placed. Prevents blocking the hole entirely. Set to 0 to disable the check.");
			HealthPoints = cfg.Bind<float>("PlaceableWall", "HealthPoints", 3f, "Number of golf club or baseball bat hits required to destroy the wall. Rocket hits always destroy in one shot.");
			VelocityImpactFactor = cfg.Bind<float>("PlaceableWall", "VelocityImpactFactor", 2.5f, "Degree to which the velocity of an object colliding with the placeable wall will damage it. Default: 2.5.");
			TorsionMultiplier = cfg.Bind<float>("PlaceableWall", "TorsionMultiplier", 0.002f, "Degree to which torque (spin) damages the bricks of the placeable wall. Default: 0.002.");
			RotationStep = cfg.Bind<float>("PlaceableWall", "RotationStep", 45f, "Degrees the wall rotates per scroll-wheel tick during the placement preview. Scroll up rotates clockwise, scroll down rotates counter-clockwise.");
			DebrisLifetime = cfg.Bind<float>("PlaceableWall", "DebrisLifetime", 30f, "Seconds before detached wall debris (bricks/pillars) are automatically destroyed.");
			RocketExplosionForce = cfg.Bind<float>("PlaceableWall", "RocketExplosionForce", 600f, "Impulse force (per brick) applied by a rocket explosion to detached wall debris.");
			DamageGolfClub = cfg.Bind<float>("PlaceableWall", "DamageGolfClub", 1f, "Damage dealt to a wall chunk per golf club swing.");
			DamageBaseballBat = cfg.Bind<float>("PlaceableWall", "DamageBaseballBat", 2f, "Damage dealt to a wall chunk per baseball bat swing.");
		}
	}
	public class PoisonJarConfig
	{
		private const string JarSection = "PoisonJar";

		private const string OverlaySection = "PoisonOverlay";

		public ConfigEntry<Key> GiveKey { get; private set; }

		public ConfigEntry<float> Uses { get; private set; }

		public ConfigEntry<float> ThrowSpeed { get; private set; }

		public ConfigEntry<float> LobAngle { get; private set; }

		public ConfigEntry<float> Radius { get; private set; }

		public ConfigEntry<float> Duration { get; private set; }

		public ConfigEntry<bool> GhostEnabled { get; private set; }

		public ConfigEntry<float> GhostOffsetX { get; private set; }

		public ConfigEntry<float> GhostOffsetY { get; private set; }

		public ConfigEntry<float> GhostAlpha { get; private set; }

		public ConfigEntry<float> RollFreq1 { get; private set; }

		public ConfigEntry<float> RollAmp1 { get; private set; }

		public ConfigEntry<float> RollFreq2 { get; private set; }

		public ConfigEntry<float> RollAmp2 { get; private set; }

		public ConfigEntry<float> RollFreq3 { get; private set; }

		public ConfigEntry<float> RollAmp3 { get; private set; }

		public ConfigEntry<float> FovFreq1 { get; private set; }

		public ConfigEntry<float> FovAmp1 { get; private set; }

		public ConfigEntry<float> FovFreq2 { get; private set; }

		public ConfigEntry<float> FovAmp2 { get; private set; }

		public ConfigEntry<float> VigPulseFreq1 { get; private set; }

		public ConfigEntry<float> VigPulseFreq2 { get; private set; }

		public ConfigEntry<float> VigBaseAlpha { get; private set; }

		public ConfigEntry<float> VigPulseAmp1 { get; private set; }

		public ConfigEntry<float> VigPulseAmp2 { get; private set; }

		public ConfigEntry<float> TintBaseAlpha { get; private set; }

		public ConfigEntry<float> TintPulseAmp { get; private set; }

		public ConfigEntry<float> TintPulseFreq { get; private set; }

		public ConfigEntry<bool> AimNoiseEnabled { get; private set; }

		public ConfigEntry<float> AimNoiseYawAmp { get; private set; }

		public ConfigEntry<float> AimNoiseYawFreq { get; private set; }

		public ConfigEntry<float> AimNoisePitchAmp { get; private set; }

		public ConfigEntry<float> AimNoisePitchFreq { get; private set; }

		public PoisonJarConfig(ConfigFile cfg, GlobalConfig global)
		{
			GiveKey = cfg.Bind<Key>("PoisonJar", "GiveKey", (Key)82, "Debug key to add the Poison Jar to your inventory.");
			Uses = cfg.Bind<float>("PoisonJar", "Uses", 1f, "Number of uses per Poison Jar pickup.");
			ThrowSpeed = cfg.Bind<float>("PoisonJar", "ThrowSpeed", 18f, "Initial throw speed in metres per second.");
			LobAngle = cfg.Bind<float>("PoisonJar", "LobAngle", 0.35f, "Upward component added to the throw direction (0 = flat, 1 = 45° up).");
			Radius = cfg.Bind<float>("PoisonJar", "Radius", 2f, "Radius in metres of the poison AoE. Also scales the splash VFX.");
			Duration = cfg.Bind<float>("PoisonJar", "Duration", 10f, "How long (seconds) the poison visual lasts on affected players.");
			GhostEnabled = cfg.Bind<bool>("PoisonOverlay", "GhostEnabled", true, "Enable the double-vision ghost image.");
			GhostOffsetX = cfg.Bind<float>("PoisonOverlay", "GhostOffsetX", 0.04f, "Horizontal ghost offset as a fraction of screen width (e.g. 0.04 = 4%).");
			GhostOffsetY = cfg.Bind<float>("PoisonOverlay", "GhostOffsetY", 0.01f, "Vertical ghost offset as a fraction of screen height.");
			GhostAlpha = cfg.Bind<float>("PoisonOverlay", "GhostAlpha", 0.35f, "Opacity of the ghost image (0–1).");
			RollFreq1 = cfg.Bind<float>("PoisonOverlay", "RollFreq1", 1f, "Primary lean frequency (Hz).");
			RollAmp1 = cfg.Bind<float>("PoisonOverlay", "RollAmp1", 4.5f, "Primary lean amplitude (degrees).");
			RollFreq2 = cfg.Bind<float>("PoisonOverlay", "RollFreq2", 0.28f, "Slow drift frequency (Hz).");
			RollAmp2 = cfg.Bind<float>("PoisonOverlay", "RollAmp2", 12f, "Slow drift amplitude (degrees).");
			RollFreq3 = cfg.Bind<float>("PoisonOverlay", "RollFreq3", 1.35f, "Subtle tremor frequency (Hz).");
			RollAmp3 = cfg.Bind<float>("PoisonOverlay", "RollAmp3", 5f, "Subtle tremor amplitude (degrees).");
			FovFreq1 = cfg.Bind<float>("PoisonOverlay", "FovFreq1", 0.5f, "Primary FOV breathing frequency (Hz).");
			FovAmp1 = cfg.Bind<float>("PoisonOverlay", "FovAmp1", 5f, "Primary FOV breathing amplitude (degrees).");
			FovFreq2 = cfg.Bind<float>("PoisonOverlay", "FovFreq2", 1.2f, "Secondary FOV breathing frequency (Hz).");
			FovAmp2 = cfg.Bind<float>("PoisonOverlay", "FovAmp2", 8f, "Secondary FOV breathing amplitude (degrees).");
			VigPulseFreq1 = cfg.Bind<float>("PoisonOver