using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using DropProne;
using DropProne.Config;
using DropProne.Menu;
using DropProne.Patches;
using DropProne.Prone;
using HarmonyLib;
using Il2CppSLZ.Marrow;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("DropProne")]
[assembly: AssemblyDescription("Go prone in BONELAB. Crawl, take cover, stay flat.")]
[assembly: AssemblyCompany(null)]
[assembly: AssemblyProduct("DropProne")]
[assembly: AssemblyFileVersion("1.1.0")]
[assembly: MelonInfo(typeof(DropProneMod), "DropProne", "1.1.0", "Rocner", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: MelonColor(255, 90, 150, 90)]
[assembly: MelonAuthorColor(255, 120, 200, 255)]
[assembly: MelonAdditionalDependencies(new string[] { "BoneLib" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("1.1.0.0")]
[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 DropProne
{
public sealed class DropProneMod : MelonMod
{
private static bool _levelReady;
public override void OnInitializeMelon()
{
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
Step("preferences", Prefs.Load);
Step("patches", delegate
{
RigPatches.Apply(((MelonBase)this).HarmonyInstance);
});
Step("menu", MenuPage.Build);
Step("level loaded hook", delegate
{
Hooking.OnLevelLoaded += OnLevelLoaded;
});
Step("level unloaded hook", delegate
{
Hooking.OnLevelUnloaded += OnLevelUnloaded;
});
((MelonBase)this).LoggerInstance.Msg("DropProne ready. Binding: " + Prefs.Bind.ToString() + ", key: " + ((object)Prefs.Key/*cast due to .constrained prefix*/).ToString() + ".");
}
private void Step(string name, Action action)
{
try
{
action();
}
catch (Exception ex)
{
((MelonBase)this).LoggerInstance.Error("Init step '" + name + "' failed: " + ex);
}
}
private static void OnLevelLoaded(LevelInfo info)
{
ProneDriver.ForceReset(rigIsAlive: false);
RigBinding.Forget();
ProneInput.Forget();
Diagnostics.Stop();
_levelReady = true;
}
private static void OnLevelUnloaded()
{
_levelReady = false;
ProneDriver.ForceReset(rigIsAlive: false);
RigBinding.Forget();
ProneInput.Forget();
Diagnostics.Stop();
}
public override void OnUpdate()
{
try
{
Run(Time.deltaTime);
}
catch (Exception ex)
{
((MelonBase)this).LoggerInstance.Error("Update failed: " + ex);
ProneDriver.ForceReset(rigIsAlive: true);
}
}
private void Run(float dt)
{
if (!(dt <= 0f) && _levelReady && RigBinding.Bind(dt))
{
Diagnostics.Tick(dt);
ProneInput.Tick(dt);
if (Prefs.Enabled)
{
Drive();
}
ProneDriver.Tick(dt);
if (RigPatches.Applied == 0)
{
ProneDriver.InjectCrouchInput();
}
if (!RigPatches.CrouchHoldPatched)
{
ProneDriver.DriveOffsets();
}
}
}
private void Drive()
{
if (Prefs.HoldMode)
{
if (ProneInput.Held)
{
ProneDriver.TryEngage("hold");
}
else
{
ProneDriver.Release("released");
}
}
else if (ProneInput.Pressed)
{
ProneDriver.Toggle("input");
}
}
public override void OnDeinitializeMelon()
{
try
{
Hooking.OnLevelLoaded -= OnLevelLoaded;
}
catch
{
}
try
{
Hooking.OnLevelUnloaded -= OnLevelUnloaded;
}
catch
{
}
try
{
ProneDriver.ForceReset(rigIsAlive: true);
}
catch
{
}
try
{
RigBinding.Forget();
}
catch
{
}
try
{
Prefs.Save();
}
catch
{
}
}
}
internal static class BuildInfo
{
public const string Name = "DropProne";
public const string Description = "Go prone in BONELAB. Crawl, take cover, stay flat.";
public const string Author = "Rocner";
public const string Company = null;
public const string Version = "1.1.0";
}
}
namespace DropProne.Prone
{
internal static class CrouchLimits
{
private static bool _captured;
private static SoftJointLimit _linearLimit;
private static SoftJointLimitSpring _linearSpring;
private static Vector3 _targetPosition;
private static JointDrive _yDrive;
private static float _colliderHeight;
private static Vector3 _colliderCenter;
public static bool Applied { get; private set; }
public static bool Captured => _captured;
public static float BaseLimit
{
get
{
if (!_captured)
{
return -1f;
}
return ((SoftJointLimit)(ref _linearLimit)).limit;
}
}
public static void HoldExtended(float bonus)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
PhysicsRig physics = RigBinding.Physics;
if ((Object)(object)physics == (Object)null || bonus <= 0f || !Capture(physics))
{
return;
}
try
{
ConfigurableJoint kneePelvisJoint = physics.kneePelvisJoint;
if (!((Object)(object)kneePelvisJoint == (Object)null))
{
SoftJointLimit linearLimit = _linearLimit;
((SoftJointLimit)(ref linearLimit)).limit = ((SoftJointLimit)(ref _linearLimit)).limit + bonus;
kneePelvisJoint.linearLimit = linearLimit;
Applied = true;
}
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("Extending the knee joint failed: " + ex);
Restore();
}
}
public static void ApplySetLimit(float minMeters, float maxMeters)
{
PhysicsRig physics = RigBinding.Physics;
if ((Object)(object)physics == (Object)null || !Capture(physics))
{
return;
}
try
{
physics.SetKneePelvisLimit(minMeters, maxMeters);
Applied = true;
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("SetKneePelvisLimit failed: " + ex);
Restore();
}
}
public static void Restore()
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
if (!Applied && !_captured)
{
return;
}
PhysicsRig physics = RigBinding.Physics;
if ((Object)(object)physics != (Object)null)
{
try
{
ConfigurableJoint kneePelvisJoint = physics.kneePelvisJoint;
if ((Object)(object)kneePelvisJoint != (Object)null)
{
kneePelvisJoint.linearLimit = _linearLimit;
kneePelvisJoint.linearLimitSpring = _linearSpring;
kneePelvisJoint.targetPosition = _targetPosition;
kneePelvisJoint.yDrive = _yDrive;
}
CapsuleCollider kneePelvisCol = physics.kneePelvisCol;
if ((Object)(object)kneePelvisCol != (Object)null)
{
kneePelvisCol.height = _colliderHeight;
kneePelvisCol.center = _colliderCenter;
}
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("Restoring crouch limits failed: " + ex);
}
}
Applied = false;
_captured = false;
}
public static void Forget()
{
Applied = false;
_captured = false;
}
public static string Describe()
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
PhysicsRig physics = RigBinding.Physics;
if ((Object)(object)physics == (Object)null)
{
return "no physics rig";
}
try
{
ConfigurableJoint kneePelvisJoint = physics.kneePelvisJoint;
CapsuleCollider kneePelvisCol = physics.kneePelvisCol;
object obj;
if (!((Object)(object)kneePelvisJoint != (Object)null))
{
obj = "n/a";
}
else
{
SoftJointLimit linearLimit = kneePelvisJoint.linearLimit;
obj = ((SoftJointLimit)(ref linearLimit)).limit.ToString("0.000");
}
string value = (string)obj;
object obj2;
if (!((Object)(object)kneePelvisJoint != (Object)null))
{
obj2 = "n/a";
}
else
{
Vector3 targetPosition = kneePelvisJoint.targetPosition;
obj2 = ((Vector3)(ref targetPosition)).ToString("F3");
}
string value2 = (string)obj2;
string value3 = (((Object)(object)kneePelvisCol != (Object)null) ? kneePelvisCol.height.ToString("0.000") : "n/a");
string value4 = (_captured ? ((SoftJointLimit)(ref _linearLimit)).limit.ToString("0.000") : "not captured");
return $"linearLimit={value} (stock {value4}) targetPosition={value2} capsuleHeight={value3}";
}
catch (Exception ex)
{
return "unreadable (" + ex.Message + ")";
}
}
private static bool Capture(PhysicsRig rig)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
if (_captured)
{
return true;
}
try
{
ConfigurableJoint kneePelvisJoint = rig.kneePelvisJoint;
if ((Object)(object)kneePelvisJoint != (Object)null)
{
_linearLimit = kneePelvisJoint.linearLimit;
_linearSpring = kneePelvisJoint.linearLimitSpring;
_targetPosition = kneePelvisJoint.targetPosition;
_yDrive = kneePelvisJoint.yDrive;
}
CapsuleCollider kneePelvisCol = rig.kneePelvisCol;
if ((Object)(object)kneePelvisCol != (Object)null)
{
_colliderHeight = kneePelvisCol.height;
_colliderCenter = kneePelvisCol.center;
}
_captured = true;
return true;
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("Reading crouch limits failed, leaving them alone: " + ex);
return false;
}
}
}
internal static class Diagnostics
{
private const float MinUsefulTravel = 0.15f;
private static float _watch;
private static readonly bool[] _lastLeft = new bool[4];
private static readonly bool[] _lastRight = new bool[4];
private static readonly string[] ButtonNames = new string[4] { "Thumbstick", "A", "B", "Menu" };
private static float _calibrate;
private static bool _seeded;
private static float _heightLow;
private static float _heightHigh;
private static float _crouchAtLow;
private static float _crouchAtHigh;
private static float _offsetAtLow;
private static float _offsetAtHigh;
private static float _targetAtLow;
private static float _targetAtHigh;
public static bool Watching => _watch > 0f;
public static bool Calibrating => _calibrate > 0f;
public static bool HasSuggestion { get; private set; }
public static float SuggestedCrouchDrive { get; private set; }
public static float SuggestedFeetOffset { get; private set; }
public static void Report()
{
//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_0337: Unknown result type (might be due to invalid IL or missing references)
Instance logger = Melon<DropProneMod>.Logger;
logger.Msg("---- DropProne rig report ----");
logger.Msg($"prone: engaged={ProneDriver.Engaged} depth={ProneDriver.Depth:0.00} limitsApplied={CrouchLimits.Applied}");
if (!RigBinding.Ready)
{
logger.Msg("rig: not bound (load into a level first)");
logger.Msg("------------------------------");
return;
}
float num = RigBinding.HeadHeight();
logger.Msg($"body: headAboveFeet={((num < 0f) ? "n/a" : (num.ToString("0.000") + "m"))} grounded={RigBinding.Grounded()} fallen={RigBinding.Fallen()}");
try
{
PhysicsRig physics = RigBinding.Physics;
logger.Msg($"physics: footSupported={physics.footSupported:0.000} pelvisHeightMult={physics.pelvisHeightMult:0.000} footballRadius={physics.footballRadius:0.000}");
}
catch (Exception ex)
{
logger.Msg("physics: unreadable (" + ex.Message + ")");
}
try
{
RemapRig remap = RigBinding.Remap;
logger.Msg($"remap: vertState={remap.vertState} travState={remap.travState}");
logger.Msg($"remap: crouchTarget={remap._crouchTarget:0.000} feetOffset={remap._feetOffset:0.000} crouchSpeedLimit={remap._crouchSpeedLimit:0.000} spineCrouchOff={remap._spineCrouchOff:0.000}");
}
catch (Exception ex2)
{
logger.Msg("remap: unreadable (" + ex2.Message + ")");
}
logger.Msg("speed: " + ProneDriver.DescribeSpeed());
try
{
OpenControllerRig controller = RigBinding.Controller;
if ((Object)(object)controller != (Object)null)
{
logger.Msg($"controller: crouch={((ControllerRig)controller)._crouch:0.000} crouchInput={((ControllerRig)controller)._crouchInput} vrVertState={controller.vrVertState}");
}
}
catch (Exception ex3)
{
logger.Msg("controller: unreadable (" + ex3.Message + ")");
}
logger.Msg("kneePelvis: " + CrouchLimits.Describe());
logger.Msg("------------------------------");
}
public static void Calibrate(float seconds)
{
if (!RigBinding.Ready)
{
Melon<DropProneMod>.Logger.Warning("No rig yet — load into a level first.");
return;
}
if (ProneDriver.Active)
{
Melon<DropProneMod>.Logger.Warning("Stand up first — while prone the mod is writing these fields itself.");
return;
}
_calibrate = seconds;
_seeded = false;
HasSuggestion = false;
Melon<DropProneMod>.Logger.Msg($"Calibrating for {seconds:0}s: stand up all the way, then crouch as low as the game lets you.");
}
public static void ApplySuggestion()
{
if (!HasSuggestion)
{
Melon<DropProneMod>.Logger.Warning("Nothing to apply — run Calibrate first.");
return;
}
Prefs.CrouchDrive = SuggestedCrouchDrive;
Prefs.ProneFeetOffset = SuggestedFeetOffset;
Prefs.ProneCrouchTarget = SuggestedFeetOffset;
Prefs.Save();
Melon<DropProneMod>.Logger.Msg($"Applied: Crouch Drive = {SuggestedCrouchDrive:0.00}, Feet Offset = {SuggestedFeetOffset:0.000}.");
}
public static void WatchInputs(float seconds)
{
_watch = seconds;
Array.Clear(_lastLeft, 0, _lastLeft.Length);
Array.Clear(_lastRight, 0, _lastRight.Length);
Melon<DropProneMod>.Logger.Msg($"Watching controller inputs for {seconds:0}s — press things.");
}
public static void Tick(float dt)
{
TickWatch(dt);
TickCalibrate(dt);
}
public static void Stop()
{
_watch = 0f;
_calibrate = 0f;
}
private static void TickCalibrate(float dt)
{
if (!(_calibrate <= 0f))
{
_calibrate -= dt;
Sample();
if (_calibrate <= 0f)
{
Finish();
}
}
}
private static void Sample()
{
float num = RigBinding.HeadHeight();
if (num <= 0f)
{
return;
}
float crouch;
float feetOffset;
float crouchTarget;
try
{
OpenControllerRig controller = RigBinding.Controller;
RemapRig remap = RigBinding.Remap;
if ((Object)(object)controller == (Object)null || (Object)(object)remap == (Object)null)
{
return;
}
crouch = ((ControllerRig)controller)._crouch;
feetOffset = remap._feetOffset;
crouchTarget = remap._crouchTarget;
}
catch
{
return;
}
if (!_seeded)
{
_seeded = true;
_heightLow = (_heightHigh = num);
_crouchAtLow = (_crouchAtHigh = crouch);
_offsetAtLow = (_offsetAtHigh = feetOffset);
_targetAtLow = (_targetAtHigh = crouchTarget);
return;
}
if (num < _heightLow)
{
_heightLow = num;
_crouchAtLow = crouch;
_offsetAtLow = feetOffset;
_targetAtLow = crouchTarget;
}
if (num > _heightHigh)
{
_heightHigh = num;
_crouchAtHigh = crouch;
_offsetAtHigh = feetOffset;
_targetAtHigh = crouchTarget;
}
}
private static void Finish()
{
Instance logger = Melon<DropProneMod>.Logger;
logger.Msg("---- DropProne calibration ----");
if (!_seeded)
{
logger.Msg("No samples captured.");
logger.Msg("-------------------------------");
return;
}
float num = _heightHigh - _heightLow;
logger.Msg($"headAboveFeet: tallest {_heightHigh:0.000}m, lowest {_heightLow:0.000}m (travel {num:0.000}m)");
logger.Msg($"crouch: standing {_crouchAtHigh:0.000}, crouched {_crouchAtLow:0.000}");
logger.Msg($"feetOffset: standing {_offsetAtHigh:0.000}, crouched {_offsetAtLow:0.000}");
logger.Msg($"crouchTarget: standing {_targetAtHigh:0.000}, crouched {_targetAtLow:0.000}");
logger.Msg("kneePelvis: " + CrouchLimits.Describe());
if (num < 0.15f)
{
logger.Msg($"Only {num:0.000}m of travel seen — stand fully then crouch fully and run it again.");
logger.Msg("-------------------------------");
return;
}
SuggestedFeetOffset = _offsetAtLow + (_offsetAtLow - _offsetAtHigh) * 0.55f;
SuggestedCrouchDrive = (Mathf.Approximately(_crouchAtLow, 0f) ? Prefs.CrouchDrive : (_crouchAtLow * 1.4f));
HasSuggestion = true;
logger.Msg($"suggested Crouch Drive = {SuggestedCrouchDrive:0.00}");
logger.Msg($"suggested Feet Offset = {SuggestedFeetOffset:0.000}");
logger.Msg("Use 'Apply Suggested' in the Calibrate page to write them in.");
logger.Msg("-------------------------------");
}
private static void TickWatch(float dt)
{
if (!(_watch <= 0f))
{
_watch -= dt;
if (_watch <= 0f)
{
Melon<DropProneMod>.Logger.Msg("Input watch finished.");
return;
}
SampleButtons(RigBinding.LeftController, _lastLeft, "left");
SampleButtons(RigBinding.RightController, _lastRight, "right");
}
}
private static void SampleButtons(BaseController controller, bool[] last, string hand)
{
if ((Object)(object)controller == (Object)null)
{
return;
}
bool[] array = new bool[4];
try
{
array[0] = controller.GetThumbStick();
array[1] = controller.GetAButton();
array[2] = controller.GetBButton();
array[3] = controller.GetMenuButton();
}
catch
{
return;
}
for (int i = 0; i < array.Length; i++)
{
if (array[i] != last[i])
{
last[i] = array[i];
if (array[i])
{
Melon<DropProneMod>.Logger.Msg("input: " + hand + " " + ButtonNames[i]);
}
}
}
}
}
internal static class ProneDriver
{
private const float AirborneGrace = 0.4f;
private static bool _speedCaptured;
private static bool _touchedRig;
private static float _baseMaxVelocity;
private static float _airborneTimer;
private static int _captureFrame = -1;
public static float PlayerCrouch { get; private set; }
public static bool Engaged { get; private set; }
public static float Depth { get; private set; }
public static bool Active => Depth > 0.001f;
public static bool Toggle(string source)
{
if (!Engaged)
{
return TryEngage(source);
}
return Release(source);
}
public static bool TryEngage(string source)
{
if (!Prefs.Enabled)
{
return false;
}
if (Engaged)
{
return true;
}
if (!RigBinding.Ready)
{
Melon<DropProneMod>.Logger.Warning("No player rig yet, cannot go prone.");
return false;
}
if (Prefs.StandWhenAirborne && !RigBinding.Grounded())
{
if (Prefs.LogEvents)
{
Melon<DropProneMod>.Logger.Msg("Not prone: airborne.");
}
return false;
}
Engaged = true;
_airborneTimer = 0f;
CaptureSpeed();
if (Prefs.UseSetLimit)
{
CrouchLimits.ApplySetLimit(Prefs.ProneMin, Prefs.ProneMax);
}
if (Prefs.LogEvents)
{
Melon<DropProneMod>.Logger.Msg("Prone (" + source + ").");
}
return true;
}
public static bool Release(string reason)
{
if (!Engaged)
{
return false;
}
Engaged = false;
if (Prefs.LogEvents)
{
Melon<DropProneMod>.Logger.Msg("Standing (" + reason + ").");
}
return true;
}
public static void Tick(float dt)
{
if (Engaged)
{
Safety(dt);
}
float num = (Engaged ? 1f : 0f);
float num2 = (Engaged ? Prefs.EnterTime : Prefs.ExitTime);
Depth = Mathf.MoveTowards(Depth, num, dt / Mathf.Max(0.01f, num2));
if (RigBinding.Ready)
{
if (Active)
{
HoldDown();
}
else if (_touchedRig)
{
LetGo();
}
}
}
public static void InjectCrouchInput()
{
if (!Active || !Prefs.DriveCrouchInput)
{
return;
}
ControllerRig controller = (ControllerRig)(object)RigBinding.Controller;
if ((Object)(object)controller == (Object)null)
{
return;
}
try
{
if (_captureFrame != Time.frameCount)
{
_captureFrame = Time.frameCount;
PlayerCrouch = controller._crouch;
}
float num = Prefs.CrouchDrive * Depth;
controller._crouch = ((num < 0f) ? Mathf.Min(PlayerCrouch, num) : Mathf.Max(PlayerCrouch, num));
controller._crouchInput = true;
}
catch
{
}
}
public static void DriveOffsets()
{
if (!Active || !Prefs.ForceFeetOffset)
{
return;
}
RemapRig remap = RigBinding.Remap;
if ((Object)(object)remap == (Object)null)
{
return;
}
try
{
remap._feetOffset = Mathf.Lerp(remap._feetOffset, Prefs.ProneFeetOffset, Depth);
remap._crouchTarget = Mathf.Lerp(remap._crouchTarget, Prefs.ProneCrouchTarget, Depth);
_touchedRig = true;
}
catch
{
}
}
public static void ForceReset(bool rigIsAlive)
{
Engaged = false;
Depth = 0f;
_airborneTimer = 0f;
if (rigIsAlive)
{
LetGo();
return;
}
CrouchLimits.Forget();
_speedCaptured = false;
_touchedRig = false;
}
public static string DescribeSpeed()
{
RemapRig remap = RigBinding.Remap;
if ((Object)(object)remap == (Object)null)
{
return "no remap rig";
}
try
{
string value = (_speedCaptured ? _baseMaxVelocity.ToString("0.00") : "not captured");
return $"maxVelocity={remap.maxVelocity:0.00} currentMax={remap.currentMaxVelocity:0.00} baseline={value}";
}
catch (Exception ex)
{
return "unreadable (" + ex.Message + ")";
}
}
private static void Safety(float dt)
{
if (RigBinding.Fallen())
{
Release("ragdolled");
}
else
{
if (!Prefs.StandWhenAirborne)
{
return;
}
if (RigBinding.Grounded())
{
_airborneTimer = 0f;
return;
}
_airborneTimer += dt;
if (_airborneTimer > 0.4f)
{
Release("airborne");
}
}
}
private static void HoldDown()
{
RemapRig remap = RigBinding.Remap;
if ((Object)(object)remap == (Object)null)
{
return;
}
if (Prefs.ExtendJoint)
{
CrouchLimits.HoldExtended(Prefs.JointBonus * Depth);
}
try
{
if (_speedCaptured)
{
remap.maxVelocity = Mathf.Lerp(_baseMaxVelocity, Prefs.CrawlSpeed, Depth);
}
if (Prefs.SetVertState && Depth > 0.6f)
{
remap.vertState = (VertState)3;
OpenControllerRig controller = RigBinding.Controller;
if ((Object)(object)controller != (Object)null)
{
controller.vrVertState = (VrVertState)4;
}
}
_touchedRig = true;
}
catch
{
}
}
private static void LetGo()
{
RemapRig remap = RigBinding.Remap;
if ((Object)(object)remap != (Object)null)
{
try
{
if (_speedCaptured)
{
remap.maxVelocity = _baseMaxVelocity;
}
if (Prefs.SetVertState)
{
remap.vertState = (VertState)0;
}
OpenControllerRig controller = RigBinding.Controller;
if ((Object)(object)controller != (Object)null && Prefs.SetVertState)
{
controller.vrVertState = (VrVertState)0;
}
}
catch
{
}
}
CrouchLimits.Restore();
_speedCaptured = false;
_touchedRig = false;
}
private static void CaptureSpeed()
{
if (_speedCaptured)
{
return;
}
RemapRig remap = RigBinding.Remap;
if ((Object)(object)remap == (Object)null)
{
return;
}
try
{
_baseMaxVelocity = remap.maxVelocity;
_speedCaptured = _baseMaxVelocity > 0.01f;
}
catch
{
}
}
}
internal static class ProneInput
{
private enum ButtonKind
{
Stick,
A,
B
}
private const float CrouchThreshold = 0.85f;
private static float _crouchHeld;
private static bool _crouchFired;
public static bool Pressed { get; private set; }
public static bool Held { get; private set; }
public static void Tick(float dt)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
Pressed = false;
Held = false;
try
{
ReadBinding(dt);
}
catch
{
_crouchHeld = 0f;
_crouchFired = false;
}
try
{
if ((int)Prefs.Key != 0)
{
if (Input.GetKeyDown(Prefs.Key))
{
Pressed = true;
}
if (Input.GetKey(Prefs.Key))
{
Held = true;
}
}
}
catch
{
}
}
public static void Forget()
{
_crouchHeld = 0f;
_crouchFired = false;
Pressed = false;
Held = false;
}
private static void ReadBinding(float dt)
{
switch (Prefs.Bind)
{
case ProneBind.LeftStickClick:
ReadButton(RigBinding.LeftController, ButtonKind.Stick);
break;
case ProneBind.RightStickClick:
ReadButton(RigBinding.RightController, ButtonKind.Stick);
break;
case ProneBind.LeftBButton:
ReadButton(RigBinding.LeftController, ButtonKind.B);
break;
case ProneBind.RightBButton:
ReadButton(RigBinding.RightController, ButtonKind.B);
break;
case ProneBind.LeftAButton:
ReadButton(RigBinding.LeftController, ButtonKind.A);
break;
case ProneBind.RightAButton:
ReadButton(RigBinding.RightController, ButtonKind.A);
break;
case ProneBind.HoldCrouch:
ReadHoldCrouch(dt);
break;
}
}
private static void ReadButton(BaseController controller, ButtonKind kind)
{
if ((Object)(object)controller == (Object)null)
{
return;
}
switch (kind)
{
case ButtonKind.Stick:
if (controller.GetThumbStickDown())
{
Pressed = true;
}
if (controller.GetThumbStick())
{
Held = true;
}
break;
case ButtonKind.A:
if (controller.GetAButtonDown())
{
Pressed = true;
}
if (controller.GetAButton())
{
Held = true;
}
break;
case ButtonKind.B:
if (controller.GetBButtonDown())
{
Pressed = true;
}
if (controller.GetBButton())
{
Held = true;
}
break;
}
}
private static void ReadHoldCrouch(float dt)
{
ControllerRig controller = (ControllerRig)(object)RigBinding.Controller;
if ((Object)(object)controller == (Object)null)
{
_crouchHeld = 0f;
_crouchFired = false;
return;
}
if (Mathf.Abs(ProneDriver.Active ? ProneDriver.PlayerCrouch : controller._crouch) < 0.85f)
{
_crouchHeld = 0f;
_crouchFired = false;
return;
}
Held = true;
_crouchHeld += dt;
if (!(_crouchHeld < Prefs.HoldCrouchTime) && !_crouchFired)
{
_crouchFired = true;
Pressed = true;
}
}
}
internal static class RigBinding
{
private static float _retry;
public static RigManager Manager { get; private set; }
public static PhysicsRig Physics { get; private set; }
public static RemapRig Remap { get; private set; }
public static OpenControllerRig Controller { get; private set; }
public static BaseController LeftController { get; private set; }
public static BaseController RightController { get; private set; }
public static bool Ready
{
get
{
if ((Object)(object)Physics != (Object)null)
{
return (Object)(object)Remap != (Object)null;
}
return false;
}
}
public static void Forget()
{
Manager = null;
Physics = null;
Remap = null;
Controller = null;
LeftController = null;
RightController = null;
_retry = 0f;
}
public static bool Bind(float dt)
{
if (Ready)
{
return true;
}
_retry -= dt;
if (_retry > 0f)
{
return false;
}
_retry = 0.5f;
try
{
Manager = Player.RigManager;
Physics = Player.PhysicsRig;
Remap = Player.RemapRig;
Controller = Player.ControllerRig;
LeftController = Player.LeftController;
RightController = Player.RightController;
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("Binding the player rig failed: " + ex);
Forget();
return false;
}
return Ready;
}
public static float HeadHeight()
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
try
{
Transform head = Player.Head;
PhysicsRig physics = Physics;
if ((Object)(object)head == (Object)null || (Object)(object)physics == (Object)null)
{
return -1f;
}
Transform val = (((Object)(object)physics.feet != (Object)null) ? physics.feet.transform : null);
if ((Object)(object)val == (Object)null)
{
return -1f;
}
return head.position.y - val.position.y;
}
catch
{
return -1f;
}
}
public static bool Grounded()
{
try
{
PhysicsRig physics = Physics;
return (Object)(object)physics != (Object)null && physics.footSupported > 0.25f;
}
catch
{
return true;
}
}
public static bool Fallen()
{
try
{
PhysicsRig physics = Physics;
return (Object)(object)physics != (Object)null && physics.manualFallenState;
}
catch
{
return false;
}
}
}
}
namespace DropProne.Patches
{
internal static class RigPatches
{
public static int Applied { get; private set; }
public static bool CrouchHoldPatched { get; private set; }
public static void Apply(Harmony harmony)
{
if (harmony != null)
{
Patch(harmony, typeof(OpenControllerRig), "OnEarlyUpdate", "AfterControllerUpdate");
Patch(harmony, typeof(OpenControllerRig), "OnUpdate", "AfterControllerUpdate");
if (Applied == 0)
{
Patch(harmony, typeof(ControllerRig), "OnUpdate", "AfterControllerUpdate");
}
CrouchHoldPatched = Patch(harmony, typeof(RemapRig), "CrouchHold", "AfterCrouchHold");
if (Applied == 0)
{
Melon<DropProneMod>.Logger.Error("No rig hooks landed. Prone will still try to drive the rig from OnUpdate, but it may fight the game.");
}
}
}
private static bool Patch(Harmony harmony, Type type, string method, string postfixName)
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
try
{
MethodInfo methodInfo = AccessTools.Method(type, method, (Type[])null, (Type[])null);
if (methodInfo == null)
{
Melon<DropProneMod>.Logger.Warning(type.Name + "." + method + " not found, skipping that hook.");
return false;
}
MethodInfo methodInfo2 = AccessTools.Method(typeof(RigPatches), postfixName, (Type[])null, (Type[])null);
harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Applied++;
Melon<DropProneMod>.Logger.Msg($"Hooked {type.Name}.{method}.");
return true;
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error($"Patching {type.Name}.{method} failed: " + ex);
return false;
}
}
private static void AfterControllerUpdate()
{
ProneDriver.InjectCrouchInput();
}
private static void AfterCrouchHold()
{
ProneDriver.DriveOffsets();
}
}
}
namespace DropProne.Menu
{
internal static class MenuPage
{
private static readonly Color Accent = new Color(0.4f, 0.68f, 0.4f);
private static readonly string[] BindNames = new string[8] { "Menu / key only", "Left stick click", "Right stick click", "Left B button", "Right B button", "Left A button", "Right A button", "Hold crouch" };
public static void Build()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
Page root;
try
{
root = Page.Root.CreatePage("Drop Prone", Accent, 0, true);
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("BoneMenu root page failed: " + ex);
return;
}
Section("main", delegate
{
BuildMain(root);
});
Section("feel", delegate
{
BuildFeel(root);
});
Section("depth", delegate
{
BuildDepth(root);
});
Section("diagnostics", delegate
{
BuildDiagnostics(root);
});
}
private static void Section(string name, Action build)
{
try
{
build();
}
catch (Exception ex)
{
Melon<DropProneMod>.Logger.Error("BoneMenu section '" + name + "' failed: " + ex);
}
}
private static void BuildMain(Page root)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
root.CreateBool("Enabled", Accent, Prefs.Enabled, (Action<bool>)delegate(bool value)
{
Prefs.Enabled = value;
Prefs.Save();
if (!value)
{
ProneDriver.Release("disabled");
}
});
root.CreateFunction("Go Prone / Stand", Accent, (Action)delegate
{
ProneDriver.Toggle("menu");
});
root.CreateInt("Binding", Accent, (int)Prefs.Bind, 1, 0, 7, (Action<int>)delegate(int value)
{
Prefs.Bind = (ProneBind)value;
Prefs.Save();
ProneInput.Forget();
Melon<DropProneMod>.Logger.Msg("Binding: " + BindNames[Mathf.Clamp(value, 0, 7)]);
});
root.CreateBool("Hold Instead Of Toggle", Accent, Prefs.HoldMode, (Action<bool>)delegate(bool value)
{
Prefs.HoldMode = value;
Prefs.Save();
ProneDriver.Release("binding changed");
});
root.CreateFloat("Hold Crouch Time", Accent, Prefs.HoldCrouchTime, 0.05f, 0.1f, 3f, (Action<float>)delegate(float value)
{
Prefs.HoldCrouchTime = value;
Prefs.Save();
});
}
private static void BuildFeel(Page root)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
Page obj = root.CreatePage("Feel", Accent, 0, true);
obj.CreateFloat("Crawl Speed", Accent, Prefs.CrawlSpeed, 0.05f, 0.05f, 6f, (Action<float>)delegate(float value)
{
Prefs.CrawlSpeed = value;
Prefs.Save();
});
obj.CreateFloat("Drop Time", Accent, Prefs.EnterTime, 0.05f, 0.05f, 3f, (Action<float>)delegate(float value)
{
Prefs.EnterTime = value;
Prefs.Save();
});
obj.CreateFloat("Stand Time", Accent, Prefs.ExitTime, 0.05f, 0.05f, 3f, (Action<float>)delegate(float value)
{
Prefs.ExitTime = value;
Prefs.Save();
});
obj.CreateBool("Stand When Airborne", Accent, Prefs.StandWhenAirborne, (Action<bool>)delegate(bool value)
{
Prefs.StandWhenAirborne = value;
Prefs.Save();
});
obj.CreateBool("Set Prone Vert State", Accent, Prefs.SetVertState, (Action<bool>)delegate(bool value)
{
Prefs.SetVertState = value;
Prefs.Save();
});
obj.CreateBool("Log Events", Accent, Prefs.LogEvents, (Action<bool>)delegate(bool value)
{
Prefs.LogEvents = value;
Prefs.Save();
});
}
private static void BuildDepth(Page root)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
Page obj = root.CreatePage("Depth", Accent, 0, true);
obj.CreateBool("Drive Crouch Input", Accent, Prefs.DriveCrouchInput, (Action<bool>)delegate(bool value)
{
Prefs.DriveCrouchInput = value;
Prefs.Save();
});
obj.CreateFloat("Crouch Drive", Accent, Prefs.CrouchDrive, 0.1f, -4f, 4f, (Action<float>)delegate(float value)
{
Prefs.CrouchDrive = value;
Prefs.Save();
});
obj.CreateBool("Extend Knee Joint", Accent, Prefs.ExtendJoint, (Action<bool>)delegate(bool value)
{
Prefs.ExtendJoint = value;
Prefs.Save();
if (!value)
{
CrouchLimits.Restore();
}
});
obj.CreateFloat("Joint Travel Bonus", Accent, Prefs.JointBonus, 0.05f, 0f, 1.5f, (Action<float>)delegate(float value)
{
Prefs.JointBonus = value;
Prefs.Save();
});
obj.CreateBool("Force Feet Offset", Accent, Prefs.ForceFeetOffset, (Action<bool>)delegate(bool value)
{
Prefs.ForceFeetOffset = value;
Prefs.Save();
});
obj.CreateFloat("Prone Feet Offset", Accent, Prefs.ProneFeetOffset, 0.05f, -3f, 3f, (Action<float>)delegate(float value)
{
Prefs.ProneFeetOffset = value;
Prefs.Save();
});
obj.CreateFloat("Prone Crouch Target", Accent, Prefs.ProneCrouchTarget, 0.05f, -3f, 3f, (Action<float>)delegate(float value)
{
Prefs.ProneCrouchTarget = value;
Prefs.Save();
});
obj.CreateFunction("Restore Joint", Accent, (Action)CrouchLimits.Restore);
BuildLegacy(obj);
}
private static void BuildLegacy(Page depth)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
Page obj = depth.CreatePage("SetKneePelvisLimit", Accent, 0, true);
obj.CreateBool("Use SetKneePelvisLimit", Accent, Prefs.UseSetLimit, (Action<bool>)delegate(bool value)
{
Prefs.UseSetLimit = value;
Prefs.Save();
if (!value)
{
CrouchLimits.Restore();
}
});
obj.CreateFloat("Prone Min", Accent, Prefs.ProneMin, 0.02f, 0f, 1.2f, (Action<float>)delegate(float value)
{
Prefs.ProneMin = value;
Prefs.Save();
Reapply();
});
obj.CreateFloat("Prone Max", Accent, Prefs.ProneMax, 0.05f, 0.2f, 3f, (Action<float>)delegate(float value)
{
Prefs.ProneMax = value;
Prefs.Save();
Reapply();
});
}
private static void BuildDiagnostics(Page root)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
Page obj = root.CreatePage("Diagnostics", Accent, 0, true);
obj.CreateFunction("Calibrate (12s)", Accent, (Action)delegate
{
Diagnostics.Calibrate(12f);
});
obj.CreateFunction("Apply Suggested", Accent, (Action)Diagnostics.ApplySuggestion);
obj.CreateFunction("Report Rig State", Accent, (Action)Diagnostics.Report);
obj.CreateFunction("Watch Inputs (10s)", Accent, (Action)delegate
{
Diagnostics.WatchInputs(10f);
});
obj.CreateFunction("Stop", Accent, (Action)Diagnostics.Stop);
}
private static void Reapply()
{
if (CrouchLimits.Applied && Prefs.UseSetLimit)
{
CrouchLimits.Restore();
CrouchLimits.ApplySetLimit(Prefs.ProneMin, Prefs.ProneMax);
}
}
}
}
namespace DropProne.Config
{
internal enum ProneBind
{
MenuAndKeyOnly,
LeftStickClick,
RightStickClick,
LeftBButton,
RightBButton,
LeftAButton,
RightAButton,
HoldCrouch
}
internal static class Prefs
{
private static MelonPreferences_Category _category;
private static MelonPreferences_Entry<bool> _enabled;
private static MelonPreferences_Entry<int> _bind;
private static MelonPreferences_Entry<bool> _holdMode;
private static MelonPreferences_Entry<int> _key;
private static MelonPreferences_Entry<float> _holdCrouchTime;
private static MelonPreferences_Entry<float> _enterTime;
private static MelonPreferences_Entry<float> _exitTime;
private static MelonPreferences_Entry<float> _crawlSpeed;
private static MelonPreferences_Entry<bool> _driveCrouchInput;
private static MelonPreferences_Entry<float> _crouchDrive;
private static MelonPreferences_Entry<bool> _extendJoint;
private static MelonPreferences_Entry<float> _jointBonus;
private static MelonPreferences_Entry<bool> _useSetLimit;
private static MelonPreferences_Entry<float> _proneMin;
private static MelonPreferences_Entry<float> _proneMax;
private static MelonPreferences_Entry<bool> _forceFeetOffset;
private static MelonPreferences_Entry<float> _proneFeetOffset;
private static MelonPreferences_Entry<float> _proneCrouchTarget;
private static MelonPreferences_Entry<bool> _setVertState;
private static MelonPreferences_Entry<bool> _standWhenAirborne;
private static MelonPreferences_Entry<bool> _logEvents;
public static bool Enabled
{
get
{
return _enabled?.Value ?? true;
}
set
{
if (_enabled != null)
{
_enabled.Value = value;
}
}
}
public static ProneBind Bind
{
get
{
return (ProneBind)Mathf.Clamp(_bind?.Value ?? 1, 0, 7);
}
set
{
if (_bind != null)
{
_bind.Value = (int)value;
}
}
}
public static bool HoldMode
{
get
{
return _holdMode?.Value ?? false;
}
set
{
if (_holdMode != null)
{
_holdMode.Value = value;
}
}
}
public static KeyCode Key
{
get
{
MelonPreferences_Entry<int> key = _key;
if (key != null)
{
return (KeyCode)key.Value;
}
return (KeyCode)99;
}
set
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected I4, but got Unknown
if (_key != null)
{
_key.Value = (int)value;
}
}
}
public static float HoldCrouchTime
{
get
{
return Mathf.Clamp(_holdCrouchTime?.Value ?? 0.55f, 0.1f, 3f);
}
set
{
if (_holdCrouchTime != null)
{
_holdCrouchTime.Value = value;
}
}
}
public static float EnterTime
{
get
{
return Mathf.Clamp(_enterTime?.Value ?? 0.45f, 0.05f, 3f);
}
set
{
if (_enterTime != null)
{
_enterTime.Value = value;
}
}
}
public static float ExitTime
{
get
{
return Mathf.Clamp(_exitTime?.Value ?? 0.35f, 0.05f, 3f);
}
set
{
if (_exitTime != null)
{
_exitTime.Value = value;
}
}
}
public static float CrawlSpeed
{
get
{
return Mathf.Clamp(_crawlSpeed?.Value ?? 0.7f, 0.05f, 6f);
}
set
{
if (_crawlSpeed != null)
{
_crawlSpeed.Value = value;
}
}
}
public static bool DriveCrouchInput
{
get
{
return _driveCrouchInput?.Value ?? true;
}
set
{
if (_driveCrouchInput != null)
{
_driveCrouchInput.Value = value;
}
}
}
public static float CrouchDrive
{
get
{
return Mathf.Clamp(_crouchDrive?.Value ?? (-1.4f), -4f, 4f);
}
set
{
if (_crouchDrive != null)
{
_crouchDrive.Value = value;
}
}
}
public static bool ExtendJoint
{
get
{
return _extendJoint?.Value ?? true;
}
set
{
if (_extendJoint != null)
{
_extendJoint.Value = value;
}
}
}
public static float JointBonus
{
get
{
return Mathf.Clamp(_jointBonus?.Value ?? 0.35f, 0f, 1.5f);
}
set
{
if (_jointBonus != null)
{
_jointBonus.Value = value;
}
}
}
public static bool UseSetLimit
{
get
{
return _useSetLimit?.Value ?? false;
}
set
{
if (_useSetLimit != null)
{
_useSetLimit.Value = value;
}
}
}
public static float ProneMin
{
get
{
return Mathf.Clamp(_proneMin?.Value ?? 0.12f, 0f, 1.2f);
}
set
{
if (_proneMin != null)
{
_proneMin.Value = value;
}
}
}
public static float ProneMax
{
get
{
return Mathf.Clamp(_proneMax?.Value ?? 1.6f, 0.2f, 3f);
}
set
{
if (_proneMax != null)
{
_proneMax.Value = value;
}
}
}
public static bool ForceFeetOffset
{
get
{
return _forceFeetOffset?.Value ?? true;
}
set
{
if (_forceFeetOffset != null)
{
_forceFeetOffset.Value = value;
}
}
}
public static float ProneFeetOffset
{
get
{
return Mathf.Clamp(_proneFeetOffset?.Value ?? (-1.15f), -3f, 3f);
}
set
{
if (_proneFeetOffset != null)
{
_proneFeetOffset.Value = value;
}
}
}
public static float ProneCrouchTarget
{
get
{
return Mathf.Clamp(_proneCrouchTarget?.Value ?? (-1.15f), -3f, 3f);
}
set
{
if (_proneCrouchTarget != null)
{
_proneCrouchTarget.Value = value;
}
}
}
public static bool SetVertState
{
get
{
return _setVertState?.Value ?? true;
}
set
{
if (_setVertState != null)
{
_setVertState.Value = value;
}
}
}
public static bool StandWhenAirborne
{
get
{
return _standWhenAirborne?.Value ?? true;
}
set
{
if (_standWhenAirborne != null)
{
_standWhenAirborne.Value = value;
}
}
}
public static bool LogEvents
{
get
{
return _logEvents?.Value ?? true;
}
set
{
if (_logEvents != null)
{
_logEvents.Value = value;
}
}
}
public static void Load()
{
_category = MelonPreferences.CreateCategory("DropProne");
_enabled = _category.CreateEntry<bool>("Enabled", true, "Enabled", (string)null, false, false, (ValueValidator)null, (string)null);
_bind = _category.CreateEntry<int>("Bind", 1, "Controller Binding", (string)null, false, false, (ValueValidator)null, (string)null);
_holdMode = _category.CreateEntry<bool>("HoldMode", false, "Hold Instead Of Toggle", (string)null, false, false, (ValueValidator)null, (string)null);
_key = _category.CreateEntry<int>("Key", 99, "Keyboard Key", (string)null, false, false, (ValueValidator)null, (string)null);
_holdCrouchTime = _category.CreateEntry<float>("HoldCrouchTime", 0.55f, "Hold Crouch Time (s)", (string)null, false, false, (ValueValidator)null, (string)null);
_enterTime = _category.CreateEntry<float>("EnterTime", 0.45f, "Drop Time (s)", (string)null, false, false, (ValueValidator)null, (string)null);
_exitTime = _category.CreateEntry<float>("ExitTime", 0.35f, "Stand Time (s)", (string)null, false, false, (ValueValidator)null, (string)null);
_crawlSpeed = _category.CreateEntry<float>("CrawlSpeed2", 0.7f, "Crawl Speed", (string)null, false, false, (ValueValidator)null, (string)null);
_driveCrouchInput = _category.CreateEntry<bool>("DriveCrouchInput", true, "Drive Crouch Input", (string)null, false, false, (ValueValidator)null, (string)null);
_crouchDrive = _category.CreateEntry<float>("CrouchDrive", -1.4f, "Crouch Drive", (string)null, false, false, (ValueValidator)null, (string)null);
_extendJoint = _category.CreateEntry<bool>("ExtendJoint", true, "Extend Knee Joint", (string)null, false, false, (ValueValidator)null, (string)null);
_jointBonus = _category.CreateEntry<float>("JointBonus", 0.35f, "Joint Travel Bonus (m)", (string)null, false, false, (ValueValidator)null, (string)null);
_useSetLimit = _category.CreateEntry<bool>("UseSetLimit", false, "Use SetKneePelvisLimit", (string)null, false, false, (ValueValidator)null, (string)null);
_proneMin = _category.CreateEntry<float>("ProneMin", 0.12f, "Prone Min (m)", (string)null, false, false, (ValueValidator)null, (string)null);
_proneMax = _category.CreateEntry<float>("ProneMax", 1.6f, "Prone Max (m)", (string)null, false, false, (ValueValidator)null, (string)null);
_forceFeetOffset = _category.CreateEntry<bool>("ForceFeetOffset", true, "Force Feet Offset", (string)null, false, false, (ValueValidator)null, (string)null);
_proneFeetOffset = _category.CreateEntry<float>("ProneFeetOffset", -1.15f, "Prone Feet Offset", (string)null, false, false, (ValueValidator)null, (string)null);
_proneCrouchTarget = _category.CreateEntry<float>("ProneCrouchTarget", -1.15f, "Prone Crouch Target", (string)null, false, false, (ValueValidator)null, (string)null);
_setVertState = _category.CreateEntry<bool>("SetVertState", true, "Set Prone Vert State", (string)null, false, false, (ValueValidator)null, (string)null);
_standWhenAirborne = _category.CreateEntry<bool>("StandWhenAirborne", true, "Stand When Airborne", (string)null, false, false, (ValueValidator)null, (string)null);
_logEvents = _category.CreateEntry<bool>("LogEvents", true, "Log Events", (string)null, false, false, (ValueValidator)null, (string)null);
}
public static void Save()
{
try
{
MelonPreferences_Category category = _category;
if (category != null)
{
category.SaveToFile(false);
}
}
catch
{
}
}
}
}
