using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Mirror;
using Rewired;
using RewiredConsts;
using TMPro;
using UnityEngine;
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(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("MHZ")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCopyright("Copyright © 2026 Masaicker")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("EnhancedControls")]
[assembly: AssemblyTitle("EnhancedControls")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.1.0")]
[module: UnverifiableCode]
namespace EnhancedControls
{
[BepInPlugin("mhz.bigwalk.enhancedcontrols", "Enhanced Controls", "1.0.1")]
public sealed class EnhancedControlsPlugin : BasePlugin
{
private sealed class RaisedPropLockAccelerationState
{
public readonly float beginTime;
public RaisedPropLockAccelerationState(float beginTime)
{
this.beginTime = beginTime;
}
}
private sealed class JumpAssistState
{
public readonly PlayerCharacter player;
private bool wasOnJumpableGround;
private bool jumpedSinceGrounded;
private float bufferedJumpUntil;
private float coyoteJumpUntil;
public JumpAssistState(PlayerCharacter player)
{
this.player = player;
}
public void UpdateGroundState(float now, bool isOnJumpableGround)
{
if (isOnJumpableGround)
{
if (!wasOnJumpableGround)
{
jumpedSinceGrounded = false;
coyoteJumpUntil = 0f;
}
}
else if (wasOnJumpableGround)
{
coyoteJumpUntil = (jumpedSinceGrounded ? 0f : (now + 0.1f));
}
wasOnJumpableGround = isOnJumpableGround;
}
public bool CanCoyoteJump(float now)
{
return !wasOnJumpableGround && coyoteJumpUntil > now;
}
public void BufferJump(float now)
{
bufferedJumpUntil = now + 0.12f;
}
public bool TryConsumeBufferedJump(float now)
{
if (bufferedJumpUntil <= now)
{
bufferedJumpUntil = 0f;
return false;
}
bufferedJumpUntil = 0f;
return true;
}
public void ClearBufferedJump()
{
bufferedJumpUntil = 0f;
}
public void RecordJump()
{
jumpedSinceGrounded = true;
bufferedJumpUntil = 0f;
coyoteJumpUntil = 0f;
}
}
private sealed class AutoRunState
{
public readonly PlayerCharacter player;
public readonly Player inputPlayer;
public bool isActive;
public bool waitingForVerticalRelease;
public bool keepSprintingWhileMoving;
public bool isControllingMoveAxis;
public float virtualMoveY;
private readonly float digitalAxisGravity;
private readonly float digitalAxisSensitivity;
private bool hasNativeMoveY;
private float nativeMoveY;
public AutoRunState(PlayerCharacter player, Player inputPlayer)
{
this.player = player;
this.inputPlayer = inputPlayer;
InputBehavior inputBehavior = inputPlayer.controllers.maps.GetInputBehavior(0);
digitalAxisGravity = ((inputBehavior != null) ? inputBehavior.digitalAxisGravity : 3f);
digitalAxisSensitivity = ((inputBehavior != null) ? inputBehavior.digitalAxisSensitivity : 3f);
}
public void StartAutoRun(float physicalMoveY)
{
if (!isControllingMoveAxis)
{
virtualMoveY = physicalMoveY;
}
isActive = true;
waitingForVerticalRelease = Mathf.Abs(physicalMoveY) > 0.2f;
keepSprintingWhileMoving = false;
isControllingMoveAxis = true;
}
public void StopAutoRun(bool keepSprintingWhileMoving, float physicalMoveY)
{
isActive = false;
waitingForVerticalRelease = false;
isControllingMoveAxis = true;
this.keepSprintingWhileMoving = keepSprintingWhileMoving || !Mathf.Approximately(virtualMoveY, physicalMoveY);
}
public void UpdateMoveAxis(float physicalMoveY, float deltaTime)
{
if (isActive)
{
virtualMoveY = Mathf.MoveTowards(virtualMoveY, 1f, digitalAxisSensitivity * deltaTime);
}
else
{
if (!isControllingMoveAxis)
{
return;
}
if (physicalMoveY >= 0.87f)
{
if (hasNativeMoveY && nativeMoveY >= virtualMoveY)
{
virtualMoveY = nativeMoveY;
isControllingMoveAxis = false;
}
return;
}
if (physicalMoveY <= -0.87f && hasNativeMoveY)
{
virtualMoveY = nativeMoveY;
isControllingMoveAxis = false;
return;
}
float num = ((Mathf.Abs(physicalMoveY) <= 0.2f) ? digitalAxisGravity : digitalAxisSensitivity);
virtualMoveY = Mathf.MoveTowards(virtualMoveY, physicalMoveY, num * deltaTime);
if (Mathf.Approximately(virtualMoveY, physicalMoveY))
{
virtualMoveY = physicalMoveY;
isControllingMoveAxis = false;
}
}
}
public void RecordNativeMoveAxis(float value)
{
nativeMoveY = value;
hasNativeMoveY = true;
}
}
[HarmonyPatch(typeof(PlayerSprinter), "LocalUpdate")]
private static class StandUpOnSprintPatch
{
[HarmonyPrefix]
private static void Prefix(PlayerSprinter __instance)
{
TryStandUp(__instance.pc, Action.sprint);
}
}
[HarmonyPatch(typeof(PlayerSprinter), "LocalUpdate")]
private static class AutoRunStatePatch
{
[HarmonyPostfix]
private static void Postfix(PlayerSprinter __instance)
{
UpdateAutoRun(__instance);
}
}
[HarmonyPatch(typeof(PlayerSitter), "Update")]
private static class StandUpOnSitPatch
{
[HarmonyPrefix]
private static void Prefix(PlayerSitter __instance, ref bool __state)
{
__state = ShouldStandUp(__instance.playerCharacter, __instance, Action.sit);
}
[HarmonyPostfix]
private static void Postfix(PlayerSitter __instance, bool __state)
{
if (__state && __instance.isSittingLocal)
{
__instance.SetSittingLocal(false);
}
}
}
[HarmonyPatch(typeof(PlayerJumper), "Update")]
private static class StandUpOnJumpPatch
{
[HarmonyPrefix]
private static void Prefix(PlayerJumper __instance, ref bool __state)
{
__state = TryStandUp(__instance.playerCharacter, Action.jump);
}
[HarmonyPostfix]
private static void Postfix(PlayerJumper __instance, bool __state)
{
if (__state)
{
__instance.jumpInQueue = false;
ClearJumpAssist(__instance.playerCharacter);
}
else
{
UpdateJumpAssist(__instance);
}
}
}
[HarmonyPatch(typeof(PlayerJumper), "OnJump")]
private static class JumpAssistOnJumpPatch
{
[HarmonyPostfix]
private static void Postfix(PlayerJumper __instance)
{
RecordOriginalJump(__instance);
}
}
[HarmonyPatch(typeof(PlayerGestures), "Update")]
private static class RaisedPropLockAccelerationPatch
{
[HarmonyPrefix]
private static void Prefix(PlayerGestures __instance)
{
AccelerateRaisedPropLock(__instance);
}
}
[HarmonyPatch(typeof(Player), "GetAxis", new Type[] { typeof(int) })]
private static class AutoRunMoveAxisPatch
{
[HarmonyPostfix]
private static void Postfix(Player __instance, int actionId, ref float __result)
{
if (ShouldOverrideAutoRunMoveAxis(__instance, actionId))
{
OverrideAutoRunMoveAxis(ref __result);
}
}
}
[HarmonyPatch(typeof(LocalizedText), "RefreshAll")]
private static class AutoRunHudLocalizationPatch
{
[HarmonyPostfix]
private static void Postfix()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
LocalizationManager instance = LocalizationManager.instance;
if (instance != null)
{
SetAutoRunHudText(instance.currentLanguage);
}
}
}
private const string HarmonyId = "mhz.bigwalk.enhancedcontrols";
private const float RaisedPropLockProgressDelay = 0.5f;
private const float RaisedPropLockTotalDuration = 2f;
private const float OriginalRaisedPropLockProgressStartRatio = 0.4f;
private const float JumpBufferDuration = 0.12f;
private const float CoyoteTimeDuration = 0.1f;
private const float AutoRunAnalogNeutralThreshold = 0.2f;
private const float AutoRunAnalogCancelThreshold = 0.87f;
private const string AutoRunHudTextEnglish = "AUTO RUN";
private const string AutoRunHudTextSimplifiedChinese = "自动奔跑";
private const string AutoRunHudTextTraditionalChinese = "自動奔跑";
private static RaisedPropLockAccelerationState raisedPropLockAcceleration;
private static JumpAssistState jumpAssist;
private static AutoRunState autoRunState;
private static int autoRunMoveXAction;
private static int autoRunMoveYAction;
private static GameObject autoRunHud;
private static LocalizedText autoRunHudText;
private static LocalizationLanguage? autoRunHudLanguage;
private static float originalRaisedPropLockDuration;
public static ConfigEntry<bool> EnableStandUpOptimization { get; private set; }
public static ConfigEntry<bool> EnableRaisedPropLockAcceleration { get; private set; }
public static ConfigEntry<bool> EnableJumpAssist { get; private set; }
public static ConfigEntry<KeyCode> AutoRunKey { get; private set; }
public static ConfigEntry<KeyCode> AutoRunGamepadKey { get; private set; }
public override void Load()
{
EnableStandUpOptimization = ((BasePlugin)this).Config.Bind<bool>("低姿态快速退出 / Quick Low-Posture Exit", "Enabled", true, "坐下、滑铲或过渡时，按坐下、奔跑或跳跃立即起身。\nImmediately stand up with Sit, Sprint, or Jump while sitting, sliding, or transitioning.");
EnableRaisedPropLockAcceleration = ((BasePlugin)this).Config.Bind<bool>("举物锁定提速 / Raised-Prop Lock Speed", "Enabled", true, "缩短举高道具时锁定姿态的长按时间。\nShortens the hold time to lock the pose while raising a prop.");
EnableJumpAssist = ((BasePlugin)this).Config.Bind<bool>("跳跃优化 / Jump Assist", "Enabled", true, "加入跳跃缓冲和土狼时间。落地前按跳会自动起跳，走出平台边缘后短暂仍可跳跃。\nAdds jump buffering and coyote time. Queues a jump pressed before landing and allows jumping briefly after walking off a ledge.");
AutoRunKey = ((BasePlugin)this).Config.Bind<KeyCode>("自动奔跑 / Auto Run", "Key", (KeyCode)120, "按下此键盘按键开始或结束自动奔跑。\nPress this keyboard key to start or stop Auto Run.");
AutoRunGamepadKey = ((BasePlugin)this).Config.Bind<KeyCode>("自动奔跑 / Auto Run", "Gamepad Key", (KeyCode)332, "按下此手柄按键开始或结束自动奔跑。\nPress this gamepad key to start or stop Auto Run.");
autoRunMoveXAction = Action.moveX;
autoRunMoveYAction = Action.moveY;
originalRaisedPropLockDuration = PlayerActionState.stickyDuration;
((BasePlugin)this).Log.LogInfo((object)"Enhanced Controls loaded.");
Harmony.CreateAndPatchAll(typeof(EnhancedControlsPlugin).Assembly, "mhz.bigwalk.enhancedcontrols");
}
private static bool ShouldStandUp(PlayerCharacter player, PlayerSitter sitter, int action)
{
return EnableStandUpOptimization.Value && player != null && ((NetworkBehaviour)player).isLocalPlayer && player.inputPlayer != null && sitter != null && sitter.isSittingLocal && player.inputPlayer.GetButtonDown(action);
}
private static bool TryStandUp(PlayerCharacter player, int action)
{
if (player == null)
{
return false;
}
PlayerSitter sitter = player.sitter;
if (!ShouldStandUp(player, sitter, action))
{
return false;
}
sitter.SetSittingLocal(false);
return true;
}
private static void AccelerateRaisedPropLock(PlayerGestures gestures)
{
if (!EnableRaisedPropLockAcceleration.Value)
{
raisedPropLockAcceleration = null;
return;
}
PlayerCharacter val = ((gestures != null) ? gestures.playerCharacter : null);
if (val == null || !((NetworkBehaviour)val).isLocalPlayer || val.inputPlayer == null)
{
return;
}
if ((!val.inputPlayer.GetButton(Action.waveLeft) && !val.inputPlayer.GetButton(Action.waveRight)) || !gestures.wasHoldingProp)
{
raisedPropLockAcceleration = null;
return;
}
if (raisedPropLockAcceleration == null)
{
raisedPropLockAcceleration = new RaisedPropLockAccelerationState(Time.realtimeSinceStartup);
}
float elapsed = Time.realtimeSinceStartup - raisedPropLockAcceleration.beginTime;
SetWaveTimeHeld(gestures, GetMappedLockTime(elapsed));
}
private static float GetMappedLockTime(float elapsed)
{
float num = originalRaisedPropLockDuration * 0.4f;
if (elapsed <= 0.5f)
{
return Mathf.Lerp(0f, num, elapsed / 0.5f);
}
float num2 = 1.5f;
float num3 = Mathf.Clamp01((elapsed - 0.5f) / num2);
return Mathf.Lerp(num, originalRaisedPropLockDuration, num3);
}
private static void SetWaveTimeHeld(PlayerGestures gestures, float timeHeld)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
PlayerActionState leftArmWavingState = gestures.leftArmWavingState;
leftArmWavingState.timeHeld = timeHeld;
gestures.leftArmWavingState = leftArmWavingState;
PlayerActionState rightArmWavingState = gestures.rightArmWavingState;
rightArmWavingState.timeHeld = timeHeld;
gestures.rightArmWavingState = rightArmWavingState;
PlayerActionState sharedArmWavingState = gestures.sharedArmWavingState;
sharedArmWavingState.timeHeld = timeHeld;
gestures.sharedArmWavingState = sharedArmWavingState;
}
private static void UpdateJumpAssist(PlayerJumper jumper)
{
PlayerCharacter val = ((jumper != null) ? jumper.playerCharacter : null);
if (!EnableJumpAssist.Value || val == null || !((NetworkBehaviour)val).isLocalPlayer || val.inputPlayer == null)
{
ClearJumpAssist(val);
return;
}
PlayerGround ground = val.ground;
if (ground != null)
{
PlayerSitter sitter = val.sitter;
if (sitter == null || !sitter.isSittingLocal)
{
if (jumpAssist == null || (Object)(object)jumpAssist.player != (Object)(object)val)
{
jumpAssist = new JumpAssistState(val);
}
float realtimeSinceStartup = Time.realtimeSinceStartup;
bool isOnJumpableGround = ground.isOnJumpableGround;
jumpAssist.UpdateGroundState(realtimeSinceStartup, isOnJumpableGround);
bool buttonDown = val.inputPlayer.GetButtonDown(Action.jump);
if (isOnJumpableGround)
{
if (buttonDown)
{
jumpAssist.ClearBufferedJump();
}
else if (jumpAssist.TryConsumeBufferedJump(realtimeSinceStartup))
{
jumper.jumpInQueue = true;
}
}
else if (buttonDown)
{
if (jumpAssist.CanCoyoteJump(realtimeSinceStartup))
{
jumpAssist.RecordJump();
jumper.jumpInQueue = false;
jumper.ForceAJump();
}
else
{
jumpAssist.BufferJump(realtimeSinceStartup);
}
}
return;
}
}
ClearJumpAssist(val);
}
private static void RecordOriginalJump(PlayerJumper jumper)
{
PlayerCharacter val = ((jumper != null) ? jumper.playerCharacter : null);
if (val != null && ((NetworkBehaviour)val).isLocalPlayer && (Object)(object)jumpAssist?.player == (Object)(object)val)
{
jumpAssist.RecordJump();
}
}
private static void ClearJumpAssist(PlayerCharacter player)
{
if (player == null || (Object)(object)jumpAssist?.player == (Object)(object)player)
{
jumpAssist = null;
}
}
private static void UpdateAutoRun(PlayerSprinter sprinter)
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
PlayerCharacter val = ((sprinter != null) ? sprinter.pc : null);
if (val == null || !((NetworkBehaviour)val).isLocalPlayer || val.inputPlayer == null)
{
SetAutoRunHudVisible(isVisible: false);
return;
}
if (autoRunState == null || (Object)(object)autoRunState.player != (Object)(object)val)
{
autoRunState = new AutoRunState(val, val.inputPlayer);
}
float physicalMoveAxisRaw = GetPhysicalMoveAxisRaw(val.inputPlayer, autoRunMoveYAction);
float physicalMoveAxisRaw2 = GetPhysicalMoveAxisRaw(val.inputPlayer, autoRunMoveXAction);
bool flag = HasPhysicalMoveInput(physicalMoveAxisRaw2, physicalMoveAxisRaw);
if (Input.GetKeyDown(AutoRunKey.Value) || Input.GetKeyDown(AutoRunGamepadKey.Value))
{
if (autoRunState.isActive)
{
autoRunState.StopAutoRun(flag, physicalMoveAxisRaw);
}
else
{
autoRunState.StartAutoRun(physicalMoveAxisRaw);
sprinter.isSprinting = true;
}
FinishAutoRunUpdate(sprinter, autoRunState, flag, physicalMoveAxisRaw);
return;
}
if (!autoRunState.isActive)
{
FinishAutoRunUpdate(sprinter, autoRunState, flag, physicalMoveAxisRaw);
return;
}
if (autoRunState.waitingForVerticalRelease)
{
if (Mathf.Abs(physicalMoveAxisRaw) <= 0.2f)
{
autoRunState.waitingForVerticalRelease = false;
}
}
else if (Mathf.Abs(physicalMoveAxisRaw) >= 0.87f)
{
autoRunState.StopAutoRun(flag, physicalMoveAxisRaw);
}
FinishAutoRunUpdate(sprinter, autoRunState, flag, physicalMoveAxisRaw);
}
private static void FinishAutoRunUpdate(PlayerSprinter sprinter, AutoRunState state, bool hasPhysicalMoveInput, float rawMoveY)
{
state.UpdateMoveAxis(rawMoveY, Time.deltaTime);
if (state.isActive)
{
sprinter.isSprinting = true;
}
else
{
KeepSprintingWhileMoving(sprinter, state, hasPhysicalMoveInput);
}
SetAutoRunHudVisible(state.isActive);
}
private static float GetPhysicalMoveAxisRaw(Player inputPlayer, int actionId)
{
return inputPlayer.GetAxisRaw(actionId);
}
private static bool HasPhysicalMoveInput(float rawMoveX, float rawMoveY)
{
return Mathf.Abs(rawMoveX) > 0.2f || Mathf.Abs(rawMoveY) > 0.2f;
}
private static void KeepSprintingWhileMoving(PlayerSprinter sprinter, AutoRunState state, bool hasPhysicalMoveInput)
{
if (state.keepSprintingWhileMoving)
{
if (hasPhysicalMoveInput || state.isControllingMoveAxis)
{
sprinter.isSprinting = true;
}
else
{
state.keepSprintingWhileMoving = false;
}
}
}
private static void SetAutoRunHudVisible(bool isVisible)
{
if (!isVisible)
{
if ((Object)(object)autoRunHud != (Object)null && autoRunHud.activeSelf)
{
autoRunHud.SetActive(false);
}
return;
}
if ((Object)(object)autoRunHud == (Object)null)
{
CreateAutoRunHud();
}
if ((Object)(object)autoRunHud != (Object)null && !autoRunHud.activeSelf)
{
autoRunHud.SetActive(true);
}
}
private static void CreateAutoRunHud()
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_010e: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
WorldMenuManager instance = WorldMenuManager.instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
TeachingHud teachingHud = instance.teachingHud;
obj = ((teachingHud != null) ? teachingHud.localizedText : null);
}
LocalizedText val = (LocalizedText)obj;
Transform val2 = ((instance != null) ? instance.hideableHud : null);
if (val != null && val2 != null)
{
LocalizedText val3 = Object.Instantiate<LocalizedText>(val, val2);
val3.noGlyphs = true;
TMP_Text textElement = val3.textElement;
if (textElement != null)
{
Color color = ((Graphic)textElement).color;
color.a = 1f;
((Graphic)textElement).color = color;
}
CanvasGroup component = ((Component)val3).GetComponent<CanvasGroup>();
if (component != null)
{
component.alpha = 1f;
}
RectTransform component2 = ((Component)val3).GetComponent<RectTransform>();
if (component2 != null)
{
component2.anchorMin = new Vector2(0f, 1f);
component2.anchorMax = new Vector2(0f, 1f);
component2.pivot = new Vector2(0f, 1f);
component2.anchoredPosition = new Vector2(28f, -28f);
component2.sizeDelta = new Vector2(250f, 42f);
}
autoRunHud = ((Component)val3).gameObject;
autoRunHudText = val3;
autoRunHudLanguage = null;
LocalizationManager instance2 = LocalizationManager.instance;
SetAutoRunHudText((LocalizationLanguage)((instance2 == null) ? 1 : ((int)instance2.currentLanguage)));
}
}
private static void SetAutoRunHudText(LocalizationLanguage language)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
if (autoRunHud != null && autoRunHudText != null && autoRunHudLanguage != (LocalizationLanguage?)language)
{
autoRunHudText.ChangeValue(GetAutoRunHudText(language));
autoRunHudLanguage = language;
}
}
private static string GetAutoRunHudText(LocalizationLanguage language)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Invalid comparison between Unknown and I4
if (1 == 0)
{
}
string result = (((int)language == 6) ? "自动奔跑" : (((int)language != 15) ? "AUTO RUN" : "自動奔跑"));
if (1 == 0)
{
}
return result;
}
private static bool ShouldOverrideAutoRunMoveAxis(Player inputPlayer, int actionId)
{
int result;
if (actionId == autoRunMoveYAction)
{
AutoRunState obj = autoRunState;
if (obj != null && obj.isControllingMoveAxis)
{
result = ((autoRunState.inputPlayer == inputPlayer) ? 1 : 0);
goto IL_002c;
}
}
result = 0;
goto IL_002c;
IL_002c:
return (byte)result != 0;
}
private static void OverrideAutoRunMoveAxis(ref float value)
{
autoRunState.RecordNativeMoveAxis(value);
value = autoRunState.virtualMoveY;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
